text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Погружение в разработку на Ethereum. Часть 3: приложение для пользователя
В предыдущих статьях ([часть 1](https://habrahabr.ru/post/336132/) и [часть 2](https://habrahabr.ru/post/336770/)) мы описали как можно пользоваться децентрализованными приложениями на смарт-контрактах, если вы сами не против быть нодом. Но чем меньше пользователя заставляют совершать дополнительные действия — тем лучше. Для работы со смарт контрактами необходимо подписывать транзакции приватным ключом, поэтому совсем без дополнительный действий, к сожалению, не обойтись. В этой статье мы рассмотрим два подхода: первый — полноценное децентрализованное приложение (DApp) на javascript с использованием библиотеки Web3 и плагина MetaMask, второй — аналогичное приложение, но использующее Ruby on Rails API и гем Ethereum.rb для доступа к блокчейну.
Для демонстрации работы настоящего DApp рассмотрим приложение, вдохновленное [официальным примером](https://www.ethereum.org/dao). Вместо Democracy с голосованием и выполнением произвольных транзакций сделаем упрощенный контракт Charity, в котором кто угодно создает предложение по распределению денег (эфира), участники голосуют, и после истечения дедлайна предложение либо выполняется, либо нет, в зависимости от результата голосования.
Логика смарт контракта в данном случае не очень важна, наша цель — продемонстрировать варианты взаимодействия пользователя с блокчейном.
Рассмотрим какие средства мы будем использовать чуть подробнее а после перейдем непосредственно к приложению.
Используемые средства
---------------------
#### 1. MetaMask
Это такой плагин для браузера Chrome, разработчики пишут, что планируют и для Firefox, но пока только хром. Скачать можно [здесь](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn). Плагин делает две вещи:
* Обеспечивает подключение к нужной Ethereum-сети через свой удаленный узел, благодаря этому пользователю не требуется разворачивать узел у себя.
* Позволяет создавать новые или импортировать существующие аккаунты для работы с блокчейном. Это дает возможность подписывать транзакции приватным ключом, который хранится локально у пользователя.
Подробнее о том как пользоваться плагином можно прочитать на [официальной странице](https://metamask.io/) или **под спойлером**В плагине можно подключаться к реальной и тестовым сетям, нажав на название сети сверху.
При необходимости можно импортировать существующий ключ, но удобнее просто создать новый.
Если вы хотите импортировать ключ, созданный в Geth или Mist — при импорте выбирайте JSON File и находите файл с нужным адресом в директориях ~/.ethereum/<сеть>/keystore. Стоит отметить, что по крайней мере на Ubuntu на момент публикации статьи есть баг с открытием JSON файла: после выбора файла окно MetaMask закрывается и никакой ключ не импортируется. В этом случае попробуйте открыть MetaMask в отдельной вкладке, используя адрес расширения chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/popup.html
Кстати, выбрав тестовую сеть и нажав BUY можно получить ссылки на ресурсы, раздающие тестовый эфир. Даже для Ropsten (достаточно нажать request 1 ether from faucet):
#### 2. Использование библиотеки Web3.js с плагином MetaMask
Web3.js — это JavaScript библиотека, та же, которую мы использовали в Geth в [предыдущей статье](https://habrahabr.ru/post/336770/). MetaMask встраивает Web3.js в каждую открытую страницу, поэтому можно протестировать простые команды непосредственно в javascript консоли в Chrome Developer Tools. Важно отметить, на момент написания этой статьи, актуальная версия Web3.js — 0.20.1. Документация для версии 0.x.x доступна по [ссылке](https://github.com/ethereum/wiki/wiki/JavaScript-API), не путайте с документацией для версии 1.0 ([ссылка](https://web3js.readthedocs.io/en/1.0/)).
Выполним две команды, одну на получение данных, например баланса аккаунта, вторую на изменение, например задание строки в смарт контракте StringHolder из [предыдущей статьи](https://habrahabr.ru/post/336770/). Предварительно не забудьте создать аккаунт в MetaMask, подключиться к нужной сети (в данном случае Ropsten Test Network) и зайти в консоль Developer Tools.
```
> web3.eth.getBalance(web3.eth.accounts[0], function(error, result) { console.log(web3.fromWei(result.toNumber())); } )
```
Не забывайте при вызове методов контракта передавать коллбэк функцию в качестве последнего аргумента. Можно так:
```
> web3.eth.getBalance(web3.eth.accounts[0], console.log)
null
e {s: 1, e: 18, c: Array(2)}
c:(2) [78950, 84540000000000]
e:18
s:1
__proto__:Object
```
Web3.js использует библиотеку [BigNumber](https://github.com/MikeMcl/bignumber.js) для числовых значений. В примере выше ответ выведен без преобразования.
Команды чтения выполняются сразу, а если вы захотите выполнить функцию, изменяющую данные в смарт контракте (не помеченную как `constant`), то MetaMask выдаст окно подписи транзакции. Продемонстрируем это, открыв контракт StringHolder из [прошлой статьи](https://habrahabr.ru/post/336770/) и вызвав в нем метод задания строки:
```
> 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)
> stringHolder.getString(console.log)
null "Hello Dolly!!! 22"
> stringHolder.setString("Hello from the other side!", console.log)
```
После вызова метода setString выдается окно с запросом подтвердить транзакцию и информацией по предположительным затратам газа и эфира. Нажмите Submit. В консоли увидите хеш транзакции.
Через некоторое время проверим, что строка изменилась:
```
> stringHolder.setString("Hello from the other side!", console.log)
"0x4252c00ff25b690846ec8ad3b4266047a75a1708153bcac24066da9cb01e6db5"
> stringHolder.getString(console.log)
null "Hello from the other side!"
```
Все работает как должно.
#### 3. Ethereum.rb
Это библиотека для работы с блокчейном Ethereum из Ruby ([ссылка на github](https://github.com/EthWorks/ethereum.rb)) — на данный момент поддерживается наиболее активно.
Попробуем открыть контракт StringHolder из irb консоли:
```
> require “ethereum.rb”
> 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" } ]'
> address = "0x65cA73D13a2cc1dB6B92fd04eb4EBE4cEB70c5eC"
> contract = Ethereum::Contract.create(name: "StringHolder", address: address, abi: abi)
> contract.call.get_string()
“Hello from the other side!”
```
*Заметьте, кэмел-кейс (getString) автоматически преобразовался в снейк-кейс (get\_string)*
Особенность вызова методов здесь в том, что через `call` вызываются только геттеры, где нужно просто получить данные. Для выполнения транзакций будет нужен `transact_and_wait` для синхронного вызова либо `transact` для асинхронного вызова.
Попробуем вызвать функцию `set_string`, для которой будет создаваться транзакция. Есть два способа: unlockAccount (deprecated) и sign transaction (об этом чуть позже).
```
> Ethereum::IpcClient.new.personal_unlock_account(Ethereum::IpcClient.new.eth_coinbase["result"], "<пароль>")
```
Необходимо назначить от кого посылается транзакция (того же, кого мы сейчас разблокировали):
```
> contract.sender = Ethereum::IpcClient.new.eth_coinbase["result"]
```
Потом можно вызывать сеттер вместо `call` подставив либо `transact_and_wait`, либо `transact`:
```
> contract.transact_and_wait.set_string(“Hello darkness, my old friend”)
```
Дожидаемся окончания, вызываем
```
> contract.call.get_string()
```
Видим наши изменения — все работает.
Что должен делать наш DApp
--------------------------
Сформулируем задачу. У нас должен быть контракт, представляющий собой благотворительную организацию со счетом. В этой организации могут быть зарегистрированы пользователи, которые могут выступать и в качестве получателей пожертвований и в качестве голосующих за предложения. Нужен способ создать предложение о перечислении денег (эфира) со счета организации на один из зарегистрировавшихся аккаунтов. Чтобы не было искушения забрать за раз весь эфир введем ограничение — предложить можно не более 1 эфира. Далее идет голосование (можно голосовать “за” или “против”), которое нельзя завершать до определенного дедлайна (5 минут с момента создания предложения). После дедлайна голоса продолжают приниматься, но должна быть возможность завершить голосование, и если оно завершилось с бо́льшим количеством “за” чем “против” — перечислять эфир со счета организации на счет получателя. Если больше голосов “против” — ничего не делать.
В целом схема приложения такая:
Два js модуля — Blockchain.js и BlockchainApi.js — отвечают за работу с блокчейном. Они делают одно и тоже, только первый работает c Web3.js и через ноду MetaMask напрямую обращается к блокчейну, второй — делает ajax запросы к Rails API, где уже происходит взаимодействие с блокчейном через гем ethereum.rb. Само клиентское приложение написано на React и не зависит от того, какой js модуль из двух используется.
Основной контракт Charity
-------------------------
Контракт в виде одного единственного файла, поэтому не будем пользоваться специальными средствами для деплоя, сделать это можно любым способом, хоть [через Mist](https://habrahabr.ru/post/336132/), хоть [используя командную строку Geth](https://habrahabr.ru/post/336770/). Можете использовать наш код [отсюда](https://github.com/rubyruby/charity-contracts). В целом его схему можно изобразить так:
Рассмотрим код контракта Charity.sol по логическим блокам. Сначала идет описание всех нужных нам переменных:
```
uint public debatingPeriodInMinutes; // время на голосование
Proposal[] public proposals; // массив предложений пожертвований, структура описана далее
uint public numProposals; // количество элементов в массиве proposals
uint public numMembers; //количество элементов в массиве members
mapping (address => uint) public memberId; // маппинг адреса аккаунта на индекс в массиве members
address[] public members; // массив зарегистрированных аккаунтов
```
Маппинг позволяет по адресу пользователя получить его индекс в массиве. Если пользователя с таким адресом не существует, то будет возвращен индекс 0. На этом будет основана далее функция, определяющая, зарегистрирован ли пользователь с данным адресом. Но это вносит требование для массива: пользователи должны храниться в массиве начиная с индекса 1. Код, отвечающий за эту логику будет рассмотрен дальше. А пока идет структура для хранения предложения.
```
struct Proposal {
address recipient; // получатель
uint amount; // размер пожертвования
string description; // описание пожертвования
uint votingDeadline; // дедлайн
bool executed; // флаг, что пожертвование уже совершено или отклонено
bool proposalPassed; // флаг, что голосование одобрило пожертвование
uint numberOfVotes; // количество голосов
int currentResult; // сумма голосов, “за“ = +1, “против” = -1
Vote[] votes; // список голосов с адресом каждого проголосовавшего и значением голоса, структура описана далее
mapping (address => bool) voted; // маппинг для быстрой проверки, проголосовал ли аккаунт с таким-то адресом
}
```
Структура голосов, складывается в массив для каждого предложения
```
struct Vote {
bool inSupport; // значение голоса
address voter; // и адрес аккаунта проголосовавшего
}
```
Рассмотрим модификатор, который позволит нам контролировать, что выполнение методов, к которым он будет добавлен, возможно только если пользователь зарегистрирован. Код проверки, как уже было сказано, основан на том, что несуществующие элементы маппинга дают индекс `0`, а пользователей будем хранить начиная с индекса `1`:
```
modifier onlyMembers {
require (memberId[msg.sender] != 0); // методы будут выполнять такой код проверки
_; // код модифицируемого метода подставляется вместо знака подчеркивания
}
```
`msg` — это структура, по которой можно получить информацию о вызывающем. В данном случае `msg.sender` — это адрес аккаунта, который вызвал метод с этим модификатором.
Опишем конструктор нашего контракта, который будет выполняться при деплое. Все, что требуется задавать — время, которое выделяется для голосования за каждое предложение. Кроме этого увеличиваем размер массива members, потому что добавлять пользователей будем исходя из размера, а нулевой элемент остается зарезервированным.
```
function Charity( uint _minutesForDebate ) payable { // payable означает, что вместе с транзакцией можно отправить эфир, этот эфир зачислится на счет контракта
debatingPeriodInMinutes = _minutesForDebate;
members.length++;
}
```
Функция для добавления пользователя:
```
function addMember(address _targetMember) {
if (memberId[_targetMember] == 0) { // 0 является признаком, что пользователь не зарегистрирован
uint id;
memberId[_targetMember] = members.length; // индексом будет номер еще не добавленного элемента, сохраняем его в маппинге
id = members.length++; // сохраняем индекс и увеличиваем размер массива
members[id] = _targetMember; // сохраняем адрес в массиве
}
}
```
Заметьте функцию `require` — она пришла на замену `throw` в более старых версиях solidity. В `require` передается `true` или `false`, если это `false` — то срабатывает обработчик аналогичный `throw` — откатывается вся транзакция.
Чтобы можно было проверить, находится ли адрес в списке пользователей используем такую функцию:
```
function isMember( address _targetMember ) constant returns ( bool ) {
return ( memberId[_targetMember] != 0 );
}
```
Следующая функция — для создания предложения, принимает адрес получателя пожертвования, количество эфира в wei и строку с описанием. К этой функции применяется модификатор onlyMembers, это значит до выполнения всего кода произойдет проверка, что вызывающий аккаунт зарегистрирован. Здесь вы увидите такие преобразования как `1 ether` и `1 minutes`. Полный список таких суффиксов можете посмотреть [здесь](http://solidity.readthedocs.io/en/develop/units-and-global-variables.html), они сделаны для удобства и могут применяться только к значениям, но не к переменным. Но чтобы применить к переменной достаточно просто добавить 1 к суффиксу, что и сделано в нашем случае для преобразования в секунды.
```
function newProposal(
address _beneficiary, // получатель пожертвования
uint _weiAmount, // размер пожертвования в wei
string _description // произвольная строка
)
onlyMembers
returns (uint proposalID)
{
require( _weiAmount <= (1 ether) ); // ограничим пожертвование в 1 эфира
proposalID = proposals.length++; // увеличение размера массива на 1
Proposal storage p = proposals[proposalID]; // далее идет присвоение элементу значений
p.recipient = _beneficiary;
p.amount = _weiAmount;
p.description = _description;
p.votingDeadline = now + debatingPeriodInMinutes * 1 minutes; // расчет дедлайна по текущему времени и времени на голосование
p.executed = false; // обнуление флагов завершенности транзакции
p.proposalPassed = false;
p.numberOfVotes = 0;
numProposals = proposalID + 1; // сохранение размера массива
return proposalID;
}
```
Заметьте здесь ключевое слово `now` — это текущее время, но не на момент вызова транзакции, а на момент создания блока. Поэтому дедлайн будет отсчитываться с момента, когда предложение уже будет создано на блокчейне.
Несмотря на то, что `proposals` у нас `public`, получать таким образом можно только простейшие поля в виде массива. То есть вызвав в контракте метод например `proposals(1)`, мы получим предложение с индексом `1` в виде массива `{ recipient, amount, description, votingDeadline, executed, proposalPassed, numberOfVotes, currentResult }`, а массивы `votes` и `voted` внутри структуры не вернутся. Но нам нужна информация о том, проголосовал ли пользователь за определенное предложение, чтобы отображать его голос или дать возможность проголосовать. И желательно сделать это в одно обращение, поэтому мы получаем эту информацию когда читаем структуру Proposal для отображения в нашем приложении с помощью специальной функции `getProposal`, которая принимает аккаунт, для которого нужен статус голоса и идентификатор предложения.
```
function getProposal( address _member, uint _proposalNumber ) constant
returns ( address, // описываем типы в возвращаемом массиве
uint,
string,
uint,
bool,
bool,
uint,
int,
int ) {
Proposal memory proposal = proposals[ _proposalNumber ]; // берем элемент для удобства
int vote = getVoted( _member, _proposalNumber ); // используем вспомогательную функцию (описана позже) для получения информации о голосе конкретного пользователя
return ( proposal.recipient,
proposal.amount,
proposal.description,
proposal.votingDeadline,
proposal.executed,
proposal.proposalPassed,
proposal.numberOfVotes,
proposal.currentResult,
vote ); // высылаем массив в соответствии с ожидаемыми типами
}
```
А это вспомогательная функция, которая ищет как проголосовал конкретный пользователь в конкретном предложении. Возвращаться будет: `0` — если пользователь не проголосовал, `1` — если пользователь проголосовал “за”, `-1` — если проголосовал “против”.
```
function getVoted(address _member, uint _proposalNumber) constant returns(int)
{
Proposal storage p = proposals[_proposalNumber];
int result = 0;
int true_int = 1;
int false_int = -1; // определяем возвращаемые значения
for (uint i = 0; i < p.numberOfVotes; i++)
{
if (p.votes[i].voter == _member) // ищем нужного пользователя перебором
{
result = p.votes[i].inSupport ? true_int : false_int;
break; // если находим выходим и возвращаем значение
}
}
return result;
}
```
Голосование: для предложения с конкретным номером отдаем голос true (за) или false (против).
```
function vote(
uint _proposalNumber, // номер предложения, за которое отдается голос
bool _supportsProposal // голос
)
onlyMembers
returns (uint voteID)
{
Proposal storage p = proposals[_proposalNumber]; // для удобства возьмем нужный элемент из массива
require (p.voted[msg.sender] != true); // не продолжать если пользователь уже голосовал
p.voted[msg.sender] = true; // отметить пользователя как проголосовавшего
p.numberOfVotes++; // увеличить количество проголосовавших для предложения
if (_supportsProposal) { // если проголосовали “за”
p.currentResult++; // увеличить результат на 1
} else { // если против
p.currentResult--; // уменьшить результат на 1
}
voteID = p.votes.length++; // добавление нового голоса в массив голосов
p.votes[voteID] = Vote({inSupport: _supportsProposal, voter: msg.sender}); // инициализация структуры
return p.numberOfVotes;
}
```
И последняя функция `executeProposal` служит для завершения голосования и отправки (или неотправки) эфира на адрес получателя.
```
function executeProposal(uint _proposalNumber) { // выполнить предложение с таким номером
Proposal storage p = proposals[_proposalNumber];
require ( !(now < p.votingDeadline || p.executed) ); // предложение должно 1) пройти дедлайн, 2) не быть уже выполненным
p.executed = true; // помечаем как выполненное
if (p.currentResult > 0) { // если большинство проголосовало “за”
require ( p.recipient.send(p.amount) ); // отправить эфир получателю
p.proposalPassed = true; // пометить, что предложение одобрено
} else { // если “за” проголосовало не большинство
p.proposalPassed = false; // пометить, что предложение отклонено и ничего не отправлять
}
}
```
В конце присутствует пустая функция с модификатором payable.
```
function () payable {}
```
Это нужно для того, чтобы на адрес контракта можно было присылать эфир. Вообще пустая функция — это функция, которая принимает и обрабатывает все сообщения, которые не являются вызовом функций. Все, что нам требуется — это сделать ее payable, тогда отправленный газ просто зачислится на контракт без каких-либо дополнительных действий. Но заметьте, что на других функциях этого модификатора нет, поэтому в нашем случае нельзя отправлять эфир например с вызовом `addMember`.
Вариант приложения с использованием Web3.js
-------------------------------------------
Основной сценарий приложения:
1. Пользователь подключается к сети Ropsten через MetaMask
2. Если на аккаунте нет эфира, будет невозможно выполнить ни одну транзакцию. Мы добавили функцию получения эфира, которая становится доступна при балансе аккаунта меньше 0.1 эфира. Реализовано это через сторонний сервис, на который делается ajax запрос с адресом, на который нужно перевести эфир.
3. Основные действия со смарт контрактом доступны только после того, как пользователь станет участником организации. Для этого вызывается метод addMember в смарт контракте.
4. Участник организации может создать Предложение о переводе средств (далее Proposal), или проголосовать за уже существующее.
5. Когда истекает время для Proposal (время создания + 5 минут), появляется возможность его завершить, в результате чего, в зависимости от распределения голосов, эфир будет переведен на указанный адрес, или нет.
Демонстрация приложения доступна по [ссылке](https://rubyruby.github.io/charity/) — MetaMask версия.
Исходный код [здесь](https://github.com/rubyruby/charity).
Еще раз обращаем ваше внимание на то, что текущая версия Web3.js — 0.20.1. Но уже готовится к релизу версия 1.0, в которой изменения достаточно существенны. Как мы говорили выше, MetaMask встраивает web3 в страницу, и его можно сразу использовать. Но учитывая то, что библиотека активно развивается, а нам нужно гарантировать работоспособность приложения для пользователя, необходимо использовать свою залоченную версию, и переопределять объект web3, который встраивает MetaMask. Мы делаем это [здесь](https://github.com/rubyruby/charity/blob/master/src/components/app-container.jsx#L82-L84) в следующем методе:
```
initializeWeb3() {
if (typeof web3 !== 'undefined') { // если MetaMask заинжектил библиотеку
const defaultAccount = web3.eth.defaultAccount; // сохраняем привязанный аккаунт
window.web3 = new Web3(web3.currentProvider); // инициализируем свою библиотеку
window.web3.eth.defaultAccount = defaultAccount; // возвращаем привязанный аккаунт
} }
```
Делать это нужно после события `window.onload`.
Одна неочевидная проблема, которая решается в этом коде — если просто сделать `window.web3 = new Web3(web3.currentProvider)` как предлагается в официальной документации, то не подхватывается аккаунт по умолчанию.
Еще в MetaMask, как уже писалось, можно выбирать сеть из списка. У нас используются адреса контрактов в сети Ropsten, если попытаться подключаться по этим адресам в других сетях — результат будет непредсказуем. Поэтому прежде чем предоставлять доступ к приложению, нужно проверить в той ли сети находится пользователь. Получить идентификатор сети можно с помощью команды:
```
web3.version.getNetwork(function (err, netId) {});
```
Мы делаем эту проверку [здесь](https://github.com/rubyruby/charity/blob/master/src/components/app-container.jsx#L92-L94) и сравниваем результат с id для сети Ropsten — это 3.
Список id всех сетей можно увидеть например [здесь](https://github.com/ethereum/wiki/wiki/JSON-RPC#net_version) в описании net\_version.
Вся логика работы с блокчейном находится в файле [blockchain.js](https://github.com/rubyruby/charity/blob/master/src/utils/blockchain.js).
Здесь есть два типа функций — функции для получения данных из блокчейна и функции изменяющие данные в блокчейне. Большинство методов из web3.js выполняются асинхронно и принимают callback в качестве последнего параметра. Поскольку зачастую приходится вызывать несколько методов для получения данных, и вызов некоторых из них зависит от результата работы других — удобно использовать промисы. В версии 1.0 web3.js асинхронные методы возвращают промисы по умолчанию.
Приведем один пример получения информации из блокчейна:
Функция `getCurrentAccountInfo` возвращает адрес текущего аккаунта, баланс и флаг того, является ли данный аккаунт участником организации.
```
Blockchain.prototype.getCurrentAccountInfo = function() {
const address = this.address;
if (address == undefined) {
return Promise.resolve({});
}
const balancePromise = new Promise(function(resolve, reject) {
web3.eth.getBalance(address, function(err, res) {
err ? reject(err) : resolve(web3.fromWei(res).toNumber());
});
});
const authorizedPromise = new Promise(function(resolve, reject) {
this.contractInstance.isMember(address, function(err, res) {
err ? reject(err) : resolve(res);
});
}.bind(this));
return new Promise(function(resolve, reject) {
Promise.all([balancePromise, authorizedPromise]).then(function(data) {
resolve({
address: address,
balance: data[0],
isMember: data[1]
});
});
});
};
```
Рассмотрим теперь функцию изменения данных в блокчейне, например функция добавления участника организации.
```
Blockchain.prototype.becomeMember = function() {
return new Promise(function(resolve, reject) {
this.contractInstance.addMember(this.address, function(err, res) {
err ? reject(err) : resolve(res);
});
}.bind(this));
};
```
Как видим, синтаксис ничем не отличается от предыдущего примера, вот только выполнение этой функции повлечет создание транзакции, для изменения данных в блокчейне.
При вызове любой функции смарт контракта, в результате которой создается транзакция, MetaMask предлагает пользователю подтвердить эту транзакцию или отклонить ее. Если пользователь подтверждает транзакцию, то функция возвращает хеш транзакции.
Один неочевидный момент — это как узнать выполнилась транзакция успешно или нет.
Определить статус транзакции можно на основании кол-ва газа, которое было использовано. Если использовано максимально доступное кол-во газа, то либо в ходе выполнения возникла ошибка, либо газа не хватило для выполнения транзакции. Проверку статуса мы делаем следующим образом.
```
Blockchain.prototype.checkTransaction = function(transaction) {
const txPromise = new Promise(function(resolve, reject) {
web3.eth.getTransaction(transaction.transactionHash, function(err, res) {
err ? reject(err) : resolve(res);
});
});
const txReceiptPromise = new Promise(function(resolve, reject) {
web3.eth.getTransactionReceipt(transaction.transactionHash, function(err, res) {
err ? reject(err) : resolve(res);
});
});
return new Promise(function(resolve, reject) {
Promise.all([txPromise, txReceiptPromise]).then(function(res) {
const tx = res[0];
const txReceipt = res[1];
const succeeded = txReceipt && txReceipt.blockNumber && txReceipt.gasUsed < tx.gas;
const failed = txReceipt && txReceipt.blockNumber && txReceipt.gasUsed == tx.gas;
let state = transactionStates.STATE_PENDING;
if (succeeded) {
state = transactionStates.STATE_SUCCEEDED;
} else if (failed) {
state = transactionStates.STATE_FAILED;
}
resolve(state);
});
});
};
```
При создании новой транзакции, мы добавляем ее в localStorage и периодически опрашиваем ее статус, до тех пор пока не узнаем что она выполнилась успешно или нет. Логика мониторинга транзакций находится в файле — [transactions-storage.js](https://github.com/rubyruby/charity/blob/master/src/utils/transactions-storage.js).
Вариант приложения с использованием Ruby on Rails и гема ethereum.rb
--------------------------------------------------------------------
По-настоящему децентрализованное приложение выглядит как вариант, описанный выше. Пользователь сам подписывает транзакции при помощи ключа, который хранится у него же. Но помимо случаев, когда пользователь приложения непосредственно взаимодействует с блокчейном, бывают случаи, когда требуется доступ к блокчейну на стороне бекенда. Возможно это какое-то внутреннее приложение и действия с блокчейном выполняются от аккаунтов, которые вы контролируете и ключи для которых вы можете хранить на сервере. Возможно логика вашего приложения на смарт контрактах подразумевает реагирование на определенные события от вашего централизованного сервера. В данном случае, помимо web3.js, который вы конечно тоже можете использовать на сервере, было бы неплохо иметь инструмент для привычного вам стека разработки. Для нас таким является Ruby on Rails, поэтому мы решили попробовать библиотеку ethereum.rb, которая должна решать туже задачу, что и web3.js.
Демонстрация приложения доступна по [ссылке](https://rubyruby.github.io/charity/) — Rails API версия.
Исходный код [здесь](https://github.com/rubyruby/charity-api).
Для демонстрации работы с ethereum.rb, мы сделали аналогичный набор функций, описанным в blockchain.js. Код работы с блокчейном можно посмотреть [здесь](https://github.com/rubyruby/charity-api/blob/master/app/blockchain/blockchain.rb), а мы опишем основные моменты и, возможно, отличия.
Первое — теперь у нас нет доступа к аккаунту пользователя, поэтому нам нужно сделать некоторый процесс авторизации и создавать для каждого пользователя аккаунт в блокчейне. Процесс авторизации в данном примере максимально упрощен, мы просто генерируем токен, который сохраняется в LocalStorage браузера, и по которому происходит авторизация запросов к API.
В целом схема работы с аккаунтами такая:
1. Пользователь нажимает кнопку Create Account, на сервере в базе данных создается пользователь с уникальным токеном для авторизации, создается аккаунт для подключения к блокчейну и приватный ключ для аккаунта сохраняется в базе данных, токен возвращается пользователю для дальнейшей авторизации.
2. Пользователь делает запросы к API используя auth token для авторизации.
3. Приватный ключ пользователя из БД используется для подписи транзакций.
Как и в js версии, есть два типа методов — те что берут данные из блокчейна, и те что изменяют их. Первые — достаточно простые и как они работают понятно из примера.
```
def proposals(address=nil)
count = @contract_instance.call.num_proposals
to = count - 1
from = count > PROPOSALS_LIMIT ? count - PROPOSALS_LIMIT : 0
res = (from..to).map do |idx|
proposal = if address
@contract_instance.call.get_proposal(address, idx)
else
@contract_instance.call.proposals(idx)
end
Proposal.new(proposal, idx)
end
res.sort_by(&:index).reverse
end
```
Методы, которые изменяют данные в блокчейне — создают транзакцию, которую нужно подписать приватным ключом. Для работы с приватными ключами используется [гем Eth](https://github.com/se3000/ruby-eth). Ниже демонстрируется процесс создания нового аккаунта для блокчейна и подпись транзакции приватным ключом.
```
def self.new_account
new_key = Eth::Key.new
return new_key.address.downcase, new_key.private_hex
end
def signed_transactions(private_key_hex)
key = Eth::Key.new priv: private_key_hex #создание объекта ключа из бинарного
@contract_instance.key = key # задание ключа для всех вызовов этого объекта контракта
res = yield(@contract_instance) # выполнение нужных транзакций
@contract_instance.key = nil # обнуление ключа после отправки транзакций
res
end
```
Рассмотрим метод `signed_transactions` — он принимает приватный ключ и блок кода, который мы хотим выполнить используя данный ключ.
В базе данных ключ хранится в бинарном виде, из которого создается объект ключа при помощи гема Eth. Далее этот ключ присваивается в поле `key` экземпляра контракта. Подпись транзакций происходит автоматически в геме ethereum.rb если в поле `key` контракта задан ключ. После вызова нужного метода, или нескольких методов, обнуляем ключ, чтобы случайно не отправить еще транзакций от этого же аккаунта.
Для примера использования `signed_transactions` рассмотрим метод завершения Proposal, который вызывает метод `executeProposal` в смарт контракте:
```
def finish_proposal(proposal_index, options={})
tx = signed_transactions(options[:private_key]) do |contract_instance|
contract_instance.transact.execute_proposal(proposal_index)
end
tx.id
end
```
Метод возвращает хеш транзакции. Логика проверки статуса транзакции аналогична той, что мы использовали в js версии.
```
def transaction_status(tx_hash)
tx = @client.eth_get_transaction_by_hash(tx_hash)['result']
tx_receipt = @client.eth_get_transaction_receipt(tx_hash)['result']
if tx_receipt
block_number = tx_receipt['blockNumber']
gas_used = tx_receipt['gasUsed'].to_i(16)
gas = tx['gas'].to_i(16)
{
succeeded: block_number && gas_used < gas,
failed: block_number && gas_used == gas
}
end
end
```
Смотрите как работает
---------------------
Демонстрация приложения доступна по [ссылке](https://rubyruby.github.io/charity/).
Мы перечислили на счет контракта некоторое кол-во эфира, если он закончится и у вас есть лишний тестовый эфир — можете задонатить сюда `0xe79d8738f0769ec69f09cef4cd497c9cc477733e` — сеть Ropsten.
Что в итоге?
------------
На наш взгляд оба варианта имеют право на жизнь, но в различных случаях. В данном конкретном примере версия с Ruby немного притянута за уши и версия использующая MetaMask более логична. Но, как уже было упомянуто в начале, задачей было не дать образец проекта, а показать на простой логике примеры взаимодействия с блокчейном при помощи javascript и ruby. Надеемся с этой задачей мы справились.
Следующей задачей ставим себе описание более продвинутой работы с деплоем и тестированием смарт контрактов. Ожидайте следующую статью на эту тему!
Погружение в разработку на Ethereum:
[Часть 1: введение](https://habrahabr.ru/post/336132/)
[Часть 2: Web3.js и газ](https://habrahabr.ru/post/336770/) | https://habr.com/ru/post/339080/ | null | ru | null |
# Details
How often do you get to 404 pages? Usually, they are not styled and stay default. Recently I’ve found [test.do.am](http://test.do.am/) which interactive character attracts attention and livens up the error page.
Probably, there was just a cat picture, then they thought up eyes movement and developer implemented the idea.Now user visits the page and checks out the effect. It’s cool and pleasant small feature, it catches, then user discusses it with colleagues or friends and even repeats the feature. It could be this easy, if not:
1. Center point is not being renewed when user resizes the window. Open the browser window with small width viewport and resize to full screen, the cat looks not at the cursor.
2. Center point is placed on the left eye, not in binocular center of the circle.
3. When user hovers cursor between the eyes, apples of the eyes don’t get together and don’t focus. Eyes are looking to infinity, that’s why the cat looks not at user, it looks through him.
4. Eyes movements are immediate, they need to be smooth.
5. Apples' movements happen because of margin-left / margin-top changing. It’s incorrect, find explanation below.
6. Eyes don’t move if cursor is under footer.
**What I suggest**
For a start, let’s implement flawless eyes movement.
1. Prepare markup
```
```
2. Get links to eyes’ elements
```
const cat = document.querySelector('.cat');
const eyes = cat.querySelectorAll('.cat__eye');
const eye_left = eyes[0];
const eye_right = eyes[1];
```
3. Register mousemove event listener and get cursor coordinates:
```
let mouseX;
let mouseY;
window.addEventListener('mousemove', e => {
mouseX = e.clientX;
mouseY = e.clientY;
})
```
I add mousemove listener on window object, not document body, because I need to use all screen to get mouse coordinates.
4. Movement
Since I’m going to smoothen movements, I can’t manage them in mousemove handler.
Add update method that will be fetched by requestAnimationFrame which is synchronized with browser renewal. Usually renewals happen 60 times per second, therefore we see 60 pics per second every 16.6 ms.
If developer supposes user’s browser can’t support requestAnimationFrame, developer can use setTimeout fallback or ready-made [polyfill](https://gist.github.com/paulirish/1579671)
```
window.requestAnimationFrame = (function () {
return window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
function (callback) {
window.setTimeout(callback, 1000 / 60);
};
})();
```
In order to renew or stable fetching of update in time, I register started variable
```
let started = false;
let mouseX;
let mouseY;
window.addEventListener('mousemove', e => {
mouseX = e.clientX;
mouseY = e.clientY;
if(!started){
started = true;
update();
}
})
function update(){
// Here comes eyes movement magic
requestAnimationFrame(update);
}
```
This way I got constantly fetching update method and cursor coordinates. Then I need to get values of apples movements inside the eyes.
I try to move both eyes as single element
```
let dx = mouseX - eyesCenterX;
let dy = mouseY - eyesCenterY;
let angle = Math.atan2(dy, dx);
let distance = Math.sqrt(dx * dx + dy * dy);
distance = distance > EYES_RADIUS ? EYES_RADIUS : distance;
let x = Math.cos(angle) * distance;
let y = Math.sin(angle) * distance;
eye_left.style.transform = 'translate(' + x + 'px,' + y + 'px)';
eye_right.style.transform = 'translate(' + x + 'px,' + y + 'px)';
```
Pretty simple: find dx and dy, which are coordinate difference between eyes center and mouse, find angle from center to cursor, using Math.cos and Math.sin methods get movement value for horizontal and vertical. Use [ternary operator](https://en.wikipedia.org/wiki/%3F) and limit eyes movement area.
Y value is given first for Math.atan2 method, then x value. As a result user notices unnaturalness of eyes motions and no focusing.
Make each eyes move and watch without reference to each other.
```
// left eye
let left_dx = mouseX - eyesCenterX + 48;
let left_dy = mouseY - eyesCenterY;
let left_angle = Math.atan2(left_dy, left_dx);
let left_distance = Math.sqrt(left_dx * left_dx + left_dy * left_dy);
left_distance = left_distance > EYES_RADIUS ? EYES_RADIUS : left_distance;
let left_x = Math.cos(left_angle) * left_distance;
let left_y = Math.sin(left_angle) * left_distance;
eye_left.style.transform = 'translate(' + left_x + 'px,' + left_y + 'px)';
// right eye
let right_dx = mouseX - eyesCenterX - 48;
let right_dy = mouseY - eyesCenterY;
let right_angle = Math.atan2(right_dy, right_dx);
let right_distance = Math.sqrt(right_dx * right_dx + right_dy * right_dy);
right_distance = right_distance > EYES_RADIUS ? EYES_RADIUS : right_distance;
let right_x = Math.cos(right_angle) * right_distance;
let right_y = Math.sin(right_angle) * right_distance;
eye_right.style.transform = 'translate(' + right_x + 'px,' + right_y + 'px)';
```
Interesting but worse than previous result, eyes move up and down independently. So I used first demo as a movement mechanic basic and make apples of the eyes get together when cursor is about the center of character.
I’ll not describe entire code, please find hereby a result:
By trial and error I’ve matched needed parameters for eyes movement and focusing. So now I need smoothing.
**Smoothing**
Link [TweenMax library](https://greensock.com) and code something like this?
```
TweenMax.to( eye, 0.15, {x: x, y: y});
```
Linking entire lib for simple task does not make sense, therefore, I make smoothing from scratch.
Put the case that there is only one eye element on the page and its displacement area is not limited at all. To smoothen mouse coordinates values, I use this mechanics:
```
const SMOOTHING = 10;
x += (needX - x) / SMOOTHING;
y += (needY - y) / SMOOTHING;
eye.style.transform = 'translate3d(' + x + 'px,' + y + 'px,0)';
```
I use translate3d to separate eyes to another rendering stream and speed them up.
The trick is that every 16.6ms (60 pics per second) variable x and y tend to needed values. Each renew closes value to its needed one for 1/10 of difference.
```
let x = 0;
let needX = 100;
let SMOOTHING = 2;
function update(){
x += (needX - x) / SMOOTHING;
console.log(x);
}
```
Then every 16.6 ms renew we get simple smoothing and next x values (approx):
```
50
75
87.5
93.75
96.875
98.4375
99.21875
99.609375
100
```
A couple more unobvious tricks:
— Start this examination to optimize workload
```
if(x != needX || y != needY){
eye.style.transform = 'translate3d(' + x + 'px,' + y + 'px,0)';
}
```
But you have to equate x to needX when they get as close as eyes positions are almost the same
```
if(Math.abs(x - needX) < 0.25){
x = needX;
}
if(Math.abs(y - needY) < 0.25){
y = needY;
}
```
Otherwise x and y values will be reaching needX and needY too long; there will be no visual differences, but every screen change will affect eyes styles. Btw you can fiddle around with it yourself.
```
let x = 0;
let needX = 100;
let smoothing = 2;
function update(){
x += (needX - x) / smoothing;
if( Math.abs(x - needX) > 0.25 ){ // replace 0.25 with anything else and check number of x renewals.
window.requestAnimationFrame(update);
} else {
x = needX;
}
console.log( x.toString(10) );
}
update();
```
— If mechanics above is clear, you can create more complex effects, e.g. spring. The simplest smoothing and to cursor approximation looks like this:
```
x += (mouseX - x) / smoothing;
y += (mouseY - y) / smoothing;
```
Add smoothing a difference between needed and current coordinates values.
Sometimes approximation limitation makes sense. There is example above where value changes from 0 to 100, so in the 1st iteration value reaches “50”, it is pretty huge figure for 1 step. This mechanics kinda remind [paradox of Achilles and the tortoise](https://en.wikipedia.org/wiki/Zeno%27s_paradoxes#Achilles_and_the_tortoise)
**Winking**
Hide and show apples of eyes every 2-3 seconds. The most trivial method is «display: none;», «transform: scaleY(N)» with dynamic value of y-scale is a bit more complex.
Create 2 consts
const BLINK\_COUNTER\_LIMIT = 180; — number of renewals before start of blinking,
const BLINKED\_COUNTER\_LIMIT = 6; — number of renewals during one wink.
And 2 variables, which values will change every renewal.
```
let blinkCounter = 0;
let blinkedCounter = 0;
```
Code of winking
```
let blinkTransform = '';
blinkCounter++;
if(blinkCounter > BLINK_COUNTER_LIMIT){
blinkedCounter++
if(blinkedCounter > BLINKED_COUNTER_LIMIT){
blinkCounter = 0;
} else {
blinkTransform = ' scaleY(' + (blinkedCounter / BLINKED_COUNTER_LIMIT) + ')';
}
} else {
blinkedCounter = 0;
}
```
BlinkTransform is stroke variable that has empty value between winking and following ones during winking
```
' scaleY(0.17)'
' scaleY(0.33)'
' scaleY(0.50)'
' scaleY(0.67)'
' scaleY(0.83)'
' scaleY(1.00)'
```
All calculations give variable blinkTransform, value of which should be added to css code of eyes position transform. Thus empty string gets added in case of 3s down time and it doesn’t effect on eyes scale, css value gets added during blinking.
```
eye_left.style.transform = 'translate(' + xLeft + 'px,' + y + 'px)' + blinkTransform;
eye_right.style.transform = 'translate(' + xRight + 'px,' + y + 'px)' + blinkTransform;
```
**Lesson of the story**
Every day we meet things that seem simple and obvious and we even don't understand that this external simplicity hides a colossal amount of questions and improvements. In my opinion devil is in the details that form entire final result. Muhammad Ali the best boxer of 20th century raised heel of rear foot in the moment of straight punch. This manoeuvre increased effective distance of blow and gave him more chances to win. It always worked.
*P.S. I have no bearing on the website and hope its owners would not take offence at my comments. For convenience I named apple of the eye = eye in code.* | https://habr.com/ru/post/443720/ | null | en | null |
# Kubernetes 1.20: обзор основных новшеств
Этой ночью, 8 декабря (по американскому времени), [состоялся](https://kubernetes.io/blog/2020/12/08/kubernetes-1-20-release-announcement/) новый релиз Kubernetes — 1.20. По традиции нашего блога, рассказываем о наиболее значимых изменениях в новой версии.
Информация, использованная для подготовки этого материала, взята из [таблицы Kubernetes enhancements tracking](https://docs.google.com/spreadsheets/u/1/d/1Ch7PIapJhwdl83HEnYvwFNz96z3vk_eHnf8heLxxgyw/edit), [CHANGELOG-1.20](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.20.md), обзора [Sysdig](https://sysdig.com/blog/whats-new-kubernetes-1-20/), а также соответствующих issues, pull requests, Kubernetes Enhancement Proposals (KEP).
Docker как deprecated
---------------------
Пожалуй, главной темой этого релиза стал отказ от Docker в kubelet, о чём широкой общественности стало известно благодаря твиту Davanum Srinivas — инженера из VMware, который и стал непосредственным автором самого изменения:
Если говорить о технической сути произошедшего и очень кратко, то, пожалуй, достаточно демонстрации таких двух схем *(заимствованы из [публикации Tariq Islam](https://www.tariqislam.com/posts/kubernetes-docker-dep/) — Cloud Solutions Engineer из Google)*.
Запуск контейнеров в Kubernetes до сих пор выглядел так:
Но мир не стоит на месте, а уж cloud native-мир со всеми его контейнерами, механизмами взаимодействия с ними и стандартами — подавно. Поэтому длинная цепочка упрощается до следующей:
Подробнее останавливаться на этом событии не будем, поскольку уже переводили для своего блога официальное заявление проекта Kubernetes по этому поводу: «[Не паникуйте: Kubernetes и Docker](https://habr.com/ru/company/flant/blog/531120/)». Кроме того, в интернете легко найти другие многочисленные материалы по теме. Среди них:
* [развёрнутый комментарий от Tim Hockin](https://www.reddit.com/r/kubernetes/comments/k5ev3e/kubernetes_is_deprecating_docker_support/geen7uz/) (одного из самых известных разработчиков Kubernetes) на Reddit;
* [лаконичное пояснение от Benjamin Elder](https://github.com/kubernetes/kubernetes/pull/94624#issuecomment-737486287) (другого разработчика Kubernetes) на GitHub;
* [заявление самой Docker Inc](https://www.docker.com/blog/what-developers-need-to-know-about-docker-docker-engine-and-kubernetes-v1-20/);
* [анонс от Mirantis](https://www.mirantis.com/blog/mirantis-to-take-over-support-of-kubernetes-dockershim-2/), которая год назад [купила](https://habr.com/ru/company/flant/blog/475814/) бизнес Docker Enterprise, а теперь собирается продолжить развитие dockershim в Kubernetes своими силами.
Узлы Kubernetes (kubelets)
--------------------------
И продолжим со связанного с dockershim изменения — [повышения](https://github.com/kubernetes/enhancements/issues/2040) статуса **поддержки CRI (Container Runtime Interface) до бета-версии** ([KEP-2040](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2040-kubelet-cri)). Исполняемые среды для контейнеров на базе интерфейса CRI — [CRI-O](https://habr.com/ru/company/flant/blog/340010/) и [containerd](https://habrahabr.ru/company/flant/blog/325358/) — уже долгое время (более года) используются разными компаниями в production с текущим API, поэтому авторы данного изменения «хотят показать пользователям, что CRI API готово к production и можно не бояться переходить с dockershim, который признан deprecated». Когда же CRI планируют перевести на итоговый уровень стабильности (stable/GA), пока не сообщается.
Попутно стоит отметить, что **[поддержка](https://github.com/kubernetes/enhancements/issues/1001) cri-containerd для Windows объявлена стабильной**. *(GA для Linux-версии [была объявлена](https://habr.com/ru/company/flant/blog/414875/) более 2 лет назад.)*
Новая возможность для kubelet'ов — [**Graceful Node Shutdown**](https://github.com/kubernetes/enhancements/issues/2000) ([KEP-2000](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2000-graceful-node-shutdown)) — призвана сообщать им о завершении работы узла и вызывать корректное, «мягкое» (graceful) выключение соответствующих pod'ов. Предусматривается обработка команд `shutdown -h`, `systemctl poweroff`, физического нажатия на кнопку питания и его аналогов для виртуальных машин и облачных инстансов (например, `gcloud compute instances stop`). В реализации отслеживаются ACPI-сигналы, предусмотрено взаимодействие с systemd-logind, а в конфигурации kubelet для этого появился параметр `ShutdownGracePeriod` (по умолчанию равен 0). Текущая версия — альфа, повышение до беты ожидается в Kubernetes 1.21.
Другая новая фича в альфа-версии — **[изменяемый размер](https://github.com/kubernetes/enhancements/issues/1967) томов, хранимых в оперативной памяти** ([KEP-1967](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/1967-size-memory-backed-volumes)). Сейчас размер для томов `emptyDir`, которые хранятся в оперативной памяти (tmpfs), по умолчанию выделяется в объеме 50% памяти Linux-хоста. Однако это вызывает ряд сложностей (при активном использовании `/dev/shm` и других задач вроде AI/ML, а также в переносимости), которые и призвано решить нововведение. Оно устанавливает размер таких томов по умолчанию равным объёму выделяемой pod'у памяти и позволяет изменять это значение на меньшее.
Многие фичи переведены в статус стабильных (GA):
* [ресурс RuntimeClass](https://github.com/kubernetes/enhancements/issues/585) с параметрами исполняемой среды для контейнеров;
* поддержка в kubelet [сторонних плагинов](https://github.com/kubernetes/enhancements/issues/606) для мониторинга устройств;
* [изоляция PID'ов](https://github.com/kubernetes/enhancements/issues/757) от узла к pod'ам;
* [проба startupProbe](https://github.com/kubernetes/enhancements/issues/950).
Но и это ещё не всё:
* kubelet [научили](https://github.com/kubernetes/enhancements/issues/1972) **учитывать таймаут для вызова проб** (альфа-версия, [KEP-1972](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/1972-kubelet-exec-probe-timeouts));
* [Node Topology Manager](https://github.com/kubernetes/enhancements/issues/693), хоть и остался в бета-версии, получил новую возможность — `scope`, — определяющую уровень, на котором требуется выравнивать ресурсы (например, `pod` или `container`);
* [добавлена](https://github.com/kubernetes/enhancements/issues/2053) поддержка HugePages в downward API ([KEP-2053](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2053-downward-api-hugepages)): теперь этот ресурс виден pod'ам так же, как и CPU, память и другие (пока в альфа-версии).
Аутентификация и безопасность
-----------------------------
Новая возможность на пересечении sig-auth и sig-storage — альфа-версия **[поддержки Service Account Token](https://github.com/kubernetes/enhancements/issues/2047) для CSI-драйверов** ([KEP-1855](https://github.com/kubernetes/enhancements/blob/master/keps/sig-storage/1855-csi-driver-service-account-token/README.md)). Идея в том, чтобы CSI-драйверы могли запрашивать и получать у kubelet'а токены ServiceAccount для pod'ов, которым они монтируют тома, — в противовес существующему подходу с прямым считыванием токенов из файловой системы. Эти токены действительны ограниченное время, поэтому у драйверов также предусмотрена возможность повторного вызова `NodePublishVolume` для монтирования томов.
Другое улучшение безопасности затрагивает инфраструктуру для сборки и релизов Kubernetes: **[представлена](https://github.com/kubernetes/enhancements/issues/1933) защита от логирования секретов на основе статического анализа** ([KEP-1933](https://github.com/kubernetes/enhancements/blob/master/keps/sig-instrumentation/1933-secret-logging-static-analysis/README.md)). Появление такого механизма мотивируется результатами [аудита безопасности](https://github.com/trailofbits/audit-kubernetes) кодовой базы K8s, проведенного американской компанией Trail of Bits в прошлом году *(проверка осуществлялась на версии Kubernetes 1.13.4)*. Его авторы заключают, что конфиденциальная информация не должна открыто появляться в логах. Для реализации соответствующего статического анализа используется утилита [go-flow-levee](https://github.com/google/go-flow-levee) от Google, вызываемая в системе Prow при тестировании pull-запросов, поступающих в репозитории Kubernetes.
*Фрагмент [итогов аудита](https://github.com/trailofbits/audit-kubernetes/blob/master/reports/Kubernetes%20Security%20Review.pdf) Kubernetes от Trail of Bits*
Другая инициатива, связанная с логами и безопасностью, — [logs sanitization](https://github.com/kubernetes/enhancements/issues/1753) ([KEP-1753](https://github.com/kubernetes/enhancements/tree/master/keps/sig-instrumentation/1753-logs-sanitization)), т.е. постоянная **очистка логов от потенциально опасных данных**. В его рамках решаются следующие задачи: предотвращение попадания в логи известных видов конфиденциальных данных, упрощённая возможность добавлять новые источники таких данных в фильтры, а также ограничение влияния всех этих процессов на общую производительность.
Для [client-go credential plugins](https://github.com/kubernetes/enhancements/tree/master/keps/sig-auth/541-external-credential-providers) добавили поддержку переменной окружения `KUBERNETES_EXEC_INFO`: через неё можно (опционально) передавать информацию о кластере, для которого плагин получает учётные данные. Сама поддержка таких внешних провайдеров осталась в бета-версии, их стабилизация отложена до следующих релизов Kubernetes.
Наконец, поддержка `TokenRequest` и `TokenRequestProjection` (из [KEP-1205](https://github.com/kubernetes/enhancements/tree/master/keps/sig-auth/1205-bound-service-account-tokens)) для того, чтобы pod'ы могли запрашивать ServiceAccount-токены, объявлена стабильной. Но работа над [интеграцией TokenRequest API и Kubelet](https://github.com/kubernetes/enhancements/issues/542) в целом ещё не завершена: другие её изменения ждут более стабильных версий.
Сети
----
В альфа-версии [стало возможным](https://github.com/kubernetes/enhancements/issues/1864) **отключать NodePorts для сервисов с типом LoadBalancer** ([KEP-1864](https://github.com/kubernetes/enhancements/tree/master/keps/sig-network/1864-disable-lb-node-ports)). До сих пор для каждого порта сервиса LoadBalancer в Kubernetes автоматически выделялся порт узла. Хотя это действительно чаще всего необходимо, в жизни так происходит не всегда: примерами подобных исключений являются MetalLB и kube-router. Теперь в `Service.Spec` есть специальное булево поле `allocateLoadBalancerNodePort`, регулирующее соответствующую настройку.
[Достигла](https://github.com/kubernetes/enhancements/issues/1435) своей альфа-версии и другая возможность, связанная с LoadBalancer'ами и развиваемая с начала этого года. Теперь **в сервисах LoadBalancer можно определять одни и те же порты для разных протоколов** ([KEP-1435](https://github.com/kubernetes/enhancements/tree/master/keps/sig-network/1435-mixed-protocol-lb)). Например, стала доступной такая конфигурация:
```
apiVersion: v1
kind: Service
metadata:
name: mixed-protocol
spec:
type: LoadBalancer
ports:
- name: dns-udp
port: 53
protocol: UDP
- name: dns-tcp
port: 53
protocol: TCP
selector:
app: my-dns-server
```
Набор допустимых протоколов при этом определяется облачным провайдером.
Работа над [**поддержкой двойного сетевого стека IPv4/IPv6**](https://github.com/kubernetes/enhancements/issues/563) продолжается. Хоть эта фича и осталась в альфа-версии, она принесла значительные обновления, которые появились в ответ на запросы пользователей/сообщества. В частности, теперь можно переключать сервисы с single-stack на dual-stack (и наоборот) — параметром `ipFamilyPolicy` в спецификации, который принимает говорящие за себя значения: `SingleStack`, `PreferDualStack`, `RequireDualStack`. Пример конфигурации для сервиса с dual-stack:
```
apiVersion: v1
kind: Service
metadata:
name: my-service
labels:
app: MyApp
spec:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv6
type: LoadBalancer
selector:
app: MyApp
ports:
- protocol: TCP
port: 80
```
Подробности по использованию dual-stack — см. в [KEP](https://github.com/kubernetes/enhancements/blob/master/keps/sig-network/20180612-ipv4-ipv6-dual-stack.md) и [документации](https://kubernetes.io/docs/tasks/network/validate-dual-stack/).
В EndpointSlice API [добавлена](https://github.com/kubernetes/enhancements/issues/1672) возможность отслеживания endpoint'ов, которые завершают свою работу ([KEP-1672](https://github.com/kubernetes/enhancements/tree/master/keps/sig-network/1672-tracking-terminating-endpoints)). Для этого в структуру `EndpointConditions` введено новое поле (`terminating`), информирующее о том, что endpoint сейчас прекращает свою работу. Теперь достаточно считать его вместо того, чтобы отслеживать статусы pod'ов, связанных с endpoint'ом, как было раньше.
Среди других сетевых новшеств:
* [возможность](https://github.com/kubernetes/enhancements/issues/1797) определять имя хоста pod'а как FQDN ([KEP-1797](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/1797-configure-fqdn-as-hostname-for-pods), поле `setHostnameAsFQDN`) переведена в бета-версию;
* [поддержка протокола SCTP](https://github.com/kubernetes/enhancements/issues/614) объявлена стабильной (GA) — см. [документацию на сайте](https://kubernetes.io/docs/concepts/services-networking/service/#sctp);
* поддержка [поля AppProtocol](https://github.com/kubernetes/enhancements/issues/1507) ([KEP-1507](https://github.com/kubernetes/enhancements/tree/master/keps/sig-network/1507-app-protocol)) как унифицированного способа определять протокол у приложения объявлена стабильной ([документация на сайте](https://kubernetes.io/docs/concepts/services-networking/service/#application-protocol)).
Хранилища
---------
**Функция создания/восстановления снапшотов томов для CSI-драйверов ([KEP-177](https://github.com/kubernetes/enhancements/tree/master/keps/sig-storage/177-volume-snapshot)) [стала](https://github.com/kubernetes/kubernetes/pull/95282) стабильной**. Документация не изменилась и доступна на [прежнем месте](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#volume-snapshot-and-restore-volume-from-snapshot-support).
Других изменений в sig-storage не так много:
* [возможность](https://github.com/kubernetes/enhancements/issues/1682) для CSI-драйверов определять права доступа на основе FSGroup перешла в бета-версию;
* [возможность](https://github.com/kubernetes/enhancements/tree/master/keps/sig-storage/695-skip-permission-change) пропускать рекурсивную смену владельца/прав перед bind-монтированием тома в контейнер (для лучшей производительности) тоже объявлена бетой.
Прочие изменения
----------------
[Новое улучшение](https://github.com/kubernetes/enhancements/issues/1610) для Horizontal Pod Autoscaler добавляет возможность **учёта потребления ресурсов отдельными контейнерами при принятии решений о масштабировании**. Сейчас вместо этого для горизонтального масштабирования используются общие значения со всех pod'ов, однако бывают сценарии, где подобные решения не являются оптимальными, т.е. нет прямой корреляции потребления ресурсов отдельными контейнерами на общее. Авторы приводят такие примеры:
* Sidecar-контейнер с сугубо дополнительной функцией вроде поставки логов. Если приложение не пишет логи часто или не создает логи в пиковые нагрузки, потребление ресурсов таким контейнером не будет расти.
* Sidecar-контейнер, реализующий аутентификацию. Из-за сильного кэширования потребление ресурсов только незаметно вырастет даже при большом росте нагрузки на основной контейнер.
* Sidecar может вставляться без настроенных ресурсов, что тоже препятствует масштабированию на основе их утилизации.
Новый подход, пока реализованный как альфа-версия и описанный в [этом KEP](https://github.com/kubernetes/enhancements/blob/master/keps/sig-autoscaling/0001-container-resource-autoscaling.md), вводит дополнительный источник метрики `ContainerResourceMetricSource` (вдобавок к существующему `ResourceMetricSource`).
Пример конфигурации HPA для случая, когда требуется масштабировать на основе данных только одного из контейнеров:
```
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
name: mission-critical
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: mission-critical
minReplicas: 1
maxReplicas: 10
metrics:
- type: ContainerResource
resource:
name: cpu
container: application
target:
type: Utilization
averageUtilization: 30
```
Пополнение в метриках — альфа-версия **Pod Resource Request Metrics** ([KEP-1748](https://github.com/kubernetes/enhancements/tree/master/keps/sig-instrumentation/1748-pod-resource-metrics)). Идея заключается в создании «из коробки» достаточного количества метрик, необходимых для планирования ресурсов кластера и простого представления модели ресурсов Kubernetes. Для её реализации в kube-scheduler появились новые метрики по запрашиваемым ресурсам (`kube_pod_resource_requests`) и желаемым лимитам (`kube_pod_resource_limits`) для всех запущенных pod'ов — они активируются по HTTP на `/metrics/resources` при использовании флага `--show-hidden-metrics-for-version=1.20`.
С новой фичей, [названной](https://github.com/kubernetes/enhancements/issues/2133) Kubelet Credential Provider или **Out-of-Tree Credential Providers** ([KEP](https://github.com/kubernetes/enhancements/blob/master/keps/sig-cloud-provider/20191004-out-of-tree-credential-providers.md)), kubelet получил возможность динамически получать учетные данные (credentials) для реестров контейнерных образов (container registry), вызывая сторонние плагины — специфичные для облачных провайдеров биинарники. Взаимодействие с плагинами происходит по Kubernetes API через stdio. Вынос специфичного кода провайдеров из ядра Kubernetes следует общему тренду смены in-tree на out-of-tree для растущей кодовой базы проекта. Текущая реализация — альфа-версия, подробности — в [документации Kubernetes](https://kubernetes.io/docs/tasks/kubelet-credential-provider/kubelet-credential-provider/).
**CronJob API**, который до сих пор находился в бета-версии (с релиза Kubernetes 1.8, а это более 3 лет назад!), решили продвинуть до стабильного уровня, однако одновременно с этим **его код переписывают** ([KEP](https://github.com/kubernetes/enhancements/tree/master/keps/sig-apps/19-Graduate-CronJob-to-Stable)) с целью улучшить масштабируемость (использовать информеры вместо polling) и добавить метрики (пропускная способность контроллера, задержки и т.п.). Для активации необходимо включить feature gate под названием `CronJobControllerV2`.
Кроме того:
* представленный в [K8s 1.18](https://habr.com/ru/company/flant/blog/493284/) механизм [API Priority and Fairness](https://github.com/kubernetes/enhancements/issues/1040) (APF) для более тонкого контролирования ограничения запросов к API-серверу (с продвинутой системой приоритетов) переведён в бета-версию;
* [команда kubectl debug](https://github.com/kubernetes/enhancements/issues/1441) перешла в бета-версию (все вызовы `kubectl alpha debug` необходимо заменить на `kubectl debug`);
* label и taint под названием `node-role.kubernetes.io/master`, добавляемый kubeadm'ом на узлы, [переименован](https://github.com/kubernetes/enhancements/issues/2067) в `node-role.kubernetes.io/control-plane`;
* каждому kube-apiserver в HA-кластерах теперь [назначается](https://github.com/kubernetes/enhancements/issues/1965) уникальный идентификатор, а у контроллеров есть возможность просмотра их списка во всем кластере (альфа-версия, [KEP-1965](https://github.com/kubernetes/enhancements/tree/master/keps/sig-api-machinery/1965-kube-apiserver-identity)).
Прочие изменения
----------------
Обновления в зависимостях Kubernetes:
* cri-tools 1.19.0;
* CNI (Container Networking Interface) 0.8.7, Calico 3.15.2;
* etcd 3.4.13;
* используемая версия Go — 1.15.5.
Немного статистики
------------------
В составе релиза Kubernetes 1.20 насчитывается 42 улучшения: 11 перешли в stable, 15 — beta, 16 — alpha.
За время его подготовки — 11 недель с 25 сентября по 9 декабря — в репозитории проекта внесли свою лепту 967 компаний и 1335 индивидуумов (44 из них сделали это впервые) из 26 стран.
В число этих компаний попал и «Флант» с несколькими contributions (см. «Flant» в [этом списке](https://k8s.devstats.cncf.io/d/9/companies-table?orgId=1&var-period_name=v1.19.0%20-%20v1.20.0&var-metric=contributions)).
**Топ-10 компаний** по числу contributions *(включают в себя коммиты, PR, issues и т.п.)* для последнего релиза выглядит следующим образом:
1. Google (32284);
2. VMware (17598);
3. Red Hat (10935);
4. Microsoft (7062);
5. IBM (5857);
6. The Scale Factory (2151);
7. Samsung SDS (1471);
8. Glassdoor (1406);
9. SUSE (1319);
10. Kubermatic (1300).
P.S.
----
Разработчики Kubernetes присвоили релизу v1.20 имя «raddest» (английский сленг, который переводится как «отличный, замечательный, классный»). Потому что, несмотря на сложный для всех год, сообществу удалось привнести рекордное число значимых изменений в этот релиз.
А такой кот стал официальным логотипом релиза Kubernetes v1.20:
P.P.S.
------
Читайте также в нашем блоге:
* «[Kubernetes 1.19: обзор основных новшеств](https://habr.com/ru/company/flant/blog/516322/)»;
* «[Kubernetes 1.18: обзор основных новшеств](https://habr.com/ru/company/flant/blog/493284/)»;
* «[Kubernetes 1.17: обзор основных новшеств](https://habr.com/ru/company/flant/blog/476998/)». | https://habr.com/ru/post/530924/ | null | ru | null |
# Восстановление утерянных данных
Всем привет!
**Данный топик — обращение к хабрасообществу за помощью.**
При включении ноута с воткнутой в него usb флешкой chkdsk куда-то дел папки с длинными названиями. Я это понял после подобного опыта: создал папку с длинным названием, поместил туда файлов на полгига и запустил проверку. Результат — папка пропала, а свободного места на флешке больше не стало.
Помогите пожалуйста восстановить данные!
**UPD:**
Вот что мне написали на Google.ответах:
`на диске с уиндоусом (c:\) в папке с названием начинающимся на букву "r" (recucle или restore). они там с другими названиями будут аля A0344f.tmp (не забудь залезть в свойства и включить отображение системных и скрытых файлов/папок)`
но увы такого нет, возможно потому, что на диске С места свободного было меньше, чем объем потерянных папок.
**UPD2:**
Проверка на удаленные файлы не помогает. CHKDSK прячет их каким-то иным способом.
#### **Решение:**
Проблему удалось решить с помощью пакета EasyRecovery Pro.
Там все оказалось предельно просто:
1. Запускаем программу
2. В правом меню выбираем Data Recovery
3. Advanced Recovery
4. Выбираем диск, на котором хотим восстанавливать данные
5. Тыкаем Next и идем спать :)
После сканирования появляется список из папок и файлов, который состоит из удаленных и поврежденных файлов. Все удаленные файлы так и отображаются, включая вложенность папок, а вот все поврежденные находятся в папке Lost Files, там выбираем все что нужно и восстанавливаем. Процесс восстановления файлов довольно-таки долгий, так что если файлов там больше, чем на 1 гигабайт, то лучше наверное ставить на ночь.
**P.S.:**
Всем огромное спасибо за советы! Очень благодарен!
— Отдельное «спасибо» хотел бы сказать всем, кто минусовал тему без объяснения. | https://habr.com/ru/post/38479/ | null | ru | null |
# Радости и горести побед над C: делаем конфетку из прототипа wc на хаскеле
Привет, Хабр.
Итак, [в прошлый раз](https://habr.com/post/489136/) мы эмпирически доказали, что на хаскеле можно довольно легко написать этакий игрушечный wc, который при этом существенно быстрее реализации wc из GNU Coreutils. Понятное дело, что это не совсем честное сравнение: наша программа не умеет ничего, кроме подсчёта байт, строк и слов, тогда как настоящий wc куда мощнее: он имеет ещё несколько статистик, поддерживает опции, умеет читать из stdin… Короче, у нас действительно получилась всего лишь игрушка.
Сегодня мы это исправим. Наша главная цель — позволить пользователю выбирать конкретные статистики для подсчёта, при этом не считая то, что пользователю не нужно. А самое главное — мы будем стремиться к модульности, выделяя каждую статистику в отдельный изолированный юнит.
Действительно, если мы посмотрим на [C-версию](https://github.com/coreutils/coreutils/blob/master/src/wc.c) — ну, лично я бы не назвал это образцом читаемого и поддерживаемого кода, так как там всё происходит в одной большой функции на 370 строк. Мы будем стараться этого избежать.
*Основная функция С-версии не влезла на 4k-экран в портретной ориентации 4-м шрифтом.*
Кроме этой модуляризации мы, среди прочего:
* выразим идею, что некоторые статистики вроде подсчёта числа байт могут работать эффективнее на всём входе целиком, а другие должны смотреть на каждый байт;
* реализуем ещё больше статистик, наслаждаясь возможностью рассуждать о каждой из них в отдельности (то, что называют local reasoning);
* напишем немного тестов, наслаждаясь local reasoning'ом ещё раз;
* испытаем некоторые почти зависимо типизированные техники, успешно получив корректно работающий, но феерически тормозящий код;
* поиграем с Template Haskell;
* полюбуемся (не)предсказуемостью и (не)воспроизводимостью производительности результирующего кода.
На всякий случай вспомним, чем мы закончили предыдущий пост:
```
{-# LANGUAGE Strict #-}
{-# LANGUAGE RecordWildCards #-}
module Data.WordCount where
import qualified Data.ByteString.Lazy as BS
data State = State
{ bs :: Int
, ws :: Int
, ls :: Int
, wasSpace :: Int
}
wc :: BS.ByteString -> (Int, Int, Int)
wc s = (bs, ws + 1 - wasSpace, ls)
where
State { .. } = BS.foldl' go (State 0 0 0 1) s
go State { .. } c = State (bs + 1) (ws + addWord) (ls + addLine) isSp
where
isSp | c == 32 || c - 9 <= 4 = 1
| otherwise = 0
addLine | c == 10 = 1
| otherwise = 0
addWord = (1 - wasSpace) * isSp
{-# INLINE wc #-}
```
Мы хотим разбить эту функцию на отдельные кусочки, считающие соответственно количество байт, слов и строк. Как этого можно добиться?
Композабельные левые свёртки
============================
В первую очередь заметим, что основная часть нашего алгоритма выражается как свёртка. В самом деле, об этом говорит даже название функции `BS.foldl'`!
Некоторое время назад я наткнулся на библиотеку [foldl](https://hackage.haskell.org/package/foldl), предназначенную для «композабельных, потоковых и эффективных левых свёрток». Это ровно то, что нам нужно! Более того, к счастью, в этой библиотеке даже есть отдельный [модуль](http://hackage.haskell.org/package/foldl-1.4.6/docs/Control-Foldl-ByteString.html) для свёрток по `ByteString`. В частности, в этом модуле есть две из трёх нужных нам статистик: количество байт равно длине входной строки (то есть, `length` в этом модуле), а количество строк можно посчитать при помощи функции `count` (через `count 10`). Похоже, осталось реализовать свёртку для подсчёта слов, и мы в дамках!
Для того, чтобы реализовать эту свёртку, можно взять нашу исходную функцию и просто выкинуть из неё всё лишнее. Вот так в итоге выглядит результат:
```
{-# LANGUAGE Strict #-}
import qualified Control.Foldl as L
import qualified Data.ByteString as BS
data WordState = WordState { ws :: Int, wasSpace :: Int }
wordsCount :: L.Fold BS.ByteString Int
wordsCount = L.Fold (BS.foldl' go) (WordState 0 1) (\WordState { .. } -> ws + 1 - wasSpace)
where
go WordState { .. } c = WordState (ws + addWord) isSp
where
isSp | c == 32 || c - 9 <= 4 = 1
| otherwise = 0
addWord = (1 - wasSpace) * isSp
```
Тогда посчитать байты, строки и слова одновременно можно так:
```
import qualified Control.Foldl.ByteString as BL
import qualified Data.ByteString.Lazy as BSL
main :: IO ()
main = do
[path] <- getArgs
contents <- unsafeMMapFile path
let res = BL.fold ((,,) <$> BL.length <*> BL.count 10 <*> wordsCount) (BSL.fromStrict contents) :: (Int, Int, Int)
print res
```
Композабельно! Но насколько эффективно?
Если бенчмаркать так же, как описано в предыдущем посте (запуская пять раз на 1.8-гигабайтовом файле, находящемся в `tmpfs`-разделе для устранения IO, и выбирая наилучший результат), то на моей машине получится в районе 2.5 секунд. Кстати, надо для честности отметить, что это машина с другим процессором, чем использованная в прошлом посте (хотя скорость работы что оригинального `wc`, что результата усилий из прошлого поста на ней отличается несущественно), да и ней есть куча источников шума вроде запущенного браузера или IDE, но для составления общей картины о характеристиках кода и иллюстрации идеи поста этого хватит.
Итак, 2.5 секунд. Почти вдвое хуже, чем было раньше.
Что, если мы посчитаем только лишь длину и количество слов?
```
let res = BL.fold ((,) <$> BL.length <*> wordsCount) contents :: (Int, Int)
print res
```
1.55 секунд. Хмм. Что насчёт количества строк?
```
let res = BL.fold (BL.count 10) contents :: Int
print res
```
1.05 секунд.
Чёрт. Оно практически аддитивно. Но оно *не должно* быть аддитивно! Например, подсчёт количества строк (сводящийся к подсчёту количества `'\n'`) должен затмеваться куда более сложной логикой подсчёта количества слов, но мы этого не наблюдаем.
Плохо. Чтобы понять, что происходит, засучим рукава и залезем в кишки библиотеки `foldl`.
`foldl` реализован следующим образом. Он берёт каждый чанк входа и скармливает его каждой из свёрток в композиции. В случае строк `foldl` бегает по ленивым `ByteString`'ам, которые примерно изоморфны списку строгих `ByteString`'ов, каждая из которых и является чанком. В данном конкретном случае размер чанка — 256 килобайт, что не влезает в L1-кэш, так что мы вынуждены платить за перемещение данных из L2 в L1 (и даже за перемещение из L1 в регистры).
Мы, конечно, могли бы уменьшить размер чанка до 16-32 килобайт, чтобы он помещался в L1, но это не так *интересно*.
И, что гораздо хуже, компилятор, похоже, не может оптимизировать лишние вычисления: время работы `BL.fold ((,) <$> wordsCount <*> wordsCount) contents` (то есть, двойного подсчёта слов) *вдвое* больше времени `BL.fold wordsCount contents`. Так что от этого подхода мы вынуждены отказаться.
Кроме того, неочевидно, как совмещать свёртки «по запросу», например, на основании опций командной строки.
Так что давайте напишем...
Наши собственные свёртки
========================
Перед тем, как бросаться к редактору кода, давайте немного подумаем о дизайне. В итоге мы хотим строить композиции свёрток на основе рантайм-выбора пользователя. Как это может выглядеть?
Пусть у нас есть какие-то базовые «атомарные» свёртки (то есть, статистики) `f1`, `f2`, `f3`, и пользователю нужна композиция `f1` и `f3`. Думаю, даже компиляторы функциональных языков ещё долго будут не настолько умны, чтобы понять, что код вроде
```
-- options — список булевых значений, соответствующих атомарным свёрткам
options <- parseCliOptions
-- theFold — результирующая композиция
let theFold = foldl' f (zip options [f1, f2, f3]) emptyFold
where
f acc (True, stat) = acc `compose` stat
f acc (False, _) = acc
```
означает, что необходимо специализировать все возможные композиции свёрток, которые тут могут возникнуть.
Единственный способ быть уверенным, что у компилятора достаточно информации — поднять всё это на уровень типов. Хаскель в итоге избавляется от типов на этапе компиляции, так что любая информация, выраженная через типы, оказывается доступна компилятору.
Типы на помощь
--------------
Так как нам представить свёртку?
Один дружественный к типам способ — через тайпкласс. Только перед тем, как обсуждать тайпклассы, давайте сразу упомянем необходимые в дальнейшем расширения системы типов, чтобы потом на них не отвлекаться:
```
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses, UndecidableInstances, FlexibleInstances #-}
{-# LANGUAGE TypeFamilyDependencies, FunctionalDependencies, PolyKinds, DataKinds, GADTs, TypeOperators #-}
{-# LANGUAGE ScopedTypeVariables #-}
```
Что на самом деле является свёрткой-статистикой в нашем случае? Статистика состоит из:
* начального состояния,
* функции-шага, обновляющей состояние согласно входному символу,
* функции для превращения состояния в окончательный ответ-результат,
* типов состояния и результата.
Давайте это запишем:
```
class Statistic s res st | res -> s, st -> s
, s -> res, s -> st
where
initState :: st
extractState :: st -> res
step :: st -> Word8 -> st
```
где `s` обозначает идентификатор статистики (чуть позже это будет штука из `DataKinds`), и мы используем функциональные зависимости для выражения того, что статистика единственным образом определяет типы состояния и результата, и наоборот. В частности, это освобождает нас от потребности перечислять все типы-параметры тайпкласса в каждом методе: иначе нам бы пришлось писать
```
initState :: proxy1 s -> proxy2 res -> st
extractState :: proxy s -> st -> res
step :: proxy1 s -> proxy2 res -> st -> Word8 -> st
```
К счастью, функциональные зависимости позволяют компилятору вывести все переменные типов, даже если упомянута всего одна из них, так что мы можем писать короткие и ясные сигнатуры.
Кстати, заметим, что мы могли бы пользоваться и куда более мощными и общими семействами типов, что дало бы инъективность в одну из сторон, но выражение статистик через мультипараметрический тайпкласс с функциональными зависимостями кажется мне более интуитивным и естественным в этой задаче.
### Статистики по чанкам
Пока всё вроде бы неплохо, но кое-чего не хватает. Давайте подумаем, как бы мы могли выразить, например, подсчёт количества байт. Если пользователь запросил только эту статистику, то нам совершенно не обязательно побайтово пробегать всю строку, инкрементируя счётчик на каждой итерации. Вместо этого мы могли бы просто взять длину всей строки и радоваться жизни, сведя сложность задачи с  до . С другой стороны, подсчёт слов (или, что ещё сложнее, подсчёт максимальной длины строки) не имеет подобной легко выразимой «чанковой» структуры (если не рассматривать различные хитроумные SIMD-реализации, анализ которых сильно вне темы этого поста). Кроме того, чуть позже мы захотим совмещать статистики. Если все из них поддерживают чанковый режим вычислений, то и результат тоже его поддерживает, а иначе придётся откатиться до побайтового анализа.
Так как мы можем выразить, что некоторые статистики поддерживают и чанковый, и побайтовый режим вычислений, тогда как другие обязаны вычисляться побайтово? Здесь нам поможет GADT! Мы добавим тип-перечисление для определения *режима подсчёта* статистик, и мы также определим GADT для хранения тех функций, которые имеют смысл для данного режима. Или в коде:
```
data StatCompTyOf = Chunked | ByteOnly
data StatComputation st compTy where
ChunkedComputation :: (st -> Word8 -> st)
-> (st -> BS.ByteString -> st)
-> StatComputation st 'Chunked
ByteOnlyComputation :: (st -> Word8 -> st)
-> StatComputation st 'ByteOnly
```
Здесь (и в последующем изложении) `BS` — модуль, соответствующий строгим байтовым строкам.
Мы также поменяем наш класс `Statistic`, добавив туда ещё один параметр `comp` и заменив метод `step` на более общий `computation`:
```
class Statistic s res st comp | res -> s, st -> s
, s -> res, s -> st, s -> comp
where
initState :: st
extractState :: st -> res
computation :: StatComputation st comp
```
И здесь нам снова помогают функциональные зависимости. Достаточно знать значение либо `s`, либо `res`, либо `st`, чтобы вывести значения всех остальных переменных.
Кроме того, явно отметим, что этот подход легко обобщить для поддержки большего количества видов вычислений. Например, можно добавить поддержку SIMD-ускоренных функций, обрабатывающих по 16-32 байта за раз. Однако для простоты изложения мы на это отвлекаться не будем.
Реализация статистик
--------------------
Какие у нас будут статистики? Давайте реализуем следующие:
* число байт,
* число (UTF-8)-символов,
* число слов,
* максимальная длина строки,
* количество строк.
Или в коде:
```
data Statistics = Bytes | Chars | Words | MaxLL | Lines deriving (Eq, Ord)
```
Этого должно быть более чем достаточно для иллюстрации подхода, да и `wc` других статистик особо не предлагает.
Тогда базовые статистики — это всего лишь реализации класса `Statistic`. И, так как состояние большинства статистик — одно число, давайте для удобства добавим типизированную обёртку:
```
newtype Tagged a = Tagged Word64 deriving (Eq, Show, Num)
```
здесь `a` предназначен исключительно для того, чтобы отличить `Tagged 'Bytes` от `Tagged 'Chars`.
Теперь мы можем написать самую простую статистику: подсчёт количества байт:
```
instance Statistic 'Bytes (Tagged 'Bytes) (Tagged 'Bytes) 'Chunked where
initState = 0
extractState = id
computation = ChunkedComputation (\st _ -> st + 1) (\st str -> st + fromIntegral (BS.length str))
```
Это, пожалуй, достаточно самодокументируемый код:
1. Мы говорим, что `Bytes` обозначает статистику, у которой `Tagged 'Bytes` является и типом состояния, и типом результата. Кроме того, эта статистика поддерживает чанковые вычисления.
2. Начальное состояние (то есть, количество байт) равно 0.
3. Для того, чтобы получить результат из состояния, не нужно делать ничего особенного — состояние и есть результат.
4. `computation` обязательно должно быть чанковым вычислением, так как мы сказали `'Chunked` на первой строке. Функция шага игнорирует текущий символ и просто увеличивает счётчик, а чанковая функция прибавляет ко счётчику всю длину входа.
Пока что вроде всё просто и понятно.
Остальные статистики реализуются аналогично, и реализации довольно скучны, так что я их спрячу под спойлер, но заинтересованный читатель приглашается
**посмотреть.**Подсчёт строк тоже довольно прост, и эта статистика тоже поддерживает как побайтовые, так и чанковые вычисления:
```
instance Statistic 'Lines (Tagged 'Lines) (Tagged 'Lines) 'Chunked where
initState = 0
extractState = id
computation = ChunkedComputation (\st c -> st + if c == 10 then 1 else 0) (\st str -> st + fromIntegral (BS.count 10 str))
```
Что насчёт подсчёта слов? Здесь мы поддерживаем только побайтовый подсчёт и заимствуем реализацию из предыдущего поста:
```
data WordsState = WordsState { ws :: Word64, wasSpace :: Word64 }
instance Statistic 'Words (Tagged 'Words) WordsState 'ByteOnly where
initState = WordsState 0 1
extractState WordsState { .. } = Tagged (ws + 1 - wasSpace)
computation = ByteOnlyComputation step
where
step WordsState { .. } c = WordsState (ws + (1 - wasSpace) * isSp) isSp
where
isSp | c == 32 || c - 9 <= 4 = 1
| otherwise = 0
```
Кроме того, это хороший пример статистики с нетривиальной функцией преобразования состояния в результат.
Итак, мы портировали те статистики, что мы уже реализовали ранее. Что насчёт новеньких — подсчёта UTF-8-символов и максимальной длины строки?
Вся сложность подсчёта символов состоит в аккуратном жонглировании битами:
```
instance Statistic 'Chars (Tagged 'Chars) (Tagged 'Chars) 'ByteOnly where
initState = 0
extractState = id
computation = ByteOnlyComputation $ \cnt c ->
cnt + 1 - fromIntegral ( ((c .&. 0b10000000) `shiftR` 7)
.&. (1 - ((c .&. 0b01000000) `shiftR` 6))
)
```
Здесь мы опираемся на следующее свойство кодировки UTF-8: каждый символ имеет один и только один байт, который не следует паттерну `10xxxxxx`. Другими словами, нам не нужно полноценно декодировать UTF-8 только для того, чтобы подсчитать количество символов.
Что насчёт максимальной длины строки? Тут вся сложность в корректном учёте непечатаемых символов и правильной обработке символов табуляции (кстати, тут, как и во всех прочих статистиках кроме предыдущей, мы ограничиваемся ASCII):
```
instance Statistic 'MaxLL (Tagged 'MaxLL) MaxLLState 'ByteOnly where
initState = MaxLLState 0 0
extractState MaxLLState { .. } = Tagged $ max maxLen curLen
computation = ByteOnlyComputation step
where
step MaxLLState { .. } 9 = MaxLLState maxLen $ curLen + 8 - (curLen `rem` 8)
step MaxLLState { .. } 8 = MaxLLState maxLen $ max 0 (curLen - 1)
step MaxLLState { .. } c | c == 10
|| c == 12
|| c == 13 = MaxLLState (max maxLen curLen) 0
| c < 32 = MaxLLState maxLen curLen
step MaxLLState { .. } _ = MaxLLState maxLen (curLen + 1)
```
Кстати, эта функция даже корректно обрабатывает backspace, в отличие от `wc`!
Итак, у нас есть все базовые статистики. Теперь можно перейти к самому интересному: их комбинированию.
Комбинирование статистик
------------------------
Если `a` — статистика, и `b` — статистика, то их пара — тоже статистика, и это наш шаг индукции. Давайте начнём с реализации типа для пары статистик:
```
infixr 5 :::
data a ::: b = a ::: b deriving (Show)
```
Мы также могли использовать обычный тип `(,)`, но теперь нам не нужно думать о том, сможет ли компилятор избежать ленивости или нет, да и, на мой взгляд, этот отдельный тип сделает поднятый на уровень типов код более читабельным.
Теперь выразим, как совмещать статистики.
Во-первых, что насчёт комбинирования чанковых и побайтовых статистик? Если обе поддерживают чанковые вычисления, то и результат их поддерживает, иначе придётся ограничиться побайтовым подсчётом. На языке типов это можно выразить так:
```
type family CombineCompTy a b where
CombineCompTy 'Chunked 'Chunked = 'Chunked
CombineCompTy _ _ = 'ByteOnly
```
Как инстанс класса `Statistic` выглядит для пары статистик? Можно написать что-то такое:
```
instance (Statistic sa resa sta compa, Statistic sb resb stb compb)
=> Statistic (sa '::: sb) (resa ::: resb) (sta ::: stb) (CombineCompTy compa compb) where
initState = initState ::: initState
extractState (a ::: b) = extractState a ::: extractState b
computation =
case (computation :: StatComputation sta compa, computation :: StatComputation stb compb) of
(ByteOnlyComputation a, ChunkedComputation b _)
-> ByteOnlyComputation $ combine a b
(ChunkedComputation a _, ByteOnlyComputation b)
-> ByteOnlyComputation $ combine a b
(ByteOnlyComputation a, ByteOnlyComputation b)
-> ByteOnlyComputation $ combine a b
(ChunkedComputation stepA chunkA, ChunkedComputation stepB chunkB)
-> ChunkedComputation (combine stepA stepB) (combine chunkA chunkB)
where
combine fa fb = \(a ::: b) w -> fa a w ::: fb b w
```
То есть, если `sa` — статистика с типом результата `resa`, типом состояния `sta` и режимом подсчёта `compa`, и аналогично для `sb`/`resb`/`stb`/`compb`, то пара `sa ::: sb` — тоже статистика, причём её тип результата — пара `resa ::: resb`, тип состояния — пара `sta ::: stb`, а режим вычисления — результат ~~функции на уровне типов~~ `CombineCompTy compa compb`.
Заметьте разницу между (с крыжечкой, запромоученным) `:::`-в-роли-конструктора и (без крыжечки, незапромоученным) `:::`-в-роли-типа в определении инстанса. `sa` и `sb` — *термы*, запромоученные на уровень типов, поэтому рядом с ними мы используем (запромоученный) конструктор *термов*, тогда как остальные переменные — *типы*, так что рядом с ними мы используем (незапромоученный) конструктор *типов*.
Всё бы хорошо, вот только… мы не можем написать такой инстанс. В текущем хаскеле нельзя использовать семейство типов в таком виде. К счастью, это легко обойти добавлением новой переменной `comp` вместе с ограничением, что она должна быть равна результату применения этого семейства типов:
```
instance (Statistic sa resa sta compa,
Statistic sb resb stb compb,
comp ~ CombineCompTy compa compb)
=> Statistic (sa '::: sb) (resa ::: resb) (sta ::: stb) comp where
```
Остальная часть инстанса никак не меняется.
Давайте теперь разбирать термы. Первые два метода просты:
1. Начальное состояние пары статистик равно паре из начальных состояний соответствующих статистик.
2. Чтобы достать ответ из состояния для пары статистик, нужно достать ответы из соответствующих компонент состояния-пары и сделать из них пару.
Кстати, нам тут не нужна ни единая аннотация типов — компилятор может вывести всё сам, и это очень круто!
Третий метод уже поинтереснее и куда более многословен, но он по большому счёту следует за определением `CombineCompTy` (и тайпчекер это на самом деле проверяет). Опять же, если обе статистики поддерживают чанковые вычисления, то и результирующая статистика их поддерживает (это последний случай), а иначе всё сводится к побайтовому вычислению.
Основная часть бойлерплейта происходит от необходимости явного паттерн-матчинга по хотя бы одному из вычислителей, который, в свою очередь, нужен для того, чтобы тайпчекер мог убедиться, что правая часть каждой ветки `case` имеет правильный тип.
А какой тип правильный? Согласно определению класса, это `StatComputation st comp`, где, согласно определению инстанса, `comp ~ CombineCompTy compa compb`. То есть, ожидаемый тип *зависит* от конкретных `compa` и `compb`. А чтобы вычислить `CombineCompTy`, тайпчекер должен знать, равны ли `Chunked` и `compa`, и `compb`, или нет.
Откуда тайпчекер знает значение `compa` или `compb`? А в общем случае он и не знает. Однако, если мы сматчимся по результату соответствующего `computation`, то тогда нам поможет логика GADT. Действительно, посмотрим ещё раз на определение типа `StatComputation`. Если значение этого типа было создано при помощи конструктора `ChunkedComputation`, то соответствующая `comp` обязательно должна быть равна `Chunked`. Если же использовался конструктор `ByteOnlyComputation`, то соответствующая переменная равна `ByteOnly`.
Кстати, если бы мы написали `CombineCompTy` без использования `_`-паттернов, а перечисляя все четыре возможные комбинации, то тайпчекер должен был бы знать значения *и* `compa`, *и* `compb`.
Ещё стоит отметить, что такое представление позволяет иметь дубликаты: `Words '::: Words` соответствует комбинированной статистике, считающей количество слов дважды. Пурис⊤ы на такое бы смотрели неодобрительно, но для наших целей оно вполне подходит, тем более, что чуть позже конкретно эта возможность нам очень пригодится.
Использование статистик
=======================
Супер, мы написали кучу кода. Как его использовать?
Пусть нам дан тип, реализующий класс `Statistic`, и `ByteString`, по которой надо посчитать статистику. Тогда мы сначала рассмотрим GADT, возвращаемый функцией `computation`. Если это `ChunkedComputation`, то мы ему кормим всю входную строку. Иначе это `ByteOnlyComputation`, и мы делаем `BS.foldl'`. Или в коде:
```
wc :: forall s res st comp. Statistic s res st comp => BS.ByteString -> res
wc s = extractState $! runCompute computation
where
runCompute :: StatComputation st comp -> st
runCompute (ByteOnlyComputation step) = BS.foldl' step initState s
runCompute (ChunkedComputation _ chunker) = chunker initState s
```
Функциональные зависимости снова нас выручают, так как тайпчекер может вывести все аргументы класса (`s`, `st`, `comp`) по одному лишь желаемому типу результата `res`. С другой стороны, похоже, тайпчекер не может вывести тип `runCompute`, так что нам приходится указывать его явно. При этом переменные `st` и `comp` в её сигнатуре должны совпадать с переменными в типе `wc`, а для этого (*очень интуитивно*) используется `forall` и расширение `ScopedTypeVariables`.
Теперь мы можем выбирать конкретные статистики либо через явную аннотацию типа возвращаемого значения:
```
let result = wc someBS :: Tagged 'Words ::: Tagged 'Lines
```
либо при помощи расширения `TypeApplications` и явного указания значения переменной `s` в сигнатуре функции:
```
let result = wc @('Words '::: 'Lines) someBS
```
Оба варианта полностью эквивалентны, но, на мой взгляд, второй способ подходит чуть лучше, так как он передаёт смысл кода более очевидным образом.
Предварительная оценка производительности
-----------------------------------------
Оправданы ли наши усилия, или же мы занимались всей этой ерундой впустую?
Давайте измерим, сколько времени занимает `wc @'Words`, используя всю ту же методологию. Наилучшее время выполнения — 1.51 секунд, немногим больше, чем подсчёт одних лишь байт, слов и строк в немодуляризованной версии. Не фонтан, но не так уж плохо.
Насколько хорош компилятор в устранении повторяющихся вычислений? Давайте измерим `wc @('Words '::: 'Words)`!
Только вот лично у меня здесь начинается полная ерунда. Я бы ожидал, возможно, увидеть чуть большие цифры, в идеале — такие же, но… Оно работает *быстрее*: 1.34 секунды. А если посчитать `wc @('Words '::: 'Words '::: 'Words)`? 1.30 секунд. Впрочем, последующее добавление `'Words` не помогает.
Что ещё более странно — эти результаты невоспроизводимы у других людей. Я поспрашивал народ в ирке на канале `#haskell` — у них этот результат не воспроизводился. Время работы было довольно стабильным и не зависящим от числа дубликатов одного и того же вычисления.
У меня этому нет хорошего объяснения. Я помедитировал на GHC Core — безрезультатно, всё выглядит разумным. Если бы это было воспроизводимое улучшение, я бы мог потеоретизировать о поведении инлайнера, или специализатора, или о чём-то таком. Но учитывая, что эти результаты не воспроизводятся у других людей… Страннота-ерунда. Я не понимаю, почему код так себя ведёт, и не могу сказать, что мне это нравится.
Ладно, хватит ныть, давайте ещё поизмеряем. Что насчёт всех трёх статистик, которые у нас были раньше? Измерим `wc @('Bytes '::: 'Words '::: 'Lines)`! Время работы в этом случае — 1.53 секунды. Это немногим хуже 1.45 секунд, которые у нас были раньше, но, на мой взгляд, вполне терпимо.
Итак, мы эмпирически доказали, что у этого подхода хотя бы есть шанс. Давайте теперь посмотрим, какие плоды нам даёт такая модуляризация.
Тестирование
============
Тестировать такой код — одно удовольствие! Локальность рассуждений позволяет протестировать каждую статистику в отдельности и при этом даёт уверенность, что они работают корректно в любой комбинации.
Например, мы можем проверить, что для любой строки количество слов равно длине списка, возвращаемого стандартной функцией `words`, если проигнорировать все символы с кодом выше `127`. В частности, мы можем считать это *определяющим свойством* нашей статистики подсчёта слов, но это уже скорее вопрос философских взглядов.
В коде это выражается как набор QuickCheck-свойств, записанных и для ASCII, и для UTF-8-входов:
```
import qualified Data.ByteString.Char8 as BS
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
-- ещё скучные импорты
import Data.WordCount
wrapUnicode :: UnicodeString -> (BS.ByteString, T.Text)
wrapUnicode ustr = (T.encodeUtf8 txt, txt)
where
txt = T.pack $ getUnicodeString ustr
replaceNonAsciiSpaces :: Char -> Char
replaceNonAsciiSpaces ch | ch >= chr 127 && isSpace ch = '_'
| otherwise = ch
main :: IO ()
main = hspec $ parallel $ modifyMaxSuccess (const 10000) $ modifyMaxSize (const 1000) $ do
describe "ASCII support" $ do
it "Counts bytes correctly" $ property $
\(getASCIIString -> str) -> wc @'Bytes (BS.pack str) `shouldBe` genericLength str
it "Counts chars correctly" $ property $
\(getASCIIString -> str) -> wc @'Chars (BS.pack str) `shouldBe` genericLength str
it "Counts words correctly" $ property $
\(getASCIIString -> str) -> wc @'Words (BS.pack str) `shouldBe` genericLength (words str)
it "Counts lines correctly" $ property $
\(getASCIIString -> str) -> wc @'Lines (BS.pack str) `shouldBe` genericLength (filter (== '\n') str)
describe "UTF8 support" $ do
it "Counts bytes correctly" $ property $
\(wrapUnicode -> (bs, _)) -> wc @'Bytes bs `shouldBe` fromIntegral (BS.length bs)
it "Counts chars correctly" $ property $
\(wrapUnicode -> (bs, txt)) -> wc @'Chars bs `shouldBe` fromIntegral (T.length txt)
it "Counts words correctly" $ property $
\(wrapUnicode -> (bs, txt)) -> wc @'Words bs `shouldBe` genericLength (T.words $ T.map replaceNonAsciiSpaces txt)
it "Counts lines correctly" $ property $
\(wrapUnicode -> (bs, txt)) -> wc @'Lines bs `shouldBe` fromIntegral (T.count "\n" txt)
```
И всё!
Заметим несколько вещей:
* В более выразительном языке мы могли бы сформулировать эти свойства как полноценные теоремы и вполне могли бы их доказать внутри языка, что даёт куда большую уверенность в корректности, чем несколько тысяч случайно сгенерированных примеров. В самом деле, кое-какой баг в реализации функции подсчёта количества UTF-8-символов в среднем ловился только на входе из второй или третьей тысячи примеров.
* Мы не формулируем и не проверяем никакие свойства для функции подсчёта длины строк, так как это… нетривиально.
* Тесты исполняются достаточно быстро: прогнать их все на 10 тысячах примеров (для каждого свойства) длиной до тысячи символов занимает 3-5 секунд на моей машине (с учётом создания тестовых данных).
В любом случае, читателю предлагается реализовать что-то подобное для версии на C из GNU Coreutils.
Обработка опций командной строки
================================
Воспользуемся библиотекой [optparse-applicative](https://hackage.haskell.org/package/optparse-applicative). Определим тип, хранящий опции командной строки, и парсер для него:
```
data Options = Options
{ countBytes :: Bool
, countChars :: Bool
, countLines :: Bool
, countMaxLineLength :: Bool
, countWords :: Bool
, files :: [FilePath]
}
options :: Parser Options
options = Options
<$> switch (long "bytes" <> short 'c' <> help "print the byte counts")
<*> switch (long "chars" <> short 'm' <> help "print the character counts")
<*> switch (long "lines" <> short 'l' <> help "print the newline counts")
<*> switch (long "max-line-length" <> short 'L' <> help "print the maximum display width")
<*> switch (long "words" <> short 'w' <> help "print the word counts")
<*> some (argument str (metavar "FILES..."))
```
Модифицируем наш `main`, чтобы распарсить командную строку и отобразить опции на значения типа `Statistics`, подсчитывая байты, слова и строки по умолчанию:
```
main :: IO ()
main = do
Options { .. } <- execParser $ info (options <**> helper) (fullDesc <> progDesc "Print newline, word, and byte counts for each file")
let selectedStats = map snd $ filter fst [ (countBytes, Bytes), (countChars, Chars)
, (countWords, Words), (countMaxLineLength, MaxLL)
, (countLines, Lines)
]
let stats | null selectedStats = [Bytes, Words, Lines]
| otherwise = selectedStats
```
Всё это наверняка можно сделать ещё элегантнее, но цель статьи не в описании парсинга командной строки, так что нам бы уж хоть как-нибудь получить список опций.
Итак, список опций мы получили. Что мы делаем дальше? Нам нужно сконвертировать этот список в *тип*, который мы можем скормить `wc`. Другими словами, у нас есть терм, и нам из него нужно сделать тип. Звучит прямо как зависимые типы!
Почти зависимые типы
--------------------
Этот подход обречён с точки зрения производительности по причинам, которые будут понятны позднее, но давайте всё равно его попробуем, ведь так мы сможем посмотреть, как писать что-то околозависимотипизированное в современном хаскеле, а зависимые типы — это круто!
Мы будем строить решение маленькими шажочками и вручную, без использования [синглтонов](https://hackage.haskell.org/package/singletons), чтобы лучше прочувствовать, как работает система типов и какие у неё ограничения.
Мы не знаем, какие статистики мы будем считать во время выполнения, поэтому мы заворачиваем их в экзистенциальный тип:
```
data SomeStats where
MkSomeStats :: Statistic s res st comp => proxy s -> SomeStats
```
Здесь `proxy s` — свидетель конкретного инстанса `Statistic`. Его единственная задача — обеспечить нас конкретным типом статистики.
Пусть теперь у нас есть значение этого экзистенциального типа. Как мы можем им пользоваться? Можно попробовать что-то такое:
```
wc' :: SomeStats -> BS.ByteString -> ?
wc' (MkSomeStats (_ :: proxy s)) input = wc @s input
```
но… Что мы должны написать вместо `?`? Какой возвращаемый тип этой функции? Понятно, что это `res` из соответствующего инстанса `Statistic`, но у нас его здесь нет.
Может, попробовать написать как-то так?
```
data SomeStats where
MkSomeStats :: Statistic s res st comp => proxy1 s -> proxy2 res -> SomeStats
wc' :: SomeStats -> BS.ByteString -> res
wc' (MkSomeStats (_ :: proxy1 s) (_ :: proxy2 res)) input = wc @s input
```
Но на самом деле понятно, что это работать не будет: в точке определения типа `wc'` нам ещё никакой `res`, завёрнутый внутрь `SomeStats`, не доступен.
Что же делать?
Давайте сделаем шаг назад и подумаем. Мы действительно не знаем конкретный возвращаемый тип `wc`, но нам это и не нужно! Достаточно того, что его можно показать пользователю. Иными словами, нам важно только то, что мы можем, например, преобразовать его в строку при помощи `show`, для чего достаточно добавить констрейнт, что `res` реализует `Show`:
```
data SomeStats where
MkSomeStats :: (Statistic s res st comp, Show res) => proxy s -> SomeStats
```
Тогда `wc` будет выглядеть примерно так:
```
wc' :: SomeStats -> BS.ByteString -> String
wc' (MkSomeStats (_ :: proxy s)) input = show $ wc @s input
```
и это корректно типизированный код.
Хорошо, но как теперь преобразовать наш список `stats` в `SomeStats`? Давайте начнём с промоутинга базовых статистик:
```
promoteStat :: Statistics -> SomeStats
promoteStat Bytes = MkSomeStats (Proxy :: Proxy 'Bytes)
promoteStat Chars = MkSomeStats (Proxy :: Proxy 'Chars)
promoteStat Words = MkSomeStats (Proxy :: Proxy 'Words)
promoteStat MaxLL = MkSomeStats (Proxy :: Proxy 'MaxLL)
promoteStat Lines = MkSomeStats (Proxy :: Proxy 'Lines)
```
Довольно уродливо, да и грустно, что нужно вручную перечислить все значения типа `Statistics`, но таково ограничение системы типов хаскеля. Вот тебе и эрзац-зависимые типы: несмотря на то, что *терм* `Bytes` и (запромоученный) *тип* `'Bytes` выглядят одинаково, тайпчекер их считает совершенно разными сущностями без всякой связи между ними, и нам приходится устанавливать эту связь вручную.
В любом случае, с этим нашим `promoteStat` теперь можно пройтись и по всему списку целиком:
```
promoteStats :: [Statistics] -> SomeStats
promoteStats [s] = promoteStat s
promoteStats (s:ss) =
case (promoteStat s, promoteStats ss) of
(MkSomeStats (_ :: proxy1 st), MkSomeStats (_ :: proxy2 sst))
-> MkSomeStats (Proxy :: Proxy (st '::: sst))
```
Для списка, состоящего из одного элемента, мы просто используем функцию `promoteStat`.
Если же список состоит из двух и более элементов, то всё куда интереснее. Сначала всё относительно стандартно для рекурсивных функций: голову мы промоутим при помощи того же `promoteStat`, а хвост обрабатываем рекурсивным вызовом `promoteStats`. Дальше их надо как-то совместить, и здесь начинается лёгкая магия. Мы матчимся по результатам вызовов `promoteStat` и `promoteStats`, привязывая переменную *типа* `st` к типу, соответствующему голове списка, а `sst` — к типу, соответствующему хвосту.
Мы ничего не знаем об этих типах кроме того, что они реализуют класс `Statistic` (так как это требуется констрейнтом в соответствующем конструкторе экзистенциального типа). Но если они реализуют `Statistic`, то и `st ::: sst` реализует `Statistic` как раз из-за комбинирующего инстанса, который мы написали выше! Кроме того, мы знаем, что `rest` и `resst` (некоторые воображаемые безымянные переменные типов, соответствующие результатам статистик `st` и `sst`) реализуют `Show`. Поэтому можно вывести, что `rest ::: resst` также реализует `Show`, а это ровным счётом тип результата статистики `st ::: sst`!
Короче, в итоге получается, что выражение `MkSomeStats (Proxy :: Proxy (st '::: sst))` вполне корректно типизировано. И очень круто, что тайпчекер может это всё сам вывести!
Кстати, это не тотальная функция: мы не обрабатываем случай пустого списка опций. С другой стороны, он у нас никогда и не возникнет, а использование вещей вроде `NonEmpty` усложнит изложение без всякой видимой выгоды.
Как бы там ни было, пользоваться этой функцией легко:
```
main :: IO ()
main = do
-- obtaining `stats` as before
forM_ files $ \path -> do
contents <- unsafeMMapFile path
putStrLn $ wc' (promoteStats stats) contents
```
### Чудеса производительности
Насколько (не)эффективен этот подход?
Если посчитать только строки, то мы получим многообещающие 1.05 секунд — ровно столько же, сколько занимает `BS.count 10`.
Но это чанковая статистика, обрабатывающая весь вход за раз. Как насчёт побайтовых статистик, например, числа слов? Запускам, получаем… 14 секунд вместо полутора.
Чёрт, **14 секунд**.
И, кстати, оно жуёт память как бешеное:
```
74,873,139,008 bytes allocated in the heap
```
Я не проводил систематических замеров аллокаций для прошлых версий, но это число всегда было меньше мегабайта. Ну, хотя бы эта версия всё ещё  по памяти — большинство аллокаций почти сразу умирают в нулевом поколении GC (`60,512 bytes maximum residency`).
Ладно. Что, если мы посчитаем и слова, и строки? **27 секунд**, 120 гигабайт аллоцировано.
Что насчёт слов, строк и байт? Можете угадать?
Если вы сказали «42 секунды», то можете съесть пирожок: оно выполняется 41 секунду и аллоцирует 194 гигабайта. Ну, *максимальное* потребление памяти согласно RTS хотя бы всё ещё в районе 60 килобайт.
Почему всё так плохо?
Ну, когда мы пишем такую функцию:
```
wc' (MkSomeStats (_ :: proxy s)) input = show $ wc @s input
```
тогда *компилятор* никак не может знать, какой `computation` связан с данной конкретной `s` — это исключительно рантайм-свойство, известное только после того, как пользователь сделает свой выбор. Поэтому у компилятора нет другого выхода, кроме как скомпилировать это в прямую передачу словаря методов класса `Statistic` и вызова методов этого словаря по указателю без какого бы то ни было инлайнинга.
Так что конкретно здесь происходит?
Функция `wc'` получает указатель на функцию `computation`, обёрнутый в значение экзистенциального типа `SomeStats` и передаёт этот указатель дальше функции `wc`, которая вызывает функцию по этому указателю *для каждого входного байта*. Никакого инлайнинга, никаких связанных с этим оптимизаций, никаких горячих циклов, а вместо этого всего вызов функции на каждой итерации. То есть, это примерно 1.8 миллиардов вызовов — конечно же это будет медленно!
При этом вызывающая сторона ответственна за упаковку всех нужных указателей в экзистенциальный тип при помощи функции `promoteStats`. Как именно она это делает?
Например, если `stats` состоит из единственного элемента, то используется уравнение
```
promoteStats [s] = promoteStat s
```
и если `s` оказывается, например, `Words`, то `promoteStat` вычисляется согласно уравнению
```
promoteStat Words = MkSomeStats (Proxy :: Proxy 'Words)
```
В итоге `promoteStats` заворачивает в `SomeStats` указатели на методы, соответствующие реализации `Statistic` для `Words`.
Но это простой случай. Что происходит, если в дело вступает второе уравнение?
```
promoteStats (s:ss) =
case (promoteStat s, promoteStats ss) of
(MkSomeStats (_ :: proxy1 st), MkSomeStats (_ :: proxy2 sst)) -> MkSomeStats (Proxy :: Proxy (st '::: sst))
```
Тогда указатель на фукнцию `computation` строится примерно следующим образом: `case` в правой части уравнения извлекает указатели из того, что вернули `promoteStat` и рекурсивный вызов `promoteStats`, и, если упрощать, передаёт их функции `computation` реализации `Statistic` для «индуктивного» случая `sa ::: sb`, которая, в свою очередь, вызывает функции по этим указателям один за другим.
Поэтому если список опций состоит из двух статистик, мы платим оверхед в 13-14 секунд дважды, и общее время выполнения должно быть в районе 28 секунд — ровно как мы и наблюдали. А если бы мы выбрали все пять статистик, то время работы было бы 65-70 секунд.
Так что понимание того, как работают экзистенциальные типы (да и вообще стирание типов) позволяет заранее ожидать исключительно хреновую производительность такого подхода.
Кстати, мы заодно можем оценить стоимость вызова функции. Оверхед составляет 13 секунд (14 секунд на всё минус 1 секунда на бизнес-логику) на 1.8 миллиардов вызовов — то есть, примерно 7 наносекунд на вызов. Звучит разумно.
Уродливый подход
----------------
Однако это упражнение с экзистенциальными типами позволяет нам ограничить пространство возможных решений: мы хотим убедиться, что компилятор видит точный (мономорфизированный) тип `wc` в каждой точке вызова. В идеале у нас бы было что-то вроде
```
main = do
-- ..
case stats of
[Words] -> print $ wc @'Words contents
[Bytes] -> print $ wc @'Bytes contents
[Lines] -> print $ wc @'Lines contents
[Words, Bytes] -> print $ wc @('Words '::: 'Bytes) contents
[Lines, Bytes] -> print $ wc @('Lines '::: 'Bytes) contents
-- ...
```
и так далее. Но даже если у нас всего лишь пять возможных статистик, то школьная комбинаторика говорит нам, что у нас будет  ветка в `case`. Понятно, что писать их все — не выход.
Вот только компилятор может нам помочь их написать, для чего нам придётся прибегнуть к Template Haskell. Мы напишем (мета-)функцию `dispatch`, которая будет использоваться так:
```
contents <- unsafeMMapFile path
putStrLn $ $(dispatch 'wc 'contents) stats
```
Здесь `$(dispatch 'wc 'contents)` создаёт функцию, которая делает `case`-анализ `stats` примерно так же, как приведённый чуть выше пример.
Написание `dispatch` — довольно техническое упражнение в Template Haskell, поэтому я просто покажу, что в итоге получается:
```
dispatch :: Name -> Name -> Q Exp
dispatch fun bs = reify ''Statistics >>= \case
TyConI (DataD _ _ _ _ cons _) -> do
let consNames = [ name | NormalC name _ <- cons ]
let powerset = filterM (const [True, False]) consNames
let matches = buildMatch fun bs <$> filter (not . null) powerset
fallbackMatch <- (\body -> Match WildP (NormalB body) []) <$> [e| error "Unexpected input" |]
pure $ LamCaseE $ matches <> [fallbackMatch]
_ -> fail "unsupported type"
buildMatch :: Name -> Name -> [Name] -> Match
buildMatch fun bs consNames = Match (ListP $ (`ConP` []) <$> consNames) (NormalB $ VarE 'show `AppE` (wcCall `AppE` VarE bs)) []
where
wcCall = VarE fun `AppTypeE` foldr1 f (PromotedT <$> consNames)
f accTy promotedTy = PromotedT '(:::) `AppT` accTy `AppT` promotedTy
```
Если совсем вкратце, то мы узнаём все конструкторы типа `Statistics` (поэтому, кстати, добавить новые статистики будет очень легко), и для каждого непустого подмножества множества конструкторов (то есть, для каждого непустого элемента в `powerset`) мы строим отдельную `case`-ветку при помощи `buildMatch`. Все построенные ветки мы заворачиваем в один большой лямбда-`case` (с расширением `{-# LANGUAGE LambdaCase #-}`).
Кстати, довольно забавно, что тут мы можем немного подзабить на корректную обработку ошибок и тотальность функций, так как всё равно этот код будет выполняться во время компиляции, и все возможные ошибки вылезут тогда же.
Единственная вещь, которая немного меня коробит (ну, кроме использования TH) — получаемая функция ожидает, что массив `stats` будет отсортированным. Можно оправдать это ожидание двумя способами. С одной стороны, мы можем аккуратно выбрать порядок элементов в списке
```
let selectedStats = map snd $ filter fst [ (countBytes, Bytes), (countChars, Chars)
, (countWords, Words), (countMaxLineLength, MaxLL)
, (countLines, Lines)
]
```
согласно порядку, порождаемому сгенерированной компилятором реализацией `Ord`. С другой стороны, мы можем просто явно сортировать список `stats`. Оба подхода вполне работают, однако второй чуть чище и надёжнее, а потери в производительности из-за сортировки `stats`, очевидно, пренебрежимо малы.
Давайте теперь сложим все кусочки вместе!
```
main :: IO ()
main = do
Options { .. } <- execParser $ info (options <**> helper) (fullDesc <> progDesc "Print newline, word, and byte counts for each file")
let selectedStats = map snd $ filter fst [ (countBytes, Bytes), (countChars, Chars)
, (countWords, Words), (countMaxLineLength, MaxLL)
, (countLines, Lines)
]
let stats | null selectedStats = [Bytes, Words, Lines]
| otherwise = selectedStats
forM_ files $ \path -> do
contents <- unsafeMMapFile path
putStrLn $ $(dispatch 'wc 'contents) stats
```
### Окончательная производительность
Насколько хорошо работает этот подход? Я не буду проверять все комбинации параметров (31 вариант — слишком много), поэтому выберу какое-то случайное их подмножество. Кроме того, в этот раз я снова возьму `wc` из GNU Coreutils в качестве некоторой базовой точки, чтобы привязать эти измерения хоть к чему-то. Бенчмаркинг производится так же, как и всегда: каждый тест запускается 5 раз на тестовом файле в 1.8 гигабайт, и рассматривается минимальное время в юзерспейсе. `wc` из Coreutils запускается с переменными окружения `LC_ALL=C LANG=C`, если не указано иное.
Вот результаты:
| Слова | Байты | Строки | Символы | Длина строки | Haskell `wc`, с | Coreutils `wc`, с |
| --- | --- | --- | --- | --- | --- | --- |
| | ✓ | | | | 0.00 ¹ | 0.00 ¹ |
| ✓ | | | | | 1.54 | 12.5 |
| ✓ | ✓ | | | | 1.20 | 12.5 |
| | | ✓ | | | 1.06 / 0.24 ² | 0.26 |
| ✓ | ✓ | ✓ | | | 1.52 | 12.5 |
| | | | ✓ | | 1.42 | 8.45 ³ |
| | | | | ✓ | 2.21 | 12.5 |
| ✓ | | | | ✓ | 2.92 | 12.5 |
Некоторые наблюдения и замечания:
* Мне всё ещё рвёт шаблон, что подсчёт байт *и* слов быстрее, чем подсчёт одних лишь слов.
* Похоже, что версия на C всегда считает некоторый базовый набор статистик (слова, байты, строки и максимальную длину строк) если включён либо подсчёт строк, либо подсчёт максимальной длины. Я не удивлён.
* ¹ Да, `time` буквально показывает `0.00user` для обоих программ в случае подсчёта байт.
* ² Первое число для подсчёта байт и строк (1.06 секунд) — результат с апстримовой библиотекой `bytestring`. Второе число — с пропатченной `bytestring`, где функция подсчёта количества вхождений символа (`count`) оптимизирована с использованием SIMD-интринсиков. По иронии судьбы оригинальная `count` реализована на C, и, что снова иронично, комплиятор не может её оптимизировать достаточно хорошо, и даже чистая реализация на хаскеле была бы быстрее (хотя и не настолько быстро, как с ручными оптимизациями и SIMD), но всю эту иронию лучше оставить для другого поста.
* ³ Здесь `wc` запускается с UTF-8-локалью, так как иначе он понимает, что число символов равно числу байт, и работает за константное время, тогда как мы хотим измерить скорость подсчёта UTF-8-символов.
На мой взгляд, вполне себе неплохие результаты.
Всякие мелочи
=============
Наша программа может обрабатывать опции командной строки, она поддерживает те же статистики, что и `wc`, она может обрабатывать несколько файлов. Что ещё можно добавить?
Параллелизм
-----------
Это легко: мы просто заменяем `forM_` на `forConcurrently_` из библиотеки [async](http://hackage.haskell.org/package/async-2.2.2/docs/Control-Concurrent-Async.html#v:forConcurrently_):
```
main :: IO ()
main = do
Options { .. } <- execParser $ info (options <**> helper) (fullDesc <> progDesc "Print newline, word, and byte counts for each file")
let selectedStats = map snd $ filter fst [ (countBytes, Bytes), (countChars, Chars)
, (countWords, Words), (countMaxLineLength, MaxLL)
, (countLines, Lines)
]
let stats | null selectedStats = [Bytes, Words, Lines]
| otherwise = selectedStats
forConcurrently_ files $ \path -> do
contents <- unsafeMMapFile path
putStrLn $ $(dispatch 'wc 'contents) stats
```
Теперь программа будет обрабатывать одновременно столько же файлов, сколько у нас есть ядер (вернее, сколько ядер разрешили использовать хаскелевскому RTS, что по умолчанию равно полному числу ядер). Если бы нас это не устраивало, то можно было бы добавить ещё одну опцию типа `-j`, но это не так уж сложно и предлагается в качестве упражнения читателю.
Каков оверхед этого параллелизма?
Подсчёт слов и байт в одном тестовом файле займёт 1.22 секунд — почти как последовательная версия, хоть и дисперсия значений в этом случае будет повыше.
Если же мы запустим эту программу, скормив ей наш тестовый файл шесть раз (по числу физических ядер в моей машине), то время работы будет равно 1.47 секунд, но с ещё более существенной дисперсией. Думаю, что в этом случае всё упирается в шину данных.
Красивая печать
---------------
Если мы сейчас запустим нашу программу, то она распечатает результат в виде
```
Tagged 123 ::: (Tagged 456 ::: Tagged 789)
```
Это не очень дружественно к пользователю, так что давайте это исправим! Проще всего добавить специальный метод в класс `Statistic`:
```
class Statistic s res st comp | res -> s, st -> s
, s -> res, s -> st, s -> comp where
-- ...
prettyPrint :: res -> String
```
Его реализация для базовых статистик проста, например:
```
instance Statistic 'Bytes (Tagged 'Bytes) (Tagged 'Bytes) 'Chunked where
-- ...
prettyPrint (Tagged n) = show n <> " bytes"
```
Для комбинации статистик тоже ничего сложного, просто чуть больше писанины:
```
prettyPrint (a ::: b) = prettyPrint a <> "\n" <> prettyPrint b
```
Мы также должны обновить нашу функцию `buildMatch`, чтобы она использовала `prettyPrint` вместо `show`:
```
buildMatch fun bs consNames = Match (ListP $ (`ConP` []) <$> consNames) (NormalB $ VarE 'prettyPrint `AppE` (wcCall `AppE` VarE bs)) []
```
И всё!
Больше видов входных данных
---------------------------
Пока что наша реализация предполагает, что входной файл всегда можно `mmap`нуть. Однако, так происходит не всегда: например, наша реализация сломается в случае `hwc <(cat foo | grep bar)`.
Это можно исправить, проверяя, является ли путь обычным файлом или символьной ссылкой — их-то `mmap`ить можно. Мы будем осторожны и не будем даже пытаться `mmap`ить все остальные виды путей. Вместо этого мы будем их считывать в *ленивую* `ByteString`, чтобы пространственная сложность всё ещё была константной. А ленивая `ByteString` — это практически список строгих чанков, так что мы можем по ним просто свернуться в случае чанковых вычислений:
```
import qualified Data.ByteString.Lazy as BSL
wcLazy :: forall s res st comp. Statistic s res st comp => BSL.ByteString -> res
wcLazy s = extractState $! runCompute computation
where
runCompute :: StatComputation st comp -> st
runCompute (ByteOnlyComputation step) = BSL.foldl' step initState s
runCompute (ChunkedComputation _ chunker) = BSL.foldlChunks chunker initState s
```
Теперь мы можем модифицировать наш `main`:
```
forConcurrently_ files $ \path -> do
stat <- getFileStatus path
if isRegularFile stat || isSymbolicLink stat
then countStrict stats $ unsafeMMapFile path
else countLazy stats $ BSL.readFile path
```
где мы добавили две маленьких вспомогательных функции:
```
where
countStrict stats act = do
contents <- act
putStrLn $ $(dispatch 'wc 'contents) stats
countLazy stats act = do
contents <- act
putStrLn $ $(dispatch 'wcLazy 'contents) stats
```
И всё!
Заметим, что на самом деле вместо добавления функции `wcLazy` мы могли бы создать ещё один тайпкласс, описывающий тип входной строки, но так как их предполагается всего две и больше не будет, то пользы от этого мало.
Поддержка stdin
---------------
Ещё одна вещь, которую умеет Coreutils `wc`, но не умеет наша версия — поддержка `stdin`. Исправить это просто, добавив проверку в конец `main`:
```
main = do
-- ... as before ...
when (null files) $ countLazy stats BSL.getContents
```
Теперь можно делать что-то вроде
```
cat testfile.txt | /usr/bin/time hwc-exe -cw
```
Насколько хуже такой подход с точки зрения производительности? Ну, например, вышеприведённая команда выполняется за 1.40 секунд — то есть, разница с 1.22 секундами ранее вполне себе заметна.
Время компиляции и распухание кода
----------------------------------
Здесь я действительно придираюсь, но давайте это тоже упомянем ради какой-никакой объективности: каков оверхед всего этого метапрограммирования? Мы можем говорить либо о времени компиляции, либо о размере получающегося файла, так что давайте рассмотрим обе эти метрики!
Если мы пойдём по «зависимо типизированной» дороге (которую можно считать чем-то вроде базы в этом случае), то `stack build` займёт 7.9 секунд для всего проекта, и размер результирующего бинарника окажется равен 2.24 мегабайта (после `strip`).
Подход с Template Haskell компилируется ровно втрое дольше: 23 секунды. С другой стороны, бинарник и не распух толком (особенно учитывая 31 вариант вызова функции): его размер стал 2.34 мегабайта, разница — 4.3%.
Хотя… Во время обычной разработки никто не делает `stack build` (так как это сборка с оптимизациями). `stack build --fast` может оказаться куда быстрее.
«Зависимо типизированная» реализация компилируется за 5.6 секунд с `--fast`, тогда как версия с TH собирается за… 7.8 секунд. Тут уже разница не такая уж и большая. С этим можно жить.
И я знаю, что для части разработчиков это очень важный фактор, так что давайте сравним время компиляции в релизном режиме и размер бинарника с C. Как и ожидалось, хаскель здесь сливает подчистую: на моей машине `wc` из GNU Coreutils компилируется за 0.06 секунд, и результирующий размер бинарника — 21 килобайт. Бинарник `wc` с убунты занимает 24 килобайта. В 100 раз меньше, чем хаскель!
Ну, другие мелочи и придирки мне в голову не пришли, так что давайте закругляться и переходить к заключению.
Заключение
==========
Что у нас получилось? Если вкратце, то мы привели наш исходный прототип `wc` к виду, который куда больше напоминает стандартные Unix-утилиты, и теперь наш хаскель-`wc` готов для того, чтобы использоваться вместо GNU Coreutils `wc`. Самое главное — он поддерживает пользовательские опции (и больше разных статистик!), да так, что он считает лишь то, что пользователю на самом деле нужно посчитать, при этом с околонулевым оверхедом на модуляризацию. Забавно, что в каком-то смысле у нас довольно легко получилось куда ближе следовать принципу «не платить за то, что не используешь», так милому сердцам программистов на C и C++, чем в случае реализации на C.
Если более подробно, то мы:
1. разделили наш изначальный прототип `wc` на набор маленьких, изолированных, тестируемых и композабельных кусочков, по одному на статистику;
2. научились совмещать эти кусочки вместе;
3. написали тесты для статистик по отдельности, будучи уверенными, что вместе они тоже будут работать правильно в любых комбинациях по построению;
4. попытались считать только то, что выбрал пользователь, используя техники, вдохновлённые зависимыми типами, и полюбовались, как красочно и громко эти техники сливают с точки зрения производительности в случае хаскеля;
5. преодолели все проблемы с производительностью обработки опций командной строки при помощи Template Haskell;
6. проверили, что результат весьма близок с точки зрения производительности к нашей изначальной реализации, так что вся эта модульность не имеет существенного влияния на производительность;
7. реализовали несколько других мелких фич, от параллельной обработки файлов до поддержки стандартного входа.
Такие дела.
А, ну и стоит упомянуть ещё две вещи:
1. Наш подход с полузависимыми типами не обязательно нежизнеспособен. Мы могли бы, например, вызывать каждый обработчик не на каждый байт, а на каждые 16-32 килобайта (по размеру кэша L1). Нетрудно подсчитать, что для стоимости вызова функций в 7 наносекунд, времени работы в районе секунды и размере файла в 1.8 гигабайт это дало бы оверхед в 0.4 мс, или 0.04%. Но тогда бы нам не пришлось играться с Template Haskell!
2. Наша реализация всё равно не является полным эквивалентом `wc`, кое-что она делает по-другому. Например, статистика подсчёта символов не поддерживает кодировки, отличные от UTF-8 или ASCII, тогда как `wc` работает с произвольной локалью, делегируя всю работу по обработке символов glibc. Но так как наша реализация позволяет очень легко добавлять новые статистики, довольно просто добавить поддержку чего-то подобного, и, что самое главное — это не повлияет на, скажем, подсчёт количества строк или слов. Но про «не платить за то, что не используешь» я уже писал чуть выше. | https://habr.com/ru/post/496370/ | null | ru | null |
# Как работать с библиотекой sktime: разбираемся на примере прогнозирования продаж
Одна из самых популярных задач прогнозирования временных рядов — это прогнозы продаж для торговли. Чтобы построить базовую модель, можно подключить несколько библиотек и написать под них свою обертку, а можно работать с уже готовым фреймворком. Здесь я расскажу, как использовать одно из таких решений.
Здравствуй, Хабр! Меня зовут Когай Алексей, я работаю руководителем отдела машинного обучения в СберМегаМаркете. В зону нашей ответственности входит внедрение машинного обучения во все процессы компании.
Нам в СберМегаМаркете очень важно понимать спрос на товары как на этапе заведения карточек, чтобы оперативнее завести на платформу товары, на которые есть высокий спрос, так и на этапе активных продаж, чтобы мы и наши любимые продавцы могли удобно и гибко планировать поставки на склады. Также модель прогнозирования спроса помогает оценивать эффект от уже проведенных промоакций и планировать нагрузку и численность курьеров в случае доставки товаров курьерами.
Как-то раз половину нашего склада заселили роботы-пылесосы. Собирались ли они в ближайшее время разъезжаться по домам, — никто не знал. Точный и простой инструмент прогнозирования спроса тут очень бы пригодился. Понимание объемов будущих продаж важно и для наших нужд, и для многочисленных продавцов маркетплейса — склады гарантируют им только 60 дней бесплатного хранения товара.
Сразу после запуска площадки прогнозирование в СберМегаМаркете работало на оценках экспертов. Все планировалось исходя из «завтра будет то же, что и вчера». Это в то время, как для таких прогнозов создают сложные модели, которые требуют учета нескольких сотен факторов и огромных вычислительных ресурсов.
Мы решили, что для начала сделаем проще и быстрее. Зачастую, все эти сложные вычисления увеличивают качество моделей всего на пару процентов по сравнению с базовыми. Поэтому я стал искать готовый фреймфорк и нашел его на github — это библиотека [sktime](https://github.com/alan-turing-institute/sktime).
Здесь я хочу рассказать, как ее использовать: в русскоязычном интернете информации по sktime ничтожно мало. На Хабре есть [статья](https://habr.com/ru/company/otus/blog/511782/), но это перевод, а не мануал на основе личного опыта.
Я разбирался с библиотекой несколько дней, а по инструкции ниже вы сможете сделать то же самое за 15 минут. Для работы со sktime нужны только базовые навыки программирования на Python.
Уверен, что использование sktime сэкономит время тем, кто, как и мы, ищет простой и надежный инструмент прогнозирования спроса и при этом не готов писать свою обертку поверх библиотек.
Добавлю, что я нашел несколько решений. Аналогичные фреймворки – [Merlion](https://github.com/salesforce/Merlion) или [Etna от Tinkoff,](https://etna.tinkoff.ru/) – вероятно, делают все то же самое. Я остановился на sktime просто потому, что у нее было больше звездочек на github.
Для начала установим все необходимое:
```
import pandas as pd
import pyodbc
import numpy as np
import warnings
warnings.filterwarnings("ignore")
%matplotlib inline
```
### Загрузка данных
Чем больше у вас данных, тем лучше. Как минимум нужно, чтобы модель видела сезонность: если у вас недельная сезонность, нужны несколько недель, месячная сезонность — несколько месяцев. Считается, что для корректной работы подобных моделей требуется полтора года наблюдений, чтобы увидеть все сезоны не один раз.
```
def load(file, good="Продукты питания"):
data = pd.read_csv(file)
data.columns = ["ts", "good", "cnt"]
data = data.sort_values("ts")
data["ts"] = pd.to_datetime(data["ts"]).dt.to_period("d")
y = data.loc[data.good == good, ["ts", "cnt"]].set_index("ts").squeeze()
return y
my_df = load()
```
### Форматы данных
На вход sktime необходимо подать pandas датафрейм:
* pd.Series для простых последовательностей;
* pd.DataFrame для нескольких последовательностей.
При этом время должно быть в индексе Series.index и DataFrame.index.
Например:
```
data["ts"] = pd.to_datetime(data["ts"]).dt.to_period("d")
y = my_data.loc[my_data.good == good, ["ts", "cnt"]].set_index("ts").squeeze()
```
Для простого прогноза необходимо только указать горизонт прогнозирования и передать его алгоритму прогнозирования.
Есть два основных способа задать горизонт прогноза:
* использование numpy.array, состоящего из целых чисел. Например, «1» означает прогноз на следующий период, «2» второй следующий период и так далее;
* использование объекта ForecastingHorizon. Его можно использовать для определения горизонтов прогноза, используя в качестве аргумента любой поддерживаемый тип индекса.
Горизонты прогнозирования могут быть абсолютными, то есть привязанными к конкретным временным точкам в будущем, или относительными — привязанными к разнице во времени в настоящем. По умолчанию настоящее — это последняя точка времени, видимая в любом «y», переданном модели прогноза.
Горизонты прогнозирования на основе numpy.array всегда относительны. В то время как объекты ForecastingHorizon могут быть как относительными, так и абсолютными. В частности, абсолютные горизонты прогнозирования могут быть заданы только с помощью ForecastingHorizon.
#### Первый способ с numpy.array
```
fh = np.arange(1, 7) # неделя
fh
Out:
array([1, 2, 3, 4, 5, 6])
```
#### Второй способ на основе ForecastingHorizon
Объект ForecastingHorizon принимает абсолютные индексы в качестве входных данных, но считает входные данные абсолютными или относительными в зависимости от флага is\_relative.
```
from sktime.forecasting.base import ForecastingHorizon
fh = ForecastingHorizon(
pd.PeriodIndex(pd.date_range("2021-10-01", periods=30, freq="D")), is_relative=False
)
fh
ForecastingHorizon(['2021-10-01', '2021-10-02', '2021-10-03', '2021-10-04',
'2021-10-05', '2021-10-06', '2021-10-07', '2021-10-08',
'2021-10-09', '2021-10-10', '2021-10-11', '2021-10-12',
'2021-10-13', '2021-10-14', '2021-10-15', '2021-10-16',
'2021-10-17', '2021-10-18', '2021-10-19', '2021-10-20',
'2021-10-21', '2021-10-22', '2021-10-23', '2021-10-24',
'2021-10-25', '2021-10-26', '2021-10-27', '2021-10-28',
'2021-10-29', '2021-10-30'],
dtype='period[D]', is_relative=False)
```
#### Определение алгоритма прогнозирования
Для составления прогнозов необходимо указать алгоритм прогнозирования. Все модели sktime используют один и тот же интерфейс, поэтому шаги будут одинаковы независимо от выбранной модели.
Для первого примера берем наивный метод прогнозирования, предсказывающий последнее увиденное значение.
```
from sktime.forecasting.naive import NaiveForecaster
forecaster = NaiveForecaster(strategy="last")
```
Теперь модель нужно обучить на наших данных:
```
forecaster.fit(y)
```
Наконец, мы запрашиваем прогнозы для указанного горизонта прогнозирования. Это необходимо сделать после обучения модели:
```
y_pred = forecaster.predict(fh)
plot_series(y.tail(60), y_pred, labels=["y", "y_pred"])
```
#### Собираем все в одном месте с другой моделью
```
from sktime.forecasting.base import ForecastingHorizon
from sktime.forecasting.naive import NaiveForecaste
```
```
y = load_df()
fh = np.arange(1, 7) # горизонт прогноза
forecaster = NaiveForecaster(strategy="last", sp=7) # sp=7 отвечает за период сезонности
forecaster.fit(y) # обучение
y_pred = forecaster.predict(fh) #предсказание
plot_series(y.tail(30), y_pred, labels=["y", "y_pred"]) #отрисовка предсказаний
```
Оценка качества модели на тестовом множестве
--------------------------------------------
Хорошей практикой является оценка качества модели перед внедрением. Процесс оценки для базовой задачи прогнозирования основан на сравнении факта с прогнозом на отложенной выборке.
Деление на train и test в sktime происходит функцией temporal\_train\_test\_split
```
from sktime.forecasting.model_selection import temporal_train_test_split
y = load_df()
y_train, y_test = temporal_train_test_split(y, test_size=7)
```
Чтобы сделать прогноз на тесте — надо передать их в fh
```
fh = ForecastingHorizon(y_test.index, is_relative=False)
forecaster = NaiveForecaster(strategy="last", sp=7)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
```
#### Выбираем и считаем ds метрику качества, чтобы оценить качество модели
Метрики могут быть вызваны двумя способами:
* при помощи функции: например, mean\_absolute\_percentage\_error, которая является функцией python (y\_true : pd.Series, y\_pred : pd.Series) -> float.
* с использованием класса: например, MeanAbsolutePercentageError, который является классом python.
Для моих целей хватает функции, но для создания своей кастомной метрики проще использовать интерфейс класса.
```
from sktime.performance_metrics.forecasting import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred)
Out:
0.1891887216729895
from sktime.performance_metrics.forecasting import MeanAbsolutePercentageError
mape = MeanAbsolutePercentageError(symmetric=False)
mape(y_test, y_pred)
Out:
0.16798576229936724
```
#### Оцениваем качество не на одном отрезке, а на кросс-валидации
Чтобы оценить эффективность модели, необходимо протестировать ее в условиях, имитирующих скользящее прогнозирование, то есть на прошлых данных. Для этого мы делаем прогнозы каждые N дней и сравниваем с фактическими значениями нужное нам число раз.
Кросс-валидация временных рядов вызывается функцией evaluate. Функция evalute принимает в качестве аргументов:
* forecaster — модель, которая будет оцениваться;
* тип кросс-валидации — ExpandingWindowSplitter — расширяющееся окно или SlidingWindowSplitter — скользящее окно;
* strategy: должна ли модель переобучаться или нет.
```
from sktime.forecasting.arima import AutoARIMA
from sktime.forecasting.model_evaluation import evaluate
from sktime.forecasting.model_selection import ExpandingWindowSplitter
forecaster = AutoARIMA(sp=7, suppress_warnings=True)
```
```
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df = evaluate(forecaster=forecaster, y=y, cv=cv, strategy="refit", return_data=True)
df.iloc[:, :5].head()
```
Как видим, на выходе получаем оценку качества для каждой точки прогноза и прочие данные, залогированные в процессе обучения.
Модели sktime
-------------
Основные модели, которые в настоящее время стабильно поддерживаются и достойны внимания:
* autoETS (экспоненциальное сглаживание) – автоподбор параметров на основе пакета из R;
* ThetaForecaster (Двойное экспоненциальное сглаживание) – с учетом тренда;
* ExponentialSmoothing (*Holt Winter's Exponential Smoothing из statsmodels) (*Тройное экспоненциальное сглаживание*) – учитывается тренд и сезонность;*
* autoARIMA из pmdarima.arima (подход тюнинга из R пакета);
* BATS и TBATS из tbats;
* PolynomialTrend (Полиномиальная регрессия);
* Prophet (Facebook) <-- не удалось запустить из этого пакета
[Метод экспоненциального сглаживания](https://www.researchgate.net/publication/256088917_The_Simple_Exponential_Smoothing_Model) или метод Брауна используются в задачах сглаживания и краткосрочного прогнозирования временных рядов. С его помощью удобно определять параметры, основанные на предварительных предположениях, например, сезонности. Прогноз строится на основе экспоненциально взвешенного среднего значения прошлых наблюдений. Наибольший вес имеет текущее наблюдение, меньший — непосредственно предшествующее, еще меньший — предшествующее и так далее (экспоненциальный спад влияния прошлых данных).
Метод [ThetaForecaster](https://www.sktime.org/en/v0.4.2/modules/auto_generated/sktime.forecasting.theta.ThetaForecaster.html) эквивалентен простому экспоненциальному сглаживанию со сдвигом. AutoETS — это модель [ETS](https://economics.hse.ru/cmf/models_ETS) с возможностью автоматической и ручной подгонки.
```
from sktime.forecasting.exp_smoothing import ExponentialSmoothing
forecaster = ExponentialSmoothing(trend="add", seasonal="additive", sp=7)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.053853603447200867
```
Экспоненциальное сглаживание:
```
from sktime.forecasting.ets import AutoETS
forecaster = AutoETS(auto=True, sp=7, n_jobs=-1)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
```
#### ARIMA и autoARIMA
Очень популярный статистический метод для прогнозирования временных рядов — [ARIMA или модель Бокса-Дженкинса](https://economics.hse.ru/data/2018/10/27/1141902040/ARIMA.pdf?ysclid=l195bra55y), показывает временной ряд на основе его предыдущих значений. Ее ошибки в прогнозе и их выравнивание можно использовать при прогнозировании будущих значений. С помощью ARIMA можно моделировать любые временные ряды, которые не являются сезонными, но демонстрируют закономерности, а не случайный белый шум.
```
from sktime.forecasting.arima import ARIMA
forecaster = ARIMA(
order=(1, 1, 0), seasonal_order=(0, 1, 0, 12), suppress_warnings=True
)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.13533986188456024
```
Auto ARIMA — это автоматически настроенный вариант ARIMA, который автоматически тюнит оптимальные параметры pdq:
```
from sktime.forecasting.arima import AutoARIMA
forecaster = AutoARIMA(sp=7, suppress_warnings=True)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.17885134346968692
```
Код вывода параметров:
```
forecaster.get_fitted_params()
Out:
{'ma.L1': -0.2038453053903969,
'ma.L2': -0.1441666812511294,
'ma.L3': -0.23627171390104673,
'ma.L4': -0.3026076973570091,
'ma.L5': 0.224013743590569,
'ar.S.L7': -0.018592736391196907,
'ar.S.L14': 0.935502948183107,
'ma.S.L7': 0.15199580326139103,
'ma.S.L14': -0.5445850041741789,
'sigma2': 4097899.2621635236,
'order': (0, 1, 5),
'seasonal_order': (2, 0, 2, 7),
'aic': 5359.428005725823,
'aicc': 5360.202653613147,
'bic': 5396.297759289221,
'hqic': 5374.1915764254845}
```
#### BATS и TBATS
Модель TBATS
* Trigonometric
* Box-Cox transformation
* ARMA
* Trend
* Seasonality
TBATS модели [разработаны](https://economics.hse.ru/data/2018/10/27/1141902074/TBATS.pdf) De Livera, Hyndman, Snyder (2011). Данный подход использует комбинацию из рядов Фурье, модель пространства состояний с экспоненциальным сглаживанием, а также преобразование Бокса-Кокса. Причем выбор параметров осуществляется полностью автоматизированным образом.
```
from sktime.forecasting.bats import BATS
forecaster = BATS(sp=7, use_trend=True, use_box_cox=False)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.14246762153645254
```
```
from sktime.forecasting.tbats import TBATS
forecaster = TBATS(sp=7, use_trend=True, use_box_cox=False)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train.tail(60), y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.12760278368723751
```
Запускаем расчет ряда моделей с кросс-валидацией по времени
-----------------------------------------------------------
```
from sktime.forecasting.arima import AutoARIMA
from sktime.forecasting.model_evaluation import evaluate
from sktime.forecasting.model_selection import ExpandingWindowSplitter
forecaster = AutoARIMA(sp=7, suppress_warnings=True)
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df_arima = evaluate(
forecaster=forecaster, y=y, cv=cv, strategy="refit", return_data=True
)
forecaster = ExponentialSmoothing(trend="add", seasonal="additive", sp=7)
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df_ExponentialSmoothing = evaluate(forecaster=forecaster, y=y, cv=cv, strategy="refit", return_data=True)
forecaster = UnobservedComponents(
level="local linear trend", freq_seasonal=[{"period": 7, "harmonics": 14}]
)
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df_unobserved_components = evaluate(forecaster=forecaster, y=y, cv=cv, strategy="refit", return_d
forecaster = TBATS(sp=7, use_trend=True, use_box_cox=True)
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df_TBATS = evaluate(forecaster=forecaster, y=y, cv=cv, strategy="refit", return_data=True)
forecaster = AutoETS(auto=True, sp=7, n_jobs=-1)
cv = ExpandingWindowSplitter(step_length=1, fh=[1, 2, 3, 4, 5, 6, 7], initial_window=31)
df_AutoETS = evaluate(forecaster=forecaster, y=y, cv=cv, strategy="refit", return_data=True)
from sklearn.neighbors import KNeighborsRegressor
from sktime.forecasting.compose import make_reduction
regressor = KNeighborsRegressor(n_neighbors=1)
forecaster = make_reduction(regressor, window_length=15, strategy="recursive")
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_series(y_train, y_test, y_pred, labels=["y_train", "y_test", "y_pred"])
mean_absolute_percentage_error(y_pred, y_test)
Out:
0.3029077745456426
```
Можно вывести на экран параметры с помощью функции scikit-learn, совместимой с функцией get\_params (и установленной с помощью set\_params).
```
forecaster.get_params()
{'estimator__algorithm': 'auto',
'estimator__leaf_size': 30,
'estimator__metric': 'minkowski',
'estimator__metric_params': None,
'estimator__n_jobs': None,
'estimator__n_neighbors': 1,
'estimator__p': 2,
'estimator__weights': 'uniform',
'estimator': KNeighborsRegressor(n_neighbors=1),
'window_length': 15}
```
Плюсы и минусы sktime
---------------------
Основных преимуществ два — простота использования и, как следствие, экономия времени. Разработчики sktime объединили все в один флакон: то, что раньше требовало подключения 8-10 библиотек, можно сделать, установив только одну. Вместо десятка форматов достаточно разобраться только с одним.
С опорой на мануал установить все необходимое можно за 5 минут, плюс 10-15 минут на каждый фреймворк. В общем, это классное готовое решение на начальном этапе, которое дает возможность не кодить каждый элемент по отдельности.
Основной минус sktime — с ней нужно разбираться.
В будущем, на основе полученных значений от sktime, мы планируем строить более сложные модели: ее прогнозы будут использованы как признаки в большом и тяжелом решении. | https://habr.com/ru/post/692392/ | null | ru | null |
# Введение в пользовательские CSS-свойства
*Автор курса [Нетологии](https://netology.ru/?utm_source=blog&utm_medium=747&utm_campaign=habr) «HTML-верстка» Стас Мельников рассказал, что такое пользовательские CSS-свойства и почему их стоит изучить.*
Стандарт CSS Custom Properties изменил CSS. Появились безумные возможности, о которых раньше мы могли только мечтать. Рассказываем, какие именно и почему новичкам стоит изучить их как можно быстрее.
Что такое пользовательское свойство
-----------------------------------
Пользовательское свойство — это CSS-свойство, которое создал сам разработчик. Браузер ничего не знает о таком свойстве, пока его не объявили.
Объявление пользовательского свойства начинается с двойного дефиса, после которого указывают название, ставят двоеточие и добавляют значение.
Для примера объявим пользовательское свойство `--netologyBrandColor` со значением `purple` для элемента `button`:
```
button {
--netologyBrandColor: purple;
}
```
Теперь браузер знает о нашем свойстве, но в чем его польза?
Особенности пользовательских свойств
------------------------------------
Первая фишка — функция `var`. С помощью этой функции мы можем сказать браузеру, чтобы он взял значение из объявленного пользовательского свойства и добавил его для встроенного свойства.
Чтобы браузер так сделал, разработчику нужно объявить встроенное свойство, например, `color`, и добавить к нему в качестве значения функцию `var`, в аргументе которой передать название пользовательского свойства.
Для примера добавим пользовательское свойство для встроенных свойств `border` и `color`:
```
button {
--netologyBrandColor: purple;
border: 2px solid var(--netologyBrandColor);
color: var(--netologyBrandColor);
}
```
В браузере кнопка будет выглядеть так:
Зачем изучать пользовательские свойства, если есть переменные в Sass и они полностью устраивают?
Переменные в препроцессорах, таких как LESS и Sass, помогают организовать код, чтобы нам было проще поддерживать его. Например, в следующем коде я использую переменную `$netologyBrandColor`, в которой хранится основной цвет бренда:
```
$netologyBrandColor: purple;
button {
border: 2px solid $netologyBrandColor;
color: $netologyBrandColor;
}
```
После преобразования кода в браузере мы увидим следующий код:
```
button {
border: 2px solid purple;
color: purple;
}
```
Исходя из примера, понятно, что после преобразования кода из Sass в CSS на место переменных компилятор вставил их значения, поэтому мы можем сказать, что Sass-переменных нет в браузере.
**Вторая фишка пользовательских свойств** — они живут в браузере, поэтому мы можем изменять их прямо в нем. Например, изменим значение пользовательского свойства `--netologyBrandColor` при наведении мыши на кнопку.
```
button {
--netologyBrandColor: purple;
border: 2px solid var(--netologyBrandColor);
color: var(--netologyBrandColor);
}
button:hover {
--netologyBrandColor: #27ae60;
}
```
Теперь, если у кнопки сработает состояние `hover`, значения у свойств `border` и `color` изменятся. Именно из-за этой особенности пользовательские свойства и называют «живыми»: они могут изменяться прямо в браузере, и соответственно менять значения встроенных свойств, к которым они применяются.
В качестве еще одного примера изменю значение пользовательского свойства при состоянии `focus`.
```
button {
--netologyBrandColor: #000000;
border: 2px solid var(--netologyBrandColor);
color: var(--netologyBrandColor);
}
button:hover {
--netologyBrandColor: #27ae60;
}
button:focus {
--netologyBrandColor: #c0392b;
outline: 3px solid var(--netologyBrandColor);
}
```
Способность динамического изменения пользовательских свойства можно сочетать с Sass-переменными или LESS-переменными.
Пользовательские свойства и media-выражения
-------------------------------------------
Еще одна возможность пользовательских свойств — их значения можно переключать с помощью медиазапросов.
Для примера создадим два пользовательских свойства: `—mq` и `—textColor`. При помощи первого выведем название медиафункции на страницу, а второе нужно для переключения цвета. На экранах с шириной до 768px текст будет пурпурным, а от 769px — красным.
```
body::before {
content: var(--mq);
color: var(--textColor);
}
@media (max-width: 768px) {
body::before {
--mq: "max-width: 768px";
--textColor: purple;
}
}
@media (min-width: 769px) {
body::before {
--mq: "min-width: 769px";
--textColor: red;
}
}
```
Пользовательские свойства и функция calc
----------------------------------------
В CSS есть функция `calc`, с помощью которой можно выполнять арифметические операции. Она также может работать и с пользовательскими свойствами. Например, мы можем контролировать количество дочерних элементов в ряду:
```
.child {
width: calc(100% / var(--childCount));
}
```
Если добавить значение 5 для пользовательского свойства `--childCount` в браузере, увидим следующую картину:
Для разнообразия изменю 5 на 7 и элементы перестроятся.
Пользовательские свойства и SVG
-------------------------------
Еще одна возможность пользовательских свойств — с их помощью можно задать значение для таких SVG-свойств, как `fill`, `stroke`, `stroke-width` и других. Это можно сделать двумя способами.
**В первом способе** будем использовать атрибуты `fill`, `stroke` и `stroke-width`, к которым в качестве значения определим пользовательские свойства.
```
```
И добавим в CSS значения для пользовательских свойств:
```
.svg-with-attr{
--iconFill: #eeeeee;
--iconStroke: #000000;
--iconStrokeWidth: 1px;
}
```
Слева иконка без стилизации, а справа с нашими настройками. Вот так просто мы можем настраивать графику.
Второй способ — убрать атрибуты их и заменить на CSS-свойства.
```
```
```
.svg-with-props {
--iconFill: #ffcc00;
--iconStroke: #000000;
--iconStrokeWidth: 2px;
stroke: var(--iconStroke);
stroke-width: var(--iconStrokeWidth);
fill: var(--iconFill);
}
```
Я специально добавил для свойств `fill`, `stroke` и `stroke-width` другие значение, чтобы визуально была заметна разница между примерами.
Поддержка браузерами
--------------------
Согласно [caniuse.com](https://caniuse.com/#feat=css-variables), пользовательские свойства работают в большинстве современных браузеров, кроме IE11.
Если на вашем проекте много пользователей с IE11, не применяйте пользовательские свойства. Я мог бы рассказать, как сделать фоллбэки, но опираясь на свой опыт, считаю, что лучше просто их не использовать.
Если же вам не нужно поддерживать IE11, смело используйте все возможности пользовательских свойств.
Заключение
----------
Надеюсь, мне удалось заинтересовать вас пользовательскими свойствами. В этой статье я коснулся только возможностей и опустил техническую и практическую часть, но наверстаю это и напишу еще несколько статей о принципах работы и кейсах.
От редакции
-----------
Курсы «Нетологии» по теме:
* онлайн-профессия «[Аналитик данных](https://netology.ru/programs/data-analyst?utm_source=blog&utm_medium=747&utm_campaign=habr)»
* онлайн-профессия «[Data Scientist](https://netology.ru/programs/data-scientist?utm_source=blog&utm_medium=747&utm_campaign=habr)»
* онлайн-курс «[Фронтенд-разработчик](https://netology.ru/programs/front-end?utm_source=blog&utm_medium=747&utm_campaign=habr)» | https://habr.com/ru/post/431616/ | null | ru | null |
# SingleA: доменный SSO своими руками
TL;DR
-----
[SingleA](https://github.com/nbgrp/singlea) — это набор Symfony бандлов, которые позволяют развернуть свой PHP’шный SSO, реализующий фреймворк [SingleAuth](https://nbgrp.github.io/singlea/singleauth/). Тот, в свою очередь, позволяет пользователям веб-приложений, живущих на общем домене (2 уровня и выше) перестать повторно ходить на SSO после того, как они один раз уже залогинились (даже ради простого редиректа).
Всё это призвано кардинально изменить подход к разработке проектов на базе SOA и микросервисов, упростив получение пользовательских данных на стороне приложений без утомительных интеграций.
---
Пара disclaimer’ов.
1. Я не профессионал в академической речи, и местами данная статья может уходить в storytelling. Если вам хочется более-менее сухой информации, вы можете обратиться к официальной [проекта](https://nbgrp.github.io/singlea/) (она написана тоже мной, но там я честно старался обойтись без лишнего словоблудства).
2. Недавно в Telegram-канале [Beer::PHP](https://t.me/beerphp) вышла заметка о шифровании. И так получилось, что в комментариях к ней один из членов сообщества разошёлся сокрушительными комментариями о том, что автор местами “сжал тему до размеров монетки”.
Эта статья не раскрывает ни одной криптографической темы. Я бы даже не взялся сходу сказать, какую тему она раскрывает в достаточной мере. Она больше выступает в качестве “неуглублённого” обзора проекта SingleA и возбудителя интереса к тем технологиям, которые будут упомянуты в ходе этого обзора.
---
В этой статье я постараюсь рассказать о проекте SingleA, его особенностях, кому и чем он может быть полезен, а также про подходы, использованные в процессе работы над проектом. Начать хотелось бы с истории того, как он в принципе появился на свет.
### Точка невозврата
Пару лет назад я столкнулся с очередной задачей по интеграции веб-приложения с корпоративной SSO’шкой. Привычное дело, но мне оно показалось интересным, потому что front и back приложения, как оно нынче водится, были разделены и жили на разных доменах. Единого подхода в компании ещё не было, и я позволил себе поиграть в изобретателя велосипеда.
Многие веб-приложения, с которыми мне доводилось иметь дело, работали следующим образом. Ты заходишь на них не залогиненным, идёшь на некий централизованный сервис аутентификации SSO, логинишься. Делаешь в приложении всё, что тебе нужно, уходишь. Потом заходишь на соседнее веб-приложение, живущее на “братском” домене, но там ты не залогинен. Тебя направляют на тот же SSO, через который ты проходишь транзитом (само собой), потому что ты уже залогинился и сессия жива. В результате пары редиректов ты снова в приложении и уже залогинен, супер. Это можно условно изобразить следующей диаграммой последовательности:
Через обозначенные на диаграмме POST-запросы SSO передаёт в приложение данные пользователя. Это не стандарт или жёсткое правило, но на своём пути я встречал только такой подход. В этом POST-запросе таится огромный подводный камень, как вы увидите в одном из примеров ниже.
**Вопрос:** если я уже залогинился на SSO, зачем меня туда посылать, даже ради простого редиректа обратно? С инженерной точки зрения, конечно, я знал ответ, но мой “внутренний пользователь” был озадачен. Когда же я столкнулся с этой ситуацией в работе, я разглядел в ней проблему, которая коснулась меня уже как инженера.
Дело в том, что залогинившись на условном front.domain.org через sso.domain.org, я не могу просто взять и начать слать запросы на api.domain.org, потому что последний обо мне ничего не знает. Тут впору вспомнить про JWT, но встаёт вопрос, кто должен его генерировать. Не все SSO это умеют, а генерация JWT на стороне front.domain.org не всегда является простым делом: API’шек может быть много, свойств пользователя тоже, а вдруг там конфиденциальные данные… Похоже на источник головной боли. Но обозначенный выше вопрос никак не выходил у меня из головы, и я решил поискать на него ответ, взглянув на проблему с другой стороны. Что изменится, если позволить следующее допущение: все веб-приложения, завязанные на один SSO (да и сам SSO), работают с общим доменом (как domain.org из примера выше). Очевидно, что в этом случае они будут иметь доступ к кукам, выставленным на этот домен.
С этой мысли началась работа над проектом, сменившим несколько имён и архитектур и ставшим “швейцарским ножом” при разработке проектов на базе сервис-ориентированной архитектуры или микросервисов. Но в начале была лишь абсолютная уверенность, что это единственное допущение про домен способно дать “зелёный свет” в реализации инструмента, который качественно изменит DX (developer experience) для меня и моей команды. Оставалось только собраться с мыслями. (И, как выяснилось впоследствии, с силами.)
### Эволюция проекта
Здесь я несколько забегу вперёд и расскажу о том, как менялся облик проекта, не вдаваясь в технические подробности.
#### Первая версия
Первый виток истории проекта можно назвать классическим: обычное приложение на базе Symfony Framework. Из необычного были только попытки осмыслить подход Package by Feature, о котором достаточно хорошо позже рассказал Валентин Удальцов [на митапе в Нижнем Новгороде](https://youtu.be/2iPNz3p5Xiw?t=3870). По замыслу, пользователи должны были ходить в это приложение, выступающее в роли SSO, проходить аутентификацию, а кука сессии ставилась бы не на домен данного приложения, а на общий домен. Затем на стороне клиентского веб-приложения происходило бы следующее: используя данную куку, выполнялся бы запрос (под капотом) к SSO на генерацию токена пользователя (JWT), который добавлялся бы в исходный запрос. Если быть точным, это делало не само клиентское приложение, а специальный клиент к SSO, представляющий собой скрипт на Lua для веб-сервера nginx, обрабатывающий запрос до передачи его в клиентское приложение. Благодаря такому подходу получилось избежать утомительной процедуры интеграции на уровне приложения. Об этом Lua-скрипте я расскажу ближе к концу. Здесь лишь отмечу, что это, пожалуй, единственная часть, которая не претерпела значительных изменений с начала работы над проектом.
> Справедливым будет сказать, что утверждение об отсутствии “утомительной процедуры интеграции” — предельно субъективно и многими может быть оспорено. Читайте дальше, чтобы составить своё собственное мнение.
>
>
Сегодня первая версия не вызывает ничего, кроме сожаления. Но тогда осознание ошибок, заложенных в подходе с поддельными запросами пользователя, было ещё впереди. Да и неумелые заигрывания с Package by Feature ничего, кроме сумбура в коде, не породили.
#### Feature-based архитектура и появление Контрактов
Спустя несколько месяцев, я вернулся к проекту. Так вышло, что я уже не работал на прежнем месте, но мне предстояло выбрать тему для диплома в ВУЗе. К тому времени я успел осознать ряд своих ошибок и решил провести время с пользой: и диплом написать, и довести приложение до ума.
На данном этапе, как мне кажется, я смог довести архитектуру, ориентированную на “фичи”, до более-менее зрелого вида. Но что гораздо важнее, на этом этапе была сформирована концепция Контрактов, которая впоследствии обернётся набором пакетов интерфейсов [SingleA Contracts](https://nbgrp.github.io/singlea/features/contracts/), напоминающих компонент [Symfony Contracts](https://symfony.com/doc/current/components/contracts.html). Благодаря контрактам стало возможным без лишних усилий заменять реализацию тех или иных частей (компонентов) сервиса. В основном, код тех компонентов сервиса, который был описан в получившихся интерфейсах, был вынесен в отдельные Symfony бандлы: что-то отвечало за генерацию JWT, что-то за хранение данных пользователей и данных, относящихся к клиентским приложениям (их конфигурации на стороне SSO, о которых я не раз скажу дальше).
Диплом был написан и успешно защищён, настал период заслуженного отдыха. Я смотрел на проект, и мне хотелось донести его до более широких масс, чем дипломная комиссия и группа сокурсников. Но он для этого совершенно не годился.
* Это было самостоятельное приложение, корректное развёртывание которого — тот ещё квест, пусть и снабжённый документацией, во всём говорящий о корпоративной природе приложения. Такой подход может быть удобен внутри организации, но если ты хочешь нести проект в мир open-source’а, это не лучший вариант.
* Реализация генератора JWT не позволяла создавать токены с поддержкой шифрования (JWE). Библиотека с поддержкой JWT существовала, но нужно было побороть нежелание переписывать большой пласт кода.
* Манипуляции с сессией пользователя казались откровенно дурно пахнущей практикой, но толковая замена этому решению никак не приходила на ум.
Этих причин хватило, чтобы провести последующий месяц в крепких раздумьях и планировании дальнейшей работы.
#### Symfony Bundle
Затем последовал самый сложный и, в то же время, самый многообещающий этап. Пришло окончательное осознание, что в мире open-source’а SingleA сможет выжить только как бандл для приложения Symfony, расширяющий его функциональность, а не как самостоятельное приложение. Это решение обернулось масштабным рефакторингом, в рамках которого были введены ключевые концепции проекта, навеянные смежными технологиями; например, пользовательские Ticket’ы многим могут отдалённо напомнить похожий механизм в Kerberos. Кроме того, был изменён способ хранения данных пользователей: вместо того, чтобы самостоятельно заботится об их хранении в отдельном хранилище, данные были перенесены в кэш приложения. Чтобы понять (и принять) это решение, достаточно осознать, что сервис SSO не должен выступать постоянным хранилищем пользовательских данных, а должен лишь быть “кэширующим слоем”. Компонент Symfony Cache позволяет использовать разные хранилища, что даёт необходимую гибкость в настройке конечного сервиса SSO.
И всё бы хорошо, но вопрос с JWT с поддержкой шифрования всё ещё не был решён, и к тому же меня уже буравил червь сомнения относительно вопросов надёжности SingleA в условиях “кровавого enterprise’а” и более-менее серьёзных нагрузок. Я решил, что лучшее, что можно сделать в такой ситуации — это обратиться к опыту старших товарищей, и отправился на встречу с коллегой из [CDNnow](https://cdnnow.ru/). Уж кто, если не они, сможет критически отнестись к идее сервиса SSO, выступающего единой точкой отказа, да ещё и собранного на PHP. И я ни разу не пожалел о той встрече. (Дима, спасибо огромное!)
#### Качественный переход
На данном (пока финальном) этапе произошли следующие изменения.
* Объединение разрозненных бандлов в монорепозиторий.
* Symfony 6 и PHP 8.1 (хотя вот это “.1”, признаться, не входило в мои планы и пришло уже на финальной стадии — “спасибо” Николасу и co. за нетипичный для Symfony Core-team шаг по увеличению минимальной версии PHP в требованиях минорного релиза).
* Переход от библиотеке [lcobucci/jwt](https://github.com/lcobucci/jwt) Луиса Кобуччи к [web-token/jwt-framework](https://github.com/web-token/jwt-framework) Флорента Морселли (aka Spomky), обеспечивающей поддержку JWE. Забегая вперёд, хочу сказать, что восхищаюсь Флорентом и бесконечно благодарен ему за вклад, который он вносит в дело open-source’а и развитие JOSE в частности.
* Был переработан компонент безопасности — механизм цифровой подписи запросов. Изначально цифровая подпись распространялась только на адрес, куда нужно было возвращать пользователя после успешной аутентификации. Она никак не была привязана ко времени запроса, что заслуженно было подвергнуто критике коллегой из CDNnow, ведь в таком случае можно уложить сервис валидными запросами, посылаемыми до бесконечности.
Теперь механизм цифровых подписей используется для всех запросов к SSO и привязан ко времени отправки запроса. Дальше расскажу подробнее.
* Данные пользователей и данные, относящиеся к клиентским приложениям, теперь хранятся на стороне SSO в зашифрованном виде, чтобы затруднить их компрометацию со стороны недобросовестных администраторов системы. Теме “тотального шифрования” ниже будет посвящён отдельный раздел. Здесь лишь скажу, что это был важный шаг на пути борьбы с собственной ленью, которая долгое время говорила “и так сойдёт”.
Защита данных пользователей и клиентов SSO — не блажь и признак паранойи, это обязанность любого, кто не хочет попасть в новостные сводки (а то и на скамью подсудимых).
---
Наверное, было что-то ещё, но сейчас уже и не вспомнить. На текущий момент за спиной 4 этапа эволюции SingleA, и у меня есть ощущение, что я начал понимать Intel с их стратегией разработки микропроцессоров [Tick-tock](https://en.wikipedia.org/wiki/Tick%E2%80%93tock_model). Сначала ты рушишь “барьеры прошлого”, чтобы увидеть доступные решения (и проблемы, которых раньше не замечал), а потом, осознав, что пути назад нет, реализуешь их.
Одним из важнейших продуктов эволюции проекта стало выделение фреймворка для аутентификации SIngleAuth (впоследствии давшего имя и всему проекту).
### SingleAuth — фреймворк для аутентификации
Я могу ошибаться в терминологии, но протоколом называть SingleAuth было бы ошибкой, потому что он не накладывает никаких требований на реализацию, кроме требования к HTTP-методу (POST) и формату обмена данными (JSON) при регистрации клиентских приложений на стороне сервиса SSO, а также ключевой “фишки” — требования устанавливать куку с “сессией” пользователя в ответах на запросы к системе аутентификации — login и logout. Данная “сессия” именуется в терминах проекта ticket’ом, как было упомянуто выше, и не имеет ничего общего с PHP сессией.
> В SingleA функция выхода из системы (logout) отнесена к системе аутентификации просто как обратная по отношению к входу в систему (login). Я понимаю, что это может сбивать с толку, и заранее прошу прощения, если вам это кажется странным.
>
>
С более полным описанием фреймворка вы можете ознакомиться в [документации](https://nbgrp.github.io/singlea/singleauth/) проекта (на разные разделы которой я буду ссылать по тексту не раз). Здесь я подсвечу только ключевые моменты.
* Реализация сервиса SSO на базе SingleAuth должна включать методы регистрации клиентского приложения (клиента), login’а и logout’а пользователя, валидации его сессии и генерации токена. Под токеном понимается строка, позволяющая на стороне клиента преобразовать её в данные пользователя любым доступным способом. Например, токеном может быть JWT, в котором закодированы все эти данные, а может быть уникальный ключ, с помощью которого клиент извлечёт все нужные данные из некоего хранилища, в которое SSO предварительно эти данные положит — это отдаётся на откуп реализации.
* Отдельное место в фреймворке отведено роли “фичей”. Feature — это функциональная возможность сервиса, обладающая собственной конфигурацией, задаваемой для каждого клиента при регистрации. SingleAuth говорит только о 3 фичах: системе аутентификации, валидации сессии пользователя и генерации токена пользователя, — но оставляет за реализацией право на расширение этого списка (включая предоставление возможности добавлять кастомные фичи). Как будет показано дальше, в SingleA всё именно так и сделано.
* Ticket — уникальный идентификатор “сессии” пользователя (в понимании SingleAuth), позволяющий осуществлять взаимодействие между сервисом SSO и клиентом без непосредственного участия пользователя. Передаваться от SSO к пользователю ticket должен посредством куки, выставленной на общий для всех “заинтересованных” веб-приложений домен 2 (или более верхнего) уровня.
* Регистрация клиента должна выполняться через POST-запрос с передачей в формате JSON необходимых для регистрации параметров (зависящих от реализации). Ответ должен быть представлен в формате JSON и содержать всю значимую информацию в теле ответа. Каждый клиент должен иметь уникальные идентификатор и секрет, которые затем должны указываться во всех запросах к SSO (пользовательских запросах на login/logout и внутренних запросах от клиента на валидацию сессии пользователя и генерацию его токена).
Остаётся отметить, что SingleAuth был спроектирован под влиянием таких протоколов, как Kerberos, OAuth 2.0 и OpenID Connect, и в особенности CAS.
---
Всё вышесказанное было долгой, но необходимой преамбулой к основной части повествования — описанию набора бандлов для Symfony, собранному в проект SinlgeA и позволяющему реализовать сервис Single Sign-On на базе фреймворка для аутентификации SingleAuth.
### SingleA: конструктор SSO на базе PHP + Symfony
Слово “конструктор” призвано подчеркнуть тот факт, что готовая SSO получится только после сложения воедино необходимых компонентов. Ядром проекта является одноимённый бандл — [nbgrp/singlea-bundle](https://github.com/nbgrp/singlea-bundle), который, используя систему контрактов, выступает в роли “оркестратора” фичей, обрабатывая входящие запросы.
Чтобы не заниматься пересказом документации проекта, расскажу о SingleA своими словами. Начнём с обзора его возможностей.
#### Концептуальный взгляд
Опираясь на систему контрактов, SingleA позволяет осуществить следующие действия:
* **Регистрация клиентов.** Клиентские приложения можно регистрировать, передавая в запросе параметры для конфигурирования фич, нужных данному клиенту. По умолчанию, все фичи SingleA считаются необязательными для конфигурирования, но позже будет показано, как настроить сервис аутентификации с обязательными фичами. Важно помнить, если какая-то фича не была сконфигурирована при регистрации клиента, впоследствии он не сможет ей пользоваться; например, не задав параметры для генерации токена пользователя, клиент не сможет делать запросы на их получение (получит в ответ ошибку).
В ответ на запрос регистрации клиента возвращается его идентификатор и секрет, а также выходные параметры некоторых фичей (если нужно). Например, ключ для проверки подписи в JWT на стороне клиента (я скажу о нём подробнее ниже).
Секрет в данном случае играет особую роль. Дело в том, что конфигурации фичей, используемых клиентом, хранятся на стороне SingleA в зашифрованном виде, и секрет — один из двух компонентов шифрования, известный только клиенту. (Вторым компонентом являются ротируемые ключи на стороне сервиса.)
* **Методы SinlgeAuth.** SingleA позволяет выполнять основные действия, указанные во фреймворке SingleAuth: проводить аутентификацию и завершение сессии пользователя, валидировать сессию пользователя и генерировать токен пользователя. Предполагается, что первые 2 запроса выполняет пользователь (браузерные запросы), а остальные являются внутренними запросами от клиента к SSO и выполняются на самом деле модулем/скриптом, именуемым ниже “клиентом SingleA для nginx”, о котором подробнее будет рассказано ниже. (Вы, конечно, можете реализовать и использовать собственный клиент, который будет делать то же самое, что и мой Lua’шный.)
* **Атрибуты пользователя.** После успешной аутентификации пользователя, для него собирается специальный набор параметров, называемый в терминах SingleA атрибутами пользователя (User Attributes). Этот набор хранится в кэше, ключ к элементу которого составлен из уникального ticket’а пользователя и имени firewall’а, через который пользователь был залогинен. Про этот firewall и его роль в работе всего SSO я скажу в следующем пункте, а здесь лишь добавлю 2 момента. Во-первых, данные пользователя, как и конфигурации фич клиента, хранятся в зашифрованном виде, где ticket выступает одним из компонентов шифрования. Во-вторых, элемент кэша, куда записывается набор пользовательских атрибутов, ограничен по времени жизни и будет удалён по истечении заданного срока.
* **Realm.** В терминах SingleA, Realm — это имя firewall’а, обрабатывающего запрос. Система realm’ов (вернее, механизм фиксации сессии в Symfony) позволяет одному пользователю быть залогиненым через SSO сразу в нескольких независимых firewall’ах, и, что ещё важнее, с помощью разных User Provider’ов. Другими словами, это позволяет одному пользователю использовать разные Identity Provider’ы при аутентификации в разных приложениях, но через один и тот же SSO. (Пример из жизни с использованием нескольких IdP будет приведён ниже.)
* **ЭЦП запросов.** Рассказывая про эволюцию проекта, я уже упоминал механизм цифровой подписи запросов. Он предполагает, что при регистрации клиента будут переданы открытый ключ и алгоритм хэширования, с помощью которых впоследствии нужно будет верифицировать подпись GET-параметров запроса, пришедшего на SSO. В числе прочего GET-параметры должны включать время отправки запроса, которое также защищено подписью, что гарантирует ограниченность срока годности запроса.
* **Функции ExpressionLanguage.** Также стоит отметить, что забота о безопасности при обработке запросов — дело добровольное. Проверка наличия во внутренних запросах ticket’а и валидность цифровой подписи (для тех клиентов, кто активизировал данную фичу) — результат использования специальных функций, относящихся к компоненту Symfony [ExpressionLanguage](https://symfony.com/doc/current/components/expression_language.html). Сюда же можно добавить, что SingleA предоставляет ещё несколько функций: для ограничения клиентских запросов по IP или подсети (предполагается использовать эту функцию для внутренних запросов на валидацию сессии пользователя и генерацию токена), а также для ограничения запросов на регистрацию клиентов по IP или подсети, или с помощью специального регистрационного ticket’а.
Подробности данного механизма можно найти в [документации проекта](https://nbgrp.github.io/singlea/bundles/singlea/#access-control-expression).
* **Наполнение payload’а из внешнего источника.** Ещё одной фичей, дополняющей фреймворк SingleAuth, стал механизм [Payload Fetcher](https://nbgrp.github.io/singlea/features/payload-fetcher/).
Зачем он нужен? Например, вам может потребоваться получить в составе токена пользователя его роли в клиентском приложении. Но SSO ничего не знает (и знать не может) о пользовательских ролях на стороне клиента. Но он может выполнить дополнительный HTTP-запрос на заранее заданный веб-сервис, передав туда набор известных ему атрибутов пользователя (а вернее только те из них, названия которых были указаны при регистрации клиента в соответствующем параметре). Предполагается, что на стороне веб-сервиса, куда уйдёт запрос, знают, как преобразовать эти данные в роли (или любую другую необходимую информацию). Полученные в ответ данные дописываются в состав payload’а (откуда и название фичи).
* **Пользовательские РНР-сессии и сессии SingleA.** Проблема в том, что PHP и Symfony так устроены, что если вы будете каждые 5 минут обновлять страницу вашего приложения, по умолчанию ваша сессия никогда не протухнет (потому что срок её жизни будет постоянно увеличиваться). Для многих корпоративных приложений (с которых и началась история проекта SingleA) это плохой вариант. Они хотят, чтобы пользователи повторно проходили процедуру аутентификации каждые N часов. В основном это связано с регламентом безопасности. Ради соблюдения этого условия в SingleA реализовано разделение PHP сессии пользователя и “сессии” с точки зрения SingleA, которая длится столько, сколько существуют атрибуты пользователя в кэше. Жизнь элемента кэша фиксирована и истекает спустя заданный промежуток времени. Но если вам нужно сохранить поведение по умолчанию, при котором жизнь сессии пользователя продлевается при контактах с сервисом, этого можно достичь благодаря механизму [Sticky Sessions](https://nbgrp.github.io/singlea/bundles/singlea/#sticky-sessions), который будет пересохранять атрибуты снова и снова при выполнении пользователем аутентификации (на других запросах этого происходить не будет, как и не будет происходить пересохранения атрибутов для уже залогиненного пользователя с отключённым механизмом Sticky Sessions). При пересохранении атрибутов пользователя, их срок жизни будет продлеваться.
* **Symfony Bundle, а не приложение.** Благодаря использованию SingleA как бандла, а не самостоятельного приложения, он может быть встроен в существующие решения в качестве реализации сервиса аутентификации. Контракты SingleA позволяют достаточно просто заменять базовые реализации тех или иных фич и разрабатывать собственные решения в соответствии со следующим набором нехитрых правил:
1. Создать отдельный интерфейс конфигурации фичи, унаследованный от общего интерфейса для всех фич SingleA\Contracts\FeatureConfig\FeatureConfigInterface (который содержит методы сериализации/десериализации). Это нужно сделать, даже если ваш интерфейс не будет содержать методов (что довольно странно, но всё бывает).
2. Создать фабрику конфигов вашей фичи, реализовав в ней общий интерфейс для всех фабрик конфигов фичей — SingleA\Contracts\FeatureConfig\FeatureConfigFactoryInterface. Фабрика обрабатывает данные из запроса на регистрацию клиента и генерирует экземпляр конфига фичи, или возвращает возникшие ошибки.
Следующий пункт зависит от того, как вы храните конфиги фич клиентов. Здесь будет приведён пример для бандла nbgrp/singlea-redis-bundle, входящего в состав проекта. Этот бандл предоставляет механизм хранения конфигов и метаданных клиентов (включающих время последнего обращения к SSO с идентификатором клиента) в Redis’е с помощью ещё одного удобного бандла — SncRedisBundle.
3. В контейнере зависимостей вам нужно будет настроить сервис маршализации вашего конфига (пример конфигурации сервиса можно найти в описании бандла nbgrp/singlea-redis-bundle). Идентификатор данного сервиса нужно будет указать в конфигурации бандла, в параметре singlea\_redis.config\_managers (что также показано в описании). Там же можно задать, является ли та или иная фича обязательной при регистрации клиента.
---
Пожалуй, с обзором SingleA можно закончить и рассмотреть несколько вопросов, связанных с безопасностью и надёжностью собранного с его помощью сервиса аутентификации.
#### Хранение данных пользователя
Как было сказано выше, атрибуты пользователя хранятся в кэше. Используется для этого компонент [Symfony Cache](https://symfony.com/doc/current/components/cache.html). С первого дня работы над SingleA была необходимость дать администратору SSO возможность принудительно разлогинить пользователя. К сегодняшнему дню эта опция реализована через элемент кэша, содержащий пользовательские атрибуты, который тегируется идентификатором пользователя. Инвалидация кэша по идентификатору пользователя приводит к удалению его атрибутов из кэша, и “сессия” пользователя считается завершённой. Но вынужденным следствием этого решения является требование использовать для кэш пула адаптер, поддерживающий работу с тегами, то есть реализующий интерфейс Symfony\Contracts\Cache\TagAwareCacheInterface.
Там, где необходимо быстрое хранилище типа ключ-значение, я предпочитаю использовать Redis. И для хранения тегированного кэша он подходит как нельзя лучше, если не считать омрачающего всё обстоятельства: записи тегов, содержащих ссылки на элементы кэша, живут вечно и не очищаются от элементов, удалённых по истечении срока жизни. Этой теме даже был посвящён [один из вопросов](https://github.com/symfony/symfony/discussions/45507) в дискуссиях Symfony, но желаемой реакции от Symfony Core team на него уже не последует. Остаётся только собраться с силами и запилить решение своими руками.
Несмотря на трудности с тегами и Redis’ом, выбор кэша как места для временного хранения атрибутов пользователя остаётся дешёвым и в то же время практичным решением. Оно позволяет использовать собственный адаптер, если стандартные вас не устраивают по каким-то причинам. В случае таких хранилищ как Redis, можно гарантировать, что данные не задержатся в хранилище дольше, чем нужно, а при необходимости можно ограничить объём занимаемой памяти с [вытеснением лишних значений](https://redis.io/docs/manual/eviction/) по той или иной стратегии.
Выше я уже говорил, что ключ кэша состоит из ticket’а пользователя и realm’а. Это позволяет иметь независимые наборы атрибутов пользователя, составленных при успешной аутентификации через разные firewall’ы, с использованием разных user provider’ов. Но это же приводит к тому, что эти независимые наборы хранятся в разных элементах кэша и имеют разные сроки жизни. Следствием может стать ситуация, когда в рамках одного realm’а сессия пользователя будет считаться оконченной (атрибуты были удалены из кэша), а в рамках другого — нет. Кроме того, для каждого realm’а можно сконфигурировать кэш пул индивидуально, задав своё время хранения элементов кэша.
Удаление данных пользователей по окончании срока жизни — это лишь полдела. Следующая цель — обеспечить их конфиденциальность на этапе хранения в кэше, чтобы любопытный администратор не мог “случайно” скомпрометировать их.
#### Тотальное шифрование
Атрибуты пользователя, как и конфиги фичей клиентов, шифруются силами библиотеки Sodium. Для шифрования используются, с одной стороны, хранящиеся на стороне SSO ключи (в том смысле, что они указываются в параметрах конфигурации бандла SingleA), а с другой стороны, ticket пользователя или секрет клиента, передаваемые в запросе. Если злоумышленник сможет добыть зашифрованные значения атрибутов или конфигов, ему ещё предстоит постараться добыть ключи и ticket/секрет. Я не утверждаю, что это остановит злоумышленника или создаст непреодолимое препятствие на его пути. Но то, что это создаст определённые сложности и исключит беспрепятственный доступ к конфиденциальной информации — это точно. При грамотном подходе к безопасности этого может хватить, чтобы обеспечить надёжное хранение данных пользователей и не допустить утечку конфигов фич.
Ключи, о которых идёт речь, задаются в виде массива, что позволяет периодически выполнять их ротацию. Первый из ключей используется для шифрования данных, а остальные, последовательно, для расшифровки. Логика ротации описана в [документации проекта](https://nbgrp.github.io/singlea/security/#keys-rotation), здесь просто скажу, что и для ключей атрибутов пользователя, и для ключей конфигов фич клиентов можно выбрать свой период ротации.
#### Слепая зона
В предыдущем абзаце я дал ссылку на раздел документации, имевший в начальной версии название “Ахиллесова пята безопасности SingleA”. Позже я сместил акцент с описываемой в нём проблемы на сильные стороны SingleA, подчёркивающие его надёжность, но сама проблема от этого никуда не делась.
Даже “обмазавшись” с ног до головы шифрованием и цифровыми подписями, мы не можем исключить атаки типа Man-in-the-middle на этапе регистрации клиента, если выполняем её через незащищённую сеть. Учитывая вновь обострившуюся тему “Чебурнета”, эта фобия кому-то может показаться вполне оправданной.
В то же время я глубоко убеждён, что столь тяжёлую артиллерию против сервиса аутентификации станут использовать только в качестве поистине крайней меры и в ответ на что-то очень нехорошее. А люди, занимающиеся подобными делами, могут не рассчитывать на поддержку и понимание с моей стороны. SingleA создан во благо и никогда не будет на их стороне.
### Один SSO — много Identity Provider’ов
Перед тем, как перейти от темы сервера SingleA к теме клиента для интеграции с ним, приведу обещанный пример ситуации, когда вам может потребоваться несколько realm’ов — firewall’ов с разными user provider’ами.
Представим, что у вас есть корпоративное приложение, закрытое от посторонних с помощью нашего сервиса SSO, который, в свою очередь, использует корпоративный ADFS в качестве Identity Provider’а. И вот в один прекрасный день к вам приходят с задачей пустить в это приложение сотрудников другой организации (допустим, бизнес-партнёров). У них есть свой ADFS, учётная политика, служба безопасности, графики отпусков и прочие особенности, о которых вам не хотелось бы не только знать, но даже думать. Чтобы не заниматься дублированием аккаунтов чужих сотрудников в свой ADFS (со всеми вытекающими рисками), вы можете просто настроить дополнительный realm и заводить на него пользователей из сети вашего бизнес-партнёра. Настройка realm’а включает в себя следующие шаги.
* Создать отдельный firewall в config/packages/security.yaml.
* Настроить для него request matcher’а, который направит входящий запрос на обработку именно в этот firewall (пример такой настройки есть в [документации](https://nbgrp.github.io/singlea/bundles/singlea/#realms)).
* Настроить необходимый аутентификатор для созданного firewall’а.
* Настроить для этого firewall’а свой user provider, который будет брать пользователя из нужного вам источника.
* Создать обработчик события SingleA\Bundles\Singlea\Event\UserAttributesEvent, который будет срабатывать при аутентификации именно в этом realm’е, и сформировать набор атрибутов пользователя. Здесь же вы можете добавить в атрибуты пользователя флаг (или любое другое значение), который в дальнейшем поможет вам отличить пользователя из сторонней организации от пользователей из вашей организации.
Для определения realm’а на основе запроса можно воспользоваться сервисом SingleA\Bundles\Singlea\Service\Realm\RealmResolver.
Таким образом можно дать пользователям доступ к приложениям через любой Identity Provider, лишь бы он интегрировался с системой аутентификации Symfony Security.
### Осталось за кадром
Что ещё полезного есть в SingleA?
* Консольные команды, позволяющие: зарегистрировать клиента из терминала, удалить выбранного клиента или всех, старше заданного количества дней, показать старейшего зарегистрированного клиента, а также принудительно разлогинить пользователя.
* Идентификатор клиента — это base58-кодированный UUIDv6, что позволяет немного сэкономить на количестве символов и при этом получить информацию о дате и времени регистрации клиента прямо из его идентификатора.
* Регистрационные ticket’ы требуют реализации интерфейса SingleA\Bundles\Singlea\Service\Client\RegistrationTicketManagerInterface, который позволяет создать механизм выдачи и отзыва этих ticket’ов.
* Система событий SingleA (в дополнение к кастомизации через переопределение и декорирование сервисов).
* Для получения дополнительного payload’а есть 2 бандла — [nbgrp/singlea-jwt-fetcher-bundle](https://github.com/nbgrp/singlea-jwt-fetcher-bundle) ([JWT Fetcher](https://nbgrp.github.io/singlea/bundles/jwt-fetcher/), обмен данными с помощью JWT, он будет приведён в примере ниже) и [nbgrp/singlea-json-fetcher-bundle](https://github.com/nbgrp/singlea-json-fetcher-bundle) ([JSON Fetcher](https://nbgrp.github.io/singlea/bundles/json-fetcher/), обмен через обычный JSON).
Подробности для каждого пункта можно найти в документации.
### Клиент SingleA для nginx: Lua
Простота использования SingleA основана на том, что токен пользователя должен добавляться в исходный запрос на этапе его обработки веб-сервером, и в клиентском приложении уже останется только извлечь и преобразовать этот токен в объект пользователя. Для реализации этого был создан скрипт на Lua, исполняемый компилятором LuaJIT на стороне веб-сервера nginx. Подробно об этом скрипте, гордо названном мной “клиентом для SingleA”, можно прочитать всё в той же [документации](https://nbgrp.github.io/singlea/client/nginx/) (чтобы не рассказывать долго и нудно о его конфигурировании). Здесь лишь подсвечу основные идеи.
* С помощью методов клиента можно проверить наличие в запросе куки с ticket’ом, и либо перенаправить пользователя на SSO (с последующим возвращением по исходному URI), либо возвратить ему 401 Unauthorized.
* Можно перенаправить пользователя на разлогинивание на SSO, с последующим возвращением на тот же URI, откуда был выполнен редирект. Соответственно, вам нужно будет самостоятельно решать, куда дальше направлять разлогиненного пользователя.
* Пожалуй, самым важным является метод, запрашивающий с SSO токен пользователя и добавляющий его в исходный запрос. Чтобы не делать лишней работы, клиент анализирует HTTP-заголовок “Cache-Control” и кэширует полученный токен в общем для всех worker’ов nginx’а участке памяти (см. директиву [lua\_shared\_dict](https://github.com/openresty/lua-nginx-module#lua_shared_dict)) на указанное в инструкции max-age время. В последующих запросах клиент берёт значение из кэша, а не запрашивает его повторно с сервера.
* Раз есть кэш, должен быть и механизм его сброса. Он есть сразу в 3х видах:
+ Можно прислать запрос со специальным HTTP-заголовком, в результате чего, вместо поиска токена в кэше, клиент удалит его оттуда и пойдёт за ним на сервер.
+ Можно выставить такой заголовок в ответе клиентского приложения, что приведёт к удалению токена из кэша уже **после** обработки запроса. Как следствие, на следующем запросе клиент получит свежий токен с сервера.
+ Наконец, всегда можно принудительно удалить токен из кэша без дополнительных условий и проверок. Актуально делать это в контексте отдельного location’а.
В документации можно найти более подробное описание клиентских методов (и аргументов для некоторых из них), а также примеры их использования. Тут лишь добавлю, что получение токена (и добавление его в исходный запрос) может быть опциональным (не приводящим к ошибке, если пользователь не залогинен). Чтобы избежать ситуации, когда токен был запрошен для пользователя, у которого непосредственно перед этим завершилась только что проверенная сессия, и в результате была возвращена ошибка, можно использовать цепочку вызовов:
```
require("singlea-client").new { ... }
:login()
:token(false)
:login()
```
В результате:
1. Первый вызов метода login() проверяет сессию до запроса токена (и выполняет редирект на аутентификацию, если нужно).
2. Метод token() получает токен (если пользователь залогинен) и добавляет его в запрос.
3. Второй вызов метода login() повторяет первую проверку (которая выполнит редирект, если пользователь был разлогинен за прошедшее с первой проверки время).
### Красивый пример “на максималках”
Опишу пример конфигурации SSO и клиентских приложений, при котором достигается максимальный эффект от использования SingleA. Со стороны SingleA возьмём следующие бандлы:
* nbgrp/singlea-bundle — то, чему посвящена большая часть текста выше.
* nbgrp/singlea-redis-bundle — хранение клиентских метаданных и конфигов фич в Redis’е (и там же будем заодно хранить кэш и PHP’шные сессии).
* nbgrp/singlea-jwt-bundle — генерация токенов пользователей в формате JWT.
* nbgrp/singlea-jwt-fetcher-bundle — получение дополнительного payload’а для токена через обмен данными в составе JWT.
На стороне клиентского приложения будем использовать Symfony Framework в связке со следующими пакетами:
* [lexik/jwt-authentication-bundle](https://github.com/lexik/LexikJWTAuthenticationBundle) — бандл, позволяющий аутентифицировать пользователя с помощью JWT и инстанцировать объект пользователя с помощью данных из payload’а JWT. Другими словами, превратить JWT в пользователя.
* [spomky-labs/lexik-jose-bridge](https://github.com/Spomky-Labs/lexik-jose-bridge) — бандл, дополняющий предыдущий и позволяющий ему иметь дело с зашифрованными токенами (чего тот сам не умеет, так как по умолчанию использует библиотеку lcobucci/jwt).
* [web-token/signature-pack](https://github.com/web-token/signature-pack) и [web-token/encryption-pack](https://github.com/web-token/encryption-pack) — эти 2 pack’а добавляют в зависимости весь набор доступных алгоритмов для цифровой подписи и шифрования JWT из проекта web-token/jwt-framework (который используется на стороне SingleA). В своём реальном приложении вы, конечно, можете подключать только те алгоритмы, которые будете использовать.
Признаюсь, что конфигурирование связки данных бандлов, самого SingleA и, наконец, Symfony — занятие несколько утомительное, но необходимое для понимания того, что на чём стоит. Расписывать это во всех подробностях в данной статье было бы неверно, как мне кажется, поэтому предлагаю заинтересовавшимся изучить этот вопрос самостоятельно. Кроме того, в тестовом примере не демонстрируется никакой автоматизации при развёртывании сервиса SSO или клиентского приложения. Клиент регистрируется на стороне SSO простым POST-запросом с любого HTTP-клиента, и полученные данные используются для конфигурирования как самого клиентского приложения, так и Lua-клиента SingleA для nginx.
Для полноты картины представим, что, кроме SSO и клиентского приложения, где-то развёрнут веб-сервис, принимающий запросы от SSO на генерацию дополнительного payload’а для JWT. Это может делать и само клиентское приложение (лишь бы nginx был правильно сконфигурирован и не заворачивал такие запросы в Lua-клиент SingleA). Для нашего примера ограничимся утверждением, что данный сервис сконфигурирован корректно, умеет принимать зашифрованные JWT и отправлять в ответ данные, упакованные в шифрованный JWT.
> Если у вас возникнет интерес к теме SingleA, можно будет рассмотреть вопрос конфигурирования связки “SingleA — клиентское приложение — Lua-клиент SingleA — веб-сервис генерации дополнительного payload’а“ в production-среде с развёртыванием в виде контейнеров.
>
>
Чтобы мои слова об утомительности конфигурирования не остались голословным утверждением, опишу некоторые данные, которые необходимо будет передать при регистрации клиента:
* ключ в формате PEM, с помощью которого SingleA будет проверять цифровую подпись запросов от этого клиента;
* ключ в формате JWK, которым нужно будет шифровать JWT, отправляемый в веб-сервис генерации дополнительного payload’а;
* ключ (JWK) для проверки подписи в JWT, который вернёт этот веб-сервис;
* ключ (JWK) для шифрования JWT, генерируемого при запросе токена пользователя.
В ответ на регистрационный запрос придёт:
* идентификатор и секрет клиента;
* ключ (JWK) для шифрования ответного JWT от веб-сервиса генерации дополнительного payload’а;
* ключ (JWK) для проверки подписи JWT в запросе на дополнительный payload;
* ключ (JWK) для проверки подписи JWT, генерируемого при запросе токена пользователя.
Чтобы не погрязнуть в рассказе о том, как и куда нужно разложить эти 7 ключей, условимся, что они попали туда, где должны быть.
У нас есть настроенный SSO (на базе Symfony и бандлов SingleA), пара клиентских приложений (на базе Symfony и упомянутых выше бандлов для работы с JWT), успешно зарегистрированных на стороне SSO, а также веб-сервис, генерирующий дополнительный payload для пользовательских JWT. Переходим к самому лакомому куску рассказа — разбору шагов, обеспечивающих отсутствие лишних редиректов для пользователя и получение всей необходимой информации на стороне клиентского приложения без лишних шаманских танцев (знаю, после всего вышесказанного это весьма спорное утверждение).
Будем считать, что запросы к клиентскому приложению заворачиваются в Lua-клиент SingleA, который выполняет вызов цепочки методов:
```
require("singlea-client").new { ... }
:login()
:token()
```
То есть сначала проверяет сессию пользователя (с возможным редиректом на SSO), а затем добавляет токен в исходный запрос.
1. Пользователь без куки с ticket’ом делает запрос к клиентскому приложению. Так как ticket’а нет, Lua-клиент SingleA редиректит его на SSO, с указанием текущего URI в качестве адреса, куда нужно вернуть пользователя после успешной аутентификации. В этом и всех остальных запросах к SSO, в числе прочего, указывается идентификатор и секрет клиента, а также цифровая подпись GET-параметров запроса и время его отправки.
2. SSO ловит запрос, проверяет наличие клиента, извлекает его конфиг фичи цифровой подписи из хранилища, расшифровывает его с помощью указанного секрета, проверяет, что время на обработку запроса не истекло и GET-параметры соответствуют цифровой подписи, указанной в запросе. Если всё хорошо, а пользователь не аутентифицирован, SSO отправляет его логиниться (на своей стороне или, например, на внешнем сервисе аутентификации), запоминая время прихода запроса, чтобы запрос не считался протухшим, когда пользователь вернётся (см. следующий пункт).
3. После успешной аутентификации и повторной проверки цифровой подписи, SSO формирует набор атрибутов пользователя, генерирует ticket и кладёт атрибуты в кэш.
4. Наконец, формируется редирект, где, в числе прочего, в куки кладётся ticket, а самой куке ставится домен, общий для всех клиентов и самой SSO. Со всем этим пользователь отправляется обратно в клиентское приложение по адресу из п. 1.
5. Вернувшись снова в клиентское приложение, Lua-клиент SingleA на этапе обработки запроса видит, что ticket есть, и выполняет внутренний запрос на валидацию сессии пользователя, а затем и на получение токена пользователя (с последующим добавлением его в заголовок исходного запроса).
1. Получая запрос на валидацию сессии пользователя, SSO выполняет необходимые проверки: существования клиента, валидности IP / подсети клиента (если настроено), цифровой подпись запроса, наличия ticket’а в правильном формате в запросе. Если всё в порядке, SSO проверяет, что атрибуты пользователя для данного ticket’а (и realm’а, в рамках которого происходит обработка запроса) существуют. Если так — возвращает 200, иначе — 403.
2. При запросе токена пользователя выполняются те же проверки + извлекаются конфиги генератора токенов (tokenizer’а) и фичи для запроса дополнительного payload’а. После этого выполняется последовательное формирование payload’а токена:
* сначала из атрибутов пользователя в массив извлекаются поля, указанные в конфиге tokenizer’а (они задаются при регистрации клиента);
* затем аналогичным образом формируется массив для запроса дополнительного payload’а;
* с помощью этого массива формируется JWT для внешнего веб-сервиса (JWT подписывается и шифруется) и отправляется туда средствами HTTP-клиента Symfony (или иного, реализующего его интерфейс из контрактов symfony/http-client-contracts);
* полученный в ответ JWT парсится (включая расшифровку и проверку подписи), и данные из его payload’а сливаются (с заменой) с массивом, который был сформирован в начале.После создания payload’a для токена пользователя, на его основе формируется JWT (с подписью и шифрованием), который возвращается в теле ответа на запрос генерации токена пользователя. Срок годности токена, и без того заданный в стандартных полях payload’а JWT, дублируется в заголовке “Cache-Control”, в инструкции max-age, для последующего кэширования Lua-клиентом SingleA.
3. Получив ответ от SSO, Lua-клиент SingleA извлекает токен из тела ответа, кэширует его и добавляет в виде заголовка в исходный запрос, после чего передаёт запрос для дальнейшей обработки в клиентское приложение.
4. В последующих запросах, если токен для этого клиентского приложения и ticket’а есть в кэше, он берётся оттуда, а не запрашивается у SSO.
6. Если необходимо, Lua-клиент удаляет из кэша токен пользователя до вставки его в исходный запрос или после полной обработки запроса клиентским приложением.
7. Наконец, клиентское приложение получает запрос и формирует объект пользователя из данных, извлечённых из токена силами упомянутых бандлов для работы с JWT.
Благодаря этой последовательности шагов, в составе JWT можно передать любую, даже самую конфиденциальную информацию, и ей ничего не будет угрожать при передаче даже по самым открытым каналам.
Если теперь пользователь сделает запрос ко второму клиентскому приложению (зарегистрированному на том же SSO и работающему с тем же общим доменом), он не будет никуда перенаправлен для транзитного редиректа, потому что Lua-клиент SingleA, обрабатывающий запросы к этому приложению, увидит ticket в куках и самостоятельно проделает всю работу, начиная с п. 5. При этом состав токена пользователя для второго приложения будет отличаться от первого, потому что у этих клиентов разные конфиги tokenizer’а на стороне SSO.
Таким образом мы получили механизм, позволяющий без излишней кастомной логики, силами нескольких бандлов и набора настроек, а также nginx’а с Lua’шным скриптом, получить интеграцию с централизованным SSO, способным освободить ваших пользователей от избыточных редиректов, и предоставить вам их данные через JWT (или любой другой формат токена). И если всё это звучит интересно, но неубедительно, вот вам ещё один пример, показывающий эффективность использования SingleA при разработке приложений на базе микросервисной архитектуры и подчёркивающий его влияние на DX.
#### Дашборд
Здесь под дашбордом имеется в виду страница, на которой собрана информация из различных источников. Лучшим примером может служить главная страница условного Яндекса: на ней выводятся новости, погода, объявления, количество непрочитанных писем в почте, информация о пробках на дорогах и многое другое. Все эти данные, скорее всего, живут в разных сервисах, для которых есть API. При создании дашборда, отображающего данные из разных систем, одним из естественных желаний может быть отправка асинхронных запросов в API этих систем со страницы дашборда. Сложность этого решения в том, что если в приложении, к которому относится дашборд, вы залогинены, то вот веб-сервисы, предоставляющие доступ к API необходимых систем, ничего о вас не знают.
> Тут стоит вспомнить диаграмму, приведённую в самом начале. POST-запросы между SSO и приложением не позволяют выполнить XHR-запросы, которые в другом случае могли бы пройти транзитом (если бы вместо POST-запросов были простые GET’ы).
>
>
Если представления пользователя у всех сервисов одинаковые (один и тот же набор свойств), то ещё можно посмотреть в сторону рассылки всем одного и того же JWT. Но как быть в случае, если набор свойств отличается? А если данные нужно шифровать, так как они содержат конфиденциальные сведения? В этом случае JWT для каждого API должен быть свой.
Вот тут-то SingleA и пригодится. Зайдя на страницу с дашбордом, пользователь пройдёт аутентификацию, общую для всех приложений и сервисов. После этого все асинхронные запросы к API будут дополнены токенами пользователя на этапе прохождения через nginx. И токен для каждого API будет содержать только те данные пользователя, которые нужны этому сервису. Обрабатывая запрос, каждый сервис будет знать о пользователе всё, что ему нужно, но не более.
В виде диаграммы последовательности сказанное можно изобразить следующим образом:
В случае, если срок сессии пользователя истечёт в процессе работы с приложением и Lua-клиент SingleA вернёт 403, достаточно будет перезагрузить страницу, что приведёт к редиректу пользователя на SSO с последующим возвращением на текущую страницу. Альтернативой может быть открытие отдельного фрейма с выполнением аутентификации в нём. Стоит обратить внимание: если на стороне SSO будет жива PHP сессия, пользователь будет автоматом перенаправлен обратно, то есть не будет никакого интерактива.
---
#### Бонус
Случалось ли вам сталкиваться со следующей ситуацией? После заполнения какой-нибудь формы (долгого и утомительного), вы отправляли её, и вместо сообщения об успехе, видели, как вас сначала редиректит на сервис аутентификации, откуда транзитом перекидывает обратно на ту же форму, но снова пустую. И вы понимали, что отправленные данные никуда по факту не отправились, а были потеряны из-за редиректа, и форму нужно заполнять заново. Кто сталкивался с этим хоть раз, наверное согласится, что допускать подобное поведение в своих приложениях — плохая идея.
В приложениях, использующих SingleA в качестве сервиса аутентификации, такое случится только в случае окончания срока жизни сессии на стороне SSO. Пока есть кука с ticket’ом и сессия жива, пользовательские запросы, включая POST, не пострадают, и пользователь не будет перенаправлен на SSO в процессе их обработки. По сути, ticket выступает аналогом Refresh Token’а из OAuth 2.0.
### Немного про статический анализ
Если всё вышесказанное описывало SingleA, то здесь я хотел бы сказать пару слов о процессе работы над этим проектом. За годы работы с кодом на PHP, если я что-то и усвоил, то это правило, что код и дизайн приложения нужно держать в чистоте и порядке. Для этого есть немало удобных инструментов, из которых для себя я выбрал: [PHP\_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer), [PHP-CS-Fixer](https://github.com/FriendsOfPHP/PHP-CS-Fixer), [PHP Mess Detector](https://github.com/phpmd/phpmd), [PHP Magic Number Detector](https://github.com/povils/phpmnd), [Deptrac](https://github.com/qossmic/deptrac), [Phan](https://github.com/phan/phan), [Psalm](https://github.com/vimeo/psalm) и [PHPStan](https://github.com/phpstan/phpstan). Когда этих инструментов стало слишком много для последовательно запуска, я открыл для себя ещё одну утилиту, позволяющую запускать весь этот зоопарк на машине разработчика параллельно — [GrumPHP](https://github.com/phpro/grumphp). Тогда мне только предстояло столкнуться с конфликтом зависимостей между разными утилитами анализа кода.
Когда эта участь настигла и меня, я посмотрел в сторону контейнерной изоляции утилит (как впоследствии выяснилось, я оказался не первым — в [jakzal/phpqa](https://github.com/jakzal/phpqa) уже эта идея была взята на вооружение). Мне захотелось совместить изоляцию утилит с удобством их конфигурирования и запуска через GrumPHP. Следствием стал инструмент [nbgrp/auditor](https://github.com/nbgrp/auditor), выполняющий все необходимые проверки в контейнере и имеющий приятный и удобный вывод в консоль результатов проверки. Он используется и локально, и в рамках GitHub Action’а, проверяющего каждый push.
Настройки непосредственно статических анализаторов (Phan, Psalm, PHPStan) я вывернул на максимум (с единичными исключениями), чтобы обезопасить себя и проект от как можно большего числа потенциальных ошибок. Трудно сказать, насколько усложняют работу над проектом инструменты, которые иногда требуют от тебя дополнительных проверок типов данных, рефакторинга избыточных или перегруженных методов и прочих изменений, от которых в ином случае можно было бы отмахнуться при “белковом” code review. Уверенно могу сказать одно: за время работы над SingleA “бездушная машина” уберегла меня от десятков ошибок в дизайне как отдельных классов, так и всего проекта. Это бесценно.
### Вместо итога
Когда после окончания университета я решил продолжить работу над SingleA и перевести его в разряд open-source’ных проектов, мои согруппники с удивлением спрашивали, зачем это мне. Ответ прост: задачи, которые решает SingleA, не решает ни один из известных мне продуктов, ни открытый, ни проприетарный (возможно такой есть, но мы не нашли друг друга). Если в результате всех моих усилий у разработчиков появится средство создания SSO’шного сервиса аутентификации, лишённого упомянутых в статье проблем, всё не зря.
С момента, когда я говорил эти слова, прошёл почти год. В моей позиции ничего не изменилось. Если SingleA может сделать вашу жизнь проще, а создаваемые вами продукты — надёжнее и функционально богаче, значит, я был прав и оно того стоило.
---
Не знаю, хорошо это или плохо, но статья вышла больше прозаической, чем технической. В ней нет красивых графиков и результатов многочисленных тестов (к сожалению, конечно), но есть история создания проекта и описание его работы с позиции создателя. Надеюсь, вы нашли такую точку зрения и сам проект интересными.
### Благодарности
Я бы хотел выразить свою огромную благодарность и признание людям, которые поддерживали меня и помогали советами, критикой и рекомендациями на всём пути создания SingleA. Некоторых из них хочу назвать поимённо.
* Дмитрий Письман, CDNnow
* Олег Суханов, Softline Group
* [Антон Назаров](https://www.linkedin.com/in/tonynazarov/)
Но самый главный вклад в работу над проектом внесла моя жена. Оля, спасибо за всю ту поддержку, которую я получал все эти без малого 2 года. Без тебя ничего этого не было бы!
---
Хабровчане, спасибо за внимание. Буду рад конструктивной критике в комментариях и постараюсь ответить на ваши вопросы. Всем добра! | https://habr.com/ru/post/666602/ | null | ru | null |
# Использование перехватов операций для бэкапа файлов в macOS “на лету”
Привет, Хабр! Меня зовут Денис Копырин, и сегодня я хочу рассказать о том, как мы решали проблему бэкапа по требованию на macOS. На самом деле интересная задача, с которой я столкнулся в институте, выросла в итоге в большой исследовательский проект по работе с файловой системой. Все подробности – под катом.
[](https://habr.com/ru/company/acronis/blog/484816/)
Не буду начинать издалека, скажу только, что началось все с проекта в МФТИ, который я разрабатывал вместе с моим научным руководителем на базовой кафедре Acronis. Перед нами стояла задача организации удаленного хранения файлов, а точнее – поддержки актуального состояния их резервных копий.
Для обеспечения сохранности данных мы используем расширение ядра macOS, которое собирает информацию о событиях в системе. В KPI для разработчиков имеется интерфейс KAUTH API, который позволяет получать нотификации об открытии и закрытии файла – и только. Если использовать KAUTH, необходимо полностью сохранять файл при открытии на запись, потому что события записи в файл оказываются недоступны разработчикам. Для наших задач такой информации было недостаточно. Ведь чтобы перманентно дополнять резервную копию данных, нужно понимать, куда именно пользователь (или вредонос :) записал новые данные в файл.
Но кого из разработчиков пугали ограничения ОС? Если API ядра не позволяет получить информацию об операциях записи, значит нужно придумать свой способ перехвата через другие средства ядра.
Сначала мы не хотели патчить ядро и его структуры. Вместо этого попробовали создать целый виртуальный том, который позволил бы нам перехватывать все запросы на чтение и запись, проходящие через него. Но при этом выяснилась одна неприятная особенность работы macOS: операционная система считает, что у нее не 1, а 2 USB-флешки, два диска и так далее. И от того, что второй том меняется при работе с первым, macOS начинает некорректно работать с накопителями. Проблем с этим методом оказалось настолько много, что от него пришлось отказаться.
### Поиск другого решения
Несмотря на ограничения KAUTH, этот KPI позволяет получить нотификацию об использовании файла для записи еще до всех операций. Разработчикам предоставляется доступ к BSD-абстракции файла в ядре — vnode. Как ни странно, оказалось, что пропатчить vnode проще, чем использовать фильтрацию тома. В структуре vnode имеется таблица функций, которые обеспечивают работу с реальными файлами. Поэтому у нас возникла идея подменить эту таблицу.
Идею сразу расценили как хорошую, но для ее реализации нужно было найти саму таблицу в структуре vnode, так как Apple нигде не документирует ее расположение. Для этого потребовалось изучить машинный код ядра, а также разобраться, можно ли писать в данный адрес так, чтобы система после этого не умерла.
Если таблица найдена, мы просто копируем ее в память, подменяем указатель и вставляем ссылку на новую таблицу в существующий vnode. Благодаря этому все операции с файлами будут проходить через наш драйвер, и мы сможем регистрировать все запросы пользователя, включая read и write. Поэтому поиск заветной таблицы стал нашей основной целью.
Учитывая, что Apple не очень-то хочет этого, для решения задачи нужно пытаться “угадать” расположение таблицы, используя эвристики для относительного расположения полей, или брать уже известную функцию, дизассемблировать ее и искать смещение из этой информации.
**Как искать смещение: простой способ**
Простейший способ нахождения смещения таблицы в vnode является эвристика, которая основывается на расположении полей в структуре ([ссылка на Github](https://github.com/apple/darwin-xnu/blob/a449c6a3b8014d9406c2ddbdc81795da24aa7443/bsd/sys/vnode_internal.h#L173)).
```
struct vnode
{
...
int (**v_op)(void *); /* vnode operations vector */
mount_t v_mount; /* ptr to vfs we are in */
...
}
```
Воспользуемся тем предположением, что нужное нам поле v\_op удалено ровно на 8 байт от v\_mount. Значение последнего можно получить при помощи публичного KPI ([ссылка на Github](https://github.com/apple/darwin-xnu/blob/a449c6a3b8014d9406c2ddbdc81795da24aa7443/bsd/vfs/kpi_vfs.c#L1469)):
```
mount_t vnode_mount(vnode_t vp);
```
Зная значение v\_mount, начнем искать “иголку в стоге сена” – будем воспринимать значение указателя на vnode ‘vp’ как uintptr\_t\*, значение vnode\_mount(vp) как uintptr\_t. Далее следуют итерации до “разумного” значения i, пока не выполнится условие ‘haystack[i]==needle’. И если предположение о расположении полей верно, смещение v\_op равно i-1.
```
void* getVOPPtr(vnode_t vp)
{
auto haystack = (uintptr_t*) vp;
auto needle = (uintptr_t) vnode_mount(vp);
for (int i = 0; i < ATTEMPTCOUNT; i++)
{
if (haystack[i] == needle)
{
return haystack + (i - 1);
}
}
return nullptr;
}
```
**Как искать смещение: дизассемблирование**
Несмотря на свою простоту, первый способ обладает существенным недостатком. Если Apple поменяет порядок полей в структуре vnode, простой метод сломается. Более универсальный, но менее тривиальный метод состоит в динамическом дизассемблировании ядра.
Например, рассмотрим дизассемблированную функцию ядра VNOP\_CREATE ([ссылка на Github](https://github.com/apple/darwin-xnu/blob/a449c6a3b8014d9406c2ddbdc81795da24aa7443/bsd/vfs/kpi_vfs.c#L3144)) в macOS 10.14.6. Интересные для нас инструкции помечены стрелкой ->.
`_VNOP_CREATE:
1 push rbp
2 mov rbp, rsp
3 push r15
4 push r14
5 push r13
6 push r12
7 push rbx
8 sub rsp, 0x48
9 mov r15, r8
10 mov r12, rdx
11 mov r13, rsi
-> 12 mov rbx, rdi
13 lea rax, qword [___stack_chk_guard]
14 mov rax, qword [rax]
15 mov qword [rbp+-48], rax
-> 16 lea rax, qword [_vnop_create_desc] ; _vnop_create_desc
17 mov qword [rbp+-112], rax
18 mov qword [rbp+-104], rdi
19 mov qword [rbp+-96], rsi
20 mov qword [rbp+-88], rdx
21 mov qword [rbp+-80], rcx
22 mov qword [rbp+-72], r8
-> 23 mov rax, qword [rdi+0xd0]
-> 24 movsxd rcx, dword [_vnop_create_desc]
25 lea rdi, qword [rbp+-112]
-> 26 call qword [rax+rcx*8]
27 mov r14d, eax
28 test eax, eax
….`
```
errno_t
VNOP_CREATE(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode_attr * vap, vfs_context_t ctx)
{
int _err;
struct vnop_create_args a;
a.a_desc = &vnop_create_desc; a.a_dvp = dvp; a.a_vpp = vpp;
a.a_cnp = cnp; a.a_vap = vap; a.a_context = ctx;
_err = (*dvp->v_op[vnop_create_desc.vdesc_offset])(&a);
…
```
Будем сканировать ассемблерные инструкции для нахождения сдвига в vnode dvp. “Целью” ассемблерного кода является вызов функции из таблицы v\_op. Для этого процессор должен проделать следующие шаги:
1. Загрузить dvp в регистр
2. Разыменовать его для получения v\_op (строка 23)
3. Получить vnop\_create\_desc.vdesc\_offset (строка 24)
4. Вызвать функцию (строка 26)
Если с шагами 2-4 все ясно, то с первым шагом возникают сложности. Как понять в какой регистр был загружен dvp? Для этого использовался метод эмуляции функции, который наблюдает за перемещениями нужного указателя. Согласно конвенции вызовов System V x86\_64, первый аргумент передается в регистре rdi. Поэтому мы решили следить за всеми регистрами, которые содержат rdi. В моем примере это регистры rbx и rdi. Также копия регистра может быть сохранена в стеке, что встречается в debug-версии ядра.
Зная, что регистры rbx и rdi хранят dvp, мы узнаем, что в строке 23 производилось разыменование vnode для получения v\_op. Так получаем предположение, что смещение в структуре равно 0xd0. Для подтверждения верного решения продолжаем сканирование и убеждаемся, что функция вызвана корректно (строки 24 и 26).
Данный метод является более безопасным, но, к сожалению, и он обладает недостатками. Нам приходится полагаться на то, что паттерн функции (а именно 4 шага, о которых мы говорили выше) будет таким же. Впрочем, вероятность изменения паттерна функции на порядок меньше, чем вероятность изменения порядка полей. Так что мы решили остановиться на втором методе.
### Подменяем указатели в таблице
После нахождения v\_op возникает вопрос, как использовать этот указатель? Есть два различных способа — перезаписать функцию в таблице (третья стрелка на картинке) или перезаписать таблицу в vnode (вторая стрелка на картинке).
Сначала кажется, что первый вариант выгоднее, ведь нам всего-лишь необходимо подменить один указатель. Однако этого подхода есть 2 существенных недостатка. Во-первых, таблица v\_op является одинаковой для всех vnode данной файловой системы (v\_op для HFS+, v\_op для APFS, …), поэтому нужна фильтрация по vnode, что может быть очень дорого – отсеивать лишние vnode придется на каждой операции записи. Во-вторых, таблица записана на Read-Only странице. Это ограничение можно обойти, если использовать запись через IOMappedWrite64, минуя проверки системы. Также если kext с драйвером файловой системы будет отгружен, то будет сложно понять, как убрать патч.
Второй вариант оказывается более точечным и безопасным – перехватчик будет вызываться только для необходимой vnode, а память vnode изначально разрешает операции Read-Write. Так как производится замена всей таблицы, необходимо выделять чуть больше памяти (80 функций вместо одной). А поскольку количество таблиц обычно равно количеству файловых систем, ограничение по памяти оказывается и вовсе ничтожным.
Именно поэтому в kext используется второй способ, хотя, повторюсь, на первый взгляд кажется, что этот вариант хуже.
В итоге наш драйвер работает по следующей схеме:
1. KAUTH API предоставляет vnode
2. Мы производим подмену таблицы vnode. Если требуется, перехватываем операции только для “интересных” vnode, например пользовательских документов
3. При перехвате проверяем, какой именно процесс производит запись, отсеиваем “своих”
4. Отправляем синхронный запрос UserSpace клиенту, который принимает решение о том, что именно нужно сохранить.
### Что получилось
На сегодняшний день у нас есть экспериментальный модуль, который является расширением ядра macOS и учитывает любые изменения файловой системы на гранулярном уровне. Стоит отметить, что в macOS 10.15 Apple ввел новый фреймворк ([ссылка на EndpointSecurity](https://developer.apple.com/documentation/endpointsecurity?language=objc)) для получения нотификаций об изменениях файловой системы, который планируется для использования в Active Protection, поэтому описанное в статье решение объявлено deprecated. | https://habr.com/ru/post/484816/ | null | ru | null |
# Анализ одного рефакторинга
В данном крохотном посте речь пойдет об одной из глав, книги «Принципы, паттерны и методики гибкой разработки на языке C#», с названием «Рефакторинг». Глава полностью посвящена рефакторингу. На примере одного большого метода, автор последовательно модифицирует код, попутно объясняя почему он делает те или иные модификации. После каждого этапа, код прогоняется через тесты.
Очевидно, что многие примеры из книг, часто являются синтетическими, и предназначены только для пояснения какой-либо мысли статьи. По этому часто в книгах присутствуют как синтаксические так и логические ошибки, и обычно, это ни как не ухудшает восприятие книги.
Статья не преследует цели дискредитации автора, просто показалось интересным выложить свои наблюдения и услышать мнение сообщества по этому поводу.
**Приступим. Первоначальный метод, который автор подверг изменениям:**
```
///
/// Этот класс генерирует простые числа, не превышающие заданного
/// пользователем порога. В качестве алгоритма используется решето
/// Эратосфена.
///
/// Эратосфен Киренский, 276 г. до н. э., Кирена, Ливия --
/// 194 г. до н. э., Александрия. Впервые измерил окружность Земли.
/// Известен также работами по составлению календаря с високосными
/// годами. Работал в Александрийской библиотеке.
///
/// Сам алгоритм прост. Пусть дан массив целых чисел, начинающийся
/// с 2. Вычеркиваем все кратные 2. Находим первое невычеркнутое
/// число и вычеркиваем все его кратные. Повторяем, пока не
/// дойдем до квадратного корня из максимального значения.
///
/// Написал Роберт К. Мартин 9.12.1999 на языке Java
/// Перевел на C# Мика Мартин 12.01.2005.
///
using System;
///
/// автор: Роберт К. Мартин
///
public class GeneratePrimes
{
///
/// Генерирует массив простых чисел.
///
///
/// Верхний порог.
public static int[] GeneratePrimeNumbers(int maxValue)
{
if (maxValue >= 2) // единственный допустимый случай
{
// объявления
int s = maxValue + 1; // размер массива
bool[] f = new bool[s];
int i;
// инициализировать элементы массива значением true.
for (i = 0; i < s; i++)
f[i] = true;
// исключить заведомо не простые числа
f[0] = f[1] = false;
// решето
int j;
for (i = 2; i < Math.Sqrt(s) + 1; i++)
{
if (f[i]) // если i не вычеркнуто, вычеркнуть его кратные.
{
for (j = 2 * i; j < s; j += i)
f[j] = false; // кратное – не простое число
}
}
// сколько оказалось простых чисел?
int count = 0;
for (i = 0; i < s; i++)
{
if (f[i])
count++; // увеличить счетчик
}
int[] primes = new int[count];
// поместить простые числа в результирующий массив
for (i = 0, j = 0; i < s; i++)
{
if (f[i]) // если простое
primes[j++] = i;
}
return primes; // вернуть простые числа
}
else // maxValue < 2
return new int[0]; // если входные данные не корректны,
// возвращаем пустой массив
}
}
```
**Конечный вариант, на котором заканчивается статья, но автор упоминает, что теоретически, можно еще продолжить:**
```
///
/// Этот класс генерирует простые числа, не превышающие заданного
/// пользователем порога. В качестве алгоритма используется решето
/// Эратосфена.
/// Пусть дан массив целых чисел, начинающийся с 2:
/// Находим первое невычеркнутое число и вычеркиваем все его
/// кратные. Повторяем, пока в массиве не останется кратных.
///
using System;
public class PrimeGenerator
{
private static bool[] crossedOut;
private static int[] result;
public static int[] GeneratePrimeNumbers(int maxValue)
{
if (maxValue < 2)
return new int[0];
else
{
UncrossIntegersUpTo(maxValue);
CrossOutMultiples();
PutUncrossedIntegersIntoResult();
return result;
}
}
private static void UncrossIntegersUpTo(int maxValue)
{
crossedOut = new bool[maxValue + 1];
for (int i = 2; i < crossedOut.Length; i++)
crossedOut[i] = false;
}
private static void PutUncrossedIntegersIntoResult()
{
result = new int[NumberOfUncrossedIntegers()];
for (int j = 0, i = 2; i < crossedOut.Length; i++)
{
if (NotCrossed(i))
result[j++] = i;
}
}
private static int NumberOfUncrossedIntegers()
{
int count = 0;
for (int i = 2; i < crossedOut.Length; i++)
{
if (NotCrossed(i))
count++; // увеличить счетчик
}
return count;
}
private static void CrossOutMultiples()
{
int limit = DetermineIterationLimit();
for (int i = 2; i <= limit; i++)
{
if (NotCrossed(i))
CrossOutputMultiplesOf(i);
}
}
private static int DetermineIterationLimit()
{
// У каждого составного числа в этом массиве есть простой
// множитель, меньший или равный квадратному корню из размера
// массива, поэтому необязательно вычеркивать кратные, большие
// корня.
double iterationLimit = Math.Sqrt(crossedOut.Length);
return (int)iterationLimit;
}
private static void CrossOutputMultiplesOf(int i)
{
for (int multiple = 2 * i;
multiple < crossedOut.Length;
multiple += i)
crossedOut[multiple] = true;
}
private static bool NotCrossed(int i)
{
return crossedOut[i] == false;
}
}
```
##### Беглый анализ
На мой взгляд, в первом примере вообще рефакторинг не нужен, достаточно просто удалить лишние комментарии, но тогда глава была бы не интересная (смайл). В конечном варианте меня смущает только подряд идущие методы, которые не принимают и не возвращают параметры. По моему ощущению, понять логику такой цепочки сложнее, так как не за что зацепиться.
##### Подробный анализ
Итак, первое что мы видим, то что метод является чистой функцией и не имеет побочных эффектов. Отсюда вытекает его детерминированность — при одних и тех же входных параметрах мы получаем одни и те же выходные параметры. После модификации, автор вынес локальные переменные из метода в класс, тем самым добавив состояние классу и добавил побочные эффекты нашему методу. Чем это плохо? Плохо это тем, что раньше наш метод был потокобезопасным, а после этого стал потокоопасным. Получается автор (или мы), невольно добавили потенциальный баг в метод, который рефакторили, при условии использования в многопоточной среде.
Во вторых, так как переменные все же являются локальными для метода (методов) и не отражают состояние класса, то в дальнейшем, при добавлении методов или состояния, будет сложнее разбираться, чьи же это переменные и зачем они нужны.
##### Вместо заключения
Рефакторинг это прекрасно! Но часто, мы сталкиваемся с проблемой яйца и курицы: чтобы понять как работает код, его необходимо отрефакторить, а чтобы отрефакторить, нужно понимать как он работает.
Всем спасибо за внимание, жду ваших комментариев. | https://habr.com/ru/post/231325/ | null | ru | null |
# Gson шпаргалка для Map, List и Array
Постоянно сталкиваясь с парсингом Json всегда подглядываю в старых проектах или на встретившуюся реализацию объекта на [stackoverflow.com](http://stackoverflow.com/).
Решил собрать три основных типа в шпаргалку Map, List, Array.
```
Type itemsMapType = new TypeToken>() {}.getType();
Type itemsListType = new TypeToken>() {}.getType();
Type itemsArrType = new TypeToken() {}.getType();
```
Рассматривается Serialization/Deserialization операции класса:
```
public class GoodsItem{
String name;
float price;
public GoodsItem(String name, float price) {
this.name = name;
this.price = price;
public String toString(){
return name + " : " + price;
}
}
```
Serialization/Deserialization выполнен с использованием библиотеки Gson. В качестве «испытуемого» рассматривается класс GoodsItem.
**HashMap**
```
Map mapItems = new HashMap();
mapItems.put(1, new GoodsItem("Samsung", 51200.6f));
mapItems.put(2, new GoodsItem("Lg", 5400.6f));
mapItems.put(3, new GoodsItem("Alcatel", 4500.6f));
String jsonStr = new Gson().toJson(mapItems);
System.out.println(jsonStr);
```
Результат Serialization:
```
{
"1":{"name":"Samsung","price":51200.6},
"2":{"name":"Lg","price":5400.6},
"3":{"name":"Alcatel","price":4500.6}
}
```
```
Map mapItemsDes = new Gson().fromJson(jsonStr, itemsMapType);
System.out.println(mapItemsDes.toString());
```
Результат Deserialization:
```
{1=Samsung : 51200.6, 2=Lg : 5400.6, 3=Alcatel : 4500.6}
```
**ArrayList**
```
List listItems = new ArrayList();
listItems.add( new GoodsItem("Samsung" , 51200.6f));
listItems.add( new GoodsItem("Lg" , 5400.6f));
listItems.add( new GoodsItem("Alcatel" , 4500.6f));
String jsonStr = new Gson().toJson(listItems);
System.out.println(jsonStr);
```
Результат Serialization:
```
[
{"name":"Samsung","price":51200.6},
{"name":"Lg","price":5400.6},
{"name":"Alcatel","price":4500.6}
]
```
```
List listItemsDes = new Gson().fromJson(jsonStr,itemsListType);
System.out.println(listItemsDes.toString());
```
Результат Deserialization:
```
[Samsung : 51200.6, Lg : 5400.6, Alcatel : 4500.6]
```
**Array**
```
GoodsItem[] arrItems = new GoodsItem[3];
arrItems[0] = new GoodsItem("Samsung", 51200.6f);
arrItems[1] = new GoodsItem("Lg", 5400.6f);
arrItems[2] = new GoodsItem("Alcatel", 4500.6f);
String jsonStr = new Gson().toJson(arrItems);
System.out.println(jsonStr);
```
Результат Serialization:
```
[
{"name":"Samsung","price":51200.6},
{"name":"Lg","price":5400.6},
{"name":"Alcatel","price":4500.6}
]
```
```
GoodsItem[] arrItemsDes = new Gson().fromJson(jsonStr, itemsArrType);
System.out.println(Arrays.toString(arrItemsDes));
```
Результат Deserialization:
```
[Samsung : 51200.6, Lg : 5400.6, Alcatel : 4500.6]
```
Как видно ArrayList и простой массив объектов преобразуются в одинаковую строку Json.
Полезные инструменты:
[parcelabler.com](http://www.parcelabler.com/) дает возможность по типу класса сгенерировать parcelable методы для Android. Например для класса GoodsItem:
**public class GoodsItem implements Parcelable**
```
public class GoodsItem implements Parcelable {
String name;
float price;
public GoodsItem(String name, float price) {
this.name = name;
this.price = price;
public String toString(){
return name + " : " + price;
}
protected GoodsItem(Parcel in) {
name = in.readString();
price = in.readFloat();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeFloat(price);
}
@SuppressWarnings("unused")
public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
@Override
public GoodsItem createFromParcel(Parcel in) {
return new GoodsItem(in);
}
@Override
public GoodsItem[] newArray(int size) {
return new GoodsItem[size];
}
};
}
```
[jsonschema2pojo.org](http://www.jsonschema2pojo.org/) — Generate Plain Old Java Objects from JSON or JSON-Schema.
Было бы интересно узнать, чем пользуетесь вы в своих проектах. | https://habr.com/ru/post/253266/ | null | ru | null |
# Реверсим «Нейроманта». Часть 2: Рендерим шрифт
Привет, ты читаешь продолжение статьи, посвящённой реверс-инжинирингу «Нейроманта» — видеоигры, выпущенной компанией *Interplay Productions* в 1988 году по мотивам одноимённого романа Уильяма Гибсона. И, если ты не видел [первую часть](https://habr.com/post/352050/), то рекомендую начать с неё, там я рассказываю о своей мотивации и делюсь первыми результатами.
> [Реверсим «Нейроманта». Часть 1: Спрайты](https://habr.com/post/352050/)
А мы продолжаем буквально с того же места, на котором остановились в прошлый раз.
---
Исходя из предположения, что в `.PIC` хранятся такие же битмапы, можно попробовать применить к `.PIC`-файлам те же самые функции, которыми я распаковывал `.IMH`-ресурсы. Беру первый попавшийся `.PIC` (`R1.PIC`) и читаю его в буфер:
```
R1.PIC: 4934 байта
0x0000: 0008 010a 000f 020c 0102 020f 0600 0f0f
0x0010: 0004 060e 0000 0607 0309 010f 0a0d 0d0f
0x0020: 981d 0000 2002 0611 74a2 38c5 d003 e9cb
0x0030: fb18 ac3b 8fbf 2713 459e 8c3f 3aa1 6ca7
...
0x1330: 6f8a c3f5 d9c7 53e5 f47c d945 51d9 c753
0x1340: e5bf 1ebf 3f00
```
Отлично, этот файл начинается так же, как и любой `.IMH`:
* `0x00:0x1F` — 32 байта неизвестного назначения *[в прошлой части я ошибочно полагал, что это палитра, но что это на самом деле — я до сих пор не выяснил]*;
* `word 0x20` — байтовый размер данных после декомпрессии *[я понял это несколько позже, когда заметил, что размер выходных данных алгоритма декомпрессии совпадает с этим значением]*;
* `word 0x22` — ноль, отделяющий данные *[вполне возможно, что это второй ворд длины, но здесь я не встречал таких больших значений]*.
Теперь осторожно, под отладчиком, пробуем это декодировать. Функция декомпрессии завершается успешно и возвращает длину разжатых данных:
```
R1.PIC_decompd: 7576 байт
0x0000: e901 1130 1113 0111 3011 1301 1130 1113
0x0010: 0111 3011 1301 3130 0113 f801 3330 1333
...
0x1d80: 00ff 0816 00fe 8000 0108 0100 0180 ff08
0x1d90: 2b00 ff80 0288 0200
```
Но то, что я здесь вижу, несколько отличается от того, что я наблюдал после декомпрессии `.IMH`-ресурсов. Нет, это по-прежнему выглядит как битмап, закодированный тем же *Run-Length* алгоритмом, но без заголовка \_[`struct rle_hdr_t` из прошлой части]*, содержащего пиксельные размеры. Это нехорошо, ведь я использовал эти размеры для своевременной остановки алгоритма декодирования* [функция `decode_rle()` из прошлой части]\_ и построения `.BMP`-заголовка. Если предположить, что там закодировано только одно изображение, то для остановки алгоритма хватило бы и длины входных данных, а вот для сохранения картинки в `.BMP` уже никак не обойтись без линейных размеров.
Но будем решать проблемы по мере их поступления. Допустим, что в каждом `.PIC` действительно хранится по одному изображению, и их пиксельные размеры одинаковы. Переделываю функцию `decode_rle()` так, чтобы она считала количество обработанных *входных* байт, а не раскодированных выходных. Пропускаю через неё буфер `r1_pic_decompd`. Завершается успешно, вернув мне битмап размером 34048 байта (17024 \* 2, с учётом того, что в одном байте записаны значения двух пикселей):
```
R1.PIC_decoded: 17024 байта
0x0000: 0111 3011 1301 1130 1113 0111 3011 1301
0x0010: 1130 1113 0131 3013 1301 3330 1333 0333
...
0x4270: 7777 7777 7777 7777 7708 8800 0088 8880
```
Ширина и высота по-проженему неизвестны, но я думаю, что имею дело с бэкграундами локаций, а значит, можно попытаться замерить их прямо в игре. Но всё ещё проще, ведь среди экспортированных `.IMH`-ресурсов нашлось изображение внутриигрового пользовательского интерфейса в натруральную величину (`NEURO.IMH`). Открываю изображение в *Paint* и делаю замеры:
Перемножение ширины и высоты даёт нужные 34048 байта — можно смело заворачивать этот и все остальные задники в `.BMP` (всего 55 штук):
---
На этой волне можно попробовать расколоть типы ресурсов неизвестного назначения — `.BIH` и `.ANH`. Действую по старой схеме: читаю рандомный файл; если похоже на то, что можно разжать — разжимаю; если похоже на *RLE* — декодирую. И, в общем-то, план сработал, но то, что внутри, так сказать… неоднозначно. Беру, к примеру, содержимое ресурса `R1.BIH` после декомпрессии:
```
R1.BIH_decompd: 2151 байт
0x0000: 00 00 00 00 00 00 fe 00 2a 00 00 00 00 00 fb 00 ......ю.*.....ы.
0x0010: fd 00 fc 00 00 00 c7 00 46 5a 5a 5f 9b 5f 9f 73 э.ь...З.FZZ_._џs
0x0020: 46 73 5a 77 00 5f 02 73 01 00 2e 00 7a 00 01 02 FsZw._.s....z...
0x0030: 13 00 03 04 05 12 00 7f 2c 00 08 14 00 2e 13 00 ........,.......
0x0040: 0e 3d 00 01 00 0e 12 00 ff ff 0e 14 00 00 00 03 .=......яя......
0x0060: 01 11 16 db 00 01 1f 02 20 0e 14 00 00 00 0e 12 ...Ы.... .......
0x0070: 00 ff ff 12 06 10 00 ff cc ff 05 10 00 06 07 00 .яя....яМя......
0x0080: 01 08 04 04 00 01 07 04 bc ff 01 0b 13 00 0c 03 ........јя......
0x0090: 17 05 10 00 ff 05 00 04 f9 ff 05 10 00 0c 07 00 ....я...щя......
0x00A0: 01 0f 04 0a 00 05 10 00 0d 0b 00 01 10 13 00 0c ................
0x00B0: 03 04 df ff 01 13 13 00 17 02 06 10 00 ff f8 ff ..Яя.........яшя
0x00C0: 05 10 00 17 07 00 01 19 04 ed ff 13 00 1b 02 01 .........ня.....
0x00D0: 1a 06 10 00 ff fc ff 05 10 00 1b 07 00 01 1d 04 ....яья.........
0x00E0: 04 00 01 1e 13 00 ff 00 04 ff ff e8 13 00 81 c3 ......я..яяи..ЃГ
0x00F0: 04 00 8b 1f 8b 47 14 01 87 ca 00 83 97 cc 00 00 .....G...К.ѓ—М..
0x0100: cb e8 01 00 90 5b 81 eb f4 00 c3 cb cb cb 59 6f Ли..ђ[Ѓлф.ГЛЛЛYo
0x0110: 75 27 76 65 20 6a 75 73 74 20 73 70 65 6e 74 20 u've just spent
0x0120: 74 68 65 20 6e 69 67 68 74 20 73 6c 65 65 70 69 the night sleepi
0x0130: 6e 67 20 66 61 63 65 2d 64 6f 77 6e 20 69 6e 20 ng face-down in
0x0140: 61 20 70 6c 61 74 65 20 6f 66 20 73 79 6e 74 68 a plate of synth
0x0150: 2d 73 70 61 67 68 65 74 74 69 20 69 6e 20 61 20 -spaghetti in a
0x0160: 62 61 72 20 63 61 6c 6c 65 64 20 74 68 65 20 43 bar called the C
0x0170: 68 61 74 73 75 62 6f 2e 20 41 66 74 65 72 20 72 hatsubo. After r
0x0180: 75 62 62 69 6e 67 20 74 68 65 20 73 61 75 63 65 ubbing the sauce
0x0190: 20 6f 75 74 20 6f 66 20 79 6f 75 72 20 65 79 65 out of your eye
0x01A0: 73 2c 20 79 6f 75 20 63 61 6e 20 73 65 65 20 43 s, you can see C
0x01B0: 68 69 62 61 20 73 6b 79 20 74 68 72 6f 75 67 68 hiba sky through
0x01C0: 20 74 68 65 20 77 69 6e 64 6f 77 2c 20 74 68 65 the window, the
0x01D0: 20 63 6f 6c 6f 72 20 6f 66 20 74 65 6c 65 76 69 color of televi
0x01E0: 73 69 6f 6e 20 74 75 6e 65 64 20 74 6f 20 61 20 sion tuned to a
0x01F0: 64 65 61 64 20 63 68 61 6e 6e 65 6c 2e 0d 0d 41 dead channel...A
...
0x0840: 3f 00 0d 0d 52 61 74 7a 20 72 65 66 75 73 65 73 ?...Ratz refuses
0x0850: 20 74 6f 20 74 61 6b 65 20 79 6f 75 72 20 63 72 to take your cr
0x0860: 65 64 69 74 73 2e 00 edits..
```
*[Да, это именно то, о чём вы подумали.]* Другие файлы с именами `R%n.BIH` имеют схожую структуру: некоторое количество байт сверху, за которыми следует полотно текста. Очевидно, я имею дело с внутриигровыми строками, разделёнными по локациям, к которым они относятся *[`R1` — первая, `R2` — вторая и так далее. Стартовая локация, к примеру, подгружает задник из `R1.PIC`, а первый текст, который мы там увидим, это: `You've just spent the night sleeping face-down in a plate of synth-spaghetti in a bar called the Chatsubo`]*. Байты из вехней части организуют некую управляющую структуру, но в отрыве от кода разобрать её не удастся, попробую заглянуть в другие `.BIH` файлы:
```
CORNERS.BIH_decompd: 128 байт
0x0000: ff ff f0 00 ff f0 0f ff ff 0f ff ff f0 ff ff ff яяр.яр.яя.яяряяя
0x0010: f0 ff ff ff 0f ff ff ff 0f ff ff ff 0f ff ff ff ряяя.яяя.яяя.яяя
0x0020: 00 00 ff ff 0f ff 00 ff 0f ff ff 0f 0f ff ff f0 ..яя.я.я.яя..яяр
0x0030: 0f ff ff f0 0f ff ff ff 0f ff ff ff 0f ff ff ff .яяр.яяя.яяя.яяя
0x0040: 0f ff ff ff 0f ff ff ff 0f ff ff ff f0 ff ff ff .яяя.яяя.яяяряяя
0x0050: f0 ff ff ff ff 0f ff ff ff f0 0f ff ff ff f0 00 ряяяя.яяяр.яяяр.
0x0060: ff ff ff f0 ff ff ff f0 ff ff ff f0 ff ff ff 0f яяяряяяряяяряяя.
0x0070: ff ff ff 0f ff ff f0 ff ff f0 0f ff 00 0f ff ff яяя.яяряяр.я..яя
```
```
ROOMPOS.BIH_decompd: 1160 байт
0x0000: 68 8f 75 0d 4b 69 00 02 8e 63 02 17 71 74 29 02 hЏu.Ki..Ћc..qt).
0x0010: 0e 63 02 17 68 8f 75 15 72 69 24 02 8e 63 02 17 .c..hЏu.ri$.Ћc..
0x0020: 15 74 7a 02 16 63 02 17 68 8f 75 0d 2a 69 00 02 .tz..c..hЏu.*i..
0x0030: 8e 63 02 17 08 74 8c 02 0e 63 02 17 70 63 75 0d Ћc...tЊ..c..pcu.
...
0x0470: 0e 6b 02 0f 6e 8f 75 0d 08 6f 8c 02 8e 69 02 11 .k..nЏu..oЊ.Ћi..
0x0480: 08 74 8c 02 0e 69 02 11 .tЊ..i..
```
То, что я здесь вижу, совсем не похоже на паттерн, который я наблюдал в `R%n.BIH`. Они даже не похожи друг на друга! Содержимое `CORNERS.BIH` напоминает битмап, а `ROOMPOS.BIH`, судя по названию, может иметь отношение к позиционированию объектов на локации, но его содержимое — непонятно.
Кроме этих, ещё есть: `COPEN%n.BIH`, `DB%nBIH`, `FIJU0.BIH`, `HITACHI0.BIH` и много других, но они похожи на `R%n.BIH` хотя бы тем, что содержат в себе читабельный текст, а вот заголовки местами различаются. Оставлю это на потом и посмотрю, что там с `.ANH`.
Здесь ситуация лучше. Все `.ANH` озаглавены как `R%n.ANH`, значит, они так или иначе относятся к локациям. Их не много: если для всех `n` присутствуют `R%n.PIC` и `R%n.BIH`, то соответсвующий `R%n.ANH` встречается лишь для некоторых `n`. Они сжаты всё тем же алгоритмом, посмотрим, что внутри:
```
R1.ANH_decomp: 1100 байт
0x0000 04 00 4e 01 0f 00 17 00 00 00 0c 00 00 00 02 00 ..N.............
0x0010 0e 00 03 00 0e 00 01 00 0e 00 02 00 0e 00 02 00 ................
0x0020 0e 00 03 00 0e 00 01 00 0e 00 02 00 0e 00 0e 00 ................
0x0030 00 00 15 00 19 00 03 00 72 00 11 00 72 00 03 00 ........r...r...
0x0040 ba 00 23 25 03 17 fd 87 00 87 3e 00 ff 44 01 00 є.#%..э...>.яD..
...
0x0160 73 00 04 00 73 00 03 00 73 00 14 00 73 00 04 00 s...s...s...s...
0x0170 00 00 03 00 00 00 03 00 73 00 04 00 73 00 04 00 ........s...s...
0x0180 00 00 03 00 00 00 03 00 73 00 04 00 73 00 0e 00 ........s...s...
0x0190 00 00 17 00 00 00 03 00 73 00 04 00 73 00 04 00 ........s...s...
0x01A0 00 00 03 00 00 00 03 00 73 00 04 00 73 00 1b 30 ........s...s..0
0x01B0 0b 10 01 00 ff 03 09 00 ff 30 08 00 fc 13 30 08 ....я...я0..ь.0.
...
0x0430 30 02 05 fe 08 88 02 08 fb 88 08 00 08 00 71 36 0..ю.€..ы€....q6
0x0440 02 05 fe 00 80 02 08 ff 88 03 08 00 ..ю.Ђ..я€...
```
Увы, здесь мало полезного, ну и ладно, буду разбираться по ходу дела. Пока можно заняться другими вещами. *[Как-то раз, запустив в игре стартовую локацию, я зметил, что задник этой локации анимирован. И это интересно, учитывая, что в `.PIC` лежат статичные изображения. Пока не проверено, но я думаю, что именно в `.ANH` содержатся эти анимации.]*
---
Некоторое время потратил на написание простенькой оконной утилитки — просмотрщика ресурсов. В процессе пришлось переехать с 2017-й студии на 2015-ю в связи с тем, что в первой сломано MFC. В том же солюшене я создал проект библиотеки `LibNeuroRoutines`, в которую постепенно буду добавлять реверснутые процедуры из оригинальной игры. Первым же делом туда попали функции декомпрессии и декодирования ресурсов. Удобно держать эти вещи отдельно.
---
Перечитав [заметку о реверс-инжиниринге](http://wiki.scummvm.org/index.php/HOWTO-Reverse_Engineering) на вики проекта *ScummVM*, решил пореверсить местный рендеринг текста. *[Сперва я надеялся просто извлечь шрифты, но, в итоге, это позволило мне добиться гораздо большего.]* Сделать первые шаги в этом направлении было легко — изучая функцию `main` в дизассемблированном листинге, я обнаружил функцию, принимающую на вход адрес строки, отображаемой в главном меню игры — "`New/Load`":
```
...
sub ax, ax
push ax
mov ax, 1
push ax
mov ax, 5098h ; "New/Load"
push ax
call sub_13C6E ; sub_13C6E("New/Load", 1, 0)
...
```
Выполнив функцию `sub_13C6E` под отладчиком, убеждаюсь в том, что именно она выводит на экран переданную строку:
И тут можно было бы начать её трассировать, но есть нюанс, она не принимает ничего похожего на координаты. При этом текст отрисовывается точно в центре рамки. Может, она также отрисовывается в этой функции? Но при чём здесь аргументы 1 и 0? Тогда я обратил внимание на вызов другой функции, сразу над `sub_13C6E`:
```
...
sub ax, ax
push ax
push ax
mov ax, 1
push ax
mov ax, 0Ah
push ax
mov ax, 14h
push ax
mov ax, 5
push ax
mov ax, 6
push ax
call sub_13A9E ; sub_13A9E(6, 5, 20, 10, 1, 0, 0)
add sp, 0Eh
sub ax, ax
push ax
mov ax, 1
push ax
mov ax, 5098h ; "New/Load"
push ax
call draw_string ; draw_string("New/Load", 1, 0)
...
```
Потрассировав этот код я увидел, что функция `sub_13A9E` рендерит рамку, а функция `draw_string` — текст в ней. Вероятно, что эти вызовы связаны через какие-то глобальные переменные. В любом случае, начинать разбираться лучше с `sub_13A9E`, тем более, что она принимает интересный набор аргументов.
Нужно сделать замеры и посмотреть — соотносятся ли как-нибудь измерения со значениями этих аргументов. Какой-то очевидной зависмости между числами здесь не наблюдается, а значит, будем трассировать `sub_13A9E`.
Вот, что там происходит: во первых, в сегменте данных заполняется некая структура (в комментариях я указал очерёдность выполнения и конкретные операции, вычисляющие записываемое значение):
```
; sub_13A9E(6, 5, 20, 10, 1, 0, 0)
; (a, b, c, d, e, f, g)
.dseg
...
word[0x65FA]: 0x20 ; 10: word[0x6602] - 8 = 32
word[0x65FC]: 0x98 ; 11: word[0x6604] - 8 = 152
word[0x65FE]: 0x7F ; 12: word[0x6606] + 8 = 127
word[0x6600]: 0xAF ; 13: word[0x6608] + 8 = 175
word[0x6602]: 0x28 ; 2: b << 3 = 40
word[0x6604]: 0xA0 ; 3: c << 3 = 160
word[0x6606]: 0x77 ; 4: (d << 3) + word[0x6602] - 1 = 119
word[0x6608]: 0xA7 ; 5: (e << 3) + word[0x6604] - 1 = 167
word[0x660A]: 0x28 ; 6: word[0x6602] = 40
word[0x660C]: 0xA0 ; 7: word[0x6604] = 160
word[0x660E]: 0x77 ; 8: word[0x6606] = 119
word[0x6610]: 0xA7 ; 9: word[0x6608] = 167
word[0x6612]: 0x06 ; 1: a = 6
word[0x6614]: 0x00 ; 14: 0
...
word[0x66D6]: 0x30 ; 17: (d << 2) + 8 = 48
word[0x66D8]: 0x02 ; 15: 2
word[0x66DA]: 0x22FB ; 16: seg11
```
Нельзя не заметить, что в вордах по адресам `0x65FA` и `0x65FC` расположились координаты левого (32) верхнего (152) угла рамки, соответсвенно. Если пойти дальше и вычесть эти значения из тех, что записаны в `0x65FE` и `0x6600`, то мы получим 95 и 23. Добавив по единице, выйдет аккурат ширина (96) и высота (24) рамки. Весьма занятно. Теперь, если проименовать аргументы функции `draw_frame` (`sub_13A9E`) от `a` до `e` *[последние два аргумента функцией не используются, вероятно они просто добавлены компилятором]*, то можно вывести следующие выражения:
```
left = b * 8 - 8 = (b - 1) * 8
top = c * 8 - 8 = (c - 1) * 8
width = (d * 8) + (b * 8) + 8 - ((b * 8) - 8) = (d * 8) + 16 = (d + 2) * 8
height = (e * 8) + (c * 8) + 8 - ((c * 8) - 8) = (e * 8) + 16 = (e + 2) * 8
```
После заполнения рассмотренной структуры, по адресу `[0x66DA]:[0x66D8]` (*22FB:0002 — сегмент: смещение*) строится битмап-изображение рамки вычисленных размеров, которое затем построчно переносится в VGA-память, начиная с адреса (в VGA-буфере), соответсвующего вычисленной координате левого верхнего угла (`152 * 320 + 32 = 0xBE20, A000:BE20`):
**так выглядит рамка в памяти**
```
SEG11:
22FB:0002 0000 0000 3000 1800
22FB:000A 000000000000000000000000...000000000000000000000000
22FB:003A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:006A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:009A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:00CA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:00FA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:012A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:015A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:018A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:01BA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:01EA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:021A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:024A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:027A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:02AA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:02DA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:030A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:033A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:036A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:039A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:03CA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:03FA 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:042A 0FFFFFFFFFFFFFFFFFFFFFFF...FFFFFFFFFFFFFFFFFFFFFFF0
22FB:045A 000000000000000000000000...000000000000000000000000
```
```
VGA:
A000:BE20 000000000000000000000000...000000000000000000000000...
+ 0x140 (320)
A000:BF60 000F0F0F0F0F0F0F0F0F0F0F...0F0F0F0F0F0F0F0F0F0F0F00...
+ 0x140 (320)
A000:C0A0 000F0F0F0F0F0F0F0F0F0F0F...0F0F0F0F0F0F0F0F0F0F0F00...
+ 0x1000 (320 * 21)
A000:DAE0 000000000000000000000000...000000000000000000000000
```
Можно двигаться дальше, к функции `draw_string`.
---
Углубляясь в `draw_string`, зацепился за следующий участок кода:
```
loc_1DB47:
mov bx, dx
inc dx
sub ax, ax
mov al, ss:[bx]
shl ax, 1
jz short loc_1DB97
shl ax, 1
shl ax, 1
add ax, 0FA6Eh
mov si, ax
mov cx, 8
mov bx, 4BA1h
loc_1DB62:
lodsb
mov ah, al
sub al, al
rol ax, 1
rol ax, 1
xlat byte ptr ss:[bx]
stosb
sub al, al
rol ax, 1
rol ax, 1
xlat byte ptr ss:[bx]
stosb
sub al, al
rol ax, 1
rol ax, 1
xlat byte ptr ss:[bx]
stosb
sub al, al
rol ax, 1
rol ax, 1
xlat byte ptr ss:[bx]
stosb
add di, ss:4BA5h
loop loc_1DB62
sub di, ss:4BA7h
jmp short loc_1DB47
loc_1DB97:
...
```
Именно "зацепился", из-за большого скопления инструкций `lodsb`, `stosb`, `xlat`,*[для себя я сделал вывод, что именно эти инструкции делают большую часть полезной работы, в конце-концов, всё это программирование сводится к тривиальному перемещению данных из одной области памяти в другую, не так ли?]* и начал его трассировать. Иду от метки `loc_1DB47`:
* в регистре `dx` находится адрес исходной строки "`New/Load`", сохраняем его в `bx` и инкрементируем;
* зануляем `ax` (`sub ax, ax`);
* помещаем в `al` код символа исходной строки, на которую указывает `bx` (`mov al, ss:[bx]`, `al = 0x4E ('N')`);
* сдвигаем код символа на один бит влево и, если результат равен нулю, прыгаем на `loc_1DB97` (проверка на нуль-терминатор);
* двигаем `ax` ещё на два бита влево и прибавляем `0xFA6E` (вместе с предыдущим сдвигом равносильно: `ax = ax * 8 + 0xFA6E`, `ax = 0xFCDE`);
* сохраняем `ax` в `si` (а значит в `ax` — адрес);
* сохраняем в `cx` — 8, а в `bx` — `0x4BA1` (вероятно, тоже адрес).
Учитывая дальнейшую инструкцию `loop loc_1DB62`, здесь был заготовлен цикл на 8 (`cx`) итераций, разбираюсь с ним:
* инструкцией `lodsb` в `al` загружается значение байта по адресу `ds:si`, `si` после этого инкрементируется. В моём случае `ds:si = F000:FCDE`, в `al` загружается значение `0xC6`, `si` становится равным `0xFCDF`;
* младший байт `ax` записывается в старший (`mov ah, al`, `ax = 0xC6C6`);
* `al` зануляется, `ax` циклически сдвигается на два бита влево (`ax = 0x1803`);
* инструкция `xlat` использует `al` как индекс в байтовом массиве по адресу `ds:bx` и сохраняет записанное там значение в `al`, при этом сегмент `ds` может быть переопределён. Здесь идёт обращение к массиву по адресу `ss:bx` (`47EA:4BA1 = {0xFF, 0xF0, 0x0F, 0x00}`), и в результате выполнения инструкции: `al = ss:bx[al] = 0x00`;
* иструкцией `stosb` значение из `al` записывается по адресу `es:di`, `di` после этого инкрементируется. У меня `es:di = 22FB:0192`, и это важно, ведь именно там расположен битмап рамки, в которой будет отображён текст. После выполнения инструкции по адресу `22FB:0192` будет записано значение `0x00` (`al`), а `di` станет равным `0x0193`.
Последние три шага повторяются трижды, затем к `di` прибавляется ворд, сохранённый по адресу `ss:4BA5` (`0x2C`), и инструкция `loop` ещё 7 раз прогоняет код от метки `loc_1DB62` до самой себя. После завершения цикла к `di` прибавляется ворд, сохранённый по адресу `ss:4BA7` (`0x17C`), и программа прыгает назад, на метку `loc_1DB47`.
Таким вот замысловатым способом здесь по очереди обрабатываются все символы исходной строки. В результате, в рамке формируется заданный текст *[подсветите нули, или уменьшите страницу]*:
```
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
FFF00FFF00FFFFFFFFFFFFFFFFFFFFFF00F0000FFFFFFFFFFFFFFFFFFFFFFF000FFF
FFF000FF00FFFFFFFFFFFFFFFFFFFFF00FFF00FFFFFFFFFFFFFFFFFFFFFFFFF00FFF
FFF0000F00FF0000FFF00FFF00FFFF00FFFF00FFFFFF0000FFFF0000FFFFFFF00FFF
FFF00F0000F00FF00FF00F0F00FFF00FFFFF00FFFFF00FF00FFFFFF00FFF00000FFF
FFF00FF000F000000FF0000000FF00FFFFFF00FFF0F00FF00FFF00000FF00FF00FFF
FFF00FFF00F00FFFFFF0000000F00FFFFFFF00FF00F00FF00FF00FF00FF00FF00FFF
FFF00FFF00FF0000FFFF00F00FF0FFFFFFF0000000FF0000FFFF000F00FF000F00FF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
```
Здесь, в приципе, понятно всё, кроме магического числа `0xFA6E`, прибавив к которому код символа, умноженный на восемь, мы получили адрес в сегменте `F000`. Это явно находится за пределами памяти самой программы, а значит нужно гуглить схему памяти *MS-DOS*. И [нагуглил](http://staff.ustc.edu.cn/~xyfeng/research/cos/resources/BIOS/Resources/assembly/biosdataarea.html), конкретно, там интересует вот что: `FFA6:E ROM graphics character table`. Учитывая сегментную адресацию, запись `FFA6:E` эквивалентна `F000:FA6E`, а по этому адресу "зашит" шрифт для отображения символов в родной досовской кодировке [*CP437*](https://ru.wikipedia.org/wiki/CP437). На каждый символ там отведено по 8 байт. Вот как это работает на примере буквы 'N':
```
1. берём код символа: 0x4E
2. умножаем на восемь: 0x4E * 8 = 0x270
3. смещаемся от начала шрифта на полученное значение: 0xFA6E + 0x270 = 0xFCDE
4. читаем восемь байт по этому адресу: C6 E6 F6 DE CE C6 C6 00
5. записывем прочитанные байты в столбик, в двоичной системе:
C6: 11000110
E6: 11100110
F6: 11110110
DE: 11011110 (здесь единицами нарисована буква 'N')
CE: 11001110
C6: 11000110
C6: 11000110
00: 00000000
```
А вот этот код:
```
sub al, al
rol ax, 1
rol ax, 1
xlat byte ptr ss:[bx]
```
можно проиллюстрировать следующим образом:
Всё достоточно просто для того, чтобы реализовать эту логику самостоятельно и вывести шрифт на экран. *[Чем я и занялся, оставив позиционирование текста на потом.]*
---
Под это дело, в одном солюшене с *ResourceBrowser* и *LibNeuroRoutines*, создал проект *NeuromancerWin32*. В качестве мультимедиа-бэкенда решил использовать [*SFML*](https://www.sfml-dev.org/). До этого у меня уже был очень позитивный опыт работы с *SDL2*, но здесь захотелось попробовать что-нибудь новое. *SDL2* мне нравилась, в том числе, тем, что она реализована на *C* и, соответсвенно, из коробки имеет *C*-совместимый интерфейс. *SFML*, в свою очередь, написана на *C++*. Чтобы не усложнять, свой проект я буду вести на *C*, и, к счастью, *SFML* имеет официальный *С*-биндинг — *CSFML*.
Уже со старта *CSFML* порадовала простотой использования. Вот, например, всё, что нужно для создания окна:
```
sfEvent event;
sfVideoMode mode = { 320, 200, 32 };
sfRenderWindow *window =
sfRenderWindow_create(mode, "NeuromancerWin32", sfClose, NULL);
while (sfRenderWindow_isOpen(window))
{
while (sfRenderWindow_pollEvent(window, &event))
{
if (event.type == sfEvtClosed)
{
sfRenderWindow_close(window);
}
}
sfRenderWindow_clear(window, sfBlack);
sfRenderWindow_display(window)
}
sfRenderWindow_destroy(window);
```
Оригинальная игра для вывода графики на экран использует 256-цветный режим *VGA* (*mode 0x13*). В этом режиме рисование сводится к записи значений цвета пикселей в *VGA*-память (`A000:0000`, `320 * 200` байт). Один байт, при этом, соответсвует одному пикселю. Я решил действовать схожим образом, но с поправкой на то, что будет использоваться 32-битный видеорежим. Таким образом, я завёл себе буфер `uint8_t *g_vga[320*200*4]` (каждый пиксель в 32-битном режиме представлен 4-мя компонентами — *RGBA*), который будет служить мне аналогом *VGA*-памяти из оригинала. В этом буфере я буду рисовать, а затем, при помощи *SFML*, выводить содержимое на экран:
```
sfRenderWindow *g_ window = NULL;
sfTexture *g_texture = NULL;
uint8_t *g_vga[320*200*4];
...
g_texture = sfTexture_create(320, 200);
...
void render()
{
sfTexture_updateFromPixels(g_texture, g_vga, 320, 200, 0, 0);
sfSprite *sprite = sfSprite_create();
sfSprite_setTexture(sprite, g_texture, 1);
sfRenderWindow_clear(g_window, sfBlack);
sfRenderWindow_drawSprite(g_window, sprite, NULL);
sfRenderWindow_display(g_window);
sfSprite_destroy(sprite);
}
...
sfTexture_destroy(g_texture);
```
Тестируем:
```
for (int i = 0; i < 320 * 240 * 4; i++)
{
g_vga[i] = rand() % 256;
}
while (sfRenderWindow_isOpen(g_window))
{
...
render();
}
```
То, что нужно. После этого написал функцию, которая по заднным координатам мапает битмап заданных размеров на *VGA*-буфер: `void draw_to_vga(int32_t l, int32_t t, uint32_t w, uint32_t h, uint8_t *pixels)` *[логика переноса битмапа на VGA, на мой взгляд, тривиальна]*:
```
uint8_t red_rectangle[96*48];
memset(red_rectangle, 0x44, 96*48);
draw_to_vga(10, 10, 96, 48, red_rectangle);
...
render();
```
Реализовал процедуру, формирующую битмап (8x8) с заданным символом:
```
static uint8_t cp437_font[1024] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 NULL
...
0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0x00, // 0x41 A
0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00, // 0x42 B
0x3C, 0x66, 0xC0, 0xC0, 0xC0, 0x66, 0x3C, 0x00, // 0x43 C
...
};
static uint8_t cp437_font_pixels[4] = {
0xFF, 0xF0, 0x0F, 0x00
};
static uint8_t cp437_font_mask[4] = {
0xC0, 0x30, 0x0C, 0x03
};
void build_character(char c, uint8_t *dst)
{
uint32_t index = c * 8;
/* unprintable */
if (c < 0x20 || c > 0x7E)
{
return;
}
memset(dst, 0, 32);
for (int i = 0; i < 8; i++)
{
uint8_t al = cp437_font[index++];
for (int j = 0; j < 4; j++)
{
dst[i * 4 + j] =
cp437_font_pixels[(al & cp437_font_mask[j]) >> (6 - j * 2)];
}
}
}
```
Посимвольно вывел алфавит на экран:
```
memset(g_vga, 0xFF, 320 * 200 * 4);
uint8_t character_bm[32];
int left = 2, top = 2;
for (char c = 0x20; c <= 0x7E; c++)
{
if (left + 8 >= 320)
{
left = 2;
top += 10;
}
build_character(c, character_bm);
draw_to_vga(left, top, 8, 8, character_bm);
left += 8;
}
render();
```
На основе `build_character` сделал функцию `build_string(char *s, uint32_t w, uint32_t h, uint8_t *dst)`, которая печатает строку целиком:
```
memset(g_vga, 0xFF, 320 * 200 * 4);
uint8_t string[320 * 20];
build_string("The future is here.\n"
"It’s just not widely distributed yet.", 320, 20, dst);
draw_to_vga(20, 88, 320, 20, string);
render();
```
---
Изначально я планировал написать больше. На самом деле, на момент написания этого текста у меня сделано почти работающее главное меню и плюс-минус реализована система рендеринга из оригинала. Но эта часть получилась и без того больше предыдущей, и её пора заканчивать. Так что уже в следующей я добью меню и рендеринг и выкачу это всё в один присест.
> [Реверсим «Нейроманта». Часть 3: Добили рендеринг, делаем игру](https://habr.com/post/415555/) | https://habr.com/ru/post/357972/ | null | ru | null |
# Хватит копипастить, или как превратить Outlook-письмо в Jira-задачу в один клик
Привет! Меня зовут Карина Суворова, в «Северстали» я занимаюсь автоматизацией пользовательских процессов. Как часто вам приходят письма и встречи с задачами, которые надо выполнить в определённые сроки? Мне много. А моим коллегам, особенно тем, чей рабочий день состоит из таких «почтовых задач», ещё больше.
Чтобы ничего не забыть, нужен удобный инструмент управления, с категоризацией и возможностью анализа загрузки, повторяемости и фактически затраченного времени. И он есть — Jira.
Но процесс регистрации в Jira тоже отнимает время — скопировать тему и имя заказчика, отметить затрачиваемое на задачу время и выполнить ещё кучу скучных действий. Из-за такой рутины многие управления продолжают вести списки задач в блокнотах и экселе.
Чтобы избавиться от этого разрыва, мы разработали прекрасное решение, которое доступно всем и не требует подготовки для поддержки. Работает оно с Outlook. Нужны только Jira для размещения и структурированного хранения задач и Visual Basic for Applications (VBA) для их создания.
Для кого и как работает посредник, который переносит данные из почты в Jira
---------------------------------------------------------------------------
Наше решение будет полезно тем, кто уже работает с Jira и хочет упростить процесс создания задач (или вообще его обойти). И тем, кто активно ведёт таймшиты в старых добрых Excel, а потом мучается с общим доступом, подвисанием, обновлением, объединением… ну вы сами всё знаете. Посмотрим, как выглядит эта штука со стороны пользователя и со стороны разработки.
### Работа со стороны пользователя
Опишу пошаговые действия пользователя.
**Шаг 1.** Выбрать письмо или назначенное собрание, по которому необходимо создать задачу в Jira. Это может быть открытое окно письма (встречи):
Или просто выделенный элемент Outlook:
**Шаг 2.** Запустить макрос. Кнопка запуска может располагаться как в основном окне Outlook, так и в самом письме (встрече):
Вид и название кнопки можно менять.
**Шаг 3.** Откроется окно с формой, в которую затягиваются элементы из письма (встречи). Это гибкая форма — там можно настраивать любые выпадающие списки и окна, полезные для создания задачи. В примере ниже заполняются данные из текста, отправитель, дата, время встречи. Длительность встречи автоматом подтягивается в поле для журнала работ.
**Шаг 4.** Можно отредактировать какие-то поля формы. Например, выбрать нужный тип задачи и исполнителя из выпадающего списка. Сохранить.
**Шаг 5.** После того как вы нажали «Сохранить», происходит проверка полей на корректность ввода (например, даты и времени). Если есть ошибки, макрос об этом сообщит и предложит изменить. После успешной проверки создаётся задача.
В текущем примере выполняется ряд изменений: назначается исполнитель, ведётся журнал работ (если он был проставлен), меняется статус задачи, прикрепляется исходное письмо (встреча) как вложение, задача открывается у пользователя в браузере.
**Шаг 6.** На этом этапе вы должны начать испытывать удовольствие.
### Работа со стороны разработки
**Инструменты для реализации:**
1. Проект в Jira, в котором будут вестись задачи.
2. Outlook, если необходимо переносить письма и встречи в Jira. Если задачи не привязаны к элементам Outlook, можно использовать любой другой продукт Microsoft, в котором поддерживается VBA. Но наша история про дружбу с Outlook.
3. Созданный технический пользователь Jira, от имени которого будут регистрироваться задачи. Можно сохранять задачи и от самих сотрудников.
#### Роли, права, доступы
Для всех сотрудников, которые будут участвовать в проекте, надо настроить определённые роли на создание и изменение элементов в Jira. Роли можно раздавать автоматически через группу Active Directory (AD) — очень удобная вещь!
Если задачи будут создаваться от имени технического пользователя, то надо выдать ему соответствующие права на проект. Нюанс: если необходимо, чтобы также фиксировалось время, затраченное на задачу в tempo, нужно создать команду в Jira-tempo, назначать руководителя и участников, а нашему техническому пользователю дать роль на управление планами команды. Так он сможет вести время за каждого сотрудника! Если же плагин tempo отсутствует, можно воспользоваться стандартным вариантом через worklog.
Дальше будет немного кода.
**Шаг 1.** Авторизация пользователя. На этом этапе можно заложить различные процедуры первичной подготовки проекта к работе. Например, проверку обновлений по проекту и подключение к сетевым папкам, на которых находятся данные для выпадающих списков форм.
**Шаг 2.** Так как у нас пример на базе Outlook с частичным заполнением данных из письма (встречи), то первый шаг — подключение к объекту Outlook:
`Dim oInspector As Inspector`
`Set oInspector = Application.ActiveInspector`
`If oInspector Is Nothing Then`
'1 вариант если нет открытых активных писем, то макрос берёт выделенное в списке писем в работу
`Set MailItem = Application.ActiveExplorer.Selection.Item(1)`
`Else`
'2 вариант если есть открытые письма, то берёт активное или последнее, с которым работал пользователь,
'если код запущен из письма — берёт текущее открытое
`Set MailItem = oInspector.CurrentItem`
`End If`
**Шаг 3.** После того как объект Outlook выбран, пользователь получает форму для заполнения, в которую уже частично вошли данные из письма (встречи). При этом для считывания некоторых полей объекта Outlook необходимо сначала проверять, чем он является — письмом или встречей:
`If MailItem1.Class = olAppointment Then`
'если это встреча
`TextBox6 = MailItem.Organizer` 'автор встречи автор
`TextBox7 = Format(MailItem.Start, "dd")`
`…`
`TextBox12 = DateDiff("n", CDate(MailItem1.Start), CDate(MailItem.End))`
`Else`
'если это письмо
`TextBox6 = MailItem.SenderName` 'автор письма для заполнения поля автор
`TextBox7 = Format(Date, "dd")`
`…`
`TextBox12 = 0`
`End If`
**Шаг 4.** Поля формы при нажатии «Сохранить» должны пройти логическую проверку. Допустим, проверку на правильный цифровой ввод, например, чтобы месяц был не более 12. Полученные данные передаются в словарь, объявленный ранее как public и получивший на входе нужные элементы:
`Public myDict As New Dictionary`
'создание при старте элементов и заполнение нулевыми значениями
`myDict.Add "tema", vbNullString`
`myDict.Add "body", vbNullString`
`myDict.Add "aftor", vbNullString`
`myDict.Add "ispolnitel", vbNullString`
'передача данных , которые были выбраны/записаны в форму, в словарь при сохранении
`myDict.Item("tema") = TextBox2`
`myDict.Item("body") = TextBox5`
`myDict.Item("aftor") = TextBox6`
`myDict.Item("ispolnitel") = ComboBox2.Value`
'чистка при завершении
`myDict.RemoveAll`
**Шаг 5.** Форма заполнена и прошла проверку. Создаём на основе полученных данных элемент Jira. Предварительно нужно собрать технические параметры проекта или задачи для постинга через просмотр кода веб-страницы: нужен ID проекта, ID типов задач. Вообще, нужен список всех параметров, которые мы передадим через post-запрос. Также параметры полей можно найти на официальном сайте api Jira, api tempo.
**Шаг 6.** Собрав ID полей, создаём формат JSON в VBA:
`issue = "{ ""fields"": { ""assignee"":{""name"": """ & j_assignee & """}, ""summary"": """ & themeBIC & """, ""description"": """ & descriptionBIC & """, ""customfield_10808"": """ & j_reporter & """,""project"": { ""id"": """ & pid & """, ""name"": """ & ProgName & """ }, ""issuetype"": { ""id"": """ & issuetype & """ } } } }"`
**!Важное замечание.** Постинг самой задачи правильно выполнять через MSXML2.xmlhttp, а вот внесение изменений в задачу через WinHttp.WinHttpRequest.5.1.
`With xmlhttp`
`.Open "post", "https://Jira.ваш домен.com/rest/api/2/issue", False`
`.setRequestHeader "Authorization", "Basic " & EncodeBase64`
`.setRequestHeader "Content-type", "application/json"`
`.setRequestHeader "X-Atlassian-token", "no-check"`
`.Send issue`
`result = .responseText`
`statusHml = .Status`
`End With`
EncodeBase64 — функция, в которой мы передаём логин и пароль от пользователя Jira. Чтобы не хранить конфиденциальные данные в самом коде VBA, можно воспользоваться переменной среды окружения у пользователей этой разработки и посадить пароль туда. Это максимально безопасный вариант хранения пароля для VBA-проекта.
`Private Function EncodeBase64() As String`
`Text = "имя пользователя:" & Environ("имя переменной окружения, которую вы создали")`
`With CreateObject("ADODB.Stream")`
`.Open: .Type = 2: .Charset = "utf-8"`
`.writetext Text: .Position = 0: .Type = 1: b = .Read`
`With CreateObject("Microsoft.XMLDOM").createElement("b64")`
`.DataType = "bin.base64": .nodeTypedValue = b`
`EncodeBase64 = Replace(Mid(.Text, 5), vbLf, "")`
`End With`
`.Close`
`End With`
`End Function`
А вот пример того, как после создания задачи заносить время в журнал работ и комментарий по работам (который равен теме задачи). Обращаю внимание: для поиска параметров идём к api tempo\*:
`Split_result = Split(result, """")` 'разделяем результат работы от постинга задачи, в дальнейшем используем для получения ID созданной задачи
`If masTik.Item("time") > vbNullString Then` ' проверка, что пользователь занёс время работы в форму
'!необходимо учитывать, что имя, которое мы использовали при создании задачи как assignee (исполнитель), может отличаться от worker — кому ведём журнал работ.
`issue = "{""started"": """ & myDict.Item("day") & """, ""timeSpentSeconds"": """ & myDict.Item("time") * 60 & """, ""worker"" : """ & j_assignee & """, ""comment"" : """ & themeBIC & """ , originTaskId"": """ & Split_result(7) & """}"`
`With xmlhttp`
`.Open "post", " https://Jira.ваш домен.com /rest/tempo-timesheets/4/worklogs/", False` 'обратить внимание, что здесь уже используется api tempo
`.setRequestHeader "Authorization", "Basic " & EncodeBase64`
`.setRequestHeader "Content-type", "application/json"`
`.setRequestHeader "X-Atlassian-token", "no-check"`
`.Send issue`
`result = .responseText`
`statusHml = .Status`
`End With`
`End if`
**\*Вариант кода без tempo:**
Работы заносятся на того, кто создаёт задачу. В этом случае запуск будет от сотрудника с запросом пароля перед началом работы.
`issue = "{""started"": """ & DataJira & """, ""timeSpentSeconds"": """ & timeSpentSeconds & """}}"`
`With xmlhttp1`
`.Open "post", " https://Jira.ваш домен.com /rest/api/2/issue/" & Split_result(7) & "/worklog", False`
`.setRequestHeader "Authorization", "Basic " & EncodeBase64`
`.setRequestHeader "Content-type", "application/json"`
`.setRequestHeader "X-Atlassian-token", "no-check"`
`.Send issue`
`result = .responseText`
`statusHml = .Status`
`End With`
`End If`
В этом проекте также используется изменение статуса задачи и прикрепление исходного письма (встречи) во вложение созданной задачи.
Эффекты от внедрения макроса
----------------------------
В итоге у нас есть проект Jira, в котором удобно смотреть:
* загруженность сотрудников;
* перекос по распределению задач;
* анализ избыточности запросов от клиентов;
* трудозатраты в разрезе исполнителей, задач или клиентов.
Всё это происходит в онлайн-режиме, при этом сотрудники тратят минимум времени для занесения всей этой информации. Решение мне самой очень нравится, да и спрос на его внедрение в компании достаточно высок.
Спасибо, что прочитали! В продолжение этой статьи у меня есть ещё две темы. Я пока не выбрала, о чём рассказывать в следующий раз. Что вам больше интересно: как Jira помогает в отслеживании поломок автоматизированных процессов на серверах или как автоматически (без сотрудников) собирать задачи в Jira из календаря собраний? | https://habr.com/ru/post/711638/ | null | ru | null |
# Автоматизируем добавление сервера в Zabbix с назначением шаблонов
Самый простой способ добавить новый сервер в Zabbix — через веб интерфейс. Засетапили новый сервер, пошли в web-морду, добавили машинку. Но, когда что-то делается руками, всегда можно забыть, особенно когда ввод серверов в строй происходит часто.
После очередного такого случая: что-то грохнулось, а потом выяснилось, что оно и не мониторилось никогда, возникла мысль автоматизировать процесс.
##### Изучение вопроса показало, что сервера можно автоматически добавлять несколькими способами:
1. Через [network discovery](https://www.zabbix.com/documentation/ru/2.0/manual/discovery/network_discovery/rule) — задаем диапазон адресов, система переодически запускает скан портов и, по результатам обнаружения, позволяет автоматически добавить узел, а так же присвоить тот или иной шаблон на основе полученных данных.
Этот вариант неплох, но, в моем случае, подсетей много, они меняются, каждый раз добавлять списки в заббикс было бы неудобно. К тому же, не всю информацию о системе можно выяснить, опрашивая порты.
2. [Авторегистрация](https://www.zabbix.com/documentation/ru/2.0/manual/discovery/auto_registration). Можно настроить zabbix сервер так, чтоб при подключении нового агента (определяется по уникальному имени хоста) происходило добавление узла сети в ту или иную группу. Также, можно добавлять какой-то набор шаблонов.
В данном случае — мы уходим от сканирования и диапазонов адресов, но получаем отсутствие гибкости в плане шаблонов
3. Есть варианты — генерировать шаблон на лету, писать информацию прямо в базу и т.п — все как-то сложно.
Так как, при сетапе нового сервера конфиг агента генерируется автоматически, при помощи puppet, было решено использовать второй вариант — авторегистрацию, а потом накатывать нужные шаблоны через API заббикса.
На самом деле, наличие паппета не критично, можно закидывать скрипт на новый хост каким-либо другим путем и использовать что-то иное для определения параметров конфигурации хоста. Я приведу простой вариант, но додумать до более сложной схемы не составит труда.
##### Итак, алгоритм такой:
1. При сетапе сервера, на него приезжает zabbix агент, в конфиге которого прописано FQDN имя хоста. Также, приезжает скрипт zabbixapi.py, который умеет работать с zabbix API.
2. Агент стучится на сервер, при этом срабатывает авто регистрация, хост попадает в специальную группу AutoRegistered, к нему автоматом применяется шаблон «New Server», с единственным элементом данных **host.relocate**
3. Zabbix сервер, выполняет опрос ключа **host.relocate**, чем запускает на выполнение скрипт zabbixapi.py.
4. Скрипт, в свою очередь, определяет базовые параметры хоста, лезет через API на Zabbix сервер, удаляет там хост из группы AutoRegistered, удаляет шаблон New Server, добавляет в нужные группы и включает нужные шаблоны.
Некоторая сложность с промежуточным шаблоном нужна для того, чтоб уйти от лишнего запуска zabbixapi.py. По сути, сам zabbix сервер перестает его дергать как только хост уезжает из группы AutoRegistered. В любом другом случае пришлось бы или запускать скрипт постоянно с некоторой периодичностью, либо запускать его один раз, не имея возможности проверить результат.
##### Что нам нужно настроить, чтоб вся система заработала?
1. Создаем группу узлов AutoRegister сети на сервере Zabbix
2. Создаем шаблон Autoregister с единственным элементом данных **host.relocate**
3. Создаем правило обнаружения, присваивающее новому хосту шаблон и добаляющее его в группу AutoRegistered. В Web интерфейсе — Настройка -> Действия, выбираем справа вверху — источник события: Авторегистрация -> Новое дествие
**Host autoregistration** 
4. Добавляем в конфиг заббикс агента соответствующий UserParameter:
`UserParameter=host.relocate,/etc/zabbix/bin/zabbixapi.py > /dev/null 2>&1 ;echo $?`
5. Кладем по указаному пути скрипт:
**/etc/zabbix/bin/zabbixapi.py**
```
#!/usr/bin/env python
import urllib, json, httplib, socket, sys, os
def httpRequest(request):
body = json.dumps(request)
headers = {"Content-type": "application/json"}
conn = httplib.HTTPConnection("zabbix.example.com", 80)
conn.request("POST", "/api_jsonrpc.php", body, headers)
response = conn.getresponse()
data = response.read()
conn.close()
return data
me = os.popen('facter --puppet fqdn').read().strip('\n')
# Авторизуемся на сервере
authToken = httpRequest({"jsonrpc": "2.0","method":"user.authenticate","params":{"user":"API_USER","password":"API_PASSWORD"},"auth": None,"id":0})
authToken = json.loads(authToken).get('result', None)
# Проверяем, находится дли сервер в группе Autoregistered
hostInGroup = httpRequest({"jsonrpc":"2.0","method":"host.get","params":{"output":"extend","filter":{"host":me}, "groupids":"21"},"auth":authToken,"id":1})
hostInGroup = json.loads(hostInGroup).get('result', None)
if hostInGroup:
hostID = httpRequest({"jsonrpc":"2.0","method":"host.get","params":{"output":"extend","filter":{"host":me}, "groupids":"21"},"auth":authToken,"id":2})
hostID = json.loads(hostID)
hostID = hostID['result'][0]['hostid']
print "Host is in AutoRegistered Group"
print "HostID is",hostID
print "We need to update host info, link templates and move host to proper group"
# Используем facter для того, чтоб собрать инфо о системе
print "Collecitng host info..."
osFamily = os.popen('facter --puppet kernel').read().strip('\n')
virtualEnv = os.popen('facter --puppet virtual').read().strip('\n')
print "Base OS is",osFamily
if osFamily == "FreeBSD":
hostGroups = [{"groupid":"11"}, {"groupid":"6"}]
hostTemplates = [{"templateid":"10077"}, {"templateid":"10090"}]
if osFamily == "Linux":
print "Checking virtualization..."
if virtualEnv == "physical":
print "Physical host detected, no virtualization"
hostGroups = [{"groupid":"11"}, {"groupid":"2"}]
hostTemplates = [{"templateid":"10076"}, {"templateid":"10090"}, {"templateid":"10127"}]
if virtualEnv == "openvzve" or virtualEnv == "openvz":
print "OpenVZ virtualization detected"
hostGroups = [{"groupid":"11"}, {"groupid":"14"}]
hostTemplates = [{"templateid":"10117"}, {"templateid":"10090"}]
print "Detected groups are", hostGroups
print "Detected templates are", hostTemplates
updateHost = {
"jsonrpc":"2.0",
"method":"host.update",
"params":{
"hostid":hostID,
"ip":"127.0.0.1",
"groups":hostGroups,
"templates":hostTemplates,
"templates_clear":"10263"
},
"auth":authToken,
"id":3
}
print "Trying to update host..."
httpRequest(updateHost)
hostInterfaceID = httpRequest({"jsonrpc":"2.0","method":"hostinterface.get","params":{"output":"extend", "hostids":hostID},"auth":authToken,"id":4})
hostInterfaceID = json.loads(hostInterfaceID)
hostInterfaceID = hostInterfaceID['result'][0]['interfaceid']
print "Host Interface ID detected as", hostInterfaceID
updateHostInterface = {
"jsonrpc":"2.0",
"method":"hostinterface.update",
"params":{
"interfaceid":hostInterfaceID,
"dns": me,
"useip": 0
},
"auth":authToken,
"id":4
}
print "Trying to update host interface to DNS based..."
httpRequest(updateHostInterface)
sys.exit(0)
else:
print "Host is absent in AutoRegistered Group"
print "Nothing to do..."
sys.exit(0)
```
В приведенном примере мы смотрим операционную систему: Linux или FreeBSD, смотрим наличие виртуализации OpenVZ — это влияет на выбор базовых шаблонов. При необходимости, функционал легко расширить, мознательно публикую простую версию, так как реализация может сильно отличаться от того, что используем мы.
Внимание, в скрипте захардкожены номера групп и шаблонов, в вашей инсталяции они будут другими, не забудьте поправить! | https://habr.com/ru/post/211384/ | null | ru | null |
# Подключение советской клавиатуры Электроника МС 7004 к современному ПК
[](https://habr.com/ru/company/timeweb/blog/706422/)
Когда я листал доски объявлений, на глаза попалась отличная клавиатура «Электроника МС 7004». Даже по современным меркам клавиатура выглядит просто потрясающе. У неё есть откидной блок со светодиодами, клавиши механика. И она настолько крутая, что даже сейчас на ней хочется работать. Но, как обычно есть один маленький нюанс: у неё свой интерфейс и электропитание.
Такие клавиатуры встречаются часто, выглядят стильно и, в общем-то, можно получить уникальное устройство ввода, но как же её подключить? Этим вопросом я занялся уже после покупки, потому что клавиатура была крута, и вылилось всё в интересное копание в схемотехнике клавиатуры, протоколах и многом другом.
❯ Историческая справка
-----------------------
В одном из объявлений была дана интересная историческая справка на эту клавиатуру, приведу её, поскольку она достаточно исчерпывающе описывает, что это такое.
> Ретро клавиатура МС7004 — это клавиатура, которая является аналогом [клавиатуры LK201 производства компании DEC](https://en.wikipedia.org/wiki/LK201). МС7004 использовалась с рядом советских ЭВМ конца 80-х годов, совместимых с архитектурой PDP-11, например, ДВК-3, ДВК-3М, Квант-4С, Электроника-85, и, вполне возможно, что ещё на кое-каких машинах. Сама клавиатура построена на микроконтроллере, и связь с ЭВМ осуществляется через стандартный последовательный порт. Принцип работы кнопок — ёмкостный. Раскладка клавиатуры — JCUKEN, в отличие от аналога LK201 с раскладкой QWERTY.
Это очень интересный момент, что клавиатура использовалась не только с определёнными ЭВМ, но и применялась для различных типов. И ещё то, что она совместима с иностранной клавиатурой LK201, и, забегая вперёд, скажу, что совместима достаточно хорошо.
Стоит даже их сравнить между собой, чтобы понять, что копировали их очень близко.
***Клавиатура «Электроника» МС 7004 (фото любезно предоставлены [xlat](https://xlat.livejournal.com/685544.html))***
***Оригинальная клавиатура DEC LK201 ([фото с сайта](https://deskthority.net/wiki/DEC_LK201))***
Про оригинальную клавиатуру LK201, с которой была скопирована клавиатура «Электроника» МС 7004, стоит рассказать более подробно.
Форм-фактор этой клавиатуры определил стандарт клавиатур, которым мы пользуемся и сейчас. Основная область ввода стала стандартом ISO, клавиатура QWERTY с вертикальной клавишей Enter (которой в копии, увы, нет), клавиша Tab находится слева от «Q», а клавиша "<" слева от «Z». Как и у предыдущей модели, которая была прародителем это — клавиатуры для терминала VT102, клавиши управления и клавиша Caps Lock находятся слева от клавиши «A». Клавиши вставки, удаления (insert, del) были перемещены в новую группу клавиш, чтобы справа от клавиши ввод было место.
LK201 также была первой клавиатурой с клавишей Shift, расположенной слева от пробела.
Главной отличительной чертой клавиатуры была компоновка клавиш курсора, в виде перевёрнутой буквы **Т**. Хотя LK201 не была первой клавиатурой, в которой использовалось такое расположение, она была выбрана после серьёзных исследований удобства использования. Был ли дизайн заново изобретён независимо или скопирован с более ранней клавиатуры, неизвестно.
***Компоновка перевёрнутой-T, представленная LK201***
Такое решение быстро прижилось, поскольку компания DEC, будучи крупным игроком в компьютерной индустрии в начале 1980-х годов, вдохновила многих преемников своими раскладками клавиатуры. Расположение клавиш курсора, клавиши удаления и функциональных клавиш было специально скопировано.
В 1983–1984 годах рабочая группа инженеров IBM, разрабатывавшая IBM Enhanced Keyboard (Model M), использовала макет LK201, включая его фирменный кластер стрелок в виде перевёрнутой буквы T, но переместила его на одну строку вниз.
Поскольку отечественную клавиатуру скопировали весьма точно, то и электрический интерфейс оказался полностью совместим. Поэтому стоит пару слов сказать и о нём.
Клавиатура LK201 питается от 12 В, которые поступают от компьютера. Клавиатура и компьютер, к которому она подключена, общаются через относительно стандартный последовательный интерфейс.
* Двунаправленное асинхронное последовательное соединение: 4800 бод, 8N1.
* Уровни последовательного интерфейса соответствуют стандарту EIA RS-423 (т.е. колебания сигналов ± 5 вольт).
* Потребляемая мощность: 4,2 Вт Макс. 350 мА при 11,8 В ± 6%.
* Здесь следует особенно остановиться на интерфейсе RS-423, его отличие от интерфейса RS-232 в амплитуде передаваемого сигнала. У RS-423 — это от минус 5 до +5 В, а у RS-232 от минус 15 до +15 В. Таким образом, в целом можно подключать клавиатуру и к интерфейсу RS-232 с некоторыми оговорками.
Специально подробно остановился на этих моментах, потому что они полезны будут и для подключения клавиатуры МС7004.
❯ «Электроника» МС 7004
------------------------
После ознакомления со всеми историческими материалами, и осознанием того, что мне предстоит, было принято решение купить эту клавиатуру. На данный момент достаточно легко, пока ещё, можно найти эти клавиатуры в продаже. И ценник на них более чем адекватен, особенно для такой удивительной модели.
Поэтому спустя пару недель приехала мне такая красавица, с откидной крышкой, под которой видны светодиоды.
Обратите внимание, что раскладка английской клавиатуры фонетическая JCUK, как и на всех отечественных компьютерах, и это ужасно…
Для того чтобы просто включить клавиатуру (подать питание), пришлось рыть кучу документации. Нашёл неплохой [сайт по ДВК](http://www.emuverse.ru/wiki/%D0%94%D0%92%D0%9A#.D0.9A.D0.BB.D0.B0.D0.B2.D0.B8.D0.B0.D1.82.D1.83.D1.80.D0.B0_.D0.9C.D0.A1_7004), где приведены два типа паспорта (см. раздел «Клавиатура МС 7004»). В паспорте самое ценное — это схема и коды клавиш. Как ни странно, далее английская документация оказалась более полной. Итак, схема подключения.
***Схема разъёма клавиатуры***
У этой модели клавиатуры съёмный провод, можно подключиться непосредственно к плате, либо к стандартному 5-контактному разъёму типа DIN. Выбрал второй вариант, и для этого набросал распиновку разъёма для подключения. Обязательно при таких операциях перепроверяйте, где находится питание, особенно если оно 12 В!
***Распиновка разъёма***
Попутно с подключением сделал неполный разбор для чистки. Хотел разобрать полностью, но побоялся, что сломаю крепления пластика, который от возраста стал хрупким. Поэтому полностью клавиатуру мне разобрать не удалось.
***Первый успешный запуск клавиатуры***
На фотографии видно, что я уже перехватываю нажатия клавиш, с помощью осциллографа. Клавиатура потребляет достаточно большой ток 0,3 А, при 12 В — это уже 3,6 Вт! Что, как по мне, для обычной клавиатуры многовато.
Теперь момент истины — подключить её к компьютеру. Как уже говорил выше, интерфейс у клавиатуры RS-423 (то есть сигналы имеют уровень ± 5 вольт относительно земли). Но решил рискнуть и подключил через шнурок USB-COM, настроил терминалку на 4800 8N1 и, всё заработало!
***Оно живое!***
Помните, я говорил, что клавиатура имеет фонетическую раскладку? Самое удивительное, что слизали всё подчистую, и коды клавиш точно соответствуют [кодам клавиш по физическому расположению у оригинальной клавиатуры LK201](https://www.netbsd.org/docs/Hardware/Machines/DEC/lk201_keycodes.html).
***Коды клавиш LK201, которые точно соответствуют кодам клавиш МС 7004***
Вот это поворот! Значит, не нужно будет переучиваться, осталось сделать железку конвертер. И казалась задачей простой и быстрой.
❯ Тщетная попытка сделать конвертер
------------------------------------
Есть два пути для подключения подобной клавиатуры: подключить её к COM-порту и написать свой драйвер и сделать преобразователь в USB-HID. Первый вариант прост, но плох тем, что клавиатура будет привязана к конкретной машине, а второй более сложен, но более универсален.
Решил реализовывать второй вариант, питание брать от USB, повышать его, а в качестве USB-HID использовать модуль Arduino Leonardo.
Взял остатки старых своих проектов, которые вы даже когда-то видели в моей статье "[С чего начинается устройство](https://habr.com/ru/post/140426/)". Там как раз есть подходящий корпус, DIN-разъём и макетная плата.
***Остатки старых проектов***
Одной из задач было получать питание 12 В, и сделать преобразователь RS-423. Последнее можно реализовать на max232. В результате у меня получилась такая платка, с max232 и повышающим преобразователем от USB.
Но радость была недолгой, при подключении клавиатуры тока порта не хватало, и всё просаживалось в ноль. Поэтому такая схема питания оказалась неработоспособной. Затем, с большим трудом добытая дефицитная max232 отказалась работать с интерфейсом RS-423, и не переваривала такой тип напряжения (хотя оно находится в стандартах RS-232). Короче, на этом моё вдохновение закончилось. Повоевал несколько дней, и вечные трудности сильно подрезали вдохновение.
Необходимо было городить внешний источник питания, делать отдельный корпус для подключения клавиатуры. И как-то это выглядело уж слишком убого, клавиатура подключается к преобразователю с блоком питания, чтобы подключаться к ПК. Поэтому руки опустились. Но есть ли пути решения?
❯ Несколько слов о создании ПО для клавиатуры
----------------------------------------------
На самом деле, информации по клавиатуре LK201 достаточно, как и примеров кода, чтобы сделать нормальный преобразователь, не влезая в схемотехнику. Есть прекрасный сайт [LK201 Keyboard Interface](https://www.netbsd.org/docs/Hardware/Machines/DEC/lk201.html), где приводятся примеры дефайнов для клавиш, и описание интерфейса работы.
Достаточно просто скопировать примеры оттуда, немного пошаманить с кодом и получить готовый результат
Есть примеры в коде ядра, по работе с этим типом клавиатуры, например вот хедер [с кодами клавиш](https://github.com/rohsaini/mkunity/blob/master/osfmk/src/mach_kernel/chips/lk201.h). Стоит тоже покопаться по всему репозиторию. Вот, например, коды команд для работы с процессором клавиатуры:
```
/*
* Commands to the keyboard processor
*/
#define LK_PARAM 0x80 /* start/end parameter list */
#define LK_CMD_RESUME 0x8b
#define LK_CMD_INHIBIT 0xb9
#define LK_CMD_LEDS_ON 0x13 /* 1 param: led bitmask */
#define LK_CMD_LEDS_OFF 0x11 /* 1 param: led bitmask */
#define LK_CMD_DIS_KEYCLK 0x99
#define LK_CMD_ENB_KEYCLK 0x1b /* 1 param: volume */
#define LK_CMD_DIS_CTLCLK 0xb9
#define LK_CMD_ENB_CTLCLK 0xbb
#define LK_CMD_SOUND_CLK 0x9f
#define LK_CMD_DIS_BELL 0xa1
#define LK_CMD_ENB_BELL 0x23 /* 1 param: volume */
#define LK_CMD_BELL 0xa7
#define LK_CMD_TMP_NORPT 0xc1
#define LK_CMD_ENB_RPT 0xe3
#define LK_CMD_DIS_RPT 0xe1
#define LK_CMD_RPT_TO_DOWN 0xd9
#define LK_CMD_REQ_ID 0xab
#define LK_CMD_POWER_UP 0xfd
#define LK_CMD_TEST_MODE 0xcb
#define LK_CMD_SET_DEFAULTS 0xd3
```
Другой пример – это ремап кодов клавиатуры для преобразования к нормальным сканкодам [k201-remap.c](https://github.com/ut-osa/txos/blob/master/drivers/tc/lk201-remap.c). И там же в папке выше тоже полезные коды. Пример табличного ремапа:
```
unsigned char scancodeRemap[256] = {
/* ----- */
/* 0 */ 0, 0, 0, 0,
....
/* 84 */ 0, 0, 0, 0,
/* ----- FIND/INSERT INSERT/HOME */
/* 88 */ 0, 0, 0x23, 0x24,
/* ----- REMOVE/PG UP SELECT/DELETE PREVIOUS/END NEXT/PG DN */
/* 8c */ 0x25, 0x38, 0x39, 0x3a,
/* ----- KP 0 */
/* 90 */ 0, 0, 0x6b, 0,
/* ----- KP . KP ENTER KP 1 KP 2 */
/* 94 */ 0x6c, 0x65, 0x62, 0x63,
/* ----- KP 3 KP 4 KP 5 KP 6 */
/* 98 */ 0x64, 0x4e, 0x4f, 0x50,
/* ----- KP ,/KP + KP 7 KP 8 KP 9 */
/* 9c */ 0x51, 0x3b, 0x3c, 0x3d,
/* ----- KP - KP F1/NUM LCK KP F2/KP / KP F3/KP * */
/* a0 */ 0x3e, 0x26, 0x27, 0x28,
/* ----- KP F4/KP - LEFT */
/* a4 */ 0x29, 0, 0, 0x5f,
/* ----- RIGHT DOWN UP SHIFT Rt */
/* a8 */ 0x61, 0x60, 0x4d, 0x5e,
/* ----- ALT COMP Rt/CTRL Rt SHIFT CONTROL */
/* ac */ 0, 0, 0x52, 0x3f,
...
```
В общем, преобразователь можно сделать и велосипед изобретать с нуля не требуется. Нужно просто найти время, чтобы переработать всю информацию.
❯ Другой путь – аппаратная доработка
-------------------------------------
Есть более варварский способ – это переделка клавиатуры аппаратно. Есть «аутентичный» способ переделки – это сделать из клавиатуры, классическую DIN-клавиатуру. Нужно будет выкинуть часть преобразователя из 12-ти вольтового питания в 5 вольт, и преобразователь интерфейса RS-423, чтобы всё соответствовало TTL-логике. Затем заменить прошивку в ПЗУ. Схемы клавиатуры можно [найти в паспортах на сайте](http://www.emuverse.ru/wiki/%D0%94%D0%92%D0%9A#.D0.9A.D0.BB.D0.B0.D0.B2.D0.B8.D0.B0.D1.82.D1.83.D1.80.D0.B0_.D0.9C.D0.A1_7004).
В журнале [«Радио» за ноябрь 1991 года](http://archive.radio.ru/web/1991/11/) было техническое описание такой переделки.
И там даётся текстовое описание, что нужно сделать с клавиатурой. Единственное, что может вызвать проблемы – это набор кода вручную, а также найти программатор и УФ стиратель, чтобы стереть и прошить ПЗУ. Подробнее, как это сделать, можно прочитать в моей статье "[Что с памятью моею стало](https://habr.com/ru/company/ruvds/blog/648649/)".
Любопытно взглянуть, какое же расположение клавиш получится после такой переделки, и там тоже оно приведено.
***Раскладка после переделки из журнала «Радио»***
Как видно, остаётся достаточно много свободных клавиш, которым можно добавить нужный функционал, например, добавить клавишу Win, скан-коды которой, соответственно, `0x5B` левой и `0x5C` – правой.
Но, если вам этот путь кажется сложным, есть другой вариант – это заменить микроконтроллер КМ1816ВЕ48 на Arduino Leonardo и уже ей заниматься сканированием клавиш. Схему питания тоже придётся переделывать, но на выходе уже получим USB-HID. Но, в любом случае мы потеряем в аутентичности.
❯ Выводы
---------
Проковырявшись месяц с этим проектом, посидев за кодом, так и не пришёл к элегантному решению подключения клавиатуры к ПК. Вроде бы всё и так ясно, но вот чтобы было красиво, так и не придумал. В результате проект был заброшен на шкаф, а впоследствии всё оборудование было распродано, включая саму клавиатуру.
Клавиатура, без сомнения, очень красивая, украсила стол любого программиста, но увы, слишком уж много мороки было с ней. Нужно, иногда бывает оценить свои силы и отказаться от тупиковых проектов, даже если они выглядят достаточно круто.
❯ Полезные ссылки
------------------
[Историческая справка о клавиатуре DEC LK201.](https://deskthority.net/wiki/DEC_LK201)
[Фотосессия клавиатур «Электроника МС 7004» от xlat.](https://xlat.livejournal.com/685544.html)
[Сайт по ДВК.](http://www.emuverse.ru/wiki/%D0%94%D0%92%D0%9A#.D0.9A.D0.BB.D0.B0.D0.B2.D0.B8.D0.B0.D1.82.D1.83.D1.80.D0.B0_.D0.9C.D0.A1_7004)
[LK201 Keyboard Interface.](https://www.netbsd.org/docs/Hardware/Machines/DEC/lk201.html)
[«Радио» за ноябрь 1991 года](http://archive.radio.ru/web/1991/11/)
[Моя статья о том как работать с ПЗУ.](https://habr.com/ru/company/ruvds/blog/648649/)
Примеры кода [первый](https://github.com/rohsaini/mkunity/blob/master/osfmk/src/mach_kernel/chips/lk201.h) и [второй](https://github.com/ut-osa/txos/blob/master/drivers/tc/lk201-remap.c) (обязательно посмотрите всю репу, кто будет писать самостоятельно).
**P.S. Если вам интересно моё творчество, вы можете [следить за мной ещё в телеграмме.](https://t.me/dlinyj_news)**
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/706422/ | null | ru | null |
# Поиск уязвимостей у хабросайтов
Время было вечером, делать было нечего… Было решено удивить хабражителей. Но как? Банальные поиски уязвимостей на известных сайтах уже никому не интересны. Чтож, значит включим фантазию… Ведь у пользователей тоже есть сайты! Срочно проверить их на стойкость!
#### Как все происходило:
Нужно было придумать план действия. Впринципе, все заключалось в том, чтобы спарсить как можно больше страниц пользователей и затем спарсить в них страницы сайтов. Затем поставить все это на сканер. Как-то так…
#### Как это работает?
**Пункт первый: Спарсить страницы.**
Не все так просто, чтоб вы знали… На странице /users лежит не так много, как хочется, пользователей. Решено было рекурсивно идти по юзерам и брать там из подписчиков других юзеров, а там еще юзеров и еще…
Расчехлен любимый питон, включено воображение, написано вот это:
```
import urllib2, re
start = "первый пользователь"
""" Выкачиваем страничку первого пользователя, и парсим с нее имена первых жертв """
page = urllib2.urlopen("http://habrahabr.ru/users/"+start+"/subscription/followers/").read()
names = re.findall('[(.\*?)](/users/(.*?)/)', page)
""" рекурсивная функция, которая, вызывая себя в себе, будет ходить по сайту в поисках новых жертв"""
def going(names):
for name in names:
page = urllib2.urlopen("http://habrahabr.ru/users/"+name[0]+"/subscription/followers/").read()
names = re.findall('[(.\*?)](/users/(.*?)/)', page)
""" и писать новых жертв в файл """
base = open('habrs.txt', 'a')
writed = 0
for item in names:
base.write(item[0]+"\r\n")
writed = writed + 1
print 'Saved habrs\'s: '+str(writed)
going(names)
going(names)
```
После некоторого времени работы было спарсено достаточное количество хабралюдей(около 10к). Ясно понятно, что большая часть этих людей повторяются… Что же делать?
**Пункт второй: Уникализировать**
Подумав, я решил, что грузить питон будет несправедливо. Поэтому в мой мозг полезла идея об array\_unique из php. Подумано — сделано.
Весь скрипт заключается в открывании-закрывании файла, но зато сама уникализация в одну функцию.
```
php
$arr = file_get_contents("habrs.txt");
$arr = explode("\r\n", $arr);
$arr = array_unique($arr);
$string = "";
foreach($arr as $name){
$string = $string.$name."\r\n";
}
file_put_contents("habrs2.txt", $string);
?
```
Запускалось все из консоли, все отлично работает.
Получилось чуть меньше 2к уникальных хабролюдей… Значит теперь нужно пойти и найти их сайты.
**Пункт третий: Поиск сайтов**
Опять достал питон, и написал такое. Все очень просто, идем по файлу(построчно), переходим на странички пользователей, ищем сайты. Находим, прячем в файл.
```
import urllib2, re
sites = ""
users = file("habrs2.txt")
for user in users:
user = re.split("\r\n", user)[0]
page = urllib2.urlopen("http://habrahabr.ru/users/"+user+"/").read()
site = re.findall('[(.\*?)]((.*?))',page)
if len(site) > 0:
for site, fake in site:
sites += site+"\r\n"
with open("sites.txt", "a") as f:
f.write(sites)
```
Сайтов получилось приличное количество, и если они не повторялись, то имели неудобоваримый вид.
Нужно их почистить…
**Пункт четвертый: Чистим сайты**
Используем preg\_match в php.
```
php
$arr = file_get_contents("sites.txt");
$arr = explode("\r\n", $arr);
$string = "";
foreach($arr as $name){
if (preg_match('/http:\/\/([^\/]+)\//i', $name, $matches)) {
$name = $matches[1];
} elseif (preg_match('/^http:\/\/([^\/]+)$/i', $name, $matches)) {
$name = $matches[1];
}
$string = $string.$name."\r\n";
}
file_put_contents("sites2.txt", $string);
?
```
Получаем хороший список, аля:
yandex.ru
google.com
yahoo.com
Теперь нужно все это прикрутить к сканеру, получить ответ, спрятать в файл…
**Пункт пятый: полет со сканером**
На питоне была написана микропрограмма, для манипуляций с консолью.
Пишу по памяти, потому как этот скрипт был написан на продакшне(BackTrack r3 на виртуалке), и после счастливого нахождения огромной кучи уязвимостей все это дело было закрыто, без сохранения(виртуалка в смысле), поэтому сам скрипт не сохранился…
Смысл в том, чтобы запустить перл скрипт nikto.pl на 60 сек, и то, что он успеет за это время, записать в файл с именем сайта(для простоты дальнейшей обработки).
```
import os, time
sites = file("sites2.txt")
for site in sites:
os.system("perl nikto.pl -h "+site+" | tee "+site+".txt")
os.system("pidof perl | tee perlID.txt")
time.sleep(60)
pid = file("perlID.txt")[0]
os.system("taskkill "+pid)
```
После работы сего сканера в файлах вида: сайт.txt, обнаруживались быстро найденные уязвимости(в течение 60 секунд).
**Пункт шестой: разбор полетов**
После некоторого времени работы(оставлял на ночь) я решил посмотреть, что же там за дыры…
Потому как хабрасообщество достаточно прошаренно в этом деле(в информационной безопасности в смысле) некоторые отчеты оказались вовсе без радующих глаз плюсиков…
Однако, среди 3-х сотен сайтов были обнаружены и «дырявые» сайты.
#### Рейтинг уязвимостей
1). Всевозможные открытые папки и не разрешенные к доступу файлы. (40~ сайтов)
2). Различные возможные места SQL и XSS. (20~ сайтов)
3). Опасные протоколы обмена информацией, незапароленные memcached и всяческие дыры в админках(нет проверки на доступ к файлам, или пустой пароль = полный пароль). (10~ сайтов)
4). Откровенные ошибки(или недоработки). Отсутствие пароля на админку(скрипт ругался аж на 12 файлов, и посылал посмотреть, что же там интересного). (2 сайта)
5). Встреченная в единственном экземпляре ошибка, и то по недосмотру(я думаю), прямой доступ к phpmyadmin'у с логином root и без пароля(дефолтные настройки). Больше на этом сайте НИКАКИХ уязвимостей найдено не было, поэтому считаю, что это просто по недосмотру.
Проверены были не все пользователи, не все сайты, не все возможности из всех возможностей!
Я надеюсь, что этот пост будет полезен кому-то(какой-то администратор вдруг проверит на своем сайте что-то).
Администраторы уязвимых сайтов извещены. Надеюсь на положительные мысли в ваших головах! | https://habr.com/ru/post/191434/ | null | ru | null |
# Тайм-киллер из детства
Уверен, многие из читающих иногда занимались на уроках бесполезной ерундой вместо того, чтобы слушать учителя. Я точно так делал, и одним из способов убить время были игры на бумаге. Особенно интересной мне казалась игра на превью (название которой мне до сих пор неизвестно), а причин тут две: она не требует второго человека и её можно завершить! Правда сделать это удавалось крайне редко. Долгое время мне было интересно, насколько простым может оказаться решение, и сейчас, спустя много лет, не составит труда найти его программным путём.
### Правила
Для начала стоит описать правила. Начинается игра со следующего поля:
`123456789`
`111213141`
`516171819`
Здесь посимвольно записаны все числа от 1 до 19, за исключением 10. Цифры расположены слева направо, строка за строкой. Правила довольно просты — на каждом шаге нужно вычеркнуть 2 цифры, соответствующие следующим критериям:
* цифры должны быть либо одинаковыми, либо в сумме давать 10 (1 и 1, 3 и 7, 8 и 2 и т.д.);
* так же они должны либо стоять друг над другом, либо располагаться последовательно. При этом уже вычеркнутые цифры игнорируются.
Ниже показан один из вариантов нескольких первых ходов:
**`1`**`23456789`
**`1`**`11213141`
`5161718`**`19`**
`#2345678`**`9`**
`#`**`1`**`1213141`
`5161718##`
`#2345678#`
`##1213141`
`5161718##`
В тот момент, когда ходов больше нет, все невычеркнутые цифры дописываются в конец. Игра заканчивается, когда всё поле будет вычеркнуто.
`#2345678#`
`##1213141`
`51`**`6`**`171`**`8`**`##`
`23`**`4`**`567`**`8`**`12`
`131415161`
`718`
`#2345678#`
`##1213`**`1`**`41`
`5`**`1`**`#`**`1`**`71###`
`23#567#12`
`131415`**`1`**`61`
`718`
`#2345678#`
`##1213#41`
`5###71###`
`2`**`3`**`#567#12`
`1`**`3`**`1415#61`
`718`
`...`
Количество доступных ходов стремительно увеличивается, игра начинает сильно ветвиться. Зачастую таблица становится настолько длинной, что переполняется на следующую страницу в тетради. Проще начать новую партию. Иногда я из упорства продолжал, но в итоге сдавался.
Тут встаёт резонный вопрос — а насколько быстро можно закончить эту игру? В детстве удавалось найти решение в один столбик на тетрадном листе — это порядка 40 строк или 360 символов.
Гарантированного способа завершить игру мне не известно. Совершенно не понятно, как выбирать стратегию. Можете попробовать сыграть сами, если не пробовали.
### Решение
Каким образом ищутся решения у подобных проблем? Не знаю наверняка, но я выбрал обычный перебор.
Нам понадобится очередь, сперва состоящая только из единственной начальной конфигурации. На каждом шаге мы берём следующую конфигурацию из очереди, смотрим все доступные из неё ходы и либо добавляем их все в конец очереди, либо объявляем себя победителем, если таких ходов нет.
`123456789 #23456789 12345678# 123456789 123456789 123456789 123456789 ...`
`111213141 #11213141 #11213141 ##1213141 1##213141 11#213141 11121314# ...`
`516171819 516171819 516171819 516171819 516171819 516#71819 51617181# ...`
Если не останавливаться на первом попавшемся решении, то данный алгоритм будет выдавать все возможные решения (при наличии бесконечного объёма оперативной памяти).
На практике настолько наивный подход совершенно не поможет, как минимум, из-за постоянно появляющихся дубликатов в очереди. Поэтому потребуются некоторые оптимизации, которые я сейчас объясню:
* естественно, конфигурации нужно кэшировать, чтобы не складывать их повторно в очередь. Это сильно увеличит использование памяти, но всё равно не поможет получить решение за приемлемое время. Более того, остро встаёт вопрос сравнения конфигураций. Раз две выигрышные конфигурации одного размера всегда будут состоять только из зачёркнутых чисел, то нужен дополнительный способ их отличать, иначе будут найдены не все решения;
* чтобы перебор был осмысленным и быстрым, лучше использовать очередь с приоритетом. Чем меньше на поле цифр (включая вычеркнутые), тем раньше такую конфигурацию следует рассматривать;
* если нужно не одно решение, а много, то лучше ограничить максимальное количество цифр на поле, перебор станет выдавать решения намного раньше.
### Ответ
Если правильно всё закодить, выясняется, что минимальное решение состоит всего из 68 символов или 8 строк!
Приведу его в виде gif-анимации. Некоторые ходы были склеены в один, чтобы уменьшить число кадров:
Буду откровенен, меня поразило, насколько это решение короткое. Но, может быть, это везение и остальные решения встретятся нескоро и будут очень длинными?
Нет, решения совсем не редки. Быстро находятся ответы длиной 72, 74 и 76. А ещё 4 принципиально различных решения длиной 80. Вообще, мне удалось найти 30 решений длиной до 90 (включительно), а если границу увеличить до 100, то решений будет уже 170. Дальше ещё больше, но и искать их становится затратнее.
Под спойлером оптимальное решение расписано подробно:
**Скрытый текст**
```
123456789
111213141
516171819
123456789
111213141
5161718##
123456789
1##213141
5161718##
12345678#
1##21314#
5161718##
#2345678#
###21314#
5161718##
#234567##
####1314#
5161718##
#234567##
####1314#
5161718##
234567131
45161718
#234567##
####1314#
51#1718##
23#567131
45161718
#234567##
####1314#
51#171###
#3#567131
45161718
#234567##
####1314#
51#171###
#3#567#31
451617#8
#234567##
####1314#
51#171###
#3#56###1
451617#8
#234567##
####1314#
5###71###
#3#56###1
451617#8
#234567##
####1314#
5###71###
#3#56###1
451617#82
345671314
571356145
16178
#234567##
####1314#
5###71###
#3#56###1
451617#82
345671314
57#356145
16#78
#234567##
####1314#
5###71###
#3#56###1
451617#82
345671314
5###56145
16#78
#234567##
####1314#
5###71###
#3#56###1
451617#82
345671314
#####6145
16#78
#234567##
####1314#
5###71###
#3#56###1
451617#82
34567131#
######145
16#78
#234567##
####1314#
5###71###
#3#56###1
451617#82
3456713##
#######45
16#78
#234567##
####1314#
5###71###
#3#56###1
451617#82
3#56713##
#######45
1##78
#234567##
####1314#
5###71###
#3#56###1
451617###
3#56713##
#######45
1##78
#234567##
####1314#
5###71###
#3#56###1
45161####
##56713##
#######45
1##78
#234567##
####1314#
5###7####
#3#56###1
45161####
##567#3##
#######45
1##78
#234567##
####1314#
5########
###56###1
45161####
##567#3##
#######45
1##78
#234567##
####1314#
#########
####6###1
45161####
##567#3##
#######45
1##78
#234567##
####1314#
#########
####6###1
45161####
##56#####
#######45
1##78
#234567##
####1314#
#########
####6###1
45161####
##5######
########5
1##78
#234567##
####1314#
#########
####6###1
45161####
#########
#########
1##78
#234567##
####131##
#########
########1
45161####
#########
#########
1##78
#234567##
####13###
#########
#########
45161####
#########
#########
1##78
#234567##
#####3###
#########
#########
4516#####
#########
#########
1##78
#23456###
#########
#########
#########
4516#####
#########
#########
1##78
#2345####
#########
#########
#########
#516#####
#########
#########
1##78
#234#####
#########
#########
#########
##16#####
#########
#########
1##78
#23######
#########
#########
#########
##1######
#########
#########
1##78
#23######
#########
#########
#########
#########
#########
#########
###78
#2#######
#########
#########
#########
#########
#########
#########
####8
#########
#########
#########
#########
#########
#########
#########
#####
```
Мой код решения на Java можно посмотреть [по этой ссылке](https://github.com/ibessonov/random/blob/master/src/timekiller/Game.java), но предупреждаю, что он ужасен, т.к. изначально писался не для публикации. В текущем виде он находит все решения до 70 символов (то есть только одно решение). Это легко исправить, поигравшись с условиями в коде.
Спасибо за внимание! | https://habr.com/ru/post/471642/ | null | ru | null |
# Поиск маршрутов за 1 человеко-месяц
Однажды для нашего проекта потребовался функционал прокладки маршрутов. Программистов у нас не то чтобы очень много, а скорее наоборот, поэтому мы хотели найти какое-то готовое решение, поискали и ничего хорошего не нашли.
Данные дорожного графа у нас были, но в таком виде, что ни в одну библиотеку или какой-то middle-ware их так просто не подать. Да и middle-ware по навигации, честно говоря, мы не нашли, так чтобы просто встраивалось в нашу систему (спасибо, если кто подскажет куда посмотреть). Поэтому приняли решение сделать самостоятельно, используя по максимуму существующие библиотеки для всего.
О процессе разработки сервиса и расскажу.
**О графе.**
Несколько слов о данных. Данные мы получаем от стороннего поставщика, на формат и состав данных влиять не можем. Данные о дорогах имеют вид файла в формате ArcView (Shapefile). Все улицы разбиты на сегменты от перекрестка до перекрестка, каждому сегменту сопоставлены атрибуты:
— уникальный идентификатор сегмента
— геометрическая ломаная, изображающая сегмент дороги
— данные о разрешенной максимальной скорости по ПДД
— данные о возможности разворота в начале и конце сегмента
— признак одностороннего движения на сегменте
— Z уровень начала и конца сегмента (например въезд на эстакаду имеет в начале уровень 0, а в конце уровень 1)
Кроме того есть отдельный файл с ограничениями движения, накладываемыми логикой и/или ПДД. Каждое ограничение — это вектор идентификаторов, ссылающихся на сегменты улицы (из первого файла), последовательное движение по которым запрещено.
Пример того, как все это выглядит, висит в заголовке поста (красным — запреты, к сожалению, наш софт в данном случае не позволяет нарисовать запреты с направлением).
Для работы алгоритмов на графе, требуется, чтобы граф был представлен в каком-то общепринятом виде, например в виде списка связанности вершин, или матрицы связанности. То есть фактически требуются данные о вершинах и связях между ними. Поскольку в наших данных сведения о вершинах очень неполные, есть только данные об их геометрическом местоположении, пришлось провести обработку, чтобы все вершины получили уникальные идентификаторы.
За основу мы взяли геометрическое местоположение вершин, но было одно обстоятельство: координаты конечных вершин сегментов не всегда совпадали на 100%, например на перекрестках (возможно дефекты работы операторов ГИС системы, точно не знаю). Поэтому мы приняли решение считать одной вершиной графа все конечные точки сегментов, имеющие одинаковый Z-уровень и отстоящие друг от друга не дальше чем на 1 метр.
Всего сегментов уличной дорожной сети в наших данных примерно 140 000, а значит конечных точек примерно 280 000. Соответственно нужен был какой-то нелобовой алгоритм нахождения всех соседей на расстоянии до 1 метра каждой точки. Лобовой перебор всех пар имеет квадратичную сложность и работает чрезмерно долго. Поскольку мы решили, что наша программка будет работать напрямую с исходным представлением данных, то есть с Shape-файлами (причины: легко обновлять, не нужно поддерживать, документировать, версионировать собственный формат хранения), то нужен был эффективный алгоритм идентификации вершин.
Придумали вот что (здесь и далее код на С++):
**1. Сделали контейнер для ребер графа:**
```
typedef size_t EdgeID;
typedef size_t VertexID;
struct EdgeDesc
{
VertexID vtxSrc, vtxDest;
EdgeInfo info;
};
typedef std::unordered_multimap EdgeMap;
```
Мультимэп, потому что мы решили не вводить новые идентификаторы сегментов/ребер графа, а информацию о прямом и обратном ребре сохранять соответственно с одинаковыми идентификаторами. Вероятно это было не самое правильное решение, потому что на мой взгляд усложнило логику некоторых процедур, но в начале казалось, что так будет нормально.
Рис 1.
**2. Координатную плоскость разбили на квадратики метр на метр (рис 1).**
Каждой вершине сопоставили ключ:
```
static_assert(sizeof(size_t) >= 8, "size_t type should be 64 bit or larger");
auto keyPartX = [this](double x)
{ return (size_t)(x - bound_.first.x) + 1; };
auto keyPartY = [this](double y)
{ return (size_t)(y - bound_.first.y) + 1; };
auto getKey = [](size_t x, size_t y)
{ return x << (sizeof(size_t) / 2 * 8) | y; };
auto getKeyXY = [&keyPartX, &keyPartY, &getKey](double x, double y)
{ return getKey(keyPartX(x), keyPartY(y)); };
```
**3. Сделали хэш-контейнер**
```
typedef size_t CellKey;
typedef std::unordered_map> SPHash;
```
При просмотре списка сегментов уличной сети, мы строим список элементов, содержащих идентификаторы начальной и конечной вершин, идентификатор ребра, и сопутствующую информацию, то есть фактически граф в виде списка смежных вершин.
Начальную и конечную точку сегмента мы пробуем добавить в SPHash по вычисленному в п. 2 ключу. Если с таким ключом в контейнере уже есть точки, то новую точку не добавляем, а возвращаем идентификатор уже имеющейся (при условии что имеющаяся точка в контейнере на том же Z уровне что и добавляемая).
Если по ключу в контейнере ничего нет, то вносим точку в контейнер и возвращаем идентификатор добавленной точки.
Правда точки, расстояние между которыми меньше 1 метра, могут иметь разные ключи, поэтому мы проверяем контейнер не только по вычисленному ключу, но и по 8-ми соседним:
```
std::vector near;
size\_t xPart = keyPartX(p.x);
size\_t yPart = keyPartY(p.y);
near.clear();
merge(near, getKey(xPart, yPart));
merge(near, getKey(xPart + 1, yPart));
merge(near, getKey(xPart - 1, yPart));
merge(near, getKey(xPart, yPart + 1));
merge(near, getKey(xPart, yPart - 1));
merge(near, getKey(xPart + 1, yPart + 1));
merge(near, getKey(xPart + 1, yPart - 1));
merge(near, getKey(xPart - 1, yPart + 1));
merge(near, getKey(xPart - 1, yPart - 1));
```
merge() строит список идентификаторов ближайших точек в векторе near.
Получив список идентификаторов соседей (по сути кандидатов на слияние в одну вершину), мы сравниваем точки, вычисляя точное евклидово расстояние между ними. И если оно меньше заданного, то считаем, что точки одинаковы и объединяем в одну вершину (на рисунке покрашены в один цвет), возвращая идентификатор подходящей вершины уже имеющейся в ячейке с ключом getKey(xPart, yPart).
При старте эта обработка занимает около 1 секунды, что нас устроило.
**4. В результате получаем, что соседние точки ближе заданного порога получают один идентификатор.**
Теперь у нас есть список смежных вершин. Временная сложность получения такого списка линейно зависит от количества вершин, потому что каждую мы обрабатываем ровно 1 раз, а операции поиска и вставки в хэш-контейнер имеет асимптотически константную сложность.
Как вы уже, должно быть, заметили, мы не обрабатываем промежуточные вершины ломаной уличного сегмента, так как на топологию графа они не влияют (в середине сегмента нельзя осуществить никакого маневра, во всяком случае у нас нет об этом данных).
Если бы мы разбили ломаную на составляющие ее отрезки и каждый отрезок считали бы ребром, то в графе вместо примерно 140 000 ребер было бы уже примерно 600 000. Значительно возросло бы время поиска пути, в конце я покажу эту разницу в абсолютных значениях.
Остался последний штрих. Ограничения, или запрещенные маневры.
Ограничение запрещает какой-либо маневр, например поворот налево на перекрестке. Исходно в данных представляет собой список сегментов, последовательное движение по которым запрещено.
Приведу пример:
Рис. 2
Красные стрелки показывают запрещенный маневр, числа обозначают идентификаторы сегментов. Фактически в данных этот запрет выглядит как {e1, e4}.
С таким представлением запретов работать в процессе прокладки маршрута очень тяжело, поэтому мы решили локально трансформировать граф так, чтобы запрещенный маневр был невозможен в графе чисто топологически, при этом все прочие разрешенные маневры остались возможными.
Для этого мы продублировали вершины, входящие в запрещенные маневр. И через эти дублированные вершины провесили ребра так, чтобы создать разрешенные маневры, а для запрещенного маневра такой маршрут просто не создавать.
При клонировании вершины ее геометрическое местоположение остается прежним (показанные на рисунке вершины v6 и v5 на самом деле геометрически в одном и том же месте и разнесены на рисунке для удобства), для новой вершины, разумеется, выделяется новый идентификатор.
Проиллюстрирую сказанное на примере перекрестка с запрещенным левым поворотом выше:
Рис 3.
Видно, что на графе с измененной топологией осуществить левый поворот по запрещенному пути на перекрестке больше нельзя, при этом все разрешенные маневры остались возможными.
Ограничения из более чем 2-х ребер обрабатываются по тому же принципу, но порождают больше новых вершин и ребер, на размер графа эти трансформации влияют, но не значительно (рост числа ребер примерно на 5%). В наших данных порядка 5000 ограничений из двух сегментов и около 400 из трех).
Вот иллюстрация того, как трансформируется граф под действием ограничения из 3-х ребер:
**Было:**
Рис 4.
**Стало:**
Рис 5.
Надо сказать, что реализация алгоритма трансформации графа стала самым сложным этапом всей работы (на нее ушло около 30% времени) и именно там было наибольшее число багов. Отчасти это связано с не самой хорошей проработкой структуры хранения данных. Так что если что-то осталось непонятным — не страшно, это действительно было непросто, задавайте вопросы, постараюсь ответить.
**Об инструментах.**
И так теперь у нас был граф представленный в удобном виде с учетом всех ограничений, по которому можно было прокладывать маршруты. В качестве алгоритма решили попробовать классический алгоритм Дейкстры, хорошая реализация которого есть в библиотеке boost.
Тут добавить особо нечего, по boost::graph есть хорошая документация и даже книги, мы взяли код одного из примеров и с небольшими изменениями использовали его у нас.
Следующим этапом стала обработка запросов. Мы решили, что удобно, если сервис сможет прокладывать маршрут, имея только начальную и конечную точку, заданные координатами. А значит надо быстро найти начальную и конечную вершину в графе, которые максимально близко расположены к соответствующим точкам запроса.
Для этого нужно было быстро уметь находить ближайшую к заданной пользователем точку на уличной сети (пользователь может захотеть маршрут от точки находящейся вне дорожно-уличной сети).
Тут уместно вспомнить о том, что сегменты дорожно-уличной сети в наших данных это ломаные, поэтому нам надо было найти ближайшую к заданной точку на ломаной (это может быть точка лежащая на ломаной, либо ее начальная или конечная вершина).
Ломаных довольно много (140 000), а искать надо быстро. Искать перебором всех сегментов слишком медленно. Тут на помощь пришла свежая версия библиотеки boost::geometry, где появились пространственные индексы (boost::geometry::index) уже с поддержкой такого объекта как ломаная линия (linestring).
С использованием этого индекса мы быстро находим несколько ближайших кандидатов, из них затем точным алгоритмом определяется сегмент, наиболее близко проходящий возле заданной точки.
Для чтения SHP файлов мы использовали библиотеку GDAL, для преобразования между географическими системами координат (мы работаем в локальной системе города, так исторически сложилось), а пользователю удобнее использовать GPS (WGS84) координаты) взяли библиотеку proj4, а для задач преобразования кодировки текста iconv.
**О деталях.**
— маршрут к середине ребра
Напомню что наш граф — топологическое представление дорожной сети, геометрические детали для работы алгоритма Дейкстры неважны. Но геометрический аспект важен для пользователя. Вспомним, что алгоритм Дейкстры строит кратчайшие маршруты от заданной вершины графа до всех остальных (включая искомую конечную вершину).
Значит начальную вершину мы должны определить, но поиск по индексу мы ведем среди ломаных, то есть фактически среди ребер. Как понять от какой вершины (в графе) нужно прокладывать маршрут, ведь промежуточных вершин сегмента там нет, а значит надо выбрать либо начальную, либо конечную вершину найденного сегмента.
Рис 6.
Однако для пользователя такое решение не будет удобным, представьте длиннющее шоссе, без поворотов и разворотов (а такое случается нередко). Пользователю будет очень удивительно видеть как маршрут построился от точки, находящейся в километре от той, что он задал (потому что на ближайшем сегменте других вершин ближе не оказалось). Это плохо. Кроме того, как показано на рисунке 6 (красные пунктирные линии) выбор ближайшей вершины сегмента иногда будет означать более длинный путь до цели, что вовсе нехорошо. Значит нам надо было как-то создать видимость того, что вершин в нашем графе больше и расположены они чаще, но так, чтобы это не повлияло на время работы алгоритма поиска пути.
Были рассмотрены несколько подходов со своими достоинствами и недостатками:
1) два поиска и от начальной и от конечной вершин сегмента и выбор того пути, который короче с учетом расстояния от точки пользователя с соответствующего конца сегмента.
**плюс:** просто в реализации
**минус:** двойной поиск кратчайшего пути с соответствующим замедлением времени работы.
2) создание избыточного графа: все геометрические вершины сегментов дорожной сети превращаются в вершины графа.
**плюс:** просто в реализации
**минусы:** значительный рост времени работы алгоритма Дейкстры, в ряде случае не решает проблемы (прямой длинный участок дороги)
3) дополнение графа временными вершинами и ребрами в момент запроса и возврат графа в начальное состояние после того, как найден маршрут.
**плюс:** один поиск маршрута, не нужно раздувать граф, быстро работает.
**минус:** сложнее в реализации чем остальные методы
Мы выбрали третий путь. В граф временно добавляется вершина, соответствующая ближайшей к пользовательской точке, лежащей на ломаной сегмента и 2 ребра (соответствующие частям сегмента до начальной и конечной вершин, либо только какой-то один из них, если сегмент с односторонним движением) эти вершина и ребра добавляются в граф, производится поиск, после чего временные вершина и ребра удаляются из графа.
— вывод в веб
На самом деле наша программа вообще не работает с сетью, она читает стандартный ввод и пишет ответ в стандартный вывод, а весь интерфейс с сетью и диспетчеризация сделаны отдельной программкой на node.js.
— многопоточность
Тут все просто. Наша программа работает в 1 поток. Но если очень нужно загрузить все ядра сервера, то можно запустить по 1 экземпляру на каждое ядро, благо 1 процесс требует для хранения графа, порядка 300 Мб (и этот размер можно сократить раза в 2-3, но мы себе пока такую задачу не ставили за ненадобностью). Как распределять запросы по процессам? Поскольку у нас есть внешняя программа диспетчер, она может заняться распределением запросов к работающим процессам, а также мониторить их работоспособность и т.д.
Другой вариант загрузки всех ядер: создание многопоточной программы на С++, нам показался сложнее. Во-первых надо было бы писать сетевой код на С++ (на node.js у нас написана практически вся серверная часть проекта и мы знали, что сделать работу с сетью на нем намного проще), либо делать более сложный интерфейс к внешнему диспетчеру по сравнению с stdin/stdout. Во-вторых у нас не read-only граф из-за временных вершин и ребер, а значит нужно было бы очень осторожно синхронизировать рабочие потоки, чтобы с одной стороны не убить производительность, а с другой не налететь на соответствующие проблемы многопоточного кода, мы не нашли преимуществ у этого подхода (на данный момент), чтобы так делать.
В заключении небольшая статистика:
Вся программа получилась всего 1500 строк, плюс несколько десятков строк диспетчера на node.js, кодированием на С++ занимался 1 человек, времени ушло около 1 месяца + помогали с идеями и отладкой еще пара коллег. Как нам кажется довольно неплохо для такой не самой элементарной задачи.
Среднее время поиска маршрута (на Core i7 3.4 Ghz) около 60-65 мс. Кстати я обещал сказать время работы на графе, где каждый отрезок ломаной дорожного сегмента превращается в отдельное ребро графа, это около 250 мс, заметная разница, согласитесь.
Спасибо за внимание тем, кто дочитал до конца. | https://habr.com/ru/post/211388/ | null | ru | null |
# Качественный интерфейс JIRA-плагина с помощью AUI Framework
[](http://habrahabr.ru/company/mailru/blog/243543/)
JIRA широко используется в Mail.Ru Group. Сейчас мы применяем эту систему не только для управления проектами и отслеживания ошибок, но и для организации самых разнообразных операционных процессов — рекрутинга, согласования договоров, командировок и так далее. Это с одной стороны очень удобно, так как многие бизнес-процессы отлично ложатся на модель Issue в JIRA. Однако часто требуются также и специфичные функции, реализуемые с помощью специально написанных нами плагинов.
Несколько лет назад мы довольствовались простыми JS-скриптами и плагинами общего назначения сторонних разработчиков. Со временем JIRA проникала в операционные процессы глубже, соответственно, и требования к функциям, заточенным именно под эти процессы, росли. В настоящее время у нас есть отдельное подразделение, задачей которого является разработка кастомизированного функционала для JIRA и Confluence. В рамках него накоплена хорошая экспертиза.
Сейчас многие JIRA-плагины сторонних разработчиков не могут похвастаться качественным интерфейсом. Это касается даже некоторых платных плагинов. Однако все средства для быстрой разработки удобных и красивых интерфейсов есть. В статье рассматривается одно из них — AUI Framework (Atlassian User Interface Framework).
Предполагается, что читатель знаком с тем, как можно сделать плагин в принципе. Если нет, то об этом можно почитать, например, [здесь](https://developer.atlassian.com/display/DOCS/Create+a+HelloWorld+Plugin+Project).
1. Что такое AUI Framework?
===========================
AUI Framework состоит из набора скриптов, таблиц стилей, шаблонов и других ресурсов, используемых при создании интерфейса. Разрабатывается и поддерживается компанией Atlassian. В целом, в AUI Framework вы можете найти примерно то же самое, что и в другом фреймворке вроде Bootstrap. Однако AUI Framework не нужно дополнительно встраивать на страницу и загружать им ее, а все компоненты полностью совпадают по стилю с самой JIRA — она сверстана с их помощью. Таким образом, полученный плагин будет замечательно выглядеть и работать в системе.
Разрабатывать интерфейс с помощью библиотеки можно гораздо быстрее, а пользоваться результатом — одно удовольствие. Наши сотрудники, пользующиеся разработанным функционалом, очень довольны.
2. Основные компоненты фреймворка
=================================
Рассмотреть все компоненты в рамках одной статьи невозможно, да и не нужно, для этого есть документация. Вместо этого ниже описаны самые полезные из них — те, которые максимально облегчают нашу жизнь и используются практически в каждом проекте.
### 2.1 Разметка страницы и декораторы
Если в плагине вам нужна какая-нибудь страница, например, для управления настройками, ее понадобится сверстать. Для этого есть 2 подхода.
Первый метод — создание этой страницы с нуля, но так, чтобы она полностью повторяла дизайн стандартных, с помощью [компонента Page](https://docs.atlassian.com/aui/latest/docs/page.html). В этом случае шапку и подвал страницы можно будет изменить так, как захочется.
Если эти изменения не требуются, лучшим выбором будет другой подход — использование декоратора. Так называется средство для автоматического обрамления страницы в соответствии с одним из стандартных стилей.
Частой задачей может быть, например, быстро создать страничку в области Администрирование. Это можно сделать очень просто с использованием декоратора `admin`. Верстать понадобится только содержимое, подсвеченное фиолетовым на скриншоте. Дополнительно можно указать, какой секции принадлежит страница и какой она соответствует вкладке с помощью соответствующих meta-тегов.
Вот HTML-код, соответствующий этой странице:
```
$i18n.getText( "ru.mail.jira.plugins.recruitment.configuration.title" )
```
Полный список возможных декораторов можно посмотреть [здесь](https://developer.atlassian.com/display/JIRADEV/Changes+to+markup%2C+CSS+and+Decorators+in+JIRA+5.0).
### 2.2 Диалоги
Мы очень часто используем диалоги, например, для того чтобы позволить пользователю создать или изменить запись в таблице AJAX-запросом. Это с одной стороны удобно для пользователя, а с другой — реализуется быстрее, чем с помощью отдельной страницы.
Во фреймворке есть 2 версии модальных диалогов — [Dialog](https://docs.atlassian.com/aui/latest/docs/dialog.html) и [Dialog 2](https://docs.atlassian.com/aui/latest/docs/dialog2.html). Dialog 2 — более новая компонента, предоставляющая больше гибкости, но находящаяся в статусе Experimental. Это значит, что есть вероятность изменения API в новой версии фреймворка. Несмотря на это, мы используем именно ее.
### 2.3 AUI Select2
[Этот компонент](https://docs.atlassian.com/aui/latest/docs/auiselect2.html) является стилизованным в соответствии с Atlassian Design Guidelines плагином jQuery [Select2](http://ivaynberg.github.io/select2/). Он предоставляет замечательные возможности, такие как поиск по значениям, AJAX-подгрузку опций, кастомизированное отображение опций и другие.
Мы часто используем его для того, чтобы сделать удобной возможность выбора опции.
### 2.4 Кнопки
Как и во многих других фреймворках, поддерживаются различные стили [кнопок](https://docs.atlassian.com/aui/latest/docs/buttons.html):
### 2.5 Элементы оформления
В наличии есть различные средства, призванные сделать страницу более яркой и легкой для восприятия. Одно из них — это [иконки](https://docs.atlassian.com/aui/latest/docs/icons.html). Их можно использовать непосредственно в тексте или вставлять в ссылки и кнопки:
У нас в JIRA настроен Gravatar, подгружающий изображения из профилей в интранете. Поэтому имеет смысл отображать [аватар](https://docs.atlassian.com/aui/latest/docs/avatars.html) рядом с именами пользователей. Это выглядит так:
Статусы можно оформлять в виде подсвеченных [лейблов](https://docs.atlassian.com/aui/latest/docs/lozenges.html). Это позволяет пользователю через какое-то время не читать текст, обращая внимание только на цвет:
Кроме вышеописанных специализированных компонент, фреймворк автоматически [оформляет](https://docs.atlassian.com/aui/latest/docs/typography.html) заголовки, абзацы и списки.
Можно применить оформление и к [таблице](https://docs.atlassian.com/aui/latest/docs/tables.html), добавив класс `aui`. Дополнительно можно добавить класс `aui-table-rowhover`. Это позволит автоматически подсвечивать всю строку при наведении курсора. Интересно, что эта возможность не описана в документации. Как и некоторые другие вещи, про это можно узнать, анализируя разметку страниц JIRA, использующих AUI.
### 2.6 Вспомогательные скрипты
Библиотека jQuery не является частью AUI Framework, однако все равно встроена в JIRA. Доступ к ней можно получить через `AJS.$`. Мы обычно оборачиваем скрипты в:
```
(function ($) {
AJS.toInit(function () {
// Script starts here...
});
})(AJS.$);
```
Первая обертка позволяет получить доступ к jQuery в привычном виде, а вторая гарантирует, что к моменту начала выполнения наших скриптов DOM-дерево и AUI уже будут инициализированы.
Существует [специальный компонент](https://docs.atlassian.com/aui/latest/docs/keyboard.html) для реализации работы горячих клавиш.
AJS содержит также несколько других полезных вспомогательных функций: для получения полного пути к приложению, подгрузки локализированных строк и так далее. Подробнее о них можно почитать [здесь](https://developer.atlassian.com/display/AUI/AJS+helper+functions).
3. Примеры того, что можно сделать
==================================
Давайте посмотрим на несколько примеров наших реальных интерфейсных задач, решенных с помощью фреймворка.
Одной из них было создание и хранение контрагентов — неких сущностей с небольшим набором параметров. Эти данные импортировались из SAP, и их было достаточно много — несколько десятков тысяч. Мы решили не хранить их в виде issue, перегружая систему, а сохранять в базу с помощью Active Objects API. Соответственно, нужна была возможность управления контрагентами.
Был реализован интерфейс с пейджингом, поиском и возможностью управления этими сущностями. Служебная информации о синхронизации была спрятана в tooltip, отображающийся только для синхронизированных контрагентов:
Другой задачей было отображение таблицы с целочисленными данными, некоторые из которых должны были иметь возможность редактирования. В AJS не было таких компонент, поэтому мы просто адаптировали верстку и скрипты Inline Issue Editing, разобравшись в исходниках:
В качестве последнего примера приведем выбор подразделения из списка. С задачей мог бы справиться и обычный Select, но нам хотелось показывать пользователю руководителя подразделения для того, чтобы упростить выбор. Поэтому мы использовали AUI Select2. Вот что получилось:
4. Недокументированные возможности
==================================
Существуют некоторые неописанные в документации возможности фреймворка и встроенных в JIRA библиотек. Ясно, что в следующих версиях JIRA они могут измениться или вообще исчезнуть, но, во-первых, это маловероятно, а, во-вторых, преимущества от их использования достаточно велики.
В качестве примера приведем уже упомянутый выше css-класс `aui-table-rowhover` для таблиц. Он точно никуда не пропадет в ближайших версиях JIRA, так как используется практически во всех стандартных таблицах.
Еще одним примером является затемнение и блокировка страницы. Нам хотелось делать это при вызове синхронизации на описанной странице управления контрагентами. Посмотрев в исходники JIRA, мы обнаружили, что это уже реализовано с помощью:
```
AJS.dim();
JIRA.Loading.showLoadingIndicator();
```
и, соответственно
```
AJS.undim();
JIRA.Loading.hideLoadingIndicator();
```
В общем случае рекомендуем искать, где в JIRA уже есть желаемый функционал и затем смотреть по исходникам, как именно он реализован. Зачастую это позволяет получить нужный результат проще и быстрее.
5. Подводные камни
==================
В целом, фреймворк ведет себя достаточно стабильно. Единственной багой, с которой мы столкнулись при разработке, было исчезновение Inline Dialog при клике на input внутри него. Опять же, покопавшись немного в исходниках, удалось найти workaround — предотвращение передачи события клика на элемент внутри диалога:
```
content.click(function(e) {
e.stopPropagation();
});
```
Обо всех известных проблемах можно узнать и сообщить в [официальном багтрекере](https://ecosystem.atlassian.net/browse/AUI), но не думаем, что вам это понадобится.
Следует также понимать, что версия фреймворка (и, соответственно, набор компонент) зависит от версии JIRA, под которой запущен плагин. Если вам нужна поддержка нескольких версий JIRA, нужно не забыть про тестирование под ними. При разработке наших внутренних плагинов, мы не занимаемся этим, так как пишем сразу под текущую версию JIRA. Но все же перед обновлением JIRA на новую версию, нам приходится учитывать Release Notes, публикуемые Atlassian.
6. Что дальше?
==============
* Довольно подробная официальная [документация](https://docs.atlassian.com/aui/latest/docs/index.html) по компонентам AUI Framework.
* Официальная [документация](https://developer.atlassian.com/display/AUI) по самому AUI Framework — о том, как можно внедрить его в свой проект, поучаствовать в разработке и подготовиться к обновлению.
* [Песочница](https://docs.atlassian.com/aui/latest/sandbox/index.html), в которой можно поиграть с компонентами и посмотреть, как они будут выглядеть.
7. Заключение
=============
Разработка качественного интерфейса — это не единственный, но очень важный шаг при создании хорошего плагина. AUI Framework позволяет сделать эту разработку проще, быстрее и эффективнее. И не нужно бояться анализа исходников фреймворка — это позволяет гораздо лучше понять его и взаимодействовать с ним.
Помимо интерфейса есть и другие, невидимые для пользователя практики качественной разработки. О них мы расскажем в одном из следующих постов. | https://habr.com/ru/post/243543/ | null | ru | null |
# Extjs, диалоги и вселенское зло!
Да! Я ошибочно считаю что диалоги типа «а вы точно хотите удалить ндцать выделенных объектов» вселенским злом. Но так считают единицы.
Постоянно требуется втыкать это безобразие в код. Но и тут не все гладко.
В Extjs это как-то через голову делается.
Хочется написать просто:
`var answ = confirmDlg('Are you sure?');
if (answ=='ok'){
this.deleteSelectedItems();
}`
где this это наша табличка. Удобно и радостно. Так нет же. «Окна» у нас асинхронные и до безобразия объектные тоже. Надо обрабатывать ответ «внутри» объекта окна. И this уже ссылается не на мою таблицу, а на окно. И начинается пляска с id и с выколупыванием доступа к таблице.
А как вы поступаете в аналогичных случаях? | https://habr.com/ru/post/23344/ | null | ru | null |
# Добавляем распределенность в SObjectizer-5 с помощью MQTT и libmosquitto
Когда-то в SObjectizer-4 «из коробки» была доступна возможность построения распределенных приложений. Но не всегда это работало так хорошо, как хотелось бы. В итоге в SObjectizer-5 от поддержки распределенности в самом ядре [SObjectizer](https://stiffstream.com/en/products/sobjectizer.html)-а мы отказались (подробнее этот вопрос рассматривается [здесь](https://habr.com/post/325248/)). Отказались в пользу того, чтобы под конкретную задачу можно было выбрать конкретный транспорт с учетом особенностей этой самой задачи. Написав для этого соответствующую обвязку, которая будет скрывать от программиста детали работы выбранного транспорта.
В данной статье мы попробуем рассказать об одной такой обвязке вокруг [MQTT](http://mqtt.org/) и [libmosquttio](https://mosquitto.org/man/libmosquitto-3.html), посредством которой была реализована возможность взаимодействия частей распределенного приложения.
Что и зачем
===========
Пару лет назад мы помогали одной команде с разработкой прототипа распределенной измерительной системы. Прототип заработал и, насколько нам известно, работает в демонстрационном режиме до сих пор. К сожалению, у команды возникли сложности с поиском дальнейшего финансирования и проект заморозили. Из-за «подвешенного» статуса проекта мы сможем рассказать только то, что сможем рассказать, без ~~имен, явок и паролей~~ подробностей.
Итак, была идея создания распределенной системы сбора некоторой измерительной информации. Планировалось иметь центральный сервер, куда стекается и где обрабатывается вся собранная информация. А также некоторое множество (от нескольких сотен до нескольких тысяч) «измерительных станций».
Первоначально центральный сервер раздает команды на сбор информации на измерительные станции. А уже дальше станции сами в любой момент могут отдавать информацию центральному серверу, при этом центральный сервер в любой момент может выдавать новые команды измерительным станциями.
Для реализации начинки измерительных станций решили использовать C++. Как из-за экономии ресурсов этих самых станций, так и из-за необходимости местами работать с системным API.
В реализации же центрального сервера можно было использовать использовать Java и/или что-то более удобное и безопасное, нежели C++. Хотя в рамках прототипа на C++ был написан демонстрационный «сервер» на C++, который поддерживал несколько сценариев сбора информации от измерительных станций, но без обработки этой информации.
MQTT в качестве транспорта
--------------------------
Итак, есть измерительная станция, на которой крутится написанный на C++ процесс, который должен взаимодействовать с центральным сервером: получать от сервера команды, отдавать серверу результаты выполнения команд, контролировать наличие связи с сервером, переподключаться к серверу при разрывах связи и т.д.
Возникал естественный вопрос: какой именно транспорт будет использоваться для общения центрального сервера с измерительными станциями?
Нужно сказать, что ответ на этот вопросы искали не очень долго. Остановились на протоколе MQTT, который:
* имеет официальную спецификацию и существуют реализации этой спецификации для разных языков программирования;
* очень простой и легковесный. Т.е. даже если придется для каких-то совсем уж специфических условий написать свою реализацию этого протокола, то это не составит большого труда;
* позволяет легко обмениваться информацией в обоих направлениях;
* предполагает использование простой, но мощной и удобной модели Publish/Subscribe.
В общем, по нашему мнению, раз уж MQTT для такого рода задач создавался, то грех его в подобных условиях не использовать.
Но MQTT — это транспорт. Сами данные было решено обрамлять в JSON. Благо, JSON достаточно простой, понятный и легковесный. Опять же, для любого мало-мальски востребованного языка программирования есть библиотеки, позволяющие работать с JSON-ом.
Таким образом мы столкнулись с тем, что в своем C++ коде мы должны подружить SObjectizer с MQTT и JSON-ом. Вот о том, как мы это сделали и поговорим дальше.
Что у нас получилось?
=====================
Мы сделали небольшую надстройку над SObjectizr-ом и libmosquitto под названием [mosquitto\_transport](https://github.com/Stiffstream/mosquitto_transport). Эта надстройка берет на себя задачи взаимодействия с MQTT-брокером и предоставляет разработчику небольшой API для публикации и подписки сообщения.
Библиотека mosquitto\_transport написана на C++14, работает под Linux, поддерживает лишь часть возможностей MQTT (в частности, используется только QoS=0). В общем, в ней реализован тот минимум, который потребовался для прототипа.
Как выглядит использование mosquitto\_transport?
------------------------------------------------
Для использования mosquitto\_transport разработчику нужно сделать несколько обязательных шагов, которые мы подробнее рассмотрим ниже.
> Библиотека mosquitto\_transport размещает все свое содержимое в пространстве имен mosquitto\_transport. Но такое длинное имя использовать в примерах неудобно. Поэтому далее местами будет использоваться синоним mosqtt, который вводится следующим образом: namespace mosqtt = mosquitto\_transport;
### Шаг первый. Инициализация mosquitto\_transport и libmosquitto
В качестве базы у mosquitto\_transport лежит libmosquitto, а libmosquitto нуждается в явной инициализации в начале работы программы и явной деинициализации при завершении программы. Поэтому для работы с mosquitto\_transport нужно создать где-то в программе объект типа lib\_initializer\_t. Этот объект в своем конструкторе проинициализирует libmosquitto, а в деструкторе — выполнит деинициализацию. Ссылку на lib\_initializer\_t нужно будет затем передать в конструктор агента a\_transport\_manager\_t.
Обычно в программе это выглядит следующим образом:
```
int main() {
mosqtt::lib_initializer_t mosqtt_lib;
...
}
```
### Шаг второй. Запуск агента a\_transport\_manager\_t и получение экземпляра instance\_t
Весь поток входящих и исходящих сообщений обслуживает специальный агент a\_transport\_manager\_t. Разработчик должен сам создать агента этого типа у себя в программе и зарегистрировать этого агента в составе какой-нибудь кооперации.
Кроме собственно создания и регистрации агента a\_transport\_manager\_t, нужно сделать еще одну важную вещь: взять у агента экземпляр объекта специального типа instance\_t. Именно этот instance\_t будет нужен для публикации и получения сообщений.
Если в приложении работают всего несколько агентов, то их всех можно поместить в одну кооперацию с агентом a\_transport\_manager\_t:
```
int main() {
...
mosqtt::lib_initializer_t mosqtt_lib;
...
so_5::launch([&](so_5::environment_t & env) {
// Сразу регистрируем кооперацию, в которую войдут все
// агенты приложения.
env.introduce_coop([&](so_5::coop_t & coop) {
// Создаем транспортного агента.
auto transport = coop.make_agent(...);
// Теперь можем создать и остальных агентов.
coop.make\_agent(..., transport->instance(), ...);
coop.make\_agent(..., transport->instance(), ...);
coop.make\_agent(..., transport->instance(), ...);
});
});
}
```
Но в более сложных случаях, когда прикладных агентов больше и/или прикладные агенты могут возникать и исчезать по ходу работы приложения, имеет смысл создать отдельную кооперацию с a\_transport\_manager\_t и привязать этого агента к собственному диспетчеру. В этом случае может быть разумным выделить создание a\_transport\_manager\_t в отдельную вспомогательную функцию:
```
mosqtt::instance_t make_transport(
so_5::environment_t & env,
mosqtt::lib_initializer_t & mosqtt_lib,
... /* Какие-то дополнительные параметры */) {
mosqtt::instance_t instance;
env.introduce_coop(
// Транспортный агент будет работать на собственной рабочей нити.
so_5::disp::one_thread::create_private_disp(env)->binder(),
[&](so_5::coop_t & coop) {
auto transport = coop.make_agent(
std::ref{mosqtt\_lib},
... /\* Дополнительные параметры \*/);
instance = transport->instance();
});
return instance;
}
```
Что позволяет затем использовать make\_transport, например, следующим образом:
```
int main() {
...
mosqtt::lib_initializer_t mosqtt_lib;
...
so_5::launch([&](so_5::environment_t & env) {
// Запускаем MQTT-транспорт.
auto mqtt = make_transport(env, mosqtt_lib, ...);
// Регистрируем первую кооперацию с прикладными агентами приложения.
env.introduce_coop([&](so_5::coop_t & coop) {
coop.make_agent(..., mqtt, ...);
coop.make\_agent(..., mqtt, ...);
coop.make\_agent(..., mqtt, ...);
});
// Регистрируем вторую кооперацию с прикладными агентами приложения.
env.introduce\_coop(...);
... // И так далее.
});
}
```
Примечательной особенностью агента a\_transport\_manager\_t является то, что ряд обработчиков событий у него помечены как thread-safe. Что делает возможным привязку этого агента к диспетчеру типа adv\_thread\_pool. В этом случае агент сможет часть своих событий обрабатывать параллельно сразу на нескольких рабочих нитях. Хотя нам на практике эта функциональность не потребовалась.
### Шаг третий. Реализация сериализации/десериализации прикладных сообщений
Самая важная часть при использовании mosquitto\_transport — это реализация формата представления передаваемых сообщений. Например, если у нас есть сообщение вида:
```
struct sensor_data_t {
data_category_t category_;
timestamp_t when_;
int value_;
...
};
```
то для передачи его MQTT-брокеру и далее подписчикам следует преобразовать сообщение в какой-то формат. Например, в XML, JSON или ProtoBuf. Для того, чтобы это происходило автоматически во время работы с mosquitto\_transport разработчик должен реализовать сериализацию/десериализацию. Подробнее этот вопрос рассматривается ниже, пока же покажем основную идею.
Во-первых, разработчик должен определиться с тем, как данные будут представлены. Например, это может быть текстовое JSON-представление. Или же бинарное ProtoBuf представление. Может быть и то, и другое — mosquitto\_transport этому не препятствует, но разработчик сам должен следить за тем, какой формат сообщений в каких топиках у него используется.
Во-вторых, для каждого своего формата разработчик должен определить тип-тег. Например, если мы хотим использовать только JSON, то мы определяем тип-тег следующего вида:
```
struct json_encoding {};
```
Этот тип-тег потребуется для параметризации шаблонов и выбора перегруженных функций.
В-третьих, разработчик должен для каждого своего форма определить в пространстве имен mosquitto\_transport частичную специализацию для шаблонных классов encoder\_t и decoder\_t.
Чтобы получилось что-то вроде:
```
// Это наш тип-тег, который определяет формат представления данных.
struct my_encoding_tag {};
// Реализация сериализации/десериализации данных через специализацию
// типов внутри пространства имен mosquitto_transport.
namespace mosquitto_transport {
// Реализация сериализации.
template
struct encoder\_t {
static std::string encode(const Msg & what) {
... // Тут какой-то код по сериализации.
}
};
// Реализация десериализации.
template
struct decoder\_t {
static Msg decode(const std::string & payload) {
... // Тут какой-то код по десериализации.
}
};
} /\* namespace mosquitto\_transport \*/
```
Далее операции публикации сообщений и подписки на сообщения нужно будет указывать тип-тег в качестве маркера, благодаря которому mosquitto\_transport будет понимать, как именно нужно сериализовать и десериализовать сообщения.
### Последующие шаги. Публикация и получение сообщений
После того как три вышеозначенных обязательных шага выполнены, можно выполнять операции публикации сообщений и подписки на сообщения.
Публикация выглядит следующим образом:
```
mosqtt::topic_publisher_t::publish(
// Объект instance, полученный от a\_transport\_manager\_t.
instance,
// Имя топика на MQTT-брокере, в который будет выполняться
// публикация сообщения.
"some/topic/name",
// Объект, чье содержимое будет опубликовано.
some\_message\_instance);
```
Такой операций мы говорим, что хотим опубликовать сообщение в конкретный топик и что это сообщение должно быть сериализовано соответствующим образом (формат определяет шаблонный параметр Tag\_Type). Например, мы могли бы написать так:
```
mosqtt::topic_publisher_t::publish(
instance,
"/sensor/1023/updates",
sensor\_data\_t{
data\_category\_t::recent\_value, current\_timestamp, value});
```
В этом случае mosquitto\_transport сериализовал бы данные из сообщения типа sensor\_data\_t в формат, определенный для my\_encoding\_tag, и опубликовал бы получившееся сообщение в топик "/sensor/1023/updates".
Для того, чтобы получать сообщения, которые кто-то публикует в интересующие нас топики нужно сделать как бы «двойную подписку»: нужно вызвать специальный метод subscribe() и внутри этого метода подписаться на сообщения из специального mbox-а. Например, если мы хотим получать все сообщения из топиков "/sensor/+/updates", то мы можем сделать вот такой вызов subscribe() внутри какого-то из своих агентов:
```
class my_agent_t : public so_5::agent_t {
...
void so_define_agent() override {
mosqtt::topic_subscriber_t::subscribe(
// Объект instance, полученный от a\_transport\_manager\_t.
instance\_,
// Топик, на который хотим подписаться.
"sensor/+/updates",
// Лямбда, внутри которой будет происходить подписка на
// входящие сообщения.
[this](so\_5::mbox\_t mbox) {
// Сама подписка для того, чтобы агент мог получать
// входящие сообщения.
so\_subscribe(mbox).event(&my\_agent\_t::on\_sensor\_data);
});
}
...
void on\_sensor\_data(
mhood\_t> cmd) {
...
}
};
```
Двойная подписка здесь нужна потому, что у нас, по сути, есть два разных действия:
* во-первых, нам нужно заставить transport\_manager-а подписаться на конкретный топик на MQTT-брокере. Без этой подписки брокер просто не будет доставлять нам новые входящие сообщения. Собственно, именно это и делает метод subscribe();
* во-вторых, когда MQTT-брокер доставляет нам сообщение из подписанного нами топика, то нужно доставить это сообщение до агента-получателя. Для этого должен использоваться механизм подписок SObjectizer-а. Как раз поэтому внутри subscribe() создается новый mbox, который будет связан с конкретной подпиской на MQTT-брокере. Когда брокер отдаст нам новое сообщение, то это сообщение будет отослано в mbox. Соответственно, сообщение дойдет до агента, который подписался на этот mbox.
### Простейший Hello, World
Для демонстрации mosquitto\_transport «в деле» сделаем типичный хелло-ворлдовский пример. В пример входят два приложения:
* demo\_server\_app. Подключается к локальному MQTT-шному брокеру и подписывается на сообщения из топиков "/client/+/hello". Когда сообщение приходит, отвечает ответным сообщением в топик "/client/:ID/replies";
* demo\_client\_app. Подключается к локальному MQTT-шному брокеру, подписывается на топик "/client/:ID/replies" и публикует сообщение в топик "/client/:ID/hello". Завершает свою работу как только в "/client/:ID/replies" приходит ответ.
В качестве ":ID" в именах топиков будет использоваться целочисленный идентификатор, который demo\_client\_app генерирует случайным образом.
Сообщения передаются в JSON-формате.
Исходные тексты примера можно найти [в этом репозитории](https://github.com/Stiffstream/so5_mosqtt_demo_ru). Мы же пройдемся по основным моментам реализации примера.
#### Определение сообщений для взаимодействия «клиента» и «сервера»
В заголовочном файле [demo/messages.hpp](https://github.com/Stiffstream/so5_mosqtt_demo_ru/blob/201909101800/dev/demo/messages.hpp) сделаны определения структур данных, которые выступают в качестве сообщений для взаимодействия «клиента» и «сервера». Клиент отсылает серверу сообщение типа client\_hello\_t, а сервер в ответ присылает сообщение типа server\_hello\_t. Конечно же, в виде MQTT-сообщений летают сериализованные в JSON представления этих сообщений. Но в программе работа идет именно с типами client\_hello\_t/server\_hello\_t.
Для того, чтобы сообщения типов client\_hello\_t/server\_hello\_t сериализовались и десериализовались должным образом, мы определяем тип-тег с именем json\_format\_t. И делаем частичную специализацию encoder\_t и decoder\_t в соответствии с тем, как мы об этом говорили выше. Для работы с JSON-ом мы используем небольшую надстройку над RapidJSON под названием [json\_dto](https://github.com/Stiffstream/json_dto). Поэтому внутри наших типов client\_hello\_t/server\_hello\_t есть шаблонные методы json\_io — это как раз специфика json\_dto.
Итак, вот что находится в messages.hpp:
```
#pragma once
#include
#include
namespace demo {
// Тип-тег, который будет указывать в каком формате должны быть
// сериализованы сообщения.
struct json\_format\_t {};
// Удобные имена для использования.
using publisher\_t = mosquitto\_transport::topic\_publisher\_t;
using subscriber\_t = mosquitto\_transport::topic\_subscriber\_t;
// Сообщение о появлении нового клиента.
struct client\_hello\_t {
int id\_;
std::string greeting\_;
std::string reply\_topic\_;
template
void json\_io(Json\_Io & io) {
using namespace json\_dto;
io & mandatory("id", id\_)
& mandatory("greeting", greeting\_)
& mandatory("reply\_topic", reply\_topic\_);
}
};
// Ответное сообщение от сервера.
struct server\_hello\_t {
std::string greeting\_;
template
void json\_io(Json\_Io & io) {
io & json\_dto::mandatory("greeting", greeting\_);
}
};
} /\* namespace demo \*/
// Средства для сериализации-десериализации сообщений.
namespace mosquitto\_transport {
template
struct encoder\_t {
static std::string encode(const Msg & msg) {
return json\_dto::to\_json(msg);
}
};
template
struct decoder\_t {
static Msg decode(const std::string & json) {
return json\_dto::from\_json(json);
}
};
} /\* namespace mosquitto\_transport \*/
```
Отдельного пояснения, возможно, заслуживают определения имен publisher\_t и subscriber\_t. Они нужны для того, чтобы в прикладном коде можно было писать, например:
```
publisher_t::publish(...)
```
вместо:
```
mosqtt::topic_publisher_t::publish(...)
```
#### Общий утилитарный код
Еще один заголовочный файл, [demo/common.hpp](https://github.com/Stiffstream/so5_mosqtt_demo_ru/blob/201909101800/dev/demo/common.hpp), содержит вспомогательные функции, который нужны как клиенту, так и серверу.
Функция make\_loggers(), которую мы рассматривать не будем, создает объекты для логгирования. Нам нужно два таких объекта. Первый будет использоваться mosquitto\_transport-ом. Второй — демонстрационным приложением. В примере для логгеров уровень детализации выставляется в spdlog::level::trace. Т.е. логироваться будет все, что позволяет наблюдать практически за всем, что происходит внутри приложения.
А вот функция run\_transport\_manager(), код которой мы посмотрим, служит как раз для создания и запуска агента a\_transport\_manager\_t. Возвращает run\_transport\_manager() экземпляр типа mosquitto\_transport::instance\_t, который затем потребуется для публикации и подписки:
```
auto run_transport_manager(
so_5::environment_t & env,
const std::string & client_id,
std::shared_ptr logger) {
mosquitto\_transport::instance\_t mqtt;
env.introduce\_coop([&](so\_5::coop\_t & coop) {
auto lib = coop.take\_under\_control(
std::make\_unique());
auto tm = coop.make\_agent(
std::ref(\*lib),
mosquitto\_transport::connection\_params\_t{
client\_id, "localhost", 1883u, 60u},
std::move(logger));
mqtt = tm->instance();
});
return mqtt;
}
```
Здесь создается новая кооперация, которая содержит единственного агента — a\_transport\_manager\_t. Этому агенту в конструктор передаются параметры подключения к MQTT-брокеру (поскольку это хелло-ворловский пример, то достаточно MQTT-брокера на localhost-е) и логгер, который следует использовать. Но самое любопытное здесь — это создание объекта lib\_initializer\_t. Он создается динамически, а ответственность за его удаление перекладывается на кооперацию с агентом a\_transport\_manager\_t. Тем самым у нас получается, что libmosquitto будет проинициализирована непосредственно перед созданием агента a\_transport\_manager\_t, а деинициализированна она будет уже после того, как агент a\_transport\_manager\_t перестанет существовать.
#### Основная часть demo\_server\_app
В [demo\_server\_app](https://github.com/Stiffstream/so5_mosqtt_demo_ru/blob/201909101800/dev/demo/server.cpp) всю прикладную логику выполняет агент listener\_t, реализованный следующим образом:
```
class listener_t final : public so_5::agent_t {
public:
listener_t(
context_t ctx,
mosqtt::instance_t mqtt,
std::shared_ptr logger)
: so\_5::agent\_t{std::move(ctx)}
, mqtt\_{std::move(mqtt)}
, logger\_{std::move(logger)}
{}
virtual void so\_define\_agent() override {
demo::subscriber\_t::subscribe(mqtt\_, "/client/+/hello",
[&](const so\_5::mbox\_t & mbox) {
so\_subscribe(mbox).event(&listener\_t::on\_hello);
});
}
private:
mosqtt::instance\_t mqtt\_;
std::shared\_ptr logger\_;
void on\_hello(mhood\_t cmd) {
logger\_->trace("message received from topic: {}, payload={}",
cmd->topic\_name(),
cmd->payload());
const auto msg = cmd->decode();
logger\_->info("hello received. client={}, greeting={}",
msg.id\_, msg.greeting\_);
demo::publisher\_t::publish(
mqtt\_,
msg.reply\_topic\_,
demo::server\_hello\_t{"World, hello!"});
}
};
```
Это, можно сказать, типичный маленький SObjectizer-овский агент. В своем перегруженном методе so\_define\_agent() выполняется подписка на сообщения из топиков, удовлетворяющих маске "/client/+/hello". Когда такие сообщения от брокера будут приходить, то для их обработки будет вызываться метод on\_hello.
В метод on\_hello() передается специальный объект, который содержит имя топика (в который сообщение было опубликовано) и само сообщение именно в том виде, в котором оно пришло от MQTT-брокера. Т.е. в JSON-представлении. Но мы хотим получить это сообщение в виде объекта типа client\_hello\_t. Для этого вызывается метод decode(), в котором и происходит десериализация тела сообщения из JSON-а в client\_hello\_t.
Ну а в конце on\_hello(), публикуется ответное сообщение. Имя топика для публикации ответа берется из пришедшего client\_hello\_t.
#### Основная часть demo\_client\_app
В [demo\_client\_app](https://github.com/Stiffstream/so5_mosqtt_demo_ru/blob/201909101800/dev/demo/client.cpp) так же основную работу выполняет единственный агент типа client\_t. Но этот агент несколько посложнее, чем listener\_t в demo\_server\_app. Вот код client\_t:
```
class client_t final : public so_5::agent_t {
public:
client_t(
context_t ctx,
int id,
mosqtt::instance_t mqtt,
std::shared_ptr logger)
: so\_5::agent\_t{std::move(ctx)}
, id\_{id}
, mqtt\_{std::move(mqtt)}
, logger\_{std::move(logger)} {
}
virtual void so\_define\_agent() override {
// Подписываемся на уведомления о наличии подключения к брокеру.
so\_subscribe(mqtt\_.mbox()).event(&client\_t::on\_broker\_connected);
demo::subscriber\_t::subscribe(mqtt\_, make\_topic\_name("/replies"),
[&](const so\_5::mbox\_t & mbox) {
so\_subscribe(mbox).event(&client\_t::on\_reply);
});
}
private:
const int id\_;
mosqtt::instance\_t mqtt\_;
std::shared\_ptr logger\_;
std::string make\_topic\_name(const char \* suffix) const {
return std::string("/client/") + std::to\_string(id\_) + suffix;
}
void on\_broker\_connected(mhood\_t) {
// После того, как подключились к брокеру можем сообщить о
// своем существовании.
demo::publisher\_t::publish(
mqtt\_,
make\_topic\_name("/hello"),
demo::client\_hello\_t{
id\_,
"Hello, World",
make\_topic\_name("/replies")});
}
void on\_reply(mhood\_t cmd) {
logger\_->trace("message received from topic: {}, payload={}",
cmd->topic\_name(),
cmd->payload());
const auto msg = cmd->decode();
logger\_->info("hello received. greeting={}", msg.greeting\_);
// Теперь мы свою работу можем завершить.
logger\_->warn("finishing");
so\_environment().stop();
}
};
```
Здесь агент client\_t обрабатывает два события. С событием, на которое подписывается обработчик on\_reply(), все должно быть понятно — это обработка сообщения, которое приходит от MQTT-брокера.
Пояснить следует обработчик on\_broker\_connected. Дело в том, что когда клиент стартует, нужно выбрать момент, когда можно публиковать начальное сообщение в топике "/client/:ID/hello". Поскольку если агент client\_t сделает это сразу после своего старта, то сообщение никуда не уйдет и будет потеряно, т.к. еще нет подключения к MQTT-брокеру. Поэтому агенту client\_t нужно дождаться, пока это подключение будет установлено.
Взаимодействием с MQTT-брокером занимается a\_transport\_manager\_t. Когда связь с брокером появляется (т.е. когда не только установили TCP-соединение с брокером, но и когда обменялись с брокером сообщениями CONNECT/CONNACT) агент a\_transport\_manager\_t отсылает в специальный mbox сигнал broker\_connected\_t. На этот сигнал подписывается client\_t и когда сигнал приходит, client\_t публикует сообщение client\_hello\_t.
#### Результаты работы приложения
Запустив demo\_server\_app можно увидеть приблизительно следующую картину:
Здесь видно, как demo\_server\_app подключился к брокеру, как сделал подписку, как получил входящее сообщение и как ответил на него.
Запустив demo\_client\_app можно увидеть картинку вот такого плана:
Здесь видно, как demo\_client\_app подключился к брокеру, как сделал подписку, как отослал свое приветственное сообщение и как получил сообщение от demo\_server\_app в ответ.
Пару слов о принятых проектных решениях
=======================================
Выше мы показали как выглядит на данный момент получившаяся у нас библиотека [mosquitto\_transport](https://github.com/Stiffstream/mosquitto_transport). Теперь можно попробовать сказать несколько слов о ряде проектных решений, которые были положены в основу реализации.
Небольшой дисклаймер: mosquitto\_transport сама по себе является прототипом
---------------------------------------------------------------------------
Когда у нас появилась задача предоставить возможность SObjectizer-овским агентам общаться с внешним миром через MQTT, то мы быстро убедились, что использовать такие широко распространенные библиотеки, как [libmosquitto](https://mosquitto.org/man/libmosquitto-3.html) и [Paho](https://www.eclipse.org/paho/) не удобно. С примитивными C++ными обертками над ними так же все было печально.
Главная проблема, в частности, с libmosquitto, заключалась в том, что в libmosquitto предполагается делать обработку вообще всех входящих сообщений в одном и том же коллбэке. Тогда как нам нужно, чтобы в приложении было несколько независимых агентов, каждый из которых должен получать только те сообщения, в которых он заинтересован.
Соответственно, нужно было сделать какой-то слой, который бы располагался между прикладными агентами и libmosquitto. Чтобы этой слой скрывал от агентов всю требуху работы с libmosquitto-вскими вызовами и коллбэками. Но каким должен быть этот слой?
Готового ответа у нас, естественно, не было. В mosquitto\_transport мы попытались найти этот ответ. Получилось более-менее нормально, особенно с учетом того, что сил в mosquitto\_transport было вложено, откровенно говоря, совсем немного. Больше всего работы потребовала поддержка wildcard-ов в именах топиков при подписке. Ну и написание понятного README, чтобы затем самим не забыть, как пользоваться mosquitto\_transport.
Наверняка можно было бы сделать лучше. Кроме того, в существующей реализации остались серьезные белые пятна. Например, поддержка уровней QoS отличных от 0. Или вопросы производительности, которые в рамках разрабатываемого прототипа были несущественными.
Так что сами мы рассматриваем текущую реализацию mosquitto\_transport как вполне себе работающий и отлаженный прототип. Который можно брать и пробовать. Но который, наверняка, придется доработать напильником для каких-то других условий.
Всю основную работу делает a\_transport\_manager\_t и одна вспомогательная рабочая нить
---------------------------------------------------------------------------------------
В mosquitto\_transport практически всю работу выполняет агент a\_transport\_manager\_t. Он создает экземпляр mosquitto, он реализует все нужные коллбэки, он запускает основной цикл событий libmosquitto на контексте отдельной рабочей нити посредством [mosquitto\_loop\_start()](https://mosquitto.org/api/files/mosquitto-h.html#mosquitto_loop_start), он же затем останавливает этот цикл через [mosquitto\_loop\_stop](https://mosquitto.org/api/files/mosquitto-h.html#mosquitto_loop_stop).
Но в работе a\_transport\_manager\_t есть несколько фокусов, на которых можно заострить внимание.
### Делегирование работы с одной рабочей нити на другую
Основной цикл обработки событий libmosquitto выполняется на контексте отдельной рабочей нити. Это означает, что и коллбэки, вроде mosquitto\_log\_callback, mosquitto\_connect\_callback, mosquitto\_subscribe\_callback и т.д., вызываются на контексте этой самой отдельной нити. Но их этих коллбэков нужно получать доступ к данным агента a\_transport\_manager\_t. Который, в свою очередь, работает на другой рабочей нити (или даже на нескольких других нитях в случае adv\_thread\_pool-диспетчера).
Мы не стали защищать данные агента a\_transport\_manager\_t какими-то примитивами синхронизации (вроде std::mutex-а). Вместо этого мы из коллбэка отсылаем агенту a\_transport\_manager\_t сообщение. Которое уже будет обработано на основном рабочем контексте агента. Из-за чего при обработке сообщения нам вообще не нужно думать о синхронизации доступа к данным.
Вот, например, как это выглядит в коде. Реализация mosquitto\_message\_callback:
```
void
a_transport_manager_t::on_message_callback(
mosquitto *,
void * this_object,
const mosquitto_message * msg )
{
auto tm = reinterpret_cast< a_transport_manager_t * >(this_object);
tm->m_logger->trace( "on_message, topic={}, payloadlen={}, qos={}"
", retain={}",
msg->topic, msg->payloadlen, msg->qos, msg->retain );
so_5::send< message_received_t >( tm->m_self_mbox, *msg );
}
```
И обработчик сообщения message\_received\_t:
```
void
a_transport_manager_t::on_message_received(
const message_received_t & cmd )
{
auto subscribers = m_delivery_map.match( cmd.m_topic );
if( !subscribers.empty() )
{
for( auto * s : subscribers )
s->deliver_message( cmd.m_topic, cmd.m_payload );
}
else
m_logger->warn( "message for unregistered topic, topic={}, "
"payloadlen={}",
cmd.m_topic, cmd.m_payload.size() );
}
```
### Асинхронная работа с подписками
Когда какой-то агент делает вызов subscribe(), то подписка на соответствующий MQTT-шный топик выполняется не синхронно внутри subscribe(), а асинхронно. Вначале агенту a\_transport\_manager\_t отсылается сообщение subscribe\_topic\_t. Затем, агент a\_transport\_manager\_t обрабатывает это сообщение и пытается создать подписку на MQTT-брокере. Что может быть в данный момент и невозможно, если сейчас связи с брокером нет.
Соответственно, вызов subscribe() вовсе не означает, что при выходе из него подписка уже создана и агент сразу же начнет получать опубликованные в соответствующем топике сообщения. Обычно это не проблема, но помнить об этом факте следует.
Иногда агенту желательно знать, существует ли подписка на топик или же подписки по каким-то причинам нет. Например, агент хочет сперва подписаться на некий топик и лишь затем начать публиковать свои сообщения. В этом случае агент может подписаться на специальные сообщения subscription\_available\_t, subscription\_unavailable\_t и subscription\_failed\_t. Скажем, вот так может выглядеть код по подписке на топик с получением уведомления о том, что подписка была выполнена успешно:
```
mosqtt::topic_subscriber_t::subscribe(
mqtt,
"some/topic/name",
[&](const so\_5::mbox\_t & mbox) {
// Из mbox будут прилетать как опубликованные в топике сообщения...
so\_subscribe(mbox).event(
[&](mhood\_t::msg\_type> cmd) {
const auto msg = cmd->decode();
...
});
// ...но и сообщения subscription\_available\_t.
so\_subscribe(mbox).event(
[&](mhood\_t cmd) {
...
});
});
```
### Автоматическая отписка от топиков
Подписки на MQTT-шные топики создаются через вызовы subscribe(). А вот удаляются подписки автоматически. Происходит это за счет небольшой уличной магии, спрятанной в SObjectizer-овских mbox-ах ([которые можно создавать под собственные, возможно, весьма специфические задачи](https://habr.com/post/344580/)).
Дело в том, что метод subscribe() создает специальный служебный mbox и именно этот mbox затем отдается в лямбда-функцию, в которой программист подписывает своего агента. Этот служебный mbox точно знает, сколько подписок сделано. Когда все подписки уничтожаются, например, при дерегистрации агента или при ручном удалении подписок агента, mbox понимает, что подписок больше нет и просить a\_transport\_manager\_t удалить подписку на MQTT-шный топик.
### Метод so\_define\_agent() как классический пример настройки агента с несколькими состояниями
Обычно мы сталкиваемся с двумя противоположными реакциями людей, которые знакомятся с SObjectizer-ом. Первые говорят о том, что у нас все как-то сложно, агентов нужно от чего-то наследовать, нужно знать про какие-то so\_define\_agent(), so\_evt\_start() и т.д. А еще у агентов непонятно зачем есть какие-то непонятные состояния.
Вторые, напротив, говорят о том, что состояния у агентов — это классно. А наличие методов so\_define\_agent(), so\_evt\_start() и so\_evt\_finishe(), как раз таки упрощает и написание агентов и, особенно, разбирательства с чужими агентами: мол сразу знаешь куда смотреть и где что искать.
Естественно, что вторая точка зрения нам гораздо ближе. И, думается, [содержимое a\_transport\_manager\_t](https://github.com/Stiffstream/mosquitto_transport/blob/v.0.6.2/dev/mosquitto_transport/a_transport_manager.cpp#L130) является хорошим тому подтверждением. В частности, метод so\_define\_agent() сразу дает представление о том, что, как и когда этот агент обрабатывает:
```
void
a_transport_manager_t::so_define_agent()
{
st_working
.event( m_self_mbox, &a_transport_manager_t::on_subscribe_topic )
.event( m_self_mbox, &a_transport_manager_t::on_unsubscribe_topic )
.event( m_self_mbox, &a_transport_manager_t::on_message_received,
so_5::thread_safe );
st_disconnected
.on_enter( [this] {
// Everyone should be informed that connection lost.
so_5::send< broker_disconnected_t >( m_self_mbox );
} )
.event< connected_t >(
m_self_mbox, &a_transport_manager_t::on_connected );
st_connected
.on_enter( [this] {
// Everyone should be informed that connection established.
so_5::send< broker_connected_t >( m_self_mbox );
// All registered subscriptions must be restored.
restore_subscriptions_on_reconnect();
} )
.on_exit( [this] {
// All subscriptions are lost.
drop_subscription_statuses();
// No more pending subscriptions.
m_pending_subscriptions.clear();
} )
.event< disconnected_t >(
m_self_mbox, &a_transport_manager_t::on_disconnected )
.event( m_self_mbox, &a_transport_manager_t::on_subscription_result )
.event( m_self_mbox, &a_transport_manager_t::on_publish_message,
so_5::thread_safe )
.event( &a_transport_manager_t::on_pending_subscriptions_timer );
}
```
Причем агент a\_transport\_manager\_t использует иерархию состояний, пусть и очень простую:
```
state_t st_working{ this, "working" };
state_t st_disconnected{ initial_substate_of{ st_working }, "disconnected" };
state_t st_connected{ substate_of{ st_working }, "connected" };
```
При этом нельзя не отметить, что a\_transport\_manager\_t далеко не самый сложный SObjectizer-овский агент, который нам приходилось реализовывать. Чем больше и сложнее агент, тем выигрышнее оказывается наличие специализированных методов so\_define\_agent(), so\_evt\_start() и so\_evt\_finish().
Более подробно про сериализацию/десериализацию сообщений
--------------------------------------------------------
Выше мы показали, как пользователь должен настроить сериализацию и десериализацию своих сообщений. Но не объяснили почему это делается именно так. Хотя это весьма принципиальный вопрос. Можно даже назвать его «краеугольным камнем». Поэтому нужно посвятить несколько слов этому аспекту.
Во-первых, несмотря на то, что mosquitto\_transport мы делали для конкретного проекта, мы хотели сделать так, чтобы mosquitto\_transport можно было бы переиспользовать и для других задач. Поэтому нужно было сделать так, чтобы mosquitto\_transport не был привязан к конкретному формату данных. Чтобы можно было передавать данные хоть в JSON, хоть в XML, хоть в ProtoBuf, хоть в каком-то другом представлении. Возможно, даже используя несколько разных представлений в рамках одной программы.
Во-вторых, нам нужно было определиться с тем, кто будет тратить ресурсы на сериализацию/десериализацию сообщений: агент a\_transport\_manager\_t или же прикладные агенты пользователя. Тратить на эти операции ресурсы a\_transport\_manager\_t не хотелось, т.к. это прямой путь к тому, чтобы a\_transport\_manager\_t стал узким местом. Поэтому мы пошли по второму пути: сериализация и десериализация выполняется на контексте пользователя. Причем сериализация выполняется автоматически внутри topic\_publisher\_t::publish. А вот десериализация выполняется вручную — пользователь сам должен указать, какой тип он хочет получить на выходе при вызове метода incoming\_message\_t::decode(). Вот как в этом примере:
```
void on_reply(mhood_t cmd) {
...
const auto msg = cmd->decode();
```
В-третьих, есть еще момент ошибок, которые могут возникать при сериализации/десериализации сообщений. Например, пришло сообщение в формате XML, а мы попытались распарсить его как JSON. Получим ошибку и… И возникает вопрос: как об этой ошибке информировать и как эту ошибку обрабатывать?
Это еще одна причина, почему сериализация/десериализация вынесена на контекст пользователя. Если при вызове publish() или decode() возникнет связанное с ошибкой сериализации/десериализации исключение, то пользователь сможет это исключение обработать любым удобным для него способом.
Вот по совокупности всех этих факторов и была выбрана описанная ранее схема: для каждого формата данных пользователь должен определить специальный тип-тег, для которого нужно сделать частичную специализацию типов encoder\_t и decoder\_t. Такая схема позволяет иметь сразу несколько форматов для сообщений в одном приложении. Плюс все разрешается статически во время компиляции, поэтому если для какого-то типа или формата сериализация/десериализация не реализована, то это будет обнаружено в compile-time.
Общие впечатления от использования mosquitto\_transport
=======================================================
Забавно, но каких-то особых впечатлений от использования mosquitto\_transport-а не осталось. Оно просто работает.
Из описанного выше видно, что больше всего кода при работе с mosquitto\_transport приходится делать для двух вещей:
* во-первых, создание a\_transport\_manager\_t в начале работы приложения;
* во-вторых, написание кода по сериализации/десериализации сообщений;
Но, как оказалось, на практике ни один из этих моментов проблем не вызвал. Код для создания a\_transport\_manager\_t довелось написать всего несколько раз: в паре-тройке тестов, ну и в основном приложении, для которого все это предназначалось. Причем, по сравнению с другим кодом, который нужен для инициализации приложения (разбор аргументов командной строки, чтение конфигурации, создание и настройка логгеров и т.д., и т.п.) несколько строчек для запуска a\_transport\_manager\_t — это пусть и не капля в море, но все равно совсем немного.
Благодаря [json\_dto](https://github.com/Stiffstream/json_dto), кода для сериализации/десериализации сообщение приходится писать довольно мало. Ну и его все равно придется писать в том или ином виде, по крайней мере до тех пор, пока в C++ не завезут рефлексию.
Так что какой-то особой трудоемкости в использовании mosquitto\_transport при реализации десятка агентов, общающихся через MQTT с внешним миром и использующих в своей работы порядка трех десятков сообщений, мы не заметили.
Вот что оставило гораздо более яркие впечатление, так это работа с libmosquitto и изучение поведения MQTT-шного брокера в каких-то ситуациях через изучения его исходного кода. Можно только пожалеть, что на глаза не попалось ничего более достойного, чем libmosquitto и Paho. Но это уже совсем другая история…
Заключение
==========
Вот, пожалуй, и все, что мы хотели рассказать о своем эксперименте по реализации распределенности для SObjectizer-приложений на базе MQTT и libmosquitto. Если какие-то интересующие вас моменты остались «за кадром», то задавайте вопросы — постараемся раскрыть интересующие вас моменты в комментариях.
В заключение, уже традиционно, предлагаем попробовать [SObjectizer](https://sourceforge.net/projects/sobjectizer/) ([github](https://github.com/eao197/so-5-5)) в деле и поделиться своими впечатлениями: практически все конструктивные отзывы используются нами для совершенствования SObjectizer-а.
Но сегодня хочется затронуть еще такой аспект. Наличие распределенности в ядре SObjectizer — местами хорошо, но местами сильно не очень (как показывает опыт SObjectizer-4). Отсутствие распределенности в ядре — опять местами хорошо, но местами не очень. Такое ощущение, что получается как в известной мудрости: чтобы ты не выбрал, все равно пожалеешь. Например, один из распространенных вопросов в адрес SObjectizer-5: «А что у вас с распределенностью?»
Уже начинает надоедать объяснять одно и тоже по сотому разу, посему закрадывается мысль: «А не проще ли сделать для SO-5 механизм для поддержки распределенности?» В связи с чем просим поделиться в комментариях своими соображениями на эту тему.
Нужна ли вам распределенность в SO-5? Если да, то для каких задач? Нужно ли вам передавать множество мелких сообщений? Или же вы передаете большие BLOB-ы? Нужна ли вам интероперабильность с другими языками? Или же вас устраивает протокол/формат, который поддерживается только одним фреймворком? Нужны ли вам подтверждения о доставке отдельных сообщений, автоматические перепосылки и т.д.? Какие-то средства интроспекции, мониторинга и сбора статистики по трафику?
В общем, чем больше хотелок будет озвучено, тем проще нам будет определиться с тем, делать ли поддержку прозрачной распределенности и, если делать, то в каком виде. А может быть и не проще. Но, в любом случае, будет какая-то информация для размышлений. | https://habr.com/ru/post/359212/ | null | ru | null |
# OpenGL ES 1.1 в Windows 8 и Windows Phone 8.1
[](http://habrastorage.org/files/a6a/c21/752/a6ac217526e34d3f8efbdad9f92a9039.png)В далеком 1998 году я пытался сделать свою игру с OpenGL. Разработка с трудом дошла до альфы и была заброшена, но что особо запомнилось, так это как удобно было делать под GL интерфейсы — ортогональная проекция, пара трансформаций, биндинг нескольких вершин с GL\_TRIANGLE\_STRIP и у нас уже есть кнопка. И вот, спустя шестнадцать лет и занимаясь мобильным игростроем я столкнулся с таким же подходом в OpenGL ES 1.\*, разве что 2D текстуры без вращений можно теперь рисовать через glDrawTexfOES.
Я поддерживал несколько проектов, сделанных по этому принципу и понемногу в голове выстроился коварный план: сделать кросс-платформенную 2D игру на мобильных с OpenGL ES и на C#, а на десктопах с обычным OpenGL. Цели я добился не с первого раза и было с этим много проблем, но в результате очередной проект у меня работает без изменений бизнес-логики на iOS, Android, BlackBerry, Windows XP/7, Mac OS X, Linux, ReactOS, Windows 8, Windows Phone 8.1. Материала набралось на много статей, но в этот раз я расскажу именно о поддержке Windows Runtime.
### OpenTK
Можно много спорить на счет удобства OpenGL именно для 2D, до хрипоты в горле убеждать себя, что для полноценной игры необходимы шейдеры и многопроходный рендеринг, а заодно и находить подтверждения, что устаревший OpenGL ES 1.1 часто реализован именно на уровне эмуляции через шейдеры. Это я оставлю для Дон Кихотов и теоретиков. Меня же волновало, что это самый простой способ написать единожды код 2D отрисовки и запускать его на разных платформах, причем не используя монструозные Unity, MonoGame и другие движки.
На iOS и Android под Xamarin все прошло гладко, работа с GL делается через библиотеку OpenTK с неймспейсом OpenGL.Graphics.GL11, константы и методы на обеих платформах одинаковы. На десктопах я решил использовать OpenTK.Graphics.OpenGL, т.е. обычный десктопный OpenGL с C# оберткой. Там в принципе нет glDrawTexfOES, но без проблем можно сделать замену для него и рисовать два треугольника через GL\_TRIANGLE\_STIP/GL\_TRIANGLES и glDrawElements — по сравнению с мобильными, производительности хватает с лихвой и VBO тут не нужны.
**Пример враппера с GL\_TRIANGLES**
```
private static readonly int[] s_textureCropOesTiv = new int[4];
private static readonly short[] s_indexValues = new short[] { 0, 1, 2, 1, 2, 3 };
private static readonly float[] s_vertexValues = new float[] { -0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f };
public void glDrawTexfOES(float x, float y, float z, float w, float h)
{
glPushMatrix();
glLoadIdentity();
glTranslatef(w / 2.0f + x, h / 2.0f + y, 0.0f);
glScalef(w, -h, 1.0f);
int[] tiv = s_textureCropOesTiv; // NOTE: clip rectangle, should be set before call
int[] texW = new int[1];
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, texW);
int[] texH = new int[1];
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, texH);
float[] texCoordValues = new float[8];
float left = 1.0f - (tiv[0] + tiv[2]) / (float)texW[0];
float bottom = 1.0f - tiv[1] / (float)texH[0];
float right = 1.0f - tiv[0] / (float)texW[0];
float top = 1.0f - (tiv[1] + tiv[3]) / (float)texH[0];
texCoordValues[0] = right;
texCoordValues[2] = left;
texCoordValues[4] = right;
texCoordValues[6] = left;
texCoordValues[1] = bottom;
texCoordValues[3] = bottom;
texCoordValues[5] = top;
texCoordValues[7] = top;
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, s_vertexValues);
glTexCoordPointer(2, GL_FLOAT, 0, texCoordValues);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, s_indexValues);
glPopMatrix();
}
```
Учтите, что копипастить себе этот код не стоит — он не будет работать там, где нет констант GL\_TEXTURE\_WIDTH/GL\_TEXTURE\_HEIGHT. Заодно переменная s\_textureCropOesTiv должна быть заполнена до вызова, а сам код не выполняет переворот вьюпорта по оси ординат.
### XAML
Некоторое количество магии понадобилось, чтобы проект запускался на актуальных версиях Mono, .Net 2.0-4.5, Wine, а заодно и под ReactOS, но в целом кроме зоопарка с текстурами особых проблем тут не было. А вот проблемы начались на Windows 8 и Windows Phone, где OpenGL отсутствует в принципе. С начала я пробовал решить это малой кровью, буквально дописав свою версию glDrawTexfOES, которая бы внутри вызывала что-то специфичное для этих систем. В ходе экспериментов я использовал XAML элемент Canvas, а в нем рисовал Rectangle, у которого в Brush использовалась нужная трансформация для отображения только части текстуры.
**Код трансформации в XAML**
```
TransformGroup group = new TransformGroup();
ScaleTransform scale = new ScaleTransform();
scale.ScaleX = (double)texture.PixelWidth / (double)clipRect.Width;
scale.ScaleY = (double)texture.PixelHeight / (double)clipRect.Height;
group.Children.Add(scale);
TranslateTransform translate = new TranslateTransform();
translate.X = -scale.ScaleX * (double)clipRect.X / (double)texture.PixelWidth;
translate.Y = -scale.ScaleY * (double)clipRect.Y / (double)texture.PixelHeight;
group.Children.Add(translate);
imageBrush.RelativeTransform = group;
```
clipRect — прямоугольник с параметрами обрезки, аналог s\_textureCropOesTiv из примера выше
texture — BitmapSource с самой текстурой
Этот метод кажется странным, но надо помнить, что XAML зачастую hardware accelerated и довольно быстр. Я портировал с таким подходом несколько мобильных OpenGL ES игр на Windows 8 и работают они приемлемо, только нет возможности изменять цвет текстур, как в GL через glColor. Т.е. в принципе в XAML разрешается менять прозрачность элемента, но никак нельзя менять его Color Tint. Например, если у вас используются белые шрифты и потом раскрашиваются в разные цвета, то с этим подоходом они так и останутся белыми.
В целом, вариант с XAML достаточно сомнителен и не совсем соответствовал изначальному плану, да и без цветовой ~~дифференциации штанов~~ модуляции, потому когда игра была на 80% готова и уже работала на мобильных и стационарном .Net/Mono, я начал искать более приемлемые варианты для Windows 8. Много было слухов и восторгов вокруг порта библиотеки [Angle](https://code.google.com/p/angleproject/), но на тот момент она была уж очень сырая и без поддержки C#. Напрямую из C# работать с DirectX оказалось тоже не возможно, а сама Microsoft предлагает разработчику несколько «простых» путей: переделать весь C# код на C++, использовать стороннюю библиотеку [SharpDX](http://sharpdx.org/) (C# биндинг над DirectX), либо перейти на MonoGame. Библиотека MonoGame это наследник XNA, использующий ту же SharpDX для вывода графики на Windows 8, она довольно неплоха, но довольно специфична и переходить на нее в моем проекте было поздновато. SharpDX выглядел не менее монструозным, ведь тянет за собой все существующие возможности DirectX, хотя и довольно близок к тому, что мне было надо. Я уже начал проводить с ним серьезные беседы с паяльником и мануалом, когда наткнулся на проект gl2dx.
### GL2DX
Библиотека эта была выложена юзером [average](https://www.codeplex.com/site/users/view/average) на [CodePlex](https://gl2dx.codeplex.com/) несколько лет назад и больше не обновлялась. Это С++ библиотека, которая объявляет такие же функции, как в OpenGL, а внутри транслирует их в вызовы D3D11. К библиотеке шел пример на C++/CX, который создавал XAML страницу с SwapChainBackgroundPanel и инициализировал ее через D3D11CreateDevice для работы с С++ частью. Проект был бы хорош, если бы хоть немного вышел из стадии прототипа. Технически, в нем работает всего несколько процентов OpenGL методов, а в остальных стоят ассерты. С другой стороны, она справляется с выводом 2D текстур, трансформацией и простейшей геометрией. На этом этапе я взялся за библиотеку и довел ее до состояния продукта, который подключается к C# проекту как Visual Studio Extension и позволяет писать подобный код:
**Код**
```
GL.Enable(All.ColorMaterial);
GL.Enable(All.Texture2D);
GL.Color4(1.0f, 1.0f, 1.0f, 1.0f);
GL.TexParameter(All.Texture2D, All.TextureCropRectOes, new int[] { 0, 0, 1024, 1024 });
GL.BindTexture(All.Texture2D, m_textureId1);
GL.DrawTex(0, - (m_width - m_height) / 2, 0, m_width, m_width);
for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
{
GL.BindTexture(All.Texture2D, m_textureId2);
GL.TexParameter(All.Texture2D, All.TextureCropRectOes, new int[] { 0, 0, 256, 256 });
}
else
{
GL.BindTexture(All.Texture2D, m_textureId2);
GL.TexParameter(All.Texture2D, All.TextureCropRectOes, new int[] { 256, 0, 256, 256 });
}
int aqPadding = 20;
int fishSize = 128;
int aqWidth = (int)m_width - aqPadding * 2 - fishSize;
float x = (Environment.TickCount / (i + 10)) % aqWidth;
float alpha = 1.0f;
if (x < fishSize)
alpha = x / fishSize;
else
if (x > aqWidth - fishSize)
alpha = (aqWidth - x - fishSize) / 128.0f;
GL.Color4(1.0f, 1.0f, 1.0f, alpha);
GL.DrawTex(x + aqPadding, m_height / 20 * (i + 5), 0, fishSize, fishSize);
}
```
P.S. Код в формате вызовов OpenTK, что немного сбивает с толку тех, что привык писать glColor4f вместо GL.Color4.
Сие поделие получило от меня гордое название MetroGL.
### MetroGL
Пример на C++/CX трансформировался в библиотеку на этом же ~~птичьем~~ современном языке, оброс большим количеством дополнительных функций, а C++ получила реализацию многих OpenGL методов, блендинги, оптимизацию внутренного VertexBuilder, загрузку произвольных изображений и DDS текстур, а главное — точную имитацию glDrawTexfOES, дающую 1в1 такую же картинку, как на OpenGL ES, а заодно соединяющую последовательные операции с одной текстурой в единый DrawCall. Кое-что пришлось доводить напильником, сам код местами грязноват (как до меня, так и после), а для создания VSIX расширения надо пересобирать проект вручную под каждую архитектуру (x86, x64, ARM) и лишь потом билдить VSIX проект. Главное, что если у вас есть OpenGL ES 1.\* код с 2D интерфейсом или не сложным 3D, то с этой библиотекой его можно использовать прямо из C#, не думая о внутренностях, С++ коде, D3D11 контекстах и других ~~гадостях~~радостях. Заодно сделан пример с рыбками справа и кодом из под ката. Конечно, если код у вас на OpenGL 2.0+ с шейдерами и экстеншенами, то ни о каком портировании речи и не будет.
Другой неприятный момент в том, что у меня нет настроения и желания доводить библиотеку до уровня 50-100% совместимости с OpenGL, а значит под ваши конкретные задачи ее придется затачивать своими силами. Благо, весь код выложен на [github](https://github.com/Nomad1/MetroGL) и я пока никуда не исчезаю и буду рад коммитам или вообще желающим взвалить на себя этот груз. Библиотека собирается под Windows 8.0 и Windows Phone 8.1, для VSIX может понадобиться не-Express версия Visual Studio.
### Эпилог
Ну и в конце-концов немного об играх. Проект свой я на 100% закончил и именно комбинация C# и OpenGL дала возможность сделать высокоуровневый код вообще не изменяемым — это библиотека без единого дефайна, не использующая каких-либо системных вызовов. Затем идет код среднего уровня: рисование через OpenGL в 2D, с вращением, трансформацией и цветовой модуляцией, тут немного код отличается на разных платформах — разные текстуры, по-разному хранятся данные. Низкоуровневая часть уже для каждой платформы разная, это создание окна, инициализация контекста, вывод звука. В любом случае, девять платформ, перечисленные в начале статьи, реально работают, и пусть C# в связке с OpenGL пока нельзя использовать в вебе или на Firefox OS, но все-равно разве это не отблеск кроссплатформенного будущего, господа?
 | https://habr.com/ru/post/246911/ | null | ru | null |
# Конфиденциальность пользователей Telegram снова нарушена. Представители мессенджера требуют не раскрывать подробностей
В конце февраля 2021 года выходит обновленный релиз клиента Telegram с заголовком: ‘*Автоудаление, виджеты и временные ссылки для приглашений’.*
На красивой, художественной [обложке](https://telegram.org/file/464001519/2/pw2YpXpzBFk.222382/9ec672b0125c50ad34) к пресс-релизу новой версии Tg-мессенджера пользователи видят корзину с таймером и уничтоженными данными, а также лицезреют главных героев из культового хакерского сериала [Мистер Робот](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D1%81%D1%82%D0%B5%D1%80_%D0%A0%D0%BE%D0%B1%D0%BE%D1%82#%D0%9D%D0%B0%D0%B3%D1%80%D0%B0%D0%B4%D1%8B_%D0%B8_%D0%BD%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D1%86%D0%B8%D0%B8). Но действительно ли все так круто с зачисткой следов как и в сериале?
Мистер Робот. Зачистка.Telegram подготовил для пользователей что-то из security-области, а эти дотошные исследователи тут же навострили ручки. Подробная вербализация одной ‘bug bounty’ описана по тексту ниже...
Цитата из [пресс-релиза:](https://telegram.org/blog/autodelete-inv2/ru#avtomaticheskoe-udalenie-soobschenii)
> Автоматическое удаление сообщений
>
> Уже несколько лет пользователи Telegram могут **бесследно** удалять сообщения для всех участников беседы. В секретных чатах с **2013** года также есть таймер самоуничтожения, который позволяет не удалять сообщения вручную.
>
> С сегодняшнего дня автоматическое удаление сообщений для всех участников доступно **в любом чате**. В этом режиме сообщения исчезают через 24 часа или 7 дней после отправки.
>
>
Так же информация о sec-функции упомянута тремя пунктами в официальном [changelog](https://desktop.telegram.org/changelog#v-2-6-23-02-21)-e Tg.
* Установите автоматическое удаление сообщений для всех через 24 часа или 7 дней после отправки.
* Управляйте настройками автоудаления в любом из ваших чатов, а также в группах и каналах, в которых вы являетесь администратором.
* Чтобы включить автоматическое удаление, щелкните правой кнопкой мыши чат в списке чатов> Очистить историю> Включить автоматическое удаление.
Я протестировал нововведение в Telegram на Android и ничего подозрительного не обнаружил. Всё security-заявленное со стороны Tg работало так, как с обложки. Спустя только несколько суток *(минимальный, честный срок автоудаления сообщений - 24ч.),* проявив усердие, я добился того что искал: сообщения которые должны автоудаляться у участников личного и приватного групповых чатов <удалялись> только визуально *(очистка окна сообщений)*, а в реальности сообщения-изображения оставались на устройствах в открытом кэше, который доступен любому пользователю по пути: `/Storage/Emulated/0/Telegram/Telegram Image`.
Сам тест на проверку очень прост: устанавливаем таймер автоудаления на 24ч. *(в личке или групповых чатах)*; обмениваемся картинками. Ждем сутки. Проверяем путь /Storage/Emulated/0/Telegram/Telegram Image, изображения автоудалились. Отменяем автоудаление и снова ставим таймер на 24ч и повторяем первоначальные действия. Обычно автоудаление не срабатывает на 2..4 раз. Как только картинки остались в кэше *(вышел баг с автоудалением сообщений),* можно таймер на чате оставить в покое, все последующие дни будет очищаться только окно сообщений в мессенджере, а картинки будут оставаться в кэше *(зачастую у получателя и отправителя, а не только у отправителя сообщений).*
Протестированный на разных гаджетах Android 7-10 *(Xiaomi; Samsung; Asus)*, найденный баг обесценивал функционал: автоудаление сообщений для пользователей, позволяя в будущем эксплуатировать уязвимость в своих личных и безобидных интересах.
Зная о негативном отношении компании Telegram к исследователям *(в т.ч. на своем предыдущем опыте)*, а также найдя интересную информацию в СМИ, что за **аналогичный баг** Telegram [выплатил](https://www.inputzero.io/2019/09/telegram-privacy-fails-again.html) исследователю 2,5к зеленых шуршунчиков, и в последствии: уязвимости был присвоен [CVE-2019-16248](https://nvd.nist.gov/vuln/detail/CVE-2019-16248) с высоким базовым рейтингом опасности 7.5 пунктов *(upd: после публикации этой статьи, уязвимость была пересмотрена до 5.5 пунктов)*:
> *The "delete for" feature in Telegram before 5.11 on Android does not delete shared media files from the Telegram Images directory. In other words, there is a potentially misleading UI indication that a sender can remove a recipient's copy of a previously sent image (analogous to supported functionality in which a sender can remove a recipient's copy of a previously sent message),*
>
>
я принял решение снова поработать с Telegram. Согласно [программе](https://hackerone.com/telegram?type=team) bug bounty на Hackerone
**5.03.21** я отправил отчет по уязвимости на [security@telegram.org](mailto:security@telegram.org). К моему удивлению
**7.03.21** я получил ответ *(далее по тексту пунктуация и орфография сообщений полностью сохранены)*:
> *Hello,*
>
> *Thank you for your email. We will send you an update soon.*
>
> *All the best, Telegram Support*
>
>
По истечению ~месяца тишины *(вышло очередное обновление мессенджера, в котором уязвимость “автоудаление сообщений” все еще не была исправлена), и* я снова напомнил Telegram о своем письме.
**3.04.21** получил следующий ответ:
> *Hello,*
>
> *Thank you for your email and sorry for the long wait. We will reply soon.*
>
> *All the best, Telegram Support*
>
>
Никакого в ближайшее время обновления я не получал *(увидел, что Tg мессенджер снова обновился и проблема всё еще сохраняется)* и спустя месяц снова напомнил Tg о своем релевантном отчете 2-х месячной давности.
**9.05.21** получил ответ, примерно-который я уже получал:
> *Hello,*
>
> *We are sorry for the long wait. We will send you an update soon.*
>
> *All the best, Telegram Support*
>
>
Подумав, что переписку ведет бот и до разработчиков мессенджера мне не удастся дописаться, отправил в ответном письме, что если они не против, то я выйду со статьей об уязвимости в СМИ. Такое письмо возымело эффект и через несколько часов
**14.05.21** получил ответ:
> *Hello,*
>
> *We don't have automatic responses here. Please wait, we will send you an update soon.*
>
> *All the best, Telegram Support*
>
>
Я согласился подождать, обычное дело. Через полтора месяца Tg снова обновился до новой версии и снова уязвимость не была исправлена. Я написал в Tg, что уязвимость в новой версии мессенджера все еще не исправлена и
**29.06.21** получил ответ:
> *Hello,*
>
> *I'm sorry for the delay. Thanks for the details.*
>
> *Re: logs.*
>
> *You can send the logs to Saved Messages, open the file and make sure that it does not contain any sensitive information.*
>
> *All the best, Alex Telegram Support*
>
>
**7.07.21** Я создаю приватный, групповой чат и приглашаю для тестирования бага и наглядности представителя Tg присоединиться к нему.
**8.07.21** получаю ответ:
> *Thanks for the details. There are two different files on your screenshots: they have different names and sizes, and they have been sent in two separate chats.*
>
> *All the best, Telegram Support*
>
>
В этот же день в чат заходит представитель Tg *(в будущем изменив свое имя с ‘support’ на ‘Николай’)* и предлагает в дальнейшем решать вопрос с багом на русском языке.
Тесты
-----
Тестируем мессенджер по моему плану, по его плану. Наглядно показываю, что проблема не выдуманная, когда сообщения-картинки не автоудаляются у 2/3 участников группового чата в рандомном порядке и не автоудаляются в личных чатах. Спустя ~месяц тестирования мессенджера на разных клиентах/версий Android-Telegram *(официальных и сторонних: Tg* [*FOSS*](https://f-droid.org/ru/packages/org.telegram.messenger/)*, Tg* [*GP*](https://play.google.com/store/apps/details?id=org.telegram.messenger&hl=ru&gl=US)*)* Николай признает существование проблемы, и казалось бы развязка уже близка и косвенно затронута тема награды.
Тестирование разных клиентов Tg под Android (FOSS; GP) в групповом чате и личке.Обещанную в течение недели beta-версию Tg с исправлением так и не прислали, но позже
**23.08.21** попросили еще немного подождать. Цитирую:
> *(Задерживаемся, но про вас помним.)*
>
>
К началу сентября мне предоставили ссылку на beta-версию Telegram. Поработав с ней я снова сообщил о том, что проблема автоудаления сообщений все еще сохраняется. Ко всему прочему в ней было сломано: “ручное удаление сообщений”, после такой иллюзорной зачистки данных в чате *(очистка окна сообщений клиента)* все файлы не удалялись с гаджета пользователя и были доступны в кэше там же: `/Storage/Emulated/0/Telegram/*`. Также наблюдалась проблема с отправкой аудио-сообщений в форматах .wma/.aac. Забраковал. Прогнав следующую build beta-версию Tg, я согласился, что проблема автоудаления сообщений картинок наконец-то исправлена.
Билды beta-версий Tg выходят каждый день.### «Упс! Что-то пошло не так»
Оставалось решить вопрос с наградой и поставить галочку в своем послужном списке.
**5.09.21** с [security@telegram.org](mailto:security@telegram.org) приходит письмо:
> *Hello,*
>
> *Thank you for vert long wait. We would like to award you with a bounty of EUR 1,000 for your findings. Could you share the following info for the agreement please?*
>
> *1. Your bank account details:*
>
> *\* your full name*
>
> *\* bank name*
>
> *\* account number or IBAN for payments in Euro*
>
> *\* SWIFT code*
>
> *2. Your full address including the postal code.*
>
> *3. Date of birth.*
>
> *Much appreciated!*
>
> *All the best,
> Alex
> Telegram Support*
>
>
В ответном письме уточняю: могу ли я получить оплату на PayPal например? Получил ответ, что нет, нужен банковский мой счет в евро и персональные данные.
В ответном письме предоставил Telegram свои персональные данные и свой банковский счет в евро для зачисления награждения в 1к евро.
**17.09.21** я получил письмо с [security@telegram.org](mailto:security@telegram.org) на русском языке:
> *Спасибо! Подпишите, пожалуйста, договор на двух последних страницах и пришлите, пожалуйста, весь документ как PDF. Можно использовать DocuSign, если неудобно печатать.
>
> С уважением,
> Alex*
>
>
Обычно при обнаружении уязвимостей исследователи и разработчики руководствуются в программах подобных bug bounty пунктом о разумных сроках по ответственному раскрытию информации, чтобы у разработчиков было время на исправление, а у исследователя его слава. Например, когда я репортил уязвимость в Яндекс, срок молчания составлял 90 дней. А после окончания срока я всё равно уточнял у Яндекса о том, могу ли я раскрыть тех.детали в СМИ? И тогда сотрудники транснациональной корпорации мягко свели мою просьбу на ‘нет’. И в СМИ *(тогда 2020 году)* я не опубликовался, сохранив общение с командой Яндекса на позитивной ноте. В течение следующего 2021 года зарепортил еще одну уязвимость по Яндексу и без проблем получил вознаграждение, а также оставил за собой моральное право на публикацию материалов согласно положению об охоте за ошибками.
Но вот иногда компании с хорошей репутацией пытаются вести [свои игры](https://habr.com/ru/news/t/452208/).
Изучив присланный на email договор представителем Telegram, обратил внимание на то, что Telegram требует не раскрывать никаких деталей сотрудничества/тех.подробностей по умолчанию без своего письменного одобрения, в т.ч. чеки, банковские выписки и публикации в СМИ с упоминанием имени компании и тд. Договор у Telegram *(в моем случае)* оказался расписан аж на 8 страницах *(приложен в конце статьи)*, а сама публичная [программа](https://hackerone.com/telegram?type=team) мягко говоря сокращена.
Описание всей программы bug bounty (правила, что можно, и как нужно...).В ответном письме я задал вопросы по договору (цитата):
> *Здравствуйте представители и разработчики Telegram!*
>
> *Некоторые вопросы по договору:*
>
> *в договоре п1.2. “Confidential Information” сообщается, что к конфиденциальной информации относятся (в том числе и):: техническая информация; и даже уровни сборов и комиссий. И согласно п9.1::. "Консультант не должен ни в течение срока действия настоящего Соглашения,* ***ни в любое другое время после его расторжения****:* ***9.1.1. разглашать или передавать любую Конфиденциальную информацию любому лицу****, компании, юридическому лицу или другой организации 9.3. Консультант не должен ссылаться на Компанию или любую Компанию Группы в каком-либо пресс-релизе, реклама или материалы без предварительного письменного согласия Компании."*
>
> *По умолчанию получается, что Telegram "против" практически любого раскрытия информации без специального письменного запроса. Кроме того при получении гонорара я обязан отчитаться в налоговый орган и предоставить чек, в котором будет отражено получении гонорара (и этот чек также попадает под конфиденциальные данные, что является странным). Можем ли мы в договоре изменить сроки в п9.1 на разумные сроки о неразглашении каких-либо деталей?*
>
> *Если все же об оказанных услугах/исследованиях не стоит нигде и никогда публично распространяться в СМИ и тд., (в любом случае) можете ли вы пересмотреть добросовестный, финансовый гонорар относительно* [*аналогичной уязвимости*](https://www.inputzero.io/2019/09/telegram-privacy-fails-again.html)*, за которую исследователь получил вознаграждение в разы выше, чем предлагается в мою пользу по договору и учитывая мои настойчивые старания по усилению конфиденциальности мессенджера?*
>
> *Спасибо вам! И на связи.*
>
>
Выше был последний ping с представителями компании Telegram, после которого те перестали выходить на связь, оборвав общение.
**27.09.21 и 28.09.21** Я написал на почту Telegram напоминание о письме без ответа и попросил в Tg Николая напомнить коллегам о переписке. Кроме того я добавил, что баги, которые я обнаружил в beta-версии Telegram *(в т.ч. сломанное ‘ручное удаление сообщений’, тот баг за который исследователь в прошлом получил 2,5к $)* перешли в официальный релиз *(при переходе с beta на версию FOSS и далее на версию Tg с оф.сайта). Он прочитал, но промолчал. И (пару недель молчания) я принял решение обнародовать имеющиеся материалы в СМИ.*
Выводы
------
Конфиденциальность пользователей Telegram снова осталась под угрозой. Пользователи надеются/надеялись на заявленный security-функционал: автоудаление сообщений *(картинок)*, который не работал, как задумано на Android устройствах до версии v8+ *(на других платформах баг не проверял) и который вводил их в заблуждение.*
Помог разработчикам устранить уязвимость с автоудалением сообщений в мессенджере в период полугода: с 5 марта по 5 сентября 2021 года.
В официальных пресс-релизах новых версий Telegram не упоминалось ни разу о существовании и решении проблемы с автоудалением сообщений. <https://desktop.telegram.org/changelog> <https://telegram.org/blog>
Так как все мои чаты настроены на автоудаление сообщений, иногда эксплуатировал баг, чтобы восстановить данные, которые пользователи считали уничтоженными имея веру в Telegram и даже не знали о проблемах, и в будущем не могли повлиять на их ликвидацию, например, с помощью ручной очистки чата.
Обещанную награду от Telegram ни в 1000 евро ни какую другую я не получил, а по классике
палец вверх.Неизвестно: сколько уязвимостей остается/останется замятых из-за ~~NDA-требований Telegram~~ "взяток за молчание", а не за вознаграждение за баги:: не распространяться и косвенно о проблемах мессенджера публично без письменного одобрения со стороны Telegram. Но при этом П. Дуров в СМИ призывает своих пользователей не верить на слово исследователям, а доверять только оф.информации компании, которая иногда чувствительная и скрывается/контролируется юридическими договорами заключенными с исследователями.
> *Мы рекомендуем пользователям не полагаться на СМИ и дожидаться официальных объявлений Telegram.
> >>>* [*П.Дуров*](https://t.me/durov_russia/11)
>
>
> *Мы не хотим платить журналистам и исследователям, чтобы они рассказывали о Telegram.
> >>>* [*П.Дуров*](https://telegra.ph/Pochemu-WhatsApp-nikogda-ne-budet-bezopasnym-05-16-7)
>
>
Прилагаю [договор](https://drive.google.com/file/d/13sEnr37gFw2ygsnDHLYbPloiAtvhR59X/view?usp=sharing), который мог бы быть заключен между мной и Telegram, но так и остался не акцептованным *(в нем изменены только мои персональные данные: ФИО и адрес).*
Прилагаю, самое первое *(от 5.03.21 года)* и последнее *(от 28.09.21 года)* видео с воспроизведением проблемы в Tg: автоудалением/ручной очисткой чатов.
**UPD**: спустя несколько дней после публикации статьи.
НКО MITRE, уязвимости присвоен [CVE-2021-41861](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41861).
Так как я работал с Tg по [саморекламе](https://hackerone.com/telegram?type=team), размещенной на HackerOne *(площадка является гарантом),* попросил последних по возможности провести расследование в отношении обфусцированной программы Tg для исследователей на HO. В ходе переписки представители HackerOne сообщили, что не могут помочь и привлечь Tg к ответственности, так как выложенная bug bounty программа на HO не связана с Telegram *(еще один трюк от компании, который необходимо учитывать багхантерам при разборе багов).*
Пример сравнения корректной и обфусцированной программ bug bounty на HackerOneСравнение программ bug bounty Veracrypt vs Tg.Ответ от HackerOneОтвет (конец переписки) по поводу Tg в списке bug bounty программ на HackerOne. | https://habr.com/ru/post/580582/ | null | ru | null |
# Прямой VPN-туннель между компьютерами через NAT'ы провайдеров (без VPS, с помощью STUN-сервера и Яндекс.диска)
Продолжение [статьи](https://habr.com/ru/post/478452/) о том, как мне удалось организовать прямой VPN-туннель между двумя компьютерами находящимися за NAT'ами провайдеров. В прошлой статье описывался процесс организации соединения с помощью третьей стороны — посредника (арендованный VPS выполняющий роль, что-то типа STUN-сервера и передатчика данных узлов для соединения). В этой статье я расскажу как обошелся без VPS, но посредники остались и ими были STUN-сервер и Яндекс.Диск…
### Введение
Прочитав комментарии прошлого поста я понял, что главным недостатком реализации было использование посредника — третьей стороны (VPS) которая указывала текущие параметры узла, куда и как подключаться. Учитывая рекомендации использовать настоящий STUN ([коих очень много](https://ru.wikipedia.org/wiki/STUN)) для определения текущих параметров подключения. Первым делом я решил посмотреть при помощи TCPDump содержимое пакетов при работе STUN-сервера с клиентами и получил совершенно нечитабельное содержимое. Погуглив протокол наткнулся на [статью с описанием протокола](https://tools.ietf.org/html/rfc3489#section-11.1). Я понял что самостоятельно реализовать запрос к STUN-серверу я не могу и убрал задумку в «далекий ящик».
### Теория
Недавно мне пришлось устанавливать STUN-сервер на Debian из пакета
```
# apt install stun-server
```
и в зависимостях я увидел пакет stun-client, но как-то не придал этому значения. Но позже я вспомнил про пакет stun-client и решил разобраться как он работает, погуглив и пояндексив я получил:
```
# apt install stun-client
# stun stun.ekiga.net -p 21234 -v
```
В ответ я получил:
> STUN client version 0.97
>
> Opened port 21234 with fd 3
>
> Opened port 21235 with fd 4
>
> Encoding stun message:
>
> Encoding ChangeRequest: 0
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Received stun message: 92 bytes
>
> MappedAddress = <Мой IP>:2885
>
> SourceAddress = 216.93.246.18:3478
>
> ChangedAddress = 216.93.246.17:3479
>
> Unknown attribute: 32800
>
> ServerName = Vovida.org 0.98-CPC
>
> Received message of type 257 id=1
>
> Encoding stun message:
>
> Encoding ChangeRequest: 0
>
>
>
> About to send msg of len 28 to 216.93.246.17:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 0
>
>
>
> About to send msg of len 28 to <Мой IP>:2885
>
> Received stun message: 28 bytes
>
> ChangeRequest = 0
>
> Received message of type 1 id=11
>
> Encoding stun message:
>
> Encoding ChangeRequest: 0
>
>
>
> About to send msg of len 28 to 216.93.246.17:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Received stun message: 92 bytes
>
> MappedAddress = <Мой IP>:2885
>
> SourceAddress = 216.93.246.17:3479
>
> ChangedAddress = 216.93.246.18:3478
>
> Unknown attribute: 32800
>
> ServerName = Vovida.org 0.98-CPC
>
> Received message of type 257 id=10
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 4
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> Encoding stun message:
>
> Encoding ChangeRequest: 2
>
>
>
> About to send msg of len 28 to 216.93.246.18:3478
>
> test I = 1
>
> test II = 0
>
> test III = 0
>
> test I(2) = 1
>
> is nat = 1
>
> mapped IP same = 1
>
> hairpin = 1
>
> preserver port = 0
>
> Primary: Independent Mapping, Port Dependent Filter, random port, will hairpin
>
> Return value is 0x000006
Строка со значением
> MappedAddress = <Мой IP>:2885
как раз то, что надо! Она отображала текущее состояние для соединения на локальном UDP порту 21234. Но это всего лишь пол дела, встал вопрос как передать эти данные удаленному узлу и организовать VPN-соединение. Использование почтового протокола, а может Telegram?! Вариантов много и решил использовать Яндекс.диск, так как попадалась мне [статья о работе Curl через WebDav с Яндекс.диском](https://fritool.ru/curl-for-webdav/). Подумав над реализацией я пришел к такой схеме:
1. Сигнализировать о готовности узлов к установке соединения наличием определенного файла с временной меткой на Яндекс.диске;
2. Если узлы готовы, то получать текущие параметры от STUN-сервера;
3. Выгружать текущие параметры на Яндекс.диск;
4. Проверять наличие и считывать параметры удаленного узла из файла на Яндекс.диске;
5. Установка соединения с удаленным узлом с помощью OpenVPN.
### Практика
Немного подумав, с учетом опыта прошлой статьи, написал скрипт на скорую руку. Нам понадобится:
```
# apt install openvpn stun-client curl
```
Собственно сам скрипт:
**Первоначальный вариант**
```
# cat vpn8.sh
```
```
#!/bin/bash
######################## Задаем цветной текст ###
WARN='\033[37;1;41m' #
END='\033[0m' #
RED='\033[0;31m' # ${RED} #
GREEN='\033[0;32m' # ${GREEN} #
#################################################
####################### Проверяем наличие необходымих приложений #########################################################
al="echo readlink dirname grep awk md5sum shuf nc curl sleep openvpn cat stun"
ch=0
for i in $al; do which $i > /dev/null || echo -e "${WARN}Для работы необходим $i ${END}"; which $i > /dev/null || ch=1; done
if (( $ch > 0 )); then echo -e "${WARN}Ой, отсутствуют необходимые для корректной работы приложения${END}"; exit; fi
#######################################################################################################################
if [[ $1 == '' ]]; then echo -e "${WARN}Введите идентификатор соединения (любое уникальное слово, должно быть одинаковое с двух сторон!) ${END} \t
${GREEN}Для запуска в автоматическом режиме при включении компьютера можно прописать в /etc/rc.local строку nohup /<путь к файлу>/vpn8.sh > /var/log/vpn8.log 2>/dev/hull & ${END}"; exit; fi
ABSOLUTE_FILENAME=`readlink -f "$0"` # полный путь до скрипта
DIR=`dirname "$ABSOLUTE_FILENAME"` # каталог в котором лежит скрипт
############################### Проверка наличия секретного ключа ##################################
key="$DIR/secret.key"
if [ ! -f "$key" ]; then
echo -e "${WARN}Секретный ключ VPN-соединения не найден, для генерации ключа выполните: \
openvpn --genkey --secret secret.key Внимание: ключ используется для авторизации и должен \
быть одинаковым с двух сторон!!!${END}
# ls -l secret.key
-rw------- 1 root root 637 ноя 27 11:12 secret.key
# chmod 600 secret.key";
exit;
fi
########################################################################################################################
ABSOLUTE_FILENAME=`readlink -f "$0"` # полный путь до скрипта
DIR=`dirname "$ABSOLUTE_FILENAME"` # каталог в котором лежит скрипт
name=$(uname -n | md5sum | awk '{print $1}')
vpn=$(echo $1 | md5sum | awk '{print $1}')
stun="stun.ekiga.net" # STUN сервер
username="Yandex" # Логин от Яндекс.диска
password="Password" # Пароль от Яндекс.диска
localport=`shuf -i 20000-65000 -n 1` # генерация локального порта
echo "$(date) Создаю папку на Яндекс.диске"
curl -X MKCOL --user "${username}:${password}" https://webdav.yandex.ru/vpn-$vpn
echo "$(date) Очищаю папку от всякого мусора"
for i in `curl --silent --user "$username:$password" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>//g' | sed 's/\n "/tmp/$date-$name-ready.txt"
curl -T "/tmp/$date-$name-ready.txt" --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/$date-$name-ready.txt
else
echo "$(date) Файл готовности уже существует - $date"
fi
remote=`curl --silent --user "${username}:${password}" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>\n&1 | grep MappedAddress | sort | uniq`
echo -e "$(date) ${GREEN}Мои данные соединения: $mydata${END}"
echo "$mydata" > "$DIR/mydata"
echo "$(date) Загрузка данных на Яндекс.диск"
curl -T "$DIR/mydata" --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/$name.txt
echo "$(date) Получение файла данных удаленного узла"
filename=$(curl --silent --user "${username}:${password}" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>" | grep "txt" | grep -v "$name" | grep -v "ready" | sed 's|.*d:displayname>||' | sed 's/
```
Для работы скрипта нужно:
1. Скопировать в буфер и вставить в редактор, например:
```
# nano vpn8.sh
```
2. указать логин и пароль от Яндекс.диска.
3. в поле "--ifconfig 10.45.54.(1 или 2) 255.255.255.252" указать внутренний IP-адрес интерфейса
4. cоздать **secret.key** командой:
```
# openvpn --genkey --secret secret.key
```
5. сделать скрипт исполняемым:
```
# chmod +x vpn8.sh
```
6. запустить скрипт:
```
# ./vpn8.sh nZbVGBuX5dtturD
```
где nZbVGBuX5dtturD — ID-соединения сгенерированный [тут](https://strongpasswordgenerator.com/)
На удаленном узле произвести всё тоже самое за исключением генерации secret.key и ID-соединения, они должны быть идентичными.
Обновленный вариант (для корректной работы время должно быть сихронизировано):
```
cat vpn10.sh
```
```
#!/bin/bash
stuns="stun.sipnet.ru stun.ekiga.net" # Список STUN серверов через пробел
username=" Login " # Логин от Яндекс.диска
password=" Password " # Пароль от Яндекс.диска
intip="10.23.22.1" # IP-адрес внутреннего интерфейса
WARN='\033[37;1;41m'
END='\033[0m'
RED='\033[0;31m'
GREEN='\033[0;32m'
al="ip echo readlink dirname grep awk md5sum openssl sha256sum shuf curl sleep openvpn cat stun"
ch=0
for i in $al; do which $i > /dev/null || echo -e "${WARN}Для работы необходим $i ${END}"; which $i > /dev/null || ch=1; done
if (( $ch > 0 )); then echo -e "${WARN}Ой, отсутствуют необходимые для корректной работы приложения${END}"; exit; fi
if [[ $1 == '' ]];
then
echo -e "${WARN}Введите идентификатор соединения (любое уникальное слово, должно быть одинаковое с двух сторон!) ${END} \t
${GREEN}Для запуска в автоматическом режиме при включении компьютера можно прописать в /etc/rc.local строку nohup /<путь к файлу>/vpn10.sh > /var/log/vpn10.log 2>/dev/hull & ${END}"
exit
fi
ABSOLUTE_FILENAME=`readlink -f "$0"` # полный путь до скрипта
DIR=`dirname "$ABSOLUTE_FILENAME"` # каталог в котором лежит скрипт
key="$DIR/secret.key"
until [[ -n "$iftosrv" ]]
do
echo "$(date) Определяю сетевой интерфейс"; iftosrv=`ip route get 8.8.8.8 | head -n 1 | sed 's|.*dev ||' | awk '{print $1}'`
sleep 5
done
timedatectl
name=$(uname -n | md5sum | awk '{print $1}')
vpn=$(echo $1 | md5sum | awk '{print $1}')
echo "$(date) Создаю папку на Яндекс.диске"
curl -X MKCOL --user "${username}:${password}" https://webdav.yandex.ru/vpn-$vpn
echo "$(date) ID на диске: $vpn"
until [ $c ];do
echo "$(date) Очищаю папку от всякого мусора"
for i in `curl --silent --user "$username:$password" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>//g' | sed 's/ "/tmp/ready-$date-$name.txt"
curl -T "/tmp/ready-$date-$name.txt" --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/ready-$name.txt
readyfile=`curl --silent --user "${username}:${password}" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>\n//g' | sed 's/<\/d:displayname>//g'`
if [[ -z $readyfile ]]
then
echo -e "$(date) ${RED} Удаленный узел не готов ${END}"
echo "$(date) Жду 60 секунд"
sleep $timeout1
else
remote=$(curl --silent --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/$readyfile)
echo -e "$(date) ${GREEN} Удаленный узел готов ${END}"
start=`curl --silent --user "${username}:${password}" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>\n "/tmp/start-$date-$name.txt"
curl -T "/tmp/start-$date-$name.txt" --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/start-$date-$name.txt
else
echo "$(date) жду $go секунд"
sleep $go
b=1
a=''
fi
fi
done
echo -e "$(date) ${GREEN}Фаза 2 - Обмен данными и установка соединения${END}"
mydata=''
filename=''
address=''
myip=''
ip=''
port=''
ex=0
until [ $a ]; do
until [[ -n "$mydata" ]]; do
k=`echo "$stuns" | wc -w`
x=1
z=`shuf -i 1-$k -n 1`
for st in $stuns; do
if [[ $x == $z ]]; then
stun=$st;
fi;
(( x++ ));
done
echo "$(date) Подключение и получение данных от STUN сервера: $stun"
sleep 5 && for pid in $(ps xa | grep "stun "$stun" 1 -p "$localport" -v" | grep -v grep | awk '{print $1}'); do kill $pid; done &
mydata=`stun "$stun" 1 -p "$localport" -v 2>&1 | grep "MappedAddress" | sort | uniq`
done
echo -e "$(date) ${GREEN}Мои данные соединения: $mydata${END}"
echo "$(date) Загрузка данных на Яндекс.диск"
echo "$mydata" > "$DIR/mydata"
echo "IntIP $intip" >> "$DIR/mydata"
curl -T "$DIR/mydata" --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/$name-ipport.txt
rm "$DIR/mydata"
sleep 5
echo "$(date) Получение файла данных удаленного узла"
filename=$(curl --silent --user "${username}:${password}" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/vpn-$vpn/ | sed 's/>" | grep "ipport" | grep -v "$name" | sed 's|.*d:displayname>||' | sed 's/ $ip:$port ${END}"
curl --silent --user "$username:$password" https://webdav.yandex.ru/vpn-$vpn/key.enc > "$DIR/secret.enc"
openssl AES-256-CBC -d -in "$DIR/secret.enc" -out "$key" -k "$passwd" -base64
chmod 600 "$key"
rm "$DIR/secret.enc"
openvpn --remote $ip --rport $port --lport $localport \
--proto udp --dev tun --float --auth-nocache --verb 3 --mute 20 \
--ifconfig "$intip" "$intip2" \
--secret "$key" \
--auth SHA256 --cipher AES-256-CBC \
--ncp-disable --ping 10 --ping-exit 20 \
--comp-lzo yes
a=1
b=''
fi
else
if (( $ex >= 5 ))
then
echo "$(date) Сброс"
a=1
b=''
fi
(( ex++ ))
sleep 5
fi
done
done
```
Для работы скрипта нужно:
1. Скопировать в буфер и вставить в редактор, например:
```
# nano vpn10.sh
```
2. указать логин (2я строка) и пароль от Яндекс.диска (3я строка).
3. указать внутренний IP-адрес туннеля (4я строка).
4. сделать скрипт исполняемым:
```
# chmod +x vpn10.sh
```
5. запустить скрипт:
```
# ./vpn10.sh nZbVGBuX5dtturD
```
где nZbVGBuX5dtturD — ID-соединения сгенерированный [тут](https://strongpasswordgenerator.com/)
На удаленном узле произвести всё тоже самое, указать соответствующий внутренний IP-адрес туннеля и ID-соединения.
Для автозапуска скрипта при включении я использую команду «nohup /<путь до скрипта>/vpn10.sh nZbVGBuX5dtturD > /var/log/vpn10.log 2>/dev/null &» содержащиюся в файле /etc/rc.local
### Заключение
Скрипт работает, проверен на Ubuntu (18.04, 19.10, 20.04) и Debian 9. В качестве передатчика можно использовать любой другой сервис, но для опыта я использовал Яндекс.диск.
В процессе экспериментов было обнаружено, что некоторые типы NAT провайдеров не позволяют организовать соединение. В основном у сотовых операторов, где заблокированы торренты.
Планирую доработать в плане:
* Автоматической генерации secret.key каждый раз при старте, шифровании и копирования на Яндекс.диск для передачи на удаленный узел (Учтено в обновленном варианте)
* Автоматического назначения IP-адресов интерфейсов
* Шифрования данных перед выгрузкой на Яндекс.диск
* Оптимизация кода
Да будет IPv6 в каждом доме!
Обновлено! **Последние файлы и DEB-пакет тут** — [yandex.disk](https://yadi.sk/d/A8966EnXxzZtCw) | https://habr.com/ru/post/481034/ | null | ru | null |
# Gobetween Exec discovery+ Elasticsearch. L4 балансировка с Data Node Discovery
Зачем все это нужно
-------------------
Все кто использовал Elasticsearch каластер для своих нужд (особенно для логирования и как основную базу данных) на больших нагрузках сталкивался с проблемами консистентности и масштабируемости. Когда требуется распараллелить нагрузку на Elasticsearch обычно применялись статические решения то типу [NGINX+Elasticsearch](https://www.nginx.com/blog/nginx-elasticsearch-better-together/). Это позволяет распараллелить нагрузку, но выглядит не слишком гибко. Особенно если учесть что ноды могут сами выпадать из кластера и простой хелсчек покажет что все отлично, а на самом деле нода перегружена, исключена из кластера. В любом случае хотелось бы иметь данные о состоянии кластера из первых рук, а не довольствоваться простыми проверками.
Итак, приступим к построению балансировки .
Как мы будем это делать
-----------------------
В данном случае мы будем использовать [CAT node API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cat-nodes.html), которое является частъю мощнейшего [CAT API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cat.html), который является инструментом поиска заголовков по Elasticsearch клстреру.
Мы будем использовать только [Gobetween](https://gobetween.io) и встроенные механизмы Elasticsearch для балансировки записи /чтения [СRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) (DATA) нод при произвольном количестве/статусе нод в кластере.
Предварительные настройки
-------------------------
Нам потребуются:
#### Elasticsearch client node :
Нужна специально для gobetween т.к. при мультимастер конфигурации она сама будет перенаправлять запрос на правильную мастер ноду(активный мастер), и таким образом будет нашим роутером внутри кластера для корректной работы нашего Data Node discovery.
В elasticsearch.conf на client ноде прописываем:
```
node.master: false
node.data: false
```
и остальные настройки идентичные настройкам нод в вашем кластере.
#### Скрипт для дискавери:
Теперь создадим скрипт который будет запрашивать API и возвращать нам список нод.
назовем его discovery\_elasticsearch.sh :
```
#!/bin/bash
curl -sS -XGET 'http://PI_OF_YOUR_CLIENT_NODE:9200/_cat/nodes?v&h=ip,r=d' |sed '1d'|tr -d ' '|sed 's/$/:9200/'
```
вывод скрипта будет примерно таким :
```
10.0.0.51:9200
10.0.0.55:9200
10.0.0.53:9200
10.0.0.52:9200
10.0.0.54:9200
итд...
```
В данном случае скрипт на возвращает вес каждой ноды, тогда вес проставляется балансировщиком автоматически одинаковый — "1".
Теперь все готово, и можно начинать настраивать непосредственно сам балансер.
Настройка балансировщика
------------------------
После [установки](https://github.com/yyyar/gobetween/wiki/Installation) настало время настроить балансировку используя [EXEC discovery](https://github.com/yyyar/gobetween/wiki/Discovery#exec) и round robin алгоритм балансировки.
Данный пример довольно простой и служит для описания возможностей данного типа балансировки. Можно расширить скрипт для динамической генерации весов для каждой ноды по их загрузке (cpu,io и т.д.).
конфиг нашего балансера будет выглядеть :
```
[logging]
level = "warn" # "debug" | "info" | "warn" | "error"
output = "stdout" # "stdout" | "stderr" | "/path/to/gobetween.log"
[defaults]
max_connections = 0
client_idle_timeout = "0"
backend_idle_timeout = "0"
backend_connection_timeout = "0"
[servers.sample3]
bind = "100.100.1.5:9200"
protocol = "tcp"
balance = "weight"
[servers.sample3.discovery]
kind = "exec"
exec_command = ["/etc/gobetween/discovery_elasticsearch.sh"]
interval="1m"
timeout = "10s"
[servers.sample3.healthcheck]
kind = "ping"
interval = "20s"
timeout = "2s"
fails = 3
passes = 3
```
Итак, мы имеем "рыбу" решения для построения гибкой балансировки в elasticsearch кластере.
В "боевых" условиях у нас работет более сложная конфигурация с динамическим определением весов.
Так же в нашем продакшне мы используем сложный скрипт хелсчека тоже завязанного на API мониторинга и самого Elasticsearch.
* [первая обзорная статъя](https://habrahabr.ru/post/303428/)
* [DRAFT Rest API](https://github.com/yyyar/gobetween/wiki/REST-API)
* [Проект на Github](https://github.com/yyyar/gobetween)
* [Вики на Github](https://github.com/yyyar/gobetween/wiki)
* [тесты производительности](https://github.com/yyyar/gobetween/wiki/Performance-tests-results)
* [Установка под Windows](https://github.com/yyyar/gobetween/wiki/3.3-Windows-specific-notes)
В Следующих статьях — json discovery, windocker service discovery и балансировка, Windows swarm service discovery и балансировка, Балансировка (Windows+linux) Doсker окружений. | https://habr.com/ru/post/304096/ | null | ru | null |
# Как написать комментарий к задаче?
В этой статье предлагается общий шаблон грамотного написания комментария к проверенным задачам, фичам, багам. Данный формат комментария будет также отлично подходить для отчетов о тестировании. Но для начала, давайте рассмотрим, кому статья будет полезна.
Для кого эта статья?
--------------------
Если коротко, то форматы комментариев - это уже процессы *Quality Assurance*, поэтому статья будет полезна для всех, кто хочет улучшать качество на своем проекте, и для тех, кому есть, что улучшать. Это важно! Есть проекты, где уже все процессы настроены и ваши нововведения никому не нужны.
Тестирование, как инженерное искусство
--------------------------------------
Многие работают в своих компаниях в должностях: Инженер по тестированию, Инженер по качеству, QA Engineer и т.п. Но по факту, это просто тестировщики, которые к слову "инженер" не имеют никакого отношения. Я предлагаю поменять мышление по отношению к этой работе.
Что такое "инженерное" мышление? Это мышление с четкой структурой, аналитикой, логикой и полнотой. То есть комментарий "все проверено, все ок" - это совсем далеко от этого.
Про эту философию у меня есть прям очень много мыслей, может напишу как-то статью отдельно про это, но сегодня эту тему затрону в разрезе комментариев.
Начало
------
Я работал в многих компаниях, и видел много разных вариантов. Есть компании, в которых тестировщики под задачей пишут "ок/готово/done" и переводят в статус Завершен.
Поэтому как бы это банально не звучало, но грамотный комментарий должен начинаться со статуса тестирования:
**Протестировано/Не протестировано** - тут могут быть и другие варианты, например, деплой прошел, фича отключена и т.п.
Следующий момент, это указание стенда, на котором было проведено действие:
**на Тестовом окружении/на Динамическом окружении** и т.д. Да, это важно. Даже если у Вас на доске, есть максимально подробные колонки, которые указывают на стенд, то это все равно важно указывать. Мы пишем отчеты для того, чтобы со временем, если находится какой-то баг, можно было по таким комментариям понять, когда эта ошибка была упущена, кем была упущена и т.п.
Тело
----
**Чек-лист** - это следующий этап нашего комментария. Да, его стоит прикреплять. Это можно делать по-разному: можно написать проверки в самом комментарии (не обязательно идеально подробный, но хотя бы с логическими делениями), но обязательно со статусами проверок; можно прикреплять excel-файл с чек-листами; можно прикреплять ссылку на тест-ран запущенный на специальной платформе (какое-то время я крепил pdf-файл выгруженный из qase после прохождения тест-рана - он был достаточно информативный и читабельный) - подойдут разные варианты, но важно, чтобы любой разработчик или менеджер мог всегда просмотреть проверки, которые были проведены, даже через несколько лет после вашего ухода из компании.
**Обнаруженные дефекты (список багов в формате что? где? когда?)**. Если во время тестирования были обнаружены дефекты, то они обязательно должны быть отображены в комментариях. Недостаточно просто написать, что они есть. Нужно хотя бы тезисно их перечислить. Идеальный формат, по моему мнению, что тезисы должны отвечать на вопросы "что? где? когда?". Например, Не работает кнопка Отправить(что происходит?) в модальном окне Новое сообщение (где?) при нажатии (когда?). Такие баги будут понятные даже без шагов воспроизведения, ожидаемых результатов и прочего. Если по багу заведен баг-репорт, в таком случае, можно указать ссылку на тикет с дефектом.
**Вопросы**. Это могут быть вопросы по документации, по реализации - вообще по всему. Особенно этот пункт важен на этапе анализа задачи перед тем, как ее начнут разрабатывать. Это должен быть четкий список (не обязательно развернутой формы). Вы можете все моменты обсуждать в переписках, но само озвучивание вопросов в задаче обязательно.
После того, как мы получаем ответы. Если они обсуждались где-то в другом месте, а не в самой задаче, то их нужно вынести в отдельный раздел **Ответы**. Можно это сделать отдельным комментарием, можно отредактировать ранее написанный комментарий. Желательно также отмечать тех, кто эти ответы давал, чтобы можно было к ним обратиться за уточнением.
**Артефакты**. Не обязательный, но все же важный пункт в нашем комментарии. Это могут быть скрины, скринкасты, логи. Все, что подтверждает, что задача работает/не работает. Также это могут быть файлы, которые мы используем для тестирования (например, когда мы тестируем загрузку документов).
Результат
---------
В зависимости от действий задачи, стоит озаглавить результат соответственно:
**Результат тестирования/Результат анализа/Результат изучения/Результат обсуждения**
Результат должен быть коротким, но полным и четким. Результат должен соответствовать дальнейшим действиям с задачей. Плохой пример:
> **Результат тестирования:**
> При тестировании были выявлены баги. Одобрено к релизу на **Прод**-окружение.
>
>
Нет логики в таком описании результата. Хороший пример:
> **Результат тестирования:**
> При тестировании были выявлены баги, минорного значения, которые не блокируют дальнейший релиз. Сами дефекты были вынесены на доработку в отдельные задачи. Одобрено к релизу на **Прод**-окружение.
>
>
Дополнительные советы:
----------------------
Тут еще пару советов о том, как сделать свои комментарии более читабельными и понятными для других:
* **Используйте форматирование**. Минимальное выделение жирным шрифтом ключевых слов помогает лучшему восприятию комментария.
* **Используйте отступы**. Разделяйте комментарий на логичные части, чтобы читающий видел не один сплошной текст, а структурный отчет, в котором можно сразу обратиться к нужной части.
* **Избегайте личностных местоимений**. "Я протестировал" или "Протестировано" - это большая разница в восприятии компетентности документа. Не забывайте, что ваш комментарий - это один из видов технической документации, а не ваше личное сообщение.
* **Используйте технический язык**. Помню, как в одном чате со специалистами, один тестировщик прислал пример баг-репорта с его проекта. Там было написано *"на маленьких экранах скукоживается текст"* - это до сих пор у нас локальный мем. Не должно быть такого в технической документации!
* **Будьте рациональными**. Если задача, изменение кнопки в одном месте с "Отмена" на "Отменить" и ее проверять 1 минуту, то не стоит тратить 20 минут, чтобы написать супер красивый комментарий. Но тем не менее используйте хотя бы техническое начало и результат.
* **Всегда работайте над тем, чтобы что-то улучшать**. Комментарий такого вида - это не предел совершенства. Всегда есть, что добавить и что улучшить.
Вместо вывода - пример:
-----------------------
**Задача "Добавление поля с вводом 1 или 0"**
> Протестировано на **Тестовом** окружении.
>
> **Чек-лист:**
> -Проверка с вводом 1 - `passed`
> - Проверка с вводом 0 - `passed`
> - Проверка с вводом нескольких 1/0 - `passed`- Проверка с вводом букв - `passed`- Проверка с вводом других цифр - `passed`- Проверка с вводом спец.символов - `failed (вынесено в Дефект 1.)`
> - Сверка поля с макетом - `skipped (вынесено в Вопрос 1.)`
>
> **Обнаруженные дефекты:**
> 1. Не работает валидация на спец.символы в поле "Введите 0 или 1"
>
> **Вопросы:**
> 1. Отсутствует макет для мобильной версии приложения. По реализации сейчас поле отличается от десктопной версии. С чем сравнивать?
>
> **Результат тестирования:**
> - При тестировании были выявлены дефекты.
> - Ожидается ответ на вопрос от <лида>.
> - Задача отправлена на доработку.
>
> | https://habr.com/ru/post/712700/ | null | ru | null |
# Boids — простой алгоритм перемещения групп юнитов
Во время разработки клона одной игрушки мне понадобилось перемещать группы юнитов от одной планеты к другой. Первое что пришло в голову — заспавнить юниты один за другим и двигать их по прямой. Но это выглядело не очень весело, кроме того — нужно было как-то обходить планеты. После беглого ознакомления с алгоритмами группового перемещения я решил попробовать Boids. В итоге получилось такое:
Под катом описание алгоритма с примерами кода.
##### Описание
Алгоритм Boids был создан Крейгом Райнольдсом (Craig Reynolds) в 1986-м году как модель перемещения стаи птиц. В его основе лежат три следующих правила:
* **Сплоченность** — юниты стараются держаться как можно ближе друг к другу
* **Разделение** — юниты стремятся разойтись с целью держаться друг от друга на некотором расстоянии
* **Выравнивание скоростей** — юниты из одной группы стремятся двигаться с одинаковой скоростью
В качестве дополнения к ним я воспользовался ещё двумя:
* **Движение к цели** — юниты стараются двигаться к заданной цели
* **Избегание препятствий** — юниты стремятся в противоположную сторону от препятствий
##### Об имплементации
Для каждого юнита необходимо хранить хранить координаты и скорость. Так же нужно знать координаты цели и препятствий. Во время пересчёта игрового мира (пересчёт можно делать, к примеру, 20 раз в секунду) нужно определить новую координату и скорость для всех юнитов. Для этого необходимо определить новую скорость юнита и передвинуть его.
Каждое из правил, перечисленных выше, позволяют получить часть скорости. Общая скорость юнита — сумма скоростей, полученных после применения правил и предыдущей скорости самого юнита.
```
v1 = Rule1();
v2 = Rule2();
v3 = Rule3();
unit.v = v1 + v2 + v3 + unit.v;
unit.pos = unit.pos + unit.v;
```
Чтобы юнит сильно не разгонялся — скорость рекомендуется ограничивать. Спавнить юниты, вылетающие из одной точки лучше всего по очереди, через короткие промежутки времени.
Правила реализуются так:
1. Сплоченность — необходимо найти центр масс (среднее арифметическое координат всех юнитов) и определить вектор, направленный от текущего юнита в центра масс.
2. Разделение — нужно определить среднее направление от всех ближайших юнитов.
3. Выравнивание скоростей — необходимо найти среднюю скорость всех юнитов.
4. Движение к цели — вектор, направленный от юнита в сторону цели.
5. Избегание препятствий — совпадает со вторым, за исключением того что направление нужно искать в сторону от ближайших препятствий.
На практике скорости, выданные каждым из правил необходимо уменьшать (путём деления на какой-то коэффициент) или ограничивать. Ограничения и коэффициенты подбираются экспериментальным путём для достижения наилучшего результата.
##### Код
А теперь немного кода. Основной код, занимающийся перемещением всех юнитов (Ships — речь идёт о космических кораблях): [pastebin.com/jeHCWr8u](http://pastebin.com/jeHCWr8u) Кроме вышеописанного тут ещё проверяется столкновение юнитов с планетами и вылет за пределы мира. Ограничение скорости — нормированный вектор (представляющий собой направление), умноженный на ограничивающий коэффициент: [pastebin.com/a57hh76V](http://pastebin.com/a57hh76V)
Реализация правил: [pastebin.com/YDSTDh3t](http://pastebin.com/YDSTDh3t) Особенности реализации — часть правил применяются только к юнитам из текущей группы (принадлежащих одному игроку и имеющими одну и ту-же цель). Distance — расстояние в геометрическом смысле.
Спавнинг кораблей реализован следующим образом. У каждой планеты имеется очередь кораблей, ожидающих спавнинга. Когда игрок отдаёт команду — создаётся несколько кораблей (от 1-го до ~20, в зависимости от количества энергии) и заносятся в очередь планеты: [pastebin.com/FprtwTy4](http://pastebin.com/FprtwTy4) А затем, каждые 50 миллисекунд спавнится по одному кораблю: [pastebin.com/Tq4cvNbB](http://pastebin.com/Tq4cvNbB)
##### Плюсы и минусы
Алгоритм больше подходит для симуляции «живых» юнитов. Его хорошо применять в тех случаях, когда допустимо «роевое» поведение группы. В случае, если необходимо организовать более строгое движение юнитов, скорее всего придётся воспользоваться другим алгоритмом (или какой-то из модификаций). Так же мне не удалось организовать проход одной группы юнитов через другую при их перпендикулярном движении — либо одна группа начинала сталкивать другую с траектории (и в итоге обходила её сбоку) — либо юниты одной группы начинали проходить сквозь юнитов из второй (почти не огибая их). На встречных курсах ситуация лучше — иногда одна группа разделяла вторую на две и проходила по центру, а иногда проходила рядом с ней. В целом, путём многократного экспериментирования с параметрами, Boids позволят добиться хорошо выглядящих результатов, подходящих для разных ситуаций.
##### Ссылки
[en.wikipedia.org/wiki/Boids](http://en.wikipedia.org/wiki/Boids) — описание алгоритма в википедии
[www.kfish.org/boids/pseudocode.html](http://www.kfish.org/boids/pseudocode.html) — псевдокод boids — с описанием некоторых эвристик
[habrahabr.ru/post/105639](http://habrahabr.ru/post/105639/) — описание boids и его различных вариаций (более теоретическое)
[github.com/bakwc/ozifi/tree/master/projects/space\_capture](https://github.com/bakwc/ozifi/tree/master/projects/space_capture) — исходники (реализация boids в server/world.cpp) | https://habr.com/ru/post/212721/ | null | ru | null |
# Unity UI Toolkit: MVVM ннада?
Изображёные приложения вы можете найти на GitHub проекта в папке примеровНи для кого не секрет, что Unity сейчас активно работают над новой системой создания пользовательского интерфейса [UI Toolkit](https://unity.com/features/ui-toolkit). Это инструмент разработки интерфейсов вдохновлённый стандартными подходами веб-разработки.
Пользовательский интерфейс состоит из двух основных частей:
* UXML документ – язык разметки, основанный на HTML и XML, определяет структуру пользовательского интерфейса.
* Unity Style Sheets (USS) – таблицы стилей, похожи на каскадные таблицы стилей CSS, применяют визуальные стили и поведение к пользовательскому интерфейсу.
И всё бы хорошо, но каково было моё удивление, что, проделав такую работу, они не предоставили механизма связывания данных, работающего в runtime. Формально, механизм связывания есть, но он работает только при создании интерфейсов для редактора.
А мне так хотелось вновь прикоснуться к WPF и MVVM, но в контексте Unity, что было решено разработать собственный механизм data-binding'а. Вдохновлялся я [.NET Community Toolkit](https://github.com/CommunityToolkit/dotnet), так что если вы уже работали с этим набором инструментов, для вас всё будет максимально знакомо.
В результате получилась библиотека которая позволяет реализовать:
* Связывание данных работающее в runtime.
* Привязку нескольких свойств у одного UI элемента.
* Поддержку кастомных UI элементов.
* Совместима с [UniTask](https://github.com/Cysharp/UniTask) для реализации асинхронных команд.
Библиотека содержит набор стандартных классов, которые облегчают создание приложений с использованием шаблона MVVM.
В этот набор входят:
* [ViewModel](https://github.com/ChebanovDD/UnityMvvmToolkit#viewmodel)
* [CanvasView](https://github.com/ChebanovDD/UnityMvvmToolkit#canvasviewtbindingcontext)
* [DocumentView](https://github.com/ChebanovDD/UnityMvvmToolkit#documentviewtbindingcontext)
* [Command & Command](https://github.com/ChebanovDD/UnityMvvmToolkit#command--commandt)
* [AsyncCommand & AsyncCommand](https://github.com/ChebanovDD/UnityMvvmToolkit#asynccommand--asynccommandt)
* [AsyncLazyCommand & AsyncLazyCommand](https://github.com/ChebanovDD/UnityMvvmToolkit#asynclazycommand--asynclazycommandt)
* [PropertyValueConverter](https://github.com/ChebanovDD/UnityMvvmToolkit#propertyvalueconvertertsourcetype-ttargettype)
* [ParameterValueConverter](https://github.com/ChebanovDD/UnityMvvmToolkit#parametervalueconverterttargettype)
* [ICommand & ICommand](https://github.com/ChebanovDD/UnityMvvmToolkit#command--commandt)
* [IAsyncCommand & IAsyncCommand](https://github.com/ChebanovDD/UnityMvvmToolkit#asynccommand--asynccommandt)
* [IPropertyValueConverter](https://github.com/ChebanovDD/UnityMvvmToolkit#propertyvalueconvertertsourcetype-ttargettype)
* [IParameterValueConverter](https://github.com/ChebanovDD/UnityMvvmToolkit#parametervalueconverterttargettype)
Также реализован базовый набор UI элементов:
* [BindableLabel](https://github.com/ChebanovDD/UnityMvvmToolkit#bindablelabel)
* [BindableTextField](https://github.com/ChebanovDD/UnityMvvmToolkit#bindabletextfield)
* [BindableButton](https://github.com/ChebanovDD/UnityMvvmToolkit#bindablebutton)
* [BindableListView](https://github.com/ChebanovDD/UnityMvvmToolkit#bindablelistview)
* [BindableScrollView](https://github.com/ChebanovDD/UnityMvvmToolkit#bindablescrollview)
Давайте рассмотрим работу библиотеки на примере простого `HelloWorld`'а.
Для этого добавим `UnityMvvmToolkit` в проект:
1. Откройте `Edit/Project Settings/Package Manager`
2. Добавьте новый `Scoped Registry`
```
Name package.openupm.com
URL https://package.openupm.com
Scope(s) com.chebanovdd.unitymvvmtoolkit
```
3. Откройте `Window/Package Manager`
4. Выберите `My Registries`
5. Установите пакет `UnityMvvmToolkit`
Первым делом создадим нашу ViewModel:
```
using UnityMvvmToolkit.Core;
public class MyFirstViewModel : ViewModel
{
public string Text { get; } = "Hello World";
}
```
Далее добавим на сцену `UI Document` выбрав `GameObject/UI Toolkit/UI Document`.
Добавление UI документа на сценуЗатем создадим файл `MyFirstView.uxml`. Это будет наша View.
Создание UXML файлаПосле того как файл `MyFirstView.uxml` будет создан. Откройте его в `UI Builder` и добавьте UI элемент `BindableLabel`, установив в поле `Binding Text Path` значение `Text` (название нашего свойства из ViewModel).
UI BuilderВсё, наша View готова. Если открыть её в редакторе кода, то там будет примерно такое содержание:
```
```
Заключительным шагом будет создание класса `MyFirstDocumentView`, который установит нашу ViewModel в качестве `BindingContext`'а для созданной View.
```
using UnityMvvmToolkit.UITK;
public class MyFirstDocumentView : DocumentView
{
}
```
Этот класс необходимо будет довавить к UI Document'у на сцене и задать нашу View там же.
Конфигурирование UI документа на сценеЗапустив проект, мы увидим наш `Hello World`.
Получившийся результатБиблиотека получилась довольно гибкой и расширяемой. В чём можно убедиться, изучив приложение `Counter` из папки [примеров](https://github.com/ChebanovDD/UnityMvvmToolkit/tree/main/samples), где в UI используются только кастомные элементы пользовательского интерфейса.
Вот так выглядит CounterView:
```
```
А так CounterViewModel:
```
public class CounterViewModel : ViewModel
{
private int _count;
private ThemeMode _themeMode;
public CounterViewModel()
{
IncrementCommand = new Command(IncrementCount);
DecrementCommand = new Command(DecrementCount);
}
public int Count
{
get => _count;
set => Set(ref _count, value);
}
public ThemeMode ThemeMode
{
get => _themeMode;
set => Set(ref _themeMode, value);
}
public ICommand IncrementCommand { get; }
public ICommand DecrementCommand { get; }
private void IncrementCount() => Count++;
private void DecrementCount() => Count--;
}
```
В заключение немного технической информации. Под капотом `UnityMvvmToolkit` использует reflection, но получение и установка значений свойств реализована через делегаты.
```
public static class PropertyInfoExtensions
{
public static Func CreateGetValueDelegate(
this PropertyInfo propertyInfo)
{
return (Func) Delegate.CreateDelegate(typeof(Func),
propertyInfo.GetMethod);
}
public static Action CreateSetValueDelegate(
this PropertyInfo propertyInfo)
{
return (Action) Delegate.CreateDelegate(typeof(Action),
propertyInfo.SetMethod);
}
}
```
Этот подход позволяет избежать упаковки (boxing) и распаковки (unboxing) для типов значений, что значительно улучшает производительность. В частности, он примерно в 65 раз быстрее, чем тот, который использует стандартные методы `GetValue` и `SetValue`, и вообще не приводит к выделению памяти.
Все исходники, примеры и документацию можно найти на [GitHub](https://github.com/ChebanovDD/UnityMvvmToolkit), также пакет опубликован на площадке [OpenUPM](https://openupm.com/packages/com.chebanovdd.unitymvvmtoolkit/). Если у вас есть идеи, предложения или желание поучавствовать в разработке, добро пожаловать в [дискуссии](https://github.com/ChebanovDD/UnityMvvmToolkit/discussions).
А что вы думаете о таком подходе создания пользовательских интерфейсов в Unity? | https://habr.com/ru/post/689134/ | null | ru | null |
# Вышел OpenSSH 9.0
Вышел релиз OpenSSH 9.0. Он [ориентирован](https://www.openssh.com/releasenotes.html#9.0) на исправление ошибок, а также включает постквантовую криптографию по умолчанию.
В этом выпуске scp(1) перестает использовать устаревший протокол scp/rcp и применяет SFTP по умолчанию. Устаревший scp/rcp отвечал за расширение имен удаленных файлов с помощью подстановочных знаков (например,"scp host:\*") через удаленную оболочку. Таким образом, без двойных кавычек метасимволов оболочки в именах файлов в командной строке scp(1) могли быть интерпретированы как команды оболочки на удаленной стороне. Разработчики не намерены вводить совместимость для устаревшего scp/rcp в scp(1) при использовании протокола SFTP.
Другая область потенциальной несовместимости была связана с использованием удаленных путей относительно домашних каталогов других пользователей, например,
```
"scp host:~user/file /tmp"
```
У протокола SFTP нет способа развернуть путь пользователя. Однако sftp-server(8) в OpenSSH 8.7 и более поздних версиях поддерживают расширение протокола "[expand-path@openssh.com](mailto:expand-path@openssh.com)". В случае несовместимости клиенту scp(1) может быть предложено использовать устаревший scp/rcp с флагом -O.
С выпуском новой версии OpenSSH 9 и принятием гибридного метода обмена ключами Streamlined NTRU Prime + x25519 появилась постквантовая криптография по умолчанию.
«Алгоритм NTRU противостоит атакам будущих квантовых компьютеров и сочетается с обменом ключами X25519 ECDH (предыдущее значение по умолчанию) в качестве защиты от любых слабых мест в NTRU Prime, которые могут быть обнаружены в будущем», — говорится в примечаниях к выпуску. | https://habr.com/ru/post/660403/ | null | ru | null |
# Сотрудник Google выложил 0day-эксплойт для маршрутизаторов TP-Link SR20
*Домашний маршрутизатор TP-Link SR20 появился на рынке в 2016 году*
Маршрутизаторы TP-Link известны многочисленными уязвимостями. Но обычно производитель старается вовремя опубликовать патчи и новые версии прошивки после того, как получает информацию о баге. Но сейчас компания не успела уложиться в 90 дней, положенные по негласным правилам — и поплатилась за это. Инженер Google Мэтью Гарретт опубликовал в открытом доступе [эксплойт](https://pastebin.com/GAzccR95), допускающий возможность удалённого исполнения кода с получением рутового доступа.
> It's been over 90 days since I reported it and [@TPLINK](https://twitter.com/TPLINK?ref_src=twsrc%5Etfw) never responded, so: arbitrary command execution on the TP-Link SR20 smart hub and router (and possibly other TP-Link device)
>
> — Matthew Garrett (@mjg59) [March 28, 2019](https://twitter.com/mjg59/status/1111106885736787975?ref_src=twsrc%5Etfw)
Мэтью Гарретт допускает, что эксплойт сработает и на других устройствах TP-Link, а не только на домашнем маршрутизаторе SR20.
38-строчный скрипт показывает, что можно выполнить любую команду с рутовыми правами root, без аутентификации.
В твиттере Гарретт объяснил, что устройства TP-Link часто поддерживают протокол отладки TDDP (TP-Link Device Debug Protocol), в котором раньше было найдено несколько уязвимостей. Например, первая версия протокола не требует пароля для обмена пакетами по TDDP.
«В SR20 по-прежнему остались некоторые команды из первой версии, одна из которых (команда 0x1f, запрос 0x01), похоже, предназначена для какой-то проверки конфигурации, — написал Гарретт. — Вы посылаете имя файла, точку с запятой, а затем аргумент».
Маршрутизатор отвечает на запрос по TFTP, запрашивает имя файла, импортирует его в интерпретатор Lua, работающий с рутовыми правами, и передаёт аргумент функции config\_test() в импортированном файле.
> The os.execute() method allows you to execute whatever you want, and you're running as root, so victory. tddp is listening on all interfaces but the default firewall rules block WAN access, so this is local network only.
>
> — Matthew Garrett (@mjg59) [March 28, 2019](https://twitter.com/mjg59/status/1111106888945401858?ref_src=twsrc%5Etfw)
В такой системе метод `os.execute()` позволяет выполнить любую команду с рутовыми правами.
Правда, масштаб бедствия не слишком большой, потому что конфигурация файрвола по умолчанию блокирует сетевой доступ по TDDP. То есть злоумышленник не может взломать произвольный маршрутизатор SR20, который обнаружит в интернете путём сканирования через Shodan. Нужно сначала установить трояна на компьютер, который подключен к маршрутизатору, и уже с него работать с маршрутизатором.
Гарретт решил опубликовать информацию для всех, чтобы компания внедрила рабочий какой-нибудь канал для сообщения об уязвимостях и больше не оставляла демоны отладки в производственной прошивке. | https://habr.com/ru/post/446160/ | null | ru | null |
# Интерфейсы командной строки Java: picocli
Всем привет!
Очередной старт группы [«Разработчик Java»](https://otus.pw/88tV/), на котором мы всё продолжаем наш эксперимент того, что процесс обучения не обязан быть непрерывным («Контрамоция должна быть непрерывной?» ). То есть мы чуть переработали и перетасовали программу, и разбили её на три ступени, которые можно спокойно проходить с перерывом между ними. В общем интересно и для студентов, и для нас, лишь бы никто не расхолаживался, а то программа стала даже вроде чуть сложнее, хотя и была непростой до этого. Ну и традиционно интересная статья связанная с нашим курсом.
Поехали!
На [официальном сайте](http://picocli.info/) picocli описывается как «мощный маленький интерфейс командной строки», который «является однофайловым Java-фреймворком для разбора аргументов командной строки и создания безупречных, легко настраиваемых вспомогательных сообщений. С цветами». В этом посте представлен [краткий обзор Picocli 0.9.7](https://github.com/remkop/picocli/releases/tag/v0.9.7) и его применения для разбора аргументов командной строки в Java-коде.
Как и другие библиотеки обработки командной строки, написанные на Java, которые описаны в этой серии, [picocli имеет открытый исходный код](https://github.com/remkop/picocli/releases). Поскольку вся picocli реализована в одном [Java-файле](http://picocli.info/#_download), при желании можно легко использовать исходный код напрямую. Сайт picocli подчеркивает, что «отличительной особенностью picocli является то, что он позволяет пользователям запускать приложения, использующие picocli, не требуя самого picocli в качестве внешней зависимости: весь исходный код располагается в одном файле, чтобы побудить авторов приложений включить его в программный исходный код". Если вам больше нравится использовать picocli в качестве библиотеки, в Maven Repository есть [JAR-файл](https://mvnrepository.com/artifact/info.picocli/picocli/0.9.7) с множеством скомпилированных .class файлов (Picocli представляет собой один Java-файл, но содержит многочисленные вложенные классы и аннотации).
Самый простой способ получить представление об однофайловой природе Picocli — это взять и посмотреть на сам файл. Исходный код для CommandLine.java доступен на странице загрузки [Picocli](http://picocli.info/#_download). Следующие два скриншота показывают вывод из [javap](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javap.html) при выполнении класса CommandLine и при выполнении одной из его внутренних аннотаций и одного из его внутренних классов.
Независимо от того, компилируем ли мы CommandLine.java в свой собственный класс/JAR-файл или используем уже собранный JAR из Maven, исходный код приложения, использующего Picocli, очевидно, будет один и тот же. Этап «определения» в разборе аргументов с помощью Picocli выполняется путем аннотирования полей экземпляра, который будет хранить значения, связанные с параметрами командной строки. Это показано в фрагменте кода ниже.
**Этап “определения” в Picocli**
```
/*
Демонстрирует обработку командной строки Java с помощью picocli.
*/
@Command(
name="Main",
description="Demonstrating picocli",
headerHeading="Demonstration Usage:%n%n")
public class Main
{
@Option(names={"-v", "--verbose"}, description="Verbose output?")
private boolean verbose;
@Option(names={"-f", "--file"}, description="Path and name of file", required=true)
private String fileName;
@Option(names={"-h", "--help"}, description="Display help/usage.", help=true)
boolean help;
```
Приведенный выше пример кода демонстрирует, что Picocli позволяет указывать несколько имен флагов (в моем примере указаны односимвольные имена с одним дефисом и многосимвольные имена с двумя дефисами). В этом примере также показывается, что для обязательных параметров может быть задано required=true, а для [вспомогательных опций](http://picocli.info/#_help_options), таких как печать деталей использования и исключение ошибок, связанных с отсутствием требуемых параметров, может быть указано help=true. Обратите внимание, что в Picocli 0.9.8 добавлена дополнительная поддержка более специфичных типов вспомогательных сообщений [versionHelp](http://picocli.info/#_help_options) и [usageHelp](http://picocli.info/#_usage_help).
Этап «разбора» в Picocli выполняется в [CommandLine.populateCommand (T, String ...)](http://picocli.info/apidocs/picocli/CommandLine.html#populateCommand-T-java.lang.String...-), где T — экземпляр класса с Picocli-аннотированными полями, а оставшиеся строки — аргументы, которые нужно проанализировать. Это показано в следующем фрагменте кода.
**Этап «разбора» в Picocli**
```
final Main main = CommandLine.populateCommand(new Main(), arguments);
```
Этап «опроса» в Picocli заключается в простом обращении к Picocli-аннотированным полям экземпляра, который передали в метод CommandLine.populateCommand (T, String ...) на этапе «разбора». Простой пример такого «опроса» показан в следующем листинге.
**Этап «опроса» в Picocli**
```
out.println(
"The provided file path and name is " + main.fileName
+ " and verbosity is set to " + main.verbose);
```
Отображать пользователю вспомогательные сообщения или информацию об использовании, когда в командной строке указано -h или --help, так же просто, как «опросить» Picocli-аннотированное поле, для которого было указано help=true, чтобы определить, установлено ли это логическое значение или нет и, если оно установлено, вызывать один из перегруженных методов CommandLine.usage. Мне пришлось использовать одну из статических версий этого метода, как показано в следующем листинге.
**Вспомогательные сообщения / информация об использовании в Picocli**
```
if (main.help)
{
CommandLine.usage(main, out, CommandLine.Help.Ansi.AUTO);
}
```
Следующие несколько скриншотов демонстрируют простое приложение, написанное с использованием picocli. На первом скриншоте отображается тип сообщения об ошибке и трассировка стека, если требуемый флаг отсутствует. Второй скриншот показывает, как используются длинные и короткие имена, указанные в аннотациях. На третьем изображении показана функция отображения вспомогательных сообщений в действии.
Одна из дополнительных возможностей Picocli, которая отсутствует во многих других библиотеках разбора аргументов командной строки, написанных на Java, — это поддержка [цветного синтаксис](http://picocli.info/#_ansi_colors_and_styles)а. В первом листинге этого поста были строки, определенные в аннотациях с @ | | @ синтаксисом. На скриншоте выше, который демонстрирует использование вспомогательных сообщений, эти символы были переданы как есть, без специальной обработки. Однако, если я запущу этот пример кода в Cygwin, я увижу, что делают эти знаки.
На приведенном выше скриншоте мы видим, что Picocli автоматически применил цветной синтаксис (желтый и белый) к опциям вспомогательных сообщений а также применил жирный и подчеркнутый жирный синтаксис к областям с описанием вспомогательных сообщений, где применен синтаксис @ | | @.
Ниже приведены дополнительные характеристики Picocli, которые следует учитывать при выборе фреймворка или библиотеки, помогающих с разбором аргументов командной строки в Java.
* Picocli является проектом с открытым исходным кодом с [лицензией Apache 2.0.](http://picocli.info/#_license)
* Picocli не требует загрузки сторонних библиотек или фреймворков.
* Весь исходный код Picocli содержится в одном .java файле, и этот код может быть скопирован и вставлен в собственную систему управления конфигурацией и собран с остальной частью кода приложения, это означает, что даже JAR-файл Picocli не является необходимым.
* Файл исходного кода CommandLine.java (Picocli 0.9.7) составляет чуть более 3700 строк (включая пробелы и комментарии) и весит почти 200 КБ. Файл picocli-0.9.7.jar весит около 83 КБ.
* Picocli своевременно и часто обновляется. Версия 0.9.8 была выпущена вчера (после того, как я написал большую часть этого поста).
* Picocli имеет [очень подробную документацию](http://picocli.info/#_introduction) и она во многом более современна, чем документация для некоторых других библиотек обработки командной строки, написанных на Java.
* Поддержка цветного синтаксиса в Picocli проста в использовании, а справка об использовании цветного синтаксиса на разных платформах задокументирована в разделе «[Поддерживаемые платформы](http://picocli.info/#_supported_platforms)».
* Использование аннотаций Picocli для полей на уровне экземпляра похоже на использование аннотаций в некоторых других библиотек обработки командной строки и имеет те же преимущества.
* Основные возможности Picocli очень удобны и легко осваиваются, но Picocli также поддерживает возможность настройки нескольких аспектов обработки командной строки с помощью Picocli.
Листинги, приведенные в этом посте, полностью доступны на [GitHub](https://github.com/dustinmarx/java-cli-demos/blob/master/src/dustin/examples/commandline/picocli/Main.java).
Picocli — это поддерживаемая и обновляемая библиотека для разбора аргументов командной строки Java. Она содержит несколько новых фич и подходов из некоторых других доступных библиотек обработки командной строки, написанных на Java, но в нее добавлены пара отличающихся фич (таких как цветной синтаксис и целая библиотека, инкапсулированная в один исходный Java-файл). Picocli достаточно проста в использовании и привлекательна сама по себе, но, скорее всего, она будет выделяться среди других библиотек для отдельного разработчика, если этот разработчик хочет поддержки цветного синтаксиса или возможности добавить файл исходного кода в проект разработчика без дополнительных JAR-файлов или скомпилированных .class-файлов.
THE END
Как всегда ждём ваши вопросы и комментарии. | https://habr.com/ru/post/419401/ | null | ru | null |
# Новое в браузерах: Firefox 66 по умолчанию блокирует видео и звук, Chromium ограничивает бюджет страниц
В ближайших версиях Firefox и Chromium могут произойти важные изменения.
Во-первых, в Firefox 66 для десктопов по умолчанию заблокируется автоматическое воспроизведение видео и звука на всех страницах. Блог Mozilla Hacks [заранее предупреждает](https://hacks.mozilla.org/2019/02/firefox-66-to-block-automatically-playing-audible-video-and-audio/) об этом разработчиков. Воспроизведение видео и звука разрешается только через `HTMLMediaElement` API и только после **взаимодействия пользователя со страницей** (щелчок мыши, нажатие кнопки или прикосновение к тачскрину).
В Chromium могут произойти ещё более интересные изменения.
При этом разрешено автоматическое воспроизведение видео с заглушённым звуком. Для такого контента нужно для `HTMLMediaElement` установить атрибут “muted” в значение true. На скриншоте показано, что пользователи могут вручную отключить блокировку звука для отдельных сайтов.
В Firefox для Android новая реализация заменит существующий механизм блокировки автоматического воспроизведения.
Технически Firefox блокирует вызов `play()` от `HTMLMediaElement.play()`, возвращая ошибку `NotAllowedError`. Так же поступают все браузеры с аналогичной функциональностью. Соответственно, веб-разработчикам не следует предполагать, что вызов `play()` всегда будет успешен. Чтобы избежать блокировки, рекомендуется два варианта. Первый: запускать воспроизведение контента в связке с обработчиком событий, например, [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent) на десктопе или [touchend](https://developer.mozilla.org/en-US/docs/Web/Events/touchend) под Android. Второй: запустить автовоспроизведение без звука (оно разрешено по умолчанию) и показать пользователю кнопку для включения звука.
Финальная версия Firefox 66 запланирована к выходу на [19 марта 2019 года](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox#Firefox_channels), так что у разработчиков есть время на подготовку.
Mozilla сейчас работает над автоматической блокировкой контента [Web Audio](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API): её обещают до конца 2019 года.
Бюджет для веб-страниц
======================
Изменения в Chromium пока на стадии обсуждения. Не факт, что соответствующий коммит включат в основную ветку. Но идея очень интересная.
4 февраля 2019 года один из разработчиков Алекс Расселл представил [коммит 1265506 («Never-Slow Mode»)](https://chromium-review.googlesource.com/c/chromium/src/+/1265506). Он предлагает внедрить в браузер дополнительный режим `--enable-features=NeverSlowMode`, который будет **ограничивать бюджет каждой веб-страницы**, тем самым гарантируя быструю загрузку.
Алекс Расселл — один из ведущих разработчиком Chrome, Blink и веб-платформы в Google, автор статьи «Вы можете себе это позволить? Бюджет веб-производительности в реальном мире», [перевод](https://habr.com/ru/post/345212/) которой публиковался на Хабре.
*Иллюстрация из [статьи](https://habr.com/ru/post/345212/) Алекса Расселла*
**Предлагаемый бюджет:**
* Объём одной картинки: 1 МБ
* Объём всех картинок: 2 МБ
* Одна таблица стилей CSS: 100 КБ
* Все таблицы стилей CSS: 200 КБ
* Максимальный размер скрипта: 50 КБ
Естественно, эту функцию пользователь будет включать по желанию. Например, если работает через медленное интернет-подключение, на слабом устройстве (устаревшем компьютере) и т. д. Ограничение бюджета гарантирует быструю загрузку и отсутствие тормозов, но при этом повышает вероятность, что страница не загрузится до конца.
Очевидно, что бюджет следует периодически пересматривать, ориентируясь на время загрузки страницы.
Ожирение сайтов
===============
Бюджетирование страниц — здравая идея. Многие пользователи и специалисты обращают внимание, что с годами программы и веб-приложения вовсе не становятся быстрее, несмотря на серьёзное повышение производительности компьютеров.
По какой-то причине запросы приложений растут быстрее, чем производительность железа. В результате с каждым годом [софт становится медленнее](https://habr.com/ru/post/423889/), а [веб-сайты жиреют](https://habr.com/ru/post/278655/).
> Тенденция такова, что софт вовсе не становится быстрее и функциональнее. Мы получаем более быстрое оборудование, на котором софт с теми же функциями ворочается медленнее, чем раньше. Всё работает намного медленнее максимальной скорости. Никогда не задумывались, почему ваш телефон загружается от 30 до 60 секунд? Почему он не может загрузиться, скажем, за одну секунду? Здесь нет никаких физических ограничений. Лично мне бы такое понравилось. Хочется, чтобы разработчики достигли предела, используя каждый бит для производительности. — Из статьи [«Моё разочарование в софте»](https://habr.com/ru/post/423889/)
Возможно, бюджет веб-страниц поможет решить проблему, если другие разработчики Chromium согласятся на коммит Расселла.
---
[](https://clck.ru/EhoeK) | https://habr.com/ru/post/439118/ | null | ru | null |
# PHP-Дайджест № 88 – интересные новости, материалы и инструменты (13 июня – 17 июля 2016)
После небольшого перерыва PHP-Дайджест снова в деле! Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [Zend Framework 3](https://framework.zend.com/blog/2016-06-28-zend-framework-3.html) — Долгожданный мажорный релиз популярного фреймворка. С момента выпуска предыдущей версии прошло [почти 4 года](https://framework.zend.com/blog/zend-framework-2-0-0-stable-released.html). Под капотом пользователей ждет поддержка PHP 7, обновленные компоненты, более чем в 4 раза улучшенная производительность, микрофреймворк из коробки, поддержка middleware и многое другое.
* [Конец поддержки Zend Framework 1](https://framework.zend.com/blog/2016-06-28-zf1-eol.html) — Вместе с анонсом ZF3 Zend объявили о прекращении поддержки ZF1. Исправления безопасности будут выпускаться только до 28 сентября этого года.
* [PyroCMS v3](https://www.pyrocms.com/posts/2016/06/14/pyrocms-3-major-release) — Релиз популярной некогда CMS. Проект переписан фактически с нуля на Laravel.
* [PHP 7.0.8](http://www.php.net/ChangeLog-7.php#7.0.8), [5.6.23](http://www.php.net/ChangeLog-5.php#5.6.23), [5.5.37](http://www.php.net/ChangeLog-5.php#5.5.37) — Обновления актуальных веток интерпретатора.
* [Завершен срок поддержки PHP 5.5](http://php.net/supported-versions.php) — 21 июля ожидается выпуск PHP 5.5.38, который станет последним в ветке 5.5.
*  [Выпущен PhpStorm 2016.2](https://habrahabr.ru/company/JetBrains/blog/305688/)
* [PHP 7.1.0 Alpha 3](http://php.net/index.php#id2016-07-07-1) — В третью альфу вошли недавно принятые предложения: [тип Iterable](https://wiki.php.net/rfc/iterable), [короткий синтаксис для оператора list](https://wiki.php.net/rfc/short_list_syntax), [создание замыкания из callable](https://wiki.php.net/rfc/closurefromcallable) и другие.
### PHP
* [RFC: Iterable](https://wiki.php.net/rfc/iterable) — Принято предложение добавить псевдотип `Iterable`, который объединил как обычные массивы, так и объекты, реализующие `Traversable`.
* [RFC: Throw Error in Extensions](https://wiki.php.net/rfc/throw_error_in_extensions) — Во многих расширениях вместо ошибок класса E\_ERROR или E\_RECOVERABLE\_ERROR будут бросать исключения типа Error. Предложение принято.
* [RFC: New operator for context-dependent escaping](https://wiki.php.net/rfc/escaping_operator) — Подробнее в хабрапосте автора предложения: [Опрос. Новый тег для HTML-экранирования данных в PHP](https://habrahabr.ru/post/304162/) .
### Инструменты
* [GitaminHQ/Gitamin](https://github.com/gitaminhq/gitamin) — Клон GitHub реализованный на Laravel.
* [Opulence](https://www.opulencephp.com/) — Новый PHP7 фреймворк. Прислал [tkf](https://habrahabr.ru/users/tkf/).
* [franzose/kontrolio](https://github.com/franzose/kontrolio) — Простая библиотека валидации данных без дополнительных зависимостей, вдохновленная Laravel и Symfony. Прислал [franzose](https://habrahabr.ru/users/franzose/).
* [layershifter/tld-extract](https://github.com/layershifter/TLDExtract) — Пакет для корректного парсинга доменных имен с использованием Public Suffix List.
* [rinvex/repository](https://github.com/rinvex/repository/) — Независимая реализация паттерна Репозиторий. Прислал [tkf](https://habrahabr.ru/users/tkf/).
* [paragonie/halite](https://github.com/paragonie/halite) — Криптографическая библиотека для PHP. [Пример использования Halite](https://www.sitepoint.com/using-halite-for-privacy-and-two-way-encryption-of-emails/) для двустороннего шифрования email-сообщений.
* [dunglas/doctrine-json-odm](https://github.com/dunglas/doctrine-json-odm) — ODM для Doctrine с поддержкой JSON-типов, добавленных в PostrgeSQL и MySQL.
* [JakubOnderka/PHP-Parallel-Lint](https://github.com/JakubOnderka/PHP-Parallel-Lint) — Инструмент проверки синтаксиса, анализирующий файлы параллельно.
* [Codeception/AspectMock 2.0](https://github.com/Codeception/AspectMock) — Библиотека для создания тестовых двойников, позволяющая делать моки буквально для всего.
* [Bacon/BaconQrCode](https://github.com/Bacon/BaconQrCode) — Генератор QR-кодов.
* [paragonie/multi\_factor](https://github.com/paragonie/multi_factor) — Цель библиотеки реализовать единый интерфейс для работы с различными провайдерами двухфакторной аутентификации. Из коробки поддерживается GoogleAuth.
* [simplesamlphp/simplesamlphp](https://github.com/simplesamlphp/simplesamlphp) — Реализация стандарта SAML, в свою очередь, используемого для реализации технология единого входа (SSO).
* [heiglandreas/JUnitDiff](https://github.com/heiglandreas/JUnitDiff) — Библиотека позволяет показывать, что изменилось между двумя запусками тестов PHPUnit.
* [bitExpert/disco](https://github.com/bitExpert/disco) — DI контейнер совместимый со стандартом [container-Interop](https://github.com/container-interop/container-interop). Подробный [туториал](https://www.sitepoint.com/disco-with-frameworks-and-design-patterns-a-fresh-look-at-dependency-injection/) по использованию.
* [gabrielbull/omnimail](https://github.com/gabrielbull/omnimail) — Библиотека для отправки писем с помощью популярных сервисов рассылки: AmazonSES, Mailgun, Mandrill и другие.
* [PiPHP/GPIO](https://github.com/PiPHP/GPIO) — Библиотека для доступа к Raspberry Pi из PHP. [Туториал](https://www.sitepoint.com/powering-raspberry-pi-projects-with-php/) в поддержку.
* [hoaproject/Websocket](https://github.com/hoaproject/websocket) — Годная реализация вебсокет клиента и сервера.
* [pavelfluffy/connector](https://github.com/pavelfluffy/connector) — [Сигналы и слоты в PHP. Такие же как в Qt. Ну почти.](https://habrahabr.ru/post/304988/)
* [larabros/elogram](https://github.com/larabros/elogram) — Библиотека для доступа к Instagram API в стиле Eloquent.
* [klermonte/zerg](https://github.com/klermonte/zerg) — Библиотека для удобного парсинга структурированных бинарных данных.
* [php-ai/php-ml](https://github.com/php-ai/php-ml) — Библиотека с реализацией алгоритмов машинного обучения на PHP.
### Материалы для обучения
* ##### Symfony
+ [grena/gruik](https://github.com/grena/gruik) — Сервис markdown заметок, реализован на Symfony.
+ [veloxy/purl](https://github.com/veloxy/purl) — Сокращалка ссылок, реализованная на Symfony. Прислал [tkf](https://habrahabr.ru/users/tkf/).
+  [Создание блога на Symfony 2.8 lts [Часть 6]](https://habrahabr.ru/post/303578/)
+  [REST API на Symfony, FOSRestBundle + GlavwebDatagridBundle](https://habrahabr.ru/post/303366/)
+  [Отчёт с Symfony Moscow Meetup 2 июня](https://habrahabr.ru/company/mailru/blog/303868/)
* ##### Yii
+ [yii2-migration-generator](https://packagist.org/packages/skobka/yii2-migration-generator) — Генератор файлов миграций для yii2 на основе аннотаций.
+ [Туториал по обработке загрузки файлов на Yii2](http://code.tutsplus.com/tutorials/how-to-program-with-yii2-uploading-files--cms-23511)
+  [Вышел официальный HTTP клиент для Yii 2](https://habrahabr.ru/post/304584/)
+  [Прошёл хакатон по Yii Framework в TACC](https://habrahabr.ru/post/304092/)
+  [Несколько полезных приемов для разработки на Yii 2](https://habrahabr.ru/post/303406/)
* ##### Laravel
+ [Zizaco/entrust](https://github.com/Zizaco/entrust) — Управление доступом на основе ролей.
+ [tightenco/mailthief](https://github.com/tightenco/mailthief) — Расширение для тестирования отправки писем.
+ [canvasowl/ribbbon](https://github.com/canvasowl/ribbbon) — Простая система управления проектами на основе Laravel.
+ [Laravel Doctrine](http://www.laraveldoctrine.org/) — Doctrine2 вместо Eloquent для Laravel. [Пост](https://www.sitepoint.com/laravel-doctrine-best-of-both-worlds/) в поддержку.
+ [spatie/laravel-activitylog](https://github.com/spatie/laravel-activitylog) — Пакет для логирования событий и действий в Laravel-приложении. [Пост](https://murze.be/2016/06/package-log-activity-laravel-app/) в поддержку.
+ [Hifone/Hifone](https://github.com/hifone/hifone) — Движок форума.
+ [austintoddj/Canvas](https://github.com/austintoddj/Canvas) — Движок для ведения блогов на основе Laravel. Прислал [tkf](https://habrahabr.ru/users/tkf/).
+ [Пишем продвинутые фильтры поиска для Eloquent](https://dotdev.co/writing-advanced-eloquent-search-query-filters-de8b6c2598db#.16sfoe3a8)
* [Фильтр Блума на PHP](http://phpden.info/Bloom-filters-in-PHP) — О реализации быстрой вероятностной [структуры данных](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0).
* [Свои собственные кастомные аннотации – больше чем просто комментарии](https://www.sitepoint.com/your-own-custom-annotations/) — Пример c использованием [doctrine/annotations](https://github.com/doctrine/annotations).
* [Серия туториалов](https://gnugat.github.io/2016/06/15/mars-rover-introduction.html) по созданию приложения с использованием принципов MonoRepo, CQRS, Event Sourcing, TDD.
* [PHP, Arduino и Minecraft](https://www.sitepoint.com/php-arduino-and-minecraft-combining-minecraft-with-php/), [2](https://www.sitepoint.com/php-arduino-and-minecraft-connecting-an-arduino-to-php/)
*  [Макросы Zend обхода циклов (HashTable Iteration)](https://habrahabr.ru/post/303678/)
*  [Пишем расширение под PHP (7.0.7) без знаний о С/C++ и как это вообще работает](https://habrahabr.ru/post/303572/)
*  [Отладка php функций с помощью phpdbg, как альтернатива Xdebug через IDE](https://habrahabr.ru/post/303426/)
*  [Пакет-географ – первая рабочая версия](https://habrahabr.ru/post/304098/)
*  [Как начать разработку крупного, нетипичного проекта. Практическое пособие](https://habrahabr.ru/post/304908/)
*  [Впечатления от лучших докладов на International PHP Conference](https://habrahabr.ru/company/nixsolutions/blog/305708/)
*  [Управление действиями процессов. Не превышение лимита RPS (QPS) API](https://habrahabr.ru/post/304536/)
*  [PHP-инструменты для японского языка](https://habrahabr.ru/post/304354/)
### Аудио и видеоматериалы
*  [DevConf2016 — Безопасность: от базовых принципов до особенностей PHP](https://www.youtube.com/watch?v=P9zUFzB_NBs)
*  [PHP Roundtable #47: All About HTTP/2](https://www.phproundtable.com/episode/all-about-http2)
*  [PHP Roundtable #48: Docker & PHP](https://www.phproundtable.com/episode/docker-and-php)
*  [PHP Town Hall: Episode 50: Low down on PSR-15](https://phptownhall.com/episode-50-low-down-on-psr15/) — Обсуждение PHP Middleware.
*  [PHP Serbia Conference 2016](https://www.youtube.com/playlist?list=PLfGr5rAHwhIKDvQCaHCW1-1X01FlmEyIb) — Видеозаписи докладов.
### Занимательное
* [PHP Sucks](https://evertpot.com/PHP-Sucks/) — Пост от известного участника PHP-сообщества Evert Pot, в котором он пишет о плохой репутации PHP и почему решил перейти на другой язык.
* [PHP занял 6-е место в рейтинге языков программирования TIOBE](http://www.tiobe.com/tiobe_index)
* [externals.io](http://externals.io/) — Новый инструмент, который отображает рассылку PHP Internals в удобном виде и позволяет легко следить за обсуждениями.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
[Прислать ссылку](http://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 87](http://habrahabr.ru/company/zfort/blog/303130/) | https://habr.com/ru/post/305808/ | null | ru | null |
# Делаем собственное Z-Wave устройство на базе Z-Uno
Протокол Z-Wave весьма популярен, и существует огромное множество совместимых устройств. Однако все, кто когда либо автоматизировал своё жилище, сталкивались с тем, что чего-то таки не хватает.
Кому-то не хватает датчика давления, кому-то датчика дождя, кому-то хочется устройство на 6 реле в одном корпусе, да ещё и на батарейках. А кому-то просто нужно управлять через Z-Wave пылесосом iRobot Roomba.
Но всего этого нет в Z-Wave (да и в других протоколах тоже), и производители не торопятся осуществлять все ваши мечты.
Мы услышали вашу боль и создали идеальный комбайн. Встречайте Z-Uno, которая сочетает простоту и универсальность. Z-Uno — это Arduino в мире Z-Wave. На этой плате вы можете собрать все ваши устройства мечты и многое другое.
Про создание устройства Z-Wave и сложности с этим связанные я [писал совсем недавно](http://geektimes.ru/company/zwave/blog/268602). Очевидно, для себя никто разрабатывать собственное устройство не будет — слишком уж это сложно и дорого. Но представьте, если вам дадут доступ к периферии чипа Z-Wave, open source компилятор, простую IDE, лёгкий доступ к сети Z-Wave, сертифицированный функционал и возможность работы с любым другим устройством Z-Wave.
И вот мы сделали это доступным в нашем новом устройстве Z-Uno (более правильно назвать Z-Uno платформой, а не устройством, т.к. устройств на этой маленькой плате можно сделать много). Идея Z-Uno проста:
Вы пишете код на языке C в стиле Arduino прямо в среде Arduino IDE. Эта же среда используется для загрузки вашего кода по USB (есть также возможность залить новый код по радио через контроллеры Z-Wave — так называемая перепрошивка OTA). Ваш код управляет всеми ножками как в Arduino. Привычный набор функций Arduino дополнен специфическими для работы с сетью Z-Wave — получения и отправки команд. Все сложности Z-Wave скрыты «под капотом» Z-Uno.
Приведём пример необычного устройства. Например, вы хотите удалённо поливать ваш любимый цветок, а также включать ему освещение. Ну, очень вам он дорог, и включать полив вы хотите сами, а не автоматически, дабы чувствовать свою причастность к уходу за растением. Для этого вы возьмете датчик влажности почвы, а также реле для включения полива и светодиодную ленту для освещение. Но тянуть провода к цветочку не хочется. Как же быть? Подключим к одному из АЦП Z-Uno наш датчик влажности, реле к цифровым выходам, а освещение к ШИМ. Значение с АЦП мы будем передавать по Z-Wave в виде «многоуровневого датчика» (Sensor Multilevel), реле представим через «бинарный выключатель» (Switch Binary), а регулятор светодиодной ленты через «многоуровневый выключатель» (Switch Multilevel). Контроллеры Z-Wave сразу подхватывают предоставленные в таком виде данные, отображают их в интерфейсе и позволяют удалённо управлять.
Вот как будет выглядеть схема подключения датчика, реле и регулятора освещения к Z-Uno (для простоты я не стал рисовать ни детали подключения реле полива, ни схему управления диммируемой светодиодной ленты — предполагается, что эту часть схемотехники вы уже имеете, собрав прототип на Arduino). Питаться данное устройство будет от micro-USB порта Z-Uno, а 3.3 В для самой Z-Uno и датчика влажности почвы получаются благодаря встроенному преобразователю DC-DC.
**Код нашей программы для Z-Uno будет выглядеть так**
```
int moistPin = A1; // нога для чтения значений влажности почвы с АЦП
int feedPin = 14; // нога для включения реле полива
int lightPin = PWM2; // нога для управления освещением
int dimLevel = 0; // тут мы храним значение диммера
int moistLevel = 0; // тут мы храним измеренное значение влажности
int moistLevelHist = 50; // константа для гистерезиса влажности (чтоб избавится от шума АЦП и реагировать только на сильные изменения)
int moistLevelCritical = 300; // пороговый уровень, при котором мы отправляем внешнему устройству команду включить реле
ZUNO_SETUP_CHANNELS(
ZUNO_SENSOR_MULTILEVEL_MOISTURE(moistureGetter), // канал для влажности почвы и ф-цию, возвращающую значение
ZUNO_SWITCH_BINARY(feedGetter, feedSetter), // канал для реле полива с ф-циями выставления и получения значений
ZUNO_SWITCH_MULTILEVEL(lightGetter, lightSetter) // канал для диммирования с ф-циями выставления и получения значений
);
ZUNO_SETUP_ASSOCIATIONS(
ZUNO_ASSOCIATION_GROUP_SET_VALUE // включаем какое-нибудь устройство Z-Wave при критичном высыхании почвы
);
void setup() {
// выставим режимы ног
pinMode(feedPin, OUTPUT);
// при подаче питания выключим полив и свет
digitalWrite(feedPin, LOW);
analogWrite(lightPin, dimLevel);
}
void loop() {
int moistLevelNew = analogRead(moistPin);
if (moistLevelNew < moistLevel - moistLevelHist || moistLevelNew > moistLevel + moistLevelHist) {
// значение влажности сильно изменилось
if (((moistLevel > moistLevelCritical) && (moistLevelNew < moistLevelCritical)) ||
((moistLevel < moistLevelCritical) && (moistLevelNew > moistLevelCritical))) {
zunoSendToGroupSetValueCommand(CTRL_GROUP_1, moistLevel < moistLevelCritical); // включить устройство, если сухо
}
moistLevel = moistLevelNew;
zunoSendReport(CHANNEL_1); // отправим отчёт на контроллер (отчёт по каналу 1)
}
delay(60*1000);
}
byte moistureGetter(void) {
byte tmpLevel = moistLevel / 9; // приведём значения 0 (сухо) - 900 (в воде) к 0-100% (АЦП 10-бит)
if (tmpLevel > 100) tmpLevel = 100;
return tmpLevel;
}
void feedSetter(byte value) {
digitalWrite(feedPin, value ? HIGH : LOW);
}
byte feedGetter() {
return digitalRead(feedPin);
}
void lightSetter(byte value) {
dimLevel = (value > 99) ? 99 : value; // по умолчанию включать сразу на максимум (тут можно было бы включать на уровень последнего значения)
analogWrite(lightPin, dimLevel*255/99);
}
byte lightGetter() {
return dimLevel;
}
```
Код неплохо прокомментирован. Ниже будет чуть подробней расписан смысл некоторых строк.
Таким образом, мы всего лишь написали код аналогичный тому, что вы имели для Arduino, для чтения значения влажности и для изменения состояния ног, управляющих реле, а также описали каналы для Z-Wave и привязали их к полученным значениям. Всю остальную работу по передаче данных Z-Uno сделает за вас. Мобильные приложения и удалённый доступ, предоставляемые центральными контроллерами Z-Wave позволят управлять поливом из любой точки мира из того же интерфейса, в котором управляется остальные элементы вашего умного дома.
Вид нашего устройства полива в интерфейсе Z-Way/RaZberry:
Вид нашего устройства полива в интерфейсе Fibaro Home Center 2 и Home Center Lite:
Вид нашего устройства полива в интерфейсе Vera Edge (видно, что экзотический датчик влажности почвы не показывается, но замена на относительную влажность решает проблему в данном случае):
Вид нашего устройства полива в интерфейсе Zipato ZipaBox:
#### Немного голых фактов о Z-Uno
Z-Uno основана на модуле Mitsumi WML-C85 (также могут встречаться версии с WML-C84 или ZM5101). Почти все ноги и функции мы предоставляем пользователю через удобное API максимально похожее на язык Arduino. Поэтому характеристики Z-Uno очень похожи на характеристики SD3502, ZM5101 и WML-C84.
*Отметим, что Z-Uno — бурно развивающийся проект. Курсивом отмечены заявленные цели. По мере реализации и тестирования мы будем их помечать* обычным шрифтом. Символом \* отмечен частично реализованные функции (наведите мышкой для отображения комментария).
##### Технические характеристики:
* 28 кБайт FLASH-памяти для ваших скетчей,
* 4 кБайта RAM,
* Z-Wave радио-трансивер на каналах 9.6, 40 и 100 кбит/с,
* 22 GPIO (некоторые перекрываются с другими функциями),
* 4 АЦП,
* 5 ШИМ\*,
* 2 UART\*,
* 1 USB (в режиме serial),
* *64 кБайта EEPROM*,
* *1 SPI (master или slave режимы)*
* *4 ИК-контроллера и 1 ИК-приёмник с функцией обучения,*
* *1 TRIAC/ZEROX контроллеры для диммирования,*
* 1 прерывание\*,
* *2 таймера (16 MHz или от внешнего источника)*,
* *I2C (программный на ногах GPIO)*,
* *1-wire (программный на ногах GPIO)*,
* *8x6 сканер кнопок (в том числе в режиме глубокого сна)*,
* 2 сервисных светодиода, 1 сервисная кнопка,
* 1 пользовательский LED (как pin 13 у Arduino).
«Распиновка» Z-Uno (нажмите, чтобы [открыть большую картинку](https://habrastorage.org/files/697/991/4ed/6979914edee84c729ba64a4a3f0084b8.gif)):
[](https://habrastorage.org/files/697/991/4ed/6979914edee84c729ba64a4a3f0084b8.gif)
##### Режимы питания:
* USB 5 В, внешнее 3 В, внешнее 4-15 В или батарейка 3 В,
* всегда в сети, спящее или FLiRS,
##### Функции Z-Wave:
* Соответствие Z-Wave Plus,
* Все частоты Z-Wave (из-за разных SAW-фильтров будет 3 вида Z-Uno),
* Поддержка из коробки шифрования AES 128 бит, описанного в протоколе Z-Wave,
* Обновление прошивки и бутлоадера через USB или по радио (Z-Wave OTA),
* MultiChannel (10 пользовательских каналов — каждый канал предоставляет одну функцию, см. ниже),
* 10 групп ассоциаций для управления другими устройствами,
* Возможность управлять по радио Z-Wave реле, диммерами, замками, запуском сцен,
Каждый пользовательский канал может содержать один из следующих классов команд Z-Wave:
* Binary Switch (для реле),
* Multilevel Switch (для диммеров, жалюзи),
* *Color Switch (для цветных ламп)*,
* Binary Sensor и Notification (для детекторов и сигнализаций),
* Multilevel Sensor (для датчиков, возвращающих числовое значение),
* *Meter (для счётчиков)*.
#### Установка и настройка среды для программирования Z-Uno
Пользовательские скетчи заливаются в Z-Uno прямо из Arduino IDE. Для работы с Z-Uno необходимо установить соответствующий пакет, который содержит компилятор, загрузчик, библиотеки и .h-файлы проекта Z-Uno. Это делается из появившейся недавно в Arduino IDE менеджера плат (Board Manager). Для появления пакета Z-Uno в списке в менеджере плат, требуется зайти в настройки и прописать в поле Additional Boards Manager URLs ссылку на описание пакетов Z-Uno: <http://z-uno.z-wave.me/files/z-uno/package_z-wave.me_index.json>. Далее зайдите в Tools -> Board -> Boards manager и установите пакет для Z-Uno.
**Важно!** На данный момент поддерживается только предпоследняя [Arduino IDE 1.6.5](https://www.arduino.cc/en/Main/OldSoftwareReleases#1.5.x).
После установки пакета Z-Uno в списке плат в меню Tools появится пункт Z-Wave>Me Z-Uno, а в списке программаторов Z-Uno Programmer. Выберите нужный порт (COM-порт под Windows, ttyACM-порт на Linux и cu.usbmodem под OS X). Пункт Burn Bootloader позволяет обновить загрузчик скетча Z-Uno и стек Z-Wave (см. архитектуру Z-Uno ниже) до самой последней версии, входящей в пакет Z-Uno.
Также в меню появится галочка для включения шифрования (класс команд Security) и компактной отправки пакетов (класс команд MultiCommand). Эти функции не поддерживаются некоторыми контроллерами. Кроме того, в этом же списке можно выбрать частоту работы Z-Uno (обратите внимание, что SAW-фильтр в любом случае настроен на один из трёх диапазонов частот, т.е. при выборе несоответствующей частоты дальность радио связи будет существенно ниже!).
В меню File->Examples также появятся примеры, специфичные для Z-Uno. С них можно начать изучение возможностей Z-Uno.
**Весь процесс в картинках**
Подробная [инструкция по установке](http://z-uno.z-wave.me/install) представлена на сайте проекта Z-Uno.
#### Что ещё можно сделать на Z-Uno?
Тут нужно пускать в ход вашу фантазию. Вот несколько идей:
* Выключатель на батарейках,
* Диммер-крутилку (роторный диммер),
* Датчик температуры, влажности, освещённости, напряжения, расстояния, давления, дождя,...
* Счётчик, датчик сухих контактов, низковольтное реле,
* ИК-пульт,
* LED-драйвер,
* Управление двигателем,
* Панель кнопок (клавиатуру) на батарейках,
* Преобразователь из Z-Wave в другие протоколы (любые датчики, подключенные по SPI/UART/I2C/1-wire шинам).
#### Z-Uno и Z-Wave
Создавая свои устройства на базе Z-Uno вам не нужно изучать всю документацию протокола Z-Wave и микроконтроллеров ZM5101. Однако какие-то минимальные знания о Z-Wave вам понадобятся, чтобы правильно описать в скетче нужные вам функции.
##### Каналы
Чтобы представить несколько функций в одном устройстве, в протоколе Z-Wave описаны каналы (изредка называемые «экземплярами»). В Z-Uno мы используем это понятие для создания сложных устройств. Каждый канал Z-Uno предоставляет одну из заявленных пользователем функций. Сколько функций описано, столько каналов будет. Используйте макрос [ZUNO\_SETUP\_CHANNELS](http://z-uno.z-wave.me/Reference/ZUNO_SETUP_CHANNELS) для описания количества и типов каналов.
**Например, вот так мы опишем устройство измерения влажности и включения полива и освещения.**
```
ZUNO_SETUP_CHANNELS(
ZUNO_SENSOR_MULTILEVEL_MOISTURE(moistureGetter),
ZUNO_SWITCH_BINARY(feedGetter, feedSetter),
ZUNO_SWITCH_MULTILEVEL(lightGetter, lightSetter)
);
```
Данный код описывает три канал. Первый будет содержать класс команд Sensor Multilevel и передавать значение влажности почвы, второй — управление поливом, третий — выключатель освещения.
##### Ассоциации
Z-Uno сама будет отправлять отчёты об изменениях состояний на каналах на контроллер (при вызове zunoSendReport(номер канала)). Однако Z-Uno также может управлять другими устройствами Z-Wave. Для упрощения настройки в протоколе Z-Wave описано понятие группы ассоциаций (или просто ассоциации). Группа ассоциаций — это список устройств сети, которым будет отправлена определённая команда при наступлении определённого события. Вид команды и события программируются в устройстве, в то время как список получателей можно легко менять из интерфейса контроллеров Z-Wave.
Макрос [ZUNO\_SETUP\_ASSOCIATIONS](http://z-uno.z-wave.me/Reference/ZUNO_SETUP_ASSOCIATIONS) позволяет определить количество доступных в устройстве групп и вид отправляемой команды для каждой группы (управление реле, диммером или запуск сцен).
**Например, вот так мы опишем группу для управления другим устройством типа реле.**Вверху файла проекта:
```
ZUNO_SETUP_ASSOCIATIONS(ZUNO_ASSOCIATION_GROUP_SET_VALUE);
```
и в нужном месте в коде:
```
zunoSendToGroupSetValueCommand(CTRL_GROUP_1, значение);
```
##### Управление питанием
Протокол Z-Wave спроектирован так, чтобы было возможно создавать устройства с очень низким потреблением энергии и питать их от батареек. Большинство датчиков Z-Wave работают на комплекте батареек более года. Однако для этого устройство должно пребывать в состоянии «сна» большую часть времени, изредка просыпаясь для измерений значений датчиков и отправки отчётов. Такие устройства называются **«спящими»**.
Чтобы с одной стороны сделать устройство работающим от батареек, а с другой — иметь возможность управлять им в режиме реального времени (не дожидаясь пробуждения), в Z-Wave введён ещё один тип управления питанием: **«часто слушающие»** устройства или FLiRS. Эти устройства просыпаются раз в секунду для проверки эфира на предмет «пробуждающего пакета» и сразу уходят спать дальше, если для них ничего нет. Связь с такими устройствами потребует чуть больше времени — перед отправкой нужной команды необходимо в течение одной секунды отправлять специальный «пробуждающий пакет». В течение этого времени сеть будет заглушена, однако после пробуждения устройство будет оперативно отвечать на команды до ухода в сон. В этом режиме устройство способно прожить на комплекте батареек около года. Типичные устройства, требующие данного режима — это реле на батарейках, сирены, дверные замки.
Все постоянно запитанные устройства, такие как диммеры, реле и другие исполнители, являются **«постоянно слушающими»**. Это означает, что они всегда доступны, всегда слушают эфир и выполняют роль ретрансляторов для других устройств, формируя ячеистую сеть.
Z-Uno поддерживает все три режима питания. Режим питания можно определить макросом [ZUNO\_SETUP\_SLEEPING\_MODE](http://z-uno.z-wave.me/Reference/ZUNO_SETUP_SLEEPING_MODE).
**Важно!** При изменении параметров или количества каналов, групп ассоциаций или режима питания необходимо исключить Z-Uno из сети и заново её включить в сеть. Это вызвано требованием протокола Z-Wave не менять свои характеристики «на лету».
##### Узнать больше о Z-Wave
Упомянутой здесь информации должно быть достаточно для создания своего устройства Z-Wave, однако более глубокое понимание никогда не помешает. Почитать подробней можно [в этой статье](http://geektimes.ru/company/zwave/blog/257684/), а также [в книге «Основы Z-Wave»](http://rus.z-wave.me/shop/additional/kniga-osnovy-z-wave/) Кристиана Петц.
#### Совместимость с контроллерами
Мы делаем Z-Uno полностью соответствующей самому свежему стандарту Z-Wave Plus. Однако, увы, это не гарантирует полной работоспособности во всех контроллерах. Увы, многие контроллеры требуют «шаблонов» для поддержки конкретных устройств. Писать такие шаблоны сложно или даже невозможно (производитель контроллера может не давать возможности загрузить свой шаблон). А некоторые контроллеры и вовсе ограничивают отображаемые функции устройства тремя или четырьмя элементами управления. Это сильно ограничивает возможность использования Z-Uno.
Сразу отметим, что наш собственный контроллер Z-Way поддерживает любые варианты устройств на базе Z-Uno прямо «из коробки». Нет, мы не делали специальную поддержку для Z-Uno и не писали никаких шаблонов. Просто Z-Way так написан, и ему лишь достаточно того, что устройство сертифицировано и соответствует протоколу Z-Wave.
Пока мы тестировали Z-Uno с Z-Way (полная совместимость), Fibaro (до четырёх функций), Vera Edge (не поддерживаются экзотические датчики), Zipato (мало тестировали, но пока проблем не замечено). Мы надеемся, что производители контроллеров будут улучшать работу контроллеров и поддержку входящих в стандарт Z-Wave функций.
#### Внутреннее устройство Z-Uno
Хотелось бы упомянуть о том, как устроена Z-Uno внутри. Исполняемый код Z-Uno состоит из четырёх частей:
**Пользовательский код**, он же «скетч» — это ваш код, написанный на [упрощённом языке C](http://z-uno.z-wave.me/Reference) и загруженный в Z-Uno посредством Arduino IDE. Пользовательский код управляет всеми «ногами» и логикой работы устройства. Вы сами решаете, как подключить ту или иную периферию!
**Загрузчик пользовательского кода** реализует уровень приложения Z-Wave в соответствии с пользовательскими настройками, определяет каналы и группы ассоциаций, задаёт режим сна. Он также управляет сервисными светодиодами и обрабатывает сервисные кнопки, необходимые для включения устройства в сеть, сброса и перевода в режим «восстановления» (режим, в котором пользовательский код не грузится). Но главная роль загрузчика состоит в том, чтобы вызывать Пользовательский код при получении пакетов Set (установка значения) и Get (запрос значения) из сети Z-Wave, а также вызов функции loop всё время, пока более низкие уровни не заняты. Данный уровень является основной частью «ядра» прошивки Z-Uno.
**Уровень приложения Z-Wave** отображает объявленные пользователем каналы, функции и ассоциации Z-Uno на классы команд Z-Wave, обеспечивая соответствие стандарту Z-Wave Plus. Данный уровень также предоставляет такие функции, как обновление прошивки, по USB и по радио (OTW и OTA), AES шифрование всех радио пакетов, мониторинг мощности радио сигнала, измерение заряда батарейки, периодические пробуждения, а также анонсирует в сеть базовую информацию об устройстве.
**Сетевой уровень Z-Wave** основан на SDK Sigma Designs (версии 6.5x), которая реализует сетевой и радио уровни протокола Z-Wave, устанавливая надёжную двухстороннюю связь в mesh-сети умного дома. Этот уровень занимается вычислением маршрутов, обеспечивая доставку пакетов получателям даже вне зоны прямой видимости, осуществляет пересылку (маршрутизацию) и приём пакетов.
Пользовательский код (скетч) компилируется в Arduino IDE с библиотеками Z-Uno Core Libraries, которые необходимо установить через Arduino Board Manager. Как и скетчи Arduino, скетчи Z-Uno являются обычными прошивками, скомпилированными для соответствующего микроконтроллера. Однако по сравнению с Arduino, основанной на микроконтроллерах Atmel, Z-Uno основана на чипе Z-Wave, т.е. архитектуре 8051. Потому вместо avg-gcc при сборке скетчей Z-Uno используется компилятор [sdcc](http://sdcc.sourceforge.net/).
Есть ещё одно отличие от скетчей Arduino: скетчи Z-Uno должны взаимодействовать с уровнями ниже. Данное взаимодействие осуществляется через Z-Uno Core Libraries, с которыми компилируются скетчи Z-Uno.
Как уже упоминалось, Пользовательский код можно загрузить через Arduino IDE по USB (используя кнопку «Upload»), а также по радио через контроллер Z-Wave, поддерживающий обновление прошивок в устройствах.
Все нижние уровни (Загрузчик пользовательского кода, Уровень приложения Z-Wave и Сетевой уровень Z-Wave — все вместе) можно также обновить по USB из Arduino IDE (используя пункт меню «Upload Bootloader») или также по радио через контроллер Z-Wave.
Замечу, что эти нижние уровни скомпилированы с библиотеками Z-Wave SDK при помощи компилятора Keil C51, в то время как пользовательский код собран при помощи sdcc. Думаю, мы напишем отдельную статью о том, как мы скрещивали ежа с ужом. Ведь эти компиляторы даже имеют немного разные конвенции и ABI вызова функций.
#### Недостатки Z-Uno
Мы старались сделать идеальный продукт, но не всегда получается все гладко ;)
Увы первая выпущенная версия не помещается на одну макетную плату (из-за размера батарейки мы не смогли уменьшить плату). Но следующая версия будет у́же и поместится на одну стандартную макетку.
Также в текущей версии мы прогадали с выбором батарейки — текущая не способна нормально питать устройство в режиме FLiRS. Следующая не будет иметь батарейки на борту, а только кабель для подключения внешней батарейки.
Также текущая плата не имеет защиты от подключения одновременно батарейки и внешнего питания. Об этом напоминает защитная бумажка в отсеке для батареек. Но и это исправится.
Как видно, эти недостатки важны, но не критичны для большинства функций. В остальном устройство получилось весьма универсальным и подходит для создания множества датчиков и исполнительных устройств.
Также стоит отметить, что в отличии от Arduino, Z-Uno имеет на ногах 3 В, а не 5 В. Это следует учитывать, чтобы не спалить входы.
После нескольких workshop мы поняли, что продукт всё-таки получился сложным: те, кто знаком с Ардуино, должны познакомиться с экосистемой устройств Z-Wave и интерфейсом контроллеров Z-Wave, а те, кто знаком с Z-Wave, должны иметь базовые знания С. К счастью пересечение подмножеств этих людей весьма велико.
#### Чем Z-Uno не является
* Z-Uno представляет одно устройство (с несколькими каналами). Т.е. полноценным шлюзом между Z-Wave и другой технологией Z-Uno быть не сможет (для этого в Z-Wave есть Bridge Controller).
* Z-Uno — дочернее Z-Wave устройство и не может быть контроллером (т.е. строить и администрировать сеть). Однако через ассоциации Z-Uno может управлять другими устройствами.
* Z-Uno не является законченным устройством — вам потребуется подключить датчики (например, из списка совместимых с Arduino) и запрограммировать работу с ними.
#### Развитие проекта и планы
Как я уже упоминал, Z-Uno — быстро развивающийся проект. Мы поставили себе очень амбициозную цель, и уверенно шагаем к ней. Вот краткий план проекта на ближайшие месяцы:
* Январь — чистка синтаксиса, подготовка к сертификации Z-Wave Plus.
* Февраль — сертификация Z-Wave Plus, добавление функций работы с EEPROM, с памятью NZ XRAM.
* Март — добавление протоколов SPI, I2C, 1-wire.
* Апрель — выпуск обновлённой версии платы (для диапазона 865-870 МГц — частоты Z-Wave для России, Европы, Малайзии, Индии,...)
* Май и далее — добавление новых функций в порядке приоритета (на основе пожеланий пользователей).
* где-то к осени — выпуск версий платы для других регионов.
##### Следите за новостями!
Вся информация о ходе проекта публикуется на сайте [z-uno.z-wave.me](http://z-uno.z-wave.me). Там же находится описание функций языка программирования C и примеры кода (на английском).
Также у нас есть англоязычный [форум](http://forum.z-wave.me/viewforum.php?f=3427), посвященный Z-Uno.
Код Z-Uno Core Libraries [доступен на github](https://github.com/Z-Wave-Me/Z-Uno-Core).
Информацию об ошибках и предложениях мы принимаем через github: вы можете [создать тикет и доложить о проблеме](https://github.com/Z-Wave-Me/Z-Uno-Core/issues).
#### Ну а купить-то где?
Z-Uno уже доступна (пока только в России) у наших партнёров [5 smart](http://www.5smart.ru/collection/super-deals/product/z-uno-2), которые в течение недели после данной публикации дарят 5% на все устройства Z-Wave по скидочному купону **GT\_ZUNO**. Надеемся, скоро Z-Uno появится и в других магазинах.
Рекомендованная розничная цена 3500 руб.
Подробности проекта на сайте [z-uno.z-wave.me](http://z-uno.z-wave.me/).
 | https://habr.com/ru/post/367571/ | null | ru | null |
# Чего ждать от NeoVim: особенности редактора
Привет! Я Антон Губарев, инженер команды Platform as a Service (PaaS) в Авито. Долгое время я пользовался IDE от JetBrains, затем пересел на VS Code. Последние несколько лет работаю с кодом только в NeoVim — адаптировал его под себя и перестал использовать другие IDE.
Я не фанат ни одного из редакторов или IDE и не буду пытаться убедить вас перейти с привычной платформы на NeoVim. Я только расскажу, к чему готовиться человеку, который привык работать в JetBrains или VS Code и планирует попробовать NeoVim.
NeoVim – это ответвление от Vim, которое привносит некоторые важные преимущества. Я для себя остановился именно на NeoVim, и поэтому большая часть статьи именно в этом контексте. Однако много чего из материала можно отнести к Vim.
NeoVim не работает «из коробки», в нём нужно прописывать конфигурацию, биндить комбинации клавиш, собирать подходящие плагины. Но в итоге получается идеальный редактор: в нём всё устроено так, как нужно конкретному разработчику.
В основе статьи — моё [выступление на Golang Evrone Meetup](https://www.youtube.com/watch?v=DbUNTGX7n94&ab_channel=EvroneDevelopment). В видео вы найдёте больше деталей о плагинах, работе команд и комбинаций. А все исходники есть [в репозитории на GitHub](https://github.com/antgubarev/dotfiles).
Буферы, окна и табы вместо привычных вкладок
--------------------------------------------
Когда новый пользователь открывает NeoVim, первое, что может запутать, — отсутствие вкладок. В большинстве редакторов каждый файл находится в отдельной вкладке внутри одного окна IDE. В NeoVim вместо этого есть три сущности: буферы, окна и табы.
Буфер — отдельный открытый файл. Один и тот же файл можно просматривать и редактировать в нескольких буферах. При этом все изменения в одном из них будут автоматически и мгновенно отображаться в остальных.
Буферы можно объединять в окна, а окна — в табы. Можно открыть несколько табов NeoVim, внутри каждого из них — несколько окон, а в каждом окне — разные комбинации файлов в буферах.
Файлы в буферах, буферы в окнах, окна в табахЧтобы начать пользоваться этим, нужно сначала постичь дзен NeoVim. У меня пока не получилось, поэтому использую специальный плагин — о нём рассказываю ниже.
Управление без мышки, только на клавиатуре
------------------------------------------
В NeoVim нет поддержки мыши, работать приходится только на клавиатуре. Причём даже навигация по коду выполняется не привычными стрелками, а клавишами HJKL. Когда создавался Vi (прародитель NeoVim) клавиатура его автора Билла Джоя выглядела вот так:
Клавиатура Билла ДжояПреимущества управления в NeoVim поймут те, кто владеет десятипальцевым методом печати. Смысл в том, что большинство комбинаций находятся на буквенных и цифровых сочетаниях, поэтому во время работы почти не нужно смещать кисти.
Поначалу может быть сложно с таким управлением, но со временем привыкаешь. Я довёл навыки до автоматизма за две недели и увидел разницу в скорости работы с мышью и без.
Команды NeoVim
--------------
В NeoVim есть команды для практически любой ситуации, которая возникает во время работы. Их можно комбинировать и вызывать подряд. Иногда это выглядит довольно сложно, но в командах получается быстро разобраться и запомнить, что за чем следует.
Допустим, нужно найти все `foo` в коде и заменить их на `bar`. При этом перед каждой заменой спрашивать подтверждение. Команда для этого:
`:s/foo/bar/gc`
Если нужно искать в диапазоне от 3-й до 10-й строки, а подтверждения не требуется, то получим:
`:3,10s/foo/bar/g`
Список базовых команд можно посмотреть [в документации NeoVim](https://neovim.io/doc/user/vimindex.html) или набрать `:h`, чтобы вызвать подсказку.
Для постоянно повторяющихся действий можно биндить команды или даже их последовательности — привязывать к конкретной клавише или комбинации. Это сильно экономит время во время работы.
Комбинации клавиш для быстрых действий
--------------------------------------
Некоторые действия с кодом закреплены за конкретными комбинациями клавиш. Для работы не надо запоминать их все. Достаточно 30–40 штук — они чаще всего используются в повседневных задачах. Например, я редактирую код с помощью комбинаций:
* `dd` — удалить строку;
* `a A i I o O` — начать редактирование (с конца строки или сначала, со следующего символа или предыдущего);
* `w b` — перемещать по словам;
* `gg G` — перейти в начало файла;
* ``х` — переместить курсор на метку х;
* `С` или `99` — перейти на строку номер ;
* `diw` — удалить слово под курсором;
* `de` — удалить символы с текущего до конца слова, включая пробел;
* `[{}]` — переместиться назад по тексту к открывающей скобке текущего блока кода;
* `%` — перейти от открывающей скобки к закрывающей, при повторном нажатии — перейти обратно;
* `u U` — изменить регистр выделенных символов на нижний.
Конфигурация: настроить можно почти всё
---------------------------------------
Конфигурируемость — это одно из главных преимуществ, которое делает NeoVim удобным и полезным.
Обычно конфигурация в редакторах кода описывается в формате JSON или XML. Их возможности ограничены синтаксисом, поэтому тонкая настройка не всегда удаётся. Самые популярные IDE вроде VS Code или JetBrains настраиваются через графический интерфейс — в нём ещё меньше возможностей для настроек, только то, что допускают разработчики софта.
В NeoVim все настройки и плагины пишутся на языке программирования Lua (есть поддержка VimScript). Это полноценный кодинг, а не просто выбор опций: можно задать условия, при которых будет работать та или иная версия конфигурации. Например, настроить новую комбинацию клавиш так, чтобы она закрывала терминал, только если процесс в нем завершен.
```
local on_attach = function(client, bufnr)
local function buf_set_keymap(...)
vim.api.nvim_buf_set_keymap(bufnr, ...)
end
-- Enable completion triggered by
vim.api.nvim\_buf\_set\_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
-- Mappings.
buf\_set\_keymap("n", "gD", "lua vim.lsp.buf.declaration()", opts)
buf\_set\_keymap("n", "gd", "Telescope lsp\_definitions", opts)
buf\_set\_keymap("n", "K", "lua vim.lsp.buf.hover()", opts)
buf\_set\_keymap("n", "gi", "Telescope lsp\_implementations", opts)
buf\_set\_keymap("n", "", "lua vim.lsp.buf.signature\_help()", opts)
buf\_set\_keymap("n", "D", "Telescope lsp\_type\_definitions", opts)
buf\_set\_keymap("n", "rn", "lua vim.lsp.buf.rename()", opts)
buf\_set\_keymap("n", "ca", "lua vim.lsp.buf.code\_action()", opts)
buf\_set\_keymap("n", "gr", "Telescope lsp\_references", opts)
if client.resolved\_capabilities.document\_formatting then
vim.cmd([[
augroup formatting
autocmd! \*
autocmd BufWritePre lua vim.lsp.buf.formatting\_seq\_sync()
augroup END
]])
end
end
-- Setup lspconfig.
local capabilities = require('cmp\_nvim\_lsp').update\_capabilities(vim.lsp.protocol.make\_client\_capabilities())
-- Replace with each lsp server you've enabled.
require('lspconfig')['gopls'].setup {
capabilities = capabilities,
on\_attach = on\_attach
}
require('lspconfig')['pyright'].setup {
capabilities = capabilities,
on\_attach = on\_attach
}
```
У конфигурации на Lua есть один большой минус: если в коде ошибка, то NeoVim может не открыться. Я редактирую код конфигурации в одном NeoVim. Потом открываю второй в другой сессии и проверяю в нём, что всё работает корректно. Если NeoVim не запускается, у меня остаётся рабочая версия без изменений в конфигурации — в ней исправляю ошибки. Иначе придётся зайти через другой редактор, чтобы откатить изменения.
Свою конфигурацию NeoVim я написал сам, но использовал полезные фишки из дотфайлов разработчиков на GitHub:
* [mathiasbynens/dotfiles](https://github.com/mathiasbynens/dotfiles)
* [ThePrimeagen/.dotfiles](https://github.com/ThePrimeagen/.dotfiles)
* [zanshin/dotfiles](https://github.com/zanshin/dotfiles)
* [caarlos0/dotfiles.fish](https://github.com/caarlos0/dotfiles.fish)
* [samoshkin/dotfiles](https://github.com/samoshkin/dotfiles)
Если не хотите заниматься настройкой и разбираться с Lua, используйте одну из готовых сборок. Из наиболее распространённых выделю:
* AstroVim
* SpaceVim
* LunarVim
* NvChad
В готовых конфигурациях уже есть всё необходимое, чтобы пользоваться NeoVim как обычной IDE. Но по-настоящему вы ощутите гибкость этого редактора, когда настроите его и подберёте плагины самостоятельно.
LSP: протокол языкового сервера
-------------------------------
Первое, что нужно сделать при настройке NeoVim, — установить языковой сервер, который поддерживает Language server protocol (LSP). Это протокол, который позволяет удобно работать с кодом, независимо от вашего языка программирования. Почитайте на сайте [langserver.org](https://langserver.org/), как он работает, и посмотрите список доступных языков.
Для NeoVim есть плагины, которые позволяют интегрировать работу с языковым сервером. Это поможет видеть в коде:
* список ошибок — например, некорректные названия переменных;
* предупреждения о коде, который никогда не сработает;
* действия с кодом — предложение импортировать пакеты, которых не хватает для корректной работы.
Ещё есть навигация по коду, поддержка автокомплита и другие функции. Я не нашёл того, чего не хватало бы по сравнению с другими IDE. Кстати, в VS Code используется тот же LSP для интеграции с вашим языковым сервером.
Плагины: превращаем редактор кода в полноценную IDE
---------------------------------------------------
Установить плагины можно через несколько разных менеджеров, я пользуюсь [VimPlug](https://github.com/junegunn/vim-plug). Он минималистичный и довольно простой, хотя и требует вручную описать все плагины, которые нужно добавить в сборку NeoVim. Зато настройка плагинов получается более гибкой: можно указать конкретные версии или выполнить дополнительные команды, например make. Вот пример как выглядит мой набор плагинов:
```
call plug#begin()
" Language
Plug 'neovim/nvim-lspconfig'
Plug 'hrsh7th/cmp-nvim-lsp'
Plug 'hrsh7th/cmp-buffer'
Plug 'hrsh7th/cmp-path'
Plug 'hrsh7th/cmp-cmdline'
Plug 'hrsh7th/nvim-cmp'
Plug 'j-hui/fidget.nvim'
Plug 'L3MON4D3/LuaSnip'
Plug 'saadparwaiz1/cmp_luasnip'
Plug 'rafamadriz/friendly-snippets'
Plug 'ray-x/lsp_signature.nvim'
" Debug and test
Plug 'mfussenegger/nvim-dap'
Plug 'leoluz/nvim-dap-go'
Plug 'rcarriga/nvim-dap-ui'
Plug 'nvim-neotest/neotest'
Plug 'nvim-neotest/neotest-go'
" Base
Plug 'folke/todo-comments.nvim'
Plug 'akinsho/toggleterm.nvim'
Plug 'antoinemadec/FixCursorHold.nvim'
" View
Plug 'nvim-lualine/lualine.nvim'
Plug 'kyazdani42/nvim-web-devicons'
Plug 'nvim-treesitter/nvim-treesitter', {'do': ':TSUpdate'}
Plug 'lukas-reineke/indent-blankline.nvim'
Plug 'Mofiqul/vscode.nvim'
" Navigation
Plug 'kyazdani42/nvim-tree.lua'
Plug 'nvim-lua/plenary.nvim'
Plug 'nvim-telescope/telescope.nvim'
Plug 'nvim-telescope/telescope-fzf-native.nvim', {'do': 'make'}
Plug 'karb94/neoscroll.nvim'
Plug 'akinsho/bufferline.nvim'
Plug 'preservim/tagbar'
" Git
Plug 'ThePrimeagen/git-worktree.nvim'
Plug 'TimUntersberger/neogit'
Plug 'lewis6991/gitsigns.nvim'
" Edit
Plug 'tpope/vim-surround'
Plug 'windwp/nvim-autopairs'
Plug 'numToStr/Comment.nvim'
" Misc
Plug 'renerocksai/telekasten.nvim'
call plug#end()
```
Когда список готов, нужно вызвать команду `:PlugInstall` — она устанавливает или обновляет плагины.
В Сети есть подборки, в которых собраны десятки тысяч плагинов на любой вкус и задачи, например эти три:
* [Vim Awesome](https://vimawesome.com/)
* [Awesome Neovim](https://github.com/rockerBOO/awesome-neovim)
* [Neovimcraft](https://neovimcraft.com/)
Среди всего множества есть плагины, которые я рекомендую установить всем, кто только начинает использовать NeoVim.
**Автокомплит.** Функция есть в нескольких плагинах — выбирайте, какой понравится: [Nvim-cmp](https://github.com/hrsh7th/nvim-cmp), [coc.nvim](https://github.com/neoclide/coc.nvim), [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe). Они различаются технологиями, реализацией и UI, но работают примерно одинаково.
[VimGo](https://github.com/fatih/vim-go)**.** Самый популярный на GitHub плагин для Go. Решает характерные задачи: установка, запуск тестов, дебаггеров, добавление импорта, запуск линтера. Я его не использую — сам накрутил все нужные мне возможности по отдельности. Но это потребовало больше времени.
[Vim-test](https://github.com/vim-test/vim-test)**.** Плагин, который запускает тест под курсором или весь файл, поддерживает добавление аргументов после go test.
[Nvim-tree](https://github.com/kyazdani42/nvim-tree.lua)**.** Плагин для навигации, в котором есть всё необходимое: поиск, копирование, вставка, предпросмотр, возможность конфигурировать эти и другие функции.
[Telescope](https://github.com/nvim-telescope/telescope.nvim)**.** Инструмент для работы со списками файлов — я не нашёл ему аналогов ни в одной IDE. Поддерживает сортировки, гибкий поиск внутри файла (live grep, rip grep), fuzzy-поиск и предпросмотр. В официальном вики плагина больше 60 расширений к нему.
**Сниппеты.** Есть много вариантов плагинов, которые добавляют привычные подсказки при наборе кода. Самые известные — [luasnip](https://github.com/L3MON4D3/LuaSnip), [vi msnippets](https://github.com/honza/vim-snippets), [friendly snippets](https://github.com/rafamadriz/friendly-snippets).
[Bufferline](https://github.com/akinsho/bufferline.nvim)**.** Для тех, кто не проникся идеей буферов и табов, есть плагин, который превращает их в простые вкладки. С ним можно сортировать, перемещать и группировать вкладки. Ещё просматривать число ошибок и предупреждений в каждой из них.
**Git.** Я нашёл для себя удобные варианты для разных задач:
* [gitsigns](https://github.com/lewis6991/gitsigns.nvim) показывает исправленные строки и blame изменений. Через вызов горячих клавиш можно посмотреть, что конкретно поменяли в коде.
* [diffview](https://github.com/sindrets/diffview.nvim) — плагин для сравнения версий кода. Умеет открывать диффы для разного числа коммитов через ссылки, хеши и названия веток. Чтобы не вбивать их вручную, придётся дорабатывать и настраивать под себя команды.
Плагины выше делают NeoVim похожим на VS Code. Но есть такие, которые добавляют новую функциональность — я не встречал её ни в одной IDE. Ниже пример работы плагина [surround](https://github.com/tpope/vim-surround), который быстрыми сочетаниями клавиш обрамляет одно слово или сочетание под курсором в другие символы или набор символов:
| | | | |
| --- | --- | --- | --- |
| Было | "Hello world!" | { Hello } world! | Hello world! [Hello] |
| Стало | 'Hello world!' | ({ Hello } world!) | world! |
| Сочетание | cs"' | yss) | ysiw |
Почему я пользуюсь NeoVim и кому ещё он подойдёт
------------------------------------------------
Для меня важное преимущество NeoVim перед другими IDE и редакторами — возможность запрограммировать на Lua любой плагин под свои узкие задачи. Например, я написал плагин для Curl, чтобы собирать и выполнять HTTP запросы из NeoVim не выходя из редактора. Храню в каждом проекте файл с самыми частыми запросами, а сам файл в глобальном gitignore.
```
local utils = require("selfext.utils")
function execCurl()
local command = utils.getCurrentParagraph()
local Terminal = require('toggleterm.terminal').Terminal
local run = Terminal:new({
cmd = command,
hidden = true,
direction = "float",
close_on_exit = false,
on_open = function(term)
vim.api.nvim_buf_set_keymap(term.bufnr, "t", "q", "close", {noremap = true, silent = true})
end,
})
run:toggle()
end
utils.keymap("n", "", "lua execCurl()")
```
Плагин работает просто:
* берёт строку под курсором;
* в цикле ищет первую после курсора пустую строку;
* создаёт буфер из n строк от той, где стоит курсор, до пустой;
* копирует буфер в терминал с командой на выполнение.
При этом не нужно совершать лишних движений — я сразу получаю в терминале результат работы кода, не использую Postman или подобные решения и мне не нужно перекладывать руку на мышь. Дальше с выводом терминала можно работать как с обычным буфером: искать, копировать или грепать.
Я советую разобраться в языке Lua всем: он довольно простой, учится быстро, при этом применяется во многих других продуктах, кроме NeoVim. Например, на нём можно расширять возможности nginx.
Советую попробовать NeoVim, если:
* вам не хватает возможностей IDE;
* вы хотите больше работать без мыши;
* готовы конфигурировать редактор под себя;
* вам требуется больше интеграции с консольными инструментами.
Не стоит пробовать NeoVim, если:
* у вас нет навыка десятипальцевой печати;
* вы предпочитаете, чтобы всё работало «из коробки»;
* вам достаточно функций текущей IDE;
* вы хотите работать только в графическом интерфейсе. | https://habr.com/ru/post/682962/ | null | ru | null |
# SQL запросы быстро. Часть 1
#### Введение
Язык SQL очень прочно влился в жизнь бизнес-аналитиков и требования к кандидатам благодаря простоте, удобству и распространенности. Из собственного опыта могу сказать, что наиболее часто SQL используется для формирования выгрузок, витрин (с последующим построением отчетов на основе этих витрин) и администрирования баз данных. И поскольку повседневная работа аналитика неизбежно связана с выгрузками данных и витринами, навык написания SQL запросов может стать фактором, из-за которого кандидат или получит преимущество, или будет отсеян. Печальная новость в том, что не каждый может рассчитывать получить его на студенческой скамье. Хорошая новость в том, что в изучении SQL нет ничего сложного, это быстро, а синтаксис запросов прост и понятен. Особенно это касается тех, кому уже доводилось сталкиваться с более сложными языками.
Обучение SQL запросам я разделил на три части. Эта часть посвящена базовому синтаксису, который используется в 80-90% случаев. Следующие две части будут посвящены подзапросам, Join'ам и специальным операторам. Цель гайдов: быстро и на практике отработать синтаксис SQL, чтобы добавить его к арсеналу навыков.
#### Практика
Введение в синтаксис будет рассмотрено на примере открытой базы данных, предназначенной специально для практики SQL. Чтобы твое обучение прошло максимально эффективно, открой ссылку ниже в новой вкладке и сразу запускай приведенные примеры, это позволит тебе лучше закрепить материал и самостоятельно поработать с синтаксисом.
[Кликнуть здесь](https://www.w3schools.com/sql/trysql.asp?filename=trysql_op_in)
После перехода по ссылке можно будет увидеть сам редактор запросов и вывод данных в центральной части экрана, список таблиц базы данных находится в правой части.
#### Структура sql-запросов
Общая структура запроса выглядит следующим образом:
```
SELECT ('столбцы или * для выбора всех столбцов; обязательно')
FROM ('таблица; обязательно')
WHERE ('условие/фильтрация, например, city = 'Moscow'; необязательно')
GROUP BY ('столбец, по которому хотим сгруппировать данные; необязательно')
HAVING ('условие/фильтрация на уровне сгруппированных данных; необязательно')
ORDER BY ('столбец, по которому хотим отсортировать вывод; необязательно')
```
Разберем структуру. Для удобства текущий изучаемый элемент в запроса выделяется CAPS'ом.
#### SELECT, FROM
SELECT, FROM — обязательные элементы запроса, которые определяют выбранные столбцы, их порядок и источник данных.
Выбрать все (обозначается как \*) из таблицы Customers:
```
SELECT * FROM Customers
```
Выбрать столбцы CustomerID, CustomerName из таблицы Customers:
```
SELECT CustomerID, CustomerName FROM Customers
```
#### WHERE
WHERE — необязательный элемент запроса, который используется, когда нужно отфильтровать данные по нужному условию. Очень часто внутри элемента where используются IN / NOT IN для фильтрации столбца по нескольким значениям, AND / OR для фильтрации таблицы по нескольким столбцам.
Фильтрация по одному условию и одному значению:
```
select * from Customers
WHERE City = 'London'
```
Фильтрация по одному условию и нескольким значениям с применением IN (включение) или NOT IN (исключение):
```
select * from Customers
where City IN ('London', 'Berlin')
```
```
select * from Customers
where City NOT IN ('Madrid', 'Berlin','Bern')
```
Фильтрация по нескольким условиям с применением AND (выполняются все условия) или OR (выполняется хотя бы одно условие) и нескольким значениям:
```
select * from Customers
where Country = 'Germany' AND City not in ('Berlin', 'Aachen') AND CustomerID > 15
```
```
select * from Customers
where City in ('London', 'Berlin') OR CustomerID > 4
```
#### GROUP BY
GROUP BY — необязательный элемент запроса, с помощью которого можно задать агрегацию по нужному столбцу (например, если нужно узнать какое количество клиентов живет в каждом из городов).
При использовании GROUP BY обязательно:
1. перечень столбцов, по которым делается разрез, был одинаковым внутри SELECT и внутри GROUP BY,
2. агрегатные функции (SUM, AVG, COUNT, MAX, MIN) должны быть также указаны внутри SELECT с указанием столбца, к которому такая функция применяется.
Группировка количества клиентов по городу:
```
select City, count(CustomerID) from Customers
GROUP BY City
```
Группировка количества клиентов по стране и городу:
```
select Country, City, count(CustomerID) from Customers
GROUP BY Country, City
```
Группировка продаж по ID товара с разными агрегатными функциями: количество заказов с данным товаром и количество проданных штук товара:
```
select ProductID, COUNT(OrderID), SUM(Quantity) from OrderDetails
GROUP BY ProductID
```
Группировка продаж с фильтрацией исходной таблицы. В данном случае на выходе будет таблица с количеством клиентов по городам Германии:
```
select City, count(CustomerID) from Customers
WHERE Country = 'Germany'
GROUP BY City
```
Переименование столбца с агрегацией с помощью оператора AS. По умолчанию название столбца с агрегацией равно примененной агрегатной функции, что далее может быть не очень удобно для восприятия.
```
select City, count(CustomerID) AS Number_of_clients from Customers
group by City
```
#### HAVING
HAVING — необязательный элемент запроса, который отвечает за фильтрацию на уровне сгруппированных данных (по сути, WHERE, но только на уровень выше).
Фильтрация агрегированной таблицы с количеством клиентов по городам, в данном случае оставляем в выгрузке только те города, в которых не менее 5 клиентов:
```
select City, count(CustomerID) from Customers
group by City
HAVING count(CustomerID) >= 5
```
В случае с переименованным столбцом внутри HAVING можно указать как и саму агрегирующую конструкцию count(CustomerID), так и новое название столбца number\_of\_clients:
```
select City, count(CustomerID) as number_of_clients from Customers
group by City
HAVING number_of_clients >= 5
```
Пример запроса, содержащего WHERE и HAVING. В данном запросе сначала фильтруется исходная таблица по пользователям, рассчитывается количество клиентов по городам и остаются только те города, где количество клиентов не менее 5:
```
select City, count(CustomerID) as number_of_clients from Customers
WHERE CustomerName not in ('Around the Horn','Drachenblut Delikatessend')
group by City
HAVING number_of_clients >= 5
```
#### ORDER BY
ORDER BY — необязательный элемент запроса, который отвечает за сортировку таблицы.
Простой пример сортировки по одному столбцу. В данном запросе осуществляется сортировка по городу, который указал клиент:
```
select * from Customers
ORDER BY City
```
Осуществлять сортировку можно и по нескольким столбцам, в этом случае сортировка происходит по порядку указанных столбцов:
```
select * from Customers
ORDER BY Country, City
```
По умолчанию сортировка происходит по возрастанию для чисел и в алфавитном порядке для текстовых значений. Если нужна обратная сортировка, то в конструкции ORDER BY после названия столбца надо добавить DESC:
```
select * from Customers
order by CustomerID DESC
```
Обратная сортировка по одному столбцу и сортировка по умолчанию по второму:
```
select * from Customers
order by Country DESC, City
```
#### JOIN
JOIN — необязательный элемент, используется для объединения таблиц по ключу, который присутствует в обеих таблицах. Перед ключом ставится оператор ON.
Запрос, в котором соединяем таблицы Order и Customer по ключу CustomerID, при этом перед названиям столбца ключа добавляется название таблицы через точку:
```
select * from Orders
JOIN Customers ON Orders.CustomerID = Customers.CustomerID
```
Нередко может возникать ситуация, когда надо промэппить одну таблицу значениями из другой. В зависимости от задачи, могут использоваться разные типы присоединений. INNER JOIN — пересечение, RIGHT/LEFT JOIN для мэппинга одной таблицы знаениями из другой,
```
select * from Orders
join Customers on Orders.CustomerID = Customers.CustomerID
where Customers.CustomerID >10
```
Внутри всего запроса JOIN встраивается после элемента from до элемента where, пример запроса:
Другие типы JOIN'ов можно увидеть на замечательной картинке ниже:
В следующей части подробнее поговорим о типах JOIN'ов и вложенных запросах.
При возникновении вопросов/пожеланий, всегда прошу обращаться! | https://habr.com/ru/post/480838/ | null | ru | null |
# Как я использовал gem gon в Групоне
На днях я зарелизил новую версию своего gem [Gon](https://github.com/gazay/gon) – 4.0.0 и решил привести пару примеров его возможностей и использования. Данная библиотека служит для упрощения работы с данными в MVC архитектуре. Она позволяет работать с данными контроллера из JS пропуская шаги перекидывания этих данных через вью. На сегодняшний день существуют реализации гона для [RoR приложений](https://github.com/gazay/gon), [sinatra-like приложений](https://github.com/gazay/gon-sinatra) (sinatra, padrino, etc.) и для [.Net MVC](https://github.com/brooklynDev/NGon).
##### Карта в админке
Передо мной стояла задача — реализовать разделение предложений в Групоне по территориальным областям, которые бы мог редактировать администратор. Предложения из областей показываются людям которые живут в этих областях с большим приоритетом нежели предложения из других областей.
Решено было сделать в админке интерактивную карту на основе Яндекс.Карты, на которой должны отображаться точки предложений и области. Области можно добавлять и редактировать и их координаты соответственно будут храниться в базе данных. Яндекс.Карты предоставляют обширный API для рисования различных элементов на картах, мне подошли оттуда многоугольники для отображения областей и точки с тултипами для предложений. Скриншот ниже без точек предложений, тк секретная информация ;)
Я создал несколько моделей данных — CityArea для описывания сущности территориальной области в городе, CityAreaPoint для хранения координат точек из которых состоит CityArea, и AreaOffer — принадлежность предложения к определенной области. Подготовил страницу, JS для рисования областей, серверную логику для связывания объектов друг с другом и встал вопрос о выводе данных на страницу. Один из стандартных способов в MVC для меня – это выбрать нужные данные в экшене контроллера, отредактировать их до необходимого формата, записать в переменную конечный массив данных и далее во вью добавить элемент с data-атрибутом в который эти данные будут записаны и откуда будут считаны JS-ом. То есть я сделал тогда примерно вот так:
`app/controllers/admin/map_controller.rb`
```
@location = City.find(params[:city_id].to_i)
@offers = Offer.sorted.by_city(@location).by_day(params[:date])
@offers.map! do |offer|
points = offer.points.map do |point|
{
id: it.id,
longitude: it.longitude,
latitude: it.latitude
}
end
{
id: offer.id,
permalink: offer.permalink,
title: offer.short_title,
points: points
}
end
@city_areas = CityArea.find_by_city @location
@city_areas.map! do |area|
# то же что и с офферами почти
end
```
`app/views/admin/map/map.html.haml`
```
.data-container{ data: { areas: @city_areas.to_json, offers: @offers.to_json } }
```
`app/assets/javascripts/admin/map.js`
```
$('.data-container').data('offers')
...
```
Получился очень загруженный контроллер — слишком много кода, которого там не должно быть. Можно вынести в модель, но код останется все равно примерно таким. Я решил использовать свой gem gon который имеет поддержку темплейтов [rabl](https://github.com/nesquena/rabl) и [jbuilder](https://github.com/rails/jbuilder). Rabl — прекрасный gem, который отлично работает с коллекциями объектов и с ассоциациями объектов бд, поэтому код внутри шаблонов получается более оптимальным. Ну а гон позволяет использовать мощь rabl легко и просто:
`app/controllers/admin/map_controller.rb`
```
@location = City.find(params[:city_id].to_i)
@offers = Offer.sorted.by_city(@location).by_day(params[:date])
@city_areas = CityArea.find_by_city @location
gon.rabl template: 'app/rabl/offers.json.rabl', as: 'offers'
gon.rabl template: 'app/rabl/areas.json.rabl', as: 'areas'
```
`app/rabl/offers.json.rabl`
```
collection @offers => 'offers'
attributes :id, :permalink, :short_title
child :points do
attributes :id, :latitude, :longitude
end
```
`app/assets/javascripts/admin/map.js`
```
gon.offers
…
```
Таким образом затратив минимум усилий на преобразование данных и прокидывание этих данных в JS я получил «чистый» контроллер и массивы нужных мне данных в JS.
##### Gon gem
Помимо работы с шаблонами [rabl](https://github.com/nesquena/rabl) и [jbuilder](https://github.com/rails/jbuilder), гон отлично подходит для вывода каких-либо начальных данных или глобальных данных, которые задаются в любой точке проекта и доступны из любой точки проекта. То есть например если значение какой-то переменной должно быть на всех страницах проекта — достаточно задать эту переменную в инишалайзере. Для этого используется метод [gon.global](https://github.com/gazay/gon/wiki/Usage-gon-global), который работает аналогично с gon за исключением того что область видимости переменных записанных в него глобальная. В JS переменные доступны через неймспейс gon.global.
Кроме того, вчера я зарелизил версию 4.0.0 в которой появилась функциональность обновления данных в переменной без перезагрузки страницы — [gon.watch](https://github.com/gazay/gon/wiki/Usage-gon-watch). Новая функциональность позволяет обновлять данные как в цикле с промежутком в n-секунд, так и разово, ответом на какое-либо событие. В качестве примера я покажу как несколькими строками кода можно вывести в реальном времени результаты команды top:
Допустим у нас есть новое rails приложение. Для отображения терминального топа нам достаточно сделать следующее:
1. Добавляем в Gemfile строку `gem 'gon'` и запускаем `bundle install`
2. Добавляем контроллер с экшеном например home#foo, вью для него `app/views/home/foo.html.erb` и JS `app/assets/javascripts/home.js.coffee`
```
rails g controller home foo
```
3. В экшене контроллера `app/controllers/home_controller.rb` записываем в gon.watch переменную разовое выполнение команды top:
```
def foo
gon.watch.top = `top -l1`
end
```
4. В лэйауте `app/views/layouts/application.html.erb` добавляем хелпер с опцией watch в head:
```
<%= include\_gon(watch: true) %>
```
5. Во вью `app/views/home/foo.html.erb` добавляем тег, в котором у нас будет выводиться top:
```
```
6. В кофе файл добавляем код который у нас будет следить за переменной и обновлять содержимое тега pre:
```
$(document).ready ->
renewPre = (data) ->
$('pre').html(data.replace(/\\n/, "\n"))
gon.watch('top', interval: 1000, renewPre)
```
`gon.watch` принимает два или три параметра — название переменной, опции (опциональные), callback. В данном случае мы передали опцию `interval: 1000`, которая зациклит выполнение кода gon.watch с периодичностью в 1 секунду. Это означает, что каждую секунду `gon.watch` посылает запрос в экшн контроллера в котором была назначена переменная и возвращает актуальное значение, при успешном выполнении запроса вызывается callback, который в свою очередь переписывает содержимое тега pre. Чтобы остановить цикл существует функция gon.unwatch, которая принимает параметрами имя переменной и callback функцию. Естественно, если не передавать опцию `interval`, то цикла не будет, будет разовый запрос и в случае его успешности — разовый вызов callback-а.
Вот и все, запускаем `rails s`, открываем `0.0.0.0:3000/foo` — там у нас живой top. | https://habr.com/ru/post/148437/ | null | ru | null |
# Создаем свой кастомный плагин Style – Темизация Views в Drupal 8
Модуль [Views](https://www.drupal.org/node/1912118) (Представления) является составляющей ядра Drupal 8. На сегодняшний день об этом известно всем. Twig – это новый обработчик шаблонов в Drupal 8. Об этом нам тоже уже известно. Но как же программно взаимодействовать с модулем Views, для того чтобы темизировать View с использованием Twig? Кроме перекрывания шаблонов, как это происходит в любой другой системе модулей, у нас есть более мощная альтернатива в виде Views плагинов (Display, Style, Row и Field).
В данной статье мы разберемся, как в Drupal 8 создать Style плагин для Views. Мы используем разметку вкладок [Bootstrap](http://getbootstrap.com/javascript/#tabs) и реализуем вкладочный вывод наших результатов Views. В конфигурации Views, настройки Style позволят нам определить, какое поле будет использоваться как копия вкладочной навигации, и оставлять видимыми в соответствующих вкладках остальные поля. В целом, каждый результат View будет представлять собой вкладку, поэтому такой пример не подойдет для представлений, у которых слишком много результатов. Наша цель – продемонстрировать процесс создания собственного Style плагина в Drupal 8.
Мы не будем вдаваться в подробности того, как вы можете использовать Bootstrap в своих проектах. Но вы можете ознакомиться с документацией или некоторыми статьями, где описывается, как сделать так, чтобы на странице анонимного пользователя загружалась jQuery. И если вы хотите посмотреть на написанный нами код раньше времени, то можете найти его в [этом репозитории](https://github.com/upchuk/d8-demo-modules/tree/master/demo) в файле Demo module.
### Что такое Style плагин?
Style плагин отвечает за передачу списков. Яркими примерами **Style плагинов** являются Неформатированный список, Список HTML, Таблица или Сетка. Их использует плагин Display, а они в свою очередь используют плагины Row, которые представляют один пункт списка.
В Drupal 8, все типы плагинов Views построены с использованием новой системы плагинов и имеют общий функционал (все они наследуются из одного и того же **[PluginBase](https://api.drupal.org/api/drupal/core!lib!Drupal!Component!Plugin!PluginBase.php/class/PluginBase/8.2.x)**).
Давайте создадим такой же Style плагин, который может быть использован большинством типов Display (Page, Block и т.д) и который использует плагин Field.
### Style плагин Вкладки Bootstrap
Первый шаг – это создание нашего класса плагина в папке **Plugin/views/style** нашего модуля:
```
namespace Drupal\demo\Plugin\views\style;
use Drupal\Core\Form\FormStateInterface;
use Drupal\views\Plugin\views\style\StylePluginBase;
/**
* Views стиль, который передает разметку для Bootstrap вкладок.
*
* @ingroup views_style_plugins
*
* @ViewsStyle(
* id = "bootstrap_tabs",
* title = @Translation("Bootstrap Tabs"),
* help = @Translation("Uses the Bootstrap Tabs component."),
* theme = "demo_bootstrap_tabs",
* display_types = {"normal"}
* )
*/
class BootstrapTabs extends StylePluginBase {
/**
* Разрешает ли этот Style плагин Row плагины?
*
* @var bool
*/
protected $usesRowPlugin = TRUE;
/**
* Поддерживает ли Style плагин группировку строк?
*
* @var bool
*/
protected $usesGrouping = FALSE;
/**
* {@inheritdoc}
*/
protected function defineOptions() {
$options = parent::defineOptions();
$options['tab_nav_field'] = array('default' => '');
return $options;
}
/**
* {@inheritdoc}
*/
public function buildOptionsForm(&$form, FormStateInterface $form_state) {
parent::buildOptionsForm($form, $form_state);
$options = $this->displayHandler->getFieldLabels(TRUE);
$form['tab_nav_field'] = array(
'#title' => $this->t('The tab navigation field'),
'#description' => $this->t('Select the field that will be used as the tab navigation. The rest of the fields will show up in the tab content.'),
'#type' => 'select',
'#default_value' => $this->options['tab_nav_field'],
'#options' => $options,
);
}
}
```
Плагин Drupal, который мы создадим – это **ViewsStyle** с кое-какими базовыми данными о нем, переданными в аннотации. Не говоря о самых очевидных данных, у нас есть ключевые слова **theme** и **display\_types**, о которых стоит упомянуть. Theme объявляет какую функцию темы будет использовать плагин для передачи данных, а display\_types объявляет, каким видом плагинов Display может использоваться этот Style (в нашем случае все типы Display, если других не определено: normal). Если хотите узнать более подробную информацию о всех возможных конфигурациях Annotation, ознакомьтесь с **Drupal\views\Annotation\ViewsStyle** класса [Annotation](https://api.drupal.org/api/drupal/core!core.api.php/group/annotation/8.2.x).
Используя два свойства класса мы объявили, что наш плагин использует Row плагины, но не разрешает группирование. Убедитесь, что вы проверили все родительские и учли другие похожие опции. Например, класс, который мы наследуем, уже объявил, что поля Views могут быть использованы с плагином Style.
Как мы уже говорили ранее, используя два метода, мы создаем опцию плагина и элемент формы, которые могут определить, какое поле должно задействоваться в качестве навигации вкладки. Используя обработчик текущего состояния (**$this->displayHandler**), мы можем загрузить все доступные поля View, которые добавил движок сайта. И этот новый элемент формы будет доступен в форме настроек Style:
Поскольку мы наследуем с класса **StylePluginBase**, больше ничего делать не нужно. Для вывода разметки мы можем положиться на тему **demo\_bootstrap\_tabs**, которая получает подходящие переменные с исполненного View. Если сильно хочется, мы можем переопределить методы и добавить больше переменных, изменить тему и т.д. Но и параметры по умолчанию нам отлично подходят, а особенно, потому что мы реализуем препроцессор для обработки переменных, которые получает шаблон.
### Тема
Самое время определить тему **demo\_bootstrap\_tabs** , как мы это делаем обычно (внутри нашего файла .module):
```
/**
* Implements hook_theme().
*/
function demo_theme($existing, $type, $theme, $path) {
return array(
'demo_bootstrap_tabs' => array(
'variables' => array('view' => NULL, 'rows' => NULL),
'path' => drupal_get_path('module', 'demo') . '/templates',
),
);
}
```
Плагин Style по умолчанию передает шаблону объект $view и результат $rows . Обработка этих переменных (если это необходимо) перед тем, как передать шаблону – это задание препроцессора.
```
/**
* Подготовка переменных для шаблона представления demo_bootstrap_tabs.
*
* Шаблон: demo-bootstrap-tabs.html.twig.
*
* @param array $variables
* Ассоциативный массив содержит:
* - view: объект view.
* - row: массив пунктов rows. Каждый row – это массив из контента.
*/
function template_preprocess_demo_bootstrap_tabs(&$variables) {
$view = $variables['view'];
$rows = $variables['rows'];
$variables['nav'] = array();
// Подготовка навигации вкладок.
$field = $view->style_plugin->options['tab_nav_field'];
if (!$field || !isset($view->field[$field])) {
template_preprocess_views_view_unformatted($variables);
return;
}
$nav = array();
foreach ($rows as $id => $row) {
$nav[$id] = array(
'#theme' => 'views_view_field',
'#view' => $view,
'#field' => $view->field[$field],
'#row' => $row['#row'],
);
}
template_preprocess_views_view_unformatted($variables);
$variables['nav'] = $nav;
}
```
Что же происходит здесь? Во-первых, мы проверяем настройки плагина Style на предмет того, было ли использовано имя поля (того, которое было выбрано при конфигурировании View). Если нет, мы вызываем return, но только после того, как препроцессор выполнит функцию **template\_preprocess\_views\_view\_unformatted**. Далее, по результатам Views проходит цикл, и, в итоге, создается массив контента для нашей вкладочной навигации. Для этого, мы используем функцию темы **views\_view\_field** для того, чтобы передать выбранное поле. Наконец, мы передаем этот массив шаблону и запускаем препроцессор стиля неформатированного списка.
### Шаблон
В Drupal 8 больше нет функций тем, теперь все обрабатывается в шаблонах Twig. Давайте посмотрим, как файл **demo-bootstrap-tabs.html.twig** выглядит в нашей папке шаблонов модуля:
```
{% for tab in nav %}
{% set active = '' %}
{% if loop.index0 == 0 %}
{% set active = 'active' %}
{% endif %}
* [{{ tab }}](#tab-{{ loop.index0 }})
{% endfor %}
{% for row in rows %}
{% set active = '' %}
{% if loop.index0 == 0 %}
{% set active = 'active' %}
{% endif %}
{{ row.content }}
{% endfor %}
```
Как вы видите, это необходимая разметка для Bootstrap вкладок. Конечно, она не будет работать, если вы не загрузили в свою тему соответствующие стили и скрипты Bootstrap.
Первое, что мы передаем – это пункты навигации вкладок (из нашей переменной nav). Когда цикл перебирает этот массив, мы также извлекаем пользу из значения индекса цикла для того чтобы сделать первый пункт активным значением по умолчанию, а также для того, чтобы у нас была возможность нацеливаться на окна контента вкладок, используя уникальные ID. Что же касается реального значения пунктов, мы просто выводим передаваемый массив, который был создан в препроцессоре, и Drupal занимается его передачей. С учетом изложенного, возможно, хорошей идеей будет убедиться, что поле, которое вы здесь используете, относительно короткое, без ссылки и основной разметки. Названия, возможно, будут работать нормально. Но тут дело в соответствующей конфигурации View.
Внизу навигации, мы передаем актуальные rows, используя тот же индекс цикла для того, чтобы установить по умолчанию первый row как активную панель вкладки и уникально обозначить их, чтобы выше созданная навигация могла контролировать их видимость. Насчет контента, мы передаем полностью переменную row.content (которая была подготовлена внутри **template\_preprocess\_views\_view\_unformatted**), в которой хранятся все поля нашего View. И если мы не хотим включать поле, которое мы использовали для навигации, мы можем просто исключить его из показа в конфигурации View. Это поле по-прежнему будет появляться в навигации (потому что мы его там поместили), но не будет появляться в основной панели вкладки.
### Заключение
Ну вот и все. Views Style плагин для вывода результатов View в виде Bootstrap вкладок. Все, что нам необходимо сейчас – это убедиться, что зависимости Bootstrap загружены и конфигурируют наш View для использования Style плагина. Имейте в виду, что такой способ не подходит для Views с большим количеством результатов, и служит только в качестве примера создания плагинов Style.
Данная статья является переводом статьи "[Theming Views in Drupal 8 – Custom Style Plugins](https://www.sitepoint.com/theming-views-in-drupal-8-custom-style-plugins/)". | https://habr.com/ru/post/330704/ | null | ru | null |
# DISLIN — высокоуровневая библиотека визуализации пользовательских данных
Думаю каждый сталкивался с проблемой визуализации данных внутри своей программы. Особенно, если программа консольная. В топике я хочу рассказать о бесплатной (для некоммерческого использования) кроссплатформенной библиотеке [DISLIN](http://www.mps.mpg.de/dislin/overview.html), которая разработана [институтом исследований Солнечной системы имени М. Планка](http://www.mps.mpg.de/en/) (Германия). DISLIN может как просто отображать графики, так и сразу их сохранять в файлы. Разработчики заявляют возможность использования в *fortran, c/c++, Perl, Python, Java, .NET.*
Библиотека поддерживает следующие типы дисплеев: *VGA, X Windows, Windows API, OpenGL и Tektronix*; и следующие форматы файлов *GKSLIN, CGM, HPGL, PostScript, PDF, WMF, SVG, PNG, BMP, GIF, TIFF.* При этом поддерживается импорт изображений в TeX, что не может не радовать.
##### Что же умеет DISLIN?
* Построение двух- и трехмерных графиков и поверхностей.
* Построение кривых, в том числе заданных параметрически.
* Элементарные операции построения линий, векторов, полей и геометрических фигур с различными типами заливки.
* Работа с текстом: легенда, подписи и т. д.
* Построение двух- и трехмерных гистограмм и диаграмм.
* Построение карт (обычных и контурных) в различных проекциях.
* Создание своего GUI.
##### Как использовать?
Покажу на примере c#. Чтобы включить DISLIN в свой проект нужно:* Добавить в «References» файл disnet.dll. Все вызовы библиотеки собраны в классе dislin.
* Добавить в проект файл dislin.cs.
* В папку проекта положить библиотеку dislnc.dll.
Попробуем построить проекцию трехмерного графика на плоскость:
> `// Определили формат вывода графика: xwin - вывод на экран
>
> dislin.metafl ("xwin");
>
>
>
> // Инициализировали библиотеку DISLIN
>
> dislin.disini ();
>
>
>
> // Определим заголовок
>
> dislin.titlin ("3-D Colour Plot of the Function", 1);
>
> dislin.titlin ("f(x,y) = sin(x) \* cos(y)", 3);
>
>
>
> // Подписи осей
>
> dislin.name ("X-axis", "X");
>
> dislin.name ("Y-axis", "Y");
>
> dislin.name ("Z-axis", "Z");
>
>
>
> // Вывели заголовок
>
> dislin.title ();
>
>
>
> // Задали размеры осей
>
> dislin.ax3len(1000, 1000, 1000);
>
>
>
> // Строим систему координат
>
> dislin.graf3(0.0f, 360.0f, 0.0f, 90.0f, 0.0f, 360.0f, 0.0f, 90.0f, -2.0f, 2.0f, -2.0f, 1.0f);
>
>
>
> // Выводим график. В массиве func хранятся предвычисленные значения функции
>
> dislin.crvmat(func, n, n, 1, 1);
>
>
>
> // Завершили работу с DISLIN
>
> dislin.disfin ();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А вот, что получилось:
Теперь построим обычный двумерный график:
> `dislin.titlin("CURVE", 1);
>
> dislin.titlin("SIN^2(X), SIN(X) + COS(X)", 3);
>
>
>
> dislin.graf(0.0f, 360.0f, 0.0f, 90.0f, -2.0f, 2.0f, -1.0f, 0.5f);
>
> dislin.title();
>
>
>
> //Построим 2 кривые
>
> dislin.color("red");
>
> dislin.curve(xPoints, func1, n);
>
> dislin.color("green");
>
> dislin.curve(xPoints, func2, n);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
График в полярных координатах:
> `dislin.polar(1.0f, 0.0f, 0.2f, 0.0f, 30.0f);
>
> dislin.curve(xPoint, func, n);
>
> \* This source code was highlighted with Source Code Highlighter.`
И наконец, трехмерная поверхность:
> `dislin.view3d (-5.0f, -5.0f, 4.0f, "ABS");
>
> dislin.graf3d (0.0f, 360.0f, 0.0f, 90.0f, 0.0f, 360.0f, 0.0f, 90.0f,
>
> -3.0f, 3.0f, -3.0f, 1.0f);
>
>
>
> dislin.color ("red");
>
> //Задаем поверхность
>
> dislin.surmat (func, n, m, 1, 1);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы сразу сохранить график в файл, необходимо в функции metafl задать желаемое расширение, например:
> `dislin.metafl ("png");`
В папке с программой появится файл dislin.png с картинкой.
###### Минусы библиотеки:
* Фигура получается статичной: нельзя повращать трехмерную поверхность или изменить масштаб. Хотя параметры проекции настраиваются.
* Нет поддержки русского языка. Приходится подписи делать по-английски.
##### Что еще почитать?
Много примеров приведено на официальном сайте библиотеки: [www.mps.mpg.de/dislin/examples.html](http://www.mps.mpg.de/dislin/examples.html)
Также можете посмотреть пользовательскую [галерею](http://www.mps.mpg.de/dislin/gallery.html).
Презентация от разработчиков (англ.): [www.mps.mpg.de/dislin/dislin.ppt](http://www.mps.mpg.de/dislin/dislin.ppt)
Онлайн руководство (англ.): [www.mps.mpg.de/dislin/manual.html](http://www.mps.mpg.de/dislin/manual.html)
Краткий справочник по функциям (англ.): [www.mps.mpg.de/dislin/appa.html](http://www.mps.mpg.de/dislin/appa.html)
**Ссылка для скачивания (v. 10.1)**: [www.mps.mpg.de/dislin/downloads.html](http://www.mps.mpg.de/dislin/downloads.html)
> Между прочим, библиотеке DISLIN уже 25 лет. Первая версия вышла в свет в декабре 1986г. | https://habr.com/ru/post/125611/ | null | ru | null |
# PHP-Дайджест № 176 (11 – 23 марта 2020)
[](https://habr.com/ru/post/493594/)
Свежая подборка со ссылками на новости и материалы. В выпуске: обновления PHP и Composer 1.10, переносы конференций, 3 новых RFC предложения из PHP Internals, порция полезных инструментов, видео, подкасты и многое другое.
Приятного чтения!
### Новости и релизы
* [PHP 7.4.4](https://www.php.net/ChangeLog-7.php#7.4.4), [PHP 7.3.16](https://www.php.net/ChangeLog-7.php#7.3.16), [PHP 7.2.29](https://www.php.net/ChangeLog-7.php#7.2.29) — Секьюрити релизы, всем рекомендуется обновиться.
* [Composer 1.10.0](https://github.com/composer/composer/releases/tag/1.10.0) — Среди прочих изменений, добавлено новое поле «funding» в composer.json, в котором можно указать, как поддержать проект. По умолчанию данные берутся из FUNDING.yml на GitHub. Также добавлена новая команда `composer fund`, которая показывает информацию о спонсорстве для ваших зависимостей.
* **Перенос мероприятий**
В связи с эпидемией и ограничительными мерами, многие мероприятия перенесены или переходят в онлайн.
• [PHP Russia](https://rmcreative.ru/blog/post/php-russia-online-i-perenos-php-russia) – Конференция перенесена, а 13 мая пройдёт первая PHP Russia Online.
•  [Митапы PHP-сообществ в марте, которые переходят в онлайн или переносятся](https://habr.com/ru/company/skyeng/blog/492038/).
• Переходят в онлайн: [Laracon EU Madrid](https://laracon.eu/2020/tickets), [Midwest PHP](https://midwestphp.org/stream).
### PHP Internals
* [[RFC] str\_contains](https://wiki.php.net/rfc/str_contains) — Предложение [принято](https://t.me/phpdigest/127). Функция `str_contains()` будет проверять, содержится ли строка в другой строке.
* [[RFC] throw expression](https://wiki.php.net/rfc/throw_expression) — В PHP нельзя бросить исключение из стрелочной функции, потому что `throw` – это оператор, а не выражение. Предлагается сделать его выражением и тогда возможно будет использование в коротких лямбдах, в тернарных операторах и других конструкциях:
```
$callable = fn() => throw new Exception();
$value = $nullableValue ?? throw new InvalidArgumentException();
$value = $falsableValue ?: throw new InvalidArgumentException();
$value = !empty($array)
? reset($array)
: throw new InvalidArgumentException();
```
* [[RFC] Compact Object Property Assignment](https://wiki.php.net/rfc/compact-object-property-assignment) — Предлагается добавить компактный синтаксис для присвоения значений нескольким свойствам объекта в одном выражении. Идея уже раньше рассматривалась в рамках [[RFC] Object Initializer](https://wiki.php.net/rfc/object-initializer), но не прошла голосование. На этот раз синтаксис весьма странный:
```
doTheFoo((new Foo)->[
a = 1,
b = 2,
c = 3,
]);
// Эквивалентно:
$myObj = new Foo();
$myObj->a = 1;
$myObj->b = 2;
$myObj->c = 3;
doTheFoo($myObj);
```
* [[RFC] Is Literal Check](https://wiki.php.net/rfc/is_literal) — Предлагается добавить функцию `is_literal()`, чтобы разработчики/фреймворки могли быть уверены, что они работают с безопасным значением, то есть созданным из одного или нескольких литералов, опредёленных в PHP, а не сформированных динамически из пользовательского ввода.
```
define('TABLE', 'example');
$sql = 'SELECT * FROM ' . TABLE . ' WHERE id = ?';
is_literal($sql); // Returns true
$sql .= ' AND id = ' . mysqli_real_escape_string($db, $_GET['id']);
is_literal($sql); // Returns false
```
К предложению много вопросов, и реализация нетривиальная. Похоже, шансов мало.
* [[RFC] Write-Once Properties](https://wiki.php.net/rfc/write_once_properties) — Судя по ходу голосования за неизменяемые свойства, предложение в текущем виде не преодолеет порог. Одним из основных аргументов против является тот факт, что свойства, объявленные неизменяемыми, нельзя будет изменить даже изнутри класса.
* Отличный [репозиторий](https://github.com/Danack/RfcCodex) с описанием всех непринятых RFC пополнился статьёй [о пропуске дефолтных значений](https://github.com/Danack/RfcCodex/blob/master/explicit_defaults.md) при вызове функций.
Все статьи содержат описания трудностей и прогнозы дальнейшей судьбы.
Ещё [автор](https://twitter.com/MrDanack) добавил статью [Understanding RFC attitudes](https://github.com/Danack/RfcCodex/blob/master/rfc_attitudes.md) о том, почему вообще какие-то предложения проходят, а какие-то нет, и как участники PHP Internals оценивают RFC.
### Инструменты
* [async-aws/aws](https://github.com/async-aws/aws) — Легковесная и асинхронная альтернатива официальному SDK для AWS.
* [lisachenko/z-engine](https://github.com/lisachenko/z-engine) — [NightTiger](https://habr.com/ru/users/nighttiger/) продолжает демонстрировать все новые возможности PHP благодаря FFI.
В документации [пример создания расширения](https://github.com/lisachenko/z-engine/#creating-php-extensions-in-runtime) для PHP на PHP, с помощью которого данные можно сохранять в памяти между запросами.
* [Badcow/DNS](https://github.com/Badcow/DNS) — Объектное представление записей DNS в PHP, а также парсер и билдер записей.
* [yswery/PHP-DNS-SERVER](https://github.com/yswery/PHP-DNS-SERVER) — И полноценный DNS-сервер, написанный полностью на PHP с использованием предыдущей библиотеки.
* [nikolaposa/rate-limit](https://github.com/nikolaposa/rate-limit) — Рейт-лимитер общего назначения с бекендом на Redis.
* [Spartaques/phpkafkacore](https://github.com/Spartaques/phpkafkacore) — Библиотека для работы с Kafka.
### Symfony
* [Новое в Symfony 5.1](https://symfony.com/blog/category/living-on-the-edge) — Среди прочего будет добавлена возможность [автовнедрения зависимостей](https://symfony.com/blog/new-in-symfony-5-1-autowire-public-typed-properties) через указание типа публичного свойства.
* [symfony/uid](https://github.com/symfony/uid) — Новый экспериментальный компонент Symfony, для генерации UUID.
* [Неделя Symfony #689 (16-22 марта 2020)](https://symfony.com/blog/a-week-of-symfony-690-16-22-march-2020)
### Laravel
* Вышел [Laravel 7.1.2](https://blog.laravel.com/security-laravel-712-released) с фиксом XSS-уязвимости.
* В связи со спором о товарном знаке в отношении названия «Airlock» пакет [Airlock переименован в Sanctum](https://blog.laravel.com/airlock-renamed-to-sanctum).
* [grosv/eloquent-sheets](https://github.com/grosv/eloquent-sheets) — Позволяет использовать Google-таблицы в качестве источника данных для Eloquent.
*  [Принцип DRY на примере Laravel](https://habr.com/ru/post/491728/).
*  [Продвинутые советы по Маршрутизации в Laravel](https://laravel.demiart.ru/routing-advanced-tips/).
*  [Серия видеороликов](https://divinglaravel.com/explaining-laravel-queue-configuration-keys) с объяснением конфигурационных ключей для очередей в Laravel.
### Async PHP
* [reactphp/socket 1.4.0](https://github.com/reactphp/socket) — В релизе [добавлена поддержка IPv6](https://clue.engineering/2020/introducing-ipv6-for-reactphp).
*  [Продолжение бесед Сергея Жука с Marc Morera](https://www.youtube.com/watch?v=2F4Yw2J0p8E) (автором [DriftPHP](https://github.com/driftphp)) об асинхронном PHP и на этот раз в контексте CQRS.
### Материалы для обучения
* [PHP reimagined](https://stitcher.io/blog/php-reimagined) — Прагматичная подборка изменений, которые могли бы сделать PHP лучше.
* [Event driven server in PHP](https://stitcher.io/blog/event-driven-php) — Впечатления от разработки EventSourcing приложения, в котором все агрегаты и проекции загружаются в память и никогда не хранятся на диске.
* [О графе потока управления в PHP](https://www.silverf0x00.com/getting-started-with-php-cfg/) и использовании [ircmaxell/php-cfg](https://github.com/ircmaxell/php-cfg).
* [Об этикете Composer пакетов](https://sebastiandedeyne.com/composer-semver-and-underlying-dependency-changes/) и когда стоит изменять мажорную версию семвера, а когда нет.
* Подробная [инструкция по созданию окружения на базе Docker](https://guille.cloud/build-a-docker-development-environment-for-php-projects/index.html).
* [Как научить Codeception прыгать к определениям методов хелперов и модулей](https://medium.com/@ivastly/how-to-teach-phpstorm-to-go-to-implemenation-of-codeception-modules-and-helpers-6acb81d41348) в PhpStorm — Прислал [catanfa](https://habr.com/ru/users/catanfa/).
* [Сравнение и бенчмарки JSON и MessagePack](https://thephp.website/en/issue/messagepack-vs-json-benchmark/).
*  [NoVerify: PHP-линтер, который работает быстро](https://habr.com/ru/company/oleg-bunin/blog/487260/).
*  [Обработка миллионов событий в сутки при помощи каскадов очередей](https://habr.com/ru/company/manychat/blog/492964/).
### Аудио/Видео
*  [Между скобок](https://soundcloud.com/between-braces) — Новый подкаст про PHP на русском! В [первом эпизоде](https://soundcloud.com/between-braces/1-dmitriy-kosov-o-pereezde-legasi-prilozheniya-s-zend-na-symfony) про перенос легаси приложения с Zend на Symfony без остановки разработки.
*  [Онлайн-митап про PHP и удалёнку](https://www.youtube.com/watch?v=WwINpXxxWMU)
*  [Видеозаписи с BeerPHP SPb Meetup](https://www.youtube.com/channel/UC7HeLRn5kBpu1o-MiAcvCyw/videos)
*  [PHP Internals News #44](https://phpinternals.news/44) — О [неизменяемых свойствах](https://wiki.php.net/rfc/write_once_properties) с [Máté Kocsis](https://twitter.com/kocsismate90).
*  [PHP Internals News #45](https://phpinternals.news/45) — С Никитой Поповым о [дальнейшем развитии PHP](https://github.com/nikic/php-rfcs/blob/language-evolution/rfcs/0000-language-evolution.md).
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 175](https://habr.com/ru/post/491660/) | https://habr.com/ru/post/493594/ | null | ru | null |
# Dispose pattern
*“Не стоит следовать некоторой идиоме только потому, что так делают все или так где-то написано”**Мысли автора статьи во время чтения и рефакторинга чужого кода*
Ни для кого не будет секретом, что платформа .NET поддерживает автоматическое управление памятью. Это значит, что если вы создадите объект с помощью ключевого слова **new**, то вам не нужно будет самостоятельно заботиться о его освобождении. Сборщик мусора определит «достижимость» объекта, и если на объект не осталось корневых ссылок, то он будет освобожден. Однако, как только речь заходит о ресурсах, таких как сокет, буфер неуправляемой памяти, дескриптор операционной системы и т.д., то сборщик мусора, по большому счету, умывает руки и весь головняк по работе с такими ресурсами ложится на плечи разработчика.
А как же финализаторы? – спросите вы. Ну, да, есть такое дело, финализаторы действительно предназначены для освобождения ресурсов, но проблема в том, что время их вызова не детерминировано, а это значит, что никто не знает, когда они будут вызваны и будут ли вызваны вообще. Да и порядок вызова финализаторов не определен, поэтому при вызове финализатора некоторые «части» вашего объекта уже могут быть «разрушены», поскольку их финализаторы уже были вызваны. В общем, финализаторы – они-то есть, но это скорее «страховочный трос», а не нормальное средство управления ресурсами.
#### Идиома RAII
В языке С++, в котором нет никаких встроенных средств для автоматического управления памятью помимо умных указателей, уже давно активно применяется паттерн (или идиома) для своевременного освобождения ресурсов (\*). Эта идиома носит название «Захват ресурса есть инициализация» (RAII — Resource Acquisition Is Initialization) и заключается в следующем. Ресурс захватывается в конструкторе и освобождается в деструкторе, а поскольку деструкторы вызываются автоматически, то и дополнительных усилий по управлению ресурсами больше не требуется.
Не удивительно, что эта же идея детерминированного управления ресурсами перекачивала и в другие более «умные» и «управляемые» среды, такие как .NET или Java (\*\*) в виде интерфейса **IDisposable** (в языке C#) и метода **dispose** (в Java). Но, поскольку эти среды более умные, по сравнению со старичком С++, и основные проблемы, связанные с управлением памятью, в них решены, то переехала эта идиома не слишком хорошо. Нет, поймите меня правильно, переехала она вполне успешно, но для этого вам нужно использовать блок **using** (для языка C#) или **try****-****with****-****resources****statement** (в Java 7), если же вы «забудете» ими воспользоваться, то от вашего детерминированного освобождения ресурсов не останется и следа.
> `// Открываем файл внутри блока using
>
> using (FileStream file = File.OpenRead("foo.txt"))
>
> {
>
> // Выходим из функции при выполнении некоторого условия
>
> if (someCondition) return;
>
> // Файл будет закрыт автоматически при выходе из блока using
>
> }
>
> // А что, если кто-то откроет файла вне блока using?
>
> FileStream file2 = File.OpenRead("foo.txt");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Однако это не единственная сложность, которая возникает при работе с ресурсами в .NET. Как мы вскоре увидим, использование обычного метода для освобождения ресурсов обладает и некоторыми другими проблемами. Поскольку метод **Dispose** освобождает ресурсы, то вызов финализатора уже не нужен и его нужно отменить, кроме того, метод **Dispose** разрушает инвариант класса, что дает пользователю возможность получить разрушенный или частично разрушенный объект. А это требует дополнительных проверок как в методе **Dispose**, так и во всех публичных методах класса.
Все это привело к тому, что относительно простая идиома RAII вылилась на платформе .NET в паттерн, который так и называется “Dispose паттерн”. Однако прежде чем переходить к его рассмотрению, давайте рассмотрим два типа ресурсов, существующие на платформе .NET: управляемые и неуправляемые ресурсы.
#### Управляемые и неуправляемые ресурсы
В .NET существует два типа ресурсов: управляемые и неуправляемые. Причем отличить их довольно просто: к неуправляемым ресурсам относятся только «сырые» ресурсы, типа **IntPtr**, сырые дескрипторы сокетов или что-то в этом духе; если же с помощью идиомы RAII этот ресурс упаковали в объект, захватывающий его в конструкторе и освобождающий в методе **Dispose**, то такой ресурс уже является управляемым. По сути, управляемые ресурсы – это «умные оболочки» для неуправляемых ресурсов, для освобождения которых не нужно вызывать какие-то хитроумные функции, а достаточно вызвать метод **Dispose** интерфейса **IDisposable**.
> `class NativeResourceWrapper : IDisposable
>
> {
>
> // IntPtr – описатель неуправляемого ресурса
>
> private IntPtr nativeResourceHandle;
>
> public NativeResourceWrapper()
>
> {
>
> // «Захватываем» неуправляемый ресурс путем вызова специальной функции
>
> nativeResourceHandle = AcquireNativeResource();
>
> }
>
> public void Dispose()
>
> {
>
> // Освобождаем захваченный ресурс, опять же, путем вызова какой-то
>
> // специальной функции
>
> ReleaseNativeResource(nativeResourceHandle);
>
> }
>
> // Есть еще и финализатор, но его роль будет раскрыта позднее
>
> ~NativeResourceWrapper() {...}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом, любой объект может владеть ресурсами двух типов: он может непосредственно содержать неуправляемый ресурс (например**,** **IntPtr**) или же он может содержать ссылку на управляемый ресурс (например, **NativeResourceWrapper**), при этом в обоих случаях объект, содержащий один из этих ресурсов, сам становится управляемым ресурсом. Это может показаться не слишком принципиальным, но понимать разницу между двумя типами ресурсов очень важно, поскольку работать с ними приходится по-разному.
#### Dispose pattern
Итак, мы знаем, что объект может владеть двумя типами ресурсов: **управляемыми** и **неуправляемыми**; а также то, что у нас есть два способа освобождения ресурсов: **детерминированный**, с помощью метода **Dispose** и **недетерминированный**, с помощью финализатора (\*\*\*). А теперь давайте посмотрим, как со всем этим добром жить и, главное, как это добро освобождать.
Идея Dispose паттерна состоит в следующем: давайте мы всю логику освобождения ресурсов поместим в отдельный метод, и будем вызывать его и из метода **Dispose**, и из финализатора, при этом, давайте добавим флажок, который бы говорил нам о том, кто вызвал этот метод. Поскольку эта простая идея содержит довольно большое количество подробностей, то давайте изложим Dispose паттерн по пунктам.
1. Класс, содержащий управляемые или неуправляемые ресурсы реализует интерфейс **IDisposable**
> `class Boo : IDisposable { ... }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
2. Класс содержит метод **Dispose****(****bool****disposing****)**, который и делает всю работу по освобождению ресурсов; параметр **disposing** говорит о том, вызывается ли этот метод из метода **Dispose** или из финализатора. Этот метод должен быть **protected****virtual** для не-sealed классов и **private** для sealed классов
> `// Для не-sealed классов
>
> protected virtual void Dispose(bool disposing) {}
>
>
>
> // Для sealed классов
>
> private void Dispose(bool disposing) {}
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
3. Метод Dispose всегда реализуется следующим образом: вначале вызывается метод **Dispose****(****true****)**, а затем может следовать вызов метода **GC****.****SuppressFinalize****()**, который предотвращает вызов финализатора.
> `public void Dispose()
>
> {
>
> Dispose(true /\*called by user directly\*/);
>
> GC.SuppressFinalize(this);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Метод **GC****.****SuppressFinalize****()**, во-первых, должен вызываться после вызова **Dispose****(****true****)**, а не перед ним, поскольку если метод **Dispose****(****true****)** «упадет» с исключением, то выполнение финализатора не отменится. Во-вторых, **GC****.****SuppressFinalize****()** должен вызываться даже для классов, не содержащих финализаторы, поскольку финализатор может появиться у его наследника (т.е. мы должны вызывать метод **GC****.****SuppressFinalize****()** во всех не-sealed классах).
4. Метод **Dispose****(****bool****disposing****)** содержит две части: (1) если этот метод вызван из метода **Dispose** (т.е. параметр **disposing** равен **true**), то мы освобождаем управляемые и неуправляемые ресурсы и (2) если метод вызван из финализатора во время сборки мусора (параметр **disposing** равен **false**), то мы освобождаем только неуправляемые ресурсы.
> `void Dispose(bool disposing)
>
> {
>
> if (disposing)
>
> {
>
> // Освобождаем только управляемые ресурсы
>
> }
>
>
>
> // Освобождаем неуправляемые ресурсы
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
5. (ОПЦИОНАЛЬНО) Класс может содержать финализатор и вызывать из него **Dispose****(****bool****disposing****)** передавая **false** в качестве параметра.
> `~Boo()
>
> {
>
> Dispose(false /\*not called by user directly\*/);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Не забывайте, что финализатор может быть вызван даже для частично сконструированных объектов, если конструктор этого класса сгенерирует исключение. Так что код очистки неуправляемых ресурсов должен учитывать то, что ресурсы еще не захвачены (\*\*\*\*).
6. (ОПЦИОНАЛЬНО) Класс может содержать поле **bool** **\_****disposed**, которое говорит о том, что ресурсы объекта уже освобождены. Disposable-классы должны спокойно позволять повторный вызов метода **Dispose**, а также генерировать исключение при доступе к любым другим публичным методам или свойствам (поскольку инвариант объекта уже разрушен).
> `void Dispose(bool disposing)
>
> {
>
> if (disposed)
>
> return; // Ресурсы уже освобождены
>
> // Освобождаем ресурсы
>
> disposed = true;
>
> }
>
>
>
> public void SomeMethod()
>
> {
>
> if (disposed)
>
> throw new ObjectDisposedException();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
7. (ОПЦИОНАЛЬНО) Класс может наследовать от **CriticalFinalizerObject**, если предыдущих шести пунктов мало и вы хотите большей экзотики. Наследование от этого класса дает вам дополнительные гарантии:
1. Финализатор таких классов компилируется JIT-компилятором сразу при конструировании экземпляра, а не отложено по мере необходимости. Это дает возможность успешно выполниться финализатору даже в случае острой нехватки памяти.
2. Как мы уже говорили, CLR не гарантирует порядок вызова финализаторов, что делает невозможным обращение внутри финализатора к другим объектам, содержащим неуправляемые ресурсы. Однако CLR гарантирует что финализаторы «простых смертных» объектов будут вызваны **до** наследников **CriticalFinalizerObject**. Это дает возможность, в частности, из финализаторов ваших классов (если они не наследуют от **CriticalFinalizerObject**) обращаться к полю **SafeHandle**, которое точно будет освобождено позднее.
3. Финализаторы таких классов будут вызваны даже в случае экстренной выгрузки домена приложения.
> `// А вы уверены, что оно вам нужно?
>
> class Foo : CriticalFinalizerObject {}
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Прагматичный взгляд на Dispose паттерн
Если вам показалось, что работа с ресурсами в .NET неоправдано сложна, то у меня по этому поводу есть две новости: одна хорошая, а другая – не очень. Новость «не очень» заключается в том, что работа с ресурсами даже сложнее, чем здесь описано (\*\*\*\*\*), хорошая же заключается в том, что в большинстве случаев вся эта сложность нас с вами касаться практически не будет.
Вся сложности реализации Dispose паттерна связаны с предположением о том, что один и тот же класс (или иерархия классов) может одновременно содержать как управляемые, так и неуправляемые ресурсы. Но давайте подумаем, а зачем вообще нам может понадобиться хранить неуправляемые ресурсы напрямую в классах бизнес-логики? А как же пресловутые **Принципы Единой Ответственности** (SRP – Single Responsibility Principle) и **Здравого Смысла**? Идиома RAII, описанная ранее, успешно используется десятки лет и предназначена как раз для таких случаев: **если у вас есть неуправляемый ресурс, то вместо того, чтобы работать с ним напрямую, оберните его в управляемую оболочку и работайте уже с нею**.
Если посмотреть на .NET Framework, то можно заметить, что там используется именно такой подход: для всех ресурсов создается оболочка, которая прячет внутри всю сложность по работе с ресурсами, предоставляя пользователю лишь вызвать метод **Dispose** для явной очистки ресурсов (ну, и финализатор, на всякий случай). Кроме того, для большей части неуправляемых ресурсов операционной системы такие оболочки уже сделаны, и изобретать велосипед не нужно.
Все это я веду к тому, что **не нужно смешивать в вашем коде бизнес-логику и логику по работе с неуправляемыми ресурсами**. И то, и другое достаточно сложно само по себе и заслуживает отдельного класса. Вот и получается, что данный паттерн «оптимизирован» на очень редкий случай (что класс может содержать и управляемые и неуправляемые ресурсы), при этом делая наиболее распространенный случай, когда класс содержит только управляемые ресурсы, очень неудобной в реализации и сопровождении.
#### Упрощенная версия Dispose паттерна
Если мы с вами знаем, что ни один человек не собирается смешивать управляемые и неуправляемые ресурсы в одном месте, так почему бы не реализовать это в коде явным образом? Мы можем оставить метод **Dispose** и вместо дополнительного метода Dispose с совсем невнятным булевым параметром, добавить виртуальный метод **DisposeManagedResources**, имя которого будет четко говорить о том, что мы должны освободить именно управляемые ресурсы. Модификатор доступа этого метода должен быть аналогичным нашему методу **Dispose(****bool)**, т.е. **protected** **virtual** для не-sealed классов или **private** для sealed классов.
> `class SomethingWithManagedResources : IDisposable
>
> {
>
> public void Dispose()
>
> {
>
> // Никаких Dispose(true) и никаких вызовов GC.SuppressFinalize()
>
> DisposeManagedResources();
>
> }
>
>
>
> // Никаких параметров, этот метод должен освобождать только неуправляемые ресурсы
>
> protected virtual void DisposeManagedResources() {}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
С первого взгляда такой подход может показаться слишком уж прагматичным, однако посудите сами: в книге [Framework Design Guidelines](http://sergeyteplyakov.blogspot.com/2009/06/framework-design-guidelines-2nd-edition.html) описанию Dispose паттерна посвящено два десятка страниц, при этом ее авторы рекомендуют добавлять финализаторы только в случае острой необходимости. При этом все мы знаем, что смешивать два типа ресурсов в одном классе плохо, но все же следуем паттерну, который это поощряет, а не запрещает.
#### **Заключение**
При разработке библиотечных классов или бизнес-классов, которые будут использоваться в десятке других проектов, то следовать всем описанным выше принципам вполне разумно. К повторно используемому коду предъявляются другие требования и при их проектировании нужно следовать другим принципам: простота в использовании и расширяемость таких классов значительно важнее стоимости сопровождения.
Если же вы проектируете классы бизнес-логики или простые библиотеки с ограниченным кругом пользователей, то можно не морочить себе голову с «канонами», а использовать упрощенную версию этого паттерна, которая работает только с управляемыми ресурсами.
------------------------------
(\*) В С++, в отличие от C#, память тоже является ресурсом. Поэтому идиома RAII в языке С++ применяется как для освобождения динамически выделенной памяти, так и для освобождения любых других ресурсов, типа дескрипторов ОС или сокетов.
(\*\*) В Java 7 наконец-то появилась конструкция, аналогичная конструкции **using** языка C#: try-with-resource statement
(\*\*\*) К сожалению в языке C# для финализаторов выбран тот же самый синтаксис (тильда, за которой идет имя класса), который используется для деструкторов в языке С++. Но семантика деструктора и финализатора очень разная, поскольку деструктор подразумевает детерминированное освобождение ресурсов, а финализатор – нет.
(\*\*\*) Да, это еще одно отличие в поведении .NET и языка С++. В последнем, деструктор вызывается только для полностью сконструированного объекта, при этом вызываются деструкторы для всех полностью сконструированных его полей.
(\*\*\*\*) Здесь я, например, не говорил о том, как можно получить «утечку ресурсов» при появлении исключений или о проблемах с изменяемыми значимыми типами, реализующими интерфейс **IDisposable**. Об этом я уже писал ранее в заметках «[Гарантии безопасности исключений](http://sergeyteplyakov.blogspot.com/2011/08/blog-post_15.html)» и «[О вреде изменяемых значимых типов](http://sergeyteplyakov.blogspot.com/2011/07/blog-post.html)» соответственно. | https://habr.com/ru/post/129283/ | null | ru | null |
# Многопоточное программирование в Android с использованием RxJava 2
Если вы новичок в общении с RxJava или пытались разобраться в этом, но не довели дело до конца, то ниже вы найдете для себя кое-что новое.
*Оригинал статьи написан 29 ноября 2017. Перевод вольный.*
Нам в GO-JEK требуется выполнять большое количество асинхронных операций в приложениях и мы не можем позволить себе идти на компромиссы в ущерб скорости работы и плавности пользовательского интерфейса.
Написание сложных многопоточных Android приложений может быть достаточно трудоемким процессом, который время от времени будет вас сильно перегружать из-за необходимости заботиться о большом количестве связанных друг с другом вещей. Это и многие другие причины убедили нас использовать RxJava в разрабатываемых Android приложениях.
В этой статье мы поговорим о том как мы использовали реальные возможности работы с многопоточностью в RxJava для того, чтобы сделать процесс разработки приложения максимально простым, легким и веселым. Во всех примерах кода ниже будет использоваться RxJava 2, но описанные концепции можно будет применять и в других [реактивных расширениях](http://reactivex.io/).
### Почему реактивное программирование?
Каждая статья о реактивном программировании начинается с такого обязательного блока и мы не нарушим эту традицию. Существует несколько преимуществ использования реактивного подхода к построению Android приложений, обратим внимание на те, которые вам *действительно* нужны.
#### Никаких больше обратных вызовов
Если вы давно разрабатываете под Android, то, должно быть, заметили, как быстро вещи становятся чересчур сложными и неподконтрольными с использованием вложенных обратных вызовов.
Это происходит, когда вы выполняете несколько асинхронных операций последовательно и хотите, чтобы дальнейшие действия зависели от результата предыдущих операций. Почти сразу код становится слишком перегруженным и сложным для поддержки.
#### Простой контроль ошибок
В императивном мире, в ситуации когда выполняется множество сложных асинхронных операций, ошибки могут возникать в большом количестве мест. И в каждом месте вы должны обрабатывать эти ошибки, в результате появляется много повторяющегося шаблонного кода, методы становятся громоздкими.
#### Очень простое использование многопоточности
Все мы знаем (и тайно признаем) насколько иногда сложной может быть работа с многопоточностью в Java. Например, выполнение части кода в фоновом потоке и возврат результата обратно в главный поток. Это только звучит просто, но на практике появляется много подводных камней, которые нужно обходить.
**RxJava делает безумно легким выполнение нескольких сложных операций в любом потоке** на ваш выбор, заботясь о корректной синхронизации и позволяя без проблем переключаться между потоками.
Преимущества RxJava бесконечны. Мы можем говорить об этом часами и адски утомить вас, но вместо этого давайте копнем глубже и начнем изучать реальную работу с многопоточностью в RxJava.
### RxJava НЕ многопоточна по умолчанию
***Да, вы прочли всё верно.*** RxJava по умолчанию не многопоточна в любом случае. Определение, данное для RxJava на официальном сайте, выглядит примерно следующим образом:
*«Библиотека для составления асинхронных и основанных на событиях программ с использованием последовательностей *(observable sequences)* для виртуальной Java машины».*
Увидев слово «асинхронных», многие люди ошибочно полагают, что RxJava многопоточна по умолчанию. Да, RxJava поддерживает многопоточность, предлагает множество мощных возможностей для легкой работы с асинхронными операциями, но это не значит что поведение RxJava по умолчанию многопоточно.
Если вы уже немного работали с RxJava, то её знаете базовые конструкции:
* Наблюдаемый источник **(source Observable)**, далее
* несколько операторов **(Operators)**, затем
* целевой подписчик **(Subscriber)**
```
Observable.just(1, 2, 3, 4, 5)
.doOnNext(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
println("Emitting item on: " + currentThread().getName());
}
})
.map(new Function() {
@Override
public Integer apply(@NonNull Integer integer) throws Exception {
println("Processing item on: " + currentThread().getName());
return integer \* 2;
}
})
.subscribeWith(new DisposableObserver() {
@Override
public void onNext(@NonNull Integer integer) {
println("Consuming item on: " + currentThread().getName());
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
});
```
Если вы запустите данный пример кода, то ясно увидите, что все действия выполняются в основном потоке приложения (проследите за именами потоков в логе в консоли). Этот пример показывает, что **по умолчанию поведение RxJava блокирующее.** Всё выполняется в том же потоке, в котором вызван код.
**Бонус:** Интересно, что же делает `doOnNext()`? Это не что иное, как *side-effect* оператор. Он помогает внедряться в цепочку объектов `observable` и выполнять грязные *(impure)* операции. Например, внедрять дополнительный код в цепочке вызовов для отладки. Прочитать больше можно [здесь](https://www.grokkingandroid.com/rxjavas-side-effect-methods/).
### Простой пример
Для того, чтобы начать работать с многопоточностью с применением RxJava необходимо познакомиться с базовыми классами и методами, такими как **Schedulers**, **observeOn/subscribeOn**.
Давайте рассмотрим один из самых простых примеров. Допустим, мы хотим получить список объектов `Book` сетевым запросом и показать его в основном потоке приложения. Довольно общий и понятный пример для начала.
```
getBooks().subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new DisposableObserver() {
@Override
public void onNext(@NonNull Book book) {
// Вы можете получить доступ к объектам Book здесь
}
@Override
public void onError(@NonNull Throwable e) {
// Отлавливаем ошибки здесь
}
@Override
public void onComplete() {
// Все объекты Book получены. Готово!
}
});
```
Здесь мы видим метод `getBooks()`, который осуществляет сетевой вызов и собирает список книг для нас. Сетевой вызов занимает время (несколько миллисекунд или секунд), поэтому мы используем `subscribeOn()` и указываем планировщик `Schedulers.io()` для выполнения операции в потоке ввода-вывода.
Также мы используем оператор `observeOn()` вместе с планировщиком `AndroidSchedulers.mainThread()` для того, чтобы обрабатывать результат в основном потоке и показать список книг в пользовательском интерфейсе приложения.
Не волнуйтесь, скоро мы перейдем к более продвинутым вещам. Этот пример был предназначен только для того, чтобы вспомнить базовые понятия, прежде чем погрузиться глубже.
### Подружимся с планировщиками *(Schedulers)*
RxJava предоставляет мощный набор планировщиков. Вы не можете получить прямой доступ к потокам или управлять ими. Если вам нужно работать с потоками, то необходимо воспользоваться встроенными планировщиками.
Можете представлять планировщики как **потоки или пулы потоков (коллекции потоков) для выполнения разного рода задач**.
Говоря проще, если вам нужно выполнить задачу в отдельном потоке — необходимо использовать верный планировщик, который возьмёт поток из своего пула доступных потоков и выполнит в нём задачу.
В RxJava доступны несколько типов планировщиков. Самая сложная часть — выбрать верный планировщик для вашей задачи. Задача никогда не будет выполняться оптимально, если вы не выберете верный планировщик. Давайте разберем каждый планировщик.
#### Schedulers.io()
Этот планировщик **основывается на неограниченном пуле потоков и используется для интенсивной работы с вводом-выводом без использования ЦП**, например, доступ к файловой системе, выполнение сетевых вызовов, доступ к базе данных и так далее. Количество потоков в этом планировщике неограничено и может расти по мере необходимости.
#### Schedulers.computation()
Этот планировщик **используется для выполнения работы, высоко нагружающей ЦП**, такой как обработка больших объемов данных, изображений и так далее. Планировщик **основывается на ограниченном пуле потоков с размером в количество доступных процессоров.**
Так как этот планировщик подходит только для интенсивной работы с ЦП — количество его потоков ограничено. Сделано это для того, чтобы потоки не конкурировали за процессорное время и не простаивали.
#### Schedulers.newThread()
Этот планировщик **создает совершенно новый поток при каждом вызове.** В данном случае использование пула потоков не принесет никакой выгоды. Потоки очень затратно создавать и уничтожать. Вы должны быть осторожны и не злоупотреблять чрезмерным созданием потоков, так как это может привести в замедлению работы системы и переполнению памяти. **Новый поток будет создаваться для обработки каждого элемента, полученного из observable-источника**.
В идеале вы должны использовать этот планировщик довольно редко, в основном для выведения в отдельный поток долго работающих частей программы.
#### Schedulers.single()
Этот планировщик **основывается на единственном потоке, который используется для последовательного выполнения задач.** Он может быть очень полезен, когда у вас есть набор фоновых заданий в разных местах вашего приложения, но нельзя допустить одновременного выполнения более чем одного из этих заданий.
#### Schedulers.from(Executor executor)
Этот планировщик будет основываться на вашем собственном `Executor`. Может возникнуть ситуация, в которой необходимо будет выполнять определенные задачи в планировщике на основании собственной логики распределения потоков.
Допустим, вы хотите ограничить число параллельных сетевых вызовов, которые делает ваше приложение. Можно создать собственный планировщик, который будет работать на базе ограниченного в размерах пула потоков (`Scheduler.from(Executors.newFixedThreadPool(n))`) и использовать его во всех местах, связанных с сетевыми вызовами.
#### AndroidSchedulers.mainThread()
Это специальный планировщик, который недоступен в библиотеке RxJava. Необходимо использовать расширяющую библиотеку [RxAndroid](https://github.com/ReactiveX/RxAndroid) для доступа к этому планировщику. Этот планировщик **полезен в Android приложениях для выполнения действий в потоке пользовательского интерфейса**.
По умолчанию этот планировщик ставит задания в очередь в `Looper`, связанный с основным потоком, но есть возможность переопределения: `AndroidSchedulers.from(Looper looper)`.
**Заметка:** Будьте осторожны в использовании планировщиков, основанных на неограниченных пулах потоков, таких как `Schedulers.io()`. Всегда есть риск бесконечного роста количества потоков.
### Понимание subscribeOn() и observeOn()
Теперь, когда у вас есть представление о типах планировщиков, разберем **subscribeOn()** и **observeOn()** в деталях.
Вы должны глубоко разбираться в том, как эти два оператора работают по отдельности и вместе, чтобы профессионально работать с многопоточностью в RxJava.
#### subscribeOn()
Простыми словами, **этот оператор говорит в какой поток наблюдаемый источник *(source observable)* будет передавать элементы**. Вы должны уяснить важность слова *«источник»*. Когда у вас цепь наблюдаемых элементов *(observables)*, источник *(source observable)* — это всегда корневой элемент или верхняя часть цепи, откуда происходит создание событий.
Как вы уже видели, если не использовать `subscribeOn()`, то все события происходят в том потоке, в котором произошел вызов кода (в нашем случае — `main` поток).
Давайте перенаправим события в вычислительный поток с помощью `subscribeOn()` и планировщика `Schedulers.computation()`. Когда вы запустите нижеследующий пример кода, то увидите, что события происходят в одном из вычислительных потоков, доступных в пуле — `RxComputThreadPool-1`.
В целях сокращения кода мы не будем полностью переопределять все методы `DisposableSubscriber`, так как нам не нужно переопределять `onError()` и `onComplete()`. Воспользуемся `doOnNext()` и лямбдами.
```
Observable.just(1, 2, 3, 4, 5, 6)
.subscribeOn(Schedulers.computation())
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
Не важно в каком месте в цепочке вызовов вы используете `subscribeOn()`. Он работает только с наблюдаемым источником *(source observable)*, и контролирует в какой поток наблюдаемый источник передает события.
В нижеследующем примере после observable-источника создаются другие объекты observable (методами `map()` и `filter()`), а оператор `subscribeOn()` помещен в конце цепочки вызовов. Но как только вы запустите этот код, то заметите, что все события будут возникать в потоке, указанном в `subscribeOn()`. Это станет более понятным при добавлении `observeOn()` в цепь вызовов. И даже если мы разместим `subscribeOn()` ниже `observeOn()`, то логика работы не изменится. `subscribeOn()` работает только с наблюдаемым источником *(source observable).*
```
Observable.just(1, 2, 3, 4, 5, 6)
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.map(integer -> integer * 3)
.filter(integer -> integer % 2 == 0)
.subscribeOn(Schedulers.computation())
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
Также важно понять, что нельзя использовать `subscribeOn()` несколько раз в одной цепочке вызовов. Можно, конечно, написать ещё раз, но никаких изменений это не повлечет. В примере ниже мы последовательно вызываем три различных планировщика, можете ли вы догадаться, какой планировщик сработает при запуске?
```
Observable.just(1, 2, 3, 4, 5, 6)
.subscribeOn(Schedulers.io())
.subscribeOn(Schedulers.computation())
.subscribeOn(Schedulers.newThread())
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
Если вы ответили `Schedulers.io()`, то вы правы! Даже если делать вызов многократно — **сработает только первый `subscribeOn()`, вызванный после observable-источника**.
#### Под капотом
Стоит потратить ещё немного времени на более подробное изучение рассмотренного примера. Почему срабатывает только планировщик `Schedulers.io()`? Обычно все думают, что сработает `Schedulers.newThread()`, так как этот вызов находится в конце цепочки.
Необходимо понять, что в RxJava подписка создаётся после обратного вызова всех экземпляров `Observable`. Код ниже поможет нам разобраться в этом. Это ранее рассмотренный пример, но расписанный подробнее.
```
Observable o1 = Observable.just(1, 2, 3, 4, 5);
Observable o2 = o1.filter(integer -> integer % 2 == 0);
Observable o3 = o2.map(integer -> integer \* 10);
o3.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
Для того, чтобы понять как всё работает — начнем разбирать всё с последней строки примера. В ней целевой подписчик *(target subscriber)*, вызывает метод `subscribe()` у observable объекта `o3`, который затем делает неявный вызов `subscribe()` у своего родительского observable объекта `o2`. Реализация наблюдателя *(observer)*, предоставляемая объектом `o3`, умножает переданные числа на 10.
Процесс повторяется и `o2` неявно вызывает `subscribe()` у объекта `o1`, передавая реализацию наблюдателя, которая позволяет обрабатывать только четные числа. Теперь мы достигли корневого элемента (`o1`), у которого нет родителя для последующего вызова `subscribe()`. На этом этапе завершается цепочка наблюдаемых *(observable)* элементов, после чего observable-источник начинает передавать *(emit)* элементы.
Теперь для вас должна быть понятна концепция работы подписок в RxJava. К настоящему времени у вас должно появиться понимание того, как формируются цепочки наблюдаемых *(observable)* объектов и как события распространяются, начиная с observable-источника.
### observeOn()
Как мы уже видели, `subscribeOn()` указывает observable-источнику передавать элементы в определенный поток и этот поток будет отвечать за продвижение элементов вплоть до подписчика *(Subscriber)*. Поэтому, по умолчанию, подписчик получает обработанные элементы в этом же потоке.
Но это может быть не то поведение, которого вы ожидаете. Предположим, вы хотите получить некие данные из сети и отобразить их в пользовательском интерфейсе.
Нужно выполнить две вещи:
* Сделать сетевой вызов в неблокирующем потоке ввода-вывода
* Получить результат в основном потоке приложения
У вас будет `Observable`, который осуществляет сетевой вызов в потоке ввода-вывода и передает результат подписчику. Если вы используете только `subscribeOn(Schedulers.io())`, то целевой подписчик будет обрабатывать результат в том же потоке ввода-вывода. И нам не повезло, так как работать с пользовательским интерфейсом в Android можно только в основном потоке.
Теперь нам крайне необходимо переключить потоки и мы используем для этого `observeOn()`. Когда `observeOn()` встречается в цепочке вызовов, то передаваемые observable-источником элементы незамедлительно перебрасываются в поток, указанный в `observeOn()`.
```
getIntegersFromRemoteSource()
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
В этом придуманном примере мы наблюдаем получение целых чисел из сети и их дальнейшую передачу из observable-источника. В реальных примерах это может быть любая другая асинхронная операция, например, чтение большого файла, выборка данных из базы данных и т.д. Вы можете запустить данный пример и посмотреть на результаты, просто следите за логами в консоли.
Теперь рассмотрим более сложный пример, в котором `observeOn()` будет вызываться несколько раз для переключения потоков в процессе обработки данных.
```
getIntegersFromRemoteSource()
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.computation())
.map(integer -> {
println("Mapping item " + integer + " on: " + currentThread().getName());
return integer * integer;
})
.observeOn(Schedulers.newThread())
.filter(integer -> {
println("Filtering item " + integer + " on: " + currentThread().getName());
return integer % 2 == 0;
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
В примере выше observable-источник передаёт элементы в цепочку обработчиков в потоке ввода вывода, так как мы использовали `subscribeOn()` вместе с `Schedulers.io()`. Далее мы хотим преобразовать каждый элемент, используя оператор `map()`, но сделать это нужно в вычислительном потоке. Для этого используем `observeOn()` вместе с `Schedulers.computation()` перед вызовом `map()` для переключения потока и передачи элементов в целевой вычислительный поток.
Следующим шагом отфильтруем некоторые элементы и по какой-то причине мы хотим выполнить эту операцию в новом потоке для каждого из элементов. Используем снова `observeOn()`, но уже в паре с `Schedulers.newThread()` перед вызовом оператора `filter()` для передачи каждого элемента в новый поток.
В итоге мы хотим, чтобы подписчик получил результат обработки в потоке пользовательского интерфейса. Для этого используем `observeOn()` вместе с планировщиком `AndroidSchedulers.mainThread()`.
Но что произойдет, если использовать `observeOn()` несколько раз последовательно? В примере ниже в каком потоке подписчик получит результат?
```
getIntegersFromRemoteSource()
.doOnNext(integer -> println("Emitting item " + integer + " on: " + currentThread().getName()))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.single())
.observeOn(Schedulers.computation())
.subscribe(integer -> println("Consuming item " + integer + " on: " + currentThread().getName()));
```
Если запустите пример, то увидите, что подписчик получит элементы в вычислительном потоке `RxComputationThreadPool-1`. Это значит, что сработал последний вызванный `observeOn()`. Интересно почему?
#### Под капотом
Возможно вы уже догадались. Как мы знаем, подписка *(subscription)* вызывается после обратного обхода всех `Obsevable`, но с передачей событий *(emissions)* всё происходит наоборот, то есть в обычном порядке, как записан код. Вызов происходит от observable-источника и далее вниз по цепочке вызова вплоть до подписчика.
Оператор `observeOn()` всегда работает в прямом порядке, поэтому последовательно происходит переключение потоков и последним происходит переключение на вычислительный поток (`observeOn(Schedulers.computation())`). Итак, когда нужно переключить поток для обработки данных в новом потоке, то просто сначала вызовите `observeOn()`, а далее обрабатывайте элементы. Синхронизация, исключение состояния гонки, всё это и многие другие сложности многопоточности RxJava обрабатывает за вас.
### Резюме
Сейчас у вас должно быть достаточно хорошее представление о том, как правильно использовать RxJava для написания многопоточных приложений, обеспечивающих быструю и плавную работу пользовательского интерфейса.
Если понимание не пришло сразу, ничего страшного. Прочитайте статью ещё раз, поэкспериментируйте с примерами кода. Здесь достаточно много нюансов для понимания, не торопитесь. | https://habr.com/ru/post/344016/ | null | ru | null |
# Забери мусор с собой!
[](http://xn--80acaphjiwsabsdmca3a.xn--p1ai "Енот, прикольный зверь")
[«Забери мусор с собой!»](http://xn--80acaphjiwsabsdmca3a.xn--p1ai "перейти на сайт, посвящённый борьбе с загрязнением окружающей среды") — так называется сайт, который я сделал пару недель назад на выходных *(почти 2 дня делал)*, как раз к весеннему сезону, когда многие начинают выезжать за город на отдых.
Главная идея проста — убеждать людей, что природу нужно сохранить чистой. Для этого на сайте призываю всех убирать за собой (и не только за собой) мусор, а также на выбор предлагаются разные варианты плакатов в формате А4, которые можно распечатать на обычном принтере и приколоть канцелярскими кнопками к дереву, такая форма наглядой агитации:
### Графика
Прежде всего стоит сказать о том, что такие замечательные картинки для плакатов я взял на сайте [openclipart.org](http://www.openclipart.org/). Они распространяются под свободной лицензией, и очень качественно отрисованы в векторе, поэтому как нельзя лучше подошли в качестве клипарта.
Плакаты я нарисовал в векторном редакторе [Inkscape](http://ru.wikipedia.org/wiki/Inkscape), после чего сохранил в pdf файлы, которые посетители сайта могут скачать и распечатать. Редактор справился с этой задачей замечательно.
### «Движок»
В кавычках — потому что там кода кот наплакал.
Сайт работает на django, используя одну модельку и три функции. Для каждого плаката с животным есть ссылка на википедию и видеоролик, это сделано для того, чтобы посетители могли узнать больше о животном с плаката. Линки на скачивание pdf обрабатываются функцией, которая ведёт статистику скачиваний плакатов. Вот это практически весь код сайта:
```
models.py
# coding: utf-8
import os
import settings
from django.db import models
from django.core.files.storage import FileSystemStorage
class OverwriteStorage(FileSystemStorage):
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
# If the filename already exists, remove it as if it was a true file system
if self.exists(name):
os.remove(os.path.join(settings.MEDIA_ROOT, name))
return name
fs=OverwriteStorage(location=settings.MEDIA_ROOT)
class Poster(models.Model):
title = models.CharField(max_length=100, verbose_name="Название плаката")
thumbnail = models.ImageField(upload_to='images/posters',verbose_name="Иконка плаката")
preview = models.ImageField(upload_to='images/posters',verbose_name="Превьюшка плаката")
pdf = models.FileField("PDF файл плаката", upload_to='posters/', storage=fs)
downloads = models.IntegerField("Количество скачиваний постера", default=0)
wiki_youtube_title = models.CharField(max_length=100, blank=True, default="", verbose_name="Текст ссылки на википедию и ютуб")
wiki_url = models.URLField("Ссылка на статью в википедии", blank=True)
video = models.TextField("Код для вставки видеоролика", blank=True)
youtube_url = models.URLField("Ссылка на ютуб-ролики", blank=True)
def __unicode__(self):
return u'Плакат "%s"' % self.title
def get_absolute_url(self):
return "/poster/%d/" % self.id
class Meta():
ordering = ['id']
verbose_name = "постер"
verbose_name_plural = "постеры"
views.py
# coding: utf-8
from models import *
from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext
from django.http import HttpResponseRedirect
def index(request):
posters = Poster.objects.all()
return render_to_response('website/index.html',
{'posters': posters,},
context_instance=RequestContext(request))
def poster(request, poster_id, please_explain=False):
poster = get_object_or_404(Poster, id=poster_id)
return render_to_response('website/poster.html',
{'poster': poster,
'please_explain': please_explain,},
context_instance=RequestContext(request))
def download_poster(request, poster_id):
poster = get_object_or_404(Poster, id=poster_id)
poster.downloads += 1
poster.save()
return HttpResponseRedirect('/static/' + poster.pdf.url)
```
В модельке я добавил youtube\_url, т.к. каждый раз html код вставлять избыточно, тем более на всех страницах плеер одинакового размера. Добавить добавил, а миграцию и шаблоны не переделывал, т.к. и так работает. В общем, недооптимизировал.
please\_explain во вьюшке poster добавлено для того, чтобы посетители с другого сайта, перешедшие по баннерам, видели коротенькое объяснение, для чего нужен этот сайт.
### css
Т.к. я не дизайнер, для оформления использовал простейшие стили, а для работы с css используется [фреймворк Compass](http://compass-style.org/). Он позволяет разрабатывать разметку сайта на основе сетки, что сильно упрощает таким как я создание более-менее кроссбраузерного контента (IE поддерживается «из коробки»). Одно время я отрицательно относился к css фреймворкам, но Compass поменял моё отношение.
В основе Compass два других фреймворка — [SASS](http://sass-lang.com/) и [Blueprint](http://www.blueprintcss.org/). SASS это фактически такой препроцессор для css файлов — там есть и переменные, и эквивалент функций и многое другое.
Исходный код \*.scss файла компилится и получается обычный css файл, но с комментами. Его потом можно обработать любым компрессором и будет всё ОК.
Если надумаете ставить Compass в Ubuntu, последовательность такая (в 10.04 по крайней мере):
```
sudo apt-get install ruby rubygems rubygems-update
cd /var/lib/gems/КАКАЯ.ТО.ВЕРСИЯ/gems/rubygems-update-КАКАЯ.ТО.ВЕРСИЯ
sudo ruby setup.rb
sudo gem install compass
```
Что касается резиновости, blueprint и compass — почему-то последняя версия неоптимально компилирует mixin liquid. Неоптимально — в смысле просто дописывает его в конец файла, переопределяя вышестоящие стили, из-за этого css файл гораздо больше в размере. Чтобы победить это, можете в своём главном scss файле использовать такую конструкцию:
```
@import "blueprint/reset";
@import "blueprint/scaffolding";
@import "blueprint/liquid";
@import "blueprint/typography";
@import "blueprint/utilities";
@import "blueprint/form";
@import "blueprint/interaction";
@include blueprint-typography;
@include blueprint-utilities;
@include blueprint-liquid-grid;
@include blueprint-interaction;
@include blueprint-form;
```
### Обещанные картинки
У моего друга есть сайт, и он предложил повесить на нём баннеры для привлечения внимания к сайту. Я решил, что надо найти какие-то интересные малоизвестные факты о животных, и использовать их в качестве текстов. Получилось вот так:
| | | |
| --- | --- | --- |
| | | |
| | |
### Ваше мнение и участие
Естественно, меня прежде всего интересует ваше мнение — что можно улучшить? Может быть, есть какие-то мысли, что можно добавить на сайт. Я думал ещё на страницы плакатов добавить инструкции по изготовлению несложных оригами на тему животных, а дочка предложила добавить анекдоты.
Ну и конечно же, большая просьба рассказать об этом сайте своим друзьям и знакомым, тем более сегодня пятница, завтра наверняка многие поедут на природу. Чем больше будет небезразличных людей, тем лучше будет наша жизнь и чище природа. | https://habr.com/ru/post/118586/ | null | ru | null |
# Сборка ICO файла с иконками в формате PNG при помощи FASM
Иногда я пишу небольшие программы на C++, и часто выходит так, что иконка программы «весит» больше, чем собственно сама программа. Так же вышло и при написании [Sound Keeper](http://geektimes.ru/post/243937/): программа — 14КБ, иконка 16×16 + 32×32 + 48×48 пикселей — 15КБ. Какое расточительство! К счастью оказалось, что Windows (начиная с Vista) поддерживает PNG внутри ICO. Это как раз то, что нужно! Но почему-то не нашлось программы, которая бы позволила самому оптимизировать файлы PNG и собрать из них файл ICO. Поскольку у файлов ICO очень простой формат, соберём его при помощи [FASM](http://flatassembler.net/). Это нестандартное использование «плоского» ассемблера показывает, что его можно применять в самых неожиданных ситуациях, и это работает!
Приступим
---------
1. Создаём изображения для иконок в формате PNG. Например, сделаем два изображения с размерами 16×16 и 32×32 пикселей. Сохраним их в файлы icon16.png и icon32.png соответственно. Оптимизируем на свой вкус своими любимыми инструментами.
2. Следуя [документации](http://blogs.msdn.com/b/oldnewthing/archive/2010/10/18/10077133.aspx), создаём файл icopng.asm с примерно таким содержимым:
```
dw 0 ; reserved, must be 0
dw 1 ; icon type, must be 1
dw 2 ; number of images in file
; 1st icon header
db 32 ; width
db 32 ; height
db 0 ; no color palette
db 0 ; reserved, must be 0
dw 1 ; planes
dw 32 ; bits per pixel
dd icon32_end-icon32_start ; length
dd icon32_start ; offset
; 2nd icon header
db 16 ; width
db 16 ; height
db 0 ; no color palette
db 0 ; reserved, must be 0
dw 1 ; planes
dw 32 ; bits per pixel
dd icon16_end-icon16_start ; length
dd icon16_start ; offset
; 1st icon body
icon32_start:
file 'icon32.png'
icon32_end:
; 2nd icon body
icon16_start:
file 'icon16.png'
icon16_end:
```
Опытным путём было установлено, что лучше подключать изображения в обратном порядке, от больших к меньшим. При добавлении большего количества иконок не забывайте исправлять поле с общим количеством изображений в заголовке. Ошибка здесь может привести к самым неожиданным последствиям.
3. Собираем иконку командой:
```
fasm icopng.asm icopng.ico
```
4. В результате мы получили иконку с изображениями в формате PNG. У меня вместо 15КБ получился файл размером всего 3КБ.
Поддержка PNG8 с альфа-каналом
------------------------------
Согласно скудной [документации](http://blogs.msdn.com/b/oldnewthing/archive/2010/10/22/10079192.aspx), должны поддерживаться только изображения в формате PNG32. [На практике](http://veg.by/habr/pngicon/png8.ico) система без проблем декодирует и изображения PNG8 даже с альфа-каналом. Разве что только просмотрщик картинок Windows не понимает PNG8 в иконках, видимо он не использует системные функции для декодирования и отрисовки иконки. Но вы же иконки делаете не для того, чтобы их в просмотрщике картинок смотреть, правда? :) Везде, где использутся стандартные функции Windows для загрузки и отображения иконки — PNG8 с альфа-каналом отображается так же, как и PNG32.
Важное замечание: даже у изображений в формате PNG8 в заголовке должно быть указано отсутствие палитры, потому что декодер PNG на выходе даёт TrueColor изображение с альфа-каналом, где могут встречаться любые цвета. То есть в примере вам нужно будет изменять только поля width и height. Остальное трогать не нужно.
Проблема в системном декодере PNG
---------------------------------
Поддержка PNG в иконках в Windows Vista и новее по умолчанию используется для сохранения только больших иконок размером 256×256. Судя по всему, поддержку PNG внутри ICO тестировали плохо, поэтому есть кое-какие проблемы и обходные пути для них.
Обнаружилась какая-то ошибка в системном декодере PNG, из-за чего конкретный файл иконки может отображаться неправильно в некоторых местах (например, в диалоге свойств файла). Причём минимальное изменение параметров сжатия легко решает проблему.
Я провёл небольшое исследование на [файле иконки](http://veg.by/habr/pngicon/problem.ico), которая неправильно отображалась в диалоге свойств файла. Системная функция [DrawIconEx](http://msdn.microsoft.com/en-us/library/windows/desktop/ms648065%28v=vs.85%29.aspx) имеет 3 режима отрисовки иконки: DI\_NORMAL (с альфой), DI\_IMAGE (без альфы) и DI\_MASK (только маска).
На этом изображении видно как одна и та же иконка вывелась в разных режимах, а под названием RESULT приведено то, как выглядит эта иконка в свойствах файла. Видно, что в режимах DI\_NORMAL и DI\_IMAGE система отрисовывает иконку правильно. Однако, в режиме DI\_MASK вычисленная с целью совместимости маска почему-то сдвинута на три пикселя вправо, а также в первом столбце пикселей появился какой-то мусор — вероятно, следствие неправильной работы с буфером. Иконка в свойствах файла, как видно, имеет серьёзные артефакты как раз по очертаниям некорректной маски. Было бы хорошо сообщить об этой проблеме разработчикам Microsoft, но к сожалению, я не нашёл какого-то открытого баг-трекера.
Советы по оптимизации PNG
-------------------------
Рекомендую использовать программу [Color Quantizer](http://x128.ho.ua/color-quantizer.html) для преобразования файлов из PNG32 в PNG8 с альфа-каналом. Результирующий файл помимо прочего сжимается весьма эффективным алгоритмом, поэтому обычно дополнительная оптимизация не требуется.
На скриншоте красным выделен блок с выбором количества цветов и коэффицентом допустимых ошибок квантования. При возникновении описанной выше проблемы с некорректным отображением иконки в диалоге свойств файла, просто поменяйте параметры квантования. Например, незначительно измените значение коэффицента допустимых ошибок квантования.
На этом всё
-----------
Теперь и ваши компактные программы могут быть с красочными иконками всех необходимых размеров. Не нужно жертвовать прозрачностью или количеством вариантов иконки. Недостаток только один — пользователи Windows XP не увидят такую иконку. Но если учесть, что официальная поддержка Windows XP уже давно закончилась, и всё меньше компьютеров работает под управлением этой операционной системы, то не так всё плохо. Тем более, что авторы маленьких программ часто для экономии вообще не добавляют иконку. | https://habr.com/ru/post/247425/ | null | ru | null |
# Аппаратные технологии безопасности Intel: новое слово в защите биометрических приложений. Часть 2
В [первой части](https://habrahabr.ru/company/intel/blog/281989/) мы обсудили проблемы современных биометрических приложений распознавания пользователей и рассказали о том, как Intel SGX, Intel VMX и Intel IPT способны повысить уровень их защиты. Сегодня продолжим разговор о безопасности биометрии, рассмотрим технологии Intel AES-NI, Intel Secure Key и Intel RealSense.
[](https://habrahabr.ru/company/intel/blog/282411/)
Для того, чтобы защитить важные данные или программный код во время исполнения, широко используются криптографические алгоритмы и рандомизация адресного пространства (Address Space Layout Randomization, ASLR). Подобные технологии применяются как на уровне обычных приложений, так и на уровне операционной системы. Важной их частью являются случайные числа.
Intel Secure Key
----------------
Если нужно сгенерировать ключевую пару или создать случайное адресное пространство, генератор настоящих случайных чисел лучше, чем генератор псевдослучайных чисел. Технология Intel Secure Key предоставляет x86-инструкцию RDRAND, которую можно использовать для создания высококачественного генератора случайных чисел.
Инструкция RDRAND воплощает инновационный подход к созданию высококачественного, высокопроизводительного генератора случайных чисел, основанного на аппаратном источнике энтропии. Генератор построен по каскадной модели, он задействует встроенный в процессор источник энтропии для периодической инициализации аппаратного криптографически безопасного генератора псевдослучайных чисел. В результате инструкция RDRAND может генерировать случайные числа, соответствующие стандарту NIST SP 800-90A. Для наиболее распространённых вариантов использования её можно считать генератором подлинно случайных чисел.
*Инструкция RDRAND получает данные из внутреннего аппаратного генератора случайных чисел*
Существует много способов использования RDRAND.
**1.** Вызов RDRAND напрямую в коде на ассемблере или на встроенном ассемблере в C++.
```
– rdrand %edx
– unsigned long therand, err;
asm volatile("rdrand %0 ; setc %1"
: "=r" (*therand), "=qm" (err));
//therand
-> сохранить результат
//err
-> возврат статуса операции, 1 при успехе, 0 при незаполнении буфера
```
**2.** Использование библиотеки от Intel (librdrand). Она написана на C/C++. Существуют версии для [Windows](https://software.intel.com/en-us/articles/user-manual-for-the-rdrand-library-windows-version), и для [Linux и OS X](https://software.intel.com/en-us/articles/user-manual-for-the-rdrand-library-linux-version).
**3.** Использование библиотек сторонних поставщиков.
* Openssl (C/C++)
* [Lizalab-rdrand-util](https://github.com/hpadmanabhan/rdrand-util) (Java)
* [Drnglib](https://github.com/cambecc/drnglib) (Java)
Intel AES-NI
------------
Intel Advanced Encryption Standard New Instructions (Intel AES-NI) – это набор инструкций, разработанный для ускорения приложений, использующих один из самых популярных симметричных алгоритмов шифрования AES. AES широко используют для шифрования данных, хранящихся в оперативной памяти и на жёстких дисках, для защиты информации, передаваемой по сети. Делается это для того, чтобы защитить конфиденциальные данные даже в том случае, если злоумышленнику удастся их скопировать с некоего носителя или перехватить при передаче.
*Шифрование канала передачи данных с использованием AES*
Для того, чтобы повысить запас надёжности, рекомендуется выполнять шифрование с использованием нескольких раундов AES, что эквивалентно увеличению длины криптографического ключа. В 2010 году Intel представила новый набор инструкций (Intel AES-NI), который предлагает полную аппаратную поддержку шифрования и дешифровки AES. Это позволяет увеличить производительность и снизить потребление памяти. В наши дни практически все настольные и мобильные процессоры Intel поддерживают AES-NI. Вот, какого прироста производительности удаётся достичь при использовании AES-NI в сравнении с полностью программной реализацией алгоритма, не использующей эти команды.
Тестируемое устройство построено на базе Intel Atom Z3770 (Bay Trail) FFRD8 PR1, оно работало под управлением Android 4.4, использовалось OpenSSL native C API.
| | | | |
| --- | --- | --- | --- |
| **Режим (CBC/256)** | **Размер файла, Мб.** | **С AES-NI, сек.** | **Без AES-NI, сек.** |
| Шифрование | 351 | 2,89 | 14,59 |
| 56 | 0,48 | 2,63 |
| Дешифровка | 351 | 1,76 | 19,78 |
| 56 | 0,29 | 3,16 |
Как видно из данных, приведённых в таблице, при шифровании использование инструкций Intel AES-NI дало 5-кратный рост производительности. При дешифровке – 11-кратный рост. Нужно отметить, что использование AES-NI позволяет снизить энергопотребление примерно на 40%.
В настоящее время большинство популярных операционных систем содержат встроенную поддержку Intel AES-NI. Когда некое приложение обращается к криптографическому API, которое предоставляет система, например, к Windows CNG API или к классу Javax.crypto в Android, низкоуровневый драйвер автоматически задействует инструкции AES-NI для повышения производительности. Кроме того, многие библиотеки, например, OpenSSL 1.0.1, Intel Integrated Performance Primitives, Crypto++, оптимизированы с целью максимально эффективного использования AES-NI.
Испытания на живучесть и датчик глубины камеры Intel RealSense
--------------------------------------------------------------
Биометрическое распознавание пользователя, основанное на анализе лица, широко используется в повседневной жизни многих людей. Например – для разблокировки Android-устройств и персональных компьютеров. Так как для распознавания лица используется традиционная оптическая камера, умеющая захватывать плоские изображения, система не может отличить реального человека от фотографии. В результате взломщик может пройти процедуру авторизации, воспользовавшись распечатанным фотоснимком лица пользователя.
Камера Intel RealSense умеет захватывать информацию о глубине пространства. Это открывает очень интересные перспективы. Одна из её функций заключается в построении трёхмерных моделей людей и объектов, попадающих в объектив. Данная возможность позволяет задействовать Intel RealSense как инструмент испытания на живучесть в некоторых сценариях захвата биометрических данных, и, как результат, повысить безопасность биометрических систем. Обычная камера, входящая в состав RealSense, фотографирует лицо пользователя, а модуль трёхмерного сканирования пространства одновременно строит объёмную картину того, что находится перед камерой. Сведения о пространственных характеристиках лицевой области легко могут быть использованы для того, чтобы определить, человек ли смотрит в камеру, или, там, где должно находиться объёмное лицо, размещён плоский лист бумаги.
*Трёхмерная модель лица с камеры глубины Intel RealSense F200. Очевидно, перед камерой настоящий человек.*
*Лист бумаги, пусть и с напечатанным фото пользователя, остаётся плоским для камеры глубины Intel RealSense F200. Очевидно, что это – подделка.*
Обзор технологий
----------------
Вот краткий обзор технологий Intel, которые могут поднять безопасность биометрических систем на новый уровень.
Жёлтыми значками показаны области применения технологий Intel для повышения безопасности биометрических приложений.
* Intel SGX
+ Защита кода и данных во время выполнения приложений.
+ Организация защищённого локального хранения информации.
+ Организация безопасного обмена важными данными по сети.
* Intel VMM
+ Защита памяти приложений, работающих с уровнем привилегий Ring-3
+ Защита памяти драйверов, работающих с уровнем привилегий Ring-0
* Intel AES-NI
+ Защита данных, хранимых на различных носителях информации, в оперативной памяти, передаваемых по сети.
+ Значительное ускорение процедур шифрования и дешифрования
* Intel IPT
+ Организация многофакторной аутентификации
+ Защита информации, выводимой на дисплей, и данных, которые вводит пользователь
* Intel RealSense
+ Организация испытаний на живучесть.
Итоги
-----
Биометрическая идентификация пользователей отличается от традиционной схемы, использующей имя и пароль. Биометрические данные человека практически невозможно изменить. Как результат, этот подход к аутентификации требует повышенного уровня безопасности систем.
Intel предлагает различные аппаратные технологии, доступные как в настольных компьютерах, оснащённых процессорами Intel, так и на мобильных устройствах. Эти технологии могут помочь разработчикам биометрических решений в создании более защищённых систем аутентификации без необходимости задействовать дополнительное аппаратное обеспечение. | https://habr.com/ru/post/282411/ | null | ru | null |
# Свой сервер обложек на Python для интернет-радио
Я перфекционист который любит во всём порядок. Больше всего меня радует когда вещи работают именно так, как они должны работать (в моём, разумеется, понимании). А ещё у меня уже давно есть своё персональное интернет-радио на базе IceCast-KH + LiquidSoap. И много лет мне не давал спокойно спать тот факт, что сервера потокового радиовещания не умеют отдавать обложки (artwork) проигрываемых треков в потоке. Да и не только в потоке — вообще никак не умеют. Я и на IceCast-KH (форк от IceCast2) перешёл только из-за одной его убер-фичи — он умеет отдавать mp3-тэги внутри flv потока (это нужно для отображения исполняемого трека при онлайн воспроизведении на сайте через флэш-плеер). И теперь пришло время закрыть последний вопрос — отдачу обложек проигрываемых треков — и успокоиться. Поскольку готовых решений не нашлось, я не придумал ничего лучше, чем написать свой сервер обложек для .mp3 файлов. Как? Добро пожаловать под кат.
### Предыстория
Радио я обычно слушаю в машине, на 2-din магнитоле на базе Android 4.4 KitKat (а дома на планшете под тем же Андроидом). Для прослушивания, после долгого и вдумчивого перебора существующих программ, была выбрана XiiaLive, в основном за то, что она умеет в пользовательские радиостанции (такая банальная, казалось бы фича, но не поддерживается большинством плееров потокового радио — вот тебе каталог ShoutCast/Uber Stations — выбирай и слушай что дают), а также за то, что умеет подкачивать и отображать обложки проигрываемых треков. Да, конечно, не всех, но умеет. Музыка играла, обложки частично показывались и на какое-то время внутренний перфекционист успокоился, но как оказалось — ненадолго.
Через некоторое время всплыл крайне неприятный баг приложения связанный с неверной обработкой юникода — если и название трека и исполнителя было не в латинице — обложка альбома показывалась неверно. Мало того — всегда одна и та же. И я вам даже больше скажу — это почему-то всегда была Нюша. Вот этого я уже вытерпеть не смог.
*Скриншот иллюстрирующий как XiiaLive покусился на святое.*
Можно было бы подождать, пока разработчики пофиксят этот [баг](http://support.xiialive.com/topics/1734-russian-titles-album-art/), но, здраво рассудив, что вряд ли у них найдутся обложки для всего, что находится в ротации именно на моей станции (у них точно не будет обложек для Ishome, Interior Disposition, tmtnsft и тем более MΣ$†ΛMN ΣKCПØNΛ†), показалось правильнее написать своё api для обложек. Которое будет уметь работать именно по локальной базе файлов с музыкой и, по возможности, без привязки к конкретному серверу вещания.
### Исследуем вопрос
Найти описание стандартного протокола для отдачи обложек не удалось (предполагаю, что единого стандарта вообще нет), поэтому решил пойти от обратного — посмотреть как это реализовано у больших дядек, в частности у того же XiiaLive. Вооружаемся [Packet Capture](https://play.google.com/store/apps/details?id=app.greyshirts.sslcapture) на Android, ловим пакеты и смотрим куда приложение ходит и зачем:
```
GET /songart.php?partner_token=7144969234&title=Umbrella&artist=The+Baseballs&res=hi HTTP/1.1
User-Agent: Dalvik/1.6.0 (Linux; U; Android 4.4.2; QuadCore-R16 Build/KVT49L)
Host: api.dar.fm
Connection: Keep-Alive
Accept-Encoding: gzip
HTTP/1.1 200 OK
Server: Apache/2.2.15 (CentOS)
X-Powered-By: PHP/5.3.3
Set-Cookie: PHPSESSID=u5sgs13h1315k9184nvvutaf33; expires=Fri, 03-Aug-2018 18:39:08 GMT; path=/; domain=.dar.fm
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
X-Train: wreck="mofas16"
Content-Type: application/xml; charset=UTF-8
Content-Length: 57
Accept-Ranges: bytes
Date: Thu, 03 Aug 2017 18:39:08 GMT
Via: 1.1 varnish
Age: 0
Connection: keep-alive
X-Served-By: cache-ams4143-AMS
X-Cache: MISS
X-Cache-Hits: 0
X-Timer: S1501785548.973935,VS0,VE390
```
Оказалось, что посылается обычный GET запрос с четырьмя переменными:
* partner\_token — токен авторизации, при запросе без него, или с неправильным токеном — возвращается 403.
* title — заголовок трека
* artist — имя исполнителя
* res — желаемое разрешение картинки. Несложный перебор дал следующий набор выдаваемых разрешений (обложки квадратные, так что разрешение описывается одним числом):
\* hi — 1080 px
\* low — 250 px
\* во всех остальных случаях — 400 px
В ответ на запрос приложение ожидает в ответ xml такого вида:
```
xml version="1.0" encoding="UTF-8" ?
http://coverartarchive.org/release/c8b16143-e87e-440d-bbb2-5c96615bed2b/2098621288-500.jpg
The Baseballs
Tik Tok
1080
```
И следующим запросом приложение ожидаемо идёт на сервер статики за картинкой. Если по сочетанию “Исполнитель” + “Название трека” ничего не найдено, то возвращается пустой xml:
```
xml version="1.0" encoding="UTF-8" ?
```
### Проектирование
Окей, входные и выходные параметры чёрного ящика определены, осталось выстроить логику его работы. И самое главное — решить откуда мы будем брать обложку для запрошенного трека.
Делать отдельную базу картинок обложек, как-то связывать её с треками, поддерживать в актуальном состоянии — мне лень. Да и не стоит умножать сущностей, заводить какие-то лишние базы и связи, ибо формат mp3 тегов ID3v2 поддерживает хранение обложек в самих mp3 файлах уже много лет, вот и будем ходить внутрь файла за обложкой (если она там, конечно, есть). А если файл не найден (или обложки в нём нет), то вместо пустого xml мы лучше будем отдавать одну из дефолтных обложек для радиостанции, чтобы пользователь не смотрел в пустой квадрат.
Вообще я предпочитаю всё скриптовать и поменьше работы делать руками. Например, как сейчас выглядит добавление файла в ротацию: закинул файл по ftp/scp в inbox каталог и забыл. Через минуту пришёл скрипт обслуживания, нашёл файл, переименовал его как нужно и переложил в каталог радиостанции. А раз в 10 минут LiquidSoap перечитает каталог, обнаружит новый файл и добавит его в плейлист. Придёт запрос на обложку — скрипт найдёт файл и извлечёт обложку из него.
> У хорошего системного администратора даже Sysadmin Day отмечается автоматически.
>
> По cron-у.
Правда в процессе реализации и тестирования логика несколько усложнилась. Ведь зачастую есть ещё cover.jpg в каталоге альбома (для исполнителей, которые в ротации присутствуют целыми альбомами). А есть ещё многочисленные исполнители из SoundCloud / PromoDJ да и просто из vk которые редко собирают треки в альбомы, или вообще заботятся вопросом обложки для трека. Для этих исполнителей (их не так уж много), заведём на сервере статики отдельный каталог с дефолтными обложками по имени исполнителя.
Последний вопрос: как найти соответствующий запрошенным тэгам файл на диске, учитывая что на момент начала поиска у нас есть только имя исполнителя и название трека? Можно хранить информацию где-нибудь в БД по ключам “исполнитель, трек -> файл на диске”, можно ходить по файлам, смотреть в них mp3-теги сравнивая с запросом (но это долго), а можно, следуя принципу не умножения сущностей просто хранить файлы на диске с именами вида "%artist% — %title%.mp3". У меня сделано именно так. Когда-то для этого я пользовался лучшей, на мой взгляд, для этих целей, программой [TagScanner](https://www.xdlab.ru/) от Сергея Серкова, а потом перешёл на python-скрипт, который автоматически переименовывает файлы в нужный формат.
Окончательная логика работы получилась такая:
* Приняли GET запрос.
* Если запрос пустой (не содержит GET параметров) — возвращает пустой XML
* Если включена авторизация по токенам (не нулевой список tokens в файле конфигурации) — проверяется пришедший токен. Если токен неверен — 401 Unauthorized.
* Если в запросе присутствуют переменные artist и title происходит поиск в локальном каталоге mp3 файлов:
* Если файл не найден — возвращается пустой XML
* Если файл найден — последовательность следующая:
* Проверяем — нет ли уже готовой обложки для этого файла в каталоге обложек? Если есть — отдаём ссылку на неё.
* Если в файле есть обложка — извлекаем её в каталог с обложками, отдаём ссылку.
* Если в в каталоге с .mp3 файлом есть обложка альбома (файл cover.jpg) — переносим его в каталог обложек альбомов, отдаём ссылку на него.
* Если в каталоге исполнителей есть обложка с именем `artist` — отдаём ссылку на него.
* Если совсем ничего не найдено — отдаём случайную картинку из каталога дефолтных обложек радиостанции.
Ну а теперь, когда логика работы определена, осталось только оформить её в виде функций.
### Код
Для извлечения обложек из mp3-файлов воспользуемся модулем mutagen. Функция, которая извлекает обложки из mp3 файлов и пишет их в .jpg:
```
import mutagen.mp3
def extract_cover(local_file, covers_dir, cover_name):
"""
Extracts cover art from mp3 file
:param local_file: file name (with path)
:param covers_dir: path to store cover art files
:param cover_name: name for extracted cover art file
:rtype: bool
:return:
False - file not found or contains no cover art
True - all ok, cover extracted
"""
try:
tags = mutagen.mp3.Open(local_file)
data = ""
for i in tags:
if i.startswith("APIC"):
data = tags[i].data
break
if not data:
return False
else:
with open(covers_dir + cover_name, "w") as cover:
cover.write(data)
return True
except:
logging.error('extract_cover: File \"%s\" not found in %s', local_file, covers_dir)
return False
```
Если в файле есть обложка и мы её успешно извлекли — делаем ресайз под нужные размеры с сохранением пропорций картинки (ибо не всегда в файле лежат стандартные квадратные обложки). С этим отлично справляется Python Imaging Library (PIL), который ещё и умеет в antialias:
```
from PIL import Image
def resize_image(image_file, new_size):
"""
Resizes image keeping aspect ratio
:param image_file: file name (with full path)
:param new_size: new file max size
:rtype bool
:return:
False - resize unsuccessful or file not found
True - otherwise
"""
try:
img = Image.open(image_file)
except:
return False
if max(img.size) != new_size:
k = float(new_size) / float(max(img.size))
new_img = img.resize(tuple([int(k * x) for x in img.size]), Image.ANTIALIAS)
img.close()
new_img.save(image_file)
return True
```
Несмотря на то, что почти все современные программы умеют сами подгонять размер обложки под размер экрана, я бы крайне рекомендовал делать это самостоятельно, на стороне сервера.
> В моей практике был случай, когда из 15-и мегабайтного .mp3 файла половину (7.62 мб), занимала обложка размерами 3508x3508, к тому же с нестандартным цветовым профилем. Этот файл наглухо вешал программу TagScanner, которой я пользуюсь для редактирования тегов. Не знаю, сколько бы отправлялся этот файл по 3G связи, и что стало бы с Андроидом при попытке подогнать его под размер экрана.
Так как XiiaLive не имеет настроек для выбора сервера обложек, пришлось подменить адрес api.dar.fm, к которому он обращается, на свой. На рутованном Android это просто:
```
/etc/hosts
api.dar.fm
```
И объясняем Nginx, что все приходящие запросы, вне зависимости от того, куда они пришли и чего хотят — обслуживает наш скрипт. Заодно поднимаем виртуальный хост для статики, откуда будут отдаваться картинки. Конечно, можно всё делать в рамках одного хоста, но всё-таки лучше ~~мухи~~ api отдельно, а ~~котлеты~~ статика — отдельно.
```
upstream fcgiwrap_factory {
server unix:/run/fcgiwrap.socket;
keepalive 32;
}
server {
listen 80;
server_name api. api.dar.fm;
root /var/wwws//api;
access\_log /var/log/nginx/api.access.log main;
error\_log /var/log/nginx/api.error.log;
location / {
try\_files $uri /api.py?$args;
}
location ~ api.py {
fastcgi\_pass fcgiwrap\_factory;
include /etc/nginx/fastcgi\_params;
fastcgi\_param SCRIPT\_FILENAME $document\_root$fastcgi\_script\_name;
}
}
server {
listen 80;
server\_name static.
root /var/wwws//static;
access\_log /var/log/nginx/static.access.log main;
error\_log /var/log/nginx/static.error.log;
index index.html;
location / {
}
}
```
После исправления багов и допиливания тонких мест — всё заработало. Музыка играет, картинки извлекаются из mp3 файлов и складываются в каталог хоста со статикой для отдачи через веб. По идее, через некоторое время все обложки перекочуют из недр mp3 файлов в static каталог, но, во-первых процесс извлечения обложки занимает в среднем 100 мс, а во-вторых — место на хостинге всё-таки не резиновое, поэтому картинки через какое-то время удаляются простейшим однострочником на баше, который висит себе в кроне и удаляет файлы к которым обращались больше недели назад:
```
find /var/wwws//static/covers/ -maxdepth 1 -type f -iname '\*.jpg' -atime +7 -exec rm {} \;
```
Разумеется, чтобы это работало, на разделе с музыкой не должен быть установлен noatime.
*Ну вот всё и заработало, как должно работать.*
### Доработка
Через неделю я проанализировал логи сервера и обнаружил интересное: сразу после запуска приложение посылает запрос вида:
```
GET /songart.php?partner_token=7144969234&res=hi HTTP/1.1" 200 334 "-" "Dalvik/1.6.0 (Linux; U; Android 4.4.2; QuadCore-R16 Build/KVT49L)
```
И только некоторое время спустя:
```
GET /songart.php?partner_token=7144969234&title=Summer+Nights&artist=John+Travolta+and+Olivia+Newton-John&res=hi HTTP/1.1" 200 334 "-" "Dalvik/1.6.0 (Linux; U; Android 4.4.2; QuadCore-R16 Build/KVT49L)
```
Соответственно между этими двумя запросами на экране никакой обложки нет, темнота и уныние.
Непорядок.
Причина ясна: приложение при запуске ещё не успело извлечь из потока тэги и не знает что играет, почему бы ему не помочь? Добавим первым пунктом ещё одно условие в логику работы программы:
* Если пришел GET запрос с токеном авторизации, но без указания исполнителя и названия трека — отдать картинку для текущего проигрываемого трека. Если есть переменная stream — из запрошенного потока вещания, иначе — из того, который мы считаем основным.
Но откуда брать название текущего трека? Не грепать же логи сервера. Очень удачно, что Icecast умеет отдавать состояние примонтированных точек в XML или JSON формате. JSON для Python более нативен, поэтому будем использовать его. Т.к. в Icecast-KH такой статистики “из коробки” нет, воспользуемся xsl файлом из статьи уважаемого [namikiri](https://habrahabr.ru/post/145694/), нечувствительно доработанным мной:
```
{
"":
{
"name" : "",
"listeners" : "",
"listener\_peak" : "",
"description" : "",
"title" : "",
"genre" : "",
"url" : ""
}
,
}
```
Файл кладём в web каталог Icecast-kh (на Ubuntu по умолчанию это /usr/local/share/icecast/web/), и при обращении через http получаем в ответ что-то типа такого:
```
{
"/256":
{
"name" : "Radio /256kbps",
"listeners" : "2",
"listener_peak" : "5",
"description" : "mp3, 265kbit",
"title" : "The Kelly Family - Fell In Love With An Alien",
"genre" : "Various",
"url" : ""
},
"/128":
{
"name" : "Radio /128kbps",
"listeners" : "0",
"listener_peak" : "1",
"description" : "mp3, 128kbit",
"title" : "The Kelly Family - Fell In Love With An Alien",
"genre" : "Various",
"url" : ""
},
"/64":
{
"name" : "Radio /64kbps",
"listeners" : "0",
"listener_peak" : "2",
"description" : "mp3, 64kbit",
"title" : "The Kelly Family - Fell In Love With An Alien",
"genre" : "Various",
"url" : ""
}
}
```
Как видно — радио имеет три точки монтирования (на самом деле несколько больше), вещающих один и тот же поток, но с разным качеством. Ну а дальше всё совсем просто:
```
import urllib2
import json
def get_now_playing(stats_url, stats_stream):
"""
Retruns current playing song - artist and title
:param stats_url: url points to icecast stats url (JSON format)
:param stats_stream: main stream to get info
:return: string "Artist - Title"
"""
try:
stats = json.loads(urllib2.urlopen(stats_url).read())
except:
logging.error('get_current_song: Can not open stats url \"%s\"', stats_url)
return False
if stats_stream not in stats:
logging.error('get_current_song: Can not find stream \"%s\" in stats data', stats_stream)
return False
return stats[stats_stream]['title'].encode("utf-8")
```
Функция ходит по указанному адресу статистики, и возвращает исполнителя и заголовок текущей композиции из нужного потока. Поток приходит либо в запросе, либо берётся дефолтный (из настроек).
### Web
Теперь пришла пора заняться сайтом. Для онлайн воспроизведения я давным-давно использую бесплатный flash-плеер от uppod в минималистичных настройках, который смотрит в /flv поток и при воспроизведении отображает проигрываемый трек. Выглядит это так:
А для отображения текущего трека, когда плеер свёрнут или неактивн, я, как и многие другие столкнувшиеся с этой проблемой, до недавнего времени пользовался прокладкой в виде .php скрипта на сервере, который ходил к Icecast за статистикой и возвращал строку с именем проигрываемого трека. Пора избавляться от промежуточных шагов, да и обложки на сайте во время онлайн-воспроизведения показывать бы хотелось, раз уж я теперь умею их отдавать.
Задача решается в два шага:
Добавляем в конфигурацию Nginx для api кастомный header разрешающий обращаться к нему через jQuery с другого хоста:
```
add_header Access-Control-Allow-Origin *;
```
И помещаем в тело веб-страницы радиостанции такой скрипт:
```
var now_playing = '';
setInterval(function () {
jQuery.ajax(
{
type: "GET",
url: "http://api./?partner\_token=&stream=/",
dataType: "xml",
success: xmlParser
})
}, 5000);
function xmlParser(xml) {
var parsedXml = jQuery(xml);
var title = parsedXml.find('title').text();
var artist = parsedXml.find('artist').text();
var arturl = parsedXml.find('arturl').text();
var song = artist.concat(" — ").concat(title);
if (now\_playing !== song) {
jQuery('div.now\_playing').html(song);
jQuery('div.cover\_art').html(arturl);
now\_playing = song;
}
};
```
Как видим, раз в пять секунд скрипт ходит туда же, куда и приложение, авторизуется там, получает .xml файл и забирает из него проигрываемый трек и ссылку на обложку. И если с момента прошлой проверки они изменились — то пишет их в нужные div-ы веб-страницы радиостанции для отображения. Сразу прошу господ фронтенд-разработчиков не ругаться на возможную корявость скрипта — jQuery я вижу первый (ну ладно — второй), раз в жизни. Скрипт может и неказист, но прекрасно работает.
*Под плеером добавлен ещё один div в котором динамически меняются обложки.*
### Заключение
На этом все намеченные задачи решены. Радио вещает как и много лет до этого, но теперь ещё и отображает обложки проигрываемых треков и делает это правильно. Маленький перфекционист внутри моей головы спит, удовлетворённо посапывая, и не отвлекает от работы.
Я понимаю, что описанная тема достаточно узкоспецифичная, и может быть интересна небольшому кругу людей, но думаю, что мой опыт кому-нибудь всё-таки пригодится. Так что полные тексты всего описанного выше кода, плюс примеры настроек Nginx и описание установки, доступны на [GitHub](https://github.com/adel-s/radio).
Всем музыки! | https://habr.com/ru/post/338564/ | null | ru | null |
# Ультра скорость для C# кода, запуск .NET на FPGA процессоре с HASTLAYER
У многих FPGA или ПЛИС, ассоциируется с низкоуровневым программированием на языках VHDL, Verilog, или OpenCL. Платформа .NET уже давно захватила нишу микроконтроллеров, проект nanoFramework. Последние [новости развития nanoFramework](https://habr.com/ru/company/timeweb/blog/669700/) только доказывают твердость намерений платформы .NET освоить работу и на «железе». Казалось бы, пал последний бастион, где не было платформы .NET. Но это был далеко не последний рубеж. Как вам возможность писать код на C#, вместо хардкорного VHDL или Verilog, с последующей загрузки .NET сборок на FPGA процессоры Xilinx для непосредственного исполнения? Открытый проект Hastlayer преобразует сборки .NET в низкоуровневый код для FPGA процессоров, обеспечивая максимальный параллелизм и низкое энергопотребление.
Что такое FPGA?
===============
Микросхема FPGA (field-programmable gate array), она же программируемая логические интегральная схема (ПЛИС), — это микросхема (ИМС), которую можно конфигурировать под сложные вычислительные задачи. В индустрии существует потребность в специализированных микросхемах (ASIC, application-specific integrated circuit, «интегральная схема специального назначения») — от управления космических аппаратов до расчетов по финансовым моделям.
До появления FPGA сильным и одновременно слабым местом специализированных ИМС была жесткая функциональность, заложенная в микросхему, а также высокая сложность проектирования и стоимость запуска в производство. Функциональность ИМС закладывалась на этапе проектирования. Если после производства готовой микросхемы обнаруживались ошибки, то приходилось исправлять, и заново выпускать чипы. А предыдущую партию чипов выбрасывать, т.к. изменить логику микросхемы после производства не представлялось возможным. По сути, это приводило к созданию новой ИМС.
Появление на рынке FPGA-процессоров, стало настоящим прорывом в нише высокопроизводительных вычислений. FPGA-процессоры можно было перепрограммировать сколь угодное число раз, это существенно ускорило время разработки, время выхода продукта на рынок. Появились совершенно новые возможности для разработчиков аппаратных средств, в т. ч. работающих над программированием специализированных интегральных схем типа ASIC.
Технология FPGA решает специализированные задачи существенно быстрее процессоров общего назначения (CPU). Сфера применения FPGA-процессоров достаточно широка, например они используются в облачных вычислениях Microsoft Azure для задач искусственного интеллекта. На FPGA-процессорах от Intel, работает сверточная нейронная сети (DNN), которая обрабатывает информацию в режиме реального времени, например, распознает изображение или голос.
FPGA-процессор представлен матрицей логических вентилей, которая может быть запрограммирована (или «сконфигурирована»).
[](https://habrastorage.org/webt/5z/g1/ie/5zg1ieqdyr8wd3ecvvkfwk0q7ze.jpeg)
*Матрица конфигурируемых логических блоков*
Конфигурируемые логические блоки (CLB) должны взаимодействовать друг с другом и с внешней схемой. Для этих целей FPGA использует матрицу программируемых межсоединений и блоков ввода/вывода (I/O). «Программа» FPGA хранится в ячейках SRAM, которые влияют на функциональность блоков CLB и управляют коммутаторами, которые устанавливают пути подключения.
Идея заключается в том, что CLB включают в себя таблицы поиска, элементы хранения (триггеры и регистры) и мультиплексоры, которые позволяют CLB выполнять логические операции, операции хранения данных и арифметические операции.
FPGA-процессоры поставляются в составе отладочных плат или карт подключаемых по шине PCI-e. Обычно внешние отладочные платы дешевле карт, но скорость обмена данными отставляет желать лучшего, т.к. доступны только интерфейсы USB, Ethernet, UART. В случае использование карт PCI-e достигается максимальная скорость, но в этом случае карту приходится размещать внутри корпуса вычислительного узла.
[](https://habrastorage.org/webt/as/xi/sc/asxisc79r6lwgh2yuxhtoomvj5q.png)
*FPGA-процессор*
Программирование FPGA-процессоров
=================================
Как мы собираемся превратить массив настраиваемых логических блоков (CLB, Configurable Logic Block) в цифровую схему, которая делает именно то, что мы хотим? На первый взгляд это кажется довольно сложной задачей. Действительно, реализация FPGA обычно считается сложнее, чем программирование микроконтроллера. Однако разработка для FPGA не требует глубокого знания функциональности CLB или кропотливой компоновки внутренних межсоединений, так же как разработка для микроконтроллеров не требует глубокого знания инструкций на языке ассемблера процессора или внутренних сигналов управления.
На самом деле, несколько неверно представлять FPGA как самостоятельный компонент. FPGA поддерживается программным обеспечением для разработки, которое выполняет сложный процесс преобразования аппаратного проектирования в программируемые биты, которые определяют поведение межсоединений и CLB.
Это оставляет нам вопрос: как мы «объясним» программе, что должно делать аппаратное обеспечение FPGA?
Для решения этой задачи разработчики создали языки, которые позволяют нам «описывать» аппаратное обеспечение, они называются языки описания аппаратных средств (HDL, hardware description language), а два наиболее распространенных – VHDL и Verilog. Несмотря на очевидное сходство между HDL кодом и кодом, написанным на языке программирования высокого уровня, они принципиально отличаются друг от друга. Код программы определяет последовательность операций, тогда как HDL код больше похож на схему, которая использует текст для представления компонентов и создания взаимосвязей.
[](https://habrastorage.org/webt/42/oy/gu/42oygufkugllibpvrqohwidy3a4.jpeg)
*Пример цифровой схемы*
Пример цифровой схемы, которая соответствует VHDL коду, приведенному ниже:
```
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
----------------------------------------------------
entity circuit_2 is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
c : in STD_LOGIC;
d : in STD_LOGIC;
out1 : out STD_LOGIC;
out2 : out STD_LOGIC);
end circuit_2;
-----------------------------------------------------
architecture Behavioral of circuit_2 is
signal sig1: std_logic;
begin
sig1 <= ( a and b );
out1 <= ( sig1 or c );
out2 <= (not d);
end Behavioral;
```
Теперь вы понимаете основные характеристики устройств программируемой логики и их потенциальные преимущества в отношении процессорных систем. Современные FPGA – это сложные, высокопроизводительные устройства, которые могут быть несколько пугающими для тех, кто привык использовать микроконтроллеры для сбора данных, управления микросхемами специального назначения и выполнения математических операций. Однако вы можете обнаружить, что в некоторых приложениях улучшенная производительность и универсальность стоят дополнительных усилий в разработке.
**Подведем итог.** FPGA, в отличие от CPU и GPU, можно перепрограммировать в соответствии с особенностями решаемой на них вычислительной задачи. Получается синтез специализированного процессора под конкретную задачу. Другими важными отличиями FPGA является пониженное энергопотребление в расчете на единицу вычислительной мощности, а также архитектура с параллельным исполнением множества векторных операций одновременно — так называемая массивно-параллельная мелкозернистая архитектура. Число ядер в чипе FPGA может достигать одного миллиона и более.
Проект HASTLAYER, запуск .NET сборок на FPGA-процессоре
=======================================================
Проект [Hastlayer](https://hastlayer.com) разрабатывает компания [Lombiq Technologies](https://lombiq.com/), занимающейся веб-разработкой с использованием открытых технологий Microsoft. Среди известных разработок компании, система [Orchard CMS](https://orchardcore.net/). Hastlayer доступен в [Azure Marketplace](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/lombiq.hastlayer-evaluation) и [Microsoft AppSource](https://appsource.microsoft.com/en-us/product/web-apps/lombiq.hastlayer-evaluation). В 2020 г. от Евросоюза, проект получил финансирование по программе Horizon 2020.
Теперь разберемся, как работает Hastlayer. Для начала кратко рассмотрим процесс компиляции программы на C#.
Вначале исходный код на C# компилируется в приложение или сборку с расширениями exe или dll на языке CIL. Common Intermediate Language (CIL) — «высокоуровневый ассемблер» виртуальной машины .NET. Промежуточный язык, разработанный фирмой Microsoft для платформы .NET Framework. По синтаксису и мнемонике язык CIL напоминает язык ассемблера. Его можно рассматривать как ассемблер виртуальной машины .NET. Далее, при запуске на выполнение подобного приложения происходит JIT-компиляция (Just-In-Time) в машинный код, который затем выполняется. Таким образом, получим цепочку, **исходный код C#** => **сборка на языке CIL** => **машинный код**.
Обратно вернемся к Hastlayer. Проект Hastlayer предназначен для платформы .NET, которая открыта и не привязана к Microsoft. Одно из преимуществ .NET заключается в том, что для написания программного обеспечения можно использовать большое количество языков программирования, потому что все программы, написанные на любом языке, будут преобразованы (скомпилированы) в один и тот же язык CIL.
Проект Hastlayer обрабатывает CIL-сборки и преобразовывает в конфигурацию для FPGA-процессора, таким образом вы можете создавать свои программы не только на C#, но и на других языках программирования, как С++, Python, PHP, даже на JavaScript. В качестве демонстрации возможности использования других языков, доступен пример [Hast.Samples.FSharpSampleAssembly](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Samples/Hast.Samples.FSharpSampleAssembly/FSharpParallelAlgorithmContainer.fs) на языке F#.
[](https://habrastorage.org/webt/n_/hg/rp/n_hgrpryxxxw6ejozi7zdyinsye.jpeg)
*Запуск Hastlayer на плате Nexys A7*
Пока компиляция CIL кода происходит на удаленных серверах, некоторым это может, не понравится. Однако, по крайней мере, вы загружаете не свой исходный код на C#, а только .NET сборки в виде DLL файлов. Авторы проекта заявляют, что вы можете формировать, в том числе и обфуцированные сборки для защиты интеллектуальной собственности.
Общий процесс использования Hastlayer выглядит следующим образом:
1. Программный код критически важный с точки зрения производительности выносится в отдельную сборку. В эту же сборку добавляется общий класс Hastlayer;
2. Вызовы критически важных методов изменяются так, что бы проходить через слой Hastlayer. Это позволяет напрямую направлять вызовы к аппаратной части, если она доступна. Но в то же время сохраняется возможность запуска сборки .NET обычным способом, если, например FPGA-процессор отсутствует;
3. Преобразование критически важной с точки зрения производительности, сборки выполняется с помощью Hastlayer: генерируется код на языке VHDL, который помещается в Hastlayer hardware framework, затем синтезируется и используется для программы подключенной к FPGA-процессору с инструментами toolchain поставщика оборудования;
4. Теперь методы напрямую вызываются на FPGA-процессоре;
5. Затем результат вычислений передается обратно программным компонентам по стеку вверх, которые и вызвали методы, после чего программа продолжает выполняться обычным образом.
Если углубиться в детали, то работа Hastlayer базируется на [OpenCL](https://habr.com/ru/post/72247/) API. Данное API было разработано компанией NVIDIA для возможности разрабатывать программы для CUDA/AMD Stream, использующие вычислительные возможности GPU. Именно абстракция OpenCL дает возможность использовать различные FPGA-процессоры без переписывания основного программного кода прикладного приложения.
[](https://habrastorage.org/webt/xb/iq/oc/xbiqocuytksahd3hbkhqkzk9e4c.png)
*Общая архитектура системы*
Применение Hastlayer
====================
Hastlayer можно применять в следующих задачах:
* Машинное обучение и искусственный интеллект;
* Обработка изображений, обработка видео и компьютерное зрение;
* Алгоритмический трейдинг, финансовые расчеты;
* Сжатие и анализ данных;
* Майнинг криптовалюты;
* Криптография;
* Встраиваемые системы (роботы, дроны, спутники, IoT).
Hastlayer предназначен для разработчиков программного обеспечения, не обладающими знаниями в области аппаратного проектирования и схемотехники. Предоставляя высокоуровневый набор инструментов, Hastlayer позволяет разработчикам использовать возможности FPGA с их существующими навыками, т.е. разработчикам не требуется получать отдельное специализированное знание для разработки конфигурации для FPGA-процессора, достаточно знание платформы .NET, принципов параллельных вычислений, и хотя бы немного аппаратных средств. Это позволяет существенно расширить круг потенциальных разработчиков, а вместе с тем и компаний использующих FPGA-процессоры.
Оборудование
============
### Nexys A7 (Nexys 4 DDR)
Для начальной разработки рекомендуется использовать плату [Nexys A7](https://digilent.com/shop/nexys-a7-fpga-trainer-board-recommended-for-ece-curriculum/), которая стоит всего 249 долларов. Но на этой плате далеко не все можно реализовать, что доступно в Hastlayer. Например, из-за небольшого объема, плата не может вместить большие алгоритмы и вдобавок поддерживает только медленные каналы связи (USB, Ethernet). Таким образом, Hastlayer с этой платой, подходит только для простых алгоритмов, которым необходимо обмениваться только небольшим объемом данных.
[](https://habrastorage.org/webt/yf/u_/q2/yfu_q2cyx6ofa2-9rwa0crbxn-i.jpeg)
*Плата Nexys A7*
Nexys A7 (предыдущее название Nexys 4 DDR) — недорогая, но мощная FPGA плата для разработки. Разработанная на основе семейства процессоров Xilinx Artix-7 FPGA, Nexys A7 представляет собой готовую к использованию платформу для разработки цифровых схем, которую удобно использовать в учебной среде.
Плата Nexys A7 оборудована большим количеством различных интерфейсов, таких как 10/100 Ethernet, USB, UART, JTAG и VGA. На плате присутствует датчик температуры, микрофон и акселерометр.
### Xilinx Alveo и AWS EC2 F1 instances
[](https://habrastorage.org/webt/ty/lx/gz/tylxgzz_dxt-q8hke2wygbg8pis.png)
*Xilinx Alveo*
Для больших нагрузок рекомендуется использовать [платы Xilinx Alveo U50, U200, U250 или U280](https://www.xilinx.com/products/boards-and-kits/alveo.html). Данные карты, также доступны в виде облачного сервиса от [Nimbix](https://www.nimbix.net/).
[Инстансы F1 в Amazon EC2](https://aws.amazon.com/ec2/instance-types/f1/) на базе Xilinx обеспечат гибкую масштабируемость вашей системы.
Схема вычислений .NET приложения с использованием Xilinx Alveo
[](https://habrastorage.org/webt/nu/dd/kg/nuddkgv4fsez1xfmvvp8x1bqn88.png)
*Модель исполнения карты Xilinx Alveo*
### .NET в космосе
23 февраля 2022 управляющий директор Lombiq Technologies и создатель Hastlayer, Zoltán Lehóczky [провел демонстрацию](https://twitter.com/satsearchco/status/1491011808307867650) как использовать аппаратное ускорение .NET с Hastlayer, в бортовых спутниковых системах, таких как [CubeSat](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D0%B1%D1%81%D0%B0%D1%82). Hastlayer подходит для небольших и простых спутников, благодаря быстрой разработке и низкого порога вхождения для разработчиков.
[](https://habrastorage.org/webt/9a/6r/wd/9a6rwdidzxz0frjurfs9bf5x3ns.jpeg)
*Презентация Hastlayer для проекта satsearch*
Благодаря платформе .NET, разработчики бортовых спутниковых систем, как и разработчики веб/мобильных приложений смогут:
* Получить доступ к современным инструментам .NET;
* Использовать развитые IDE-среды;
* Используйте расширенную отладку приложения;
* Выполнять автотесты и мониторить производительность относительно участков программного кода;
* Использовать различные платформы для разработки и запуска приложений (Windows, Mac, некоторые дистрибутивы Linux).
[](https://habrastorage.org/webt/ak/hn/jk/akhnjkwzjqkfyjkibly3542y9la.jpeg)
*Xilinx Zynq-7000 FPGA accelerator*
Несмотря на то, что аппаратные платформы, такие как Xilinx Zynq, уже стали квазистандартами из-за их широкого использования, каждый производитель бортовых компьютеров (OBC) использует собственный набор инструментов SDK, с которым разработчикам необходимо разобраться, чтобы эффективно использовать все возможности платформы. Использование Hastlayer позволяет разработчикам унифицировать подход к написанию ПО, несмотря на различия в аппаратной части, как в свое время это было сделано в [.NET nanoFramework](https://habr.com/ru/post/549012/).
Но возможности .NET не безграничны. Да, разработчики пишут безопасный управляемый код, но этот код не является детерминированным. Код на C# можно использовать для разработки приложений и ускорения обработки бортовой информации, но он не подходит для вычислений в режиме реальном времени или критически важных подсистем.
### .NET в Catapult FPGA от Microsoft
С конца [2019 года проект](https://hastlayer.com/blog/supporting-large-catapult-fpgas-hastlayer-v1-1-is-here) Hastlayer поддерживает большие FPGA-процессоры проекта [Microsoft Catapult platform](https://www.microsoft.com/en-us/research/project/project-catapult/). Проект Catapult был разработан в лаборатории Microsoft Research. Исследователи ставили себе целью, использование FPGA-процессоров для задач связанных с искусственным интеллектом, вычислений с большими данными, с предоставлением облачного доступа. Компания Microsoft одни из первых, среди поставщиков облачных решений, кто предоставила вычисления на FPGA-процессорах.
[](https://habrastorage.org/webt/e_/oj/vw/e_ojvwj38udy6ikpffa2rjgryxc.jpeg)
*Используемая в проекте Catapult плата FPGA, на базе Intel Stratix 10*
Проект Catapult себя зарекомендовал в таких службах как, Bing’s IndexServe engine, Azure Machine Learning, Azure Networking, Azure Cloud Server Infrastructure (CSI), и Azure Storage.
[](https://habrastorage.org/webt/jk/ih/zh/jkihzhtb0w0z5zr3vlfgh6goulc.jpeg)
*В 2015 г. впервые использовали сервера с FPGA-платами в дата-центрах для ускорения работы Bing и Azure*
В 2017 г. Microsoft уже на базе проекта Catapult презентовала новый [проект Brainwave](https://www.microsoft.com/en-us/research/blog/microsoft-unveils-project-brainwave/) для решения задач в области искусственного интеллекта в режиме реального времени. Режим реального времени означает, что система обрабатывает поступающие данный со сверхмалой задержкой, такие потоки данных как поисковые запросы, видео, потоки датчиков или взаимодействие с пользователями.
Тесты скорости использования Hastlayer по сравнению со стандартным .NET кодом
=============================================================================
Необходимо обратить внимание, что прямое сравнение производительности несколько затруднено т.к. при использовании FPGA вы не запускаете программу на процессоре, как при использовании CPU или GPU, вместо этого создается процессор из вашего алгоритма.
Тем не менее, приведенные ниже результаты демонстрируют сравнение FPGA-процессора и хост-ПК (или ЦП), находящиеся примерно на одном уровне; например, сравнивается ЦП среднего уровня с FPGA среднего уровня.
Представленные алгоритмы в примерах Hastlayer, доступны для самостоятельной проверки. Вы можете просмотреть [бенчмарк Zynq на GitHub](https://github.com/Lombiq/Hastlayer-SDK/blob/2c2732099657888fe444a1eb278727fcee51b671/Docs/Benchmarks.md#zynq), и некоторые [примеры SDK Hastlayer](https://github.com/Lombiq/Hastlayer-SDK/tree/dev/Samples).
В тестах сравнивается аппаратное ускорение [Zynq-7000 FPGA](https://www.xilinx.com/products/silicon-devices/soc/zynq-7000.html) с SoM ARM. В тестах используется модуль Trenz Electric TE0715-04-30-1C, подключенный к несущей плате TE0706 (с форм-фактором, аналогичным Raspberry Pi).
Характеристики следующие:
* FPGA: Xilinx Zynq XC7Z030-1SBG485C SoC FPGA. Основная частота 150 МГц;
* Хост: двухъядерный процессор ARM Cortex-A9 MPCore;
* Обе системы используют 1 ГБ (32-разрядной) памяти DDR3L SDRAM.
Согласно отчетам Trenz, энергопотребление составляет около 5 Вт. С помощью встроенного электросчетчика были получены результаты в потребление не менее 4,6 Вт.
В рамках теста было подготовлено две сборки, первая выполнялась только на CPU, другая только на FPGA. Для репрезентативности сборки неоднократно выполнялись в циклах.
[](https://habrastorage.org/webt/ft/zj/p5/ftzjp5z3vx60v3c-cywr_uvdhdk.png)
*Сравнение эффективности использования Hastlayer*
Детальные результаты тестов доступны в [таблице на GitHub](https://github.com/Lombiq/Hastlayer-SDK/blob/c39fdf9bb729e9bf1c773a481a40a4960586514a/Docs/Attachments/TE0715-04-30-1C%20benchmark.pdf), включая потребление электроэнергии в расчете полезной нагрузки на CPU и FPGA.
Разработка
==========
Разработка ведется в [Visual Studio 2019 или старше](https://www.visualstudio.com/downloads/) (любая редакция). Если используется Linux, то необходимо использовать проект [Mono](https://www.mono-project.com/). Если у вас имеется совместимая FPGA плата, то вы можете запустить готовый пример для теста без обращения к службе Hastlayer Remote Services. Документация располагается в папке GitHub — [Lombiq/Hastlayer-SDK/blob/dev/Docs/](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Docs). Сборка должны быть основана на .NET Framework или .NET Core 3.1- 6.0.
Рассмотрим первый демонстрационный пример [Hast.Samples.Demo](https://github.com/Lombiq/Hastlayer-SDK/tree/dev/Samples/Hast.Samples.Demo), который запускает простые параллельные вычисления на FPGA-процессоре, файл [Program.cs](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Samples/Hast.Samples.Demo/Program.cs). Программный код разделяется на три региона:
* Configuration;
* HardwareGeneration;
* Execution.
#### region Configuration
В этом участке кода происходит инициализация самого FPGA-процессора, затем добавляется точка взаимодействия, и добавляется событие срабатывания после вычислений на процессоре.
```
using var hastlayer = Hastlayer.Create();
#region Configuration
var configuration = new HardwareGenerationConfiguration("Nexys A7", "HardwareFramework");
configuration.AddHardwareEntryPointType();
configuration.VhdlTransformerConfiguration().VhdlGenerationConfiguration = VhdlGenerationConfiguration.Debug;
hastlayer.ExecutedOnHardware += (_, e) =>
Console.WriteLine(
StringHelper.ConcatenateConvertiblesInvariant(
"Executing on hardware took ",
e.Arguments.HardwareExecutionInformation.HardwareExecutionTimeMilliseconds,
" milliseconds (net) ",
e.Arguments.HardwareExecutionInformation.FullExecutionTimeMilliseconds,
" milliseconds (all together)."));
#endregion Configuration
```
#### region HardwareGeneration
Определяем проксирующий/шлюз класс взаимодействия с FPGA-процессором.
```
#region HardwareGeneration
Console.WriteLine("Hardware generation starts.");
var hardwareRepresentation = await hastlayer.GenerateHardwareAsync(
new[]
{
typeof(ParallelAlgorithm).Assembly,
},
configuration);
#endregion HardwareGeneration
```
#### region Execution
Параллельные алгоритмы хорошо демонстрируют ускорение с помощью Hastlayer. Для примера берется класс/сборка [ParallelAlgorithm](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Samples/Hast.Samples.SampleAssembly/ParallelAlgorithm.cs#L12), которая будет исполняться непосредственно на FPGA-процессоре.
Вначале выполняется замер времени работы на общем CPU. Ничего сложного, просто вызывается метод *ParallelAlgorithm().Run(...)*. По итогу вычислений выводится информация о затраченном времени на вычисления.
```
#region Execution
Console.WriteLine("Hardware generated, starting software execution.");
var sw = System.Diagnostics.Stopwatch.StartNew();
var cpuOutput = new ParallelAlgorithm().Run(234234);
sw.Stop();
Console.WriteLine(StringHelper.ConcatenateConvertiblesInvariant("On CPU it took ", sw.ElapsedMilliseconds, " milliseconds."));
```
Затем выполняются вычисления уже на FPGA-процессоре.
```
Console.WriteLine("Starting hardware execution.");
var parallelAlgorithm = await hastlayer.GenerateProxyAsync(hardwareRepresentation, new ParallelAlgorithm());
var memoryConfig = hastlayer.CreateMemoryConfiguration(hardwareRepresentation);
var output1 = parallelAlgorithm.Run(234234, hastlayer, hardwareRepresentation.HardwareGenerationConfiguration);
var output2 = parallelAlgorithm.Run(123, hastlayer, hardwareRepresentation.HardwareGenerationConfiguration);
var output3 = parallelAlgorithm.Run(9999, hastlayer, hardwareRepresentation.HardwareGenerationConfiguration);
#endregion Execution
```
Как видим, программный код вызова алгоритма на FPGA-процессоре достаточно прост. В прокси-класс добавляем алгоритм *new ParallelAlgorithm()* для вычислений на FPGA-процессоре, затем точно так же, как и с CPU вызываем запуск.
И все, получаем результаты и сравниваем выигрыш в скорости.
А теперь посмотрим программный код метода *ParallelAlgorithm().Run(...)* файл [ParallelAlgorithm.cs](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Samples/Hast.Samples.SampleAssembly/ParallelAlgorithm.cs):
```
public virtual void Run(SimpleMemory memory)
{
var input = memory.ReadInt32(RunInputInt32Index);
var tasks = new Task[MaxDegreeOfParallelism];
// Hastlayer will figure out how many Tasks you want to start if you kick them off in a loop like this. If this
// is more involved then you'll need to tell Hastlayer the level of parallelism, see the comment in
// ParallelAlgorithmSampleRunner.
for (int i = 0; i < MaxDegreeOfParallelism; i++) { tasks[i] = Task.Factory.StartNew( indexObject =>
{
var index = (int)indexObject;
int result = input + (index * 2);
var even = true;
for (int j = 2; j < 9_999_999; j++)
{
if (even) result += index; else result -= index;
even = !even;
}
return result;
},
i);
}
// Task.WhenAny() can be used too.
Task.WhenAll(tasks).Wait();
int output = 0;
for (int i = 0; i < MaxDegreeOfParallelism; i++)
{
output += tasks[i].Result;
}
memory.WriteInt32(RunOutputInt32Index, output);
}
```
Как видим все просто, привычный алгоритм на C#. Согласитесь, на порядок проще примера VHDL-кода, который представлен в начале поста.
Приблизительная оценка сложности программирования отображена на диаграмме, чем выше значение, тем сложнее изучение, по заявлениям разработчиков Hastlayer.
[](https://habrastorage.org/webt/td/lt/fw/tdltfwshfqqovr-otuxrgy66bds.png)
*Сравнение сложности изучения Hastlayer*
Подробно про типы данных и построение алгоритма в документации — [Working with Hastlayer](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Docs/WorkingWithHastlayer.md).
Насколько хорош Hastlayer можно оценить, посмотрев [тесты производительности](https://github.com/Lombiq/Hastlayer-SDK/blob/dev/Docs/Benchmarks.md).
Итог
====
Стартап Hastlayer безусловно заслуживает внимания. Проект Arduino в свое время, в сфере программирования микроконтроллеров сделал революцию и перевернул всю индустрию. Используя подход абстракций оборудования, теперь разработчику не требуется в деталях разбираться в какой регистр записать, а из какого регистра считать данные. Теперь он фокусируется на выполнение своей задачи и не задумывается над аппаратной реализации платформы. Вторым хорошим примером, для платформы .NET является фреймворк .NET nanoFramework. Написанный программный код, одинаково хорошо работает, как и на микроконтроллерах ESP32, так и на STM32. С единственной разницей, требуется указывать номера контактов для интерфейсов, и объемы памяти могут быть различны. Но при переносе программного кода, разработчику не придется переписывать с нуля основной код, и это существенный прогресс с точки зрения массовости и привлекательности платформы.
Проект Hastlayer делает то же самое, что и Arduino и NET nanoFramework, только в сфере использования FPGA-процессоров. Программный код для Hastlayer переносим между различными процессорами, мало того вычисления можно с легкостью перенести в облако Azure или AWS. С точки зрения работодателя гораздо проще найти на рынке .NET специалиста, немного его обучить для работы с Hastlayer, чем найти специалиста знающего, что такое VHDL-код.
Массовые вычисления на FPGA-процессорах это вторая волна революции, после представлению миру Arduino-подхода для программирования микроконтроллеров. Одним из признаков увеличения интереса к FPGA вычислениям является [запуск сервиса бесплатной аренды отладочных плат с FPGA](https://habr.com/ru/post/674166/).
Вполне возможно, через несколько лет, на отладочной плате вместе с микроконтроллером типа ESP32 начнут размещать небольшой FPGA-сопроцессор, для небольших вычислительных задач, с возможностью программирования на C#.
.NET и C# — технологии, за которыми будущее!
Ресурсы
=======
* [Hastlayer — Lombiq Technologies](https://hastlayer.com/)
* [Hastlayer-SDK — GitHub](https://github.com/Lombiq/Hastlayer-SDK/tree/dev)
* [Hastlayer Samples — GitHub](https://github.com/Lombiq/Hastlayer-SDK/tree/dev/Samples)
* [Spotlight advancing satellite software development with Hastlayer — of satsearch member Lombiq Technologies satsearch blog](https://blog.satsearch.co/2021-11-09-satellite-software-development-with-hastlayer-by-lombiq)
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/674800/ | null | ru | null |
# Карманная книга по TypeScript. Часть 1. Основы
* [Часть 1. Основы](https://habr.com/ru/company/macloud/blog/559902/)
* [Часть 2. Типы на каждый день](https://habr.com/ru/company/macloud/blog/559976/)
* [Часть 3. Сужение типов](https://habr.com/ru/company/macloud/blog/560594/)
* [Часть 4. Подробнее о функциях](https://habr.com/ru/company/macloud/blog/561470/)
* [Часть 5. Объектные типы](https://habr.com/ru/company/macloud/blog/562054/)
* [Часть 6. Манипуляции с типами](https://habr.com/ru/company/macloud/blog/562786/)
* [Часть 7. Классы](https://habr.com/ru/company/macloud/blog/563408/)
* [Часть 8. Модули](https://habr.com/ru/company/macloud/blog/563722/)
*Обратите внимание*: для большого удобства в изучении книга была оформлена в виде [прогрессивного веб-приложения](https://typescript-handbook.ru/).
С сегодняшнего дня мы начинаем серию публикаций адаптированного и дополненного перевода [`"Карманной книги по TypeScript`".](https://www.typescriptlang.org/docs/handbook/intro.html)
Каждое значение в `JavaScript` при выполнении над ним каких-либо операций ведет себя определенным образом. Это может звучать несколько абстрактно, но, в качестве примера, попробуем выполнить некоторые операции над переменной `message`:
```
// Получаем доступ к свойству `toLowerCase`
// и вызываем его
message.toLowerCase()
// Вызываем `message`
message()
```
На первой строке мы получаем доступ к свойству `toLowerCase` и вызываем его. На второй строке мы пытаемся вызвать `message`.
Предположим, что мы не знаем, какое значение имеет `message` — обычное дело — поэтому мы не можем с уверенностью сказать, какой результат получим в результате выполнения этого кода.
* Является ли переменная `message` вызываемой?
* Имеет ли она свойство `toLowerCase`?
* Если имеет, является ли `toLowerCase` вызываемым?
* Если оба этих значения являются вызываемыми, то что они возвращают?
Ответы на эти вопросы, как правило, хранятся в нашей памяти, поэтому остается только надеяться, что мы все помним правильно.
Допустим, `message` была определена следующим образом:
```
const message = 'Hello World'
```
Как вы, наверное, догадались, при запуске `message.toLowerCase()` мы получим ту же строку, только в нижнем регистре.
Что насчет второй строки кода? Если вы знакомы с `JS`, то знаете, что в этом случае будет выброшено исключение:
```
TypeError: message is not a function
// Ошибка типа: message — это не функция
```
Было бы здорово, если бы мы имели возможность избегать подобных ошибок.
При запуске нашего кода, способ, с помощью которого движок `JS` определяет, что делать, заключается в выяснении *типа* (type) значения — каким поведением и возможностями он обладает. На это намекает `TypeError` — она говорит, что строка `'Hello World'` не может вызываться как функция.
Для некоторых значений, таких как примитивы `string` и `number`, мы можем определить их тип во время выполнения кода (runtime) с помощью оператора `typeof`. Но для других значений, таких как функции, соответствующий механизм для определения типов во время выполнения отсутствует. Например, рассмотрим следующую функцию:
```
function fn(x) {
return x.flip()
}
```
Читая этот код, мы можем сделать вывод, что функция будет работать только в случае передачи ей объекта с вызываемым свойством `flip`, но `JS` не обладает этой информацией. Единственным способом определить, что делает `fn` с определенным значением, в чистом `JS` является вызов этой функции. Такой вид поведения затрудняет предсказание поведения кода во время его написания.
В данном случае *тип* — это описание того, какие значения могут передаваться в `fn`, а какие приведут к возникновению ошибки. `JS` — это язык с динамической (слабой) типизацией — мы не знаем, что произойдет, до выполнения кода.
*Статическая* система типов позволяет определять, что ожидает код до момента его выполнения.
Проверка статических типов
--------------------------
Вернемся к `TypeError`, которую мы получили, пытаясь вызвать `string` как функцию. Никто не любит получать ошибки или *баги* (bugs) при выполнении кода.
Было бы здорово иметь инструмент, помогающий нам выявлять баги перед запуском кода. Это как раз то, что делают инструменты проверки статических типов, подобные `TS`. Системы статических типов описывают форму и поведение значений. `TS` использует эту информацию и сообщает нам о том, что, возможно, имеет место несоответствие определенным типам.
```
const message = 'Hello!'
message()
// This expression is not callable. Type 'String' has no call signatures. Данное выражение не является вызываемым. Тип 'String' не обладает сигнатурами вызова
```
При использовании `TS`, мы получаем ошибку перед выполнением кода (на этапе компиляции).
Ошибки, не являющиеся исключениями
----------------------------------
До сих пор мы говорили об ошибках времени выполнения — случаях, когда движок `JS` сообщает нам о том, что произошло нечто с его точки зрения бессмысленое. Спецификация `ECMAScript` содержит конкретные инструкции относительно того, как должен вести себя код при столкновении с чем-то неожиданным.
Например, спецификация определяет, что при попытке вызвать нечто невызываемое должно быть выброшено исключение. На основании этого, мы можем предположить, что попытка получить доступ к несуществующему свойству объекта также приводит к возникновению ошибки. Однако, вместо этого возвращается `undefined`:
```
const user = {
name: 'John',
age: 30
}
user.location // undefined
```
В `TS` это, как и ожидается, приводит к ошибке:
```
const user = {
name: 'John',
age: 30
}
user.location
// Property 'location' does not exist on type '{ name: string; age: number; }'. Свойства 'location' не существует в типе...
```
Это позволяет «перехватывать» (catch) многие легальные, т.е. допустимые (с точки зрения спецификации) ошибки.
Например:
* опечатки
```
const announcement = «Hello World!»;
// Как быстро вы заметите опечатку?
announcement.toLocaleLowercase();
announcement.toLocalLowerCase();
// Вероятно, мы хотели написать это
announcement.toLocaleLowerCase();
```
* функции, которые не были вызваны
```
function flipCoin() {
// Должно было быть `Math.random()`
return Math.random < 0.5;
// Operator '<' cannot be applied to types '() => number' and 'number'. Оператор '<' не может быть применен к типам...
}
```
* или логические ошибки
```
const value = Math.random() < 0.5 ? «a» : «b»;
if (value !== «a») {
// ...
} else if (value === «b») {
// This condition will always return 'false' since the types 'a' and 'b' have no overlap. Данное условие будет всегда возвращать 'false', поскольку типы 'a' и 'b' не пересекаются
// Упс, недостижимый участок кода
}
```
Типы, интегрированные в среду разработки
----------------------------------------
`TS` защищает нас от совершения ошибок. Как он это делает? Все просто. Поскольку `TS` обладает информацией о системе типов, используемых в нашем коде, он начинает предполагать (делать вывод относительно того), какое свойство мы хотим использовать. Это означает, что `TS` показывает сообщения об ошибках и варианты завершения в процессе написания кода. Редактор кода, поддерживающий `TS`, также может предлагать способы «быстрого исправления» ошибок, предоставлять средства для автоматического рефакторинга, т.е. для легкой реорганизации кода, а также для полезной навигации, например, для быстрого перехода к определениям переменных или для поиска ссылок на переменную и т.д.
`tsc`, компилятор `TS`
----------------------
Для начала установим `tsc`:
```
yarn global add tsc
# или
npm i -g tsc
```
Создадим файл `hello.ts`:
```
// Приветствуем всех собравшихся
console.log('Hello World!')
```
И скомпилируем (преобразуем) его в `JS`:
```
tsc hello.ts
```
Отлично. Мы не получили сообщений об ошибках в терминале, следовательно, компиляция прошла успешно. Заглянем в текущую директорию. Мы видим, что там появился файл `hello.js`. Этот файл является идентичным по содержанию файлу `hello.ts`, поскольку в данном случае `TS` нечего было преобразовывать. Кроме того, компилятор старается сохранять код максимально близким к тому, что написал разработчик.
Теперь попробуем вызвать ошибку. Перепишем `hello.ts`:
```
function greet(person, date) {
console.log(`Hello, ${person}! Today is ${date}.`)
}
greet('John')
```
Если мы снова запустим `tsc hello.ts`, то получим ошибку:
```
Expected 2 arguments, but got 1. Ожидалось 2 аргумента, а получен 1
```
`TS` сообщает нам о том, что мы забыли передать аргумент в функцию `greet`, и он прав.
### Компиляция с ошибками
Вы могли заметить, что после компиляции кода, содержащего ошибку, файл `hello.js` все равно обновился. Это объясняется тем, что `TS` считает вас умнее себя. Это также не мешает работающему JS-коду, при наличии некоторых ошибок, связанных с типами, благополучно работать дальше при постепенном переносе проекта на `TS`. Однако, если вы хотите, чтобы `TS` был более строгим, то можете указать флаг `--noEmitOnError`. Попробуйте снова изменить `hello.ts` и скомпилировать его с помощью такой команды:
```
tsc --noEmitOnError hello.ts
```
Вы увидите, что `hello.js` больше не обновляется.
Явные типы
----------
Давайте отредактируем код и сообщим `TS`, что `person` — это `string`, а `date` — объект `Date`. Мы также вызовем метод `toDateString()` на `date`:
```
function greet(person: string, date: Date) {
console.log(`Hello, ${person}! Today is ${date.toDateString().}`)
}
```
То, что мы сделали, называется добавлением аннотаций типа (type annotations) к `person` и `date` для описания того, с какими типами значений может вызываться `greet`.
После этого `TS` будет сообщать нам о неправильных вызовах функции, например:
```
function greet(person: string, date: Date) {
console.log(`Hello, ${person}! Today is ${date.toDateString()}.`);
}
greet('John', Date());
// Argument of type 'string' is not assignable to parameter of type 'Date'. Аргумент типа 'string' не может быть присвоен параметру типа 'Date'
```
Вызов `Date()` возвращает строку. Для того, чтобы получить объект `Date`, следует вызвать `new Date()`:
```
greet('John', new Date());
```
Во многих случаях нам не нужно явно аннотировать типы, поскольку `TS` умеет предполагать (infer) тип или делать вывод относительно типа на основе значения:
```
const msg = 'Hello!'
// const msg: string
```
Удаление типов
--------------
Давайте скомпилируем функцию `greet` в `JS` с помощью `tsc`. Вот что мы получаем:
```
«use strict»;
function greet(person, date) {
console.log(«Hello « + person + «! Today is « + date.toDateString() + «.»);
}
greet(«John», new Date());
```
*Обратите внимание* на две вещи:
1. Наши параметры `person` и `date` больше не имеют аннотаций типа.
2. Наша «шаблонная строка» — строка, в которой используются обратные кавычки (символ ```) — была преобразована в обычную строку с конкатенациями (+).
Что касается первого пункта, то все дело в том, что аннотации типа не являются частью `JS` (или `ECMAScript`, если быть точнее), поэтому для того, чтобы преобразованный `JS` мог выполняться в браузере, они полностью удаляются из кода, как и любые другие специфичные для `TS` вещи.
Понижение уровня кода
---------------------
Процесс, который часто называют понижением уровня кода (downleveling), состоит в преобразовании кода в код более старой версии, например, JS-кода, соответствующего спецификации `ECMAScript 2015` (`ES6`), в код, соответствующий спецификации `ECMAScript 3` (`ES3`). Шаблонные литералы (или шаблонные строки) были представлены в `ES6`, а `TS` по умолчанию преобразует код в `ES3`, поэтому наша шаблонная строка превратилась в обычную строку с объединениями. Для изменения спецификации, которой должен соответствовать компилируемый код, используется флаг `--target`. Например, команда `tsc --target es2015 hello.ts` оставит нашу строку неизменной.
Строгость
---------
Строгость проверок, выполняемых `TS`, определяется несколькими флагами. Флаг `--strict` или настройка `"strict": true` в [`tsconfig.json`](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) включает максимальную строгость. Двумя другими главными настройками, определяющими строгость проверок, являются `noImplicitAny` и `strictNullChecks`.
* `noImplicitAny` — когда `TS` не может сделать точный вывод о типе значения, он присваивает такому значению наиболее мягкий тип `any`. Данный тип означает, что значением переменной может быть что угодно. Однако, использование данного типа противоречит цели использования `TS`. Использование флага `noImplicitAny` или соответствующей настройки приводит к тому, что при обнаружении переменной с неявным типом `any` выбрасывается исключение
* `strictNullChecks` — по умолчанию значения `null` и `undefined` могут присваиваться любым другим типам. Это может облегчить написание кода в некоторых ситуациях, но также часто приводит к багам, если мы забыли их правильно обработать. Флаг `strictNullChecks` или соответствующая настройка делает обработку `null` и `undefined` более явной и избавляет нас от необходимости беспокоиться о том, что мы забыли их обработать
---
Облачные серверы от [Маклауд](https://macloud.ru/?partner=4189mjxpzx) быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=igor) | https://habr.com/ru/post/559902/ | null | ru | null |
# Изменения модальной презентации экранов в iOS 13
Всем привет!
Меня зовут Илья, я из Tinkoff.ru. Я перевел для вас статью от Geoff Hackworth про то, как изменился стиль модальной презентации в iOS 13, на что это повлияло и как работает обратная совместимость с предыдущими версиями iOS и Xcode.
Введение
--------
На момент написания статьи WWDC 2019 подходит к концу. Как и многие разработчики для iOS, я медленно обрабатываю всю новую информацию, которую Apple нам дала, и в ближайшие недели (и месяцы!) Постараюсь посмотреть столько видео, сколько смогу.
У меня появилось три вопроса по поводу моих собственных приложений:
* Мои текущие приложения работают без проблем на iOS 13? У Apple долгая история обратной совместимости, основанная на версии Xcode, с которой было создано приложение. История показывает, что приложения, созданные в Xcode 10 под iOS 13, будут вести себя так, как если бы они работали на iOS 12. Но это не всегда так.
* Работают ли мои приложения при сборке с Xcode 11 / iOS 13? Сборка с использованием новейших инструментов позволяет приложению работать по-новому, минуя обратную совместимость с предыдущими версиями iOS. Что-нибудь сломалось?
* Какие изменения можно / нужно сделать, чтобы мои приложения работали лучше или использовали преимущества новых функций iOS 13? Это самая большая задача, и она займет больше времени для изучения и реализации. Это исследование для отдельной статьи.
Я еще не установил iOS 13 на реальном устройстве, но могу провести тестирование пункта №1, установив приложения, созданные в Xcode-10, на симулятор iOS 13.
Я все еще работаю над пунктом №2, но на основании моего начального тестирования и чтения твитов от других разработчиков, делающих подобные открытия, я обнаружил ряд поведенческих изменений в моих приложениях при сборке с Xcode 11. У меня есть много видео для просмотра и информация для усвоения, но в этом посте я хочу сосредоточиться на заметных сразу и потенциально разрушительных изменениях в презентации UIViewController в iOS 13.
Изменение стиля модальной презентации по-умолчанию
--------------------------------------------------
По умолчанию модальная презентация теперь представляет собой "страницу" (ориг. Page Sheet), а не полный экран (Full Screen). Документация для `modalPresentationStyle` гласит:
> По умолчанию используется UIModalPresentationAutomatic для iOS, начиная с iOS 13.0, и UIModalPresentationFullScreen в предыдущих версиях.
>
> По умолчанию UIViewController, если в качестве `modalPresentationStyle` установлен UIModalPresentationAutomatic, использует UIModalPresentationPageSheet, но системные контроллеры могут использовать другие стили показа для UIModalPresentationAutomatic.
Последствия этого изменения различаются для iPhone и iPad.
Модальная презентация на iPhone
-------------------------------
Стили презентации Page Sheet, Form Sheet и Popover на iPhone адаптированы к полноэкранному режиму, если только метод `UIAdaptivePresentationControllerDelegate` не используется для предотвращения адаптации. Например, экран настроек может быть презентован в стиле Form Sheet, чтобы он отображался в полноэкранном режиме на iPhone и в уменьшенном виде на iPad. Технически внешний вид / адаптация зависят от ширины. Презентации в стиле Page Sheet / Form Sheet / Popover на устройствах Landscape iPhone Plus и XS Max не занимают весь экран, потому что они имеют обычную ширину. Внешний вид iPad зависит от размеров slide over и режима многозадачности.
На следующих снимках экрана показана презентация Form Sheet на iPhone XS для трех случаев: сборка в Xcode 10 для iOS 12, сборка в Xcode 10 для iOS 13, сборка в Xcode 11 для iOS 13.
Обратная совместимость iOS 12 с iOS 13 для сборки Xcode 10 приводит к полноэкранному представлению. Стиль сгруппированных UITableView изменился в iOS 13, чтобы скрыть пространство над первым разделом при отсутствии заголовка. Даже сборка Xcode 10 / iOS 12 ведет себя по-разному при запуске на iOS 13, а это не то, что я ожидал.
Самым большим изменением в iOS 13, конечно же, является карточное представление экранов (ориг. card-like appearance). UIViewController был уменьшен в размерах, и его верх все еще немного виден за вновь представленным UIViewController. UIWindow за корневым UIViewController также немного видимо. Черный фон UIWindow по умолчанию выглядит великолепно, особенно на устройствах с выемкой (notch). Некоторые из моих приложений устанавливали фон UIWindow белым (по причинам, которые я уже не помню), и это выглядело довольно уродливо. Я быстро исправил это!
### Поведение UIViewController при новом модальном стиле показа
Если представленный UIViewController показывает еще один UIViewController, карточки накладываются друг на друга с приятной анимацией. Обратите внимание, что виден только последний показанный UIViewController и немного предыдущего:
Другое потенциально важное различие в поведении — это то, что происходит с показывающим (ориг. presenting) UIViewController. Полноэкранное представление (ориг. full screen presentation), которое полностью покрывает UIViewController, приведет к удалению UIViewController из иерархии. Но в случае с новой карточной презентацией UIViewController должен оставаться в иерархии, потому что он все еще видим. Однако, хотя пользователь может видеть только два UIViewController одновременно, многократный показ UIViewController не удаляет нижние UIViewController из иерархии.
### Изменения размеров
Новый внешний вид в стиле карточки означает, что показанный UIViewController не такой высокий на iOS 13, как на iOS 12:
### Я хочу full screen!
Явный запрос на показ UIViewController в режиме Full Screen предотвратит показ экрана в стиле карточки. Однако, это может нарушить поведение приложения на iPad. Пожалуйста, не поддавайтесь искушению проверить идиому устройства и использовать другой стиль презентации для iPhone и iPad. Если последние несколько лет нас чему-то и научили, так это тому, что мы не должны делать предположений на основе типов устройств или размеров экрана. Если вы хотите, чтобы на iPad отображался Page / Form Sheet, но на iPhone был Full Screen, вы можете использовать `UIAdaptivePresentationControllerDelegate` для адаптации к полноэкранному режиму в условиях компактной ширины.
Модальная презентация на iPad
-----------------------------
### Form Sheets
Экраны, показанные в стиле Form Sheet, остаются неизменными в iOS 13:
### Page Sheets
Как отмечалось выше, `modalPresentationStyle` по умолчанию в iOS 13 теперь Page Sheet. На iPad размер UIViewController в этом стиле изменился как в книжной, так и в альбомной ориентации:
Как и в iOS 12, ограничение по "читаемому контенту" (ориг. readable content size) меняет размер при изменении категории размера контента (ориг. content size category). Реальный размер кажется разным на iOS 12 и 13 в некоторых категориях размера контента.
Сам UIViewController, презентованный в стиле Page Sheet, также увеличивается на iOS 13 с увеличением категории размера контента. Вот так выглядит категория «Extra Extra Extra Large» (максимальный размер, доступный без включения larger accessibility sizes):
### Остальные виды презентации
Документация для `modalPresentationStyle` гласит:
> По умолчанию UIViewController определяет UIModalPresentationAutomatic как UIModalPresentationPageSheet, но остальные системные контроллеры могут определять UIModalPresentationAutomatic по-другому.
Я не уверен на 100% во всех правилах для «остальных системных контроллеров», но я обнаружил, что показ UIViewController с разделенным экраном (split screen) без установки `modalPresentationStyle` дает карточный вид во всю ширину:
Swipe to dismiss
----------------
Еще одно важное изменение, которое затрагивает как iPhone, так и iPad, заключается в том, что модально презентованные экраны не в полноэкранном режиме (кроме всплывающих окон) можно интерактивно закрыть с помощью смахивания вниз. В это время экран позади переходит обратно в полноэкранный режим:
Обратите внимание, что в этом примере я поместил экран «О программе» в UINavigationController экрана настроек. Несмотря на то, что UINavigationController не отображал свой корневой контроллер, интерактивное закрытие было возможным.
### Не смахивай меня, пожалуйста!
Если вы полагаетесь на то, что пользователь нажимает кнопку «Готово» (или аналогичную кнопку) или переходит обратно к вершине стека контроллера навигации, чтобы закрыть показанный модально UIViewController, новое поведение смахивания для закрытия может нарушить работу вашего приложения, поскольку ваш обработчик закрытия экрана не будет выполнен.
Например, в моем приложении Pomodoro Timer Pommie пользователь может перейти к подэкрану на экране «Настройки» и добавить или отредактировать профиль таймера (конфигурация для периодов работы / перерыва для конкретного вида задачи):
В случае с Pommie, я думаю, что это нормально (и безопасно), если пользователь закрывает весь экран настроек с помощью смахивания. Пользователи, вероятно, будут ожидать, что они могут закрыть экран одним движением, и я хочу, чтобы мои приложения работали правильно в iOS 13. Однако, я чувствую, что на экране «Добавить / изменить профиль таймера» нельзя давать пользователю закрывать экран смахиванием, так как существует риск потери изменений. Для пользователя может быть не совсем понятно что произойдет после такого закрытия.
Одна часть исправления этой проблемы — новое свойство UIViewController: `isModalInPresentation`. Из документации:
> modalInPresentation устанавливается, когда вы хотите заставить экран стать модальным. Когда этот параметр включен, презентация будет предотвращать интерактивное закрытие и игнорировать события за пределами границ UIViewController, пока для этого параметра не будет установлено значение NO.
Чтобы получить поведение, аналогичное iOS 12, для моего экрана «Настройки» на iOS 13, я мог бы просто установить true для свойства `isModalInPresentation` у показанного модально UINavigationController. Если пользователь попытается смахнуть вниз, чтобы закрыть его, экран немного сместится, но будет сопротивляться действиям пользователя и не будет закрыт.
Свойство можно изменить в любое время, чтобы вы могли, например, разрешить закрытие, если пользователь еще не внес изменения, которые будут потеряны, если он явно не сохранил их. Но как только изменение было внесено, вы можете установить `isModalInPresentation`, чтобы предотвратить закрытие с помощью смахивания. Это заставит пользователя нажать кнопку «Отмена» или «Сохранить».
### Обнаружение закрытия
Как отмечалось ранее, некоторым приложениям может потребоваться выполнить некоторый код, когда показанный модально UIViewController закрывается с помощью кнопки «Отмена», «Готово» или «Сохранить» (кроме просто его закрытия). Например, вам может потребоваться перезапустить таймер в игре или действовать на основании некоторой информации, которую пользователь изменил. Этот код не будет выполнен, если пользователь закроет экран смахиванием. Ваша кнопка не нажата, поэтому обработчик ее действия вызываться не будет. Это может нарушить поведение вашего приложения.
Самый простой способ избежать этой проблемы — предотвратить интерактивное закрытие с помощью isModalInPresentation. Пользователь должен будет нажать кнопку, чтобы закрыть контроллер представления, так же, как это было до iOS 13. Но есть другой способ…
iOS 13 добавляет некоторые новые методы UIAdaptivePresentationControllerDelegate. Они позволяют другому объекту (как правило, экрану, который показал другой экран модально) управлять тем, следует ли разрешить интерактивное закрытие (альтернатива использованию `isModalInPresentation`), и получать информацию о том, когда интерактивное закрытие начинается или завершается. Эти методы хорошо документированы и четко объяснены в [WWDC 2019 224: Modernizing Your UI for IOS 13](https://developer.apple.com/videos/play/wwdc2019/224/), начиная с 15й минуты. Обратите внимание, что `presentationControllerWillDismiss` может вызываться несколько раз, если пользователь начинает смахивать, чтобы закрыть, передумывает, а затем снова смахивает. В методе `presentationControllerDidDismiss` вам необходимо выполнить дополнительный код, который вызывается при нажатии кнопки «Отмена», «Готово» или «Сохранить» (разумеется, вам не нужно закрывать показанный экран). Эти методы не будут вызываться, если UIViewController закрыт программно. Поэтому вам все равно нужно будет выполнить свой код в обработчике кнопки (или в своем собственном делегате), который вызывает закрытие даже при работе на iOS 13.
Давайте рассмотрим метод делегата `presentationControllerDidAttemptToDismiss`. Он будет вызван, если пользователь попытается провести пальцем, чтобы закрыть, но `isModalInPresentation` привел к блокировке закрытия. В видео с WWDC предлагается показать список действий с вопросом, хочет ли пользователь отказаться от изменений или сохранить их. Это кажется очень хорошей идеей, если показанный UIViewController имеет кнопки «Отмена» и «Сохранить / Готово»: создание новой заметки, редактирование свойств объекта и т.д.
Я думаю, что для вложенного UIViewController в навигационном стеке с кнопками «Отмена» и «Сохранить» это более сложно. Код для выполнения сохранения, вероятно, находится в UIViewController, который на один уровень выше в стеке, а не в объекте, который реализует `UIAdaptivePresentationControllerDelegate`. Попытка перенаправить выбор пользователя на объект, который может выполнить сохранение, может быть не совсем уместной. В моих собственных приложениях, я думаю, я просто заблокирую закрытие экранов, которые требуют явного действия отмены / сохранения, если они не находятся на вершине стека навигации.
Ресурсы
-------
Видео WWDC 2019 станет лучшим местом для того, чтобы узнать, что изменилось в iOS 13, какие изменения нужно внести в свои приложения, чтобы они работали корректно при сборке в Xcode 11, и какие изменения вы можете внести, чтобы улучшить их, чтобы воспользоваться новыми функциями. Вот несколько видео для начала:
* [WWDC 2019 214: Implementing Dark Mode on iOS](https://developer.apple.com/wwdc19/214)
* [WWDC 2019 224: Modernizing Your UI for IOS 13](https://developer.apple.com/videos/play/wwdc2019/224/)
* [WWDC 2019 801: What’s New in iOS and macOS Design](https://developer.apple.com/videos/play/wwdc2019/801/)
Заключение
----------
До сих пор я не обнаружил никаких проблем с моими приложениями, созданными в Xcode 10 под iOS 13. Обратная совместимость здесь действительно работает. Я был немного удивлен, увидев изменение внешнего вида сгруппированной таблицы.
Сборки Xcode 11 нуждались в некоторых небольших исправлениях, чтобы иметь дело с изменениями в модальных представлениях, обсужденных в этом посте. Вероятно, будут изменения, которые я еще не обнаружил.
Тщательно протестируйте свои модальные презентации (особенно с панелями поиска)! Решите, хотите ли вы разрешить пользователю закрывать модальные экраны смахиванием, и используйте `isModalInPresentation`, чтобы получить поведение, необходимое для предотвращения случайной потери данных из-за ошибочного смахивания. Для большей гибкости и контроля используйте `UIAdaptivePresentationControllerDelegate`. | https://habr.com/ru/post/467969/ | null | ru | null |
# Blue-Green Deployment приложений на Spring c веб-сервером Nginx
***Прим. перев.** — Этой статьёй мы начинаем цикл переводов, посвященных теме Zero Downtime Deployment. Следующие публикации осветят вопросы деплоя новых версий приложения с БД и деплой в Kubernetes.*
*Несмотря на то, что техническое решение, описываемое ниже достаточно спорно, целью данной статьи является знакомство читателя непосредственно с подходом Blue-Green деплоя, который, кстати, применим не только к приложениям Spring.*
Целью Blue-Green деплоя является устранение простоев во время развертывания новой версии приложения.
Простой связан с недоступностью серверов, когда новая версия приложения устанавливается для замены старой. Идея Blue / Green deployment заключается в развертывании новой версии приложения в некоем отдельном месте, где можно проводить тестирование, вплоть до момента принятия окончательного решения о переключении на неё как на основную.
В этой статье мы рассмотрим, **как настроить Blue-Green деплой Spring boot приложения.** Мы будем использовать Nginx в качестве основного веб-сервера для перенаправления входящих запросов в наши приложения.
### Настройка сервера
В этом руководстве предполагается, что у вас есть сервер и работающее Spring boot приложение, которое можно на нём развернуть.
На сервере зайдите в домашнюю директорию и создайте две папки: `blue` и `green`. Затем нам понадобятся две символические ссылки `available` и `testing`. Эти ссылки будут указывать либо на синюю, либо на зеленую папку. Например, если `available` указывает на `green`, тогда `testing` указывает на `blue`.
```
mkdir blue
mkdir green
ln -s ./green ./available
ln -s ./blue ./testing
```
Каждая папка будет содержать свое собственное приложение Spring и конфигурацию Nginx. В какой-то момент во время деплоя **оба приложения будут работать одновременно** (хотя и на разных портах), и для переключения с синего приложения на зеленое **нам потребуется только изменить конфигурацию Nginx** либо на green, либо на blue.
### Конфигурации Nginx
Допустим, у нас есть домен springsite.com. “Зеленая” конфигурация Nginx перенаправит все вызовы **springsite.com/api/** в приложение `green` на порт 8080, а все вызовы **springsite.com/api-test/** — в приложение `blue` на порт 8090.
Давайте создадим эти конфигурационные файлы. Откройте ваш любимый редактор и добавьте следующее содержимое.
```
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
server {
listen 80;
server_name mysite.com;
location /api {
proxy_pass http://localhost:8090/api;
}
location /api-test {
proxy_pass http://localhost:8080/api;
}
}
include servers/*;
}
```
```
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
server {
listen 80;
server_name mysite.com;
location /api {
proxy_pass http://localhost:8080/api;
}
location /api-test {
proxy_pass http://localhost:8090/api;
}
}
include servers/*;
}
```
Структура файлов должна выглядеть примерно так:
```
--root
|--- blue
|--- nginx.conf.blue
|--- app-V2.jar
|--- green
|--- nginx.conf.green
|--- app-V1.jar
|--- available -> ./green
|--- testing -> ./blue
```
Допустим, мы хотим развернуть новую версию в `blue` контейнере. **Мы можем протестировать ее, пока предыдущая версия еще доступна**. Как только все довольны новой версией, нам нужно будет всего лишь поменять ссылки!
Создайте файл `swap.sh` в папке, содержащей как `blue`, так и `green` папки:
```
touch swap.sh
chmod +x swap.sh
```
Добавьте следующее содержимое в файл `swap.sh`:
```
#!/bin/bash
testing_now=$(ls -l ./ | grep testing)
if [[ "$testing_now" == *blue ]]
then
testing="blue"
active="green"
else
testing="green"
active="blue"
fi
#remove current links
rm ./available
rm ./testing
rm -f /etc/nginx/nginx.conf
#create new links with the active/inactive reversed
ln -s ./$inactive ./available
ln -s ./$active ./testing
ln -s /home/ubuntu/spring/$active/nginx.conf /etc/nginx/nginx.conf
#reload the http server
service nginx reload
echo swap completed $active is now available
```
На этом этапе мы можем запустить 2 приложения Spring на портах 8090 и 8080 и менять их, запуская sudo `./swap.sh`.
### Деплой
Благодаря символическим ссылкам мы знаем, что на основное приложение всегда указывает `available`, а на тестируемое — `testing`. Следовательно, мы всегда должны деплоить новую версию приложения в папке `testing`, используя символическую ссылку. Предполагается, что мы только что упаковали приложение, и теперь мы можем загрузить его с помощью `scp`.
```
scp -r -i ~/.ssh/MyKeyPair.pem @:spring/testing
```
### Идем дальше
Настройка Blue-Green деплоя на вашем сервере позволит **значительно сократить время простоя**. В этом руководстве объясняется, как деплоить новые версии вашего приложения, которые находятся на одном физическом сервере. Оно может быть адаптировано к ситуациям с несколькими физическими серверами и балансировщику нагрузки. Однако, для этого потребуется иметь вдвое больше производственных сред, чем необходимо. **Для очень большой инфраструктуры это либо невозможно, либо чрезвычайно дорого.**
Это приводит к вопросу: **Как крупным компаниям удается выпускать новые версии своих приложений без простоев?** Подумайте о Google или Facebook, которые всегда доступны!
Использование Blue-Green деплоя тут нереально из-за огромного количества необходимых серверов. Обновления приложений выполняются постепенно: серверы поочередно выводятся из работы, а после обновления возвращаются обратно. Более того, новые версии также выпускаются постепенно: в начале только небольшая часть серверов будет работать с новой версией. Затем, если проблем или багов не обнаружено, всё больше и больше серверов будут запускаться с новым кодом. На этом этапе оцениваются важные метрики производительности, такие как CPU, память и производительность запросов. Если все прошло успешно, то релиз завершен, и на каждом сервере по всему миру будет запущена новая версия приложения.
### Заключение
Я надеюсь, теперь вы понимаете, как решить проблему простоя благодаря Blue-Green деплою. **Теперь вы сможете настроить базовый Blue-Green деплой вашего Spring приложения с NGINX.**
Как вы, возможно, заметили, когда мы используем это решение, старые и текущие версии ваших приложений работают одновременно и оба подключены к базе данных. Это может привести к неожиданным проблемам при изменении структуры базы данных. Эта замечательная статья <https://spring.io/blog/2016/05/31/zero-downtime-deployment-with-a-database> описывает, как справиться с подобными ситуациями.
И, наконец, вас может заинтересовать то, что и AWS, и Google Cloud Compute предлагают услуги по Blue-Green Deployment из коробки:
<https://aws.amazon.com/quickstart/architecture/blue-green-deployment/>
<https://cloud.google.com/solutions/continuous-delivery/>
### Также читайте другие статьи в нашем блоге:
* [Как запустить несколько пайплайнов с помощью GitLab CI/CD](https://habr.com/ru/company/nixys/blog/467107/)
* [/etc/resolv.conf для Kubernetes pods, опция ndots:5, как это может негативно сказаться на производительности приложения](https://habr.com/ru/company/nixys/blog/464371/)
* [Разбираемся с пакетом Context в Golang](https://habr.com/ru/company/nixys/blog/461723/)
* [Три простых приема для уменьшения Docker-образов](https://habr.com/ru/company/nixys/blog/437372/)
* [Бэкапы Stateful в Kubernetes](https://habr.com/ru/company/nixys/blog/426543/)
* [Резервное копирование большого количества разнородных web-проектов](https://habr.com/ru/company/nixys/blog/424717/)
* [Telegram-бот для Redmine. Как упростить жизнь себе и людям](https://habr.com/ru/company/nixys/blog/347526/) | https://habr.com/ru/post/470568/ | null | ru | null |
# Критическая уязвимость в Saltstack мастере (уже под атакой)
Привет, Хабр!
Этой ночью началась массовая экплуатация свежей уязвимости SaltStack master <=3000.1 версий. Еще один хороший пример того, что нужно закрывать все торчащее наружу апи фаерволом.
В репозитории saltstack [предупреждение](https://github.com/saltstack/community/blob/master/doc/Community-Message.pdf) появилось 9 дней назад, но я не встречал его где-либо еще в интернете, хотя и слежу за новостями подобного рода.
> The vulnerabilities allow a remote attacker who connects to the request server can bypass all authentication mechanisms and publish arbitrary control messages, read and write files anywhere on the master file system.
>
>
>
> Attackers can also steal the secret keys and authenticate as a master user, results in “full remote command execution as root on both the master and all minions that connect to it.”
>
>
>
> CVE-2020-11651 – Resides in ClearFuncs class that does not properly validate method calls, which allows attackers to retrieve user tokens.
>
>
>
> CVE-2020-11652 – The ClearFuncs allow access to some methods due to improper sanitization, it allows arbitrary directory access to authenticated users.
>
> [Источник](https://gbhackers.com/saltstack-salt/)
>
>
Что известно на данный момент:
на все миньоны устанавливается криптомайнер [salt-minions](https://t.co/1Ms44xzNNT?amp=1) и [salt-store](https://t.co/dz8XLhwGXZ?amp=1) ([источник](https://twitter.com/TehHarry/status/1256780974282747907)). Для очистки нужно выполнить примерно следующие команды:
```
service salt-minion stop
rm -rf /var/tmp/salt-store
rm -rf /var/tmp/salt-minions
rm -rf /tmp/salt-store
rm -rf /tmp/salt-minions
pgrep salt-minion| xargs kill -9
pgrep salt-store| xargs kill -9
```
Так же троян пытается атаковать все сервисы, включая редис и докер. Изменения системных файлов пока не замечено. Актуальные новости собираются в том числе в [ишью на гитхабе](https://github.com/saltstack/salt/issues/57057).
Берегите себя и свои сервера
Апдейт от 6 мая:
* С понедельника 4 мая началась новая атака, уже с более серьезной вирусной нагрузкой, компрометирующей всю систему. Если вас взломали, начиная с понедельника, — только полный ресетап системы является панацеей :(
* Среди прочих [были взломаны](https://xakep.ru/2020/05/06/saltstack-salt-rces/) блогинговая платформа Ghost, удостоверяющий центр Digicert и серверы LineageOS
* [Выпущены патчи](https://community.saltstack.com/blog/active-saltstack-cve-critical-updates/) для множества мажорных версий satstack. Если вы ставили saltstack через bootstrap скрипт, убедитесь, что вы используете [официальные репозитории](https://repo.saltstack.com), а не git branch, — и обновляйтесь. | https://habr.com/ru/post/500174/ | null | ru | null |
# Как использовать soy, requirejs, backbone js в плагинах для Atlassian Jira
В этой статье разработаем плагин, который будет сохранять настройки плагина в Jira. Мы будем использовать библиотеки soy, requirejs, backbone js для отображения пользовательского интерфейса. Soy, requirejs, backbone js это встроенные в Jira библиотеки.
Цель статьи состоит в том, чтобы показать как можно использовать встроенные средства Jira для разработки пользовательского интерфейса.
Разработанный плагин будет содержать модуль webwork для сохранения параметров плагина в Jira. Параметры будут вводиться на двух экранах (по два параметра на каждом экране). Далее параметры будут упаковываться в json, который и будет сохраняться в Jira. Исходный код плагина можно посмотреть вот [тут](https://bitbucket.org/alex1mmm/webwork-soy-require-backbone/src/master/).
Создадим скелет плагина
-----------------------
Откроем терминал и выполним команду ниже:
`atlas-create-jira-plugin`
Ответим на вопросы в терминале вот так:
```
Define value for groupId: : ru.matveev.alexey.jira.tutorial.webworkui
Define value for artifactId: : webwork-soy-require-backbone
Define value for version: 1.0.0-SNAPSHOT: :
Define value for package: ru.matveev.alexey.jira.tutorial.webworkui: :
Y: : Y
```
Внесем изменения в pom.xml
--------------------------
После создания скелета плагина необходимо внести изменения для корректной работы [atlassian-spring-scanner 2](https://bitbucket.org/atlassian/atlassian-spring-scanner/src/master/).
Установим версию atlassian-spring-scanner в 2.0.0:
```
2.0.0
```
Изменим scope зависимости atlassian-spring-scanner-annotation с compile на provided:
```
com.atlassian.plugin
atlassian-spring-scanner-annotation
${atlassian.spring.scanner.version}
provided
```
Удалим зависимость atlassian-spring-scanner-runtime.
Создадим сервис для получения и сохранения настроек плагина
-----------------------------------------------------------
Сначала создадим интерфейс для управления настройками плагина.
**src/main/java/ru/matveev/alexey/jira/tutorial/webworkui/api/PluginSettingService.java**
```
package ru.matveev.alexey.jira.tutorial.webworkui.api;
public interface PluginSettingService {
String getConfigJson();
void setConfigJson(String json);
}
```
Теперь сделаем реализацию интерфейса.
**src/main/java/ru/matveev/alexey/jira/tutorial/webworkui/impl/PluginSettingServiceImpl.java**
```
package ru.matveev.alexey.jira.tutorial.webworkui.impl;
import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
import com.atlassian.sal.api.pluginsettings.PluginSettings;
import com.atlassian.sal.api.pluginsettings.PluginSettingsFactory;
import ru.matveev.alexey.jira.tutorial.webworkui.api.PluginSettingService;
import javax.inject.Inject;
import javax.inject.Named;
@Named
public class PluginSettingServiceImpl implements PluginSettingService {
public final PluginSettings pluginSettings;
private static final String PLUGIN_STORAGE_KEY = "ru.matveev.alexey.jira.tutorial.webworkui.";
private static final String CONFIG_JSON = "configjson";
@Inject
public PluginSettingServiceImpl(@ComponentImport PluginSettingsFactory pluginSettingsFactory) {
this.pluginSettings = pluginSettingsFactory.createGlobalSettings();
}
private void setSettingValue(String settingKey, String settingValue) {
this.pluginSettings.put(PLUGIN_STORAGE_KEY + settingKey, settingValue != null?settingValue:"");
}
private String getSettingValue(String settingKey) {
return pluginSettings.get(PLUGIN_STORAGE_KEY + settingKey) != null?pluginSettings.get(PLUGIN_STORAGE_KEY + settingKey).toString():"";
}
@Override
public String getConfigJson() {
return getSettingValue(CONFIG_JSON);
}
@Override
public void setConfigJson(String json) {
setSettingValue(CONFIG_JSON, json);
}
}
```
Методы getConfigJson и setConfigJson отвечают за получение и сохранение параметра в формате json.
Создадим webwork для управления настройками плагина
---------------------------------------------------
Откроем терминал в папке плагина и выполним команду ниже:
`create-atlas-jira-plugin-module`
На вопросы в терминале отвечаем следующим образом:
```
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 31
Enter Plugin Module Name My Webwork Module: : Config
Show Advanced Setup? (Y/y/N/n) N: : Y
Module Key config: : webwork-config
Module Description The Config Plugin: :
i18n Name Key config.name: :
i18n Description Key config.description: :
Enter Action Classname MyActionClass: : ConfigWebwork
Enter Package Name ru.matveev.alexey.jira.tutorial.webworkui.jira.webwork: :Enter Alias ConfigWebwork: :
Enter View Name success: : success.soy
Enter Template Path /templates/webwork-config/configwebwork/success.soy.vm: : /templates/webwork-config/configwebwork/success.soy
Add Another View? (Y/y/N/n) N: : N
Add Another Action? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : N
```
В результате будет создан файл src/main/java/ru/matveev/alexey/jira/tutorial/webworkui/jira/webwork/ConfigWebwork.java. Этот файл нужно изменить вот так:
**src/main/java/ru/matveev/alexey/jira/tutorial/webworkui/jira/webwork/ConfigWebwork.java**
```
package ru.matveev.alexey.jira.tutorial.webworkui.jira.webwork;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.atlassian.jira.web.action.JiraWebActionSupport;
import ru.matveev.alexey.jira.tutorial.webworkui.api.PluginSettingService;
import javax.inject.Inject;
public class ConfigWebwork extends JiraWebActionSupport
{
private static final Logger log = LoggerFactory.getLogger(ConfigWebwork.class);
private final PluginSettingService pluginSettingService;
private String configJson;
@Inject
public ConfigWebwork(PluginSettingService pluginSettingService) {
this.pluginSettingService = pluginSettingService;
}
@Override
public String execute() throws Exception {
super.execute();
return SUCCESS;
}
public void doSave() {
pluginSettingService.setConfigJson(configJson);
}
@ActionViewData
public String getConfigJson() {
return pluginSettingService.getConfigJson().isEmpty()?"{}":pluginSettingService.getConfigJson();
}
public void setConfigJson(String json) {
this.configJson = json;
}
}
```
Аннотация @ActionViewData необходима для того, чтобы параметр configJson был доступен в soy шаблоне.
Создадим web section и web item
-------------------------------
Мы добавили webwork. Теперь добавим пункт меню, из которого будет запускаться webwork.
Открываем терминал и выполняем следующую команду:
`create-atlas-jira-plugin-module`
Отвечаем на вопросы следующим образом:
```
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 30
Enter Plugin Module Name My Web Section: : Webwork Config Section
Enter Location (e.g. system.admin/mynewsection): admin_plugins_menu
Show Advanced Setup? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : Y
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 25
Enter Plugin Module Name My Web Item: : Webwork Config Item
Enter Section (e.g. system.admin/globalsettings): admin_plugins_menu/webwork-config-section
Enter Link URL (e.g. /secure/CreateIssue!default.jspa): /secure/ConfigWebwork.jspa?
Show Advanced Setup? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : N
```
В результате мы создали пункт меню на странице Add-ons.
Создаем soy шаблон
------------------
Подробно про soy шаблоны можно почитать [тут](https://developers.google.com/closure/templates/).
Мы создадим файл
src/main/resources/templates/webwork-config/configwebwork/success.soy.
**src/main/resources/templates/webwork-config/configwebwork/success.soy**
```
{namespace webwork.config}
/**
* This template is needed for drawing the formview.
*/
{template .formview}
{@param configJson: string}
{webResourceManager_requireResource('ru.matveev.alexey.jira.tutorial.webworkui.webwork-soy-require-backbone:webwork-soy-require-backbone-resources')}
my page page
Json
the configJson Parameter
[Cancel](#)
{/template}
```
В файле atlassian-plugin.xml в тег web-resource нужно добавить ссылку на созданный soy шаблон:
Теперь внесем изменения в atlassian-plugin.xml для того, чтобы при обращении к webwork был бы отображен созданный soy шаблон:
```
:webwork-soy-require-backbone-resources/webwork.config.formview
```
webwork-soy-require-backbone-resources — это атрибут name в теге web-resource, куда мы добавили ссылку на наш soy шаблон.
webwork.config.formview — namespace и название шаблона из soy файла.
Протестируем плагин
-------------------
Откроем терминал в папке плагина и выполним следующую команду:
`atlas-run`
После того как Jira запустится нужно перейти в браузере по следующей ссылке:
[localhost](http://localhost):2990/jira/secure/ConfigWebwork.jspa
Экран будет выглядеть вот так:
Можно попробовать ввести данные в поле Json и сохранить. Webwork работает.
Теперь нам нужно сделать так, чтобы было два экрана для заполнения параметров, и на последнем экране кнопка Save должна приводить все параметры в json формат и сохранять в настройках плагина.
Для управления логикой перемещения по экранам и приведением параметров в json формат мы будем использовать backbone js. Про backbone js можно почитать [тут](http://backbonejs.org).
Создадим backbone модель
------------------------
**src/main/resources/js/webwork-config-model.js**define('webwork/config/model', [
'jquery',
'backbone',
'underscore'
], function($, Backbone, \_) {
var WebConfigModel = Backbone.Model.extend({
defaults: {
parameter1: '',
parameter2: '',
parameter3: '',
parameter4: ''
}
});
return {
Model: WebConfigModel
};
})
Для того, чтобы модель была доступна при загрузке soy шаблона, файл с моделью необходимо добавить в atlassian-plugin.xml в тег web-resource:
Создадим backbone вью
---------------------
Я написал в коде комментарии для важных моментов.
**src/main/resources/js/webwork-config-view.js**//define это директива requirejs и определяет модель как модуль webwork/config/view. Это позволяет нам определять зависимости в других файлах от модели.
define('webwork/config/view', [
'jquery',
'backbone',
'underscore'
], function($, Backbone, \_) {
«use strict»;
var AppView = Backbone.View.extend({
events: {
«click #config-save-button»: «saveConfig»,
«click #next-button»: «nextButton»,
«click #back-button»: «prevButton»
},
// функция, которая работает по кнопке Save. Сохраняет параметры с экрана в модель и преобразует параметры в json формат
saveConfig: function(){
this.model.set(«parameter3», $("#parameter3").val());
this.model.set(«parameter4», $("#parameter4").val());
$("#configJson").val(JSON.stringify(this.model));
},
// функция, которая работает по кнопке Next на первом экране. Сохраняет параметры с первого экрана в модель и рисует второй экран
nextButton: function(){
this.model.set(«parameter1», $("#parameter1").val());
this.model.set(«parameter2», $("#parameter2").val());
var template = webwork.config.page2({configJson:$("#configJson").val(), parameter3:this.model.get('parameter3'), parameter4:this.model.get('parameter4')});
$("#container").replaceWith(template);
$("#configJson").val(JSON.stringify(this.model));
},
// функция, которая работает по кнопке Back на втором экране. Сохраняет параметры со второго экрана в модель и рисует первый экран
prevButton: function(){
this.model.set(«parameter3», $("#parameter3").val());
this.model.set(«parameter4», $("#parameter4").val());
var template = webwork.config.page1({configJson:$("#configJson").val(), parameter1:this.model.get('parameter1'), parameter2:this.model.get('parameter2')});
$("#container").replaceWith(template);
$("#configJson").val(JSON.stringify(this.model));
},
initialize: function(){
this.render();
},
render: function(){
var template = webwork.config.page1({configJson:$("#configJson").val(), parameter1:this.model.get('parameter1'), parameter2:this.model.get('parameter2')});
$("#container").replaceWith(template);
},
// это ссылка на главный контейнер. Вью будет ловить все события от элементов ниже этого элемента
el: '#maincontainer'
});
return {
View: AppView
};
})
Для того, чтобы вью была доступна при загрузке soy шаблона, файл с вью необходимо добавить в atlassian-plugin.xml в тег web-resource:
Создадим js file, чтобы настроить backbone модель и вью
-------------------------------------------------------
**src/main/resources/js/webwork-soy-require-backbone.js**require([
'webwork/config/view',
'webwork/config/model',
'jquery',
'backbone',
'underscore'
], function(webworkConfigView, webworkConfigModel, $, Backbone, \_) {
var webworkConfigModel = new webworkConfigModel.Model(JSON.parse($("#configJson").val()));
var actionsView = new webworkConfigView.View({model: webworkConfigModel});
})
Наш js файл использует requirejs. Директива require позволяет добиться того, что файл будет загружен только после того, как все зависимости загружены. Мы определили следующие зависимости для нашего файла: webwork/config/view, webwork/config/model, query, backbone, underscore.
Добавим параметры необходимые для работы soy шаблонов
-----------------------------------------------------
В тег web-resource в файле atlassian-plugin.xml нужно добавить:
```
```
Эти параметры позволяют обращаться к soy шаблону в js файлах.
Внесем изменения в success.soy
------------------------------
Я добавил комментарии к важным моментам
**src/main/resources/templates/webwork-config/configwebwork/success.soy**
```
{namespace webwork.config}
/**
* Этот шаблон запускается сразу из webwork. Здесь выводится json параметр. Далее этот шаблон сразу перерисовывается шаблоном page1. Шаблон нужен для того, чтобы получить json параметр и заполнить backbone model.
*/
{template .formview}
{@param configJson: string}
{webResourceManager_requireResource('ru.matveev.alexey.jira.tutorial.webworkui.webwork-soy-require-backbone:webwork-soy-require-backbone-resources')}
my page page
{/template}
/**
* Это шаблон первого экрана. Он содержит parameter1 и parameter2.
*/
{template .page1}
{@param configJson: string}
{@param parameter1: string}
{@param parameter2: string}
Parameter 1
Value of Parameter 1
Parameter 2
Value of Parameter 2
[Cancel](#)
{/template}
/**
* Это шаблон второго экрана. Он содержит parameter3 и parameter4.
*/
{template .page2}
{@param configJson: string}
{@param parameter3: string}
{@param parameter4: string}
Parameter 3
Value of Parameter 3
Parameter 4
Value of Parameter 4
{/template}
```
Протестируем приложение
-----------------------
Открываем терминал в папке плагина и запускаем:
`atlas-run`
После того как Jira запуститься, откройте браузер по ссылке:
`http://localhost:2990/jira/secure/ConfigWebwork.jspa`
Вы увидите следующий экран:
Заполните параметры и нажмите на кнопку Next. Появится следующий экран:
Заполните параметры 3 и 4 и нажмите на кнопку Save. Параметры будут сохранены в формате Json. Можно нажать на кнопку Back и вы перейдете к первому экрану.
Наш плагин работает. | https://habr.com/ru/post/415809/ | null | ru | null |
# Создание несложного бота для WoW, программирование маршрутов
#### Введение
Прочитал недавно [пост](http://habrahabr.ru/post/113258/), в котором автор рассказал о своём боте для торговли на аукционе в игре World of Warcraft. Его персонаж бегал челноком на небольшие расстояния и выполнял конкретные действия, строго заданные в управляющей программе. Воспользовавшись его идеями, я решил пойти немного дальше: пусть персонаж будет способен бегать по маршруту длительностью хотя бы пять минут, при этом должна быть возможность записывать маршрут и выполняемые действия извне, не прибегая к изменению самой программы управления. Описанное мной является развитием [поста-оригинала](http://habrahabr.ru/post/113258/), тем не менее я постарался, чтобы его чтение не было обязательным.
В посте я опишу
1. Процесс создания тривиального аддона для пользовательского интерфейса WoW на языке Lua
* Сериализация данных для передачи между частями системы
* Передача с помощью цвета пикселей
2. Процесс управления персонажем на языке AutoIt
* Программа для записи выполняемых действий
* Программа для воспроизведения
* Мат.расчеты направления перемещения
* Почему не стоит прибегать к чтению/записи памяти процесса
3. Программа управления (ро)ботом с командами, понятными непрограммисту
#### Предупреждение
Я отлично понимаю, что использование ботов запрещено лицензионным соглашением Blizzard. Это может привести к перманентному бану аккаунта. Я бы расстроился, узнав, что кто-то, воспользовавшись материалами данного поста, стал наживаться, ухудшая экономику игры и вызывая неодобрение других игроков. И да, я понимаю, то, что делаю я, нечестно.
Цель поста — рассказать о моем опыте и описать сложности, с которыми я столкнулся, узнать у вас, что можно было сделать лучше.
#### Предыстория
##### Коллекционирование
Люди, далекие от индустрии игр, могут без ущерба пропустить этот раздел. В игре WoW есть такой аспект — коллекционирование. Как и в нумизматике/филателии, чем больше у вас, например, верховых животных, тем вам приятнее. Точно так же важен процесс получения. Какие-то драконы требуют для получения выполнения десятка задач («ачивок»), какие-то — войти в лучшие 2% игроков в мире по навыку управления персонажем (сражения на арене), что-то можно просто купить за игровую валюту, что-то — за реальные деньги в магазине. Подробности можно почитать в [другом источнике](http://www.mmopeon.ru/index.php/articles/235-wow-all-mounts), речь не об этом. Так вот, некоторые из коллекционируемых предметов падают в подземелье с шансом около 0,5%. Если шанс выпадения дается игроку лишь раз в день (иногда в неделю), вам потребуется время, соизмеримое с годом, для забегов. И все ради того мгновения получения заветного выстраданного предмета. Чем больше вы потратили времени и сил на "[фарм](http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D1%80%D0%BC%D0%B5%D1%80_(MMORPG))" предмета, тем приятнее вам его в итоге получить. По моему опыту радость очень мимолетна.
##### Зависимость шанса выпадения от количества попыток
Небольшое отступление. Какова вероятность того, что за шесть бросков игральной кости выпадет «6»? Очевидно, что [](http://www.codecogs.com/eqnedit.php?latex=1-\frac5&space;6^6\approx&space;0.66). То есть, наше событие является [противоположным событием](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C#.D0.A1.D0.B2.D0.BE.D0.B9.D1.81.D1.82.D0.B2.D0.B0_.D0.B2.D0.B5.D1.80.D0.BE.D1.8F.D1.82.D0.BD.D0.BE.D1.81.D1.82.D0.B8) к невыпадению «6» за все шесть попыток.
Используя [второй замечательный предел](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BC%D0%B5%D1%87%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB#.D0.92.D1.82.D0.BE.D1.80.D0.BE.D0.B9_.D0.B7.D0.B0.D0.BC.D0.B5.D1.87.D0.B0.D1.82.D0.B5.D0.BB.D1.8C.D0.BD.D1.8B.D0.B9_.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB), нетрудно показать, что [](http://www.codecogs.com/eqnedit.php?latex=1-(1-\frac1&space;n)^n\rightarrow&space;1-\frac1&space;e).
А вероятность получения коня с шансом «дропа» в 1% за 100 попыток примерно равна 63%.
Некоторые игроки, сделав триста попыток считают, что вот-вот повезет — ведь вероятность облома за такое большое число попыток мала. Их ждет разочарование, ведь за следующие 100 им повезет снова лишь на 63%. А старые труды не дают ничего.
##### Задача
Есть подземелье. Нужно пробежать по нему с виражами, выполнить пару несложных задач по пути. Убить финального босса и поднять добычу. Чтобы не бежать к выходу пешком, телепортироваться в ближайшую деревню и долететь ко входу. Повторить 5 раз.
Карта подземелья и маршрут:
Задача максимум. Запустил и ушел на пол часа. Процесс полностью автоматический.
Задача минимум. Запустить и сидеть рядом, читать или играть на гитаре, поглядывая на монитор. При необходимости изредка помогать персонажу выбраться из непредвиденной ситуации.
Важно иметь возможность при желании описать маршрут другого подземелья, не залезая в код.
#### Подход
##### Движение и позиционирование
Просто записать нажатие и отпускание клавиш, позицию и щелчки мыши не получится. Точнее записать-то получится, только при проигрывании будет происходить совсем не то, что вы ожидали, по следующим причинам:
1. Вам требуется воспроизвести первоначальное положение персонажа и направление его взгляда. Если вы перед автоматическим забегом повернетесь слегка в другую сторону, вы побежите кривовато и рано или поздно упретесь в стенку
2. Если вы записали точные координаты и угол, то поставить персонажа туда же вам также не удастся. Реагирует на кнопки он как бульдозер и поворачивается так же. А даже ошибка в 1 градус через 100 метров выльется в [](http://www.codecogs.com/eqnedit.php?latex=\sin1^{\circ}*100\approx&space;2) метра (ширина дверного проема)
3. Время нажатия и отпускания кнопок тоже далеко от идеала. Это похоже на передвижение по квартире с закрытыми глазами. Вроде бы шесть шагов вперед и строго направо, но на деле вместо туалета мы оказываемся в ванной. Попробуйте также открыть дверь с закрытыми глазами, не щупая ручку
Вот по этим причинам нам необходимо позиционироваться в мире при помощи координат. При этом сверять позицию и вносить коррективы необходимо регулярно, каждые 100 миллисекунд.
```
move 40.644 20.417 1.537
move 40.526 20.411 1.537
move 40.246 20.408 1.592
move 39.974 20.414 1.592
move 39.691 20.411 1.537
move 39.417 20.388 1.510
```
Это отрывок из списка команд робота по перемещению. Указаны координаты **x**, **y** и угол поворота в пространстве в радианах.
##### Клавиши и команды
По пути надо нажимать кнопки и кликать мышкой, открывать двери, где-то нужно ждать. Не хотелось бы выписывать это все вручную. Да и искать среди команд с координатами (в примере выше), куда же что вписать, не очень приятно. Поэтому единовременные нажатия на кнопки и клики мы будем писать параллельно с записью координат.
```
pitch -0.89
mouse right 942 498
pause 10000
move 39.417 20.388 1.510
key `
pause 1000
key {SPACE}
move 39.142 20.364 1.510
key {TAB}
key 3
key 3
mouse right 963 622
move 38.864 20.340 1.510
move 38.653 20.321 1.510
```
Отдельно упомяну про «pitch» (наклон). Если персонаж смотрит в горизонт, он равен нулю. Если под ноги, наклон отрицателен. А в небо — положителен. Измеряется в радианах. Его пришлось добавить, как только персонажу захотелось летать.
##### Модули
Таким образом, у нас вырисовываются части ~~программно-аппаратного комплекса~~ бота:
1. Мы напишем **addon для интерфейса WoW**, который будет определять позицию персонажа, азимут, наклон. Правилами игры аддоны ничуть не запрещены, указанная информация доступна через игровое API внутри аддона. Он будет рисовать это все на экране. Сам аддон пишется на языке Lua, потому что так решили разработчики игры.
2. В аддоне можно определять кое-что, можно рисовать, но вот заставить персонажа двигаться нельзя. Еще в аддоне нельзя писать в файл, спрашивать у игры, где стены, где враги, да и много чего еще нельзя. Поэтому нам нужно написать **внешнее управляющее приложение**. Я не стал оригинальничать и использовал [AutoIt](http://www.autoitscript.com/site/). Это действительно быстро и удобно, хоть и немного дико для меня, привыкшего программировать на [строго типизированных языках](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F).
* Приложение должно уметь **записывать** мои действия. Назовем этот функционал Recorder
* Приложение должно уметь **воспроизводить** запись. Назовем Player
3. **Записанные действия и координаты** мы будем хранить в текстовом файле построчно. Их можно и нужно редактировать вручную. Добавлять костыли, удалять мусор. Скажу сразу, это самое сложное.
#### Addon для WoW на Lua
[Аддон для WoW](http://www.wowwiki.com/AddOns) это скрипт на языке [Lua](http://ru.wikipedia.org/wiki/Lua). Язык полноценный, гибкий, эффективный. Делать с системой ничего нельзя. Делать с игрой можно все, но только в рамках того [API](http://www.wowpedia.org/World_of_Warcraft_API), которое предоставляет вам игра. Так как Blizzard не хочет, а точнее, запрещает игрокам и предпринимателям писать ботов, то и API кроме упомянутых выше координат почти ничего полезного и не предоставляет. Разумеется, полезного для наших нужд. Неплохой гайд по написанию аддонов сразу с описанием Lua можно найти [здесь](http://www.mmo-champion.com/threads/817817-Creating-Your-Own-WoW-Addon). Ну а я опишу свой вариант.
##### Манифест и GUI
[Подробности](http://www.wowwiki.com/WoW_AddOn) и [источник](http://wowpedia.org/Getting_started_with_writing_addons). В папке *World of Warcraft\Interface\AddOns\* создаете папку *HelloWorld*. В нее кладете *HelloWorld.toc* с содержимым
```
## Interface: 50001
## Title: Hello, World!
## Notes: My first AddOn
HelloWorld.lua
```
Если бы я хотел понарисовать формочек и кнопочек (а для этого обычно и нужны аддоны), последней строчкой я бы вписал еще *HelloWorld.xml* с описанием этих кнопочек. В дизайне и написании такого GUI-аддона хорошо помогает [AddOn Studio](http://addonstudio.codeplex.com/). Мощный инструмент на базе MS Visual Studio.
Но так как я минималист, рисовать мы в этот раз не будем. Кроме того, это даст мне возможность показать, что создавать формы можно динамически из самого скрипта без использования дизайнера. Рассмотрим же *HelloWorld.lua*. Редактировал я его в Notepad++. Чтобы игра подключила изменения в *HelloWorld.toc*, надо перезапустить ее целиком. А вот изменения в *HelloWorld.lua* можно подхватить, написав в консоли команду **/reload**. Поэтому процесс программирования и отладки не такой болезненный.
##### Слеш-команды
Кстати, об отладке. Советую сразу добавить [обработчик слеш-команд](http://wowpedia.org/HOWTO:_Create_a_Slash_Command):
```
SLASH_HELLO_WORLD1 = '/helloworld';
function SlashCmdList.HELLO_WORLD(msg, editbox)
local facing = GetPlayerFacing();
local pitch = GetUnitPitch("player");
local x, y = GetPlayerMapPosition("player");
print(format("HelloWorld %.2f %.2f %.2f %.2f", x*100, y*100, facing, pitch));
end
```
Для этого определим переменную вида **SLASH\_ИМЯn**. Где **ИМЯ** уникально для всех аддонов, а **n** либо пусто, либо порядковое число с 1. И добавим функцию с именем **ИМЯ** в некий объект. Может показаться странным для программиста на C++, что мы эту функцию-обработчик нигде явно не регистрируем. Да и со строковой переменной связываем чисто по имени переменной. Но вот такая она, мощь и магия Lua.
Теперь команда в WoW-консоли **/helloworld** выполнит требуемые вам действия: позволит вывести отладочную информацию, а для простейших аддонов, собственно, произведет все то, ради чего вы их писали.
Ну и тут же я показал WoW API, которое достает требуемую информацию.
##### Обработчик событий
Система работы с GUI в аддоне похожа на работу Windows со своими сообщениями и их обработкой.
```
local EventFrame = CreateFrame("Frame")
function EventFrame:OnEvent(event, ...)
print("HelloWorld:", event)
self[event](self, ...)
end
EventFrame:SetScript("OnEvent", EventFrame.OnEvent)
EventFrame:RegisterEvent("PLAYER_LOGIN")
function EventFrame:PLAYER_LOGIN()
-- Инициализация тут
end
function EventFrame:OnUpdate()
-- Полезные действия тут
end
EventFrame:SetScript("OnUpdate", EventFrame.OnUpdate)
```
Мы создаем фрейм типа "**Frame**" и подключаемся на действия "**OnEvent**" и "**OnUpdate**" командами
```
EventFrame:SetScript("OnEvent", EventFrame.OnEvent)
EventFrame:SetScript("OnUpdate", EventFrame.OnUpdate)
```
Обработчик **OnUpdate** будет вызываться после каждого кадра — то, что нам нужно для обновления координат. А **OnEvent** будет вызываться при других желаемых событиях. Из него будем дергать соответствующие функции:
```
self[event](self, ...)
```
Что еще удобнее в Lua, это то, что вот такой конструкцией можно вызвать уникальные обработчики вида
```
function EventFrame:PLAYER_LOGIN()
```
Здесь **PLAYER\_LOGIN** — это событие, которое рассылается во все фреймы при входе в мир и перезапуске пользовательского интерфейса. Другие события: **PLAYER\_LEAVE\_COMBAT**, **QUEST\_FINISHED**, **PLAYER\_EQUIPMENT\_CHANGED**, **PLAYER\_DEAD**, — и еще очень много. С полным списком можно ознакомиться [тут](http://wowprogramming.com/docs/events). Зарегистрируем то событие, которое мы хотим обрабатывать, командой
```
EventFrame:RegisterEvent("PLAYER_LOGIN")
```
##### Передача информации
Так как в аддоне нельзя ничего делать с системой, информацию из WoW другой части бота мы будем передавать при помощи изменения цвета пикселей. Как это делал [rednaxi](https://habrahabr.ru/users/rednaxi/) в своем [посте](http://habrahabr.ru/post/113258/). Но только мы будем передавать цветом не один бит информации, а будем сериализовать данные и передавать их больше.
##### Рисование
Так как для рисования тоже нужны фреймы, создадим их
```
local HelloWorld1 = CreateFrame("Frame", nil, UIParent)
local HelloWorld2 = CreateFrame("Frame", nil, UIParent)
function EventFrame:PLAYER_LOGIN()
HelloWorld1:SetFrameStrata("BACKGROUND")
HelloWorld1:SetWidth(10)
HelloWorld1:SetHeight(10)
HelloWorld1.texture = HelloWorld1:CreateTexture(nil,"BACKGROUND")
HelloWorld1.texture:SetAllPoints(HelloWorld1)
HelloWorld1:SetPoint("TOPLEFT",0,0)
HelloWorld1:Show()
HelloWorld2:SetFrameStrata("BACKGROUND")
HelloWorld2:SetWidth(10)
HelloWorld2:SetHeight(10)
HelloWorld2.texture = HelloWorld2:CreateTexture(nil,"BACKGROUND")
HelloWorld2.texture:SetAllPoints(HelloWorld2)
HelloWorld2:SetPoint("TOPLEFT",10,0)
HelloWorld2:Show()
end
```
Думаю, тут все понятно и без комментариев. Подробности по каждому методу [ищите](http://www.wowwiki.com/index.php?search=CreateTexture&fulltext=Search&ab=46) сами.
##### Сериализация
У нас есть две координаты и два угла. Все — числа с плавающей запятой. Компоненты цветов пикселей в аддоне тоже числа с плавающей запятой, но от **0.0** до **1.0**. Кроме того, известно, что сохранится компонента цвета в одном байте. Поначалу я каждую координату сохранял в одну компоненту цвета. В итоге точность позиционирования в локации составляла **1/255** от размера карты. Получалось как в **GPS**: вроде координаты есть, но вести машину на автомате (управление компьютером без человека) по дороге по навигатору не выйдет. Так что пришлось давать два байта. Как повыгоднее сохранить одно дробное число в два байта? Я сделал так
```
local x1, x2 = math.modf(x*255)
```
Функция **modf** возвращает целую и дробную часть числа через запятую. Здесь используется [параллельное присваивание](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D1%81%D0%B2%D0%B0%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5#.D0.9F.D0.B0.D1.80.D0.B0.D0.BB.D0.BB.D0.B5.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D0.BF.D1.80.D0.B8.D1.81.D0.B2.D0.B0.D0.B8.D0.B2.D0.B0.D0.BD.D0.B8.D0.B5) — еще одна полезная фишечка Lua.
При таком подходе я использую полную мощность каждого из двух байтов, в которые сохраняется координата. Ну а азимут и наклон не так требовательны к точности, лишь бы укладывались в отрезок **0.0-1.0**. Получается вот так:
```
local math = getfenv(0).math
function EventFrame:OnUpdate()
local facing = GetPlayerFacing();
local pitch = GetUnitPitch("player");
local x, y = GetPlayerMapPosition("player");
local x1, x2 = math.modf(x*255)
local y1, y2 = math.modf(y*255)
HelloWorld1.texture:SetTexture(x1/255, x2, facing/7)
HelloWorld2.texture:SetTexture(y1/255, y2, pitch/4+0.5)
end
```
Теперь при перемещении по миру в левом верхнем углу два квадратика 10 на 10 будут хаотично менять свой цвет.
**Полный текст HelloWorld.lua**
```
local math = getfenv(0).math
SLASH_HELLO_WORLD1 = '/helloworld';
local EventFrame = CreateFrame("Frame")
local HelloWorld1 = CreateFrame("Frame", nil, UIParent)
local HelloWorld2 = CreateFrame("Frame", nil, UIParent)
function EventFrame:OnEvent(event, ...)
print("HelloWorld:", event)
self[event](self, ...)
end
EventFrame:SetScript("OnEvent", EventFrame.OnEvent)
EventFrame:RegisterEvent("PLAYER_LOGIN")
function EventFrame:PLAYER_LOGIN()
HelloWorld1:SetFrameStrata("BACKGROUND")
HelloWorld1:SetWidth(10)
HelloWorld1:SetHeight(10)
HelloWorld1.texture = HelloWorld1:CreateTexture(nil,"BACKGROUND")
HelloWorld1.texture:SetAllPoints(HelloWorld1)
HelloWorld1:SetPoint("TOPLEFT",0,0)
HelloWorld1:Show()
HelloWorld2:SetFrameStrata("BACKGROUND")
HelloWorld2:SetWidth(10)
HelloWorld2:SetHeight(10)
HelloWorld2.texture = HelloWorld2:CreateTexture(nil,"BACKGROUND")
HelloWorld2.texture:SetAllPoints(HelloWorld2)
HelloWorld2:SetPoint("TOPLEFT",10,0)
HelloWorld2:Show()
end
function EventFrame:OnUpdate()
local facing = GetPlayerFacing();
local pitch = GetUnitPitch("player");
local x, y = GetPlayerMapPosition("player");
local x1, x2 = math.modf(x*255)
local y1, y2 = math.modf(y*255)
HelloWorld1.texture:SetTexture(x1/255, x2, facing/7)
HelloWorld2.texture:SetTexture(y1/255, y2, pitch/4+0.5)
end
EventFrame:SetScript("OnUpdate", EventFrame.OnUpdate)
function SlashCmdList.HELLO_WORLD(msg, editbox)
local facing = GetPlayerFacing();
local pitch = GetUnitPitch("player");
local x, y = GetPlayerMapPosition("player");
print(format("HelloWorld %.2f %.2f %.2f %.2f", x*100, y*100, facing, pitch));
end
```
#### Заключение первой части
Повторим, о чем шла речь
1. Мы посчитали вероятность получения предмета за большое число попыток
2. Обозначили задачу, выработали подход к решению, разбили на модули
3. Мы рассмотрели код простейшего аддона для WoW на языке Lua
* научились передавать координаты при помощи цвета
* научились рисовать, обрабатывать события
* научились обрабатывать слеш-команды
Теперь вы готовы к написанию своего аддона.
А если вы разрабатываете нечто и хотите дать возможность себе или пользователям принимать участие, гибко подстраивать ПО под себя с использованием вашего API (например, писать искусственный интеллект противников, дать возможность брокерам размещать позиции, основываясь на котировках, дать возможность администраторам выполнять свои действия по результатам инвентаризации систем пользователей и т.п.), то знайте, Lua очень гибок и очень легко встраивается. Обдумайте такую возможность.
Ну, а в [следующей части](http://habrahabr.ru/post/189874/) мы поговорим о
1. написании Recorder'а клавиш и координат на языке AutoIt
2. написании Player'a инструкций для бота
3. математике 2D, как ориентироваться в декартовой системе координат без теоремы косинусов
4. управлении роботом при недостаточном количестве датчиков
5. мерах противодействия ботам
**Изменение от 14.08**
Добавил [ссылку](http://habrahabr.ru/post/189874/) на вторую часть. | https://habr.com/ru/post/189792/ | null | ru | null |
# Дизайн-система IVI. Взгляд изнутри. Часть 2
Это вторая часть статьи про нашу дизайн-систему. [Первая часть](https://habr.com/ru/post/565500/) выходила раньше.
В этот раз речь пойдёт о философии нашей работы, взаимодействии с дизайнерами и клиентскими разработчиками; о трудностях, с которыми сталкиваемся, и как их преодолеваем; о том, как мы развиваем нашу ДС.
Философия дизайн-системы
------------------------
Если мы поддерживаем такую штуку как дизайн-система, важно не забывать, кому и зачем это вообще нужно.
### ДС как источник истины
Разумеется, дизайн-система важна как *единый источник правды о внешнем виде*. Поэтому мы поддерживаем её в актуальном состоянии, и если по какой-то причине встречается расхождение между макетом и данными в ДС, по умолчанию права именно ДС.
### ДС как «стыковочный сервис»
Задача ДС как сервиса — *формализовывать идеи дизайнеров и отдавать их платформам*.
В такой парадигме дизайн-системе нужно обеспечивать удобство и эффективность работы для обеих сторон процесса. И *всем* в этой схеме важно *открыто коммуницировать и уметь договариваться*.
Мы не только регулярно организуем встречи по актуальным вопросам, но и всячески стимулируем дизайнеров и платформы не стесняясь высказывать свои мысли и идеи, возникающие в процессе работы, будь то описание в стилях компонента какого-то ранее не использовавшегося свойства или дополнение формата отдачи данных.
Поэтому почти всегда правильным ответом на вопрос «А мы можем как-то добавить вот это?» будет «Мы можем всё! Давайте обсудим детали». Главное — *договориться со всеми заинтересованными*, как это должно выглядеть в данных.
Например, в новой вариации текстового бейджика для дизайнера принципиально было использовать увеличенное межбуквенное расстояние (`letter-spacing`), но до этого мы в ДС нигде не описывали подобное. Либо понадобилась стрелочка в ссылке, выравнивающаяся относительно последнего слова в тексте. Либо по наведению на постер нужно его скейлить, причём в одном случае от центра, а в другом от нижнего края.
В этом случае мы вбрасываем в чатик дизайн-системы, что есть потребность описать такую-то сущность. В чатике присутствуют и дизайнеры, и платформенные разработчики, они рассказывают свои возможности, предлагают варианты описания, также предлагаем их и мы как дизайн-система. Если кто-то из платформ не участвует в обсуждении, вовлекаем принудительно, чтобы потом ни для кого не было неприятных сюрпризов.
Опять же, если какая-то новая фича или изменение нужны одной платформе, обсуждаем идею с другими платформами, а если это затрагивает процессы дизайна, то и с дизайнерами.
Таким образом, мы постоянно приучаем дизайнеров и платформенных разработчиков к мысли, что дизайн-система — это не какая-то «данность», с которой нужно смириться и страдать, а инструмент, необходимый в первую очередь для их же удобства. И если каждый будет набрасывать идеи и намечать путь, мы будем постоянно двигаться в нужном направлении. В противном случае дизайн-система вместо инструмента развития рискует превратиться в стопор.
### ДС как арбитр
Ещё одна важная функция ДС — быть арбитром между дизайном и разработкой. При выработке решений мы следим, чтобы не ущемлялись ни права дизайнеров, ни права какой-то из платформ.
По ходу работы мы агрегируем знания об особенностях каждой платформы: возможностях, ограничениях, состоянии дел по внедрению тех или иных фич, текущих проблемах. Эта информация оседает в документации или тикетах-эпиках, в некоторых случаях отражается в наших внутренних тестах, а что-то просто держим в голове и уточняем по необходимости.
### Концентрация на важном
Когда обслуживаешь нужды большого числа людей из различных отделов, нужно делать это эффективно. В первую очередь тут важна документация, которая поможет получить большую часть ответов самостоятельно. Среди прочего у нас есть автоматически генерируемая документация по компонентам дизайн-системы, которая помогает разработчикам правильно интерпретировать данные из ДС. Документация доступна как в виде HTML, так и в виде машиночитаемого JSON.
Так как фронт работ по наполнению и совершенствованию нашей дизайн-системы никогда не пустует, мы стараемся концентрироваться на важных задачах и тратить свои усилия на творческую работу, а не на рутину. Если же от какой-то рутины избавиться пока невозможно, мы стараемся её по максимуму автоматизировать — так у нас появилось автозаполнение доки по компонентам, инструменты для анализа диффов данных, напоминалки ревьюерам, автоматические переходы статусов и т.д.
И, разумеется, не стоит выполнять вручную те проверки, с которыми лучше справится автоматика, поэтому валидация графики и данных (как исходных, так и клиентских) у нас включена в тесты.
### Всё будет изменяться
Наша система работает с такой творческой составляющей как дизайн. Поэтому самое плохое, что мы можем сделать — затормозить полёт дизайнерской мысли техническими ограничениями ДС. Если сейчас что-то реализовано одним образом, это не означает, что завтра не понадобится всё переделать совсем по-другому. Мы всегда живём с *готовностью к неожиданным изменениям*, а также постоянно развиваем процессы и кодовую базу дизайн-системы в сторону большей гибкости.
Разумеется, какие-то изменения могут в текущих условиях оказаться более «дорогими» в сравнении с альтернативами. В этом случае мы оглашаем возможные варианты, но выбор остаётся в любом случае за дизайнерами.
Также в этом контексте не нужно забывать про ограничения на стороне платформ. Если какая-то из них технически не может реализовать тот или иной визуал, нужно вместе с дизайнерами выработать решение. Чаще всего в таких случаях мы приходим к тому, что платформа будет игнорировать «сложные» для неё свойства, либо мы предоставляем какой-то фолбек, т.е. альтернативный визуал, более простой в реализации, чем основной.
Трудности, решения, перспективы
-------------------------------
Разумеется, по ходу развития нашей дизайн-системы мы регулярно сталкиваемся с различным вызовами и трудностями. Ниже приведём некоторые примеры возникавших недавно проблем и наших решений для них.
### Превьюер, удобный для всех
В предыдущей статье [уже отмечалось](https://habr.com/ru/post/565500/#previewer), что для многих точкой входа в ДС, её основной витриной является именно превьюер. За прошедшее с запуска время мы многократно дорабатывали и шлифовали его функционал, однако на данный момент он всё равно удобен не для всех вариантов использования.
Мы выявили потребности разных групп пользователей (разработчиков, дизайнеров, тестировщиков, менеджеров) и на основе этой информации строим новый превьюер рядом со старым. Основным вариантом, вероятнее всего, станет Storybook, но помимо него будут дополнительные «околопревьюерные» инструменты для некоторых специфических юзкейсов.
### Мир дизайна vs мир ДС
Дизайнеры рисуют в фигме, мы заносим данные в дизайн-систему. Синхронизация этих вселенных происходит вручную, так что возможны какие-то рассогласования.
Мы вместе с дизайнерами наметили несколько векторов развития для того, чтобы исправить ситуацию. В первую очередь это единообразный нейминг вариаций компонентов, чтобы прямо из макета можно было понять не только название компонента, но и значения его модификаторов.
Далее мы планируем задействовать API фигмы для синхронизации части примитивов (цветов, типографики, возможно также иконок). После этого будем копать в сторону более сложных синхронизаций, например лейаутов компонентов, но это пока вызывает много вопросов и сомнений.
### Очень. Много. Иконок.
Ещё совсем недавно при каждой выгрузке дизайн-системы формировалась огромная масса иконок во всех возможных цветах и форматах, это занимало кучу времени и места (т.к. вся эта масса ещё и версионировалась на продакшене), а с урлами к этим иконками было очень неудобно работать.
Мы рассматривали несколько вариантов переработки подсистемы иконок, в итоге остановились на том, чтобы организовать её в виде статического «котла», в который сверху «доливаются» изменённые или добавленные иконки, а основная часть остаётся неизменной. При этом существует прозрачная схема для получения урла к нужной иконке в нужном цвете и формате, а значит, не требуется отдавать полный список урлов.
Большинство клиентов уже перешло на прямые запросы к новой подсистеме (Solea), а старую (Painter) мы сохранили лишь как «оболочку»: теперь она фактически ничего не собирает, а лишь отдаёт чужие новые урлы вместо собственных. После перехода оставшихся платформ на Solea мы сможем избавиться от Painter как от рудимента.
### Клиентский формат
Формат данных ДС, с которым сейчас работают клиенты, остался практически неизменным с 2018 года. Мы тогда ещё не вполне представляли, как это всё будет работать, поэтому реализация была максимально простой — стилевые свойства каждого компонента или вариации представлены в виде плоского списка, нет явной типизации, перечня состояний и элементов, а значит, сложнее автоматизировать обработку таких данных. Постепенно «сбоку» от этого мы нарастили дополнительный набор данных, который эти недостатки компенсирует, но лишь частично.
В течение последнего года мы совместно с платформами разработали новый клиентский «формат мечты», в котором присутствует жёсткая типизация свойств, значения сгруппированы по условиям (например, по вариациям и/или состояниям) и элементам, перечислены явным образом состояния, описана иерархия элементов и отсылки к дочерним компонентам и т.д.
Такой формат позволяет лучше автоматизировать обработку данных на стороне платформ, а значит, изменения будут попадать в приложения проще и быстрее.
На данный момент часть компонентов описана в новом формате, платформы постепенно «щупают» эти тестовые данные. Тем временем мы реорганизуем систему так, чтобы старый и новый формат генерировались из единого источника, ведь переходный период никто не отменял.
### Входной формат ДС
Как уже [упоминалось](https://habr.com/ru/post/565500/#platforms) в первой части статьи, основная часть дизайн-системы IVI — это данные. Мы пишем их в виде JSON и клиентам отдаём тоже JSON, но нюанс в том, что их фактическое содержимое может отличаться. Наш входной JSON-формат снабжён дополнительными обвесами в виде отсылок, вычислений и т.д.
На момент запуска такая реализация была гораздо быстрее, чем искать подходящий готовый инструментарий, к тому же всегда можно было просто написать JSON сразу в финальном виде без каких-либо преобразований.
И это всё очень неплохо работало до тех пор, пока число компонентов не превысило первую сотню, но на данный момент мы уже переросли такой подход — пользоваться имеющимся инструментарием стало попросту неудобно. К тому же он не очень подходит для формирования нового клиентского формата — «формата мечты».
Поэтому по мере проработки «формата мечты» мы параллельно экспериментировали и со входным форматом данных для ДС. Было несколько реализаций на YAML, TypeScript и неожиданно вполне успешный вариант на LESS (разработчики CSS-препроцессора наверняка и представить не могли, *насколько* нестандартным образом можно использовать их детище).
В итоге мы остановились на одной из реализаций на основе YAML и TypeScript. Именно её мы начали использовать для описания значений, из которых для платформ будет формироваться как «формат мечты», так и — временно — старый клиентский формат.
### Server-Driven UI
Несмотря на то, что ДС описывает внешний вид компонентов для отрисовки страниц и экранов приложения, логика построения этих экранов зашита частично в ответы API, а частично в код каждого из приложений. Это не позволяет управлять содержимым экранов со стороны продукта так же просто, как это сейчас происходит для стилей компонентов.
Поэтому в прошлом году мы начали размышлять над внедрением подхода Server-Driven UI, в рамках которого API отдаёт содержимое экрана в некоем кроссплатформенном формате (если данные ДС сравнивать с CSS, то тут скорее будет уже «HTML» к этому «CSS»).
В наших реалиях заход SDUI также помог бы более тесно интегрировать общее API и ДС, т.к. сейчас их знания друг о друге не настолько крепки и надёжны, как иногда требуется. Например, ответ API может ссылаться на название сущности, описанной в дизайн-системе (цвет, иконка, вариация компонента), но при этом не иметь информации, действительно ли такая сущность содержится в ДС. С другой стороны, описание структуры компонента в дизайн-системе может быть более простым, если закладываться на то, что часть этой структуры для конкретного случая просто прилетит в ответе API.
Есть несколько внешних реализаций подхода, таких как [Flutter](https://flutter.dev/), [Beagle](https://usebeagle.io/), [Ghost Platform](https://medium.com/airbnb-engineering/a-deep-dive-into-airbnbs-server-driven-ui-system-842244c5f5) или [Screenflow](https://artem-tyurin.medium.com/screenflow-an-unfinished-attempt-at-a-cross-platform-server-driven-ui-at-uber-749c1bc1d89); также у нас были некоторые [внутренние наработки](https://habr.com/ru/company/ivi/blog/511150/) по этой теме.
Но когда когда речь заходит о кроссплатформенности на *таком* уровне, очевидным образом появляется масса вопросов о ресурсоёмкости, производительности и надёжности, которые нам только предстоит решить. Поэтому мы пока скорее только «лежим в эту сторону», хотя от идеи полностью не отказываемся.
### Не всё описано в ДС
На данный момент не все сущности в приложениях, которые заслуживают быть компонентами, описаны в нашей дизайн-системе, — в т.ч. и потому, что пока занесение туда всего и вся время- и трудозатратны.
Однако новый входной и новый клиентский формат, а также интеграция с фигмой, должны существенно облегчить эти процессы. Ну, а в случае захода SDUI повальное занесение компонентов попросту станет неизбежностью.
Резюмируя
---------
Наша дизайн-система существует не первый год, но постоянно развивается. Мы не только постоянно наполняем её данными, но и совершенствуем инструментарий, форматы данных и другие возможности системы.
В таких реалиях критически важно правильно выстроить процессы и коммуникации со всеми заинтересованными сторонами, получать регулярный фидбек и собирать идеи, иначе дизайн-система вместо инструмента развития продукта превратится в обузу.
Развиваясь правильным путём, дизайн-система не только не утратит актуальности в ближайшем будущем, но и будет постоянно увеличивать наполнение и охват, а также всё глубже проникать в продуктовые и разработческие процессы компании. | https://habr.com/ru/post/565516/ | null | ru | null |
# Использование библиотеки ColorPicker в Android для реализации гибкого выбора цвета
Понадобилось реализовать выбор цвета пользователем для вашего Android-приложения? Эта библиотека — отличный выбор.Без долгих предисловий, начнем.
Как всегда, для начала добавим библиотеку в приложение (файл build.gradle(module.app) ):
`implementation 'com.jaredrummler:colorpicker:1.1.0'`
С этим разобрались. Теперь приступим непосредственно к реализации выбора цвета.
Создадим разметку:
```
xml version="1.0" encoding="utf-8"?
```
У нас есть 2 кнопки, по нажатию на которые будет открываться диалоговое окно для выбора цвета. Когда мы выбрали цвет, он будет меняться у двух наших TextView.
Добавим наши поля в MainActivity:
```
Button firstButton,secondButton;
TextView firstText,secondText;
private static final int firstId = 1,secondId = 2;
// id нужны для реализации метода onColorSelected интерфейса ColorPickerDialogListener
```
… и инициализируем их в onCreate():
```
firstButton = findViewById(R.id.firstButton);
secondButton = findViewById(R.id.secondButton);
firstText = findViewById(R.id.firstText);
secondText = findViewById(R.id.secondText);
```
**ВАЖНО**: Также необходимо, чтобы MainActivity реализовывала методы интерфейса ColorPickerDialogListener:
Теперь создадим метод для создания диалогового окна и указаный в XML-разметке метод onClick:
```
private void createColorPickerDialog(int id) {
ColorPickerDialog.newBuilder()
.setColor(Color.RED)
.setDialogType(ColorPickerDialog.TYPE_PRESETS)
.setAllowCustom(true)
.setAllowPresets(true)
.setColorShape(ColorShape.SQUARE)
.setDialogId(id)
.show(this);
// полный список атрибутов класса ColorPickerDialog смотрите ниже
}
public void onClickButton(View view) {
switch (view.getId()) {
case R.id.firstButton:
createColorPickerDialog(firstId);
break;
case R.id.secondButton:
createColorPickerDialog(secondId);
break;
}
}
```
*все атрибуты класса ColorPickerDialog*
Также необходимо реализовать методы интерфейса ColorPickerDialogListener:
```
@Override
public void onColorSelected(int dialogId, int color) {
switch (dialogId) { // смотрим, какая кнопка нажата
case firstId:
firstText.setTextColor(color);
break;
case secondId:
secondText.setTextColor(color);
break;
}
}
@Override
public void onDialogDismissed(int dialogId) {
Toast.makeText(this, "Dialog dismissed", Toast.LENGTH_SHORT).show();
}
```
Запускаем и… готово!
Однако это ещё не все возможности библиотеки ColorPicker. Она также добавляет preference для PreferenceScreen. Это позволяет реализовать выбор цвета в настройках. Посмотрим, как это работает.
1) Создадим новую SettingsActivity:
2) Откроем файл root\_preferences.xml и изменим его следующим образом:
```
```
Как видите, мы создали Preference типа ColorPreferenceCompat
3) Создадим в activity\_main.xml кнопку для перехода в нашу SettingsActivty:
4) Создадим метод openSettingsActivity в MainActivity и укажем его в поле «onClick» этой кнопки:
```
public void openSettingsActivity(View view) {
startActivity(new Intent(this,SettingsActivity.class));
}
```
В этой же MainActivity создадим метод, который изменяет её фон в зависимости от выбранного в настройках цвета и вызовем этот метож в onCreate:
```
private void setBackgroundColorFromSettingsActivity() {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
//SharedPreferences используется для сохранения настроек
//Подробнее - тут:
//https://developer.android.com/reference/android/content/SharedPreferences?hl=ru
int color = sp.getInt("color_picker",Color.GREEN);
RelativeLayout layout = findViewById(R.id.activityMain);
layout.setBackgroundColor(color);
}
```
Переопределим метод onResume (подробнее [тут](https://developer.android.com/guide/components/activities/activity-lifecycle?hl=ru)):
```
@Override
protected void onResume() {
setBackgroundColorFromSettingsActivity();
super.onResume();
}
```
5) Запустим приложение и посмотрим, что получилось:
Как видите, все работает корректно.
P.S: Полезные сслыки:
* [Код библиотеки на GitHub (оф.документация там же)](https://github.com/jaredrummler/ColorPicker)
* [Похожая библиотека(если эта вам чем-то не приглянулась)](https://github.com/QuadFlask/colorpicker)
P.S.S: [Код приложения на GitHub](https://github.com/wllboy/ColorPickerApplication) | https://habr.com/ru/post/496136/ | null | ru | null |
# Proxy на работе и отсутствие его дома
##### Или галочка достала
[](http://www.imageup.ru/img38/form111651.jpg)
У меня на работе, как и у многих других, Интернет работает через Proxy, естественно каждое утро (так как у меня ноут который всегда со мной) приходится ползти в настройки и ставить эту галочку, приходя домой с работы, опять же нужно ее убирать. В общем достало…
##### Решение проблемы
Наверное есть специальные программы для управления Proxy серверами если кто знает может перечислить их в комментах. Я пошел по другому пути. За галочку в реестрее отвечает вот этот параметр.
`HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\ProxyEnable`
Пишем bat файл который быстренько будет инвертировать нам это значение.
`@echo off`
Где 192.168.0.242 ip адрес моего internet Proxy на работе
Алгоритм прост, пингуем Proxy если пингуется значит на работе ставим галочку еже ли нет то убираем галочку
все это копируем в \*.bat и пользуемся
Кому интересно почитать про Командную Строку прошу [суда](http://www.firststeps.ru/msoffice/win/bats/bats1.html) или [туда](https://forum.ru-board.com/topic.cgi?forum=5&topic=4582&start=1440)
**UPDATE:** работает и IE и Хроме | https://habr.com/ru/post/55348/ | null | ru | null |
# Маркетинговая аналитика на Python. Пишем код для RFM-сегментации
RFM - классический инструмент маркетинга для сегментации вашей клиентской базы. Я использую ее для работы в В2В, В2G сегменте. В основе него - понятные управленцу ценности: LTV и Purchase Frequency.
Как можно применять этот инструмент:
1. Посчитать отток клиентской базы
2. Найти клиентов в оттоке - самых крупных заказчиков, которые, почему-то, раньше покупали часто и много, а потом - перестали. В первую очередь, важно выяснить причину оттока и попытаться вернуть именно этих партнёров.
3. Определить ключевых заказчиков - которые покупают много, часто и давно. Этот сегмент самых лояльных пользователей можно использовать для опросов, создания совместных кейсов использования вашего продукта или услуги, воспитания адвокатов бренда, да и просто для укрепления дружественных связей - например, приглашения на мероприятия.
4. Определить сегмент пользователей, которые делают заказы часто и давно - работа с таким сегментом будет заключаться в попытках поднять средний чек - возможно, не обо всех продуктах и услугах компании известно этим пользователям.
Методология RFM вполне простая: исследователю нужно присвоить каждому заказчику степень «1», «2», «3» в зависимости от :
* общей суммы отгруженных заказов (предоставленных и оплаченных услуг) за весь период работы с контрагентом. За нее отвечает показатель Monetary (M)
* частоты заказов – Frequency (F)
* насколько недавно была совершена последняя сделка – Recency (R)
Степеней может быть больше – это будет зависеть от того, насколько данные однородные. Какие могут встречаться комбинации в RFM:
1. R=3, F=1, M=1 = заказчики с самым высоким LTV и высокой частотой заказов, которые делали последний заказ давно, находятся в оттоке. Такие контрагенты требуют экстренных мероприятий по выявлению причин оттока и попыток вернуть клиента
2. M=1, F=1, R=1 = потенциально опинион-лидеры, адвокаты вашего бренда. Также полезно изучить качественный состав таких контрагентов при большом количестве сегментов целевой аудитории в вашей базе
3. M=2/3, F=1, R=1= в таком сегменте здорово проводить мероприятия, направленные на увеличение среднего чека
Большинство маркетологов, проводя это исследование, используют выгрузку из своей CRM и проводят сортировку в Excel. Такой подход имеет серьезные недостатки:
1. Отсутствует простое и быстрое решение исследования однородоности данных. Например, у 5% ваших заказчиков LTV может составлять более нескольких миллионов рублей (маржинальную прибыль вы рассматриваете или общий доход – не так важно), а у остальных 95% заказчиков – составлять менее нескольких сотен тысяч рублей. В такой ситуации «просто поделить базу на 3 сегмента» не получится
2. Excel работает очень медленно с большим массивом данных (в представленном мною примере мы изучали базу контрагентов производственной компании Первый Профильный Завод, состоящую из 3480 компаний)
3. Отсутствует простое и быстрое решение визуализации данных (в Python это реализуется в пару строк), визуализация понадобится нам для прогнозирования спроса, выявления тренда и сезонности (может, напишу материал об этой методологии исследования спроса и расскажу о своих попытках применить модели временных рядов, ARIMA и SARIMA на Python).
Я использую в работе Jupiter Notebook, библиотеки Python Numpy, Pandas, Matplotlib. Поехали.
В первую очередь мне понадобилось выполнить предобработку данных непосредственно в Excel и привести выгрузку из 1С к виду:
В таблице представлены уникальные наименования контрагентов, даты и суммы всех их заказов за весь период сотрудничества. Уникальный User\_id присваивается каждому уникальному наименованию ООО. Если вы – начинающий пользователь Python, обратите внимание на названия колонок таблицы – мы будем использовать их в коде. Мои комментарии к процессам работы вы найдете на скринах после ''#’ символа.
После выполнения предобработки данных, сохраним файл и скопируем путь к нему, откроем новый проект в Jupiter Notebook и импортируем необходимые библиотеки. Откроем файл с данными - наименование компании, id компании, даты заказов компании и суммы заказов. Библиотека Datetime понадобится нам для того, чтобы преобразовать строковый тип данных в дату и посчитать дельту дней между сегодняшним днём и последней датой заказа каждого контрагента.
Обращу внимание на принципы работы с датафреймами, которые помогут серьёзно сократить вам время исследования и избежать моих ошибок:
1. Обязательно пересохраняйте или создавайте новый датафрейм после преобразований.
2. Проверяйте количество строк в датафрейме после того, как задали индексы или соединили датафреймы методом merge
3. Переименовывайте колонки после выполнения преобразований над ними, это поможет не запутаться.
Далее мы должны преобразовать строковый тип данных в дату и найти частоту заказов Frequency (частота заказов будет совпадать с количеством упоминаний уникального user\_id), это можно выполнить с помощью следующего кода:
Выполняем преобразования датафреймов по индексу:
Вызываем волшебный инструмент, который исследует однородность данных. Функция describe оценивает столбцы с числовым типом данных и возвращает статистические данные, которые дают представление о распределении значений.
Можно отметить значительную разницу между максимальным количеством заказов по контрагенту и 99% процентами других контрагентов, вероятно, контрагентов с количеством заказов 50-1255 стоит выделить в отдельный RFM сегмент или имел место некоторый выброс данных (например, как в нашем случае, компания вешает весомую часть заказов за наличный расчёт на одного контрагента с общим уникальным наименованием и user\_id):
Понятно, почему после исследования методом describe таблицы с частотой Frequency, мы обнаружили, что 80% контрагентов делали заказы 5 и менее раз - это связано с ростом количества новых клиентов в последний год.
Найдем общую сумму заказов по каждому контрагенту (LTV по общему доходу):
И переименуем колонку, чтобы избежать путаницы:
Найдем даты последних заказов по каждому контрагенту, чтобы описать показатель Recency:
Периодически я проверяю количество строк в получившемся датафрейме, чтобы избежать потери данных после неправильного преобразования индексов (своего рода самопроверка). Опять переименуем колонку, чтобы понимать, что мы получили в результате исследований дату именно последней отгрузки:
и удалим из датафрейма более не нужную нам колонку order\_value:
Объединим два датафрейма - с LTV контрагента и датой его последней отгрузки по user\_name и user\_id:
Используйте форматирование для того, чтобы оставить только два знака после запятой в столбцах с суммами, если того требует вашу чувство прекрасного и размеры монитора. Попробуем описать таблицу, получившуюся после слияния:
Можно увидеть значительную разницу между максимальной суммой всех заказов одного покупателя и 97% остальных контрагентов, это может потребовать дополнительного изучения, стоит помнить об этом при RFM сегментации, скорректировать персентиль и изучить список контрагентов с самым высоким LTV. Такую картину можно наблюдать еще, если, например, все отгрузки за расчет по кассе вы кидаете на одного контрагента с общим уникальным наименованием - "Частное лицо", например. По - хорошему стоит избавиться от такого выброса данных. Пока я не нашла оптимального способа подбора персентиля для исследования однородности распределения данных и просто подбираю его вручную, в зависимости от амплитуды полученных значений. Клиентов с общей суммой всех отгруженных заказов свыше 716252.17 пока попробуем выделить в отдельный RFM сегмент most\_monetary. Вызвав .shape, можно найти сразу, что количество таких контрагентов - 104 шт.
Сегмент most\_monetary состоит из 104 клиентов, отсортируем его по последней дате заказа, чтобы выделить клиентов, которые требуют действий для возвратности. Можно отметить, что в основном это заказчики - промышленные компании, а не строительные, что логично, так как серийное производство привязано к OEM-подряду и регулярно закупает комплектующие. Таким образом, теперь мы можем доказать собственнику, что самый важный сегмент (most\_monetary) для расширения клиентской базы - именно промышленные компании, несмотря на то, что основную часть оборота составляют строительные материалы, а основную часть базы контрагентов - строительные компании:
Найдем, сколько клиентов делали свой последний заказ более 730 дней назад (6 месяцев, в среднем, по моим подсчетам, составляет цикл сделки в сфере Первого Профильного Завода: В2В, В2G производства комплектующих и строительства, далее вы поймете, почему я выбрала 730 дней для описания пользователей в оттоке - будет страшная история о несостоятельности гипотез. . ). Во время работы я сохранила данные и о пользователях, которые делали последний заказ более полугода назад, и о тех, кто делал последний заказ более года назад, приведу только пример с 730 днями:
Колонка churn\_time покажет, сколько дней назад последний раз был отгружен заказ. Так мы сможем найти контрагентов в оттоке. Исследуем и эти данные на однородность. 50% пользователей делали последний заказ в промежутке между 705 и 1721 днями назад последний раз. Какой-то вопиющий процент оттока, подозрительно:
При первом рассмотрении данных возникла такая гипотеза: что госконтракты - разовые сделки для ООО , некоторые открывают ООО и ИП конкрентно под госпоставки, отсюда и отток.
Я уже собралась проводить опрос среди этих 50% контрагентов, чтобы определить причину отказа от сотрудничества, но меня вовремя остановили собственники - оказалось, что большинство из этих контрагентов были просто перенесены в базу из базы бывшей головной компании, чьими дилерами мы были до запуска своих производственных мощностей. Такой вот Data Science. Опять же, стоит исключить всех таких контрагентов из нашей базы и очистить RFM, но для моделирования пока будем использовать эту базу, присвоив ей статус "сферического коня в вакууме".
Отсортируем пользователей в оттоке по сумме заказов:
Добавили данные по частоте заказов и выбрали оттекших пользователей более 730 дней назад :
Мне нужно было изучить и видеть все строки и колонки данных в этом датафрейме, так что вот волшебная кнопка:
Эти данные - контрагентов с последней датой заказов, частотой заказов и общим LTV и днями пребывания в оттоке уже можно было бы сохранить в виде таблицы, удалив ненужную колонку с информацией по current\_date, которую мы использовали для "вычитания" дат.
Таким образом, мы создали базовые коды для быстрой аналитики клиентской базы Первого Профильного Завода для отдела продаж, можем найти клиентов с наибольшим общим доходом в оттоке и сформировать для них персональное предложение, провести опрос по причинам оттока. Приступим непосредственно к RFM-сегментации. Добавим коэффициент значение Monetary, учитывая то, что всего лишь 3% от всех контрагентов сделали заказов всего на сумму более 716252.51 и распределим по сегментам:
Присвоим индекс количества заказов F (вы помните, что после исследования методом describe таблицы с частотой, мы обнаружили, что 80% контрагентов делали заказы 5 и менее раз):
Добавим коэффициент давности заказа на основе изучения churn time, помня о том, что был значительный рост оборота и прирост клиентской базы в последние 730 дней:
Получили итоговую разбивку по RFM c учетом неоднородности данных клиентской базы:
И проведем еще пару полезных манипуляций: Сегмент attention требует изучения причин оттока, одни из самых крупных клиентов с самыми старыми датами последних заказов, которых мы найдем так:
`attention_raw = rfm_final.loc[rfm_final ['M'] == 1]
attention = attention_raw.loc[rfm_final ['R'] == 3]`
И импортируем их в файл:
`attention.to_csv('file1.csv')`
Или найдем самых классных, верных и упитанных конрагентов, чтобы премировать их, создавать адвокатов бренда, свозить на море и прочее:
`prize_raw = rfm_final.loc[rfm_final ['M'] == 1]
prize = prize_raw.loc[rfm_final ['R'] == 1]`
`prize_fin = prize.loc[rfm_final ['F'] == 1]`
И импортируем их в файл:
`prize_fin.to_csv('file2.csv')`
Ура, теперь мы знаем, как можно использовать Python для изучения клиентской базы и RFM - сегментации. В будущем я постараюсь показать прогнозирование спроса, выявление его сезонности и тренда с помощью Python. Это мой первый пост на Хабре и первые попытки применить новый для себя инструмент в маркетинговой рутине - я буду очень благодарна за вашу критику и комментарии.
UPD: вы можете написать мне ВКонтакте <https://vk.com/korotko_marsianskoe_leto>, чтобы получить ссылку на файл .ipynb и датасет. | https://habr.com/ru/post/658225/ | null | ru | null |
# [DotNetBook] Stackalloc: забытая команда C#
 С этой статьей я продолжаю публиковать целую серию статей, результатом которой будет книга по работе .NET CLR, и .NET в целом. Вся книга будет доступна на GitHub (ссылка в конце статьи).
В C# существует достаточно интересное и очень редко используемое ключевое слово `stackalloc`. Оно настолько редко встречается в коде (тут я даже со словом «редко» преуменьшил. Скорее, «никогда»), что найти подходящий пример его использования достаточно трудно а уж придумать тем более трудно: ведь если что-то редко используется, то и опыт работы с ним слишком мал. А все почему? Потому что для тех, кто наконец решается выяснить, что делает эта команда, `stackalloc` становится более пугающим чем полезным: темная сторона `stackalloc` — unsafe код. Тот результат, что он возвращает не является managed указателем: значение — обычный указатель на участок не защищенной памяти. Причем если по этому адресу сделать запись уже после того как метод завершил работу, вы начнете писать либо в локальные переменные некоторого метода или же вообще перетрете адрес возврата из метода, после чего приложение закончит работу с ошибкой. Однако наша задача — проникнуть в самые уголки и разобраться, что в них скрыто. И понять, в частности, что если нам дали этот инструмент, то не просто же так, чтобы мы смогли найти секретные грабли и наступить на них со всего маху. Наоборот: нам дали этот инструмент чтобы мы смогли им воспользоваться и делать поистине быстрый софт. Я, надеюсь, вдохновил вас? Тогда начнем.
> ### Примечание
>
>
>
> Глава, опубликованная на Хабре не обновляется и возможно, уже несколько устарела. А потому, прошу обратиться за более свежим текстом к оригиналу:
>
>
>
> *  CLR Book: [GitHub, оглавление](https://github.com/sidristij/dotnetbook/)
> *  CLR Book: [GitHub, глава, ссылка на часть `Выделение памяти на стеке: stackalloc`](https://github.com/sidristij/dotnetbook/blob/master/ThreadStack.md#%D0%92%D1%8B%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8-%D0%BD%D0%B0-%D1%81%D1%82%D0%B5%D0%BA%D0%B5-stackalloc)
> *  Релиз 0.5.2 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.2)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/)
Чтобы найти правильные примеры использования этого ключевого слова надо проследовать прежде всего к его авторам: компании Microsoft и посмотреть как его используют они. Сделать это можно поискав полнотекстовым поиском по репозиторию [coreclr](https://github.com/dotnet/coreclr). Помимо различных тестов самого ключевого слова мы найдем не более 25 использований этого ключевого слова по коду библиотеки. Я надеюсь что в предыдущем абзаце я достаточно сильно вас мотивировал чтобы вы не остановили чтение, увидев эту маленькую цифру и не закрыли мой труд. Скажу честно: команда CLR куда более дальновидная и профессиональная чем команда .NET Framework и если она что-то сделала то нам сильно в чем-то должно помочь. А если это не использовано в .NET Framework… Ну, тут можно предположить, что там не все инженеры в курсе что есть такой мощный инструмент оптимизации. Иначе бы объемы его использования были бы гораздо больше.
[**Класс Interop.ReadDir**](https://github.com/dotnet/coreclr/blob/b29f6328510207970763580d6f4db864e4b198af/src/mscorlib/shared/Interop/Unix/System.Native/Interop.ReadDir.cs#L71-L83)
```
unsafe
{
// s_readBufferSize is zero when the native implementation does not
// support reading into a buffer.
byte* buffer = stackalloc byte[s_readBufferSize];
InternalDirectoryEntry temp;
int ret = ReadDirR(dir.DangerousGetHandle(), buffer, s_readBufferSize, out temp);
// We copy data into DirectoryEntry to ensure there are no dangling references.
outputEntry =
ret == 0
? new DirectoryEntry() {
InodeName = GetDirectoryEntryName(temp),
InodeType = temp.InodeType
}
: default(DirectoryEntry);
return ret;
}
```
Для чего здесь используется `stackalloc`? Как мы видим, после выделения памяти код уходит в unsafe метод для заполнения созданного буфера данными. Т.е. unsafe метод, которому необходим участок для записи выделяется место прямо на стеке: динамически. Это отличная оптимизация если учесть что альтернативы: запросить участок памяти у Windows или fixed (pinned) массив .NET, который помимо нагрузки на кучу нагружает GC тем что массив прибивается гвоздями чтобы GC его не пододвинул во время доступа к его данным. Выделяя память на стеке мы не рискуем ничем: выделение происходит почти моментально и мы можем совершенно спокойно заполнить его данными и выйти из метода. А вместе с выходом из метода исчезнет и stack frame метода. В общем, экономия времени значительнейшая.
Давайте рассмотрим еще один пример:
[**Класс Number.Formatting::FormatDecimal**](https://github.com/dotnet/coreclr/blob/efebb38f3c18425c57f94ff910a50e038d13c848/src/mscorlib/shared/System/Number.Formatting.cs#L287-L311)
```
public static string FormatDecimal(
decimal value,
ReadOnlySpan format,
NumberFormatInfo info)
{
char fmt = ParseFormatSpecifier(format, out int digits);
NumberBuffer number = default;
DecimalToNumber(value, ref number);
ValueStringBuilder sb;
unsafe
{
char\* stackPtr = stackalloc char[CharStackBufferSize];
sb = new ValueStringBuilder(new Span(stackPtr, CharStackBufferSize));
}
if (fmt != 0)
{
NumberToString(ref sb, ref number, fmt, digits, info, isDecimal:true);
}
else
{
NumberToStringFormat(ref sb, ref number, format, info);
}
return sb.ToString();
}
```
Это — пример форматирования чисел, опирающийся на еще более интересный пример класса [ValueStringBuilder](https://github.com/dotnet/coreclr/blob/efebb38f3c18425c57f94ff910a50e038d13c848/src/mscorlib/shared/System/Text/ValueStringBuilder.cs), работающий на основе `Span`. Суть данного участка кода в том что для того чтобы собрать текстовое представление форматированного числа максимально быстро, код не использует выделения памяти под буфер накопления символов. Этот прекрасный код выделяет память прямо в стековом кадре метода, обеспечивая тем самым отсутствие работы сборщика мусора по экземплярам StringBuilder если бы метод работал на его основе. Плюс уменьшается время работы самого метода: выделение памяти в куче тоже время занимает. А использование типа `Span` вместо голых указателей вносит чувство безопасности в работу кода, основанного на `stackalloc`.
И на последок давайте разберем еще один пример: сам класс `ValueStringBuilder`, который спроектирован использовать `stackalloc`. Без него не было бы и этого класса.
[**Класс ValueStringBuilder**](https://github.com/dotnet/coreclr/blob/efebb38f3c18425c57f94ff910a50e038d13c848/src/mscorlib/shared/System/Text/ValueStringBuilder.cs)
```
internal ref struct ValueStringBuilder
{
private char[] _arrayToReturnToPool;
private Span \_chars;
private int \_pos;
public ValueStringBuilder(Span initialBuffer)
{
\_arrayToReturnToPool = null;
\_chars = initialBuffer;
\_pos = 0;
}
public int Length
{
get => \_pos;
set
{
int delta = value - \_pos;
if (delta > 0)
{
Append('\0', delta);
}
else
{
\_pos = value;
}
}
}
public override string ToString()
{
var s = new string(\_chars.Slice(0, \_pos));
Clear();
return s;
}
public void Insert(int index, char value, int count)
{
if (\_pos > \_chars.Length - count)
{
Grow(count);
}
int remaining = \_pos - index;
\_chars.Slice(index, remaining).CopyTo(\_chars.Slice(index + count));
\_chars.Slice(index, count).Fill(value);
\_pos += count;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Append(char c)
{
int pos = \_pos;
if (pos < \_chars.Length)
{
\_chars[pos] = c;
\_pos = pos + 1;
}
else
{
GrowAndAppend(c);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void GrowAndAppend(char c)
{
Grow(1);
Append(c);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void Grow(int requiredAdditionalCapacity)
{
Debug.Assert(requiredAdditionalCapacity > \_chars.Length - \_pos);
char[] poolArray = ArrayPool.Shared.Rent(
Math.Max(\_pos + requiredAdditionalCapacity, \_chars.Length \* 2));
\_chars.CopyTo(poolArray);
char[] toReturn = \_arrayToReturnToPool;
\_chars = \_arrayToReturnToPool = poolArray;
if (toReturn != null)
{
ArrayPool.Shared.Return(toReturn);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void Clear()
{
char[] toReturn = \_arrayToReturnToPool;
// for safety, to avoid using pooled array if this instance is erroneously appended to again
this = default;
if (toReturn != null)
{
ArrayPool.Shared.Return(toReturn);
}
}
// Пропущенные методы
private void AppendSlow(string s);
public bool TryCopyTo(Span destination, out int charsWritten);
public void Append(string s);
public void Append(char c, int count);
public unsafe void Append(char\* value, int length);
public Span AppendSpan(int length);
}
```
Этот класс по своему функционалу сходен со своим старшим собратом `StringBuilder`, обладая при этом одной интересной и очень важной особенностью: он является значимым типом. Т.е. передается целиком по значению. А новейший модификатор типа `ref`, который приписан к сигнатуре объявления типа говорит нам о том что данный тип обладает дополнительным ограничением: он имеет право находиться только на стеке. Т.е. вывод его экземпляров в поля классов приведет к ошибке. К чему все эти приседания? Для ответа на этот вопрос достаточно посмотреть на класс `StringBuilder`:
[**Класс StringBuilder**](https://github.com/dotnet/coreclr/blob/68f72dd2587c3365a9fe74d1991f93612c3bc62a/src/mscorlib/src/System/Text/StringBuilder.cs#L47-L62)
```
public sealed class StringBuilder : ISerializable
{
// A StringBuilder is internally represented as a linked list of
// blocks each of which holds a chunk of the string. It turns
// out string as a whole can also be represented as just a chunk,
// so that is what we do.
// The characters in this block
internal char[] m_ChunkChars;
// Link to the block logically before this block
internal StringBuilder m_ChunkPrevious;
// The index in m_ChunkChars that represent the end of the block
internal int m_ChunkLength;
// The logical offset (sum of all characters in previous blocks)
internal int m_ChunkOffset;
internal int m_MaxCapacity = 0;
// ...
internal const int DefaultCapacity = 16;
```
StringBuilder — это класс, внутри которого находится ссылка на массив символов. Т.е. когда вы создаете его то по сути создается как минимум два объекта: сам StringBuilder и массив символов в как минимум 16 символов (кстати именно поэтому так важно задавать предполагаемую длину строки: ее построение будет идти через генерацию односвязного списка 16-символьных массивов. Согласитесь, это — расточительство). Что это значит в контексте нашего разговора о типе ValueStringBuilder: capacity по-умолчанию отсутствует, т.к. он заимствует память извне плюс он сам является значимым типом и заставляет пользователя расположить буфер для символов на стеке. Как итог весь экземпляр типа ложится на стек вместе с его содержимым и вопрос оптимизации здесь становится решенным. Нет выделения памяти в куче? Нет проблем с проседанием производительности по куче. Но вы мне скажите: почему тогда не пользоваться ValueStringBuilder (или его самописной версией: сам он internal и нам не доступен) всегда? Ответ такой: надо смотреть на задачу, которая вами решается. Будет ли результирующая строка известного размера? Будет ли она иметь некий известный максимум по длине? Если ответ «да» и если при этом размер строки не выходит за некоторые разумные границы, то можно использовать значимую версию StringBuilder. Иначе, если мы ожидаем длинные строки, переходим на использование обычной версии.
Также, перед тем как перейти к выводам стоит упомянуть как делать нельзя или просто опасно. Другими словами, какой код может работать хорошо, но в один прекрасный момент выстрелит в самый не подходящий момент. Опять же, рассмотрим пример:
```
void GenerateNoise(int noiseLength)
{
var buf = new Span(stackalloc int[noiseLength]);
// generate noise
}
```
Код мал да удал: нельзя вот так брать и принимать размер для выделения памяти на стеке извне. Если вам так нужен заданный снаружи размер и при этом ваш код известен только известному вам потребителю, примите, например, сам буфер:
```
void GenerateNoise(Span noiseBuf)
{
// generate noise
}
```
Этот код гораздо информативнее, т.к. заставляет пользователя задуматься и быть аккуратным при выборе чисел. Первый вариант при неудачно сложившихся обстоятельствах может выбросить `StackOverflowException` при достаточно неглубоком положении метода в стеке потока: достаточно передать большое число в качестве параметра.
Вторая проблема, которую я вижу: если нам случайным образом не удалось попасть в размер того буфера, который мы сами себе выделили на стеке, а терять работоспособность мы не хотим, то, конечно, можно пойти несколькими путями: либо довыделить памяти опять же на стеке либо выделить ее в куче. Причем скорее всего второй вариант в большинстве случаев окажется более предпочтительным (так и поступили в случае `ValueStringBuffer`), т.к. более безопасен с точки зрения получения `StackOverflowException`.
### Выводы к stackalloc
Итак, для чего же лучше всего использовать `stackalloc` и как?
* Для работы с неуправляемым кодом, когда необходимо заполнить неуправляемым методом некоторый буфер данных или же принять от неуправляемого метода некий буфер данных, который будет использоваться в рамках жизни тела метода;
* Для методов, которым нужен массив, но опять же на время работы самого метода. Пример с форматированием очень хороший: этот метод может вызываться слишком часто чтобы он выделял временные массивы в куче.
* Если используется unsafe версия взаимодействия, необходимо тщательно проверять работу тех методов, в которые уходит ссылка (void \*) т.к. если они куда-то ее отдают, то возникает дальнейшая возможность порчи стека: вы ведь не можете гарантировать что внешний метод не решит передать ссылку, например для кэширования. Если же вы уверены что такое исключено, то использование будет безопасным
* Если вы имеете возможность пользоваться `ref struct` типами или же Span типом, то работа со stackalloc переходит в область managed кода, а это значит что компилятор просто не даст вам использовать тип не так как задумано
Использование данного аллокатора может сильно повысить производительность ваших приложений.
> ### Ссылка на всю книгу
>
>
>
> *  CLR Book: [GitHub](https://github.com/sidristij/dotnetbook/)
> *  Релиз 0.5.0 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.0)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/) | https://habr.com/ru/post/348130/ | null | ru | null |
# Анонимный Дед Мороз 2015-2016 — Пост хвастовства новогодними подарками
Привет, `%username%`!
20 человек уже отметили, что получили свой подарок. Настало время собрать их фотографии и рассказы в этом традиционном посте.
**С НАСТУПИВШИМ НОВЫМ 2016 ГОДОМ!** | https://habr.com/ru/post/275355/ | null | ru | null |
# Простой шейдер мультяшной графики в OpenGL своими руками
Недавно я заинтересовался рисунками, состоящими только из контуров, и решил попытаться воспроизвести нечто подобное для трехмерной графики.
*Suzanne, неофициальный маскот Blender, отрендеренный с получившимся шейдером*
В этом посте я расскажу, как написать отрисовку контуров с плавным переходом веса линий на OpenGL, хотя метод может использоваться в любом другом графическом API. Всем заинтересованным — добро пожаловать под кат.
Дополнительные библиотеки, которые я буду использовать:
* [glfw](https://www.glfw.org/) — для создания окна и обработки событий
* [glew](http://glew.sourceforge.net/) — для загрузки функций OpenGL
* [glm](https://glm.g-truc.net/0.9.9/index.html) — для векторной и матричной математики
* [assimp](https://www.assimp.org/) — для загрузки модели
Конфигурационный файл CMakeLists.txt у меня выглядит так:
```
cmake_minimum_required(VERSION 3.17)
project(OpenGL_posteffect_tutorial)
find_package(GLEW REQUIRED)
find_package(OpenGL REQUIRED)
find_package(glfw3 REQUIRED)
find_package(glm REQUIRED)
find_package(assimp REQUIRED)
add_executable(main main.cpp)
target_link_libraries(main GLEW::GLEW OpenGL glfw glm assimp)
```
В целом, все просто — ищем нужные библиотеки и подключаем.
Шаг 1. Создание окна
--------------------
Создадим наше окно:
```
#include
#include
#include
// Вспомогательный класс, чтобы описать
// освобождение ресурсов сразу после их выделения
class InvokeOnDestroy {
std::function f;
public:
InvokeOnDestroy(std::function &&fn) : f(fn) {}
~InvokeOnDestroy() { f(); }
};
// В целях отладки будем выводить сообщения glfw об ошибках
void myGlfwErrorCallback(int code, const char \*description) {
printf("[GLFW] %d: %s\n", code, description);
fflush(stdout);
}
// Будем закрывать приложение по нажатию на Escape
void myGlfwKeyCallback(GLFWwindow \*window, int key, int scancode, int action,
int mods) {
if (key == GLFW\_KEY\_ESCAPE && action == GLFW\_PRESS)
glfwSetWindowShouldClose(window, GLFW\_TRUE);
}
int main() {
if (!glfwInit())
return \_\_LINE\_\_;
InvokeOnDestroy \_glfwTerminate(glfwTerminate);
glfwSetErrorCallback(myGlfwErrorCallback);
GLFWwindow \*window = glfwCreateWindow(640, 360, "OpenGL Tutorial", nullptr, nullptr);
glfwSetKeyCallback(window, myGlfwKeyCallback);
// Основной цикл
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
glfwSwapBuffers(window);
}
return 0;
}
```
**Результат**
Черный экран. Ожидаемо, ведь мы пока ничего и не рисуем
Шаг 2. Загрузка OpenGL
----------------------
Теперь загрузим сам OpenGL:
```
// GLEW обязательно включать до GLFW
#include
#include
#include
#include
class InvokeOnDestroy {
std::function f;
public:
InvokeOnDestroy(std::function &&fn) : f(fn) {}
~InvokeOnDestroy() { f(); }
};
void myGlfwErrorCallback(int code, const char \*description) {
printf("[GLFW][code=%d] %s\n", code, description);
fflush(stdout);
}
void myGlfwKeyCallback(GLFWwindow \*window, int key, int scancode, int action,
int mods) {
if (key == GLFW\_KEY\_ESCAPE && action == GLFW\_PRESS)
glfwSetWindowShouldClose(window, GLFW\_TRUE);
}
// Создадим обработчик для отладочного вывода самого OpenGL
void GLAPIENTRY myGlDebugCallback(GLenum source, GLenum type, GLuint id,
GLenum severity, GLsizei length,
const GLchar \*message,
const void \*userParam) {
printf("[GL][source=0x%X; type=0x%X; id=0x%X; severity=0x%X] %s\n", source,
type, id, severity, message);
}
int main() {
if (!glfwInit())
return \_\_LINE\_\_;
InvokeOnDestroy \_glfwTerminate(glfwTerminate);
glfwSetErrorCallback(myGlfwErrorCallback);
GLFWwindow \*window =
glfwCreateWindow(800, 600, "OpenGL Tutorial", nullptr, nullptr);
glfwSetKeyCallback(window, myGlfwKeyCallback);
// Загрузка OpenGL
glfwMakeContextCurrent(window);
if (glewInit() != GLEW\_OK)
return \_\_LINE\_\_;
// Привязка отладчика
glEnable(GL\_DEBUG\_OUTPUT);
glDebugMessageCallback(myGlDebugCallback, nullptr);
// Будем закрашивать окно, например, синим цветом
glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
glClear(GL\_COLOR\_BUFFER\_BIT);
glfwSwapBuffers(window);
}
return 0;
}
```
**Результат**
Теперь фон синий
Шаг 3. Отрисовка треугольника
-----------------------------
Напишем несколько простых вспомогательных классов, чтобы легко производить освобождение ресурсов в случае ошибок. Правильная их обработка не является целью этого туториала, но даже при падении программы мы будем корректно освобождать ресурсы.
Дополнительные включаемые файлы:
```
#include
#include
#include
```
Вспомогательный класс шейдера:
```
class Shader {
// Идентификатор объекта OpenGL
GLuint id;
// Загрузка исходного кода из файла
void load(const char *filename) {
FILE *f = fopen(filename, "r");
// В случае неудачи выбросим исключение
// Корректная обработка ошибок не входит в цели этого туториала
// Поэтому здесь ей можно пренебречь
if (!f)
throw std::exception();
InvokeOnDestroy _fclose([&]() { fclose(f); });
// Читаем содержимое файла
std::string src;
int c;
while ((c = getc(f)) != EOF)
src.push_back(c);
// Загружаем код шейдера
const GLchar *string = src.data();
const GLint length = src.length();
glShaderSource(id, 1, &string, &length);
}
// Компиляция шейдера
void compile() {
glCompileShader(id);
// Проверяем успешность компиляции
GLint status;
glGetShaderiv(id, GL_COMPILE_STATUS, &status);
if (!status) {
// В случае неудачи -- выведем сообщение компилятора
// и выбросим исключение
GLchar infoLog[2048];
GLsizei length;
glGetShaderInfoLog(id, sizeof(infoLog) / sizeof(infoLog[0]), &length,
infoLog);
fputs(infoLog, stderr);
fflush(stderr);
throw std::exception();
}
}
public:
Shader(GLenum type) : id(glCreateShader(type)) {}
~Shader() { glDeleteShader(id); }
// Оператор преобразования к GLuint,
// чтобы можно было вызывать функции OpenGL
// прямо от нашего объекта
operator GLuint() { return id; }
// Вынесено в отдельную функцию,
// т.к. в случае исключения в конструкторе
// деструктор не вызывается
void init(const char *filename) {
load(filename);
compile();
}
};
```
Такой же для шейдерной программы:
```
class ShaderProgram {
// Идентификатор объекта OpenGL
GLuint id;
// Компоновка программы
void link() {
glLinkProgram(id);
// Проверяем успешность
GLint status;
glGetProgramiv(id, GL_LINK_STATUS, &status);
if (!status) {
// В случае неудачи -- выведем сообщение компоновщика
// и выбросим исключение
GLchar infoLog[2048];
GLsizei length;
glGetProgramInfoLog(id, sizeof(infoLog) / sizeof(infoLog[0]), &length,
infoLog);
fputs(infoLog, stderr);
fflush(stderr);
throw std::exception();
}
}
// Валидация программы
void validate() {
glValidateProgram(id);
// Проверяем успешность
GLint status;
glGetProgramiv(id, GL_VALIDATE_STATUS, &status);
if (!status) {
// В случае неудачи -- выведем сообщение валидатора
// и выбросим исключение
GLchar infoLog[2048];
GLsizei length;
glGetProgramInfoLog(id, sizeof(infoLog) / sizeof(infoLog[0]), &length,
infoLog);
fputs(infoLog, stderr);
fflush(stderr);
throw std::exception();
}
}
public:
ShaderProgram() : id(glCreateProgram()) {}
~ShaderProgram() { glDeleteProgram(id); }
operator GLuint() { return id; }
// Вынесено в отдельную функцию,
// т.к. в случае исключения в конструкторе
// деструктор не вызывается
void init(const char *vertSrc, const char *fragSrc) {
// Создадим вершинный и фрагментный шейдеры
Shader vert(GL_VERTEX_SHADER);
Shader frag(GL_FRAGMENT_SHADER);
vert.init(vertSrc);
frag.init(fragSrc);
// Присоединим их к программе
glAttachShader(id, vert);
glAttachShader(id, frag);
// Скомпонуем и проверим программу
link();
validate();
}
};
```
А также нам понадобятся вспомогательные классы для:
* Буферов
* Массивов вершин
* Текстур
* Фреймбуферов
У всех этих объектов почти одинаковый интерфейс создания/удаления, поэтому можно создать нужные классы с помощью простого макроса.
```
#define DEFINE_GL_ARRAY_HELPER(name, gen, del) \
struct name : public std::vector { \
name(size\_t n) : std::vector(n) { gen(n, data()); } \
~name() { del(size(), data()); } \
};
DEFINE\_GL\_ARRAY\_HELPER(Buffers, glGenBuffers, glDeleteBuffers)
DEFINE\_GL\_ARRAY\_HELPER(VertexArrays, glGenVertexArrays, glDeleteVertexArrays)
DEFINE\_GL\_ARRAY\_HELPER(Textures, glGenTextures, glDeleteTextures)
DEFINE\_GL\_ARRAY\_HELPER(Framebuffers, glGenFramebuffers, glDeleteFramebuffers)
```
Указатели на функции OpenGL динамические, поэтому воспользоваться шаблонами не получится.
Создадим шейдерную программу, пока что просто выводящую вершины без пространственных преобразований белым цветом:
```
ShaderProgram mainProgram;
mainProgram.init("s1.vert", "s1.frag");
```
s1.vert
```
#version 330 core
in vec3 vertexPosition;
void main() {
gl_Position = vec4(vertexPosition, 1);
}
```
s1.frag
```
#version 330 core
out vec4 pixelColor;
void main() {
pixelColor = vec4(1);
}
```
Зададим координаты треугольника:
```
Buffers buffers(1);
VertexArrays vertexArrays(1);
GLint attribLocation;
glBindVertexArray(vertexArrays[0]);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
// Заполним буфер координатами точек треугольника
GLfloat vertices[] = {
-0.5f, -0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, 0.0f, 0.0f,
};
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Подключим буфер как вход вершинного шейдера
attribLocation = glGetAttribLocation(mainProgram, "vertexPosition");
glEnableVertexAttribArray(attribLocation);
// Зададим использование трех координат на вершину с плотной упаковкой
glVertexAttribPointer(attribLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
```
И начнем отрисовывать треугольник в главном цикле:
```
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
int framebufferWidth, framebufferHeight;
glfwGetFramebufferSize(window, &framebufferWidth, &framebufferHeight);
glViewport(0, 0, framebufferWidth, framebufferHeight);
glClear(GL_COLOR_BUFFER_BIT);
glBindVertexArray(vertexArrays[0]);
glUseProgram(mainProgram);
// Отрисовываем треугольник из начала буфера и трех вершин
glDrawArrays(GL_TRIANGLES, 0, 3);
glUseProgram(0);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
```
**Результат**
Шаг 4. Перемещение камеры
-------------------------
Добавим вращение камеры вокруг треугольника.
Заголовочный файл glm для векторной математики:
```
#include
```
Немного поменяем наш треугольник:
```
GLfloat vertices[] = {
0.0f, 0.0f, 1.0f,
0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 0.0f,
};
```
Новый вершинный шейдер будет применять стандартную последовательность преобразований смещение объекта — преобразование координат в пространство камеры — проекция:
```
#version 330 core
uniform mat4 matModel;
uniform mat4 matView;
uniform mat4 matProjection;
in vec3 vertexPosition;
void main() {
gl_Position = matProjection * matView * matModel * vec4(vertexPosition, 1);
}
```
Получим ссылки на uniform-переменные шейдера, чтобы заполнять их в программе:
```
GLint ulMatModel = glGetUniformLocation(mainProgram, "matModel");
GLint ulMatView = glGetUniformLocation(mainProgram, "matView");
GLint ulMatProjection = glGetUniformLocation(mainProgram, "matProjection");
```
Пусть камера вращается со скоростью 1/8 радиана в секунду, направлена в  и ось «вверх» это Z:
```
float angle = 0.5f * glfwGetTime();
float sin = glm::sin(angle);
float cos = glm::cos(angle);
glm::vec3 pos(2.5f * sin, 2.5f * cos, 1.5f);
glm::vec3 forward = glm::normalize(-pos);
glm::vec3 up(0.0f, 0.0f, 1.0f);
glm::vec3 right = glm::normalize(glm::cross(forward, up));
up = glm::cross(right, forward);
```
Здесь pos — это положение камеры, а forward, right и up — это левая тройка ортогональных единичных векторов, задающих в пространстве камеры оси Z (от камеры), X (вправо) и Y (вверх) соответственно.
Камера смотрит в , поэтому вектора pos и forward противонаправлены.
Вектора forward, up и  лежат в одной плоскости, поэтому вектор right можно получить нормированием векторного произведения forward и  (мировая система координат — правая).
Ну и наконец вектор up можно получить как векторное произведение right и forward (эти векторы уже единичные и ортогональные, поэтому их векторное произведение также будет единичным).
Создадим матрицы преобразований:
```
glm::mat4 matModel(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
```
Никакого смещения в глобальной системе координат не делаем, поэтому матрица модели — единичная.
```
glm::mat4 matView(right.x, up.x, forward.x, 0.0f,
right.y, up.y, forward.y, 0.0f,
right.z, up.z, forward.z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
matView *= glm::mat4(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
-pos.x, -pos.y, -pos.z, 1.0f);
```
Матрица вида — это смещение на положение камеры и проекция на оси координат в пространстве камеры, т.е.
![$M=\left[\begin{array}{cccc} R_x & R_y & R_z & 0 \\ U_x & U_y & U_z & 0 \\ F_x & F_y & F_z & 0 \\ 0 & 0 & 0 & 1 \\ \end{array}\right]\cdot\left[\begin{array}{cccc} 1 & 0 & 0 & -P_x \\ 0 & 1 & 0 & -P_y \\ 0 & 0 & 1 & -P_z \\ 0 & 0 & 0 & 1 \\ \end{array}\right]$](https://habrastorage.org/getpro/habr/formulas/f6f/d34/595/f6fd3459542e39ba42f31d5d67aec374.svg)
Где  — forward,  — right,  — up,  — pos.
Стоит учесть, что в glm матрицы задаются по столбцам, т.е. элементы идут в следующем порядке:
![$A=\left[\begin{array}{cccc} a_1 & a_5 & a_9 & a_{13} \\ a_2 & a_6 & a_{10} & a_{14} \\ a_3 & a_7 & a_{11} & a_{15} \\ a_4 & a_8 & a_{12} & a_{16} \\ \end{array}\right]$](https://habrastorage.org/getpro/habr/formulas/d0f/422/cfd/d0f422cfdfa79fc2246d8b9bbc6d677b.svg)
```
float zNear = 0.0625f;
float zFar = 32.0f;
glm::mat4 matProjection(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, (zFar + zNear) / (zFar - zNear), 1.0f,
0.0f, 0.0f, -2.0f * zFar * zNear / (zFar - zNear), 0.0f);
```
На данном этапе матрица проекции преобразовывает Z из отрезка ![$[z_1;z_2]$](https://habrastorage.org/getpro/habr/formulas/8b7/c07/60a/8b7c0760a435771a8aaf2d1cc1eee01c.svg) ( — zNear,  — zFar) в отрезок ![$[-1;1]$](https://habrastorage.org/getpro/habr/formulas/611/111/1aa/6111111aa20c26d9acfc70c888d6d1d0.svg), а также делит X и Y на Z.
Как это работает: вывод gl\_Position вершинного шейдера до растеризации делится на свою координату W, поэтому для того, чтобы поделить координаты X и Y на Z мы присваиваем W значение нашей координаты Z. При этом отображаемые координаты XYZ ограничены кубом ![$[-1;1]^3$](https://habrastorage.org/getpro/habr/formulas/031/faa/9f2/031faa9f21d995d531be8077773608fe.svg), таким образом новая координата Z должна попасть в этот куб. Зададим минимальное —  и максимальное —  значения этой координаты до преобразования, и представим новую Z как линейную комбинацию Z до преобразования и 1 (т.е. W до преобразования):
При этом  должна остаться возрастающей, т.к.  — ближняя граница, а  — дальняя. Отсюда можно составить простую систему уравнений:
И полученная матрица проекции:
![$M=\left[\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & \frac{z_2+z_1}{z_2-z_1} & -2\frac{z_2z_1}{z_2-z_1} \\ 0 & 0 & 1 & 0 \\ \end{array}\right]$](https://habrastorage.org/getpro/habr/formulas/0af/47b/d30/0af47bd3012881fe7cdec8bfcb33ca9c.svg)
Наконец, загрузим наши матрицы в шейдер:
```
glUseProgram(mainProgram);
glUniformMatrix4fv(ulMatModel, 1, GL_FALSE, &matModel[0][0]);
glUniformMatrix4fv(ulMatView, 1, GL_FALSE, &matView[0][0]);
glUniformMatrix4fv(ulMatProjection, 1, GL_FALSE, &matProjection[0][0]);
glDrawArrays(GL_TRIANGLES, 0, 3);
```
**Результат**
Как и ожидалось, просто вращающийся белый треугольник. Пока ничего интересного.
Шаг 5. Загрузка произвольной модели
-----------------------------------
Заменим треугольник на произвольную фигуру. Подключим заголовочные файлы assimp:
```
#include
#include
#include
```
Пока будем загружать простой куб. Его OBJ-файл выглядит так:
```
v 1 1 1
v 1 1 -1
v 1 -1 1
v 1 -1 -1
v -1 1 1
v -1 1 -1
v -1 -1 1
v -1 -1 -1
f 1 5 7 3
f 4 3 7 8
f 8 7 5 6
f 6 2 4 8
f 2 1 3 4
f 6 5 1 2
```
Здесь просто 8 вершин куба и 6 его граней, по 4 вершины на каждую
Заменим код загрузки вершин в буфер:
```
// Нам потребуется 2 буфера: для вершин и для индексов вершин
Buffers buffers(2);
VertexArrays vertexArrays(1);
GLint attribLocation;
glBindVertexArray(vertexArrays[0]);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
// В объекте произвольное количество вершин, поэтому запишем его в переменную
GLuint indexCount;
{
Assimp::Importer importer;
// Грани могут быть записаны не в виде треугольников,
// поэтому произведем триангуляцию при загрузке
const aiScene *scene =
importer.ReadFile("scene.obj", aiProcess_Triangulate);
// Пока считаем, что у нас только один объект в сцене
const aiMesh *mesh = scene->mMeshes[0];
glBufferData(GL_ARRAY_BUFFER, mesh->mNumVertices * 3 * sizeof(GLfloat),
mesh->mVertices, GL_STATIC_DRAW);
// Проходим по всем граням и запоминаем индексы вершин треугольников
std::vector indices;
for (int i = 0; i < mesh->mNumFaces; ++i)
for (int j = 0; j < mesh->mFaces[i].mNumIndices; ++j)
indices.push\_back(mesh->mFaces[i].mIndices[j]);
// Запоминаем количество индексов
indexCount = indices.size();
// Загружаем индексы в буфер
glBufferData(GL\_ELEMENT\_ARRAY\_BUFFER, indexCount \* sizeof(GLuint),
indices.data(), GL\_STATIC\_DRAW);
}
// Здесь ничего не меняется, на вход вершинного шейдера по-прежнему подаются
// трехмерные вектора вещественных чисел одинарной точности
attribLocation = glGetAttribLocation(mainProgram, "vertexPosition");
glEnableVertexAttribArray(attribLocation);
glVertexAttribPointer(attribLocation, 3, GL\_FLOAT, GL\_FALSE, 0, 0);
glBindVertexArray(0);
glBindBuffer(GL\_ARRAY\_BUFFER, 0);
glBindBuffer(GL\_ELEMENT\_ARRAY\_BUFFER, 0);
```
И код отрисовки:
```
// Заменяем glDrawArrays(GL_TRIANGLES, 0, 3) на
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
```
А также пока заменим наш фрагментный шейдер, чтобы цвет точки зависил от ее глубины:
```
#version 330 core
out vec4 pixelColor;
void main() {
pixelColor = vec4(vec3(exp(-gl_FragCoord.w)), 1);
}
```
**Результат**
Что-то тут не так. Ведь глубина на поверхности куба должна быть непрерывной.
Добавим проверку глубины, чтобы было видно не отрисованный позже пиксель, а ближайший к камере:
```
glEnable(GL_DEPTH_TEST);
```
Также нужно очищать буфер глубины:
```
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
```
**Результат**
Вот теперь порядок
Шаг 6. Постобработка
--------------------
Теперь создадим базовую программу постобработки. Идея заключается в том, чтобы отрендерить изображение в текстуру, а затем эту текстуру отрендерить еще раз. Таким образом, мы сможем считывать значения соседних пикселей при отрисовке текстуры, что и будем использовать для проверки глубины при отрисовке контуров.
Схема треугольника, на который отображается текстура:
Здесь черным обозначены экранные координаты, а синим — текстурные.
Как можно заметить, в черный квадрат экрана (координаты от -1 до 1) попадают точки текстуры с координатами от 0 до 1.
Создадим еще один буфер и массив вершин — для треугольника; две текстуры — для отрисовки цвета и глубины; фреймбуфер — для обозначения, куда мы хотим отрисовывать.
```
Buffers buffers(3);
VertexArrays vertexArrays(2);
Textures textures(2);
Framebuffers framebuffers(1);
```
Загружаем координаты треугольника:
```
glBindVertexArray(vertexArrays[1]);
glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
GLfloat fillTriangle[] = {
-1.0f, -1.0f, 0.0f, 0.0f, //
3.0f, -1.0f, 2.0f, 0.0f, //
-1.0f, 3.0f, 0.0f, 2.0f, //
};
glBufferData(GL_ARRAY_BUFFER, sizeof(fillTriangle), fillTriangle,
GL_STATIC_DRAW);
attribLocation = glGetAttribLocation(postProgram, "vertexPosition");
glEnableVertexAttribArray(attribLocation);
glVertexAttribPointer(attribLocation, 2, GL_FLOAT, GL_FALSE,
4 * sizeof(GLfloat), 0);
attribLocation = glGetAttribLocation(postProgram, "vertexTextureCoords");
glEnableVertexAttribArray(attribLocation);
glVertexAttribPointer(attribLocation, 2, GL_FLOAT, GL_FALSE,
4 * sizeof(GLfloat), (GLvoid *)(2 * sizeof(GLfloat)));
```
Создадим текстуры:
```
const int MAX_WIDTH = 2048;
const int MAX_HEIGHT = 2048;
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, MAX_WIDTH, MAX_HEIGHT, 0, GL_RGB,
GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, MAX_WIDTH, MAX_HEIGHT, 0,
GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
```
Чтобы не пересоздавать текстуры каждый раз при изменении размеров окна, создадим их с запасом по размеру (у меня монитор 1920 на 1080, поэтому 2048 на 2048 — достаточный запас), и будем домножать текстурные координаты на коэффициент
Создаем фреймбуфер:
```
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[0]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
textures[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
textures[1], 0);
GLenum drawBuffers[] = {GL_COLOR_ATTACHMENT0};
glDrawBuffers(sizeof(drawBuffers) / sizeof(drawBuffers[0]), drawBuffers);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
```
И создаем программу постобработки:
```
ShaderProgram postProgram;
postProgram.init("s2.vert", "s2.frag");
```
s2.vert
```
#version 330 core
uniform vec2 textureScale;
in vec2 vertexPosition;
in vec2 vertexTextureCoords;
out vec2 textureCoords;
void main() {
gl_Position = vec4(vertexPosition, 0, 1);
textureCoords = textureScale * vertexTextureCoords;
}
```
s2.frag
```
#version 330 core
uniform sampler2D renderTexture;
uniform sampler2D depthTexture;
in vec2 textureCoords;
out vec4 pixelColor;
void main() {
vec4 baseColor = texture2D(renderTexture, textureCoords);
pixelColor = vec4(baseColor.x, 1 - baseColor.y, baseColor.z, 1);
}
```
Как можно заметить, пока суть такой постобработки просто в инвертировании зеленого канала.
Прицепим текстуру цвета в слот 0, а текстуру глубины — в слот 1.
```
glBindVertexArray(vertexArrays[1]);
glUseProgram(postProgram);
glUniform1i(glGetUniformLocation(postProgram, "renderTexture"), 0);
glUniform1i(glGetUniformLocation(postProgram, "depthTexture"), 1);
glUseProgram(0);
glBindVertexArray(0);
```
Запомним положение переменной, отвечающей за масштаб текстуры:
```
GLint ulTextureScale = glGetUniformLocation(postProgram, "textureScale");
```
Новый главный цикл:
```
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
int framebufferWidth, framebufferHeight;
glfwGetFramebufferSize(window, &framebufferWidth, &framebufferHeight);
glViewport(0, 0, framebufferWidth, framebufferHeight);
// Сначала отрисовываем фреймбуфер
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[0]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(vertexArrays[0]);
glUseProgram(mainProgram);
// Здесь ничего не поменялось
float angle = 0.5f * glfwGetTime();
float sin = glm::sin(angle);
float cos = glm::cos(angle);
glm::vec3 pos(2.5f * sin, 2.5f * cos, 1.5f);
glm::vec3 forward = glm::normalize(-pos);
glm::vec3 up(0.0f, 0.0f, 1.0f);
glm::vec3 right = glm::normalize(glm::cross(forward, up));
up = glm::normalize(glm::cross(right, forward));
float zNear = 0.0625f;
float zFar = 32.0f;
glm::mat4 matModel(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
glm::mat4 matView(right.x, up.x, forward.x, 0.0f,
right.y, up.y, forward.y, 0.0f,
right.z, up.z, forward.z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
matView *= glm::mat4(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
-pos.x, -pos.y, -pos.z, 1.0f);
glm::mat4 matProjection(
(float)framebufferHeight / framebufferWidth, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, (zFar + zNear) / (zFar - zNear), 1.0f,
0.0f, 0.0f, -2.0f * zFar * zNear / (zFar - zNear), 0.0f);
glUniformMatrix4fv(ulMatModel, 1, GL_FALSE, &matModel[0][0]);
glUniformMatrix4fv(ulMatView, 1, GL_FALSE, &matView[0][0]);
glUniformMatrix4fv(ulMatProjection, 1, GL_FALSE, &matProjection[0][0]);
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
// Теперь отрисуем получившуюся текстуру
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// В слоте 0 -- текстура цвета
glBindTexture(GL_TEXTURE_2D, textures[0]);
// В слоте 1 -- текстура глубины
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glBindVertexArray(vertexArrays[1]);
glUseProgram(postProgram);
// Масштаб текстуры
glUniform2f(ulTextureScale,
(GLfloat)framebufferWidth / MAX_WIDTH,
(GLfloat)framebufferHeight / MAX_HEIGHT);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glfwSwapBuffers(window);
}
```
**Результат**
Зеленый канал инвертирован
Шаг 7. Отрисовка контуров
-------------------------
Вернем отображение всех треугольников белым цветом, т.к. больше их цвет нам не понадобится
s1.frag
```
#version 330 core
out vec4 pixelColor;
void main() {
pixelColor = vec4(1);
}
```
Наконец, все приготовления закончены, и можно заниматься самим шейдером постобработки.
s2.frag
```
#version 330 core
uniform vec2 reverseMaxSize;
uniform sampler2D renderTexture;
uniform sampler2D depthTexture;
in vec2 textureCoords;
out vec4 pixelColor;
void main() {
vec4 baseColor = texture2D(renderTexture, textureCoords);
float sum = 0.0f;
float my = texture2D(depthTexture, textureCoords).x;
sum += texture2D(depthTexture, textureCoords + vec2(+1, 0) * reverseMaxSize).x;
sum += texture2D(depthTexture, textureCoords + vec2(-1, 0) * reverseMaxSize).x;
sum += texture2D(depthTexture, textureCoords + vec2(0, +1) * reverseMaxSize).x;
sum += texture2D(depthTexture, textureCoords + vec2(0, -1) * reverseMaxSize).x;
float d = sum / my - 4.0f;
pixelColor = baseColor - vec4(1000.0f * d, 100.0f * d, 10.0f * d, 0);
}
```
Здесь мы сравниваем глубину обрабатываемого пикселя и 4 соседних, и в зависимости от нее устанавливаем цвет пикселя на мониторе. Причем если пиксель находится внутри треугольника, то значение d будет равно 0: глубина линейно зависит от координат X и Y, поэтому сумма значений на концах отрезка равна удвоенной сумме в середине отрезка, и разность этих значений, соответственно, выдаст 0. Отрезков у нас 2:  и , и не на границах треугольника влияние каждого из них на d будет нулевым.
**Результат**
Как можно заметить, границ мы на самом деле обнаруживаем 2: внутреннюю (цвет темнее белого, d > 0) и внешнюю (белую, d < 0). Двойная граница это конечно классно, и, может быть, кто-то хочет воспользоваться именно таким стилем, но я хотел бы пойти дальше.
Самое простое решение — взять модуль от d. Тогда мы увидим двойную темную границу:
```
float d = abs(sum / my - 4.0f);
```
Заодно установим светло-серый фон, т.к. темные контуры на синем фоне уже не особо видны:
```
glClearColor(0.875f, 0.875f, 0.875f, 0.0f);
```
**Результат**
Заменим модельку куба на что-нибудь поинтереснее, например Suzanne из Blender, а заодно поменяем ракурс:
```
float angle = 0.125f * glfwGetTime();
float sin = glm::sin(angle);
float cos = glm::cos(angle);
glm::vec3 pos(2.0f * sin, 2.0f * cos, 0.125f);
```
**Результат**
Теперь хотелось бы сделать линии толщиной не 2, а 1 пиксель. Самое простое, что приходит в голову — отрендерить текстуру до постобработки в 2 раза большего размера:
```
const int MAX_WIDTH = 4096;
const int MAX_HEIGHT = 4096;
```
```
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[0]);
glViewport(0, 0, 2 * framebufferWidth, 2 * framebufferHeight);
```
```
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, framebufferWidth, framebufferHeight);
```
```
glUniform2f(ulTextureScale,
2.0f * framebufferWidth / MAX_WIDTH,
2.0f * framebufferHeight / MAX_HEIGHT);
```
**Результат**
Но такой подход требует в 4 раза больше времени на растеризацию до постобработки. Вместо этого можно, например, рисовать только один из двух контуров (внешний и внутренний):
```
float d = max(0.0f, sum / my - 4.0f);
```
**Результат**
```
float d = max(0.0f, 4.0f - sum / my);
```
**Результат**
Основной недостаток этих методов в том, что они неодинаково обрабатывают выпуклые и вогнутые грани, что можно видеть на модели Suzanne. Но, тем не менее, они выдают линию толщиной 1 пиксель без отрисовки изображения удвоенного разрешения.
Заключение
----------
В этом туториале мы прошлись по пути от создания окна до шейдера постобработки с уникальным стилем. Надеюсь, кому-нибудь такая постобработка покажется интересной, и найдет применение в уникальном стиле игры или анимации.
[Весь код туториала доступен на GitHub](https://github.com/asurkis/opengl-posteffect-tutorial) | https://habr.com/ru/post/505726/ | null | ru | null |
# Стратегии по ускорению кода на R, часть 2
Цикл for в R может быть очень медленным, если он применяется в чистом виде, без оптимизации, особенно когда приходится иметь дело с большими наборами данных. Есть ряд способов сделать ваш код быстрее, и вы, вероятно, будете удивлены, узнав насколько.
Эта статья описывает несколько подходов, в том числе простые изменения в логике, параллельную обработку и `Rcpp`, увеличивая скорость на несколько порядков, так что можно будет нормально обрабатывать 100 миллионов строк данных или даже больше.
Давайте попробуем ускорить код с циклом for и условным оператором (if-else) для создания колонки, которая добавляется к набору данных (data frame, df). Код ниже создает этот начальный набор данных.
```
# Создание набора данных
col1 <- runif (12^5, 0, 2)
col2 <- rnorm (12^5, 0, 2)
col3 <- rpois (12^5, 3)
col4 <- rchisq (12^5, 2)
df <- data.frame (col1, col2, col3, col4)
```
В [первой части](https://habrahabr.ru/company/infopulse/blog/277681/): векторизация, только истинные условия, ifelse.
В этой части: which, apply, побайтовая компиляция, Rcpp, data.table, результаты.
#### Использование which()
Используя команду `which()` для выбора строк, можно достичь одной третьей скорости `Rcpp`.
```
# Спасибо Гейб Бекер
system.time({
want = which(rowSums(df) > 4)
output = rep("less than 4", times = nrow(df))
output[want] = "greater than 4"
})
```
```
# количество строк = 3 миллиона (примерно)
user system elapsed
0.396 0.074 0.481
```
#### Используйте семейство функций apply вместо циклов for
Используем функцию `apply()` для реализации этой же логики и сравним с векторизированным циклом for. Результаты растут с увеличением количества порядков, но они медленнее, чем `ifelse()` и версии, где проверка делалась за пределами цикла. Это может быть полезно, но возможно, потребуется определенная изобретательность для сложной бизнес-логики.
```
# семейство apply
system.time({
myfunc <- function(x) {
if ((x['col1'] + x['col2'] + x['col3'] + x['col4']) > 4) {
"greater_than_4"
} else {
"lesser_than_4"
}
}
output <- apply(df[, c(1:4)], 1, FUN=myfunc) # применить 'myfunc' к каждой строке
df$output <- output
})
```
*Использование apply и цикла for в R*
#### Используйте побайтовые компиляции для функций cmpfun() из пакета compiler вместо собственно функции
Это, наверное, не лучший пример для иллюстрации эффективности побайтовой компиляции, поскольку полученное время немного выше, чем обычная форма. Однако, для более сложных функций побайтовая компиляция доказала свою эффективность. Думаю, стоит попробовать при случае.
```
# побайтовая компиляция кода
library(compiler)
myFuncCmp <- cmpfun(myfunc)
system.time({
output <- apply(df[, c (1:4)], 1, FUN=myFuncCmp)
})
```
*Apply, цикл for и побайтовая компиляция кода*
#### Используйте Rcpp
Давайте выйдем на новый уровень. До этого мы увеличивали скорость и производительность с помощью различных стратегий и обнаружили, что использование `ifelse()` наиболее эффективно. Что если мы добавим еще один ноль? Ниже мы реализуем эту же логику с `Rcpp`, с набором данных в 100 миллионов строк. Мы сравним скорости `Rcpp` и `ifelse()`.
```
library(Rcpp)
sourceCpp("MyFunc.cpp")
system.time (output <- myFunc(df)) # функция Rcpp ниже
```
Ниже приведена та же логика, реализованная на С++ с помощью пакета Rcpp. Сохраните код ниже как «MyFunc.cpp» в вашей рабочей директории сессии R (или вам придется применять sourceCpp, используя полный путь). Обратите внимание, комментарий `// [[Rcpp::export]]` обязателен, и его нужно поместить непосредственно перед функцией, которую вы хотите выполнить из R.
```
// Источник для MyFunc.cpp
#include
using namespace Rcpp;
// [[Rcpp::export]]
CharacterVector myFunc(DataFrame x) {
NumericVector col1 = as(x["col1"]);
NumericVector col2 = as(x["col2"]);
NumericVector col3 = as(x["col3"]);
NumericVector col4 = as(x["col4"]);
int n = col1.size();
CharacterVector out(n);
for (int i=0; i 4){
out[i] = "greater_than_4";
} else {
out[i] = "lesser_than_4";
}
}
return out;
}
```
*Производительность `Rcpp` и `ifelse`*
#### Используйте параллельную обработку, если у вас многоядерный компьютер
Параллельная обработка:
```
# параллельная обработка
library(foreach)
library(doSNOW)
cl <- makeCluster(4, type="SOCK") # for 4 cores machine
registerDoSNOW (cl)
condition <- (df$col1 + df$col2 + df$col3 + df$col4) > 4
# параллелизация с векторизацией
system.time({
output <- foreach(i = 1:nrow(df), .combine=c) %dopar% {
if (condition[i]) {
return("greater_than_4")
} else {
return("lesser_than_4")
}
}
})
df$output <- output
```
#### Удаляйте переменные и очищайте память как можно раньше
Удаляйте больше ненужные объекты в коде с помощью `rm()`, как можно раньше, особенно перед длинными циклами. Иногда может помочь применение `gc()` в конце каждой итерации цикла.
#### Используйте структуры данных, занимающие меньше памяти
`Data.table()` — отличный пример, поскольку не перегружает память. Это позволяет ускорять операции, подобные объединению данных.
```
dt <- data.table(df) # создать data.table
system.time({
for (i in 1:nrow (dt)) {
if ((dt[i, col1] + dt[i, col2] + dt[i, col3] + dt[i, col4]) > 4) {
dt[i, col5:="greater_than_4"] # присвоить значение в 5-й колонке
} else {
dt[i, col5:="lesser_than_4"] # присвоить значение в 5-й колонке
}
}
})
```
*Dataframe и data.table*
#### Скорость: результаты
**Метод:** Скорость, количество строк в df / затраченное время = n строк в секунду
**Исходный:** 1X, 120000/140.15 = 856.2255 строк в секунду (нормализировано к 1)
**Векторизированный:** 738X, 120000/0.19 = 631578.9 строк в секунду
**Только истинные условия:** 1002X, 120000/0.14 = 857142.9 строк в секунду
**ifelse:** 1752X, 1200000/0.78 = 1500000 строк в секунду
**which:** 8806X, 2985984/0.396 = 7540364 строк в секунду
**Rcpp:** 13476X, 1200000/0.09 = 11538462 строк в секунду
Числа, приведенные выше, приблизительны и основаны на случайных запусках. Нет расчетов результатов для `data.table()`, побайтовой компиляции кода и параллелизации, поскольку они будут сильно отличаться в каждом конкретном случае и в зависимости от того, как вы их применяете. | https://habr.com/ru/post/277693/ | null | ru | null |
# Рисуем кнопку в SVG
В настоящее время я работаю над одним веб-приложением, и вот захотелось мне обновить нынешний, довольно-таки топорный интерфейс на что-то более современное, более красивое. Начать решил с кнопок как с наиболее технически нагруженной части: в них требуется не только заменить внешний вид, но и добавить индикацию нажатия и обработку событий. Сразу же возникла проблема: как обеспечить масштабирование? Обычной растровой картинкой не обойтись, так как у пользователей могут использоваться разные шрифты (как вид, так и размер), и картинка-подложка не будет под них адаптирована. Логично было бы попробовать использовать для этих целей SVG, чем я и занялся.
К сожалению, в конечном итоге я пришёл к выводу, что овчинка не стоит выделки: слишком много проблем вылезло при попытке реализации этой идеи. Тем не менее, я не считаю это время потерянным: я приобрёл новые знания и навыки и теперь хотел бы поделиться ими с сообществом, чтобы облегчить жизнь тем, кто решит повторить мой путь. Описать свои мучения я планирую в двух статьях: в первой — работа над собственно SVG-картинкой, во второй — техника внедрения полученной картинки в качестве кнопок, возникающие при этом проблемы и их решение или обходные пути. Кому интересна первая часть, прошу под кат.
Для начала хочу предупредить, что область SVG для меня совершенно новая, и полностью изучить все мыслимые функции и всякие хитрые трюки я не имел возможности. Соответственно, если в тексте встречается фраза вида «это сделать невозможно», считайте её просто сокращённой формой от «я не нашёл способа сделать это ни в стандарте, ни в учебниках, ни в гугле». :-) Естественно, всяческим поправкам и уточнениям буду очень благодарен.
Ну а теперь приступим к ТЗ: хочется иметь красивую масштабируемую картинку, которую можно было бы использовать в качестве кнопки на веб-страницах. В качестве основы для экспериментального дизайна я выбрал приглянувшуюся мне кнопочку с сайта [One day files](http://onedayfiles.com/):
Немного поразбиравшись с картинкой, я составил её векторное описание: по границе — серый прямоугольник с закруглёнными краями, внутри — вертикальный градиент, состоящий из двух линейных областей (50%/50%). Получилась элементарнейшая задача для первого класса занятия по изучению SVG; решение может выглядеть следующим образом:
```
```
(Здесь и далее я для экономии места буду опускать XML-заголовок и определение тега .)
Однако здесь не всё так просто. Вот как выглядит то, что получилось:
Остроглазые товарищи наверняка уже увидели, что здесь что-то не так. Для остальных я заменю цвет границы на красный и увеличу изображение, чтоб было лучше видно:
Во-первых, граница получилась какая-то невнятная, размытая и более тёмная, чем предполагалось. Во-вторых, уголковые части границы получились явно толще, чем боковушки. В-третьих, переходы к закруглению не плавные, а угловатые.
Вся беда в том, что векторные координаты находятся не в центрах пикселей, а «в промежутках» между ними. Естественно, при отрисовке такая линия «размывается» между двумя соседними положениями вдоль всей своей длины, причём одна из «половинок» линии оказывается за пределами рисунка и не отображается. Если бы у нас был обычный прямоугольник, можно было бы объявить это фичей, подправив цвет на более яркий (для компенсации размытия) или вообще установив толщину границы в два пикселя. Однако в нашем случае проблему это не решит, закруглённые уголки всё портят: они-то находятся целиком в области видимости, поэтому и переход останется угловатым, и толщина линии в закруглениях останется «полноценной», в отличие от боковых границ. Как быть? Можно попытаться сдвинуть координаты на половину пикселя, это решит проблему «междупиксельности». Но ширину и высоту мы в этом случае корректно задать уже не сможем: невозможно указать значение «сто процентов минус один пиксель». Задавать какие-нибудь 95% бессмысленно: для маленьких кнопок разница в 5% будет слишком мала, для больших — слишком велика. Если же указывать все размеры только в пикселях, то мы не сможем обеспечить необходимый режим масштабирования: толщина границы тут же окажется привязанной к размерам изображения и будет меняться пропорционально. В результате, если мы растянем картинку по горизонтали, оставив высоту неизменной (типичный вариант использования кнопок на веб-странице), то боковые границы станут толще, чем верхняя и нижняя, что выглядит очень некрасиво.
Основная проблема здесь в том, что мы пытаемся совместить процентные и пиксельные координаты, масштабируемую часть с фиксированной частью изображения, что в SVG как бы не принято. Более того, как выяснилось, процентные координаты можно указывать только для фигур. Тег их не поддерживает в принципе (несмотря на заверения учебников, что все фигуры — это всего лишь частные случаи ). Что ж, попытаемся обойтись обычными фигурами, и в этом нам поможет атрибут **transform**. Трюк заключается в том, что мы установим начальную координату в 100%, ширину и высоту укажем фиксированную — в пикселях, а полученную фигуру (находящуюся за пределами рисунка) вдвинем обратно в изображение, сместив его на нужное число пикселей. Например, чтобы нарисовать прямоугольник размерами 5×10 в нижнем левом углу, можно использовать следующий код:
К сожалению, даже этот трюк не поможет нарисовать сразу всю границу одним тегом , но мы можем, комбинируя простые фигуры, нарисовать маску для той области, где должна проходить граница, а потом выполнить заливку. Конкретный способ рисования маски, разумеется, может варьироваться, но я сделал так: двумя прямоугольными рамками, сдвинутыми на полпикселя, обрисовал общий прямоугольник границы. Далее вырезал угловые участки, посадил на их место кружочки и, наконец, отрезал лишние части этих кружочков, оставив лишь по одной четверти для закругления углов. Вот итоговый код:
```
```
Конечно, в качестве вырезания нужных четвертей из кругов было бы логичнее воспользоваться маской или обрезкой через , но оказалось, что при таком вложенном использовании Оперу версий ниже 11 начинает здорово колбасить: начальная отрисовка выполняется корректно, но если поверх неё протащить другое окно, обновление изображения выполняется некорректно. Проще оказалось отказаться от вложенных масок и замостить обычными прямоугольничками, чем бодаться с этим глюком.
Собственно, кнопка уже практически готова. Осталось лишь навесить текст, но и здесь полезли неприятности. Первая, она же главная: каким должен быть размер шрифта? Простого решения этого вопроса не нашлось, а поскольку он имеет самое прямое отношение к интеграции SVG-изображения с HTML-страницей, я отложу эту рассмотрение этой проблемы до следующей статьи, а пока для иллюстративного примера оставлю размер шрифта умолчальным. Также хотелось получить отцентрированный текст, но даже такая простая задача оказалась не под силу некоторым браузерам (не будем указывать пальцем, хотя это Firefox), которые не умеют подстраивать базу шрифта, поэтому придётся пока обойтись центрированием лишь по горизонтали.
В итоговой картинке я также добавил при помощи скриптинга подсветку при наведении мыши и нажатии на кнопку, а также перевёл часть описаний в стили. С этим никаких трудностей не возникло, всё сразу заработало, как надо, поэтому загромождать текст описанием данных вещей я не стану: они есть в любом учебнике. Код получившейся кнопки можно посмотреть [здесь](http://flint-inc.ru/Temp/svg/button.svg).
Для тех, кто хочет посмотреть, как это выглядит в натуре, может попробовать на [живом примере](http://flint-inc.ru/Temp/svg/test.html) (разумеется, требуется браузер с поддержкой SVG).
Благодарю за внимание, готов ловить помидоры. :-)
***UPD:*** [Вторая часть статьи](http://habrahabr.ru/blogs/svg/111682/) | https://habr.com/ru/post/110869/ | null | ru | null |
# Знакомство с lit-element и веб-компонентами на его основе
В один момент мне предстояло срочно познакомиться с веб-компонентами и найти способ удобно разрабатывать с их помощью. Я планирую написать серию статей, что бы
как-то систематизировать знания по веб-компонентам, lit-element и дать краткое ознакомление с этой технологией для других. Я не являюсь экспертом в данной технологии и с радостью приму любой фидбек.
[lit-element](https://github.com/Polymer/lit-element) — это обертка (базовый шаблон) для нативных веб-компонентов. Она реализует множество удобных методов, которых нет в спецификации. За счет своей близости к нативной реализации lit-element показывает очень хорошие результаты в различных [benchmark](https://vogloblinsky.github.io/web-components-benchmark/) относительно других подходов (на 06.02.2019г).
Бонусы, которые я вижу от использования lit-element как базового класса веб-компонентов:
1. Данная технология реализует уже вторую версию и «переболела детскими болезнями», свойственными только что появившимся инструментам.
2. Сборка может осуществляться как polymer, так и webpack, typescript, rollup и т.д., это позволяет встроить lit-element в любой современный проект без каких-либо проблем.
3. У lit-element очень удобная система работы с property в плане типизации, инициирования и конвертирования значений.
4. lit-element реализует почти такую же логику, как у реакт, т.е. он предоставляет самый минимум — единый шаблон построения компонентов и его рендеринга и не ограничивает разработчика в выборе экосистемы и дополнительных библиотек.
Создадим простой веб-компонент на lit-element. Обратимся к документации. Нам необходимо следующее:
1. Добавить в нашу сборку npm пакет с lit-element
```
npm install --save lit-element
```
2. Создать наш компонент.
Например, нам надо создать веб-компонент, инициализирующийся в теге `my-component`. Для этого создадим js файл `my-component.js` и определим его базовый шаблон:
```
// для импорта базового шаблона на основе lit-element
import { } from '';
// для создания логики самого компонента
class MyComponent { }
// для регистрации компонента в браузере
customElements.define();
```
Первым делом импортируем наш базовый шаблон:
```
import { LitElement, html } from 'lit-element';
// LitElement - это базовый шаблон (обертка) для нативного веб-компонента
// html - функция lit-html, которая обрабатывает переданную ей строку, парсит
// и вставляет полученный html в структуру документа
```
Во вторых, создадим сам веб-компонент, используя `LitElement`
```
// прошу обратить внимание, в нативной реализации
// вместо LitElement мы бы использовали HTMLElement
class MyComponent extends LitElement {
// жизненный цикл компонента LitElement гораздо богаче
// и нам не обязательно вызывать constructor или connectedCallback
// мы можем сразу указать что именно должен отрисовать наш компонент
// прошу так же заметить, что по умолчанию к компоненту добавляется
// shadowDOM с опцией {mode: 'open'}
render() {
return html`Hello World!
`
}
}
```
И последнее — зарегистрировать веб-компонент в браузере
```
customElements.define('my-component', MyComponent);
```
В итоге получаем следующее:
```
import { LitElement, html } from 'lit-element';
class MyComponent extends LitElement {
render() {
return html`Hello World!
`
}
}
customElements.define('my-component', MyComponent);
```
Если исключить необходимость подключать `my-component.js` к html, то это все. Самый простой компонент готов.
Предлагаю не изобретать велосипед и взять готовую сборку lit-element-build-rollup. Следуем инструкции:
```
git clone https://github.com/PolymerLabs/lit-element-build-rollup.git
cd lit-element-build-rollup
npm install
npm run build
npm run start
```
После выполнения всех команд переходим на страницу в браузере <http://localhost:5000/>.
Если взглянем в html, увидим, что перед закрывающим тегом находится [webcomponents-loader.js](https://github.com/webcomponents/webcomponentsjs). Это набор полифиллов для веб-компонентов, и для кроссбраузерной работы веб-компонента желательно, чтобы был данный полифилл. Посмотрим на [таблицу браузеров](https://www.webcomponents.org/), реализующих все стандарты для работы веб-компонентов, там указано, что EDGE все еще не до конца реализует стандарты (я молчу про IE11, который до сих пор требуется поддерживать).
Реализовано 2 варианта этого полифилла:
1. [webcomponents-bundle.js](https://github.com/webcomponents/webcomponentsjs#using-webcomponents-bundlejs) — данная версия содержит все возможные варианты полизаполнения, все они инициируются, но каждый полифилл будет работать только на основании обнаруженных признаков.
2. [webcomponents-loader.js](https://github.com/webcomponents/webcomponentsjs#using-webcomponents-loaderjs) — это минимальный загрузчик, который на основании обнаруженных признаков подгружает нужные полифиллы
Также прошу обратить внимание на еще один полифилл — [custom-elements-es5-adapter.js](https://github.com/webcomponents/webcomponentsjs#custom-elements-es5-adapterjs). Согласно спецификации, в нативный customElements.define могут быть добавлены только ES6 классы. Для лучшей производительности код на ES6 стоит передавать только тем браузерам, которые его поддерживают, а ES5 — всем остальным. Так не всегда получается сделать, поэтому для лучшей кроссбраузерности, рекомендуется весь ES6 код переводить в ES5. Но в таком случае веб-компоненты на ES5 не смогут работать в браузерах. Для решения этой проблемы и существует custom-elements-es5-adapter.js.
Теперь давайте откроем файл `./src/my-element.js`
```
import {html, LitElement, property} from 'lit-element';
class MyElement extends LitElement {
// @property - декоратор, который может обработать babel и ts
// он нужен для определения типа переменной и дальнейшей
// ее проверки, силами транспайлера
@property({type: String}) myProp = 'stuff';
render() {
return html`
Hello World
${this.myProp}
`;
}
}
customElements.define('my-element', MyElement);
```
Шаблонизатор lit-html может обработать строку по-разному. Приведу несколько вариантов:
```
// статичный элемент:
html`Hi`
// выражение:
html`${this.disabled ? 'Off' : 'On'}`
// свойство:
html``
// атрибут:
html``
// атрибут типа boolean, если checked === false,
// то данный атрибут не будет добавлен в HTML:
html``
// обработчик события:
html``
```
Советы по оптимизации функции render():
* не должна изменять состояние элемента,
* не должна иметь side effects,
* должна зависеть только от свойств элемента,
* должна возвращать одинаковый результат при передаче одинаковых значений.
Не делайте обновление DOM вне функции render().
За отрисовку lit-element отвечает lit-html – это декларативный способ описания того, как должен отображаться веб-компонент. lit-html гарантирует быстрое обновления, меняя только те части DOM, которые должны быть изменены.
Почти все из этого кода было в простом примере, но добавлен [декоратор](https://github.com/tc39/proposal-decorators#decorators) `@property` для свойства `myProp`. Данный декоратор указывает на то, что мы ожидаем атрибут с именем `myprop` в нашем `my-element`. Если такой атрибут не задан, ему по умолчанию задается строковое значение `stuff`.
```
```
lit-element предоставляет 2 способа работы с `property`:
1. Через декоратор.
2. Через статический геттер `properties`.
Первый вариант дает возможность указать каждое свойство отдельно:
```
@property({type: String}) prop1 = '';
@property({type: Number}) prop2 = 0;
@property({type: Boolean}) prop3 = false;
@property({type: Array}) prop4 = [];
@property({type: Object}) prop5 = {};
```
Второй – указать все в одном месте, но в этом случае, если у свойства есть значение по умолчанию, его необходимо прописывать в методе конструктора класса:
```
static get properties() {
return {
prop1: {type: String},
prop2: {type: Number},
prop3: {type: Boolean},
prop4: {type: Array},
prop5: {type: Object}
};
}
constructor() {
this.prop1 = '';
this.prop2 = 0;
this.prop3 = false;
this.prop4 = [];
this.prop5 = {};
}
```
API для работы с properties в lit-element довольно обширное:
* **attribute**: может ли свойство стать наблюдаемым атрибутом. Если значение `false`, то атрибут будет исключен из наблюдения, для него не будет создан геттер. Если `true` или `attribute` отсутствует, то свойство, указанное в геттере в формате lowerCamelCase, будет соотноситься с атрибутом в строчный формат. Если задана строка, например `my-prop` – то будет соотноситься с таким же названием в атрибутах.
* **converter**: содержит описание того, как преобразовать значение из/в атрибута/свойства. Значением может быть функция, которая работает для сериализации и десериализации значения, либо это может быть объект с ключами `fromAttribute` и `toAttribute`, эти ключи содержат отдельные функции для конвертации значений. По умолчанию свойство содержит преобразование в базовые типы `Boolean`, `String`, `Number`, `Object` и `Array`. Правила преобразования указаны [тут](https://lit-element.polymer-project.org/guide/properties#conversion).
* **type**: указывает на один из базовых типов, который будет содержать данное свойство. Используется как «подсказка» для конвертера о том, какой тип должно содержать свойство.
* **reflect**: указывает на то, должен ли атрибут быть связан со свойством (`true`) и изменяться в соответствии с правилами из `type` и `converter`.
* **hasChanged**: есть у каждого свойства, содержит функцию, определяющую, есть ли изменение между старым и новым значением, соответственно возвращает `Boolean`. Если `true` – то запускает обновление элемента.
* **noAccessor**: данное свойство принимает `Boolean` и по умолчанию `false`. Оно запрещает генерировать геттеры и сеттеры для каждого свойства для обращения к ним из класса. Это не отменяет конвертацию.
Сделаем гипотетический пример: напишем веб-компонент, который содержит параметр, в котором содержится строка, на экран должно быть отрисовано это слово, в котором каждая буква больше предыдущей.
```
```
```
//ladder-of-letters.js
import {html, LitElement, property} from 'lit-element';
class LadderOfLetters extends LitElement {
@property({
type: Array,
converter: {
fromAttribute: (val) => {
// console.log('in fromAttribute', val);
return val.split('');
}
},
hasChanged: (value, oldValue) => {
if(value === undefined || oldValue === undefined) {
return false;
}
// console.log('in hasChanged', value, oldValue.join(''));
return value !== oldValue;
},
reflect: true
}) letters = [];
changeLetter() {
this.letters = ['Б','В','Г','Д','Е'];
}
render() {
// console.log('in render', this.letters);
// для стилизации есть директивы, тут не использовано
// что бы не нагромождать функционала в примере
return html`
${this.letters.map((i, idx) => html`${i}`)}
// @click это краткая запись о том, что мы добавляем слушатель
// на событие 'click' по данному элементу
Изменить на 'БВГДЕ'
`;
}
}
customElements.define('ladder-of-letters', LadderOfLetters);
```
в итоге получаем:
при нажатии на кнопку было изменено свойство, что вызвало сначала проверку, а потом было отправлено на перерисовку.
а используя `reflect` мы можем увидеть также изменения в html
При изменении этого атрибута кодом вне этого веб-компонента мы также вызовем перерисовку веб-компонента.
Теперь рассмотрим стилизацию компонента. У нас есть 2 способа стилизовать lit-element:
1. Стилизация через добавление тега style в метода render
```
render() {
return html`
p {
color: green;
}
Hello World
`;
}
```
2. Через статический геттер `styles`
```
import {html, LitElement, css} from 'lit-element';
class MyElement extends LitElement {
static get styles() {
return [
css`
p {
color: red;
}
`
];
}
render() {
return html`
Hello World
`;
}
}
customElements.define('my-element', MyElement);
```
В итоге получаем, что тег со стилями не создается, а прописывается (`>= Chrome 73`) в `Shadow DOM` элемента в соответствии со [спецификацией](https://wicg.github.io/construct-stylesheets/). Таким образом улучшается перфоманс при большом количестве элементов, т.к. при регистрации нового компонента он уже знает, какие свойства ему определяют его стили, их не надо регистрировать каждый раз и пересчитывать.
При этом, если данная спецификация не поддерживается, то создается обычный тег `style` в компоненте.
Плюс, не забывайте, что таким образом мы также можем разделить, какие стили будут добавлены и рассчитаны на странице. Например, использовать медиазапросы не в css, а в JS и имплементировать только нужный стиль, например (это дико, но имеет место быть):
```
static get styles() {
const mobileStyle = css`p { color: red; }`;
const desktopStyle = css`p { color: green; }`;
return [
window.matchMedia("(min-width: 400px)").matches ? desktopStyle : mobileStyle
];
}
```
Соответственно, это мы увидим, если пользователь зашел на устройстве с шириной экрана более 400px.
А это – если пользователь зашел на сайт с устройства с шириной менее 400px.
Мое мнение: практически нет ни одного адекватного кейса, когда пользователь, работая на мобильном устройстве, неожиданно окажется перед полноценным монитором с шириной экрана 1920px. Добавим к этому еще и ленивую загрузку компонентов. В итоге получим очень оптимизированный фронт с быстрым рендерингом компонентов. Единственная проблема – сложность в поддержке.
Теперь предлагаю ознакомиться с методами жизненного цикла lit-element:
* **render()**: реализует описание DOM элемента с помощью `lit-html`. В идеале, функция `render` – это чистая функция, которая использует только текущие свойства элемента. Метод `render()` вызывается функцией `update()`.
* **shouldUpdate(changedProperties)**: реализуется, если необходимо контролировать обновление и рендеринг, когда были изменены свойства или вызван `requestUpdate()`. Аргумент функции `changedProperties` – это `Map`, содержащий ключи измененных свойств. По умолчанию данный метод всегда возвращает `true`, но логику метода можно изменить, чтобы контролировать обновлением компонента.
* **performUpdate()**: реализуется для контроля времени обновления, например для интеграции с планировщиком.
* **update(changedProperties)**: этот метод вызывает `render()`. Также он выполняет обновление атрибутов элемента в соответствии со значением свойства. Установка свойств внутри этого метода не вызовет другое обновление.
* **firstUpdated(changedProperties)**: вызывается после первого обновления DOM элемента непосредственно перед вызовом `updated()`. Этот метод может быть полезен для захвата ссылок на визуализированные статические узлы, с которыми нужно работать напрямую, например, в `updated()`.
* **updated(changedProperties)**: вызывается всякий раз, когда DOM элемента обновляется и отображается. Реализация для выполнения задач после обновления через API DOM, например, фокусировка на элементе.
* **requestUpdate(name, oldValue)**: вызывает запрос асинхронного обновления элемента. Это следует вызывать, когда элемент должен обновляться на основе некоторого состояния, не вызванного установкой свойства.
* **createRenderRoot()**: по умолчанию создает Shadow Root для элемента. Если использование Shadow DOM не нужно, то метод должен вернуть `this`.
Как происходит обновление элемента:
* Свойству задают новое значение.
* Если свойство `hasChanged(value, oldValue)` возвращает `false`, элемент не обновляется. Иначе планируется обновление путем вызова `requestUpdate()`.
* **requestUpdate()**: обновляет элемент после microtask (в конце event loop и перед следующей перерисовкой).
* **performUpdate()**: выполняется обновление, и продолжает остальную часть update API.
* **shouldUpdate(changedProperties)**: обновление продолжается, если возвращается `true`.
* **firstUpdated(changedProperties)**: вызывается когда элемент обновляется в первый раз, сразу же перед вызовом `updated()`.
* **update(changedProperties)**: обновляет элемент. Изменение свойств в этом методе не вызывает другого обновления.
+ **render()**: возвращает `lit-html` шаблон для отрисовки элемента в DOM. Изменение свойств в этом методе не вызывает другого обновления.
* **updated(changedProperties)**: вызывается всякий раз, когда элемент обновляется.
Чтобы понять все нюансы жизненного цикла компонента, советую обратиться к [документации](https://lit-element.polymer-project.org/guide/lifecycle).
На работе у меня проект на adobe experience manager (AEM), в его авторинге пользователь может делать drag & drop компонентов на страницу, и по идеологии AEM этот компонент содержит тег `script`, в котором содержится все что нужно для реализации логики данного компонента. Но по факту, такой подход порождал множество блокирующих ресурсов и сложностей с реализацией фронта в данной системе. Для реализации фронта были выбраны веб-компоненты как способ не изменять рендеринг на стороне сервера (с чем он прекрасно справлялся), а также мягко, поэлементно, обогащать старую реализацию новым подходом. На мой взгляд, есть несколько вариантов реализации подгрузки веб-компонентов для данной системы: собрать бандл (он может стать очень большим) или разбить на чанки (очень много мелких файлов, нужна динамическая подгрузка), или использовать уже текущий подход с встраиванием script в каждый компонент, который рендерится на стороне сервера (очень не хочется к этому возвращаться). На мой взгляд, первый и третий вариант – не вариант. Для второго нужен динамический загрузчик, как в stencil. Но для lit-element в «коробке» такого не предоставляется. Со стороны разработчиков lit-element была [попытка создать динамический загрузчик](https://github.com/PolymerLabs/split-element), но он является экспериментом, и использовать его в продакшен не рекомендуется. Также от разработчиков lit-element есть [issue](https://github.com/w3c/webcomponents/issues/782) в [репозиторий спецификации веб-компонентов](https://github.com/w3c/webcomponents) с предложением добавить в спецификацию возможность динамически подгружать необходимый js для веб-компонента на основе html разметки на странице. И, на мой взгляд, этот нативный инструмент – очень хорошая идея, которая позволит создавать одну точку инициализации веб-компонентов и просто добавлять ее на всех страницах сайта.
Для динамической подгрузки веб-компонентов на основе lit-element ребятами из PolymerLabs был разработан [split-element](https://github.com/PolymerLabs/split-element). Это эксперементальное решение. Работает оно следующим способом:
* Чтобы создать SplitElement, вы пишете два определения элементов в двух модулях.
* Одним из них является «заглушка», которая определяет загруженные части элемента: обычно это имя и свойства. Свойства должны быть определены с заглушкой, чтобы lit-element мог своевременно генерировать наблюдаемые атрибуты для вызова `customElements.define()`.
* Заглушка также должна иметь статический асинхронный метод загрузки, который возвращает класс реализации.
* Другой класс – это «реализация», которая содержит все остальное.
* Конструктор `SplitElement` загружает класс реализации и выполняет `upgrade()`.
Пример заглушки:
```
import {SplitElement, property} from '../split-element.js';
export class MyElement extends SplitElement {
// MyElement содержит асинхронную функцию load которая будет
// вызвана в момент при вызове connectedCallback() пользовательского элемента
static async load() {
// через динамический импорт указывается путь и класс
// элемента который будет имплементирован вместо MyElement
return (await import('./my-element-impl.js')).MyElementImpl;
}
// желательно указать некоторое первоначальное значение
// для свойств веб-компонента
@property() message: string;
}
customElements.define('my-element', MyElement);
```
Пример реализации:
```
import {MyElement} from './my-element.js';
import {html} from '../split-element.js';
// MyElementImpl содержит render и всю логику веб-компонента
export class MyElementImpl extends MyElement {
render() {
return html`
I've been upgraded
==================
My message is ${this.message}.
`;
}
}
```
Пример SplitElement на ES6:
```
import {LitElement, html} from 'lit-element';
export * from 'lit-element';
// подменяем базовый класс LitElement на SplitElement
// в котором реализуем логику асинхронной подгрузки
export class SplitElement extends LitElement {
static load;
static _resolveLoaded;
static _rejectLoaded;
static _loadedPromise;
static implClass;
static loaded() {
if (!this.hasOwnProperty('_loadedPromise')) {
this._loadedPromise = new Promise((resolve, reject) => {
this._resolveLoaded = resolve;
this._rejectLoaded = reject;
});
}
return this._loadedPromise;
}
// функция которая сменит прототип для веб-компонента
// с его загрузчика на реализацию
static _upgrade(element, klass) {
SplitElement._upgradingElement = element;
Object.setPrototypeOf(element, klass.prototype);
new klass();
SplitElement._upgradingElement = undefined;
element.requestUpdate();
if (element.isConnected) {
element.connectedCallback();
}
}
static _upgradingElement;
constructor() {
if (SplitElement._upgradingElement !== undefined) {
return SplitElement._upgradingElement;
}
super();
const ctor = this.constructor;
if (ctor.hasOwnProperty('implClass')) {
// Реализация уже загружена, немедленно обновить
ctor._upgrade(this, ctor.implClass);
} else {
// Реализация не загружена
if (typeof ctor.load !== 'function') {
throw new Error('A SplitElement must have a static `load` method');
}
(async () => {
ctor.implClass = await ctor.load();
ctor._upgrade(this, ctor.implClass);
})();
}
}
// Заглушка не должна что либо рендерить
render() {
return html``;
}
}
```
Если вы все еще используете сборку, предложенную выше на Rollup, не забудьте установить для babel возможность обрабатывать динамические импорты
```
npm install @babel/plugin-syntax-dynamic-import
```
А в настройках .babelrc добавить
```
{
"plugins": ["@babel/plugin-syntax-dynamic-import"]
}
```
Тут я сделал небольшой пример реализации веб-компонентов с отложенной подгрузкой: <https://github.com/malay76a/elbrus-split-litelement-web-components>
Попробовал применить подход динамической подгрузки веб-компонентов, пришел к следующему выводу: инструмент вполне рабочий, надо все определения веб-компонентов собирать в один файл, а описание самого компонента через чанки подключать отдельно. Без http2 данный подход не работает, т.к. формируется очень большой пул мелких файлов, описывающих компоненты. Если исходить из принципа [atomic design](http://bradfrost.com/blog/post/atomic-web-design/), то импортирование атомов необходимо определять в организме, а вот организм уже подключать как отдельный компонент. Одно из «узких» мест – это то, что пользователю в браузер придет множество определений пользовательских элементов, которые будут так или иначе инициализированы в браузере, и им будет определено первоначальное состояние. Такое решение избыточно. Один из вариантов простого решения для загрузчика компонентов это следующий алгоритм:
1. подгрузить обязательные утилиты,
2. подгрузить полифиллы,
3. собрать пользовательские элементы из light DOM:
1. выбираются все элементы DOM содержащие дефис в названии тега,
2. фильтруется список и формируется список из первых элементов.
4. запустить проход по циклу полученных пользовательских элементов:
1. на каждый навешивается Intersection Observer,
2. при попадании первого пользовательского элемента во вьюпорт +- 100px произвести загрузку ресурсов через динамический import.
5. 1. ИЛИ повторяется с пункта 3 только для пользовательского элемента и его shadowDOM,
2. ИЛИ компоненты, содержащие в shadowDOM другие компоненты, декларативно реализуют подгрузку необходимых зависимостей, указав import в голове JS.
Для более удобной работы с веб-компонентами и lit-element я бы предложил обратить внимание на проект [open-wc.org](http://open-wc.org/). Там предложены генераторы для сборщиков на основе webpack и rollup, туллинг для тестирования веб-компонентов и их демонстрации с помощью storybook, а также советы и рекомендации по разработке и настройки IDE.
Дополнительные ссылки:
----------------------
1. [Let's Build Web Components! Part 5: LitElement](https://dev.to/bennypowers/lets-build-web-components-part-5-litelement-906)
2. [Web Component Essentials](https://books.google.ru/books?id=HStxDwAAQBAJ&pg=PA71&lpg=PA71&dq=LitElement+performance&source=bl&ots=d_axG-lsTB&sig=sdyQdApVjn0kGsi4ov6x6d3Sm6Q&hl=ru&sa=X&ved=2ahUKEwirjtq11KbfAhWKZlAKHdPXB34Q6AEwB3oECAAQAQ#v=onepage&q=LitElement&f=false)
3. [A night experimenting with Lit-HTML…](https://medium.com/@lucamezzalira/a-night-experimenting-with-lit-html-585a8c69892a)
4. [LitElement To Do App](https://medium.com/@westbrook/litelement-to-do-app-1e08a31707a4)
5. [LitElement app tutorial part 1: Getting started](https://www.youtube.com/watch?v=UcCsGZDCw-Q)
6. [LitElement tutorial part 2: Templating, properties, and events](https://www.youtube.com/watch?v=s6P3R-J0IiI)
7. [LitElement tutorial part 3: State management with Redux](https://www.youtube.com/watch?v=_Gt12UhGLY0)
8. [LitElement tutorial part 4: Navigation and code splitting](https://www.youtube.com/watch?v=JajSgc7xelI)
9. [LitElement tutorial part 5: PWA and offline](https://www.youtube.com/watch?v=ToxKlmqgZHw)
10. [Lit-html workshop](https://github.com/LarsDenBakker/lit-html-workshop)
11. [Awesome lit-html](https://github.com/web-padawan/awesome-lit-html) | https://habr.com/ru/post/445438/ | null | ru | null |
# Пишем Custom MSBuild Task для деплоя (WMI included)
Добрый день! Одним прекрасным днем мы обнаружили, что наш MSBuild деплой проект не хочет работать в новой среде: для создания и управления сайтами и пулами он использовал MSBuild.ExtensionPack. Падали ошибки, связанные с недоступностью DCOM. Среду менять было нельзя, поэтому кстати пришлась возможность написания собственных задач для MSBuild: [msdn.microsoft.com/en-us/library/t9883dzc.aspx](https://msdn.microsoft.com/en-us/library/t9883dzc.aspx), было принято решения написать свои, которые работали бы через WMI (доступный на среде) Кому интересно, что получилось, прошу под кат.
### Почему MSBuild и WMI
Есть такие среды, в которых мы не властны открывать порты и конфигурировать их как хотим. Однако в данной среде уже все было настроено для работы WMI внутри всей сети, так что решение использовать WMI было наиболее безболезненным.
MSBuild Использовался для деплоя несложного сайта с самого начала, поэтому было выбрано не переписывать весь деплоймент на Nant, а использовать уже имеющийся скрипт и заменить только не работающие таски.
### Как писать собственные задачи для MSBuild
Подключаем в свой проект сборки Microsoft.Build.Framework, Microsoft.Build.Tasks.v4.0 и Microsoft.Build.Utilities.v4.0. Теперь есть 2 альтернативы:
1 — наследовать от интерфейса [ITask](https://msdn.microsoft.com/en-us/library/microsoft.build.framework.itask.aspx) и потом саму переопределять кучу методов и свойств.
2 — наследовать от абстрактного класса [Task](https://msdn.microsoft.com/en-us/library/microsoft.build.utilities.task.aspx) и переопределять только метод Execute.
Как несложно догадаться, был выбран второй метод.
HelloWorld для собственной задачи:
```
using System;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
namespace MyTasks
{
public class SimpleTask : Task
{
public override bool Execute()
{
Log.LogMessage("Hello Habrahabr");
return true;
}
}
}
```
Метод Execute возвращает true, если задача выполнилась успешно, и false — в противном случае. Из полезных свойств, доступных в классе Task стоит отметить свойство [Log](https://msdn.microsoft.com/en-us/library/microsoft.build.utilities.task.log.aspx), позволяющее поддерживать взаимодействие с пользователем.
Параметры передаются тоже несложно, достаточно определить открытое свойство в этом классе (с открытыми геттером и сеттером):
```
using System;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
namespace MyTasks
{
public class SimpleTask : Task
{
public string AppPoolName { get; set; }
[Output]
public bool Exists { get; set; }
public override bool Execute()
{
Log.LogMessage("Hello Habrahabr");
return true;
}
}
}
```
Чтобы наша задача что-то возвращала, свойству надо добавить атрибут [Output].
Так что можно сказать, что простота написания также явилась плюсом данного решения. На том, как с помощью WMI управлять IIS я останавливаться [не буду](http://www.iis.net/learn/manage/scripting/managing-sites-with-the-iis-wmi-provider), только отмечу, что используем namespace WebAdministration, который ставится вместе с компонентом Windows «IIS Management Scripts and Tools».
Под спойлерами листинг базовой задачи, в которой инкапсулирована логика подключения к WMI и базовые параметры задачи, такие как:
1. Machine — имя удаленной машины или localhost
2. UserName — имя пользователя, под которым будем коннектиться к WMI
3. Password — пароль пользователя, под которым будем коннектиться к WMI
4. TaskAction — название самого действия (Create, Stop, Start, CheckExists)
**BaseWMITask**
```
using Microsoft.Build.Utilities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading;
namespace MSBuild.WMI
{
///
/// This class will be used as a base class for all WMI MSBuild tasks.
/// Contains logic for basic WMI operations as well as some basic properties (connection information, actual task action).
///
public abstract class BaseWMITask : Task
{
#region Private Fields
private ManagementScope _scope;
#endregion
#region Public Properties (Task Parameters)
///
/// IP or host name of remote machine or "localhost"
/// If not set - treated as "localhost"
///
public string Machine { get; set; }
///
/// Username for connecting to remote machine
///
public string UserName { get; set; }
///
/// Password for connecting to remote machine
///
public string Password { get; set; }
///
/// Specific action to be executed (Start, Stop, etc.)
///
public string TaskAction { get; set; }
#endregion
#region Protected Members
///
/// Gets WMI ManagementScope object
///
protected ManagementScope WMIScope
{
get
{
if (_scope != null)
return _scope;
var wmiScopePath = string.Format(@"\\{0}\root\WebAdministration", Machine);
//we should pass user as HOST\\USER
var wmiUserName = UserName;
if (wmiUserName != null && !wmiUserName.Contains("\\"))
wmiUserName = string.Concat(Machine, "\\", UserName);
var wmiConnectionOptions = new ConnectionOptions()
{
Username = wmiUserName,
Password = Password,
Impersonation = ImpersonationLevel.Impersonate,
Authentication = AuthenticationLevel.PacketPrivacy,
EnablePrivileges = true
};
//use current user if this is a local machine
if (Helpers.IsLocalHost(Machine))
{
wmiConnectionOptions.Username = null;
wmiConnectionOptions.Password = null;
}
_scope = new ManagementScope(wmiScopePath, wmiConnectionOptions);
_scope.Connect();
return _scope;
}
}
///
/// Gets task action
///
protected TaskAction Action
{
get
{
return (WMI.TaskAction)Enum.Parse(typeof(WMI.TaskAction), TaskAction, true);
}
}
///
/// Gets ManagementObject by query
///
/// String WQL query
/// ManagementObject or null if it was not found
protected ManagementObject GetObjectByQuery(string queryString)
{
var query = new ObjectQuery(queryString);
using (var mos = new ManagementObjectSearcher(WMIScope, query))
{
return mos.Get().Cast().FirstOrDefault();
}
}
///
/// Wait till the condition returns True
///
/// Condition to be checked
protected void WaitTill(Func condition)
{
while (!condition())
{
Thread.Sleep(250);
}
}
#endregion
}
}
```
**AppPool**
```
using Microsoft.Build.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading;
namespace MSBuild.WMI
{
///
/// This class is used for operations with IIS ApplicationPool.
/// Possible actions:
/// "CheckExists" - check if the pool with the name specified in "AppPoolName" exists, result is accessible through field "Exists"
/// "Create" - create an application pool with the name specified in "AppPoolName"
/// "Start" = starts Application Pool
/// "Stop" - stops Application Pool
///
public class AppPool : BaseWMITask
{
#region Public Properties
///
/// Application pool name
///
public string AppPoolName { get; set; }
///
/// Used as outpur for CheckExists command - True, if application pool with the specified name exists
///
[Output]
public bool Exists { get; set; }
#endregion
#region Public Methods
///
/// Executes the task
///
/// True, is task has been executed successfully; False - otherwise
public override bool Execute()
{
try
{
Log.LogMessage("AppPool task, action = {0}", Action);
switch (Action)
{
case WMI.TaskAction.CheckExists:
Exists = GetAppPool() != null;
break;
case WMI.TaskAction.Create:
CreateAppPool();
break;
case WMI.TaskAction.Start:
StartAppPool();
break;
case WMI.TaskAction.Stop:
StopAppPool();
break;
}
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
return false;
}
//WMI tasks are execute asynchronously, wait to completing
Thread.Sleep(1000);
return true;
}
#endregion
#region Private Methods
///
/// Gets ApplicationPool with name AppPoolName
///
/// ManagementObject representing ApplicationPool or null
private ManagementObject GetAppPool()
{
return GetObjectByQuery(string.Format("select * from ApplicationPool where Name = '{0}'", AppPoolName));
}
///
/// Creates ApplicationPool with name AppPoolName, Integrated pipeline mode and ApplicationPoolIdentity (default)
/// Calling code (MSBuild script) must first call CheckExists, in this method there's no checks
///
private void CreateAppPool()
{
var path = new ManagementPath(@"ApplicationPool");
var mgmtClass = new ManagementClass(WMIScope, path, null);
//obtain in-parameters for the method
var inParams = mgmtClass.GetMethodParameters("Create");
//add the input parameters.
inParams["AutoStart"] = true;
inParams["Name"] = AppPoolName;
//execute the method and obtain the return values.
mgmtClass.InvokeMethod("Create", inParams, null);
//wait till pool is created
WaitTill(() => GetAppPool() != null);
var appPool = GetAppPool();
//set pipeline mode (default is Classic)
appPool["ManagedPipelineMode"] = (int)ManagedPipelineMode.Integrated;
appPool.Put();
}
///
/// Starts Application Pool
///
private void StartAppPool()
{
GetAppPool().InvokeMethod("Start", null);
}
///
/// Stops Application Pool
///
private void StopAppPool()
{
GetAppPool().InvokeMethod("Stop", null);
}
#endregion
}
}
```
**WebSite**
```
using Microsoft.Build.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace MSBuild.WMI
{
///
///
///
public class WebSite : BaseWMITask
{
#region Public Properties
///
/// Web Site name
///
public string SiteName { get; set; }
///
/// Web Site physical path (not a UNC path)
///
public string PhysicalPath { get; set; }
///
/// Port (it's better if it's custom)
///
public string Port { get; set; }
///
/// Name of the Application Pool that will be used for this Web Site
///
public string AppPoolName { get; set; }
[Output]
public bool Exists { get; set; }
#endregion
#region Public Methods
///
/// Executes the task
///
/// True, is task has been executed successfully; False - otherwise
public override bool Execute()
{
try
{
Log.LogMessage("WebSite task, action = {0}", Action);
switch (Action)
{
case WMI.TaskAction.CheckExists:
Exists = GetWebSite() != null;
break;
case WMI.TaskAction.Create:
CreateWebSite();
break;
case WMI.TaskAction.Start:
StartWebSite();
break;
case WMI.TaskAction.Stop:
StopWebSite();
break;
}
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
return false;
}
//WMI tasks are execute asynchronously, wait to completing
Thread.Sleep(1000);
return true;
}
#endregion
#region Private Methods
///
/// Creates web site with the specified name and port. Bindings must be confgiured after manually.
///
private void CreateWebSite()
{
var path = new ManagementPath(@"BindingElement");
var mgmtClass = new ManagementClass(WMIScope, path, null);
var binding = mgmtClass.CreateInstance();
binding["BindingInformation"] = ":" + Port + ":";
binding["Protocol"] = "http";
path = new ManagementPath(@"Site");
mgmtClass = new ManagementClass(WMIScope, path, null);
// Obtain in-parameters for the method
var inParams = mgmtClass.GetMethodParameters("Create");
// Add the input parameters.
inParams["Bindings"] = new ManagementBaseObject[] { binding };
inParams["Name"] = SiteName;
inParams["PhysicalPath"] = PhysicalPath;
inParams["ServerAutoStart"] = true;
// Execute the method and obtain the return values.
mgmtClass.InvokeMethod("Create", inParams, null);
WaitTill(() => GetApp("/") != null);
var rootApp = GetApp("/");
rootApp["ApplicationPool"] = AppPoolName;
rootApp.Put();
}
///
/// Gets Web Site by name
///
/// ManagementObject representing Web Site or null
private ManagementObject GetWebSite()
{
return GetObjectByQuery(string.Format("select * from Site where Name = '{0}'", SiteName));
}
///
/// Get Virtual Application by path
///
/// Path of virtual application (if path == "/" - gets root application)
/// ManagementObject representing Virtual Application or null
private ManagementObject GetApp(string path)
{
return GetObjectByQuery(string.Format("select * from Application where SiteName = '{0}' and Path='{1}'", SiteName, path));
}
///
/// Stop Web Site
///
private void StopWebSite()
{
GetWebSite().InvokeMethod("Stop", null);
}
///
/// Start Web Site
///
private void StartWebSite()
{
GetWebSite().InvokeMethod("Start", null);
}
#endregion
}
}
```
### Вызываем собственные задачи из билд скрипта
Теперь осталось только научиться вызывать эти задачи из билд скрипта. Для этого надо, во-первых, сказать MSBuild где лежит наша сборка и какие задачи оттуда мы будем использовать:
```
```
Теперь можно использовать задачу MSBuild.WMI.AppPool точно так же, как и самые обычные MSBuild команды.
```
```
Под спойлером — пример deploy.proj файла, который умеет создавать пул и сайт (если их нет), останавливать их перед деплоем, а потом запускать заново.
**deploy.proj**
```
xml version="1.0" encoding="utf-8"?
localhost
TestAppPool
TestSite
8088
D:\Inetpub\TestSite
False
```
Для вызова деплоя достаточно передать этот файл msbuild.exe:
```
"C:\Program Files (x86)\MSBuild\12.0\Bin\msbuild.exe" deploy.proj
```
### Выводы и ссылки
Можно сказать, что написать свои задачи и подсунуть их MSBuild совсем не сложно. Спектр действий, которые могут выполнять такие задачи, тоже весьма широк и позволяет использовать MSBuild даже для не самых тривиальных операций по деплою, не требуя ничего, кроме msbuild.exe. На гитхабе выложен этот проект с примером билд файла: [github.com/StanislavUshakov/MSBuild.WMI](https://github.com/StanislavUshakov/MSBuild.WMI) Можно расширять и добавлять новые задачи! | https://habr.com/ru/post/261603/ | null | ru | null |
# Тюнинг PHP-FPM. Введение
**БОНУС:** в нашем подкасте мы обсудили эту тему с экспертом, членом сообщества PHP программистов: <https://share.transistor.fm/s/6a8637ba>
PHP-FPM (или FastCGI Process Manager) имеет по сравнению с mod\_php несколько преимуществ, из которых самые очевидные — он более гибок в настройке, и в настоящее время сообщество отдает предпочтение именно этому режиму работы PHP. Однако, если вы используете дефолтную конфигурацию от вашего диспетчера пакетов, то, скорее всего, вы не получите максимум выгоды от его использования.
В этой статье я представлю краткий обзор того, как улучшить производительность PHP-FPM, сконцентрировав ваше внимание на трех типах менеджеров процессов PHP-FPM и том, какой и когда лучше использовать.
PHP-FPM может использовать один из [трех режимов управления процессами](https://www.php.net/manual/en/install.fpm.configuration.php#pm):
* static
* dynamic
* ondemand
Сейчас мы подробнее рассмотрим, что представляет собой каждый из них.
### Static
Static гарантирует, что обработка пользовательских запросов всегда доступна фиксированному количеству дочерних процессов. Оно устанавливается с помощью [pm.max\_children](https://www.php.net/manual/en/install.fpm.configuration.php#pm.max-children). В этом режиме запросам не нужно ждать запуска новых процессов, что делает его самым быстрым подходом.
Предположим, что вы выбрали static конфигурацию с постоянно доступными 10 дочерними процессами, тогда вам нужно настроить ее в `/etc/php/7.2/fpm/pool.d/www.conf` (при условии, что вы используете дефолтную конфигурацию Debian/Ubuntu для PHP-FPM) следующим образом:
```
pm = static pm.max_children = 10
```
Чтобы проверить результат внесенных изменений запустите `pstree -c -H -S` после перезапуска PHP-FPM. Вы увидите, как в примере ниже, что доступно десять процессов.
`php-fpm7.2-+-php-fpm7.2 |-php-fpm7.2`
`|-php-fpm7.2 |-php-fpm7.2 |-php-fpm7.2 |-php-fpm7.2 |-php-fpm7.2 |-php-fpm7.2 |-php-fpm7.2 `-php-fpm7.2`
### Dynamic
В этом режиме PHP-FPM динамически регулирует количество доступных дочерних процессов и гарантирует постоянную доступность *хотя бы одного* из них.
Данная конфигурация задействует пять параметров:
* `pm.max_children`: максимальное количество дочерних процессов, которые могут быть запущены.
* `pm.start_servers`: количество дочерних процессов, запускаемых на запуске PHP-FPM.
* `pm.min_spare_servers`: минимальное количество бездействующих дочерних процессов, которые создает PHP-FPM. Если доступно меньше, чем это число, то создаются другие процессы.
* `pm.max_spare_servers`: максимальное количество бездействующих дочерних процессов, которые создает PHP-FPM. Если доступно больше дочерних процессов, чем здесь указано, некоторые из них будут “убиты”.
* `pm.process_idle_timeout`: время простоя в секундах, по истечении которого дочерний процесс будет убит.
Теперь самое интересное; как рассчитать значения для каждой настройки? [Sebastian Buckpesch](https://medium.com/@sbuckpesch/apache2-and-php-fpm-performance-optimization-step-by-step-guide-1bfecf161534), предлагает следующую формулу:
| | |
| --- | --- |
| **Настройка** | **Значение** |
| max\_children | (Общий объем оперативной памяти - Память используемая для Linux, базы данных и т.д.) / Размер процесса |
| start\_servers | Количество ядер процессора х 4 |
| min\_spare\_servers | Количество ядер процессора х 2 |
| max\_spare\_servers | То же, что и для start\_servers |
Мы также должны установить параметр `pm.process_idle_timeout` - количество секунд, по истечении которых бездействующий процесс будет убит.
Допустим, у нашего сервера два процессора, каждый по четыре ядра, и 8 ГБ оперативной памяти. Если предположить, что Linux и связанные с ним демоны используют около 2 ГБ (для получения более конкретного значения можно использовать `free -hl`), то у нас останется около 6192 МБ.
Как узнать, сколько памяти использует каждый процесс? Чтобы вычислить это, есть скрипт Python под названием [ps\_mem.py](https://raw.githubusercontent.com/pixelb/ps_mem/master/ps_mem.py). После его запуска с помощью `sudo python ps_mem.py | grep php-fpm`, вы получите следующий результат:
```
28.4 MiB + 33.8 MiB = 62.2 MiB php-fpm7.2 (11)
```
Первый столбец - это собственная память. Второй столбец — общая память. Третий столбец — это общий объем используемой оперативной памяти. Четвертый столбец — это наименование процесса.
Исходя из вышеизложенного, понятно, что размер процесса составляет 62,2 МБ. Итак, введя все эти значения в нашу формулу, мы получим следующий результат:
```
# Round the result up. (8192 - 2000) / 62.2
```
Исходя из этого, мы получаем следующие значения для наших настроек:
| | |
| --- | --- |
| **Настройка** | **Значение** |
| max\_children | 100 |
| start\_servers | 32 |
| min\_spare\_servers | 16 |
| max\_spare\_servers | 32 |
Мы оставим `pm.process_idle_timeout` равным значению по умолчанию в 10s. Предположим, что нас устраивают эти настройки. Мы бы выполнили их конфигурацию следующим образом:
```
pm = dynamic pm.max_children = 100 pm.start_servers = 32 pm.min_spare_servers = 16 pm.max_spare_servers = 32 pm.max_requests = 200
```
Для отслеживания количества памяти, которое использует ваше приложение, вы можете регулярно использовать инструменты мониторинга памяти. Для PHP доступно несколько опций, включая [php-memprof](https://github.com/arnaud-lb/php-memory-profiler) и [Tideways](https://tideways.com/profiler/features).
### ondemand
ondemand заставляет PHP-FPM форкать процессы *при получении запросов*. Чтобы настроить PHP-FPM для его использования, нам нужно установить `pm` в режим `dynamic` и предоставить значения для следующих настроек:
* max\_children
* process\_idle\_timeout
* max\_requests
`max_requests` устанавливает количество запросов, которые каждый дочерний процесс должен выполнить перед респауном. В документации говорится, что эта настройка нужна для решения проблем с утечками памяти.
Предположим, что мы берем те же настройки, что и для режима `dynamic`. Конфигурация выглядела бы следующим образом:
```
pm = ondemand pm.max_children = 100 pm.process_idle_timeout = 10s pm.max_requests = 200
```
### Какая конфигурация подойдет вам?
Если честно, ответ на этот вопрос: «*смотреть надо по ситуации*», поскольку это всегда зависит от типа приложений, которые вы запускаете. Однако все же есть несколько рекомендаций относительно того, какую конфигурацию выбрать.
#### Сайт с низким трафиком
Если у вас сайт с низким трафиком, например такой, который содержит бэкендскую панель управления хостингом, скажем *cPanel*, используйте ondemand. Таким образом, вы выиграете в памяти, поскольку дочерние процессы будут создаваться только по необходимости, и завершаться, когда они больше не нужны. Поскольку это бэкенд, пользователи могут подождать на пару секунд дольше, пока не появится поток для обработки их запроса.
#### Сайт с высоким трафиком
Если у вашего сайта высокая посещаемость, используйте static и выставляйте настройки в зависимости от ваших потребностей и имеющихся аппаратных ресурсов. Может показаться, что ни к чему такое большое количество дочерних процессов готовых к приему запросов.
Однако сайты с высоким трафиком должны иметь как можно меньшее время ответа, поэтому использование режима static крайне важно для наличия достаточного количества готовых к работе дочерних процессов.
В режиме ondemand дочерние процессы, скорее всего, будут расходовать слишком много памяти, порождая и убивая потоки, и задержка запуска снизит производительность.
В режиме dynamic все может быть не так плохо, все зависит от конфигурации. Однако вы можете в итоге получить конфигурацию, которая по сути копирует static.
### Использование нескольких пулов для фронтенда/бэкенда
И последняя рекомендация: обслуживайте фронтенд и бэкенд вашего сайта, используя [разные пулы](https://www.nginx.com/blog/thread-pools-boost-performance-9x/). Допустим, у вас есть интернет-магазин, например, на платформе Magento. Вы можете рассматривать приложение как состоящее из двух частей:
* Фронтенд, где клиенты могут просматривать и совершать покупки.
* Бэкенд, где администраторы управляют магазином (например, *добавляют/удаляют продукты*, *категории* и *теги*, а также *проверяют рейтинги*).
При таком подходе, целесообразно иметь один пул, который обслуживает фронтенд, а другой - бэкенд, и настраивать каждый соответствующим образом.
Как бы то ни было, вы можете разделить любое приложение на несколько частей, используя эту стратегию, если это имеет смысл. Вот как это сделать.
Добавьте в `/etc/php/7.2/fpm/pool.d/www.conf` следующую конфигурацию:
```
; frontend [frontend] listen = /var/run/php-fpm-frontend.sock user = www-data group = www-data listen.owner = www-data listen.group = www-data pm = static pm.max_children = 5
; backend [backend] listen = /var/run/php-fpm-backend.sock user = www-data group = www-data listen.owner = www-data listen.group = www-data pm = ondemand pm.max_children = 5 pm.process_idle_timeout = 10s
```
Это создаст два пула: один для фронтенда, а другой — для бэкенда. Оба имеют одного и того же пользователя и группу, но имеют разные конфигурации менеджера процессов и подключены через разные сокеты.
Пул фронтенда использует `static` конфигурацию с небольшим максимальным количеством дочерних процессов. Пул бэкенда использует конфигурацию `ondemand`, также с небольшим количеством конфигураций. Их значения произвольны, так как они приведены для примера.
Сохранив это, используйте для вашего NGINX vhost файла следующую конфигурацию:
```
server { listen 80; server_name test-site.localdomain; root /var/www/test-site/public;
access_log /var/log/nginx/test-site.access.log; error_log /var/log/nginx/test-site.error.log error; index index.php;
set $fpm_socket "unix:/var/run/php-fpm-frontend.sock";
if ($uri ~* "^/api/") { set $fpm_socket "unix:/var/run/php-fpm-backend.sock"; }
location / { try_files $uri $uri/ /index.php;
location ~ .php$ { fastcgi_split_path_info ^(.+.php)(/.+)$; fastcgi_pass $fpm_socket; fastcgi_index index.php; include fastcgi.conf; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; } } }
```
Это создаст конфигурацию виртуального хоста, которая отправляет запросы в пул фронтенда или бэкенда в зависимости от запрошенной локации. Любые запросы к /api отправляются в пул бэкенда, а все остальные запросы направляются во фронтенд.
### В заключение
Что ж, это было быстрое введение в тюнинг PHP-FPM в целях повышения производительности. Мы рассмотрели три различных режима работы менеджера процессов, их настройки и обсудили, когда использование каждого из режимов уместно. Мы закончили рассмотрением юзкейса с пулами. Спасибо за внимание!
---
> Материал подготовлен в рамках курса [«PHP Developer. Professional»](https://otus.pw/vG0e/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [здесь.](https://otus.pw/QQeG/)
>
> | https://habr.com/ru/post/582442/ | null | ru | null |
# Захват всех доменов .io с помощью таргетированной регистрации
В [предыдущей статье](https://thehackerblog.com/the-journey-to-hijacking-a-countrys-tld-the-hidden-risks-of-domain-extensions/index.html) мы обсуждали захват доменных расширений *.na*, *.co.ao* и *.it.ao* разными хитростями с DNS. Сейчас рассмотрим угрозу компрометации домена верхнего уровня (TLD) и как нужно действовать злоумышленнику, чтобы достичь поставленной цели. Одним из довольно простых методов видится регистрация доменного имени одного из [авторитативных серверов имён](https://en.wikipedia.org/wiki/Name_server#Authoritative_name_server) этой TLD. Поскольку в TLD авторитативные серверы могут размещаться на произвольных доменах, то есть вероятность зарегистрировать такой домен, воспользовавшись ошибкой из-за неправильной конфигурации, истечения срока действия или других ошибок. Затем этот сервер можно использовать для выдачи новых DNS-записей в целой доменной зоне.
Приведу здесь соответствующую цитату из предыдущей статьи:
*> Такой вариант казался верной дорогой к победе, так что я потратил много времени на разработку инструментария для проверки ошибок этого типа. По сути, этот процесс состоит в записи всех хостов серверов имён для данного домена — и проверке, когда истечёт срок регистрации какого-нибудь из корневых доменов и он станет доступен для регистрации. Основная проблема в том, что многие регистраторы не говорят, что домен полностью свободен, пока вы реально не попробуете его купить. Кроме того, было несколько случаев, когда у сервера заканчивался срок регистрации, но по какой-то причине домен был недоступен для регистрации, хотя не был помечен как зарезервированный. В результате такого сканирования удалось зафиксировать много перехватов доменов в закрытых зонах (.gov, .edu, .int и др.), но не самих TLD.*
Как выяснилось, такой способ не только подходит для атаки TLD, но в реальности привёл к крупнейшему захвату TLD на сегодняшний день.
Аномалия .io
------------
В пятницу вечером, составляя [график путей делегирования DNS](https://github.com/mandatoryprogrammer/trusttrees) для различных TLD, мой скрипт выдал неожиданный результат для зоны .io:
[](https://thehackerblog.com/wp-content/uploads/2017/07/io._trust_tree_graph.png)
Одна из функций этого скрипта (который называется [TrustTrees](https://github.com/mandatoryprogrammer/trusttrees)) заключается в том, что ему можно передать [ключ Gandi API](https://www.gandi.net/) — а он проверит, есть ли в цепочке делегирования серверы имён со свободными для регистрации доменными именами. Скрипт показал, что в зоне .io многие домены серверов имён доступны для покупки! Впрочем, это не означает, что их в самом деле можно купить. Раньше я неоднократно сталкивался с тем, что свободное доменное имя нельзя зарегистрировать, потому что оно «зарезервировано». Я решил пойти на сайт регистратора [NIC.IO](https://www.nic.io/) и проверить. Быстренько поискав доменное имя *ns-a1.io*, с удивлением обнаружил, что оно выставлено на продажу по цене $90,00. Поскольку было около полуночи (*наверное, автор считает это «детским» временем — прим.пер.*), я решил продолжить и реально попытаться купить этот домен. Вскоре пришло письмо с подтверждением, что регистрация доменного имени «обрабатывается»:
Не совсем понятно, почему письмо пришло от компании 101Domain. Вероятно, она занимается регистрацией доменов в зоне .io (возможно, и управляет всем реестром?). В этот время уже далеко за полночь я пожал плечами и пошёл спать, и забыл об этом случае, пока в среду утром не пришло такое письмо, когда я уже собирался уходить на работу:
Тут я вспомнил о своём пятничном расследовании и всех подробностях регистрации. Пришлось вернуться за компьютер: интересно, неужели я действительно получил контроль над серверами имён доменной зоны .io? Я быстренько запустил команду `dig` для домена — и убедился, что мои тестовые серверы имён DNS (*ns1/ns2.networkobservatory.com* ) действительно записаны на *ns-a1.io*:
```
bash-3.2$ dig NS ns-a1.io
; <<>> DiG 9.8.3-P1 <<>> NS ns-a1.io
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 8052
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;ns-a1.io. IN NS
;; ANSWER SECTION:
ns-a1.io. 86399 IN NS ns2.networkobservatory.com.
ns-a1.io. 86399 IN NS ns1.networkobservatory.com.
;; Query time: 4 msec
;; SERVER: 2604:5500:16:32f9:6238:e0ff:feb2:e7f8#53(2604:5500:16:32f9:6238:e0ff:feb2:e7f8)
;; WHEN: Wed Jul 5 08:46:44 2017
;; MSG SIZE rcvd: 84
bash-3.2$
```
Запросил один из корневых серверов DNS и снова убедился, что этот домен указан в качестве авторитативного сервера имён для доменной зоны первого уровня .io:
```
bash-3.2$ dig NS io. @k.root-servers.net.
; <<>> DiG 9.8.3-P1 <<>> NS io. @k.root-servers.net.
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 19611
;; flags: qr rd; QUERY: 1, ANSWER: 0, AUTHORITY: 7, ADDITIONAL: 12
;; WARNING: recursion requested but not available
;; QUESTION SECTION:
;io. IN NS
;; AUTHORITY SECTION:
io. 172800 IN NS ns-a1.io.
io. 172800 IN NS ns-a2.io.
io. 172800 IN NS ns-a3.io.
io. 172800 IN NS ns-a4.io.
io. 172800 IN NS a0.nic.io.
io. 172800 IN NS b0.nic.io.
io. 172800 IN NS c0.nic.io.
;; ADDITIONAL SECTION:
ns-a1.io. 172800 IN AAAA 2001:678:4::1
ns-a2.io. 172800 IN AAAA 2001:678:5::1
a0.nic.io. 172800 IN AAAA 2a01:8840:9e::17
b0.nic.io. 172800 IN AAAA 2a01:8840:9f::17
c0.nic.io. 172800 IN AAAA 2a01:8840:a0::17
ns-a1.io. 172800 IN A 194.0.1.1
ns-a2.io. 172800 IN A 194.0.2.1
ns-a3.io. 172800 IN A 74.116.178.1
ns-a4.io. 172800 IN A 74.116.179.1
a0.nic.io. 172800 IN A 65.22.160.17
b0.nic.io. 172800 IN A 65.22.161.17
c0.nic.io. 172800 IN A 65.22.162.17
;; Query time: 70 msec
;; SERVER: 2001:7fd::1#53(2001:7fd::1)
;; WHEN: Wed Jul 5 08:46:14 2017
;; MSG SIZE rcvd: 407
```
Ничего себе! Я сразу же соединился по SSH со своим тестовым сервером DNS, к которому теперь был привязан этот домен, и быстренько убил работающий BIND-сервер. Если ко мне повалит DNS-трафик, то я определённо не хочу возвращать плохие ответы людям, которые имеют законный доступ ко своим доменам .io. Поскольку BIND-сервер больше не обрабатывает запросы на порт 53, то все DNS-запросы автоматически перенаправятся на другие сервера имён этой TLD и не слишком повлияют на трафик (кроме небольшой задержки при резолвинге, пока DNS-клиенты достучаться до работающего сервера имён). Чтобы посмотреть, действительно ли ко мне пошли DNS-запросы, я быстренько запустил запись дампа [tcpdump](https://en.wikipedia.org/wiki/Tcpdump) всего DNS-трафика в файл — и тут же на экран хлынули сотни запросов со случайных IP со всех уголков интернета. Похоже, я действительно обрабатывал трафике для всей доменной зоны. А ещё хуже: вероятно, это было только начало, потому что многие DNS-клиенты ещё руководствовались кешированными старыми DNS-записями, которые скоро обновятся.
Сообщение об проблеме безопасности в TLD
----------------------------------------
Поскольку мой сервер больше не отвечал на DNS-запросы, я думал только о том, как побыстрее исправить ситуацию. Больше всего меня беспокоило, что в продаже осталось ещё много доменов для серверов имён, которые может зарегистрировать кто угодно, у кого есть деньги и знания, что нужно делать. Я поискал контакты администраторов .io TLD в [корневой базе данных IANA](https://www.iana.org/domains/root/db/io.html):
Затем составил описание проблемы и отправил письма на оба адреса, отметив необходимость срочного решения. Указал, что домены для других серверов имён TLD по-прежнему доступны для регистрации и что если проблему не решат в течение нескольких часов, я зарегистрирую их, чтобы защитить зону. Немедленно после отправки письма я получил отлуп от почтового сервера с указанием, что адрес *adminstrator@nic.io* не существует:
Это явно не прибавляло уверенности, что кто-то прочитает моё письмо. Так что я решил потратить немного денег и купить остальные домены серверов имён, чтобы никто не хакнул TLD. Как и в первом случае, я явно настроил DNS-сервер не принимать входящие запросы, так что не вмешивался в обычный трафик .io. Эти заказы на покупку оформили достаточно быстро:
Фух! По крайней мере, их не взломает какой-нибудь случайный хакер, а я могу с чистым сердцем идти на работу.
Позже в этот день я позвонил по телефону в поддержку NIC.IO и спросил действующий адрес электронной почты кого-нибудь из сотрудников отдела безопасности для TLD. Агент заверил меня, что подходящим адресом для такого запроса будет *abuse@101domain.com* (я дважды переспросил его на этот счёт для уверенности). Хотя такой адрес не выглядит подходящим, но я переправил туда отчёт с описанием проблемы и надеялся, что его хотя бы перешлют компетентному специалисту. Поскольку не было возможности узнать другие адреса, я ждал ответа.
«Упс» — исправление путём аннулирования регистрации доменов
-----------------------------------------------------------
Около полудня следующего дня пришла серия уведомлений от 101Domains о том, что регистрации доменов отменяются, деньги возвращаются на карточку, а мой «тикет в суппорте» отвечен и закрыт:
Удивительно, но похоже на то, что адрес abuse@ действительно оказался правильным адресом для решения проблемы. Зайдя в свой аккаунт 101Domain, я обнаружил такое письмо из юридического отдела 101Domain:
[](https://thehackerblog.com/wp-content/uploads/2017/07/101domain_oops_deleted_io_ns.png)
Всё было сделано довольно быстро и правильно (хотя обычно я получаю просто письмо с уведомлением вместо ответа юридического отдела). Убедившись, что указанные домены боле недоступны для регистрации, можно было сделать вывод, что ситуация полностью исправлена.
Возможные последствия
---------------------
Учитывая, что мы зарегистрировали четыре из семи авторитативных серверов имён для доменной зоны .io, мы могли бы изменить/перенаправить записи DNS для всех зарегистрированных доменов .io. Более того, поскольку мы контролировали более половины серверов имён, то DNS-запросы с *большей* вероятностью шли бы к нам без всяких дополнительных трюков вроде [долгих TTL ответов](https://thehackerblog.com/respect-my-authority-hijacking-broken-nameservers-to-compromise-your-target/index.html) и других, которые ещё больше увеличивают наши шансы. Даже при условии немедленной реакции на такого рода атаку потребуется некоторое время, пока кешированные записи полностью сотрутся из всех мировых DNS-резолверов.
Для исправления ситуации помогло бы то, что в доменной зоне .io поддерживается технология DNSSEC. Это значит, что если ваш резолвер тоже поддерживает эту технологию, то можно защититься от подобных атак с подделкой записей DNS. Но как я говорил в прошлой статье, [почти никто не использует DNSSEC](https://dnssec.vs.uni-due.de/). Я редко вижу хоть какую-либо поддержку этой технологии, если только сам специально не настраиваю резолвер.
*\*Одно замечание, не имеющее отношения к теме: важно не забыть остановить tcpdump после запуска. Если этого не сделать, то у вас хорошие шансы забить всё место на диске VPS данными DNS. Обратите внимание на то, что все записанные для отладочных целей данные DNS очищены от конфиденциальной информации о пользователях.*
Защита и безопасность TLD
-------------------------
Я довольно подробно писал, как TLD могут избежать некоторых из этих проблем (для дополнительной информации см. «Выводы и последние мысли» в статье «[Маршрут взлома национальной TLD — скрытые риски расширений доменных имён](https://thehackerblog.com/the-journey-to-hijacking-a-countrys-tld-the-hidden-risks-of-domain-extensions/index.html)». В будущем я собираюсь составить более обширное руководство, как TLD и операторам расширений доменных имён отслеживать и предотвращать такие ситуации.
Приветы
-------
Я обещал своему другу, что передам ему хакерский приветик в следующем посте в блоге, так что должен выполнить обещание :). Особая благодарность этим ребятам за моральную и «аморальную» поддержку (как говорил единственный и неповторимый [HackerBadger](https://twitter.com/aegarbutt)).
**Привет, [HackerBadger](https://twitter.com/aegarbutt), EngSec (вы знаете, кто вы), [Hacke the planet](https://www.youtube.com/watch?v=u3CKgkyc7Qo), [the gibson](https://www.youtube.com/watch?v=Bmz67ErIRa4) и всё такое.** | https://habr.com/ru/post/333026/ | null | ru | null |
# Избавление .NET программы от регистрации на примере BEM
Не так давно я решил изучить, а заодно попробовать поправить одну библиотечку, избавив программу работающую на данной библиотеке от лицензии.
Началось все с того, что как то мне в руки попала программа для бухгалтерской отчетности, некий бюджетный вариант 1С. Как заверяли разработчики этой программы, что она является, чуть ли не самой защищенной и устойчивой к взломам. Именно это хвастовство и подтолкнуло опровергнуть излишнюю самоуверенность разработчиков.
Покопавшись в программе через [Reflector](http://reflector.red-gate.com/), обнаружил, что все основные библиотеки программы написаны сторонней компанией, более того писались они не для конкретного проекта, а являлись целым Фреймворком. Фреймворк писался как раз для бухгалтерских программ. Для такого рода направленности Фреймворка, в него впихнули необычайно много ненужного функционала (к примеру, работу с FTP). Было переопределено невероятное количество системных пространств имен.
А так же в одной из библиотек данного Фреймворка было определено пространство имен, классы которого отвечали за проверку корректности лицензии. В связи с этим я решил погуглить с целью поиска информации и документации к данному Фреймворку. Через пару минут поисков, стало ясно, что данный Фреймворк является закрытым. Почему закрытым? — да потому, что распространяется он по неизвестным критериям, по крайней мере я не нашел информации по этому поводу на [сайте](http://netdec.uz/index.php) разработчика. Так же на сайте разработчика не удалось найти справочную информацию по данному Фреймворку. Искал всю эту информацию по тому, что как выше было сказано, за лицензирование программы отвечал именно этот Фреймворк, частичка души все же наивно полагала найти keygen к этому Фреймворку, ведь система лицензии для всех программ, базирующихся на этом Фреймворке единая. Это означало, что кто – то для одной из программ на этом Фреймворке сделал keygen. Но, увы, поиски не увенчались успехом.
Да кстати название Фреймворку [NetDec](http://netdec.uz/index.php).
Также анализ библиотеки, в которой находились классы, отвечающие за проверку лицензии, показал, что част классов обфусцированы, в том числе и все пространство имен отвечающих за лицензию. Заморачиваться над деобфускацией и последующей перекомпиляцией не было желания, тем более стояла цель написать генератор лицензии или патчер.
[](https://habrastorage.org/storage/habraeffect/8d/76/8d76958dce96b0c2aec7a9e4aef2828e.png "Хабрэффект.ру")
Метод, отвечающий за проверку лицензии, был найден очень быстро, нужно было только отследить обработчик нажатия на кнопку ОК в форме ввода лицензии.
[](https://habrastorage.org/storage/habraeffect/85/26/8526cf84d25ff28c7f35389820982ae4.png "Хабрэффект.ру")
Для удобства анализа кода все-таки пришлось искать аналог Reflector только с деобфускатором на борту. Таковым оказался [DisSharp](http://www.netdecompiler.com/).
Как видно лицензия в программе является цифровой подписью на алгоритме [DSA](http://ru.wikipedia.org/wiki/DSA). Для создания цифровой подписи берется так называемый код компьютера (так они его назвали, углубляться в генерацию данного кода не стал) далее код компьютера соединяется с серийным номером, и в методе DSACryptoServiceProvider::VerifyData сверяются с цифровой подписью.
В метод в переменной text1 передается XML строка для восстановления объекта DSA. Немного покопавшись, был найден XML файл, в котором и был объект для восстановления DSA. Первым делом был брошен взгляд на поиск приватного ключа (ну чем черт не шутит), увы, естественно разработчики от него избавились. Сам XML файл был вшит в ресурсы библиотеки. Первым делом были приняты попытки сгенерировать свой объект DSA, и вшить полученный XML в ресурсы библиотеки, заменив старый.
Ранее ничем подобным мне заниматься не приходилось, поэтому поиски программы для замены ресурсов результаты не дали. Да и хотелось сделать полностью автоматизированное решение для активации программы. Конечно, можно было пропатчить подобными программами эту дллку, а потом просто патчером заменять ею стандартную, но как то это не эстетично. Полностью автоматизированное решение хотелось сделать для того, чтобы отправить его на оценку разработчикам этого продукта.
Поиски на тему замены ресурсов программным путем адекватного решения не дали. Руки как то отпустились. Хотя уже в принципе я доказал, что обойти лицензию можно вшив свой DSA объект в библиотеку, и на этом же объекте сделать генератор лицензий.
На время пришлось забросить в дальний ящик все это дело, и заняться работой. По прошествии некоторого времени, мне снова кто то сказал об этой программе и о ее защищенности. Снова взялся за разбор.
Посидев, подумав некоторое время, вспомнив, что IL компилятор не компилирует строки, в голову пришла идея (которая покажется многим очень примитивной и глупой) взглянуть на внутренности библиотеки через простой блокнот. Да-да прострой notepad. Поиск по ключевому слову DSAKeyValue сразу же вывел мне XML данные DSA объекта. В голову сразу же пришла идея по регулярному выражению программно заменить этот объект на свой. Взялся за кодинг, реализовав задуманное, столкнулся с тем, что библиотека отказалась вообще работать. Ожидая подобный результат, перед полной заменой я попробовал частичную замену объекта, после чего библиотека отлично работала, только не кушала даже официальную лицензию.
Предварительно я сверил длину официального объекта DSA в XML файле и своего (под длиной подразумевается количество символов), размеры полностью совпадали.
Далее я просто программно считал всю библиотеку в массив байтов, зафиксировал при чтении первое и последнее вхождение в xml объект dsa заменил эти байты на свои, и сохранил обратно в файл.
Забыл сказать, DSA объект генерировался на лету, и при его генерации в xml строку можно указать добавлять к данным приватный ключ или нет, я установил это значение в false, в оригинальной сигнатуре его ведь нет. Сразу же когда инициализировался объект DSA, создавались цифровая подпись с серийным номером, которые сохранялись в файл лицензии.
Проделав вышеописанные шаги, мой xml объект DSA должен был отражаться в рефлекторе. Оставалось только попробовать запустить программу. Прищурился и попытался запустить программу. Как и ожидалось, программа запустилась безо всяких вопросов лицензии.
Спустя некоторое время я обнаружил [статью](http://habrahabr.ru/blogs/net/108947/) на хабре, про инъекции MSIL кода в сторонние сборки по средством библиотеки [Mono.Cecil](http://www.go-mono.com/mono-downloads/download.html). Через пару минут был сделан код, который добавляет простой return в начало метода проверки лицензии тем самым лицензия успешно подтверждается!
```
private void Injector(string path) {
var assembly = AssemblyDefinition.ReadAssembly (path);
foreach (var typeDef in assembly.MainModule.Types)
{
foreach (var method in typeDef.Methods)
{
string mp = "(";
for (int i = 0; i < method.Parameters.Count; i++)
{
mp += method.Parameters[i].ParameterType+",";
}
mp = mp.Trim(' '); mp = mp.Trim(',');
mp += ")";
if (mp == "(System.Byte[],System.String,System.String)")
{
var ilProc = method.Body.GetILProcessor();
Instruction badInstruction = Instruction.Create (OpCodes.No);
Instruction firstInstruction = ilProc.Body.Instructions [0];
ilProc.InsertBefore (firstInstruction, Instruction.Create (OpCodes.Ret, firstInstruction));
ilProc.InsertBefore (firstInstruction, badInstruction);
}
}
}
assembly.Write(path);
}
```
Данный способ срабатывает, потому что принцип проверки лицензии в данном Фреймворке невероятно простой. В методе вызывающем метод проверку лицензии установлен обработчик исключений, если в методе проверке лицензии происходит исключение, значит лицензия неправильная или ее нет вообще, если исключений нет, то все в порядке можно стартовать.
Так как все методы обфусцированы, искать метод по имени через Mono.Cecil не имеет смысла. Посмотрев в рефлекторе, я обратил внимание, что в данной библиотеки нет не у кого таких же аргументов, с таким же типом и последовательностью. Поэтому было решено выделять метод по аргументам:
```
if (mp == "(System.Byte[],System.String,System.String)"){
//…
}
```
Вот в принципе и все.
P.S. Данная статья не коем образом не предназначалась пособием по крекингу и т.п. Не нужно быть гуру в программировании чтобы понять, что проделанные выше действия примитивные, а порой и смешны своей реализацией. | https://habr.com/ru/post/111330/ | null | ru | null |
# Тёмная сторона SQL Server In-Memory OLTP
Пару лет назад, в разговоре с кем-то промелькнула примерно такая фраза: "Мы используем In-Memory OLTP - это очень быстро, зачастую даже вместо временных таблиц создаём In-Memory и всем советуем". Спустя какое-то время, мне задали вопрос как можно держать одну таблицу в памяти, чтобы работать с ней максимально быстро. Выяснив подробности - небольшая таблица, данные должны храниться только за последние несколько минут, суммарно не больше 10000 записей "приемлемых" (не LOB) типов данных, потеря данных при перезагрузке/файловере не страшна и даже приветствуется. In-Memory OLTP, без тени сомнения ответил я.
Перед запуском в продакшн я излазил всю документацию, проводил свои тесты - просто огонь. Работает реально быстро, таблица SCHEMA\_ONLY и IO не генерирует вообще (я же умный, смотрю sys.dm\_io\_virtual\_file\_stats до и после). С обращениями через natively compiled stored procedures - не просто быстро работает, летает. Одним словом мечта.
Правда, оказалось, что у моей мечты есть тёмная сторона.
Сочиняем мечту
--------------
Про In-Memory написано уже очень много всего, в т.ч. и на Хабре ([1](https://habr.com/ru/post/225167/), [2](https://habr.com/ru/post/225935/)). И во всех материалах, которые я встречал, [написано](https://docs.microsoft.com/en-us/sql/relational-databases/in-memory-oltp/defining-durability-for-memory-optimized-objects?view=sql-server-2017):
> SCHEMA\_ONLY
>
> This option ensures durability of the table schema. When SQL Server is restarted or a reconfiguration occurs in an Azure SQL Database, the table schema persists, but data in the table is lost. (This is unlike a table in tempdb, where both the table and its data are lost upon restart.) A typical scenario for creating a non-durable table is to store transient data, such as a staging table for an ETL process. **A SCHEMA\_ONLY durability avoids both transaction logging and checkpoint, which can significantly reduce I/O operations**.
>
>
Жирненьким текст в цитате выделил я, потому что во всех источниках видел эту фразу в том или ином виде. Если мы создаём таблицу как SCHEMA\_ONLY, её содержимое никоим образом не попадает на диск - данные не пишутся ни в журнал транзакций, ни при чекпоинтах.
Но так ли это на самом деле?
Воплощаем мечту
---------------
Я делаю всё на SQL Server 2017, но всё описанное будет одинаковым для любой версии SQL Server 2014-2019 (правда, на 2016 не проверял).
Итак, чтобы насладиться быстродействием In-Memory OLTP нам нужна база данных, в этой БД нужно создать файловую группу, которая CONTAINS MEMORY\_OPTIMIZED\_DATA и в этой файловой группе нужно создать файл (на самом деле каталог). Поехали
```
CREATE DATABASE hekaton;
GO
ALTER DATABASE hekaton
ADD FILEGROUP hekaton CONTAINS MEMORY_OPTIMIZED_DATA;
GO
ALTER DATABASE hekaton
ADD FILE (
NAME=hekaton_hekaton,
FILENAME='D:\SQLServer\DEFAULT\hekaton_hekaton'
)
TO FILEGROUP hekaton;
GO
ALTER DATABASE hekaton
SET RECOVERY FULL;
GO
BACKUP DATABASE hekaton TO DISK = 'NUL';
GO
USE hekaton
GO
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Я перевожу БД в полную модель восстановления, потому что то, о чём я буду говорить дальше, наиболее очевидно проявляется в ней. Последний запрос выводит список файлов и их размеры:
Да, каюсь, я никогда не работал с FILESTREAM. Да, везде написано, что In-Memory файловая группа, по сути, FILESTREAM. Если вы работали, то, наверное, уже понимаете, от чего у меня полыхает. Если нет - давайте я покажу.
Убиваем мечту
-------------
Теперь переходим к тому, из-за чего всё затевалось, я создаю чудесную, молниеносную, волшебную In-Memory таблицу с DURABILITY = SCHEMA\_ONLY и даже вставляю в неё одну запись:
```
CREATE TABLE hekaton (
id int NOT NULL PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT = 1500000)
)
WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_ONLY);
GO
INSERT INTO hekaton (id)
VALUES (1);
GO
```
Ну и посмотрим, что у нас вставилось и сколько теперь файлы занимают на диске:
```
SELECT *
FROM hekaton;
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Воу, 105 мегабайт на диске для хранения 1 записи? Ну, ладно, я, в общем, готов с этим смириться - ведь больше расти не будет, правильно? Нет, не правильно. Для демонстрации я запущу вот это:
```
CHECKPOINT;
GO 10
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Господа, делайте ваши ставки! Что произойдёт с размером файлов после выполнения десяти чекпоинтов? Я бы зуб поставил, что ничего (и хорошо, что не поставил):
Но ведь это же не может быть правдой? У меня SCHEMA\_ONLY-таблица с одной записью! Так, ладно. Насколько же глубока кроличья нора? В [документации сказано](https://docs.microsoft.com/ru-ru/sql/relational-databases/in-memory-oltp/the-memory-optimized-filegroup?view=sql-server-ver15#configuring-a-memory-optimized-filegroup), что нужно планировать место в размере размер in-memory таблицы \* 4, где-то я видел, что нужно обеспечить свободное место в объём ОЗУ, доступного SQL Server, \* 4. Давайте попробуем.
```
EXEC sp_configure 'show advanced options', 1
RECONFIGURE
GO
EXEC sp_configure 'max server memory (MB)', 512
RECONFIGURE
GO
EXEC sp_configure 'max server memory (MB)'
```
```
CHECKPOINT;
GO 100
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Ваши ставки?
Такие дела. In-Memory таблица с одной записью (которая даже не изменяется), оказывается может занимать на диске столько места, сколько доступно на этом диске.
Срываем покровы
---------------
Вам, наверняка интересно почему так получается. На самом деле, мне тоже интересно, почему так получается со SCHEMA\_ONLY-таблицей. В целом, на msdn есть отличная [статья про Durability Memory-Optimized таблиц](https://docs.microsoft.com/en-us/sql/relational-databases/in-memory-oltp/durability-for-memory-optimized-tables?view=sql-server-ver15) (а если вам нужно детально разобраться с тем как устроен In-Memory OLTP, есть отличный [whitepapper от Kalen Delaney](https://docs.microsoft.com/en-us/sql/relational-databases/in-memory-oltp/sql-server-in-memory-oltp-internals-for-sql-server-2016?view=sql-server-ver15)). И, справедливости ради, нигде не написано, что для SCHEMA\_ONLY таблиц поведение будет отличаться.
Суть в том, что для обеспечения Durability, SQL Server создаёт и хранит Data и Delta файлы для одной или нескольких таблиц. Оба файла append-only и есть специальный background-процесс, который отвечает за запись в них. Периодически эти файлы мёржатся, а "старые", "ненужные" уже Data и Delta файлы удаляются специальным сборщиком мусора. Исходя из цитаты в начале (ну и если наблюдать за sys.dm\_db\_xtp\_checkpoint\_files) - SQL Server ничего не пишет в журнал транзакций и при чекпоинтах, но всё равно создаёт эти файлы при каждом CHECKPOINT'е! Причём, если у вас больше 16 ГБ ОЗУ - файлы будут по 128 МБ, если меньше (как у меня сейчас) - по 16 МБ. Ну а в каких-то случаях, начиная с SQL Server 2016, могут использоваться "large checkpoint" по 1 ГБ!
Ключевая, для меня, фраза в статье (хотя, на мой взгляд, она не передаёт все нюансы):
> CFPs transition through several states before they can be deallocated. Database checkpoints and log backups need to happen to transition the files through the phases, and ultimately clean up files that are no longer needed.
>
>
Исходя из [написанного здесь](https://www.sqlskills.com/blogs/paul/filestream-garbage-collection/) (там про FILESTREAM) и собственного горького опыта, речь не столько о самих бэкапах и чекпоинтах (**ВАЖНО!** Не делайте чекпоинты без бэкапа журнала транзакций в полной модели восстановления, чтобы вызвать сборщик мусора - ситуация будет становиться только хуже), сколько о том, что для того, чтобы файлы могли совершить "transition through the phases" нужно чтобы тот [VLF](https://habr.com/ru/post/349656/), в котором они были созданы, был помечен как неактивный.
Ну ладно, скажете вы, это же ерунда - бэкапы журнала транзакций в полной модели восстановления у вас снимаются регулярно, а в простой модели восстановления и волноваться не о чем. И я скажу вам да, но нет.
Давайте посмотрим как это выглядит:
```
ALTER DATABASE hekaton
SET RECOVERY SIMPLE;
GO
BACKUP DATABASE hekaton TO DISK = 'NUL';
GO
CHECKPOINT;
GO
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Повторим эксперимент. В одной сессии откроем транзакцию:
```
CREATE TABLE foo (bar int);
GO
BEGIN TRAN
INSERT INTO foo (bar)
VALUES (1);
```
А во второй выполним:
```
CHECKPOINT;
GO 30
SELECT name, type_desc, size * 8 / 1024 AS sizeMB
FROM sys.database_files;
```
Ой, в простой модели восстановления файловая группа для In-Memory продолжает расти, если что-то мешает "переводу" нужного VLF в статус "неактивный". Это может быть незакрытая транзакция, репликация, какой-нибудь REBUILD индексов - да много можно чего придумать.
В полной модели восстановления у вас, помимо перечисленного, может быть настроена Availability Group.
DANGER! Availability Group
--------------------------
А что не так с Availability Group? С ней всё так, не считая того, что она использует специальный механизм, который не отмечает забэкапленные VLF как неактивные. Почему? Потому что Microsoft заботится о нас. Потому что у нас может отвалиться реплика, а что же ей потом делать, если пока она была офлайн, прошёл бэкап журнала транзакций? Вот на этот случай, SQL Server и не отмечает неактивными VLF даже после бэкапа журнала транзакций (предполагаю, что тоже самое может касаться Database Mirroring). При этом для процесса, пишущего в журнал транзакций, нет проблемы понять какие "активные" VLF можно переиспользовать, а какие нет. [Более подробно про Availability Group и FILESTREAM](https://www.sqlhammer.com/filestream-garbage-collection-with-alwayson-availability-groups/).
Честно говоря, даже удивительно, что какие-то механизмы могут понимать, что VLF, отмеченный как активный, на самом деле неактивный, а In-Memory OLTP не может. Но благодаря этому, моя чудесная SCHEMA\_ONLY-таблица из 10 тысяч строк, о которой я говорил в начале, в нормальной жизни занимает порядка 2 МБ в памяти и 4 ГБ на диске, а во время "окна для обслуживания" может занимать на диске в десятки раз больше.
А это правда проблема?
----------------------
It depends.
С одной стороны - проблема не самая большая. По сути, без Availability Group, проблема возникает только в том случае, когда за промежуток между бэкапами журнала транзакций, выполняется столько чекпоинтов, что файловая группа вырастает настолько, что это становится проблемой. В каких ситуациях это возможно? Наиболее вероятный вариант, кмк - это "обслуживание индексов". [Документация говорит](https://docs.microsoft.com/en-us/sql/relational-databases/in-memory-oltp/checkpoint-operation-for-memory-optimized-tables?view=sql-server-ver15):
> For memory-optimized tables, an automatic checkpoint is taken when transaction log file becomes bigger than 1.5 GB since the last checkpoint. This 1.5 GB size includes transaction log records for both disk-based and memory-optimized tables.
>
>
Плюс, у нас есть recovery interval и target recovery time, которые тоже влияют на частоту чекпоинтов. Будет ли это проблемой для вас - я не знаю. В любом случае - заводя memory-optimized table (даже с DURABILITY = SCHEMA\_ONLY) в большой БД, стоит начать обращать на это внимание и отслеживать чекпоинты. Availability Group значительно усугубляет ситуацию.
Нужно понимать, что в полной мере проблема с ростом in-memory файловой группы проявится (ну или наконец-таки станет проблемой) именно тогда, когда у вас и без того будет куча проблем. Вырастает журнал транзакций - железно вместе с ним вырастает In-memory файловая группа и если места на диске впритык - вас ждут незабываемые моменты. И нужно помнить, что эту файловую группу нельзя ограничить в размере, потому что если она уткнётся в этот лимит, БД перейдёт в [состояние SUSPECT](https://docs.microsoft.com/ru-ru/sql/relational-databases/in-memory-oltp/the-memory-optimized-filegroup?view=sql-server-ver15#configuring-a-memory-optimized-filegroup).
Решение?
--------
У меня нет работающего "production-ready" решения.
В любой версии SQL Server Memory-Optimized таблицы могут занимать на диске на порядки больше места, чем в памяти, и могут занять всё свободное место вне зависимости от модели восстановления БД.
Единственное решение, которое помогает, в случае, когда место на диске приближается к концу - подрезать журнал транзакций, физически убирая, тем самым, часть VLF, чтобы сборщик мусора мог удалить лишние файлы.
Принимая решение об использовании In-Memory OLTP в промышленном окружении нужно обязательно учитывать, что:
1. Файловую группу In-Memory нельзя удалить из БД, она останется с вами навсегда.
2. Файловая группа In-Memory, при совпадении ряда условий, может быстро и значительно расти.
3. Таблицы, объявленные как SCHEMA\_ONLY, не генерируют IO и не используют Data и Delta файлы на диске, но эти файлы для них создаются при каждом CHECKPOINT'е.
4. При использовании Availability Group, файловая группа In-Memory будет гораздо больше, чем в точно такой же БД, не входящей в Availability Group. | https://habr.com/ru/post/547220/ | null | ru | null |
# Пишем Guard
Привет, Хабр! Есть несколько способов проверять аргументы на правильность. Например, для проверки на null можно использовать:
1. if (!ReferenceEquals(arg, null)) throw…
2. [Code Contracts](https://msdn.microsoft.com/ru-ru/library/dd264808.aspx): Contract.Requires(!ReferenceEquals(arg, null))
3. Guard.IsNotNull(arg, nameof(arg))
В статье я рассмотрю только третий вариант (все примеры кода — для C#, однако некоторые из них будут полезны и в Java).
Ошибка №1: не подготовились к проверкам аргументов и в теле метода
==================================================================
Чаще всего в проекте, для устранения копирования одинакового кода, кто-то создает статический класс, в котором можно проверить поле на null, больше нуля и т.д.
Однако в этом случае забывается, что одна и так же проверка может быть крайне полезна и для валидации аргументов (в этом случае дополнительным параметром передается имя аргумента), и для проверок внутри метода (в этом случае бросается другое исключение).
Итак, для начала лучше всего заранее договориться об именованиях обоих случаев. Например, `Guard.IsNotNull` для тела метода и `Guard.ArgumentIsNotNull` для аргументов
Ошибка №2: вызов string.format при каждой проверке
==================================================
Сразу примеры ошибочного кода:
```
Guard.IsNotNull(connection, $"Unable to setup connection with host {host} and port {port}")
Guard.IsNotNull(connection, string.Format("Unable to setup connection with host {0} and port {1}", host, port)) // это просто развернутая строчка выше
```
Оба примера выше генерят строку на каждую проверку (в теории, все Guard не бросают исключений на боевом сервере, то есть мы генерим немало строк просто для того, чтобы их потом съел сборщик мусора).
Исправленный вариант:
```
public static class Guard
{
public static void IsNotNull(object value, string format, params object[] formattingArgs) // тут мы сконструируем строку в самый последний момент, когда выделение небольшого куска памяти уже не будет ударять по производительности
}
```
На самом деле вариант выше тоже плохой. В нем уже не создается строка, однако на каждый вызов метода создается новый массив formattingArgs. Конечно, для него выделяется меньше памяти, однако такие методы всё равно будут нагружать на сборщик мусора.
Самое обидное, что программа будет тормозить, однако простой профайлинг не подстветит проблему. У вас просто программа будет чаще останавливаться для очистки памяти (я исправил такую ошибку в одной из программ, сборка мусора стала занимать вместо прежних 15% всего лишь 5%).
Итак, поступаем так же, как сделано в [string.Format](https://msdn.microsoft.com/ru-ru/library/system.string.format.aspx): нагенерим побольше методов для разного числа аргументов.
```
public static class Guard
{
public static void IsNotNull(object value, string errorMessage)
public static void IsNotNull(object value, string errorMessageFormat, object arg1)
public static void IsNotNull(object value, string errorMessageFormat, object arg1, object arg2)
public static void IsNotNull(object value, string errorMessageFormat, object arg1, object arg2, object arg3)
}
```
Итак, теперь массив выделяться не будет. Однако, мы автоматом получили новую проблему — Boxing.
Рассмотрим вызов метода: `Guard.IsNotNull(connection, "Unable to setup connection with host {0} and port {1}", host, port)`. Переменная port имеет тип int (чаще всего по крайней мере).
Получается, что для того, чтобы передать переменную по значению, .Net каждый раз будет создавать int в куче, чтобы передать его как object. Эта ситуация будет встречаться намного реже, но всё же будет.
И другая проблема — если изначальный проверяемый объект — это value type (например, мы проверяем на null в generic методе, который не имеет ограничений на тип).
Исправить это можно созданием Generic методов для проверок:
```
public static class Guard
{
public static void IsNotNull(TObject value, string errorMessage)
public static void IsNotNull(TObject value, string errorMessageFormat, TArg1 arg1)
public static void IsNotNull(TObject value, string errorMessageFormat, TArg1 arg1, TArg2 arg2)
public static void IsNotNull(TObject value, string errorMessageFormat, TArg1 arg1, TArg2 arg2, TArg3 arg3)
}
```
Ошибка №3: отсутствие кодогенерации
===================================
Как видно выше, для того, чтобы удобно проверять значения на null нам надо:
1. Создать два набора функций — для проверки аргументов и для проверок в теле метода
2. В каждом наборе — создать кучу дубликатов, который будут содержать один и тот же код
Без кодогенерации относительно сложно добавлять новые функции, а уж тем более менять их.
Еще улучшения
=============
Пункты ниже не ускорят вашу программу, а просто незначительно улучшат читаемость
ReSharper Annotations
---------------------
Часто ReSharper ругается, что значение может быть null, хотя его вроде бы проверили с помощью Guard'а. В этом случае можно либо начать постепенно забивать на предупреждения в коде (что может быть чревато), либо объяснить проверяющим, что всё нормально. Полный список аттрибутов [можно просмотреть здесь](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html), однако вот полезные для нас:
* [AssertionMethodAttribute и AssertionConditionAttribute](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html#AssertionMethodAttribute) — они вдвоем объяснят системе, что метод только проверяет аргумент, а заодно и распишут, что именно проверяют
* [NoEnumerationAttribute](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html#NoEnumerationAttribute) — покажет, что если передать на вход IEnumerable, то по нему никто не будет итерироваться
* [CollectionAccessAttribute](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html#CollectionAccessAttribute) — если вы вдруг решили проверить все аргументы коллекции (например, что их не больше пяти, и что они не null), то с помощью этого аттрибута можно сказать, что именно происходит с коллекцией (чтение, запись и т.д.)
* [StringFormatMethodAttribute](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html#StringFormatMethodAttribute) — объясняет, что один из параметров является строкой, которую потом будут использовать как формат. В этом случае её дополнительно проверят, что она может быть разобрана string.Format, что число аргументов соответствует ожиданиям и т.д. Я, кстати, еще не видел проекта, в котором была бы отключена эта проверка, и в котором после её включения не было бы ошибок, что string.Format просто не может выполниться
Записывать больше информации
----------------------------
В теории, число исключений из наших функций на боевых серверах должно быть наименьшим. А следовательно, любое их срабатывание должно нести в себе максимум информации: что же произошло на самом деле (ведь ситуация-то редкая). Как минимум, лучше всего включать в текст:
1. Тип (а лучше — вызов ToString у него), который оказался некорректным.
2. Если есть еще аргументы для сравнения — то информацию о них тоже
3. Полный stacktrace (т.к. иначе он обрезается до места, где исключение было поймано)
Заключение
==========
Надеюсь, эта статья поможет сравнительно просто улучшить проверки в вашем коде.
Немного ранее я реализовал все наработки в [библиотеке](https://www.nuget.org/packages/CheckContracts/) [(исходный код под MIT лицензией)](https://github.com/imanushin/CheckContracts) — так что можете просто использовать её (или скопировать код к себе и т.д.) | https://habr.com/ru/post/330150/ | null | ru | null |
# Распознавание лиц. Создаем и примеряем маски
Пока сообщество iOS-разработчиков спорит, как писать проекты, пока пытается решить, использовать ли MVVM или VIPER, пока пытается подSOLIDить проект или добавить туда реактивную турбину, я попытаюсь оторваться от этого и рассмотреть, как работает под капотом еще одна технология с [графика Hype-Driven-Development](http://www.gartner.com/smarterwithgartner/top-trends-in-the-gartner-hype-cycle-for-emerging-technologies-2017/).
В 2017 году на вершине графика хайпа — машинное обучение. И понятно почему:
* Появилось больше открытых наборов данных.
* Появились соответствующее аппаратные средства. В том числе облачные решения.
* Технологии из этой области стали применяться в production-проектах.
Машинное обучение — широкая тема, остановлюсь на распознавании лиц и попытаюсь разобраться, какие технологии были до рождества ~~христова~~ CoreML, и что появилось после релиза фреймворка Apple.
Теория распознавания лиц
------------------------
Задача распознавания лиц — часть практического применения теории распознавания образов. Она состоит из двух подзадач: идентификации и классификации ([тут подробно об отличиях](https://habrahabr.ru/post/317798/)). Идентификация личности активно используется в современных сервисах, таких как Facebook, iPhoto. Распознавание лица используется повсеместно, начиная от FaceID в iPhone X, заканчивая использованием при наведении целей в военной технике.
Человек распознает лица других людей благодаря зоне мозга на границе затылочной и височной долей — веретеновидной извилине. Мы распознаем разных людей с 4-х месяцев. Ключевые особенности, которые выделяет мозг для идентификации, — глаза, нос, рот и брови. Также человеческий мозг восстанавливает лицо целиком даже по половине и может определить человека лишь по части лица. Все увиденные лица мозг усредняет, а потом находит отличия от этого усредненного варианта. Поэтому людям европеоидной расы кажется, что все, кто принадлежит монголоидной расе, на одно лицо. А монголоидам трудно различать европейцев. Внутреннее распознавание настроено на спектральном диапазоне лиц в голове, поэтому, если какой-то части спектра не хватает данных, лицо считается за одно и тоже.
Задачи по распознаванию лиц решают уже более 40 лет. В них входит:
* Поиск и распознавание нескольких лиц в видеопотоке.
* Стойкость к изменениям лица, прически, бороды, очков, возраста и повороту лица.
* Масштабируемость данных для идентификации человека.
* Работа в реальном времени.
Один из оптимальных алгоритмов для нахождения лица на картинке и его выделения — [гистограмма направленных градиентов](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D1%81%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BD%D0%B0%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BE%D0%B2).
Есть и иные алгоритмы. Здесь описывается подробно, как происходит поиск зоны с лицом по [алгоритму Виолы-Джонса](https://habrahabr.ru/post/133826/). Он менее точный и хуже работает с поворотами лица.
Краткий экскурс в технологии и решения распознавания образов
------------------------------------------------------------
Решений, которые включают алгоритмы для распознавания образов, много. Список популярных библиотек, которые используются в iOS:
*рис 1. Структура библиотеки DLIB*
[**DLIB**](http://dlib.net/)
* Плюсы:
— Open source решение, можно участвовать в развитии и смотреть текущие тренды.
— Написана на С++. Имеет поддержку для iOS в виде cocoapods: pod 'dlib'.
— Можно также интегрировать в виде C++ библиотеки. Работает на Windows, Linux, MacOS. Работать можно и в swift приложениях, написав обертку на objective-c++.
* Минусы:
— Большой размер подключаемой библиотеки. 40 мегабайт в виде pod.
— Высокий порог входа. Большое количество внутренних алгоритмов, под каждый из которых предстоит писать обертку на Objective-C.
*рис 2. Структура библиотеки OpenCV*
[**OpenCV** (Open Source Computer Vision Library)](http://opencv.org/)
* Плюсы:
— Самое большое коммьюнити, регулярно участвующее в поддержке.
— Написана на С++. Имеет поддержку для iOS в виде cocoapods: pod 'OpenCV'.
* Минусы:
— Высокий порог входа.
— Большой размер подключаемой библиотеки. 77 мегабайт в виде pod, 180 мегабайт в виде C++ библиотеки.
*рис 3. Структура CoreML*
[**iOS Vision Framework**](https://developer.apple.com/documentation/vision)
* Плюсы:
— Простая интеграция в приложение.
— Содержит удобный конвертер, который поддерживает несколько различных моделей других фреймворков (Keras, Caffe, scikit-learn).
— Коробочное решение с малым размером.
— Работает на GPU.
* Минусы:
— Является частью CoreML, поэтому поддерживает лимитированное количество типов моделей других существующих фреймворков.
— Нет поддержки TensorFlow, одного из самых популярных решений машинного обучения. Придется потратить много времени на самописные конвертеры.
— Является высокоуровневой абстракцией. Вся имплементация закрыта, отсюда невозможность контроля.
— iOS 11+.
Существуют платные платформы, которые предоставляют решения для задачи распознавания образов. Большинство развивает собственные алгоритмы и технологии. Само собой, эти технологии активно развиваются и используются военными, поэтому некоторые решения засекречены и не имеют открытых исходников.
Что такое landmarks
-------------------
*рис 4. Визуальное отображение структур лица*
Цель определения landmarks — нахождение точек лица. Первый шаг в алгоритме — определение локации лица на картинке. После получения локации лица ищут **ключевые контуры**:
* Контур лица.
* Левый глаз.
* Правый глаз.
* Левая бровь.
* Правая бровь.
* Левый зрачок.
* Правый зрачок.
* Нос.
* Губы.
Каждый из этих контуров является массивом точек на плоскости.
*рис 5. dlib 68 landmarks*
На картинке можно четко увидеть структуры лица. При этом в зависимости от выбранной библиотеки количество landmarks отличается. Разработаны решения на 4 landmarks, 16, 64, 124 и более.
Триангуляция Делоне для построения маски
----------------------------------------
Перейдем к практической части. Попробуем построить простейшую маску на лице по полученным landmarks. Ожидаемым результатом будет маска вида:
*рис 6. Маска, визуализирующая алгоритм триангуляции Делоне*
**Триангуляция Делоне** — триангуляция для множества точек S на плоскости, при которой для любого треугольника все точки из S за исключением точек, являющихся его вершинами, лежат вне окружности, описанной вокруг треугольника. Впервые описана в 1934 году советским математиком Борисом Делоне.
*рис 7. Пример триангуляции Делоне. Из каждой точки порождается окружность, проходящая через две ближайшие в метрике Евклида*
Практическая реализация алгоритма
---------------------------------
Реализуем алгоритм триангуляции Делоне для нашего лица в камере.
Шаг 1. Внутри вы увидите обертку, которая принимает массив точек в двухмерном пространстве и возвращает массив треугольников.
```
public final class Triangle {
public var vertex1: Vertex
public var vertex2: Vertex
public var vertex3: Vertex
public init(vertex1: Vertex, vertex2: Vertex, vertex3: Vertex) {
self.vertex1 = vertex1
self.vertex2 = vertex2
self.vertex3 = vertex3
}
}
```
А vertex это wrapper для CGPoint, дополнительно содержащий номер конкретного landmark.
```
public final class Vertex {
public let point: CGPoint
// Идентификатор точки. От 0 до 67. Всего 68 значений для dlib. Либо 65 для vision
public let identifier: Int
public init(point: CGPoint, id: Int) {
self.point = point
self.identifier = id
}
}
```
Шаг 2. Перейдем к отрисовке полигонов на лице. Включаем камеру и показываем изображение с камеры на экране:
```
final class ViewController: UIViewController {
private var session: AVCaptureSession?
private let faceDetection = VNDetectFaceRectanglesRequest()
private let faceLandmarks = VNDetectFaceLandmarksRequest()
private let faceLandmarksDetectionRequest = VNSequenceRequestHandler()
private let faceDetectionRequest = VNSequenceRequestHandler()
private lazy var previewLayer: AVCaptureVideoPreviewLayer? = {
guard let session = self.session else {
return nil
}
var previewLayer = AVCaptureVideoPreviewLayer(session: session)
previewLayer.videoGravity = .resizeAspectFill
return previewLayer
}()
private lazy var triangleView: TriangleView = {
TriangleView(frame: view.bounds)
}()
private var frontCamera: AVCaptureDevice? = {
AVCaptureDevice.default(AVCaptureDevice.DeviceType.builtInWideAngleCamera,
for: AVMediaType.video, position: .front)
}()
override func viewDidLoad() {
super.viewDidLoad()
sessionPrepare()
session?.startRunning()
guard let previewLayer = previewLayer else {
return
}
view.layer.addSublayer(previewLayer)
view.insertSubview(triangleView, at: Int.max)
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
previewLayer?.frame = view.frame
}
private func sessionPrepare() {
session = AVCaptureSession()
guard let session = session, let captureDevice = frontCamera else {
return
}
do {
let deviceInput = try AVCaptureDeviceInput(device: captureDevice)
session.beginConfiguration()
if session.canAddInput(deviceInput) {
session.addInput(deviceInput)
}
let output = AVCaptureVideoDataOutput()
output.videoSettings = [
String(kCVPixelBufferPixelFormatTypeKey): Int(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
]
output.alwaysDiscardsLateVideoFrames = true
if session.canAddOutput(output) {
session.addOutput(output)
}
session.commitConfiguration()
let queue = DispatchQueue(label: "output.queue")
output.setSampleBufferDelegate(self, queue: queue)
print("setup delegate")
} catch {
print("can't setup session")
}
}
}
```
Шаг 3. Далее получаем кадры с камеры
*рис 8. Пример полученного кадра с камеры*
```
extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {
func captureOutput(_ output: AVCaptureOutput,
didOutput sampleBuffer: CMSampleBuffer,
from connection: AVCaptureConnection) {
guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
return
}
guard let attachments = CMCopyDictionaryOfAttachments(kCFAllocatorDefault,
sampleBuffer,
kCMAttachmentMode_ShouldPropagate)
as? [String: Any] else {
return
}
let ciImage = CIImage(cvImageBuffer: pixelBuffer,
options: attachments)
// leftMirrored for front camera
let ciImageWithOrientation = ciImage.oriented(forExifOrientation: Int32(UIImageOrientation.leftMirrored.rawValue))
detectFace(on: ciImageWithOrientation)
}
}
```
Шаг 4. Ищем лица на кадре
```
fileprivate func detectFace(on image: CIImage) {
try? faceDetectionRequest.perform([faceDetection], on: image)
if let results = faceDetection.results as? [VNFaceObservation] {
if !results.isEmpty {
faceLandmarks.inputFaceObservations = results
detectLandmarks(on: image)
}
}
}
```
Шаг 5. Ищем landmarks на лице
*рис 9. Пример найденных landmarks на лице*
```
private func detectLandmarks(on image: CIImage) {
try? faceLandmarksDetectionRequest.perform([faceLandmarks], on: image)
guard let landmarksResults = faceLandmarks.results as? [VNFaceObservation] else {
return
}
for observation in landmarksResults {
if let boundingBox = faceLandmarks.inputFaceObservations?.first?.boundingBox {
let faceBoundingBox = boundingBox.scaled(to: UIScreen.main.bounds.size)
var maparr = [Vertex]()
for (index, element) in convertPointsForFace(observation.landmarks?.allPoints,
faceBoundingBox).enumerated() {
let point = CGPoint(x: (Double(UIScreen.main.bounds.size.width - element.point.x)),
y: (Double(UIScreen.main.bounds.size.height - element.point.y)))
maparr.append(Vertex(point: point, id: index))
}
triangleView.recalculate(vertexes: maparr)
}
}
}
private func convertPointsForFace(_ landmark: VNFaceLandmarkRegion2D?,
_ boundingBox: CGRect) -> [Vertex] {
guard let points = landmark?.normalizedPoints else {
return []
}
let faceLandmarkPoints = points.map { (point: CGPoint) -> Vertex in
let pointX = point.x * boundingBox.width + boundingBox.origin.x
let pointY = point.y * boundingBox.height + boundingBox.origin.y
return Vertex(point: CGPoint(x: Double(pointX), y: Double(pointY)), id: 0)
}
return faceLandmarkPoints
}
```
Шаг 6. Далее поверх рисуем нашу маску. Берем полученные треугольники из алгоритма Делоне и рисуем в виде layers.
*рис 10. Финальный результат — простейшая маска поверх лица*
Полная реализация алгоритма триангуляции Делоне на Swift [здесь](https://github.com/NikAshanin/Swift-Triangulation-Delaunay).
И пара советов по оптимизации для искушенных. Рисовать новые layers каждый раз — дорогая операция. Постоянно вычислять координаты треугольников по алгоритму Делоне тоже дорого. Поэтому берем лицо в высоком разрешении и хорошем качестве, которое смотрит в камеру, и прогоняем один раз алгоритм триангуляции Делоне на этой фотографии. Полученные треугольники сохраняем в текстовый файл, а дальше используем эту треугольники и меняем у них координаты.
Что представляют собой маски
----------------------------
MSQRD, Snapchat, VK, даже Авито — все используют маски.
*рис 11. Примеры масок в snapchat*
Реализовать [простейший вариант маски легко](https://github.com/marsbroshok/face-replace). Берем landmarks, которые получили выше. Выбираем маску, которую хотите применить, и размещаем на ней наши landmarks. При этом существуют простейшие 2D проекции, а есть более сложные 3D маски. Для них вычисляют преобразование точек, которое переведет вершины маски на кадр. Чтобы landmarks, отвечающие за уши, отвечали за уши нашей маски. Далее просто отслеживаем новые положения landmarks лица и меняем нашу маску.
[](https://www.youtube.com/watch?v=&feature=youtu.be "Оригинальное лицо")
[](https://www.youtube.com/watch?v=6X2vD8vt1t4&feature=youtu.be "Маска в виде растянутого лица Арнольда Шварценеггера")
В этой области есть непростые задачи, которые решаются при создании масок. К примеру, сложности отрисовки. Еще сильнее задачу усложняют моменты скачков landmarks, так как в этом случае маски искажаются и будут вести себя непредсказуемо. А так как захват кадров с камеры мобильного телефона — это хаотичный процесс, включающий в себя быструю перемену света, тени, резкие подергивания и так далее, то задача становится весьма трудоемкой. Еще одной проблемой становится построение сложных масок.
Как развлечение или решение простой проблемы это интересно. Но как и в других областях, если вы хотите решать крутые задачи, то придется потратить время на обучение.
В следующей статье
------------------
Решение задач распознавания образов, лиц, автомобильных номеров, пола, возраста становится все более востребованным. IT-компании на этом рынке вводят технологии для решения таких задач постепенно и незаметно для пользователя. [Китай инвестирует 150 млрд в machine learning в течение ближайших лет](https://www.cnbc.com/2017/07/21/china-ai-world-leader-by-2030.html), чтобы стать первым в этой области.
В следующей статье расскажу, как идентифицировать конкретного человека по выделенному лицу и фильтровать нечеткие фотографии перед идентификацией. | https://habr.com/ru/post/343514/ | null | ru | null |
# Учимся надежному управлению Kubernetes
Всем доброго!
Мы возвращаемся к нашей любимой традиции — раздача полезностей, которые мы собираем и изучаем в рамках наших курсов. Сегодня у нас на повестке дня [курс по DevOps](https://otus.pw/rCwU/) и один из его инструментов — [Kubernetes](https://kubernetes.io/).
Недавно мы создали распределенную систему планирования задач ([cron jobs](https://en.wikipedia.org/wiki/Cron)) на базе Kubernetes — новой, захватывающей платформы для оркестрации контейнеров. Kubernetes становится все популярней и дает много обещаний: например, инженерам не придется переживать, на каком устройстве запущено их приложение.
Распределенные системы сложны сами по себе, а управление сервисами на распределенных системах — одна из сложнейших проблем, с которыми сталкиваются команды управления. Мы очень серьезно относимся к вводу нового программного обеспечения в производство и обучению его надежному управлению. В качестве примера важности управления Kubernetes (и почему это так сложно!), почитайте отличный постмортем часового перебоя в работе, вызванного багом в Kubernetes.
В этом посте мы объясним, почему выбрали именно Kubernetes. Изучим процесс его интегрирования в существующую инфраструктуру, метод укрепления доверия (и улучшения) надежности нашего Kubernetes кластера и абстракцию созданную на основе Kubernetes.
Что такое Kubernetes?
---------------------
Kubernetes — распределенная система планирования программ для запуска в кластере. Вы можете сказать Kubernetes запустить пять копий программы, и он динамически запланирует их в ваших рабочих нодах. Контейнеры должны увеличить утилизацию, тем самым экономят средства, мощные [примитивы](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) развертывания позволяют постепенно выкатывать новый код, а [Security Contexts](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/#set-the-security-context-for-a-pod) и [Network Policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) позволяют безопасно запускать multi-tenant рабочие нагрузки.
В Kubernetes встроено множество различных возможностей планирования. Можно планировать длительные службы HTTP, [daemonsets](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/), запущенные на всех машинах вашего кластера, задачи, запускающиеся каждый час, и другое. Kubernetes представляет собой даже больше. И если вы хотите это узнать, посмотрите отличные выступления Kelsey Hightower: можно начать с [Kubernetes для сисадминов](https://www.youtube.com/watch?v=HlAXp0-M6SY) и healthz: [Перестаньте заниматься реверс-инженерингом](https://vimeo.com/173610242) приложений и начните наблюдать их изнутри. Не стоит забывать и про хорошее сообщество в Slack.
Почему именно Kubernetes?
-------------------------
Каждый инфраструктурный проект (я надеюсь!) начинается с потребности бизнеса, и наша задача — улучшить надежность и безопасность существующей системы планирования cron job, которая уже есть. Наши требования следующие:
* Реализация и управление проектом возможны сравнительно небольшой командой (всего 2 человека, работающих full time на этом проекте);
* Возможность планирования около 500 различных задач на 20 машинах;
И вот несколько причин, почему мы выбрали Kubernetes:
* Желание создавать на базе уже существующего open-source проекта;
* Kubernetes включает в себя распределенный планировщик задач, поэтому нам не придется писать свой;
* Kubernetes — активно развивающийся проект, в котором можно принять участие;
* Kubernetes написан на Go, который прост в изучении. Почти все багфиксы по части Kubernetes были произведены программистами, не имеющими предыдущего опыта с Go;
* Если нам удастся управлять Kubernetes, то в будущем мы сможем создавать уже на базе Kubernetes (например, сейчас мы работаем над системой на базе Kubernetes для тренировки моделей машинного обучения).
Раньше в качестве планировщика задач мы использовали [Cronos](https://github.com/mesos/chronos), но он перестал удовлетворять нашим требованиям надежности и сейчас почти не поддерживается (1 коммит за последние 9 месяцев, и последний раз pull request был добавлен в марте 2016 года). Поэтому мы решили больше не вкладываться в улучшение нашего существующего кластера.
Если вы рассматриваете Kubernetes, имейте в виду: не используйте Kubernetes просто потому что, так делают другие компании. Создание надежного кластера требует огромного количества времени, а способ его использования в бизнесе не всегда очевиден. Инвестируйте ваше время с умом.
Что значит “надежный”?
----------------------
Когда дело доходит до управления сервисами, слово “надежный” не имеет смысла само по себе. Чтобы говорить о надежности, сначала нужно установить SLO (service level objective, то есть целевой уровень сервиса).
У нас было три основных задачи:
1. 99.99% задач нужно планировать и запускать в течение 20 минут их запланированного времени работы. 20 минут — довольно большой временной промежуток, но мы опросили наших внутренних клиентов и никто не потребовал большей точности;
2. Задания должны быть выполнены в 99.99% случаев (без прерывания);
3. Наш переезд на Kubernetes не должен вызвать инцидентов на стороне клиента.
Это означало несколько вещей:
* Короткие периоды простоя в API Kubernetes — приемлемы (если оно упало на 10 минут — не критично, если возможно восстановиться в течение 5 минут);
* Планирование багов (когда уже запущенная задача падает или не может запуститься вовсе) — неприемлемо. Мы очень серьезно отнеслись к отчетам планирования багов;
* Нужно быть осторожным с удалением подов и уничтожением инстансов, чтобы задачи не прерывались слишком часто;
* Нам нужен хороший план переезда.
Создание Kubernetes кластера
----------------------------
Базовый подход к созданию первого Kubernetes кластера заключался в создании кластера с нуля, без использования инструментов вроде [kubeadm](https://kubernetes.io/docs/reference/generated/kubeadm/) или [kops](https://github.com/kubernetes/kops). Мы создали конфигурацию с помощью Puppet, нашего стандартного инструмента управления настройкой. Создание с нуля привлекало по двум причинам: мы могли глубоко интегрировать Kubernetes в нашу архитектуру, и мы приобрели широкие знания его внутреннего устройства.
*Построение с нуля позволило нам интегрировать Kubernetes в существующую инфраструктуру.* Мы хотели цельную интеграцию с нашими существующими системами логирования, управления сертификатами, секретов, сетевой безопасности, мониторинга, управления инстансами AWS, развертывания, прокси баз данных, внутренних DNS серверов, управления настройками, и многими другими. Интеграция всех этих систем иногда требовала творческого подхода, но, в целом, оказалась проще потенциальных попыток заставить kubeadm/kops делать то, что нам от них нужно.
Мы уже доверяем и знаем, как управлять существующими системами, поэтому хотели продолжить их использовать в новом Kubernetes кластере. Например, надежное управление сертификатами — очень сложная проблема, но у нас уже сейчас есть способ ее решения. Нам удалось избежать создания нового CA для Kubernetes благодаря грамотной интеграции.
*Мы были вынуждены понять, как именно настраиваемые параметры влияют на нашу установку Kubernetes.* Например, было использовано более дюжины параметров для настройки сертификатов/CA аутентификации. Понимание всех этих параметров облегчило отладку нашей установки при нахождении проблем с аутентификацией.
Укрепление уверенности в Kubernetes
-----------------------------------
В самом начале работы с Kubernetes ни у кого в команде не было опыта его использования (только для домашних проектов). Как же прийти от “Никто из нас никогда не использовал Kubernetes” к “Мы уверены в использовании Kubernetes на продакшне”?
Стратегия 0: Поговорить с другими компаниями
--------------------------------------------
Мы спросили несколько человек из других компаний об их опыте с Kubernetes. Все они использовали его по-разному и в разных окружениях (для запуска HTTP сервисов, на голом железе, на [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/) и т.д.).
Когда речь идет о больших и сложных системах как Kubernetes, особенно важно думать именно о ваших кейсах применения, экспериментировать, находить уверенность в вашем окружении и решать за себя. Например, не стоит после чтения этого поста решать “Ну, в Stripe успешно пользуются Kubernetes, значит и мы сможем!”.
Вот что мы узнали из бесед с различными компаниями, управляющих кластерами Kubernetes:
* Приоритезируйте работу над надежностью вашего etcd кластера (именно в etcd будут храниться состояния вашего Kubernetes кластера);
* Некоторые функции Kubernetes более стабильны, чем другие, так что осторожнее с альфа-функциями. Некоторые компании используют стабильные альфа-функции, после того, как их стабильность подтвердилась более одного релиза подряд (то есть, если функция становится стабильной в 1.8, они ждут 1.9 или 1.10, прежде чем начать ее использовать);
* Присмотритесь к размещенным Kubernetes системам вроде GKE/AKS/EKS. Самостоятельная установка отказоустойчивой системы Kubernetes с нуля — сложная задача. В AWS не было управляемого Kubernetes сервиса во время этого проекта, поэтому мы его не рассматривали;
* Будьте осторожны с дополнительной задержкой сети, вызванной overlay-сетями/программными сетями.
Беседы с другими компаниями, конечно, не дали четкого ответа, подходит ли нам Kubernetes, зато обеспечили нас вопросами и поводами для беспокойств.
Стратегия 1: Прочитать код
--------------------------
Мы планировали сильно зависеть от одного компонента Kubernetes — контроллера cron job. В то время он находился в альфе, что стало небольшим поводом для волнения. Мы проверили его на тестовом кластере, но как можно сказать наверняка, будет ли он нас устраивать на продакшне? К счастью, весь код функционала контроллера состоит из 400 строк Go. Чтение [исходного кода](https://github.com/kubernetes/kubernetes/blob/028c4c9399307834d6ecfff346bacb42bff4a839/pkg/controller/cronjob/cronjob_controller.go) быстро показало, что:
1. Контроллер — сервис без состояний (как и любой другой компонент Kubernetes, за исключением etcd);
2. Каждые 10 секунд этот контроллер вызывает syncAll function: go wait.Until(jm.syncAll, 10\*time.Second, stopCh);
3. Функция syncAll возвращает все задачи из Kybernetes API, проходит через этот список, определяет, какие задачи должны быть запущены следующими, а затем запускает их.
Базовая логика была проста для понимания. Что более важно, если бы в контроллере обнаружился баг, скорее всего мы бы смогли его починить самостоятельно.
Стратегия 2: Провести нагрузочное тестирование
----------------------------------------------
Перед тем как начать строить наш кластер, мы провели нагрузочное тестирование. Нас не беспокоило количество нодов, с которыми мог справиться кластер Kubernetes (планировали разворачивать около 20 нодов), было важно убедиться, что Kubernetes способен выдерживать столько задач, сколько нам нужно (около 20 в минуту).
Мы провели тест на трёхнодовом кластере, где было создано 1000 cron jobs, каждая из которых запускалась раз в минуту. Все задачи просто запускали bash -c 'echo hello world'. Мы выбрали простые задачи, потому что хотели протестировать возможности планирования и оркестрации кластера, а не его общую вычислительную мощность.
Тестовый кластер не смог выдержать 1000 задач в минуту. Мы выяснили, что каждый нод запускает максимум один под в секунду, и кластер мог без проблем запустить 200 задач в минуту. Учитывая, что нам нужно примерно 50 задач в минуту, было решено, что такое ограничение нас не блокировало (и что при необходимости мы могли их решить позже). Вперед!
Стратегия 3: Приоритезировать создание и тестирование отказоустойчивого etcd кластера
-------------------------------------------------------------------------------------
Очень важно при настройке Kubernetes — правильно запустить etcd. Etcd — сердце вашего Kubernetes кластера, именно там хранятся все данным о нем. Все кроме etcd не имеет состояний. Если etcd не запущен, вы не можете внести изменения в ваш Kubernetes кластер (хотя существующие сервисы продолжат работать!).
При запуске стоит держать в голове два важных момента:
* Задайте репликацию, чтобы ваш кластер не умер при потере нода. Сейчас у нас есть три копии etcd;
* Убедитесь, что у вас достаточная пропускная способность I/O. В нашей версии etcd была проблема, что один нод с высокой fsync задержкой мог вызвать длительный выбор лидера, оборачивающийся недоступностью кластера. Мы исправили это, убедившись, что пропускной способностью I/O наших нодов выше, чем количество записей, совершаемых etcd.
Настройка репликации — задача не из разряда сделал-и-забыл. Мы внимательно протестировали, что при потере нода etcd, кластер все равно изящно восстанавливается.
Вот некоторые задачи, которые мы выполнили для настройки etcd кластера:
* Настройка репликации;
* Проверка доступности etcd кластера (если etcd упал, мы сразу должны об этом знать);
* Написание простых инструментов для легкого создания новых etcd нодов и добавления их в кластер;
* Добавление etcd Consul интеграции, чтобы можно было запустить более одного etsd кластера в нашем производственном окружении;
* Тестирование восстановления из резервной копии etcd;
* Тестирование возможности перестроить кластер полностью без простоев.
Мы очень рады, что рано провели тестирование. Одним пятничным утром, в нашем производственном кластере перестал пинговаться один из etcd нодов. Мы получили предупреждение об этом, уничтожили нод, подняли новый, добавили его в кластер и все это время Kubernetes продолжал работать без перебоев. Удивительно.
Стратегия 4: Постепенно перенести задачи в Kubernetes
-----------------------------------------------------
Одной из наших основных целей было перенести задачи в Kubernetes, не вызвав перебоев в работе. Секрет успешного производственного переноса заключается не в безошибочном процессе (это невозможно), а в проектировании процесса таким образом, чтобы снизить вред от ошибок.
Мы были счастливыми обладателями большого разнообразия задач, требующих миграции в новый кластер, поэтому среди них оказались те, что обладали низким уровнем влияния — пара-тройка ошибок в их переносе была приемлемой.
Перед началом миграции мы создали простой в использовании инструмент, позволяющий перемещать задачи между старой и новой системами, менее, чем за пять минут. Этот инструмент снизил ущерб от ошибок — если мы перенесли задачу, обладающую зависимостью, которую мы не планировали, не проблема! Можно просто вернуть ее обратно, исправить проблему и попробовать снова.
Мы придерживались такой стратегии миграции:
1. Примерно распределите задачи по степени их важности;
2. Неоднократно перенесите несколько задач в Kubernetes. При обнаружении новых проблемных мест, быстро откатите, исправьте проблему и попытайтесь еще раз.
Стратегия 5: Исследовать баги Kubernetes (и исправить их)
---------------------------------------------------------
В самом начале проекта мы установили правило: если Kubernetes делает что-то неожиданное, нужно понять почему и предложить исправление.
Разбор каждого бага занимает много времени, но очень важен. Если бы мы просто отмахнулись от странного поведения Kubernetes, решив, что виновата сложность работы распределенной системы, то каждый новый баг заставлял бы думать, что только мы в нем виноваты.
После принятия этого подхода, мы нашли (и пофиксили!) несколько багов в Kubernetes.
Вот несколько проблем, которые мы нашли во время этих тестов:
* Cronjobs с именами длиннее 52 символов молча не справляются с планированием задач (исправлено [здесь](https://github.com/kubernetes/kubernetes/pull/52733));
* Поды могут навсегда зависнуть в Pending состоянии (исправлено [здесь](https://github.com/kubernetes/kubernetes/pull/50028) и [здесь](https://github.com/kubernetes/kubernetes/pull/50106));
* Планировщик [падает](https://github.com/kubernetes/kubernetes/issues/50916) каждые три часа (исправлено [здесь](https://github.com/kubernetes/kubernetes/pull/55262));
* Бэкэнд Flannel hostgw не заменил устаревшие корневые значения (исправлено [здесь](https://github.com/coreos/flannel/pull/803)).
Исправление этих багов помогло нам лучше относиться к использованию Kubernetes в проекте — он не только работал достаточно хорошо, но и принимал патчи и обладал хорошим процессом ревью PR.
Kubernetes полон багов, как и любой софт. К примеру, мы усиленно используем планировщик (потому что наши задачи постоянно создают новые поды), а использование планировщиком кэширования иногда оборачивается багами, регрессией и падениями. Кэширование — это сложно! Но codebase доступный и мы смогли справиться со всеми багами, с которыми столкнулись.
Еще одна достойная упоминания проблема — логика переноса подов в Kubernetes. В Kubernetes есть компонент под названием контроллер нодов, который отвечает за ликвидацию подов и их перенос в другие ноды в случае неотзывчивости. Возможен случай отсутствия ответа от всех нодов (например, при проблеме с сетью и настройкой), тогда Kubernetes может уничтожить все поды в кластере. Мы с этим сталкивались уже в начале тестирования.
Если вы запускаете большой кластер Kubernetes, внимательно прочитайте [документацию](https://kubernetes.io/docs/concepts/architecture/nodes/#node-controller) контроллера нодов, обдумайте настройку и усиленно тестируйте. Каждый раз, когда мы тестировали изменения в конфигурации этой настройки (например, --pod-eviction-timeout) с помощью создания ограничения сети, происходили удивительные вещи. Лучше узнавать о таких сюрпризах из тестирования, а не в 3 утра на продакшне.
Стратегия 6: намеренно создавайте проблемы для Kubernets кластера
-----------------------------------------------------------------
Мы и раньше обсуждали запуск упражнений игрового дня в [Stripe](https://stripe.com/blog/game-day-exercises-at-stripe), и продолжаем это делать сейчас. Идея заключается в том, чтобы придумать ситуации, которые могут произойти в производстве (например, потеря сервера Kubernetes API), а затем специально создать их (во время рабочего дня, с предупреждением), чтобы убедиться в возможности их исправить.
Проведение нескольких упражнений на нашем кластере выявило некоторые проблемы вроде пробелов в мониторинге и ошибок конфигурации. Мы были очень рады найти эти проблемы заранее и в контролируемой среде, а не случайно шесть месяцев спустя.
Некоторые игровые упражнения, которые мы провели:
* Выключение одного сервера Kubernetes API;
* Выключение всех серверов Kubernetes API и их поднятие (на удивление, все сработало хорошо);
* Выключение etcd нода;
* Обрыв рабочих нодов в нашем Kubernetes кластере от API серверов (чтобы они потеряли возможность общаться). В результате все поды из этих нодов были перенесены в другие ноды.
Мы были очень рады увидеть, что Kubernetes достойно выстоял наши поломки. Kubernetes спроектирован быть устойчивым к ошибкам — у него один etcd кластер, в котором хранятся все состояния, API сервер, представляющий собой простой REST интерфейс для базы данных и набор контроллеров без состояний, который координирует управление кластером.
Если любой из корневых компонентов Kubernetes (сервер API, управление контроллеров, планировщик) прерван и перезапущен, то сразу после восстановления он читает состояние из etcd и продолжает работать. Это одна из тех вещей, которая привлекла в теории, и на практике показала себя не хуже.
Вот некоторые проблемы, которые мы нашли во время тестов:
* “Странно, мне не сообщили об это, хотя должны были. Нужно поправить тут наблюдение”;
* “Когда мы уничтожили инстансы API сервера и подняли их обратно, они потребовали человеческого вмешательства. Лучше исправить это”;
* “Иногда, когда мы проверяем отказоустойчивость etcd, API сервер начинает тайм-аутить запросы до тех пор, пока мы его не перезапустим”.
После запуска этих тестов мы внесли правки для найденных проблем: улучшили мониторинг, исправили найденные настройки конфигурации, задокументировали баги Kubernetes.
Делаем cron jobs легкими в использовании
----------------------------------------
Кратко ознакомимся, как мы сделали нашу систему на базе Kubernetes простой в использовании.
Нашей изначальной целью было проектирование системы для запуска задач, которыми наша команда могла с уверенностью управлять. Когда мы стали уверены в Kubernetes, возникла необходимость в простой настройке и добавлении новых cron jobs нашими инженерами. Мы разработали конфигурационный YAML формат, чтобы наши пользователи не нуждались в понимании внутреннего строения Kubernetes для использования нашей системы. Вот этот формат:
```
name: job-name-here
kubernetes:
schedule: '15 */2 * * *'
command:
- ruby
- "/path/to/script.rb"
resources:
requests:
cpu: 0.1
memory: 128M
limits:
memory: 1024M
```
Ничего сложного — просто написали программу, которая берет этот формат и переводит его в [конфигурацию](https://v1-7.docs.kubernetes.io/docs/api-reference/v1.7/#cronjob-v2alpha1-batch) cron job Kubernetes, который мы применяем с kubectl.
Также мы написали тестовый набор для проверки длины (названия задач Kubernetes не может превышать 52 символа) и уникальности названий задач. Сейчас мы не используем [cgroups](https://en.wikipedia.org/wiki/Cgroups) для ограничения объемов памяти в большинстве наших задач, но это есть в планах на будущее.
Наш формат был прост в использовании, а, учитывая, что мы автоматически сгенерировали и cron job’ы Chronos, и cron job’ы Kubernetes, переместить задачи между двумя системами было легко. Это было ключевым элементом в хорошей работе нашей постепенной миграции. Как только перенос задачи в Kubernetes вызывал ошибку, мы могли перенести его обратно простым трехстрочным изменением в конфигурации, менее чем за 10 минут.
Мониторинг Kubernetes
---------------------
Мониторинг внутренних состояний нашего Kubernetes кластера оказался приятным. Мы используем пакет [kube-state-metrics](https://github.com/kubernetes/kube-state-metrics) для мониторинга и небольшую программу на Go под названием [veneur-prometheus](https://github.com/stripe/veneur/blob/master/cmd/veneur-prometheus/main.go) для сбора метрик Prometheus, которые выдает kube-state-metrics и их публикации в виде statsd метрики в нашей системе мониторинга.
Вот, например, график количества Pending подов в нашем кластере за последний час. Pending означает, что они ждут назначения рабочему ноду для запуска. Можно увидеть пик значения в 11 утра, потому что многие задачи запускаются в нулевую минуту часа.
Кроме этого, мы следим, что нет подов, застрявших в состоянии Pending — проверяем, что каждый под запускается в рабочем ноде в течение 5 минут, а иначе получаем предупреждение.
Будущие планы для Kubernetes
----------------------------
Настройка Kubernetes, достижение момента готовности запустить продакшн код и миграция наших cron jobs в новый кластер, заняли у трёх программистов на full-time пять месяцев. Одна из значимых причин, по которой мы вложились в изучение Kubernetes — ожидание более широкого использования Kubernetes в Stripe.
Вот некоторые принципы управления Kubernetes (и любой другой сложной распределенной системой):
* Определите четкую бизнес-причину для вашего Kubernetes проекта (и всех инфраструктурных проектов!). Понимание кейса и нужд пользователей значительно упростило наш проект;
* Агрессивно сокращайте объемы. Мы решили не использовать многие базовые функции Kubernetes для упрощения кластера. Это позволило нам запуститься быстрее — например, с учетом того, что pod-to-pod сеть не была обязательной для нашего проекта, мы смогли ограничить все сетевые соединения между нодами и отложить размышления о сетевой безопасности в Kubernetes до будущего проекта.
* Отведите много времени изучению правильного управления Kubernetes кластера. Внимательно тестируйте острые кейсы. Распределенные системы очень сложны, поэтому многие вещи могут пойти не так. Возьмем пример, описанный ранее: контроллер нодов может убить всех подов в вашем кластере, если они потеряют контакт с API серверами, в зависимости от вашей конфигурации. Изучение поведения Kubernetes после каждого изменения настройки, требует времени и внимательности.
Сохраняя фокус на этих принципах, мы можем с уверенностью использовать Kubernetes в производстве. Наше использование Kubernetes продолжит расти и развиваться — например, с интересом смотрим AWS релизы EKS. Мы завершаем работу над другой системой тренировки моделей машинного обучения, а также рассматриваем вариант перенести некоторые HTTP сервисы на Kubernetes. И в процессе использования Kubernetes в производстве, мы планируем внести свой вклад в open-source проект.
THE END
-------
Как всегда ждём ваши комментарии, вопросы тут или на нашем [Дне открытых дверей](https://otus.pw/AOMY/). | https://habr.com/ru/post/347810/ | null | ru | null |
# Intel Power Monitoring Tool — на страже энергоэффективности
Мы продолжаем разговор об [энергоэффективности мобильных устройств](http://habrahabr.ru/company/intel/blog/184708/) и [приложениях Intel под Android](http://habrahabr.ru/company/intel/blog/185448/). Сегодняшний пост касается обеих тем одновременно, ведь речь пойдет о программе Intel Power Monitoring Tool (Intel PMT) — средстве, позволяющем осуществлять аудит потребляемых ресурсов как системой в целом, так и отдельным приложением. Intel PMT может быть интересен любопытным пользователям Android, желающим все знать о своей системе, но адресована прежде всего разработчикам и служит средством диагностики проблем, не видимых невооруженным глазом.
Итак, [Intel Power Monitoring Tool](https://play.google.com/store/apps/details?id=com.intel.PowerMonitoringTool) является инструментом профилирования данных системы Android, связанных с энергопотреблением и производительностью. С заданным пользователем интервалом приложение записывает действующие значения четырех десятков основных показателей ОС (количество десятков сильно зависит от числа ядер процессора, поскольку именно он находится в центре внимания утилиты). Среди этих значений вы найдете параметры:
* Батареи — состояние, напряжение, ток, потребляемую/получаемую мощность, оставшуюся емкость;
* ЦПУ — частоту и утилизацию каждого ядра, CPU P state residency и CPU C state residency;
* Дисплея — состояние, яркость подсветки
* Интерфейсов Wi-Fi и 3G — скорость передачи в пакетах и битах
* Внешних и внутренних устройств хранения — скорость записи и чтения
Интерфейс приложения суров и не перегружен каким-либо дизайном. Элементы управления исчерпываются буквально несколькими кнопками, реализующими самое необходимое. Можно стартовать процесс записи (он идет в фоне) и остановить его; вывести результаты на дисплей или строку состояния системы; отправить лог программы по почте. Наконец, отдельной кнопокой инициируется мониторинг конкретного приложения, имя которого, в лучших традициях консольных утилит, вводится вручную.
Вывод результатов оформлен еще проще: никаких графических представлений данных, только текстовый формат, только хардкор! Возможно, такой подход и оправдан, ведь профессиональным разработчикам нужна не цветомузыка, а поток цифровых данных, который далее можно обработать в базе данных или табличном редакторе. С другой стороны, с непривычки такой аскетизм выглядит чрезмерным — можно было включить визуализацию хотя бы в виде опции.
Программа пишет свой лог в текстовом формате, его можно получить через подключение к ПК или с помощью электронной почты — соответствующая кнопка есть в интерфейсе. Каждая строчка лога имеет такой вид:
`07:40:21 Status Charging BP 406.30 V 3833 I 106 C 692 CPU0 900 27.00% 17.00% 10.00% CPU1 900 42.00% 39.00% 3.00% CpuPStateResidency 0.00% 1.01% 13.13% 85.86% 0.00% CpuCStateResidency 0.01% 3.44% 41.49% 11.09% 43.98% 0.00% 0.00% On 1 Brightness 15.00% WifiTxPackets 0 WifiRxPackets 0 WifiTxBytes 0 WifiRxBytes 0 ModemTxPackets 0 ModemRxPackets 0 ModemTxBytes 0 ModemRxBytes 0 DiskReadBandwidth 0.00 DiskWriteBandwidth 0.00 EmmcReadBandwidth 0.00 EmmcWriteBandwidth 6.00 SdCardReadBandwidth 0.00 SdCardWriteBandwidth 0.00 youtube PID 3858 AppState 83 AppNumOfThreads 48 AppCpuUserUtil 21.00 AppCpuSystemUtil 2.00 AppCpuUtil 23.00`
Что означает каждое поле, можно выяснить из таблицы.
Последняя секция лога относится к контролируемому приложению, в данном примере им является клиент YouTube.
Каким образом Intel Power Monitoring Tool может быть использован для нужд разработчиков? Приведем с сокращениями пример из [статьи](http://software.intel.com/ru-ru/node/184789?wapkw=intel+power+monitoring+tool), посвященной инструменту, с сайта Intel.
> Предположим, Марк — разработчик приложений для мобильных устройств Android. Он разработал приложение для чтения книг под названием EReader. Ему хотелось бы выяснить, нет ли в его приложении серьезных проблем с энергопотреблением и производительностью. Для этого он решил использовать инструмент Power Monitoring Tool. Изучая полученные данные, он обращает внимание на то, что общая загрузка процессора и загрузка процессора приложением почти достигает 100 % без каких-либо действий пользователя. Он решает проверить данные профилирования, чтобы выяснить, является ли это проблемой. Он извлекает данные Power Monitoring Tool и строит графики загрузки процессора пользовательским приложением и системой, как показано на следующем рисунке. На этом рисунке загрузка процессора пользовательским приложением достигает 50 %, что означает, что приложение полностью использует одно ядро для выполнения кода в пользовательском пространстве.
>
>
>
> 
>
>
>
> Благодаря полученным от инструмента Power Monitoring Tool данным о загрузке процессора приложением Марк определяет, что максимальная загрузка процессора приходится на момент открытия книги. Марк догадывается, что это может быть вызвано фрагментом кода, открывающим электронную книгу. Он проверяет этот фрагмент кода и находит в нем ошибку в виде бесконечного цикла.
Несмотря на некоторую деревянность интерфейса, Intel Power Monitoring Tool может оказаться удобным средством для тех разработчиков, кто скрупулезно следит за энергоэффективностью своих приложений. К сожалению, приложение уже довольно давно (более года) не обновлялось, что приводит к некоторой несовместимости с новым «железом» (о чем программа честно сообщает при запуске). Правда, в случае нашего тестового смартфона Orange AZ210A несовместимость проявила себя только в отсутствии показаний с Wi-Fi интерфейса. Приложение Intel PMT работает под управлением ОС Android 2.3 и выше на платформе Intel Atom. | https://habr.com/ru/post/188420/ | null | ru | null |
# Система сообщений или “мягкая связь” между компонентами для Unity3D
#### Введение
В данной статье будут затронуты темы, связанные с реализацией возможности “мягкой связи” компонентов игровой логики на основе системы сообщений при разработке игр на Unity3D.
Ни для кого не секрет, что в подавляющем большинстве случаев средств, которые предоставляет движок в базовом виде, недостаточно для полноценной реализации систем обмена данными между компонентами игры. В самом примитивном варианте, с которого все начинают, мы получаем информацию через экземпляр объекта. Получить этот экземпляр можно разными способами от ссылки на объект сцены, до функций Find. Это не удобно, делает код не гибким и заставляет программиста предусматривать множество нестандартных поведений логики: от “объект исчез из сцены”, до “объект не активен”. Помимо прочего может страдать и скорость работы написанного кода.
Прежде, чем приступить к рассмотрению способов решения проблемы, остановимся подробнее на ее предпосылках и базовых терминах, которые будут упомянуты ниже. Начнем с того, что подразумевается под “мягкой связью”. В данной случае — это обмен данными между компонентами игровой логики таким образом, чтобы эти компоненты абсолютно ничего не знали друг о друге. Исходя из этого, любые ссылки на объекты сцены или же поиск объекта в сцене по имени или типу дают нам “жесткую связь”. Если эти связи начнут выстраиваться в цепочки, то в случае необходимости изменения поведения логики программисту придется все перенастраивать заново. Как не сложно догадаться, гибкостью здесь и не пахнет. Конечно, можно написать расширение редактора, которое будет автоматически заполнять ссылки, но это не решит другую проблему – покомпонентное тестирование игровой логики.
Для того, чтобы написанное выше было более понятно, рассмотрим простой пример. В логике нашей сферической игры есть несколько компонентов: оружие, враг и пуля. Произведя выстрел из оружия, мы должны получить следующую информацию: попала или нет пуля во врага, если попала, то сколько нанесла врагу урона, если нанесла урон, то умер враг или нет. Помимо этого, мы должны передать часть этой информацию другим компонентам, таким как графический интерфейс, который отобразит нам количество нанесенного урона, количество здоровья у врага и количество боеприпасов в оружии. Сюда же можно отнести отображение соответствующих эффектов выстрела, попадания, а также анимации и т.п… Не трудно представить количество взаимосвязей и передаваемых данных. Реализовать это на “жесткой связи” можно, однако, что будет, если нам нужно протестировать логику пули, если при этом у нас еще нет оружия и нет врагов или же протестировать логику работы интерфейса, но у нас нет при этом ни логики оружия, ни врагов, ни пули, или мы захотели заменить пулю на ракету. Именно решением подобной проблемы и продиктована необходимость создания систем “мягкой связи”, которая позволит нам с легкостью имитировать различные компоненты, даже если их еще не существует, а также менять их без изменения, связанного с ними кода.
Остановимся более подробно на базовом принципе реализации “мягкой связи”. Как было сказано выше, чтобы “мягко” связать два компонента, мы должны передать данные от одного к другому, так, чтобы они не знали ничего друг о друге. Для того, чтобы это обеспечить, нам нужно получить данные не по запросу (имея на руках экземпляр объекта), а использовать механизм уведомлений. Фактически это означает, что при наступлении каких-либо событий в объекте/компоненте, мы не спрашиваем этот объект о его состоянии, объект сам уведомляет о том, что в нем произошли изменения. Набор таких уведомлений формирует интерфейс (не путать с interface в C#), с помощью которого игровая логика получает данные о нашем объекте. Наглядно это можно представить следующим образом:
Таким образом любой компонент системы через интерфейс уведомлений может получить необходимые данные об объекте игровой логике, при этом наличие самого объекта для тестирования связанных с ним компонентов необязательно, нам достаточно реализовать интерфейс, а затем подменить его на рабочий экземпляр.
Рассмотрим более подробно способы реализации описанного выше механизма, а также их плюсы и минусы.
#### Система сообщений на основе UnityEvents/UnityAction
Данная система появилось сравнительно недавно (в 5 версии движка Unity3D). Пример того, как реализовать простую систему сообщений можно посмотреть по этой [ссылке](https://unity3d.com/ru/learn/tutorials/modules/intermediate/live-training-archive/events-creating-simple-messaging-system).
Плюсы использования данного способа:
* Встроенная в Unity возможность.
Минусы:
* Встроенная в Unity возможность (не всегда родные системы лучше).
* Не гибко из-за использования **UnityAction** (хотя это можно обойти), который дает ограничение на количество параметров (четыре максимум).
* Не гибко из-за сложностей с изменением параметров сообщения, так как придется во многих местах кода менять типы, обработчики и т.п..
* Непонятно зачем использовать при наличии в C# **event/delegate**.
#### Классическая система C# на Event/Delegate
Самый простой и достаточно эффективный способ реализации связи компонентов на основе уведомлений — это использование пары **event/delegate**, которая является частью языка C# (подробнее можно почитать в статьях на habr'е или msdn).
Есть много разных вариантов реализации системы сообщений на основе **event/delegate**, некоторые из них можно найти на просторах интернета. Я приведу пример, на мой взгляд, наиболее удобной системы, однако для начала хочу упомянуть об одной важной детали, связанной с использованием event'ов. Если у события (event) нет подписчиков, то при вызове этого события произойдет ошибка, поэтому перед использованием обязательна проверка на null. Это не совсем удобно. Конечно можно написать обертку для каждого event, где будет проводиться проверка на null, но это еще более не удобно. Перейдем к реализации.
**Для начала определяем интерфейс сообщений для нашего объекта логики:**
```
// Message Interface
public partial class GameLogicObject
{
public delegate void StartEventHandler();
public delegate void ChangeHealthEventHandler(int health);
public delegate void DeathEventHandler();
public static event StartEventHandler StartEvent;
public static event ChangeHealthEventHandler ChangeHealthEvent;
public static event DeathEventHandler DeathEvent;
}
```
**Вызов уведомлений делается следующим образом (пример):**
```
public partial class GameLogicObject : MonoBehaviour
{
public int Health = 100;
void Start()
{
if (StartEvent != null)
{
StartEvent();
}
StartCoroutine(ChangeHealth());
}
IEnumerator ChangeHealth()
{
yield return new WaitForSeconds(1f);
Health = Mathf.Clamp(Health - UnityEngine.Random.Range(1, 20), 0, 100);
if (ChangeHealthEvent != null)
{
ChangeHealthEvent(Health);
}
if (Health == 0)
{
if (DeathEvent != null)
{
DeathEvent();
}
}else
{
StartCoroutine(ChangeHealth());
}
}
}
```
**Интерфейс и логика сформированы, теперь ничто не мешает нам использовать его в любом другом месте и подписаться на нужные уведомления:**
```
public class GUILogic : MonoBehaviour
{
public Text HealthInfo;
public Text StateInfo;
void OnEnable()
{
GameLogicObject.StartEvent += GameLogicObject_StartEventHandler;
GameLogicObject.ChangeHealthEvent += GameLogicObject_ChangeHealthEventHandler;
GameLogicObject.DeathEvent += GameLogicObject_DeathEventHandler;
}
private void GameLogicObject_DeathEventHandler()
{
StateInfo.text = "Im died";
}
private void GameLogicObject_ChangeHealthEventHandler(int healthValue)
{
HealthInfo.text = healthValue.ToString();
}
private void GameLogicObject_StartEventHandler()
{
StateInfo.text = "Im going";
}
void OnDisable()
{
GameLogicObject.StartEvent -= GameLogicObject_StartEventHandler;
GameLogicObject.ChangeHealthEvent -= GameLogicObject_ChangeHealthEventHandler;
GameLogicObject.DeathEvent -= GameLogicObject_DeathEventHandler;
}
}
```
Как видно из примера, подписка происходит в методе **OnEnable**, а отписка в **OnDisable** и в данном случае она обязательна, иначе гарантирована утечка памяти и исключения по нулевой ссылке (null reference exception), если объект будет удален из игры. Саму подписку можно осуществлять в любой необходимый момент времени, это не обязательно делать только в **OnEnable**.
Легко заметить, что при таком подходе, мы можем без каких-либо проблем тестировать работу класса **GUILogic**, даже в отсутствии реальной логики **GameLogicObject**. Достаточно написать имитатор, использующий интерфейс уведомлений и использовать вызовы вида **GameLogicObject.StartEvent** ().
Какие плюсы дает нам данная реализация:
* Стандартный механизм языка C#, как итог 100% кроссплатформенность без танцев с бубнами.
* Простота реализации системы (без дополнительных вложений в код).
Минусы:
* Необходимо следить за памятью (отписка от уведомлений). При больших объемах кода, легко забыть отписаться от одного события и потом долго ловить баги.
* Необходимо отписываться от событий, если объект сцены деактивируется на время, в противном случае для него будет вызван обработчик.
* Не гибко из-за сложностей с изменением параметров сообщения, так как придется во многих местах кода менять типы, обработчики, вызовы и т.п..
* Необходимо учитывать, что событие может не иметь подписчиков.
#### Reflection система сообщений с идентификаций на string
Прежде чем приступить к описанию системы и ее реализации, хотелось бы остановиться на предпосылках, которые толкнули на ее создание. До прихода к этим мыслям в своих приложениях я использовал описанную выше систему на основе event/delegate. Те проекты, которые мне пришлось разрабатывать на тот момент, были относительно простые, в них требовалась скорость реализации, минимум багов на тестах, исключение по максимуму человеческого фактора в фазе разработки игровой логики. Исходя из этого, родился ряд некоторых требований относительно обмена данными между компонентами:
* Автоматическая подписка на события.
* Отсутствие необходимости следить за памятью (самоочистка системы).
* Отсутствие необходимости следить за подписчиками, система должна работать даже если их нет.
Итогом недолгих размышлений стало рождение идеи использовать рефлексию через атрибуты методов класса/компонента.
**Идентифицируем метода класса как обработчик события:**
```
[GlobalMessanger.MessageHandler]
void OnCustomEvent(int param)
{
}
```
**GlobalMessanger.MessageHandler** – атрибут, который указывает нам, что метод является обработчиком события. Для того, чтобы определить тип события, которое данный метод обрабатывает, существует два способа (хотя на самом деле может быть и больше):
1. Указывать типа события в параметрах атрибута:
```
[GlobalMessanger.MessageHandler("CustomEvent")]
```
2. Использовать тип события в имени метода с префиксом “On” (или любым другим). Я использую именно этот способ, поскольку в 100% случаях, чтобы не путаться именую методы именно так.
Для того, чтобы осуществить подписку в автоматическом режиме, опять же, существует два способа:
1. Использовать скрипт, которые будет осуществлять поиск всех компонентов на объекте, а затем через рефлексию искать в них методы с атрибутом. Для того, чтобы не добавлять этот скрипт руками, достаточно будет во всех компонентах, где это потребуется, проставить
```
[RequireComponent(typeof(AutoSubsciber))]
```
Я лично считаю этот способ менее удобным, чем второй, поскольку требует лишних телодвижений.
2. Создание обертки над классом MonoBehaviour:
**CustomBehaviour**
```
public class CustomBehaviour : MonoBehaviour
{
private BindingFlags m_bingingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
protected void Subscribe(string methodName)
{
var method = this.GetType().GetMethod(methodName, m_bingingFlags);
GlobalMessanger.Instance.RegisterMessageHandler(this, method);
}
protected void Unsubscribe(string methodName)
{
var method = this.GetType().GetMethod(methodName, m_bingingFlags);
GlobalMessanger.Instance.UnregisterMessageHandler(this, method);
}
protected virtual void Awake()
{
var methods = this.GetType().GetMethods(m_bingingFlags);
foreach(MethodInfo mi in methods)
{
if(mi.GetCustomAttributes(typeof(GlobalMessanger.MessageHandler), true).Length != 0)
{
GlobalMessanger.Instance.RegisterMessageHandler(this, mi);
}
}
}
}
```
Как видно, данная обертка содержит в себе два метода, которые позволяют подписываться и отписываться от события (тип события забирается из имени метода). Они необходимы в случае, если нам нужно осуществить подписку на событие по ходу работы логики. Автоматическая подписка осуществляется в методе Awake. Отписка от событий осуществляется автоматически, но об этом чуть позже.
**Определяем систему менеджмента подписок и вызовов событий:**
```
public class GlobalMessanger : MonoBehaviour
{
private static GlobalMessanger m_instance;
public static GlobalMessanger Instance
{
get
{
if(m_instance == null)
{
var go = new GameObject("!GlobalMessanger", typeof(GlobalMessanger));
m_instance = go.GetComponent();
}
return m\_instance;
}
}
public class MessageHandler : Attribute { }
private class MessageHandlerData
{
public object Container;
public MethodInfo Method;
}
private Hashtable m\_handlerHash = new Hashtable();
}
```
Класс **GlobalMessanger** является обычным компонентом Unity, доступ к которому осуществляется на основе Unity-синглетона. При этом, для этого компонента создается отдельный объект сцены, который существует только внутри нее и будет удален, когда сцена будет выгружена. Поскольку у нас события идентифицируются на основе строк, то информацию о событиях и подписчиках я решил хранить в хеш-таблице.
**Теперь нам нужны методы регистрации/удаления подписчиков:**
```
public void RegisterMessageHandler(object container, MethodInfo methodInfo)
{
var methodName = methodInfo.Name;
var messageID = methodName.Substring(2);
if (!m_handlerHash.ContainsKey(messageID))
{
RegisterMessageDefinition(messageID);
}
var messageHanlders = (List)m\_handlerHash[messageID];
messageHanlders.Add(new MessageHandlerData() { Container = container, Method = methodInfo });
}
public void UnregisterMessageHandler(object container, MethodInfo methodInfo)
{
var methodName = methodInfo.Name;
var messageID = methodName.Substring(2);
if (m\_handlerHash.ContainsKey(messageID))
{
var messageHanlders = (List)m\_handlerHash[messageID];
for (var i = 0; i < messageHanlders.Count; i++)
{
var mhd = messageHanlders[i];
if (mhd.Container == container && mhd.Method == methodInfo)
{
messageHanlders.Remove(mhd);
return;
}
}
}
}
```
**Далее нам нужен метод вызова событий и подписчиков на них:**
```
public void Call(string messageID, object[] parameter = null)
{
if (m_handlerHash.ContainsKey(messageID))
{
var hanlderList = (List) m\_handlerHash[messageID];
for(var i = 0; i < hanlderList.Count; i++)
{
var mhd = hanlderList[i];
var unityObject = (MonoBehaviour)mhd.Container;
if (unityObject != null)
{
if (unityObject.gameObject.activeSelf)
{
mhd.Method.Invoke(mhd.Container, parameter);
}
}
else
{
m\_removedList.Add(mhd);
}
}
for (var i = 0; i < m\_removedList.Count; i++)
{
hanlderList.Remove(m\_removedList[i]);
}
m\_removedList.Clear();
}
}
```
Как видно, при вызове события происходит проверка на существование объекта и на активность объекта. В первом случае, удаленный объект убирается из подписчиков, во втором же игнорируется при вызове методов обработки события. Таким образом, следить за отпиской событий у удаленного объекта не требуется, все осуществляется автоматически. При этом, если объект был временно деактивирован, то не осуществляется отписка от событий и повторная подписка, а также при вызове наличие подписчиков на событие не обязательно.
**Последнее, что требуется от нас, это провести очистку по выгрузке сцены:**
```
void OnDestroy()
{
foreach(var handlers in m_handlerHash.Values)
{
var messageHanlders = (List)handlers;
messageHanlders.Clear();
}
m\_handlerHash.Clear();
m\_handlerHash = null;
}
```
Легко заметить, что описанная выше система не представляет из себя ничего сверхординарного и не несет в себе откровений, однако она проста и удобна и хорошо подходит для относительно небольших проектов.
**Пример использования данной системы:**
```
// Message Interface
public partial class GameLogicObject
{
public static void StartEvent()
{
GlobalMessanger.Instance.Call("StartEvent");
}
public static void ChangeHealthEvent(int value)
{
GlobalMessanger.Instance.Call("ChangeHealthEvent", new object[] { value });
}
public static void DeathEvent()
{
GlobalMessanger.Instance.Call("DeathEvent");
}
}
// Event source
public partial class GameLogicObject : MonoBehaviour
{
public int Health = 100;
void Start()
{
StartEvent();
StartCoroutine(ChangeHealth());
}
IEnumerator ChangeHealth()
{
yield return new WaitForSeconds(1f);
Health = Mathf.Clamp(Health - UnityEngine.Random.Range(1, 20), 0, 100);
ChangeHealthEvent(Health);
if (Health == 0)
{
DeathEvent();
}else
{
StartCoroutine(ChangeHealth());
}
}
}
// Event subsciber
public class GUILogic : MonoBehaviour
{
public Text HealthInfo;
public Text StateInfo;
[GlobalMessanger.MessageHandler]
private void OnDeathEvent()
{
StateInfo.text = "Im died";
}
[GlobalMessanger.MessageHandler]
private void OnChangeHealthEvent(int healthValue)
{
HealthInfo.text = healthValue.ToString();
}
[GlobalMessanger.MessageHandler]
private void OnStartEvent()
{
StateInfo.text = "Im going";
}
}
```
Думаю, сразу заметно насколько сократился код по сравнению с event/delegate, что меня лично радует.
Какие плюсы дает нам данная реализация:
* Автоматическая подписка на события.
* Нет необходимости следить за отпиской от событий (даже в случае ручной подписки).
* Относительно простая реализация.
* Удобное чтение кода, по атрибутам легко видно, кто является обработчиком событий и каких именно.
* Меньший объем кода по сравнению с event/delegate
* Нет необходимости думать о том, что у события нет подписчиков.
Минусы:
* Поскольку отписка от событий происходит в отложенном режиме, на очень больших проектах, возможно это будет забирать лишнюю память, но это легко решаемо за счет ручной отписки событий, аналогично тому как это было показано в разделе про event/delegate.
* Привязка к строкам, так как если захочется сделать имя события более красивым, придется менять его во многих местах.
* Нет гибкости по параметрам и типам данных событий, изменения требует многих действий по коду.
* Возможны проблемы с кроссплатформенностью из-за использования рефлексии.
#### Reflection система сообщений с идентификаций на типах данных
В предыдущем разделе была описана система более удобная (на мой взгляд) по сравнению с **event/delegate**, однако она все также имеет ряд недостатков, которые сильно влияют на гибкость нашего кода, поэтому следующим шагом было ее развитие с учетом этих факторов.
Итак, нам нужно сохранить все плюсы предыдущей системы, но сделать ее гибче и более устойчивой к возможным изменениям в игровой логике. Поскольку основная проблема — это изменения имени события и передаваемых параметров, то возникла идея идентифицировать события именно по ним. Фактически это означает, что любое событие, которое возникает в компоненте характеризуется ничем иным, как данными, которые оно передает. Поскольку мы не можем просто привязаться к стандартным типам (int, float и т.п.), потому что в логике такие данные могут передавать многие компоненты, то логичным шагом было сделать обертку над ними, которая была бы удобной, легко читаемой и однозначно интерпретирующей событие.
**Таким образом, наш интерфейс сообщений принял следующий вид:**
```
public partial class GameObjectLogic
{
[GEvents.EventDescription(HandlerRequirement = GEvents.HandlerRequirementType.NotRequired)]
public sealed class StartEvent : GEvents.BaseEvent { }
[GEvents.EventDescription(HandlerRequirement = GEvents.HandlerRequirementType.Required)]
public sealed class ChangeHealthEvent : GEvents.BaseEvent
{
public int Value { get; private set; }
public ChangeHealthEvent(int value)
{
Value = value;
}
}
[GEvents.EventDescription(HandlerRequirement = GEvents.HandlerRequirementType.Required)]
public sealed class DeathEvent : GEvents.BaseEvent { }
}
```
Как видно, у событий появились атрибуты. Это дает нам возможность получить отладочную информацию, в случае, если событие требует подписчика, а в коде его по каким-то причинам нет.
Метод вызова событий Call (и его перегрузки), который ранее у нас был частью класса **GlobalMessanger**, теперь является статическим и находится в **GEvents.BaseEvent** и принимает теперь в качестве параметра экземпляр класса, описывающего тип события.
**Код вызова уведомлений теперь будет таким:**
```
public partial class GameLogicObject : MonoBehaviour
{
public int Health = 100;
void Start()
{
StartEvent.Call(); //вызов уведомления о событии
StartCoroutine(ChangeHealth());
}
IEnumerator ChangeHealth()
{
yield return new WaitForSeconds(1f);
Health = Mathf.Clamp(Health - UnityEngine.Random.Range(1, 20), 0, 100);
ChangeHealthEvent.Call(new ChangeHealthEvent(Health)); //вызов уведомления о событии
if (Health == 0)
{
DeathEvent.Call(); //вызов уведомления о событии
}else
{
StartCoroutine(ChangeHealth());
}
}
}
```
Подписка и отписка на события, осуществляется тем же самым способом, что и ранее, через атрибуты методов, однако теперь идентификация типа события происходит не по строковому значению (имя метода или параметр атрибута), а по типу параметра метода (в примере это классы StartEvent, ChangeHealthEvent и DeathEvent).
**Пример метода обработчика:**
```
[GEvents.EventHandler]
public void OnDeathEventHandler(GameLogicObject.DeathEvent ev)
{
//выполняем действия связанные с событием
}
```
Таким образом, используя описанную выше реализацию, мы получили максимально возможную гибкость в коде, поскольку теперь мы можем как угодно менять передаваемые данные в событиях без значительных затрат, нам достаточно изменить тело обработчика под новые параметры. В случае же, если мы захотим изменить имя события (имя класса), компилятор скажет нам в каких местах кода используется старый вариант. При этом необходимость менять имя метода обработчика полностью отпадает.
#### Итог
Я постарался описать в этой статье все возможные на мой субъективный взгляд способы построения систем обмена данными между компонентами на основе уведомлений. Все эти способы были использованы мной в разных проектах и разной сложности: от простых мобильных проектов, до сложных PC. Какую систему использовать в вашем проекте – решать только вам.
PS: я намеренно не стал описывать в статье построение системы сообщения на основе SendMessage-функций, поскольку по сравнению с остальными она не выдерживает критики не только по удобству, но и по скорости работы. | https://habr.com/ru/post/282524/ | null | ru | null |
# GPSS-WORLD основы имитационного моделирования на живых примерах
Доброй пятницы уважаемые читатели Хабра.
В данном посте я предлагаю вам бегло ознакомиться с возможностью создания имитационной модели процессов в программе GPSS-WORLD. Данный пост нельзя считать полноценным туториалом, но я поделюсь с Вами теми крупицами, что знаю и вполне возможно что уже через пол часа после прочтения статьи Вы проявив фантазию создадите свою собственную имитационную модель. Как говориться в народе: «Тяжело в учении легко в бою».
И пусть местами, данный «туториал» придерживается принципа: «битый не битого везет», но я всё же донесу до вас те знания, которые у меня есть, ну а вы уж сами вольны решать, стоить ли мне доверять или лучше проверять. В любом случае я буду рад аудиту кода от знатоков GPSS-WORLD. Все материалы статьи размещены на [GItHub](https://github.com/bosonbeard/Funny-GPSS-world-models)
**Изучать самые азы будем сразу на живых примерах** — доступных, понятных и близких сердцу многим сотрудникам проводящим свои законные 8 часов в офисах.
От конкретики перейдем к лирике, пятница традиционно располагает задаваться безумными вопросами, и в этот раз мы с моим коллегой [DrZugrik](https://habr.com/ru/users/drzugrik/) задались вопросом: «Сколько нужно сотрудников тех поддержки, чтобы рассказать, как вкрутить лампочку?».
За подробностями сего мысленного эксперимента прошу под кат.
*Написание этого мини туториала вместе с разработкой моделей заняло 6 часов чистого времени.
буду признателен если статья доберется до потенциально заинтересованных читателей.*
Во избежания вызова негативных эмоций первоначальная картинка заменена на кота с трубкой и спрятана под спойлер.
**первоначальная иллюстрация**
Для начала нам понадобиться сам [GPSS-World](http://www.minutemansoftware.com/downloads.asp).
Мы будем использовать бесплатную версию для студентов.
Также при изучении языка имитационного моделирования будет полезен учебник
Можно взять вот [этот](http://simulation.su/uploads/files/default/2007-uch-posob-bronov-1.pdf) .
На мой взгляд, не очень доступно, но лучше чем ничего.
Итак необходимым инструментарием мы запаслись, теперь осталось подключить фантазию и придумать первую модель.
Меня никак нельзя назвать гуру имитационного моделирования в целом и GPSS-World в частности, подосновой для примеров приведенных тут служили материалы из этой [книги](http://www.centrmag.ru/book2815979.html) . Но думаю, что составляемые модели имеют право на жизнь.
Давайте для начала рассмотрим такой случай.
Дано:
Офис в котором работает 10 сотрудников, Кулер в конце коридора до которого «шкваркать 4 минуты», сотрудники которые желают испить чаю и совершают путешествие к кулеру один раз в час. Время наполнения чаши с пакетиком живительной влагой составляет примерно 2 минуты. Рабочий день составляет 480 минут (8 часов без перерыва на обед так сказать)
Определить:
Коэффициент использования кулера сотрудниками офиса.
Создадим имитационную модель
```
GENERATE ,,,10 ; 1 Amount office staff
ADVANCE 4,0.8 ; 2 Time to reach the cooler
DRINK QUEUE STAND ; 3 Queue to the cooler. input
SEIZE COOLER ; 4 Verification of employment cooler
DEPART STAND ; 5 Queue to the cooler. output
ADVANCE 2,0.8 ; 6 Filling the cup with boiling water
RELEASE COOLER ; 7 leave the cooler
ADVANCE 60,10 ; 8 Time for tea, time to work, time to get back to the cooler
TRANSFER ,DRINK ; 9 Go back to the cooler
GENERATE 480 ; 10 Working day (minutes)
TERMINATE 1 ; 11 Minus one minute
START 1 ; 12 Start from the first minute
```
Поскольку комментарии я оставлял на своем ломаном английском, то безусловно вижу смысл детально рассказать о функционировании модели.
Строка 1 — GENERATE ,,,10 — сам по себе блок GENERATE задает нам количество входящих требований (в данном случае сотрудников офиса), запись операторов вида ,,,10 говорит нам о том что первые три параметра пропущены, а четвертый параметр указывает на максимальное количество входящих требований. Блок GENERATE. Можно задать и с другими параметрами, но об этом я расскажу немного позже.
Как вы догадались " ;" — отделяет поле комментария. Еще немного о конструкции оформления кода, код читается слева направо, есть несколько блоков, которые желательно разделять табуляцией. Самый левый блок это метка (аналогична метке в др. языках программирования), затем идет сам блок (например generate) затем обычно идут его параметры, затем комментарии. Когда-то давно нас учили разделять эти блоки табуляцией, но это скорее вопрос эстетики. 1 пробела кажется тоже достаточно что бы все запустилось. Кстати там где написано все БОЛЬШИМИ буквами, лучше так и писать, а то может вылететь ошибка при исполнении.
Строка 2 — ADVANCE 4,0.8; Отвечает за временные характеристики процесса, чтобы было понятней в данном случае это значит, что работник идет к кулеру 4 минуты ± 0.8 минуты.
Таким образом первая цифра означает затраченные единицы времени (итерации), вторая цифра означает отклонение в большую или меньшую сторону, в книгах написано что значение отклонения генерируется случайным образом, может это и так, но каждый перезапуск система выдает одинаковые значения (не знаю может быть есть аналог randomize из старого доброго паскаля, но я его не нашел).
Блок ADVANCE также можно задать с другими значениями, но об этом чуть позже.
Строка 3 — DRINK QUEUE STAND; — вот тут мы встречаем нашу первую метку DRINK, после которой следует блок QUEUE, который создает очередь в эту очередь у нас будут попадать все кто направляется к кулеру промочить горло,. STAND – это скажем так идентификатор очереди.
Строка 4 — SEIZE COOLER – блок SEIZE определяет свободно ли наше устройство, в данном случае идентификатор устройства COOLER (ну или попросту кулер).
Строка 5 DEPART STAND — если прошлый блок дал нам положительный результат (кулер свободен), то срабатывает следующий за ним блок DEPART, который обеспечивает выход человека из очереди STAND.
Строка 6 — ADVANCE 2,0.8 человек, который вышел из очереди будет наливать себе примерно 2 минуты кипяток в кружку (ну плюс успеет поболтать с людьми в очереди к кулеру)
Строка 7 — RELEASE COOLER, сделав свое «мокрое» дело, человек освободит устройство COOLER, для следующего страждущего.
Строка 8 — ADVANCE 60,10 – данный блок учитывает время. Которое человек испивший воды, затратит на то чтобы собраться с силами и прийти к кулеру еще раз (по крайней мере я надеюсь, что моделируется именно это).
Строка 9 — TRANSFER ,DRINK – «И повторится все, как встарь» — сказал бы А. Блок, если бы был знаком с программированием. Данный оператор обеспечивает переход на метку DRINK.
Строка 10 – GENERATE 480 казалось бы с точки зрения программирования после перехода на метку в прошлом блоке, все что лежит ниже не имеет смысла, но это не так.(а почему так, я если честно не сильно вникал, но судя по опыту и выпадающим ошибкам, этот кусок воспринимается немного вне контекста предыдущих 8 блоков). Главное, что данный блок задает нам время выполнения всей модели, а именно 480 минут (8 часов)
Строка 11 — TERMINATE 1 – Этот бок вычитает из каждой счетчика итераций единицу. Без этого блока можно уйти в бесконечный цикл.
Строка 12 — START 1 – Говорит программе с какого момента цикла начать, мы начинаем с первой минуты.
Ух, ну вот мы и закончили с описанием первой модели.
Кому интересны результаты, прошу под спойлер. Если вы любите все проверять самостоятельно то еще раз напомню все модели выложены на [GItHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/1.GPSS_SciLab_Maxima)
**результаты Модель 1 - коэффициент использования кулера**
проанализируем результаты
Итак мы видим, что в среднем наш кулер загружен на 33%, то есть в нашей команде из 10 сотрудников получается примерно так как если бы к нему постоянно прикладывался Администратор Петр, Марья Васильевна из бухгалтерии и Менеджер проекта Василий Чуфыркин, ну и еще 0.33 человека, или например — кот. На самом деле этот блок текста не несет смысловой нагрузки, мне просто очень хотелось нарисовать кота и кулер и Марью Васильевну из бухгалтерии (все кроме кота личности сугубо выдуманные)
Хотя черт побери после того как я прочел [это](http://habrahabr.ru/post/191960/)), могу смело утверждать, что кулер мог бы напоить 12 милых котиков =)
Но вернемся к теме.
Давайте рассмотрим, результаты выдачи.
Facility – это список всех наших работающих устройств, в данном случае только кулер.
Entries 79 – означает число подходов на обслуживание к устройству, в данном случае число человек с пустыми чашками составило 79 – за всю рабочую смену.
Util – коэффициент использования оборудования, Он говорит нам о том, что кулер бездествовал (1-0.33)\*100%=67% всего времени.
AVE. TIME – среднее время использования кулера 1 человеком 2.002 минуты
AVAIL. – Доступность кулера, не знаю что это значит видимо еденица говрит, что он был доступен
DELAY = 0 – говрит нам о том, что чсло людей которые просто подошли к кулеру, расстроились и ушли с пустыми руками (кружкой), равно нулю.
Теперь переедем к нашей очереди (QUEUE)
Как видите тут указано имя созданной нами ранее очереди,
В которой максимально находилось 9 человек, в которую было 79 входов, и 48 нулевых входов (по всей видимости входов без ожидания в очереди), среднее время проведенное человеком в очереди равно 1.5 минуты. Cont. = 0 говорит нам о том, что на момент окончания моделирования в очереди никого не было.
Ну вот вроде бы все не плохо, но что будет если мы вернемся в сытый 2006
Год и наймем еще 30 сотрудников в наш офис?
**результаты Модель 1 - коэффициент использования кулера при 40 сотрудниках**
Как видно из модели, наш кулер почти перестанет простаивать, а среднее время в очереди составит аж 20 минут, что наводит на мысли либо о том, что нужен второй кулер, либо о том, что пора всех лишать премии за долгие чаепития.
Может быть данная модель, простовата, но даже она при проявлении некоторой фантазии позволяет нам оценить количество кулеров которое необходимо на этаже.
Но на текущий момент мы с вами еще не умеем, разрабатывать многоканальные модели обслуживания. Так убьем же двух зайцев, научимся многоканальному обслуживанию и заодно ответим на вопросов, которым мы с коллегой задались в самом начале статьи. (кто внимательный и помнит — молодец, тому счастья добра и безпохмельных выходных: )
При создании модели операторы call центра и абоненты, зададимся такими условиями
Дано:
2 оператора техподдержки обслуживают пользовталей, которые звонят пимерно раз в две минуты, Если один оператор занят трубку берет другой. Рабочий день составляет 480 минут (8 часов без перерыва на обед так сказать)
Определить:
Коэффициент загруженности сотрудников службы поддержки.
```
HELPDESK STORAGE 2 ;1 Number of operators helpdesk
**************************************************************************************************
GENERATE 6,3 ;2 The number of subscribers Ticket
ADVANCE (Exponential(1,0,2)),, ;3 during dialing
ENTER HELPDESK ;4 incoming call
TRANSFER ALL,OPR1,OPR2,3 ;5 definition of operator availability
OPR1 SEIZE OP1 ;6 Verification of employment operator number 1
ASSIGN 1,OP1 ;7 If the operator is free in this case, accept a call
TRANSFER ,COME ;8 Jump to the process of service
OPR2 SEIZE OP2 ;9 Verification of employment operator number 1.
ASSIGN 1,OP2 ;10 If the operator is free in this case, accept a call
COME LEAVE HELPDESK ;11 Beginning the process of providing technical support
ADVANCE 10,8 ;12 Service time
RELEASE P1 ;13 The release of the operator
TERMINATE 0 ;14 Removes the Active Transaction from the simulation
GENERATE 480 ;15 Working day (minutes)
TERMINATE 1 ;16 Minus one minute
START 1 ;17 Start from the first minute
```
Как и в прошлый раз опишу построчно
Строка 1 — HELPDESK STORAGE 2 – Создаем накопитель Служба поддержки емкостью 2 сотрудника
Строка 2 — GENERATE 6,3; вот мы и подошли к другому способу задачи блока генерации, в даннмо случае цифра 6 означает что примерно раз в 6 мнут появляется 1 звонок, цифра 3 означает что отклонения от шести минут составлят ± 1.5 минуы. Еще блок GENERATE можно было задать так
(Exponential(1,0,6)), вообще то что справедливо для ADVANCE, во многом справедливо и для GENERATE.
Строка 3 – ADVANCE (Exponential(1,0,2)),, — говорит нам о том сколько времени у звонящего уходит на то чтобы вспомнить телефон тех поддержки и набрать номер, а уходит у нас в среднем 2 минуты по экспоненциальному распределению. цифра 1 – выбирает генератор случайных чисел (от 1-7 как с ними работать я не разобрался), цифра 0 – определяет смещение (пока для меня тоже загадка), цифра 2 собственно минуты. Хочу добавить что существуют и другие законы распределения, по которым можно задать временной промежуток, но о них лучше почитать в учебнике. Который я указал вначале статьи.
Строка 4 — ENTER HELPDESK – вход в накопитель (входящий звонок)
Строка 5 — TRANSFER ALL,OPR1,OPR2,3 – говорит нам что данное событие обрабатывается для всех входящих вызовов (ALL), что операторы обработки начинаются с метки OPR1 и движутся с шагом в 3 блока пока не доберутся до метки OPR2
Строка 6 — OPR1 SEIZE OP1 — вот и наш первая метка, на которой происходит проверка занятости первого оператора службы поддержки (OP1)
Строка 7 — ASSIGN 1,OP1 – В случае если оператор 1 свободен. То мы передаем входящий звонок ему, если нет то через три строки (от 6-й) идем на строку 9
Строка 8 — TRANSFER ,COME — нет нужды узнавать о занятости второго оператора, переходим на метку COME
Строка 9 OPR2 SEIZE OP2 — если первый оператор был занят, проверяем второго
Строка 10 — - ASSIGN 1,OP2 – и отдаем звонок ему.
Строка 11 — COME LEAVE HELPDESK – звонок покидает накопитель служб поддержки
Строка 12 — ADVANCE 10,8 – время которое оператор затрачивает на то чтобы дать человеку совет как правильно вкрутить лампочку.
Строка 13 — RELEASE P1; — оператор помог человеку и освободился. P1 в данном случае это ссылка на некий указатель (или параметр ), этот момент я не могу объяснить, но он работает.
Строка 14 – TERMINATE – (ноль можно не писать по умолчанию и так ноль), если верить справки то в данном случае этот блок расскажет системе о том, что пора выводить эту итерацию из активного цикла и переходить к следующей. В любом случае без него система выдаст нам ошибку.
Строки 15- 17 аналогичны строкам первой модели.
В результате получим следующие данные
**результаты Модель 2 - коэффициент использования операторов**
Структура вывода похожа на структуру вывода первой модели, разве что вместо очереди — накопитель предлагаю вам с ней разобраться самостоятельно. Кстати параметры генерации отчета можно настроить (на этом компьютере у меня не установлен GPSS и нет желания его ставить, поэтому поверьте пока на слово, что в настройках программы есть такая возможность ну, а я если не забуду допишу в понедельник сюда, как это сделать)
Итак, мы видим, что наши операторы вполне приемлемо загружены примерно на 75% и 87 % соответственно. Будем считать, что двух операторов вполне достаточно, чтобы посоветовать людям как правильно вкрутить лампочку. Но мы же с вами — народ любопытный, давайте посмотрим, что будет если к ребятам подсадить еще одно нахлебника с телефоном.
Для этого рассмотрим немного модифицированную модель. Предлагаю вам разобраться с ней самостоятельно.
```
HELPDESK STORAGE 3 ;1 Number of operators helpdesk
**************************************************************************************************
GENERATE 6,3 ;2 The number of subscribers Ticket
ADVANCE (Exponential(1,0,2)),, ;3 during dialing
ENTER HELPDESK ;4 incoming call
TRANSFER ALL,OPR1,OPR3,3 ;5 definition of operator availability
OPR1 SEIZE OP1 ;6 Verification of employment operator number 1
ASSIGN 1,OP1 ;7 If the operator is free in this case, accept a call
TRANSFER ,COME ;8 Jump to the process of service
SEIZE OP2 ;9 Verification of employment operator number 1.
ASSIGN 1,OP2 ;10 If the operator is free in this case, accept a call
TRANSFER ,COME ;11 Jump to the process of service
OPR3 SEIZE OP3 ;12 Verification of employment operator number 1.
ASSIGN 1,OP3 ;13 If the operator is free in this case, accept a call
COME LEAVE HELPDESK ;14 Beginning the process of providing technical support
ADVANCE 10,8 ;15 Service time
RELEASE P1 ;16 The release of the operator
TERMINATE 0 ;17 Removes the Active Transaction from the simulation
GENERATE 480 ;18 Working day (minutes)
TERMINATE 1 ;19 Minus one minute
START 1 ;20 Start from the first minute
```
Результат под спойлером
**результаты Модель 2 - коэффициент использования трех операторов**
Что же в итоге мы видим, что третий оператор нам явно не нужен и можно смело идти и убирать вакансию, а вместе с ней и всех кандидатов.
На последок хочется вам рассказать о том, что GPSS-WORLD представляет более обширные возможности для моделирования, чем те о которых я вам поведал. Просто ввиду ограниченности моих знаний я не могу вам их адекватно продемонстрировать. Но, тем не менее в качестве бонуса приведу пример работы с переменными
```
INITIAL X$APPLES,3 ;1 Set Variable
GENERATE 1 ;2 set count of cicles
SAVEVALUE APPLES-,1 ;3 set APPLES=APPLES-1
TERMINATE 1 ;4 delete one iteration
START 1 ;5 1 Start from the first cicle
```
Давайте опять построчно
Строка 1 — INITIAL X$APPLES,3 ;1 задаем значение переменной, X$ в данном случае нам как-то указывает на название переменной, а цифра три это значение которое мы запишем в переменю APPLES (кстати я не фанат продукции APPLE просто в тот момент на общем столе лежало 3 яблока, а одно я забрал себе, прям как в детсадовских задачах по математике)
Строка – 2 GENERATE 1 – создадим 1 итерацию
Строка 3 — SAVEVALUE APPLES-,1; – сохраним в переменную яблоки ее значение минус один.
Строки 4-5 помогут нам закончить программу.
**результаты Модель 3 - переменные**
Если честно не смотря на то, что данный пример работает и из переменной действительно вычитается единица, полного механизма работы с переменными я не понимаю, поэтому оставлю на откуп профессионалам.
Ну что же теперь вы знаете об одном из инструментов с помощью, которого можно создать имитационную модель процесса, инструмент не самый удобный и уже похоже не дорабатываемый разработчиками, но тем не менее если вы проявите фантазию то за один два дня сможете провести исследование какой-нибудь модели и например опубликовать его в научном журнале или на конференции (об этом я уже [писал раньше](http://habrahabr.ru/post/184894/) )
В любом случае теперь у вас есть еще 1 инструмент, чтобы творить, развиваться и делать мир лучше. Право слово это интереснее чем лопать шарике на смартфоне, сидя в общественном транспорте.
Всем хороших выходных, счастья добра и удачи :) | https://habr.com/ru/post/192044/ | null | ru | null |
# Process Mining без PM4PY
Построить граф по логам процесса очень просто. В распоряжении аналитиков в настоящее время достаточное многообразие профессиональных разработок, таких как Celonis, Disco, PM4PY, ProM и т.д., призванных облегчить исследование процессов. Намного сложнее найти отклонения на графах, сделать верные выводы по ним.
Что делать, если некоторые профессиональные разработки, зарекомендовавшие себя и представляющие особый интерес не доступны по тем или иным причинам, или вам хочется больше свободы в расчетах при работе с графами? Насколько сложно самим написать майнер и реализовать некоторые необходимые возможности для работы с графами? Сделаем это на практике с помощью стандартных библиотек Python, реализуем расчеты и дадим с их помощью ответы на детальные вопросы, которые могли бы заинтересовать владельцев процесса.
Сразу хочется оговориться, что решение, приведенное в статье, не является промышленной реализацией. Это некоторая попытка начать работать с логами самостоятельно с помощью простого кода, который понятно работает, а значит, позволяет легко его адаптировать. Это решение не стоит использовать на больших данных, для этого требуется существенная его доработка, например, с применением векторных вычислений или путем изменения подхода к сбору и агрегации информации о событиях.
Перед построением графа, необходимо выполнить расчеты. Собственно расчет графа и будет тем самым майнером, о котором говорилось ранее. Для выполнения расчета необходимо собрать знания о событиях — вершинах графа и связях между ними и записать их, например в справочники. Заполняются справочники с помощью процедуры расчета calc ([код на github](https://github.com/RomanKrekhno/processmining_example)). Заполненные справочники передаются в качестве параметров процедуре отрисовки графов draw (см. код по ссылке выше). Эта процедура форматирует данные, в представленный ниже вид:
```
digraph f {"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit APPROVED by ADMINISTRATION (4839)" [label=4829 color=black penwidth=4.723857205400346]
"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit REJECTED by ADMINISTRATION (83)" [label=83 color=pink2 penwidth=2.9590780923760738]
"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit REJECTED by EMPLOYEE (231)" [label=2 color=pink2 penwidth=1.3410299956639813]
…
start [color=blue shape=diamond]
end [color=blue shape=diamond]}
```
и передает его для отрисовки графическому движку Graphviz.
Приступим к построению и исследованию графов с помощью реализованного майнера. Будем повторять процедуры чтения и сортировки данных, расчета и отрисовки графов, как в приведенных ниже примерах. Для примеров взяты логи событий по международным декларациям из соревнования BPIC2020. [Ссылка на соревнование.](https://icpmconference.org/2020/bpi-challenge/)
Считаем данные из лога, отсортируем их по дате и времени. Предварительно формат .xes преобразован в .xlsx.
```
df_full = pd.read_excel('InternationalDeclarations.xlsx')
df_full = df_full[['id-trace','concept:name','time:timestamp']]
df_full.columns = ['case:concept:name', 'concept:name', 'time:timestamp']
df_full['time:timestamp'] = pd.to_datetime(df_full['time:timestamp'])
df_full = df_full.sort_values(['case:concept:name','time:timestamp'], ascending=[True,True])
df_full = df_full.reset_index(drop=True)
```
Выполним расчет графа.
```
dict_tuple_full = calc(df_full)
```
Выполним отрисовку графа.
```
draw(dict_tuple_full,'InternationalDeclarations_full')
```
После выполнения процедур получим граф процесса:
Так как полученный граф не читаем, упростим его.
Есть несколько подходов к улучшению читаемости или упрощению графа:
1. использовать фильтрацию по весам вершин или связей;
2. избавиться от шума;
3. сгруппировать события по схожести названия.
Применим 3 подход.
Создадим словарь объединения событий:
```
_dict = {'Permit SUBMITTED by EMPLOYEE': 'Permit SUBMITTED',
'Permit APPROVED by ADMINISTRATION': 'Permit APPROVED',
'Permit APPROVED by BUDGET OWNER': 'Permit APPROVED',
'Permit APPROVED by PRE_APPROVER': 'Permit APPROVED',
'Permit APPROVED by SUPERVISOR': 'Permit APPROVED',
'Permit FINAL_APPROVED by DIRECTOR': 'Permit FINAL_APPROVED',
'Permit FINAL_APPROVED by SUPERVISOR': 'Permit FINAL_APPROVED',
'Start trip': 'Start trip',
'End trip': 'End trip',
'Permit REJECTED by ADMINISTRATION': 'Permit REJECTED',
'Permit REJECTED by BUDGET OWNER': 'Permit REJECTED',
'Permit REJECTED by DIRECTOR': 'Permit REJECTED',
'Permit REJECTED by EMPLOYEE': 'Permit REJECTED',
'Permit REJECTED by MISSING': 'Permit REJECTED',
'Permit REJECTED by PRE_APPROVER': 'Permit REJECTED',
'Permit REJECTED by SUPERVISOR': 'Permit REJECTED',
'Declaration SUBMITTED by EMPLOYEE': 'Declaration SUBMITTED',
'Declaration SAVED by EMPLOYEE': 'Declaration SAVED',
'Declaration APPROVED by ADMINISTRATION': 'Declaration APPROVED',
'Declaration APPROVED by BUDGET OWNER': 'Declaration APPROVED',
'Declaration APPROVED by PRE_APPROVER': 'Declaration APPROVED',
'Declaration APPROVED by SUPERVISOR': 'Declaration APPROVED',
'Declaration FINAL_APPROVED by DIRECTOR': 'Declaration FINAL_APPROVED',
'Declaration FINAL_APPROVED by SUPERVISOR': 'Declaration FINAL_APPROVED',
'Declaration REJECTED by ADMINISTRATION': 'Declaration REJECTED',
'Declaration REJECTED by BUDGET OWNER': 'Declaration REJECTED',
'Declaration REJECTED by DIRECTOR': 'Declaration REJECTED',
'Declaration REJECTED by EMPLOYEE': 'Declaration REJECTED',
'Declaration REJECTED by MISSING': 'Declaration REJECTED',
'Declaration REJECTED by PRE_APPROVER': 'Declaration REJECTED',
'Declaration REJECTED by SUPERVISOR': 'Declaration REJECTED',
'Request Payment': 'Request Payment',
'Payment Handled': 'Payment Handled',
'Send Reminder': 'Send Reminder'}
```
Выполним группировку событий и отрисуем граф процесса еще раз.
```
df_full_gr = df_full.copy()
df_full_gr['concept:name'] = df_full_gr['concept:name'].map(_dict)
dict_tuple_full_gr = calc(df_full_gr)
draw(dict_tuple_full_gr,'InternationalDeclarations_full_gr'
```
После группировки событий по схожести названия читаемость графа улучшилась. Попробуем найти ответы на вопросы. [Ссылка на список вопросов.](https://icpmconference.org/2020/bpi-challenge/) Например, скольким декларациям не предшествовало предодобренное разрешение?
Для ответа на поставленный вопрос отфильтруем граф по интересующим событиям и отрисуем граф процесса еще раз.
```
df_full_gr_f = df_full_gr[df_full_gr['concept:name'].isin(['Permit SUBMITTED',
'Permit APPROVED',
'Permit FINAL_APPROVED',
'Declaration FINAL_APPROVED',
'Declaration APPROVED'])]
df_full_gr_f = df_full_gr_f.reset_index(drop=True)
dict_tuple_full_gr_f = calc(df_full_gr_f)
draw(dict_tuple_full_gr_f,'InternationalDeclarations_full_gr_isin')
```
С помощью полученного графа мы легко сможем дать ответ на поставленный вопрос – 116 и 312 декларациям не предшествовало предодобренное разрешение.
Можно дополнительно “провалиться” (отфильтровать по ‘case:concept:name’, участвующих в нужной связи) за связи 116 и 312 и убедиться, что на графах будут отсутствовать события, связанные с разрешениями.
“Провалимся” за связь 116:
```
df_116 = df_full_gr_f[df_full_gr_f['case:concept:name'].isin(d_case_start2['Declaration FINAL_APPROVED'])]
df_116 = df_116.reset_index(drop=True)
dict_tuple_116 = calc(df_116)
draw(dict_tuple_116,'InternationalDeclarations_full_gr_isin_116')
```
“Провалимся” за связь 312:
```
df_312 = df_full_gr_f[df_full_gr_f['case:concept:name'].isin(d_case_start2['Declaration APPROVED'])]
df_312 = df_312.reset_index(drop=True)
dict_tuple_312 = calc(df_312)
draw(dict_tuple_312,'InternationalDeclarations_full_gr_isin_312')
```
Так как на полученных графах полностью отсутствуют события, связанные с разрешениями, корректность ответов 116 и 312 подтверждается.
Как видим, написать майнер и реализовать необходимые возможности для работы с графами не сложная задача, с которой успешно справились встроенные функции Python и Graphviz в качестве графического движка. | https://habr.com/ru/post/521152/ | null | ru | null |
# XMLDSig: php + openssl
Продолжение поста про интеграцию с ГИС ЖКХ - <https://habr.com/en/post/710462/>
В этой части разберём как правильно подписать xml-запрос в `php` при помощи `openssl`
В этой статье я не разбираю почему `xmldsig` формируется именно так - я привожу пример реализации. Поэтому я ожидаю, что вы уже знакомы с основными понятиями и алгоритмом подписания по `xmldsig`.
Будем использовать модифицированную версию `openssl` из первого поста, поэтому он обязателен к прочтению
В основе всего лежит базовый класс `Xml`, наследуемый от `DOMDocument`:
Xml
```
php
namespace gis\xml;
use DOMDocument as GlobalDOMDocument;
use DOMElement;
use RuntimeException;
class Xml extends GlobalDOMDocument
{
public function setVersion(string $version)
{
$this-addAttributeToTag($this->getRequestPayloadXml()->localName, new TagAttributeData([
'attributeName' => 'base:version',
'attributeValue' => $version,
'attributeNamespace' => 'xmlns:base',
'attributeNamespaceValue' => 'http://dom.gosuslugi.ru/schema/integration/base/'
]));
}
public function addAttributeToTag(string $tagName, TagAttributeData $tagAttributeData)
{
/** @var DOMElement $tag */
$tag = $this->getElementByTagName($tagName);
if ($tagAttributeData->getAttributeNamespace()) {
$tag->setAttribute($tagAttributeData->getAttributeNamespace(), $tagAttributeData->getAttributeNamespaceValue());
}
$tag->setAttribute($tagAttributeData->getAttributeName(), $tagAttributeData->getAttributeValue());
$tmpDoc = self::fromText($tag->C14N(true), false);
$imported = $this->importNode($tmpDoc->documentElement, true);
$body = $this->getBody();
$body->removeChild($tag);
$body->appendChild($imported);
}
public function getRequestPayloadXml(): DOMElement
{
$availableTags = ['exportDSRsRequest', 'importDSRResponsesRequest'];
foreach ($availableTags as $tagName) {
if ($found = $this->getElementByTagName($tagName)) {
return $found;
}
}
throw new RuntimeException('Not yet implemented');
}
public function getElementByTagName(string $qualifiedName): ?DOMElement
{
return $this->getElementsByTagName($qualifiedName)->item(0);
}
public static function fromText(string $source, bool $canonicalize = true): static
{
$xml = new static('1.0', 'utf-8');
$xml->loadXML($source);
return $canonicalize ? self::fromText($xml->C14N(), false) : $xml;
}
public function getBody(): DOMElement
{
return $this->getElementByTagName('Body');
}
}
```
В нём используется класс `TagAttributeData` - это просто `DTO` с данными по атрибуту тэга:
TagAttributeData
```
php
namespace gis\xml;
use yii\base\Component;
final class TagAttributeData extends Component
{
public string $attributeName;
public string $attributeValue;
public ?string $attributeNamespace = null;
public ?string $attributeNamespaceValue = null;
public function getAttributeName(): string
{
return $this-attributeName;
}
public function getAttributeValue(): string
{
return $this->attributeValue;
}
public function getAttributeNamespace(): ?string
{
return $this->attributeNamespace;
}
public function getAttributeNamespaceValue(): ?string
{
return $this->attributeNamespaceValue;
}
}
```
От него наследует класс `SignedXml`, который собственно и подписывает запрос:
SignedXml
```
php
namespace gis\xml;
use common\helpers\DateHelper;
use DOMElement;
use DOMNode;
use gis\components\UUID;
use gis\openssl\OpenSSLInterface;
use Yii;
final class SignedXml extends Xml
{
private OpenSSLInterface $openssl;
public function __construct(string $version, string $encoding)
{
$this-openssl = Yii::$app->get('openssl');
parent::__construct($version, $encoding);
}
public function saveXML(?DOMNode $node = null, int $options = null): string|false
{
$this->tagSignedElement();
$signatureElement = $this->importSignatureContainer();
$this->digestSignedProperties($signatureElement);
$this->digestSignedInfo($signatureElement);
return parent::saveXML();
}
private function tagSignedElement(): void
{
$this->addAttributeToTag($this->getRequestPayloadXml()->localName, new TagAttributeData([
'attributeName' => 'Id',
'attributeValue' => 'signed-data-container',
]));
}
private function importSignatureContainer(): DOMElement
{
$x509 = $this->openssl->getX509();
$signedInfoProperties = [
'signatureId' => UUID::new(),
'keyInfoId' => UUID::new(),
'canonicalDataDigest' => $this->openssl->digest($this->getRequestPayloadXml()->C14N(true)),
'x509CertDigest' => $this->openssl->digest(base64_decode($x509->getStripped())),
'x509Cert' => $x509->getStripped(),
'signingTime' => DateHelper::soap(),
'x509IssuerName' => $x509->getIssuerName(),
'x509SerialNumber' => $x509->getSerialNumber()
];
$render = Yii::$app->getView()->renderPhpFile(Yii::getAlias('@gis/templates/full-signature.php'), $signedInfoProperties);
$signatureContainer = Xml::fromText($render);
$signatureElement = $this->importNode($signatureContainer->documentElement, true);
$actualRequestBody = $this->getRequestPayloadXml();
$firstParam = $actualRequestBody->childNodes->item(0);
$actualRequestBody->insertBefore($signatureElement, $firstParam);
return $signatureElement;
}
private function digestSignedProperties(DOMElement $signatureElement): void
{
$signedPropertiesElement = $signatureElement->getElementsByTagName('SignedProperties')->item(0);
$signedPropertiesDigest = $this->openssl->digest($signedPropertiesElement->C14N(true));
$signatureElement->getElementsByTagName('DigestValue')->item(1)->textContent = $signedPropertiesDigest;
}
private function digestSignedInfo(DOMElement $signatureElement): void
{
$signatureValue = $this->openssl->sign($signatureElement->getElementsByTagName('SignedInfo')->item(0)->C14N(true));
$signatureElement->getElementsByTagName('SignatureValue')->item(0)->textContent = $signatureValue;
}
}
```
В нём используется класс `UUID`:
UUID
```
php
namespace gis\components;
class UUID
{
public static function new(): string
{
$data = random_bytes(16);
return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}
}
</code
```
Для подписи используются два интерфейса `OpenSSLInterface` и `X509Interface`, приведу их текущие реализации:
OpenSSLInterface
```
php
namespace gis\openssl;
use gis\components\TemporaryFile;
use Yii;
use yii\base\Component;
class OpenSSL extends Component implements OpenSSLInterface
{
private X509Interface $x509;
public function __construct($config = [])
{
$this-x509 = Yii::$app->get('x509')::fromFile(Yii::$app->params['gis']['openssl']['x509.pem']);
parent::__construct($config);
}
public function digest(string $value): string
{
return $this->dgst($value);
}
private function dgst(string $value, ?string $privateKeyPath = null): bool|string|null
{
$temporaryFile = new TemporaryFile($value);
$filepath = $temporaryFile->getFilepath();
$command = [
'cat',
$filepath,
'|',
'openssl',
'dgst',
'-md_gost12_256',
'-binary',
];
if ($privateKeyPath) {
$command = array_merge($command, [
'-sign',
$privateKeyPath
]);
}
$command = array_merge($command, [
'|',
'base64',
'-w',
'0'
]);
return shell_exec(implode(' ', $command));
}
public function sign(string $value): string
{
return $this->dgst($value, Yii::$app->params['gis']['openssl']['private.key']);
}
public function getX509(): X509Interface
{
return $this->x509;
}
}
```
В нём используется класс `TemporaryFile`:
TemporaryFile
```
php
namespace gis\components;
class TemporaryFile
{
private string $filepath;
public function __construct(?string $data = null)
{
$this-filepath = tempnam(sys_get_temp_dir(), 'php');
$data && $this->setData($data);
}
public function setData(string $data): void
{
file_put_contents($this->getFilepath(), $data);
}
public function getFilepath(): bool|string
{
return $this->filepath;
}
public function __destruct()
{
$this->destroy();
}
private function destroy(): void
{
if (!file_exists($this->filepath)) {
return;
}
unlink($this->filepath);
}
}
```
X509Interface
```
php
namespace gis\openssl;
use common\components\MathHelper;
use yii\base\Component;
final class X509 extends Component implements X509Interface
{
private string $content;
public static function fromFile(string $filepath): static
{
$x509 = new self();
$x509-content = file_get_contents($filepath);
return $x509;
}
public function getSerialNumber(): string
{
$serialNumber = $this->getParsedValue('serialNumber');
return str_starts_with($serialNumber, '0x')
? MathHelper::bcHexToDecimal(substr($serialNumber, 2))
: $serialNumber;
}
private function getParsedValue(string $key): mixed
{
$read = openssl_x509_read($this->content);
return openssl_x509_parse($read)[$key] ?? null;
}
public function getIssuerName(): string
{
$issuer = $this->getParsedValue('issuer');
$issuerData = [
'CN' => $issuer['CN'],
'O' => $issuer['O'],
'OU' => $issuer['OU'],
'C' => $issuer['C'],
'ST' => $issuer['ST'],
'L' => $issuer['L'],
'E' => $issuer['emailAddress'],
'STREET' => $issuer['street'],
'1.2.643.100.4' => $issuer['INN'] ?? $issuer['UNDEF'] ?? null,
'1.2.643.100.1' => $issuer['OGRN'],
];
$mergedIssuerData = [];
foreach ($issuerData as $key => $value) {
$value = str_replace(['"', ','], ['\"', '\,'], $value);
$mergedIssuerData[] = "$key=$value";
}
return implode(',', $mergedIssuerData);
}
public function getStripped(): string
{
$allLines = explode(PHP_EOL, $this->content);
unset($allLines[0], $allLines[count($allLines) - 1]);
return implode(PHP_EOL, $allLines);
}
}
```
В них используется шаблон подписи:
Разметка шаблона подписи
```
php
/**
* @var string $signatureId
* @var string $keyInfoId
* @var string $canonicalDataDigest - digest1
* @var string $x509CertDigest - digest2
* @var string $x509Cert
* @var string $signingTime
* @var string $x509IssuerName
* @var string $x509SerialNumber
*/
?
= $canonicalDataDigest ?
= $x509Cert ?
= $signingTime ?
= $x509CertDigest ?
= $x509IssuerName ?
= $x509SerialNumber ?
```
Теперь посмотрим как это всё слить воедино, чтобы получить подписанный xml-запрос
На этом этапе я предположу, что вы уже знаете как из WSDL сформировать xml-запрос
Если нет1. гуглим "php soap client wsdl"
2. пишем кастомную обёртку над soap client
3. перехватываем сгенерированный из wsdl запрос
Пример кастомной обёртки можно найти в первой части статей по ссылке вверху
```
$xml = Xml::fromText($request); # $request = ваш перехваченный wsdl-запрос
$xml->setVersion('13.1.1.6');
$signedXml = SignedXml::fromText($xml->saveXML())->saveXML();
```
Примечания:
1. На строке 38 в классе `XML` идёт перечисление поддерживаемых wsdl-запросов, потому что по-другому вычленять тело запроса *сложновато*
2. По классу `SignedXML`:
1. Реализацию интерфейса `OpenSSLInterface` инжектите как хотите, конкретно в `Yii2` это проще через service locator было сделать
2. На строке 52 есть `DateHelper::soap()` - это просто текущая дата в формате `Y-m-d\TH:i:s.uP`
3. На строке 57 идёт импорт шаблона подписи - меняйте на нужный вам. Моя реализация тут опять же напрямую зависит от фреймворка
3. По классу `OpenSSL`:
1. Реализацию интерфейса `X509Interface` инжектите как хотите)
2. Да, для формирования `digest` действительно используется `shell_exec`. Если очень хочется, то пересобирайте `php` с поддержкой `openssl` с поддержкой `gost-engine`)
3. На строке 59 в `dgst` вторым аргументом передаётся секретный ключ вашего сертификита, который мы получили в первой статье
4. По классу `X509`:
1. Пожалуй, то, от чего больше всего седеют волосы во всей этой интеграции - это названия полей с данными. У всех нормальных людей ИНН лежит в поле INN, у гис жкх это почему-то `1.2.643.100.4`
2. На строке 25 мы получаем серийник сертификата:
```
public static function bcHexToDecimal(string $hex): string
{
if (strlen($hex) === 1) {
return hexdec($hex);
}
$remain = substr($hex, 0, -1);
$last = substr($hex, -1);
return bcadd(bcmul(16, self::bcHexToDecimal($remain)), hexdec($last));
}
```
Пара-пара-пам! Вот и всё. Этот манёвр стоил мне 2 недели жизни. Надеюсь, пригодится вам.
Как всегда - рад любым вопросам, всё что надо - допишу в статью. | https://habr.com/ru/post/710532/ | null | ru | null |
# Конвертирование видео фильмов в формат .mо (Mobiclip)
В этой статье я вам расскажу, как получать и воспроизводить фильмы и клипы, например, в форматах FullHD на экранах ваших КПК. Без тормозов, зависаний, запаздываний аудио- или видео-дорожки друг от друга, а наоборот — в оригинальном качестве и со всеми вытекающими от просмотра данного формата плюсами, как на вашей домашней FullHD панели. Абсолютно не будет важным и тот факт, что у вас самое слабое устройство на базе Windows Mobile с экраном начиная от 176х220 и до WVGA.
**Mobiclip** (формат .mo) – это очень прогрессивная технология, позволяющая проигрывать видео файлы, flash-анимацию в полноэкранном режиме, проигрывать мелодии. Также можно играть в полноценные flash-видеоигры; использовать анимированные звонки (flash), видео звонки; присутствует и функция karaoke.
**Mobiclip** – действительно, прогрессивная технология, так как работает на low-end девайсах: процессор от 16 Mhz (на данной частоте работает ARM7)! Правда, весь прикол заключается в том, что Mobiclip Player распространяется бесплатно, тогда как Mobiclip Converter распространяется только в среде разработчиков и стоит бешеных денег. Кроме того, Mobiclip Converter – является лишь beta-версией.
Чтобы конвертировать видео в формат .mo, естественно, нужен сам конвертер Mobiclip Converter, который весит 21323 Kb (уже есть в архиве). Кроме того, конвертер не запускается без пакета Microsoft .Net Frameworks 1.1, который можно скачать с сайта производителя бесплатно, весит чудо-пакет 23697 Kb (уже есть в архиве). И еще для конвертирования видео понадобится VirtualDub, весящий 893 Kb (уже есть в архиве VirtualDub 1.9.0.30586 Русская Версия + Plugins).
Итак, после скачивания и установки необходимых программ (Mobiclip Converter, Microsoft .Net Frameworks 1.1, VirtualDub) можно приступать к работе.
**Инструкция по конвертированию видео в формат .mo**:
1) Запускаем VirtualDub, и открываем исходный файл, например video.avi
2) В меню «Видео» выбираем «Режим полной обработки»
3) В меню «Видео» открываем «Компрессия» и выбираем видео-кодек из представленных в списке — Actimagine Mobiclip Video Codec
4) Нажимаем на кнопку «Настройка» и переставляем ползунок с 75% на 70%, с помощью чего мы регулируем Image Quality, то есть качество картинки. Как вы поняли с качеством картинки можно экспериментировать
5) В меню «Видео» выбираем «Частота кадров» и ставим селективную кнопку на Process every other frame (decimate by 2), это меняет частоту смены кадров с 30 fps на 25 fps
6) В меню «Видео» выбираем «Фильтры». В меню «Фильтры» куча фильтров, можно и с ними экспериментировать, но мы рассмотрим лишь необходимые. Нажимаем на кнопку «Добавить» и добавляем фильтр Resize. Меняем размер: в строке «Новая ширина» прописываем, например, 640; в строке Новая высота прописываем 480. В строке «Режим фильтра» ставим Precise bicubic. После можно нажать на кнопку «Просмотр», и посмотреть, что у нас получилось. Касательно Windows Mobile (дисплей составляет от 176 на 220 и до 480 на 800) значения Шовая ширина и Новая высота могут меняться.
7) В меню «Фильтры» нажимаем на кнопку «Добавить» и добавляем фильтр Rotate, с помощью которого нам предлагается повернуть изображение: Left by 90, Right by 90, Around 180 — то есть влево на 90, вправо на 90, вокруг на 180. Теперь счастливым владельцам КПК можно смотреть видео в нормальном виде.
8) В меню «Аудио» выбираем «Режим полной обработки»
9) В меню «Аудио» открываем «Компрессия» и убеждаемся, что стоит No Compression (PCM)
10) В меню «Аудио» выбираем «Конверсия». В окне «Конверсия» ставим селективные кнопки 48000 Hz, High quality, 16
bits, Стерео (или везде ставил галочки «Без изменений»)
11) В меню «Файл» нажимаем на «Сохранить параметры обработки», и прописываем имя, например, Mobiclip.vcf. Таким образом мы сохранили все установки, чтобы в следующий раз не пришлось ставить их заново.
12) Наконец, В меню «Файл» нажимаем на «Сохранить как AVI», и прописываем имя, например, videoclip.avi. Смотрим, как на наших глазах происходит процесс конвертирования. Закрываем VirtualDub
13) Теперь открываем директорию, где мы сохранили videoclip.avi (можем посмотреть в любом player'е). Кликаем правой кнопкой мыши на videoclip.avi, и в выпадающем меню выбираем Convert to Mobiclip (.mo). После конвертирования в той же директории, где находится videoclip.avi, появляется videoclip.mo
Могу вас поздравить, после этих адских трудов мы можем посмотреть на то, что у нас получилось! Открываем videoclip.mo и смотрим на то, что у нас получилось (Mobiclip Player For Windows OS входит в состав конвертера). Теперь с помощью ActiceSync и X-device или аналогичной переносим videoclip.mo на microSD(HS) (у кого какая карта) в папку mobiclip (то есть на диск Ваша карта памяти:mobiclip). Или просто отправляем на наш девайс в виде сообщения.
**Примечание**:
Все пункты инструкции по конвертированию видео в формат .mo должны быть строго соблюдены, иначе у вас ничего не выйдет.
Используйте Mobiclip Player для Windows Mobile, который находится в составе Mobiclip Converter или скачайте отдельный клиент с этого сайта. Он находится в директории, в которой вы установили Mobiclip Converter. Например, у меня Mobiclip Player для Windows Mobile находится в «C:Program FilesActimagineMobiclip (beta)PlayerMobiclip-sp2003». Mobiclip Player должен быть версии 1.83. Дело в том, что умельцы из Actimagine не встроили в свое детище одной немаловажной функции, скорее всего специально: более новая версия не понимает .mo файлы старой версии player'а
**Инструкция по конвертированию flash-анимации в формат .mo**:
Для конвертирования flash-анимации .swf в формат .mo нам понадобятся Mobiclip Converter, Microsoft .Net Frameworks 1.1, и любой инструмент для создания flash-анимации, например, Macromedia Flash MX.
1) Не использовать alpha effects, gradient fills, или mask layers
2) Не использовать bitmap'ы в качастве фоновых изображений
3) Использовать только один аудиопоток
4) Касательно самой Macromedia Flash MX в меню Modify выбираем Shape и ставим Convert lines to fills. Дело в том, что в
Mobiclip Player не вырисовываются линии
5) В Library, в окне Properties, снять галочку с Use imported JPEG data
6) В меню File, выбираем Publish в разделе Flash устанавливаем следующие значения для звука: Raw, Mono, 44 Khz
7) Частота смены кадров должна быть не меньше 4. Она должна быть оптимальной, иначе возникнут портаки со звуком
Теперь после создания собственной flash-анимации и просмотра ее на Macromedia Flash Player, кликаете на ней правой кнопкой и в выпадающем меню выбираете Convert to Mobiclip (.mo). Получившийся flash-ролик можно просмотреть на компьютере.
**Примечание**:
В силу вышеописанных пунктов нам не совсем походит flash-анимация скачанная с сети: слишком капризным оказался Mobiclip Player, он просто не понимает многих эффектов, характерных для современной flash-анимации.
Однако можно скачать в сети flash-анимацию в формате .swf, например, Масяню и переделать ее, для этого надо запустить Macromedia Flash MX, и в меню File выбрать Import, указать исходный файл, например, Масяня.swf. Далее придется переделывать все по инструкции, описанной выше.
И еще один маленький нюанс: в составе Mobiclip Converter содержится инструкция MobiclipManual.pdf, где описаны Ограничения сценария (Script Limitations)
Конвертировал видео и flash-анимацию собственноручно. Работает 100% на RoverPC S6. Предлагаю опробовать новую технологию Mobiclip специалистам и всем желающим. Единственная проблема заключается в размере полноэкранного видео (использовались вышеописанные установки): при конвертировании видео файла .mpg размером 31,5 Mb получился .mo видео файл размером в 10 Mb! При конвертировании flash-анимации в формате .swf в формат Mobiclip .mo размер исходного файла практически не отличается от получившегося: изменяется лишь на 5%-10% (при условии, что клип сделан самостоятельно)
**Пример копирования и воспроизведения полученных видео-материалов**:
За пример я взял видео с благотворительного концерта 2010 FIFA World Cup™ Kick-off Concert группы Black Eyed Peas — I Gotta Feeling — [вот адрес на YouTube.ru](http://www.youtube.com/watch?v=LLCaOBj7ZHU&feature=channel)
При скачивании этого виде с YouTube.ru в наилучшем качестве, оно будет весить 131.088 Мб. (в формате MPEG-4, FullHD), а после конвертации они стало весить только 34 Mб. При этом оно остальсь такого же качества со всеми вытекающими отсюда эмоциями, что и оригинальное видео в 131.088 Мб. После конвертирования его вам нужно будет поместить вот по этому пути в самой устройство (пример как у меня используется):
`"Storage CardMobiclipugc=Personal_Videosmouqf32oP1Eyniv1PwufqTkFA=Black_Eyed_Peas__I_Gotta_Feeling"` | https://habr.com/ru/post/140188/ | null | ru | null |
# Решаем проблему родительского контроля в Ubuntu с помощью Dansguardian и Privoxy
Я придерживаюсь мнения, что Ubuntu вполне себе подходит на роль user-friendly десктопной операционной системы.
Соответственно, считаю, что при покупке компьютеров и ноутбуков на стоимости лицензионной Windows вполне можно сэкономить, поставив бесплатную (открытую) ОС (вспомните, сколько, лет 5 назад, продавалось ноутов с Linux, и сколько сейчас).
Детям я купил [неттоп Acer Aspire Revo R3700](http://www.ixbt.com/news/hard/index.shtml?13/74/72), который, наверное, сам по себе стоит отдельного обзора (двухъядерный Atom + Ion), прикрутил его сзади к монитору, благо оба поддерживают стандарт крепления VESA (получился этакий компактный моноблок), снес предустановленный Linpus и поставил Ubuntu 10.10
В принципе, и я, и мои дети были всем довольны — работает все достаточно шустро (тьфу-тьфу-тьфу), посёрфить в интернете, посмотреть фотки, послушать музыку, поиграть в детские и обучающие игры — для этого неттоп подходит, на мой взгляд, идеально. Единственное, что удручало, это баннеры на различных, даже детских (!), сайтах со всяким контентом (прежде всего, визуальным), от которого очень хотелось детей оградить.
Вот тут меня и постигло разочарование, когда узнал, что встроенного (штатного) родительского контроля в Ubuntu попросту нет. В Windows Vista и 7 — есть, есть много отдельных «виндовых» программ, например, [Интернет Цензор](http://habrahabr.ru/blogs/infosecurity/88669/) (пробовал под Windows в свое время, в принципе, остался доволен).
А вот в Ubuntu с этим туго. Наткнулся в репозитарии на Gnome Nanny — поставил, потом снес. Выскакивают грозные предупреждения, что сейчас отключится интернет и выключится компьютер, но… ничего не происходит. Возможно, расчет был на сознательность детей (сарказм), хотя, скорее, я просто не разобрался. Правда, делал все по мануалу, а тратить недели на выяснение причин не хотелось.
Также сразу оговорюсь, что [провайдер](http://lurkmore.ru/%D0%90%D0%BA%D0%B0%D0%B4%D0%BE) запрещает использование сторонних DNS, а то бы, возможно, я просто ограничился каким-либо OpenDNS, где, вроде бы, режется реклама и есть фильтр для взрослого контента.
Коротко о том, как построена моя домашняя сеть: есть роутер D-Link Dir-615, к нему по сетевому кабелю подключен основной домашний комп, а также [медиаплеер Popcorn Hour A-110](http://forum.ixbt.com/topic.cgi?id=62:13822), по Wi-Fi — детский неттоп, iPad, нетбук, ноутбук, парочка смартфонов на андроиде, еще один медиаплеер [WD TV Live](http://www.wdc.com/ru/products/products.aspx?id=330) и… вроде бы всё.
Возвращаясь к проблеме родительского контроля: наткнулся на программу под название [Dansguardian](http://dansguardian.org/), почитал, подумал, решил ставить.
Для экспериментов достал старенький [EEE PC 701 4G](http://eee-pc.ru/wiki/asus_eee_pc_701) (на всякий случай, может, кто не знает: цифра перед G означает всего лишь «ёмкость встроенной памяти (твердотельный накопитель) в гигабайтах», а не встроенный 4G модем), поставил на него Lubuntu 10.10 (кстати, Лубунту порадовала — нетребовательна к ресурсам, потому быстрая, привычная для тех, кто «после Windows», все железо заработало буквально «из коробки»):
[](https://habrastorage.org/storage/habraeffect/ba/c0/bac09c109b3cb9abe3c88c1b1db6c2aa.png "Хабрэффект.ру")
После этого завел две учетные записи, одну [kid] (в квадратных скобках здесь и далее — обозначение учетной записи, которое вы можете выбрать по своему вкусу, где kid — учетная запись ребенка, parent — учетная запись родителя) и [parent]. [kid] — с правами пользователя, [parent] — с правами администратора.
Заходим под учетной записью ребенка, открываем терминал («Пуск» (хехе, а как иначе назвать кнопку на таскбаре в левом нижнем углу?) -> Стандартные -> LXTerminal)
Набираем (естественно, без квадратных скобок):
`su [parent]`
Вводим пароль. Далее:
`sudo apt-get install -y privoxy dansguardian`
Вводим пароль, следуем подсказкам на экране, после чего у вас должны поставиться, как Вы догадались, Dansguardian и Privoxy (нетяжелый прокси-сервер — через него, собственно, и будет работать Dansguardian).
Далее, на всякий случай, можно проверить, запущен ли privoxy, командой
`sudo /etc/init.d/privoxy status`
После этого надо настроить установленные программы, для этого правим конфигурационные файлы:
`sudo leafpad /etc/privoxy/config`
Ищем строку listen-address, приводим ее к следующему виду (не забываем убирать знак комментария #):
`listen-address 127.0.0.1:8118`
Ищем параметр accept-intercepted-requests и присваиваем ему значение 1:
`accept-intercepted-requests 1`
Всё, настройка прокси privoxy закончена, сохраняемся, выходим.
Далее настраиваем сам dansguardian:
`sudo leafpad /etc/dansguardian/dansguardian.conf`
В самом начале файла написано, что надо удалить строку UNCOMMITED, чтобы настройки вступили в силу. Удаляем ее. Далее ищем незакомментированную строку, начинающуюся со слова language и меняем ее:
`language = 'russian-1251'`
Это нужно, чтобы страница с шаблоном «Доступ запрещен» была на русском языке.
Ищем и меняем следующие строки (если в файле прописано по умолчанию так же, то менять, естественно, не нужно):
`filterport=8080
proxyip=127.0.0.1
proxyport-8118`
Сохраняем, закрываем. Далее перезапускаем обе программы:
`sudo service dansguardian force-reload
sudo service privoxy force-reload`
Далее запускаем браузер по умолчанию (предустановленный Chromium), заходим на какой-нить playboy.com и видим… что он успешно грузится, как и раньше! Чтобы не рвать волосы на голове (как пару дней подряд делал это я), читайте дальше.
В общем, так и должно быть, потому что мы не поменяли в браузере настройки прокси-сервера. Привычными кликами заходим в расширенные настройки Chromium («Ведь это тот же Хром!») и видим удручающую картину:
[](https://habrastorage.org/storage/habraeffect/ba/da/badadef1dfaf34e29ede0019c81a02fc.png "Хабрэффект.ру")
Все правильно, в Lubuntu нет «гуёвого» интерфейса настройки прокси-сервера. Как временное решение, пишем в терминале:
`sudo chromium-browser --proxy-server=127.0.0.1:8080`
Запустится браузер, зайдем на playboy.com и увидим такую картинку:
[](https://habrastorage.org/storage/habraeffect/d6/41/d641dd98ce9cf075384e955e33ac0bb6.png "Хабрэффект.ру")
Урра! Но радость омрачается тем, что если мы перезапустим браузер, то настройки прокси слетят, а это не вариант. Да и ребенок, позврослев, научится обходить прокси-сервер, поставив какой-нибудь Firefox и убрав галочку напротив пункта «использовать настройки прокси-сервера». Значит нужен более надежный вариант.
И вот тут нам на помощь приходят iptables и ufw. Скажу сразу, что оставшиеся мои волосы чуть не поседели, пока дошел до правильных настроек всего этого хозяйства (понимаю, что кто-то посмеется над таким «ламерством»).
Итак, ufw (Uncomplicated Firewall) в Lubuntu включен, как я уже потом выяснил, по умолчанию. Потому выполняем следующее:
`sudo leafpad /etc/ufw/before.rules`
В конце файла, после COMMIT, со следующей строки вставляем такие строки:
`# Rules for Dansguardian + Privoxy
*nat
:PREROUTING ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A OUTPUT -p tcp -m tcp --dport 80 -m owner --uid-owner root -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 80 -m owner --uid-owner [parent] -j REDIRECT --to-port 8118
-A OUTPUT -p tcp -m tcp --dport 8118 -m owner ! --uid-owner dansguardian -j REDIRECT --to-port 8080
-A OUTPUT -p tcp -m tcp --dport 80 -m owner ! --uid-owner privoxy -j REDIRECT --to-port 8080
# don't delete the 'COMMIT' line or these rules won't be processed
COMMIT`
Сохраняем, закрываем, перезапускаем:
`sudo ufw disable && sudo ufw enable`
Все, теперь смышленый ребенок не сможет обойти прокси.
Дальше над чем стоит поработать:
* настроить под себя страницу с шаблоном «Доступ запрещен» (например, найти забавную картинку со Смешариками и написать более жизнерадостный текст, что заходить на этот сайт «Низзя!»)
* прошерстить внимательно каталог с dansguardian — там все подробно написано в комментариях в файлах, как и что настраивать
* научиться составлять список плохих слов на русском (у dansguardian вроде как плохо с кодировками, отличными от utf-8, судя по форумам)
* желательно найти уже в сети готовые списки плохих русских слов (чтобы не составлять самому и не изощряться в матерном языке)
В общем, судя по описанию выше, кажется все просто, но на деле я провел несколько бессонных ночей, пытаясь понять, почему настройки не работают.
С нетерпением жду комментариев — где, как не в них можно почерпнуть дополнительную полезную информацию, узнать много нового ~~и как можно было сделать то же самое, только проще и лучше~~. Статью написал, в первую очередь, для себя (чтобы можно было зайти на Хабр и сверить подзабытые настройки) и для тех, кто так же, как и я, мучается с родительским контролем в Ubuntu.
При настройке dansguardian и privoxy очень помогли следующие материалы:
[How to transparent proxy](http://blog.bodhizazen.net/linux/how-to-transparent-proxy/)
[Ubuntu Documentation > Community Documentation > UFW](https://help.ubuntu.com/community/UFW)
ну и [Dansguardian Documentation](http://dansguardian.org/?page=documentation)
Публикация данной статьи стала возможной благодаря [MrCleaner](https://habrahabr.ru/users/mrcleaner/), за что ему большое спасибо. | https://habr.com/ru/post/119286/ | null | ru | null |
# Создание многопользовательской веб-игры в жанре .io
Вышедшая в 2015 году [Agar.io](https://agar.io) стала прародителем нового жанра [**игр .io**](https://www.google.com/search?q=.io+game), популярность которого с тех пор сильно возросла. Рост популярности игр .io я испытал на себе: за последние три года я [создал и продал две игры этого жанра.](https://victorzhou.com/about/).
На случай, если вы никогда раньше не слышали о таких играх: это бесплатные многопользовательские веб-игры, в которых легко участвовать (не требуется учётная запись). Обычно они сталкивают на одной арене множество противоборствующих игроков. Другие знаменитые игры жанра .io: [Slither.io](https://slither.io) и [Diep.io](https://diep.io).
В этом посте мы будем разбираться, как **с нуля создать игру .io**. Для этого достаточно будет только знания Javascript: вам нужно понимать такие вещи, как синтаксис [ES6](https://www.w3schools.com/js/js_es6.asp), ключевое слово `this` и [Promises](https://developers.google.com/web/fundamentals/primers/promises). Даже если вы знаете Javascript не в совершенстве, то всё равно сможете разобраться в большей части поста.
Пример игры .io
---------------
Для помощи в обучении мы будем ссылаться на [пример игры .io](https://example-io-game.victorzhou.com). Попробуйте в сыграть в неё!
Игра довольно проста: вы управляете кораблём на арене, где есть другие игроки. Ваш корабль автоматически стреляет снарядами и вы пытаетесь попасть в других игроков, в то же время избегая их снарядов.
1. Краткий обзор/структура проекта
----------------------------------
> Рекомендую [**скачать исходный код**](https://github.com/vzhou842/example-.io-game) примера игры, чтобы вы могли следовать за мной.
В примере используется следующее:
* [Express](https://expressjs.com/) — самый популярный веб-фреймворк для Node.js, управляющий веб-сервером игры.
* [socket.io](https://socket.io/) — библиотека websocket для обмена данными между браузером и сервером.
* [Webpack](https://webpack.js.org/) — менеджер модулей. О том, зачем использовать Webpack, можно прочитать [здесь](https://victorzhou.com/blog/why-you-should-use-webpack/).
Вот как выглядит структура каталога проекта:
````
public/
assets/
...
src/
client/
css/
...
html/
index.html
index.js
...
server/
server.js
...
shared/
constants.js
````
### public/
Всё в папке `public/` будет статически передаваться сервером. В `public/assets/` содержатся используемые нашим проектом изображения.
### src/
Весь исходный код находится в папке `src/`. Названия `client/` и `server/` говорят сами за себя, а `shared/` содержит файл констант, импортируемый и клиентом, и сервером.
2. Сборки/параметры проекта
---------------------------
Как сказано выше, для сборки проекта мы используем менеджер модулей [Webpack](https://webpack.js.org/). Давайте взглянем на нашу конфигурацию Webpack:
##### webpack.common.js:
```
const path = require('path');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
module.exports = {
entry: {
game: './src/client/index.js',
},
output: {
filename: '[name].[contenthash].js',
path: path.resolve(__dirname, 'dist'),
},
module: {
rules: [
{
test: /\.js$/,
exclude: /node_modules/,
use: {
loader: "babel-loader",
options: {
presets: ['@babel/preset-env'],
},
},
},
{
test: /\.css$/,
use: [
{
loader: MiniCssExtractPlugin.loader,
},
'css-loader',
],
},
],
},
plugins: [
new MiniCssExtractPlugin({
filename: '[name].[contenthash].css',
}),
new HtmlWebpackPlugin({
filename: 'index.html',
template: 'src/client/html/index.html',
}),
],
};
```
Самыми важными здесь являются следующие строки:
* `src/client/index.js` — это входная точка клиента Javascript (JS). Webpack будет начинать отсюда и станет рекурсивно искать другие импортированные файлы.
* Выходной JS нашей сборки Webpack будет располагаться в каталоге `dist/`. Я буду называть этот файл нашим **пакетом JS**.
* Мы используем [Babel](https://babeljs.io/), и в частности конфигурацию [@babel/preset-env](https://babeljs.io/docs/en/babel-preset-env) для транспиляции (transpiling) нашего кода JS для старых браузеров.
* Мы используем плагин для извлечения всех CSS, на которые ссылаются файлы JS, и для объединения их в одном месте. Я буду называть его нашим **пакетом CSS**.
Вы могли заметить странные имена файлов пакетов `'[name].[contenthash].ext'`. В них содержатся [подстановки имён файлов](https://webpack.js.org/configuration/output/#output-filename) Webpack: `[name]` будет заменён на имя входной точки (в нашем случае это `game`), а `[contenthash]` будет заменён на хеш содержимого файла. Мы делаем это, чтобы [оптимизировать проект для хеширования](https://webpack.js.org/guides/caching/#output-filenames) — можно приказать браузерам бесконечно кешировать наши пакеты JS, потому что **если пакет изменяется, то меняется и его имя файла** (изменяется `contenthash`). Готовым результатом будет имя файла вида `game.dbeee76e91a97d0c7207.js`.
Файл `webpack.common.js` — это базовый файл конфигурации, который мы импортируем в конфигурации разработки и готового проекта. Вот, например, конфигурация разработки:
##### webpack.dev.js
```
const merge = require('webpack-merge');
const common = require('./webpack.common.js');
module.exports = merge(common, {
mode: 'development',
});
```
Для эффективности мы используем в процессе разработки `webpack.dev.js`, и переключается на `webpack.prod.js`, чтобы оптимизировать размеры пакетов при развёртывании в продакшен.
### Локальная настройка
Рекомендую устанавливать проект на локальной машине, чтобы вы могли следовать за этапами, перечисленными в этом посте. Настройка проста: во-первых, в системе должны быть установлены [Node](https://nodejs.org/en/download/) и [NPM](https://www.npmjs.com/get-npm). Далее нужно выполнить
```
$ git clone https://github.com/vzhou842/example-.io-game.git
$ cd example-.io-game
$ npm install
```
и вы готовы к работе! Для запуска сервера разработки достаточно выполнить
```
$ npm run develop
```
и зайти в веб-браузере на [localhost:3000](http://localhost:3000). Сервер разработки будет автоматически пересобирать заново пакеты JS и CSS в процессе изменения кода — просто обновите страницу, чтобы увидеть все изменения!
3. Входные точки клиента
------------------------
Давайте приступим к самому коду игры. Для начала нам потребуется страница `index.html`, при посещении сайта браузер будет загружать её первой. Наша страница будет довольно простой:
##### index.html
```
An example .io game
PLAY
```
*Этот пример кода слегка упрощён для понятности, то же самое я сделаю и со многими другими примерами поста. Полный код всегда можно посмотреть на [Github](https://github.com/vzhou842/example-.io-game).*
У нас есть:
* [Элемент HTML5 Canvas](https://www.w3schools.com/html/html5_canvas.asp) (), который мы будем использовать для рендеринга игры.
* для добавления нашего пакета CSS.
* | https://habr.com/ru/post/450574/ | null | ru | null |
# Навигация по соседним документам (Siblings)
**Задача:** необходимо снабдить каждую дочернюю страницу навигацией « предыдущий следующий »
Всё кол-во скудных решений, которые я нашел — не подходили мне: некоторые не работали, некоторые показались очень объемные для решения такой тривиальной задачи. Решил написать свой сниппет, надеюсь что он облегчит жизнь не только мне.
> `php<br/
> $ID = $modx->documentIdentifier;
>
> $parentId = array\_pop($modx->getParentIds($modx->documentIdentifier,1));
>
>
>
> $children = $modx->getActiveChildren($parentId,'menuindex','ASC');
>
>
>
> $i=0;
>
> $key = false;
>
> while(!$key && $i
> $key = array\_search($ID,$children[$i]);
>
> $i++;
>
> }
>
>
>
> if(!empty($key) && count($children)>1){
>
> $placeholders = array(
>
> 'prev'=>($i-2>=0?'['id']('</font>.$modx->makeUrl($children[$i-2][<font color=)]).'">« назад':''),
>
> 'next'=>($i'['id']('</font>.$modx->makeUrl($children[$i][<font color=)]).'">вперед »':'')
>
> );
>
> $output = $modx->parseChunk('prevnext',$placeholders,'[+', '+]');
>
>
>
> }
>
> return $output;
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Сниппет выводит результат в чанк **prevnext**, в котором используются два плейсхолдера:
[+prev+]
[+next+]
Даже работает ;) | https://habr.com/ru/post/71722/ | null | ru | null |
# Ликбез по типизации в языках программирования
Эта статья содержит необходимый минимум тех вещей, которые просто необходимо знать о типизации, чтобы не называть динамическую типизацию злом, Lisp — бестиповым языком, а C — языком со строгой типизацией.
В полной версии находится подробное описание всех видов типизации, приправленное примерами кода, ссылками на популярные языки программирования и показательными картинками.
Рекомендую прочитать сначала краткую версию статьи, а затем при наличии желания и полную.
### Краткая версия
Языки программирования по типизации принято делить на два больших лагеря — *типизированные* и *нетипизированные* (*бестиповые*). К первому например относятся C, Python, Scala, PHP и Lua, а ко второму — язык ассемблера, Forth и Brainfuck.
Так как «бестиповая типизация» по своей сути — проста как пробка, дальше она ни на какие другие виды не делится. А вот типизированные языки разделяются еще на несколько пересекающихся категорий:
* *Статическая* / *динамическая* типизация. Статическая определяется тем, что конечные типы переменных и функций устанавливаются на этапе компиляции. Т.е. уже компилятор на 100% уверен, какой тип где находится. В динамической типизации все типы выясняются уже во время выполнения программы.
Примеры:
Статическая: C, Java, C#;
Динамическая: Python, JavaScript, Ruby.
* *Сильная* / *слабая* типизация (также иногда говорят строгая / нестрогая). Сильная типизация выделяется тем, что язык не позволяет смешивать в выражениях различные типы и не выполняет автоматические неявные преобразования, например нельзя вычесть из строки множество. Языки со слабой типизацией выполняют множество неявных преобразований автоматически, даже если может произойти потеря точности или преобразование неоднозначно.
Примеры:
Сильная: Java, Python, Haskell, Lisp;
Слабая: C, JavaScript, Visual Basic, PHP.
* *Явная* / *неявная* типизация. Явно-типизированные языки отличаются тем, что тип новых переменных / функций / их аргументов нужно задавать явно. Соответственно языки с неявной типизацией перекладывают эту задачу на компилятор / интерпретатор.
Примеры:
Явная: C++, D, C#
Неявная: PHP, Lua, JavaScript
Также нужно заметить, что все эти категории пересекаются, например язык C имеет статическую слабую явную типизацию, а язык Python — динамическую сильную неявную.
Тем-не менее не бывает языков со статической и динамической типизаций одновременно. Хотя забегая вперед скажу, что тут я вру — они действительно существуют, но об этом позже.
Пойдем дальше.
### Подробная версия
Если краткой версии Вам показалось недостаточно, хорошо. Не зря же я писал подробную? Главное, что в краткой версии просто невозможно было уместить всю полезную и интересную информацию, а подробная будет возможно слишком длинной, чтобы каждый смог ее прочесть, не напрягаясь.
#### Бестиповая типизация
В бестиповых языках программирования — все сущности считаются просто последовательностями бит, различной длины.
Бестиповая типизация обычно присуща низкоуровневым (язык ассемблера, Forth) и эзотерическим (Brainfuck, HQ9, Piet) языкам. Однако и у нее, наряду с недостатками, есть некоторые преимущества.
##### Преимущества
* Позволяет писать на предельно низком уровне, причем компилятор / интерпретатор не будет мешать какими-либо проверками типов. Вы вольны производить любые операции над любыми видами данных.
* Получаемый код обычно более эффективен.
* Прозрачность инструкций. При знании языка обычно нет сомнений, что из себя представляет тот или иной код.
##### Недостатки
* Сложность. Часто возникает необходимость в представлении комплексных значений, таких как списки, строки или структуры. С этим могут возникнуть неудобства.
* Отсутствие проверок. Любые бессмысленные действия, например вычитание указателя на массив из символа будут считаться совершенно нормальными, что чревато трудноуловимыми ошибками.
* Низкий уровень абстракции. Работа с любым сложным типом данных ничем не отличается от работы с числами, что конечно будет создавать много трудностей.
##### Сильная безтиповая типизация?
Да, такое существует. Например в языке ассемблера (для архитектуры х86/х86-64, других не знаю) нельзя ассемблировать программу, если вы попытаетесь загрузить в регистр cx (16 бит) данные из регистра rax (64 бита).
`mov cx, eax ; ошибка времени ассемблирования`
Так получается, что в ассемлере все-таки есть типизация? Я считаю, что этих проверок недостаточно. А Ваше мнение, конечно, зависит только от Вас.
#### Статическая и динамическая типизации
Главное, что отличает статическую (static) типизацию от динамической (dynamic) то, что все проверки типов выполняются на этапе компиляции, а не этапе выполнения.
Некоторым людям может показаться, что статическая типизация слишком ограничена (на самом деле так и есть, но от этого давно избавились с помощью некоторых методик). Некоторым же, что динамически типизированные языки — это игра с огнем, но какие же черты их выделяют? Неужели оба вида имеют шансы на существование? Если нет, то почему много как статически, так и динамически типизированных языков?
Давайте разберемся.
##### Преимущества статической типизации
* Проверки типов происходят только один раз — на этапе компиляции. А это значит, что нам не нужно будет постоянно выяснять, не пытаемся ли мы поделить число на строку (и либо выдать ошибку, либо осуществить преобразование).
* Скорость выполнения. Из предыдущего пункта ясно, что статически типизированные языки практически всегда быстрее динамически типизированных.
* При некоторых дополнительных условиях, позволяет обнаруживать потенциальные ошибки уже на этапе компиляции.
* Ускорение разработки при поддержке IDE (отсеивание вариантов, заведомо не подходящих по типу).
##### Преимущества динамической типизации
* Простота создания универсальных коллекций — куч всего и вся (редко возникает такая необходимость, но когда возникает динамическая типизация выручит).
* Удобство описания обобщенных алгоритмов (например сортировка массива, которая будет работать не только на списке целых чисел, но и на списке вещественных и даже на списке строк).
* Легкость в освоении — языки с динамической типизацией обычно очень хороши для того, чтобы начать программировать.
##### Обобщенное программирование
Хорошо, самый важный аргумент за динамическую типизацию — удобство описания обобщенных алгоритмов. Давайте представим себе проблему — нам нужна функция поиска по нескольким массивам (или спискам) — по массиву целых чисел, по массиву вещественных и массиву символов.
Как же мы будем ее решать? Решим ее на 3-ех разных языках: одном с динамической типизацией и двух со статической.
Алгоритм поиска я возьму один из простейших — перебор. Функция будет получать искомый элемент, сам массив (или список) и возвращать индекс элемента, или, если элемент не найден — (-1).
**Динамическое решение (Python):**
```
def find( required_element, list ):
for (index, element) in enumerate(list):
if element == required_element:
return index
return (-1)
```
Как видите, все просто и никаких проблем с тем, что список может содержать хоть числа, хоть списки, хоть другие массивы нет. Очень хорошо. Давайте пойдем дальше — решим эту-же задачу на Си!
**Статическое решение (Си):**
```
unsigned int find_int( int required_element, int array[], unsigned int size ) {
for (unsigned int i = 0; i < size; ++i )
if (required_element == array[i])
return i;
return (-1);
}
unsigned int find_float( float required_element, float array[], unsigned int size ) {
for (unsigned int i = 0; i < size; ++i )
if (required_element == array[i])
return i;
return (-1);
}
unsigned int find_char( char required_element, char array[], unsigned int size ) {
for (unsigned int i = 0; i < size; ++i )
if (required_element == array[i])
return i;
return (-1);
}
```
Ну, каждая функция в отдельности похожа на версию из Python, но почему их три? Неужели статическое программирование проиграло?
И да, и нет. Есть несколько методик программирования, одну из которых мы сейчас рассмотрим. Она называется обобщенное программирование и язык C++ ее неплохо поддерживает. Давайте посмотрим на новую версию:
**Статическое решение (обобщенное программирование, C++):**
```
template
unsigned int find( T required\_element, std::vector array ) {
for (unsigned int i = 0; i < array.size(); ++i )
if (required\_element == array[i])
return i;
return (-1);
}
```
Хорошо! Это выглядит не сильно сложнее чем версия на Python и при этом не пришлось много писать. Вдобавок мы получили реализацию для всех массивов, а не только для 3-ех, необходимых для решения задачи!
Эта версия похоже именно то, что нужно — мы получаем одновременно плюсы статической типизации и некоторые плюсы динамической.
Здорово, что это вообще возможно, но может быть еще лучше. Во-первых обобщенное программирование может быть удобнее и красивее (например в языке Haskell). Во-вторых помимо обобщенного программирования также можно применить полиморфизм (результат будет хуже), перегрузку функций (аналогично) или макросы.
##### Статика в динамике
Также нужно упомянуть, что многие статические языки позволяют использовать динамическую типизацию, например:
* C# поддерживает псевдо-тип dynamic.
* F# поддерживает синтаксический сахар в виде оператора ?, на базе чего может быть реализована имитация динамической типизации.
* Haskell — динамическая типизация обеспечивается модулем Data.Dynamic.
* Delphi — посредством специального типа Variant.
Также, некоторые динамически типизированные языки позволяют воспользоваться преимуществами статической типизации:
* Common Lisp — декларации типов.
* Perl — с версии 5.6, довольно ограниченно.
Итак, идем дальше?
#### Сильная и слабая типизации
Языки с сильной типизацией не позволяют смешивать сущности разных типов в выражениях и не выполняют никаких автоматических преобразований. Также их называют «языки с строгой типизацией». Английский термин для этого — strong typing.
Слабо типизированные языки, наоборот всячески способствуют, чтобы программист смешивал разные типы в одном выражении, причем компилятор сам приведет все к единому типу. Также их называют «языки с нестрогой типизацией». Английский термин для этого — weak typing.
Слабую типизацию часто путают с динамической, что совершенно неверно. Динамически типизированный язык может быть и слабо и сильно типизирован.
Однако мало, кто придает значение строгости типизации. Часто заявляют, что если язык статически типизирован, то Вы сможете отловить множество потенциальных ошибок при компиляции. Они Вам врут!
Язык при этом должен иметь еще и сильную типизацию. И правда, если компилятор вместо сообщения об ошибке будет просто прибавлять строку к числу, или что еще хуже, вычтет из одного массива другой, какой нам толк, что все «проверки» типов будут на этапе компиляции? Правильно — слабая статическая типизация еще хуже, чем сильная динамическая! (Ну, это мое мнение)
Так что-же у слабой типизации вообще нет плюсов? Возможно так выглядит, однако несмотря на то, что я ярый сторонник сильной типизации, должен согласиться, что у слабой тоже есть преимущества.
Хотите узнать какие?
##### Преимущества сильной типизации
* Надежность — Вы получите исключение или ошибку компиляции, взамен неправильного поведения.
* Скорость — вместо скрытых преобразований, которые могут быть довольно затратными, с сильной типизацией необходимо писать их явно, что заставляет программиста как минимум знать, что этот участок кода может быть медленным.
* Понимание работы программы — опять-же, вместо неявного приведения типов, программист пишет все сам, а значит примерно понимает, что сравнение строки и числа происходит не само-собой и не по-волшебству.
* Определенность — когда вы пишете преобразования вручную вы точно знаете, что вы преобразуете и во что. Также вы всегда будете понимать, что такие преобразования могут привести к потере точности и к неверным результатам.
##### Преимущества слабой типизации
* Удобство использования смешанных выражений (например из целых и вещественных чисел).
* Абстрагирование от типизации и сосредоточение на задаче.
* Краткость записи.
Ладно, мы разобрались, оказывается у слабой типизации тоже есть преимущества! А есть ли способы перенести плюсы слабой типизации в сильную?
Оказывается есть и даже два.
##### Неявное приведение типов, в однозначных ситуациях и без потерь данных
Ух… Довольно длинный пункт. Давайте я буду дальше сокращать его до «ограниченное неявное преобразование» Так что же значит однозначная ситуация и потери данных?
Однозначная ситуация, это преобразование или операция в которой сущность сразу понятна. Вот например сложение двух чисел — однозначная ситуация. А преобразование числа в массив — нет (возможно создастся массив из одного элемента, возможно массив, с такой длинной, заполненный элементами по-умолчанию, а возможно число преобразуется в строку, а затем в массив символов).
Потеря данных это еще проще. Если мы преобразуем вещественное число 3.5 в целое — мы потеряем часть данных (на самом деле эта операция еще и неоднозначная — как будет производиться округление? В большую сторону? В меньшую? Отбрасывание дробной части?).
Преобразования в неоднозначных ситуациях и преобразования с потерей данных — это очень, очень плохо. Ничего хуже этого в программировании нет.
Если вы мне не верите, изучите язык PL/I или даже просто поищите его спецификацию. В нем есть правила преобразования между ВСЕМИ типами данных! Это просто ад!
Ладно, давайте вспомним про ограниченное неявное преобразование. Есть ли такие языки? Да, например в Pascal Вы можете преобразовать целое число в вещественное, но не наоборот. Также похожие механизмы есть в C#, Groovy и Common Lisp.
Ладно, я говорил, что есть еще способ получить пару плюсов слабой типизации в сильном языке. И да, он есть и называется полиморфизм конструкторов.
Я поясню его на примере замечательного языка Haskell.
Полиморфные конструкторы появились в результате наблюдения, что чаще всего безопасные неявные преобразования нужны при использовании числовых литералов.
Например в выражении `pi + 1`, не хочется писать `pi + 1.0` или `pi + float(1)`. Хочется написать просто `pi + 1`!
И это сделано в Haskell, благодаря тому, что у литерала 1 нет конкретного типа. Это ни целое, ни вещественное, ни комплексное. Это же просто число!
В итоге при написании простой функции `sum x y`, перемножающей все числа от x до y (с инкрементом в 1), мы получаем сразу несколько версий — sum для целых, sum для вещественных, sum для рациональных, sum для комплексных чисел и даже sum для всех тех числовых типов что Вы сами определили.
Конечно спасает этот прием только при использовании смешанных выражений с числовыми литералами, а это лишь верхушка айсберга.
Таким образом можно сказать, что лучшим выходом будет балансирование на грани, между сильной и слабой типизацией. Но пока идеальный баланс не держит ни один язык, поэтому я больше склоняюсь к сильно типизированным языкам (таким как Haskell, Java, C#, Python), а не к слабо типизированным (таким как C, JavaScript, Lua, PHP).
Ладно, пойдем дальше?
#### Явная и неявная типизации
Язык с явной типизацией предполагает, что программист должен указывать типы всех переменных и функций, которые объявляет. Английский термин для этого — explicit typing.
Язык с неявной типизацией, напротив, предлагает Вам забыть о типах и переложить задачу вывода типов на компилятор или интерпретатор. Английски термин для этого — implicit typing.
По-началу можно решить, что неявная типизация равносильна динамической, а явная — статической, но дальше мы увидим, что это не так.
Есть ли плюсы у каждого вида, и опять же, есть ли их комбинации и есть ли языки с поддержкой обоих методов?
##### Преимущества явной типизации
* Наличие у каждой функции сигнатуры (например `int add(int, int)`) позволяет без проблем определить, что функция делает.
* Программист сразу записывает, какого типа значения могут храниться в конкретной переменной, что снимает необходимость запоминать это.
##### Преимущества неявной типизации
* Сокращение записи — `def add(x, y)` явно короче, чем `int add( int x, int y)`.
* Устойчивость к изменениям. Например если в функции временная переменная была того-же типа, что и входной аргумент, то в явно типизированном языке при изменении типа входного аргумента нужно будет изменить еще и тип временной переменной.
Хорошо, видно, что оба подхода имеют как плюсы так и минусы (а кто ожидал чего-го еще?), так давайте поищем способы комбинирования этих двух подходов!
##### Явная типизация по-выбору
Есть языки, с неявной типизацией по-умолчанию и возможностью указать тип значений при необходимости. Настоящий тип выражения транслятор выведет автоматически. Один из таких языков — Haskell, давайте я приведу простой пример, для наглядности:
```
-- Без явного указания типа
add (x, y) = x + y
-- Явное указание типа
add :: (Integer, Integer) -> Integer
add (x, y) = x + y
```
Примечание: я намерено использовал некаррированную функцию, а также намерено записал частную сигнатуру вместо более общей `add :: (Num a) => a -> a -> a`\*, т.к. хотел показать идею, без объяснения синтаксиса Haskell'а.
\* Спасибо [int\_index](https://habrahabr.ru/users/int_index/) за нахождение ошибки.
Хм. Как мы видим, это очень красиво и коротко. Запись функции занимает всего 18 символов на одной строчке, включая пробелы!
Однако автоматический вывод типов довольно сложная вещь, и даже в таком крутом языке как Haskell, он иногда не справляется. (как пример можно привести ограничение мономорфизма)
Есть ли языки с явной типизацией по-умолчанию и неявной по-необходимости? Кон
ечно.
##### Неявная типизация по-выбору
В новом стандарте языка C++, названном C++11 (ранее назывался C++0x), было введено ключевое слово auto, благодаря которому можно заставить компилятор вывести тип, исходя из контекста:
```
Давайте сравним:
// Ручное указание типа
unsigned int a = 5;
unsigned int b = a + 3;
// Автоматический вывод типа
unsigned int a = 5;
auto b = a + 3;
```
Неплохо. Но запись сократилась не сильно. Давайте посмотрим пример с итераторами (если не понимаете, не бойтесь, главное заметьте, что запись благодаря автоматическому выводу очень сильно сокращается):
```
// Ручное указание типа
std::vector vec = randomVector( 30 );
for ( std::vector::const\_iterator it = vec.cbegin(); ... ) {
...
}
// Автоматический вывод типа
auto vec = randomVector( 30 );
for ( auto it = vec.cbegin(); ... ) {
...
}
```
Ух ты! Вот это сокращение. Ладно, но можно ли сделать что-нибудь в духе Haskell, где тип возвращаемого значения будет зависеть от типов аргументов?
И опять ответ да, благодаря ключевому слову decltype в комбинации с auto:
```
// Ручное указание типа
int divide( int x, int y ) {
...
}
// Автоматический вывод типа
auto divide( int x, int y ) -> decltype(x / y) {
...
}
```
Может показаться, что эта форма записи не сильно хороша, но в комбинации с обобщенным программированием (templates / generics) неявная типизация или автоматический вывод типов творят чудеса.
Некоторые языки программирования по данной классификации
Я приведу небольшой список из популярных языков и напишу как они подразделяются по каждой категории “типизаций”.
```
JavaScript - Динамическая | Слабая | Неявная
Ruby - Динамическая | Сильная | Неявная
Python - Динамическая | Сильная | Неявная
Java - Статическая | Сильная | Явная
PHP - Динамическая | Слабая | Неявная
C - Статическая | Слабая | Явная
C++ - Статическая | Слабая | Явная
Perl - Динамическая | Слабая | Неявная
Objective-C - Статическая | Слабая | Явная
C# - Статическая | Сильная | Явная
Haskell - Статическая | Сильная | Неявная
Common Lisp - Динамическая | Сильная | Неявная
D - Статическая | Сильная | Явная
Delphi - Статическая | Сильная | Явная
```
Примечания к таблице (за идею и напоминание о C# спасибо [qxfusion](https://habrahabr.ru/users/qxfusion/)):
* C# — поддерживает динамическую типизацию, посредством специального псевдо-типа dynamic с версии 4.0. Поддерживает неявную типизацию с помощью dynamic и var.
* С++ — после стандарта C++11 получил поддержку неявной типизации с помощью ключевых слов auto и decltype. Поддерживает динамическую типизацию, при использовании библиотеки Boost (boost::any, boost::variant). Имеет черты как сильной так и слабой типизации.
* Common Lisp — стандарт предусматривает декларации типов, которые некоторые реализации могут использовать также для статической проверки типов.
* D — также поддерживает неявную типизацию.
* Delphi — поддерживает динамическую типизацию посредством специального типа Variant.
Возможно я где-то ошибся, особенно с CL, PHP и Obj-C, если по какому-то языку у Вас другое мнение — напишите в комментариях.
### Заключение
Окей. Уже скоро будет светло и я чувствую, что про типизацию больше нечего сказать. Ой как? Тема бездонная? Очень много осталось недосказано? Прошу в комментарии, поделитесь полезной информацией.
И удачи!
#### Полезные ссылки
[Прогопедия: типизации](http://progopedia.ru/typing/)
[Википедия: типизация](http://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
[Квадранты типизации в языках программирования](http://love5an.livejournal.com/364869.html) | https://habr.com/ru/post/161205/ | null | ru | null |
# Библиотека эмуляции терминала ROTE и Lua привязки
[ROTE](http://rote.sourceforge.net/) — простая библиотека на языке C, служащая для эмуляции [терминала VT100](https://en.wikipedia.org/wiki/VT100). Она создает терминал и предоставляет доступ к его состоянию в виде структуры языка C. В терминале можно запустить дочерний процесс, «нажимать» в нем клавиши и смотреть, что он рисует на терминале. Кроме того, есть функция для отрисовки состояния терминала в окне curses.
Зачем на практике может потребоваться эмулировать терминал и взаимодействовать через него с дочерним процессом? В первую очередь это нужно для автоматического тестирования программ, рисующих что-то на терминале с помощью curses, по моему мнению. Как иначе написать тесты для программы, которая ждёт, что пользователь нажмёт клавишу, и выводит результаты в определенное место экрана средствами curses?
Несмотря на всё удобство и внутреннюю красоту ROTE, использовать её напрямую в тестах было бы громоздко. Поэтому я решил упростить задачу, привязав ROTE к языку Lua, который я очень люблю и знаю, [как](http://olivinelabs.com/busted/) писать тесты. Так и родилась библиотека [lua-rote](https://starius.github.io/lua-rote/), о которой я хочу рассказать.
### Установка
Потребуется Linux, curses, Lua версии от 5.1 до 5.3 или LuaJIT, пакетный менеджер luarocks с установленными пакетом luaposix и, собственно, сама библиотека [ROTE](http://rote.sourceforge.net/).
ROTE устанавливается простым ./configure && make && make install. Надо отследить, чтобы она установилась туда, где её увидит система сборки. Я использую для этого ./configure --prefix=/usr. Чтобы не замусоривать систему бесхозными файлами, можно сделать пакет, для этого подойдёт программа [checkinstall](https://wiki.debian.org/CheckInstall).
lua-rote добавлен в luarocks, поэтому для его установки достаточно набрать следующую команду:
```
$ sudo luarocks install lua-rote
```
Если ROTE установили в /usr/local, то об этом надо сообщить luarocks'у посредством опции:
```
$ sudo luarocks install lua-rote ROTE_DIR=/usr/local
```
Чтобы установить версию с GitHub, введите следующие команды:
```
$ git clone https://github.com/starius/lua-rote.git
$ cd lua-rote
$ sudo luarocks make
```
Чтобы устанавливать пакеты в luarocks локально (то есть в домашнюю папку пользователя, а не в системные папки), добавьте опцию --local. В таком случае потребуется изменить кое-какие переменные окружения, чтобы Lua увидел эти пакеты:
```
$ luarocks make --local
$ luarocks path > paths
$ echo 'PATH=$PATH:~/.luarocks/bin' >> paths
$ . paths
```
### Использование
Вся библиотека lua-rote находится в модуле rote, так что для начала подключим его:
```
rote = require 'rote'
```
Основная часть библиотеки — класс RoteTerm, представляющий терминал.
Создадим терминал из 24 строк и 80 столбцов:
```
rt = rote.RoteTerm(24, 80)
```
Чтобы удалить терминал, надо просто удалить переменную, в которой он живёт. В Lua работает сборщик мусора, который при очередном проходе сделает всю работу по удалению.
Запустим дочерний процесс:
```
pid = rt:forkPty('less /some/file')
```
Команда запускается при помощи '/bin/sh -c'. В переменную pid попадает идентификатор дочернего процесса. Позже его можно выяснить с помощью метода childPid(). В случае ошибки метод возвращает -1. Если попытаться запустить неправильную команду, то ошибка не будет отловлена на этом уровне: shell попытается запустить её и завершится со статусом 127. Чтобы перехватывать подобные ошибки, надо устанавливать обработчик сигнала SIGCHLD. Чтобы игнорировать завершение дочерних процессов, надо установить обработчик SIGCHLD в значение SIG\_IGN. В Lua всё это можно сделать с помощью библиотеки [luaposix](https://luaposix.github.io/luaposix/modules/posix.signal.html):
```
signal = require 'posix.signal'
signal.signal(signal.SIGCHLD, function(signo)
-- do smth
end)
signal.signal(signal.SIGCHLD, signal.SIG_IGN)
```
Взаимодействие с терминалом, в котором дочерний процесс завершился, не является ошибкой, хотя вряд ли имеет смысл. Тем не менее, стоит уведомить ROTE о завершении дочернего процесса, вызвав метод forsakeChild().
#### Чтение содержимого терминала
У терминала есть ряд методов, возвращающих его параметры и состояние:
* rt:rows() и rt:cols() — число строк и столбцов терминала
* rt:row() и rt:col() — текущие координаты курсора
* rt:update() — применяет изменения, пришедшие от дочернего процесса; вызывать перед чтением содержимого терминала
* rt:cellChar(row, col) — символ ячейки (row, col) в форме строки длины 1
* rt:cellAttr(row, col) — атрибуты ячейки (row, col) в форме числа (см. ниже, что с ним делать)
* rt:attr() — текущие атрибуты, которые применяются к новым символам
* rt:rowText(row) — строка терминала номер row, без "\n" на конце
* rt:termText() — строка, представляющая весь терминал; ряды завершаются "\n"
Ещё есть метод draw для рисования содержимого терминала в окне curses:
```
curses = require 'posix.curses'
-- инициализация curses, см. ниже demo/boxshell.lua
window = ...
rt = ...
start_row = 0
start_col = 0
rt:draw(window, start_row, start_col)
```
#### Запись в терминал
Есть несколько методов, позволяющих менять состояние терминала напрямую:
* rt:setCellChar(row, col, character) — заменяет символ ячейки (row, col)
* rt:setCellAttr(row, col, attr) — заменяет атрибуты ячейки (row, col)
* rt:setAttr(attr) — меняет текущие атрибуты, которые применяются к новым символам
* rt:inject(data) — вводит данные в терминал
Более важны методы, посылающие данные в дочерний процесс:
```
-- Отправляет последовательность ':wq\n' в терминал
-- Если есть дочерний процесс, данные передаются ему.
-- Иначе данные напрямую вставляются в терминал при помощи inject()
rt:write(':wq\n') -- сохраняем документ и закрываем vim
-- Отправляет нажатие клавиши дочернему процессу через write()
local keycode = string.byte('\n') -- число
rt:keyPress(keycode)
```
Коллекцию кодов клавиш для keyPress можно найти в [curses](https://luaposix.github.io/luaposix/modules/posix.curses.html#Constants). К сожалению, эти константы появляются в модуле только после инициализации curses, которую часто производить нежелательно (например, в коде тестов). Чтобы как-то жить с этим, был сделан модуль [rote.cursesConsts](https://github.com/starius/lua-rote/blob/master/src/cursesConsts.lua), запускающий curses в дочернем процессе через ROTE и возвращающий все константы.
#### Снимки состояния терминала
Метод rt:takeSnapshot() возвращает объект-снимок, а метод rt:restoreSnapshot(snapshot) восстанавливает состояние терминала согласно снимку. Объект-снимок также удаляется автоматически сборщиком мусора.
#### Атрибуты и цвета
Атрибут — это 8-битное число, в котором хранится цвет букв, цвет фона, бит полужирного текста (bold bit) и бит мигающего текста (blink bit). Порядок битов следующий:
```
бит: 7 6 5 4 3 2 1 0
содержимое: S F F F H B B B
| `-,-' | `-,-'
| | | |
| | | `----- 3 бита цвета фона (0 - 7)
| | `--------- бит мигающего текста
| `------------- 3 бита цвета букв (0 - 7)
`----------------- бит полужирного текста
```
Есть пара функций для упаковки и распаковки значения атрибута:
```
foreground, background, bold, blink = rote.fromAttr(attr)
attr = rote.toAttr(foreground, background, bold, blink)
-- foreground и background - числа (0 - 7)
-- bold и blink - логические переменные
```
Коды цветов:
* 0 = черный
* 1 = красный
* 2 = зеленый
* 3 = желтый
* 4 = синий
* 5 = фиолетовый
* 6 = голубой
* 7 = белый
В модуле rote есть таблицы перевода между кодами цветов и названиями цветов:
```
rote.color2name[2] -- возвращает "green"
rote.name2color.green -- возвращает 2
```
### Пример использования
А ещё я занимаюсь биоинформатикой :)
Давно хотелось иметь программу для просмотра выравниваний вроде [Jalview](http://www.jalview.org/), но прямо в терминале, так как часто файлы находятся на сервере, к которому я подключён через ssh. В таких случаях нужно что-то вроде less для fasta-файлов. Всё, что мне удалось найти на эту тему, — программа [tview](http://samtools.sourceforge.net/tview.shtml) для просмотра ридов, но это немного не то.
В результате я написал программу [alnbox](https://github.com/starius/alnbox), которая именно это и делает: показывает выравнивание ДНК в curses, позволяет «ходить» по нему стрелочками, перемещаться в начало и в конец. Названия последовательностей отображаются слева, номера позиций — сверху, консенсус — снизу. Код написан несколько шире, поэтому может пригодиться не только для выравниваний, но и любых less-подобных программ с заголовками вдоль всех 4-ех сторон терминала. Весь код программы написан на Lua, без использования C.
С помощью lua-rote и [busted](http://olivinelabs.com/busted/) написаны [тесты для alnbox](https://github.com/starius/alnbox/tree/master/spec), в которых проигрываются все возможные варианты работы с программой. За основу кода интеграции тестов в Travis CI взят костяк [lua-travis-example](https://github.com/moteus/lua-travis-example) от [moteus](https://github.com/moteus).
Проект пока незавершён, но смотреть выравнивания уже можно. Зависимости те же + сам lua-rote. Для установки наберите команду luarocks make.
### Ещё один пример использования
Вместе с библиотекой ROTE распространяется файл [demo/boxshell.c](https://gist.github.com/starius/c57f0f352fa0775cb91f). Это по сути терминал в терминале: bash запускается внутри ROTE, а состояние ROTE рисуется в curses при помощи метода draw(). Этот пример я [перенёс](https://github.com/starius/lua-rote/blob/master/demo/boxshell.lua) в Lua. В начале статьи показан пример работы в этом терминале.
В Lua-версию boxshell внесено несколько исправлений. Во-первых, можно запустить в качестве дочернего процесса любую команду, а не только bash. Во-вторых, переделано чтение нажатых клавиш от пользователя: вместо nodelay используется halfdelay, то есть ожидание нажатия клавиши с таймаутом. Благодаря этому нагрузка на процессор со стороны boxshell снижена с 100% до менее чем 1%.
### Баги
* Нет поддержки юникода.
* Метод draw() может [чудить](https://travis-ci.org/starius/lua-rote/jobs/54479120#L1160) при запуске в Travis CI. Воспроизвести этот баг у себя не удаётся. Точной причины я не знаю, но подозреваю, что дело в особенностях терминала, который предоставляет Travis CI.
* Возвращает неправильные данные, если у терминала мало столбцов (пример: терминал 1x2).
[Сообщить о баге](https://github.com/starius/lua-rote/issues/new)
[Исходный код ROTE](http://rote.sourceforge.net/) был написан в 2004 году Бруно Т. К. де Оливейра (Bruno T. C. de Oliveira) и опубликован под лицензией GNU Lesser General Public License 2.1. [Исходный код lua-rote](https://github.com/starius/lua-rote) опубликован под той же лицензией. Автор ROTE пишет, что разработка библиотеки завершена и обновления стоит искать в библиотеке [libvterm](https://sourceforge.net/projects/libvterm//), которая основана на ROTE. Есть [ещё один проект](http://www.leonerd.org.uk/code/libvterm) с названием libvterm, который развивается активнее и есть [модификация](https://github.com/neovim/libvterm) для проекта NeoVim. Для моих текущих целей ROTE хватило, и она выглядит более простой, поэтому пока я остановился именно на ней. Возможно, потом перейду к одному из libvterm.
### Ссылки
* [GitHub](https://github.com/starius/lua-rote)
* [Home page](https://starius.github.io/lua-rote)
* [Сообщить о баге](https://github.com/starius/lua-rote/issues/new)
* [Сообщение в списке рассылки lua-l](http://lua-users.org/lists/lua-l/2015-03/msg00325.html)
* [Ветка обсуждения на Reddit](https://www.reddit.com/r/lua/comments/30ast4/ann_luarote_lua_binding_to_rote_terminal/)
* [ROTE](http://rote.sourceforge.net)
* [Busted](http://olivinelabs.com/busted/), фреймворк для тестирования кода на Lua
* [lua-travis-example](https://github.com/moteus/lua-travis-example), костяк для интеграции Lua-проекта в Travis CI | https://habr.com/ru/post/254089/ | null | ru | null |
# Найти и заблокировать: поиск фишера при помощи Maltego
Команда безопасности REG.RU в работе часто сталкивается с мошенниками, любителями спама, фишинговыми доменами, взломом аккаунтов, попытками угона доменов и т. д. На примере поиска создателя фишинговых сайтов я расскажу, как мы вычисляем подобных нарушителей с помощью Maltego.
Заранее отмечу, что:
* определить факт мошенничества и вынести наказание могут только правоохранительные органы. Но мы проводим и собственные расследования на основе тех данных, что у нас есть, чтобы самостоятельно принять законные меры при очевидном правонарушении;
* статья не рекламная, все примеры, кейсы, имена (как собственные, так и доменные) вымышлены, любые совпадения случайны.
### Немного о Maltego
**Maltego** – это программа для сбора информации из разных источников и последующего её представления в удобном виде. Активно используется в расследованиях и разведке на основе открытых и закрытых источников.
Информация в программе визуализируется в виде графа:
Граф состоит из объектов (Entities) и связей между ними (Links). В качестве объекта может выступать любая единица информации: доменное имя, IP-адрес, организация, данные клиента (ФИО и номер телефона) и др.
Добавлять объекты и связи можно вручную или автоматически при помощи трансформаций (Transforms) ― скриптов, которые находят данные о существующих объектах в разных источниках и добавляют эти данные на граф уже в виде новых объектов. Есть набор готовых трансформаций под разные задачи. Например, если нужна информация об IP-адресе, то при помощи встроенных трансформаций можно узнать данные из Whois, местоположение, репутацию адреса (Fraud-check) и проверить по нодам Tor’a.
Расширить набор трансформаций можно в Transforms Hub ― встроенном маркетплейсе.
Для некоторых трансформаций может понадобиться API-ключ сервиса, из которого нужно достать данные.
Для работы с данными из внутренних источников можно создать свои трансформации.
Maltego распространяется в двух вариантах ― бесплатном и платном. Бесплатные версии ― CaseFile и Community Edition. Коммерческий вариант называется Maltego One и имеет три тарифа: Pro, Enterprise и Enterprise On-premise. Актуальные издания и их фичи доступны [на официальном сайте](https://www.maltego.com/maltego-desktop-client-versions/).
### Кейс с фишинговыми сайтами
А теперь рассмотрим вымышленное, но вполне типичное расследование.
**Задача:** найти создателя фишинговых сайтов, а также все его домены и аккаунты. Прежде чем забанить аккаунты мошенника, а на его домены завести процедуру идентификации данных администратора, необходимо убедиться, что домены фишинговые.
**Что у нас есть:** для регистрации нового аккаунта на REG.RU нужно указать электронную почту и телефонный номер. А чтобы зарегистрировать домен, ещё и ФИО с паспортными данными (зависит от доменной зоны). В логах можно найти IP-адреса, cookie, User-Agent и другие параметры системы злоумышленника. Из всех этих данных можно составить цифровой отпечаток предполагаемого нарушителя. Чем больше входных данных, тем больше шанс найти взаимосвязи.
Обрабатывать и сопоставлять большие объемы данных из разных источников вручную ― трудозатратно и скучно. Поэтому я буду использовать Maltego. С его помощью, написав свои скрипты, можно читать логи и базы данных, а затем вывести результат в виде графа с объектами и связями между ними.
Для начала надо создать новый граф и разместить на нем домен MOB-VTB24.RU. На панели инструментов (Entity Palette) есть объекты разных типов, которые можно переместить в рабочую область. Перетащу объект «Domain» из панели на граф и укажу нужное доменное имя.
Еще объекты можно добавлять из буфера обмена с автоматическим распознаванием типа. Если распознается неправильно, можно поправить вручную из меню «Change Type».
### Добавление новых типов объектов
Теперь можно получить информацию о владельце домена, указанную при регистрации:
* ФИО,
* номер,
* email,
* логин аккаунта, в котором находится домен.
Нужно создать новый тип объекта ― «User», и написать трансформации для поиска домена по нашей базе (в статье все запросы в базу упрощены).
Во вкладке «Entities» создаю объект «User» и задаю для него основное свойство ― «user\_id».
Объект создан. Пора написать трансформацию, которая выведет данные домена и аккаунта на граф в виде объектов и связей.
### Создание трансформаций
Для написания трансформаций я использовал библиотеку [maltego\_trx](https://github.com/paterva/maltego-trx) для Python 3.6 и выше. Команда для ее установки:
`pip install maltego-trx`
Команда для создания нового проекта:
`maltego-trx start new_project`
Файлы трансформаций будут храниться в *new\_project/transforms/*.
Теперь создам новый класс и унаследую его от «DiscoverableTransform». Переопределяю метод «create\_entities», внутри которого будет вся логика поиска данных и добавления объектов на граф. За размещение объектов на графе отвечает метод «response.addEntity».
```
from maltego_trx.transform import DiscoverableTransform
import MySQLdb
# Наследуем наш класс от DiscoverableTransform
class SearchDomain(DiscoverableTransform):
"""
Выполняет поиск домена.
"""
# Переопределяем метод create_entities
@classmethod
def create_entities(cls, request, response):
# Получаем входящее значение
email = request.Value
# Инициализируем подключение к базе
db = MySQLdb.connect(host='database.host',
port='3306',
user='user',
passwd='password',
db='db',
charset="utf8")
cursor = db.cursor(MySQLdb.cursors.DictCursor)
# Выполняем поиск по таблице domains
cursor.execute("""select user_id, name, phone, email
from domain
where domain = %s
""", [domain])
rows = cursor.fetchall()
# В зависимости от поля добавляем на граф
# объекты соответствующих типов
for row in rows:
response.addEntity('yourorganization.User', row['user_id'])
response.addEntity('maltego.Person', row['name'])
response.addEntity('maltego.PhoneNumber', row['phone'])
response.addEntity('maltego.EmailAddress', row['email'])
```
При добавлении объекта нужно использовать тот «Unique Type Name», который указывался при создании объекта «User». В моем случае это «yourorganization.User». Классы же для встроенных объектов можно импортировать из библиотеки.
```
from maltego_trx.entities import Person
...
response.addEntity(Person, row['name'])
```
Если объектов много, можно сделать маппинг полей и объектов.
```
field_map = {
'user_id': 'yourorganization.User',
'name': 'maltego.Person',
'phone': 'maltego.PhoneNumber',
'email': 'maltego.EmailAddress'
}
for row in rows:
for field in row:
if field_map.get(field):
response.addEntity(field_map[field], row[field])
```
### Добавление трансформаций
Готовую трансформацию надо добавить в Maltego. Для этого во вкладке «Transforms» выбираю «New Local Transform» и заполняю поля. В поле «Input Entity Type» выбираю тип объекта, с которым работает трансформация:
Указываю путь к интерпретатору Python3:
Где:
* **project.py** ― основной скрипт;
* **local ―** говорит о том, что трансформация работает локально;
* **searchdomain** ― имя трансформации, соответствующее названию класса.
Чтобы проверить, правильно ли создан класс, можно вывести список всех трансформаций проекта при помощи команды *python3 project.py list*.
### Запуск трансформаций
Теперь можно запустить трансформацию:
В результате работы на графе появились объекты:
Логи работы трансформации пишутся в Output. Туда же можно вывести отладочную информацию для поиска ошибок в работе скрипта. Для этого в настройках трансформации нужно активировать «Show debug info».
Через интерфейс или код можно помечать объекты на графе и добавлять к ним комментарии:
```
from maltego_trx.maltego import BOOKMARK_CLRS
...
...
me = response.addEntity(
'yourorganization.User', user_id
)
me.setBookmark(BOOKMARK_CLRS["red"]) #добавить заметку
me.setNote("Регистрирует фишинговые домены") #добавить флажок
```
Тем временем уже удалось найти подозреваемого. На графе есть его ФИО, почта и телефон. По этим данным можно сделать обратный поиск.
### Обратный поиск
Для обратного поиска нужны новые трансформации. Добавляю их по аналогии с «SearchDomain» и запускаю поиск. Результат ― новые домены и аккаунт.
Найденные доменные имена выглядят подозрительно, так как связаны с банками и сервисами BlaBlaCar и Drom.
После повторного поиска **только** по номеру получаю еще 88 доменов:
Выгружаю информацию по новым аккаунтам и получаю новые почтовые ящики и телефоны. Чтобы найти IP-адреса, с которых входили в аккаунты, использую в поиске логи авторизации.
При повторных поисках с использованием новых объектов получилась вот такая сеть:
Чтобы получить полный список доменов, упрощу большой и непонятный граф сортировкой данных по типу. Получившийся список уже можно экспортировать в нужном формате.
Осталось убрать из графа ненужные объекты и выгрузить финальный список доменов и аккаунтов. По нему уже можно работать над блокировкой аккаунтов и доменов.
Так выглядит один из возможных вариантов работы с Maltego при расследованиях и анализе большого объема информации. В дальнейшем можно добавить больше источников и улучшить скрипты, чтобы уберечь потенциальных жертв от мошенничества.
### Заключение
Maltego упрощает расследования за счет автоматизации поиска и понятной визуализации данных. Инструмент подходит как для внутренних расследований, так и для поиска информации в открытых источниках (OSINT ― Open source intelligence). Очевидно, что в статье я охватил далеко не все его возможности: тут есть удобные функции для анализа информации на графе, есть возможности экспорта данных, а поиск можно прокачать, объединив скрипты в «машины». Дайте знать, если интересно узнать о чем-то подробнее.
А еще рекомендую цикл статей про Maltego от [@Wolchara000](https://habr.com/ru/users/Wolchara000/).
Статьи цикла[Часть 1 — 4 релиза Maltego. Принципы работы и возможности](https://habr.com/ru/company/tomhunter/blog/462457/)
[Часть 2 — Maltego ближе к телу](https://habr.com/ru/company/tomhunter/blog/466799/)
[Часть 3 — Facebook плачет, Social Links смеется, Maltego курит](https://habr.com/ru/company/tomhunter/blog/486338/)
[Часть 4 — ВК, Instagram, LinkedIN и другие фантастические твари](https://habr.com/ru/company/tomhunter/blog/492666/)
[Часть 5 — Твое лицо тебя сдало](https://habr.com/ru/company/tomhunter/blog/493544/)
[Часть 6 — «Дорогой, где ты был? Бегал!» (с)](https://habr.com/ru/company/tomhunter/blog/516026/)
[Часть 7 ― DarkNet matter](https://habr.com/ru/company/tomhunter/blog/526506/) | https://habr.com/ru/post/685656/ | null | ru | null |
# Intel Wireless Display: для разработчика
 Нет, это не ошибка в движке Хабры, и не повтор статьи, опубликованной на прошлой неделе и [посвященной технологии WiDi](http://habrahabr.ru/company/intel/blog/138202/). В этот раз мы поговорим о том, как разработчики могут использовать WiDi в своих приложениях. А Вы знали, что для работы с WiDi существует [WiDi Extension SDK](http://downloadcenter.intel.com/Detail_Desc.aspx?lang=rus&changeLang=true&DwnldID=20410)? Нет? Тогда эта статья для Вас.
Кому из разработчиков это может пригодиться? По идее это может ограничиваться только фантазией разработчика. Идеи лежащие на поверхности — это программы для воспроизведения видео или аудио с визуализацией, программы для просмотра фото. Умная программа может определить наличие WiDi в системе и предложить пользователю отображать воспроизводимый контент на экране телевизора. Возможно, что на данный момент эта тема не слишком актуальна — WiDi адаптеров в настоящий момент не так уж и много.
Но в ближайшем будущем, после того как WiDi адаптеры начнут устанавливать сразу в телевизоры, например компания LG уже продемонстрировала первый телевизор на CES 2012 и [собирается начать](http://www.worldtvpc.com/blog/lg-smart-3dtv-widi-builtin-easy-wireless-streaming/) их выпуск в этом году, данная тема заинтересует многих разработчиков.
Для разработчиков, желающих встроить функционал для работы с WiDi в свои приложения, компания Intel выпустила Intel WiDi Extensions SDK. Данный SDK позволяет:
* Определять наличие и работоспособность WiDi
* Поиск и определение адаптеров готовых к подключению
* Подключение к адаптеру
* Изменение параметров экрана, режима отображения (клонировать экран, расширить рабочий стол на второй экран)
В SDK Вы найдете документацию, файлы, необходимые для включения в проект и примеры на C++, C#.
Кстати, для разработки приложения, работающего с WiDi, не обязательно иметь железо, поддерживающее данную технологию. Такое железо понадобится только для тестирования.
Начнем встраивать функционал для работы с WiDi в свою программу.
Для начала необходимо перейти на сайт и скачать [Intel WiDi Extensions SDK](http://downloadcenter.intel.com/Detail_Desc.aspx?lang=rus&changeLang=true&DwnldID=20410). Внутри архива лежит дистрибутив, содержащий сам SDK. Сохраняем, распаковываем, устанавливаем.
Создаем наше тестовое приложение, подключаем к проекту заголовочный файл
```
#include
```
Первое, что необходимо сделать, это создать и инициализировать IWiDiExtensions
```
HRESULT hr;
hr = CoCreateInstance(CLSID_WiDiExtensions, NULL, CLSCTX_INPROC_SERVER, __uuidof(IWiDiExtensions), (LPVOID*)&m_pWiDi);
if(hr == S_OK)
{
hr = m_pWiDi->Initialize((DWORD)m_hWnd);
}
```
Все функции WiDi API являются асинхронными. Для уведомления о результате выполненной операции используются оконные сообщения, посылаемые окну, хэндл которого был передан при вызове функции *Initialize*.
```
HRESULT Initialize(
HWND windowHandle
);
```
Для того, чтобы получить уведомление об успешном окончании инициализации, окно приложения должно уметь обрабатывать сообщение *WM\_WIDI\_INITIALIZED*.
Для получения уведомления об ошибке, возникшей в процессе инициализации, используется сообщение *WM\_WIDI\_INITIALIZATION\_FAILED*. Параметр wParam обработчика сообщения *WM\_WIDI\_INITIALIZATION\_FAILED* будет содержать соответствующий код ошибки:
```
RC_WIDI_APP_NOT_FOUND // Не установлено приложение для работы с WiDi
RC_WIDI_FAILED_TO_START // Не удалось запустить приложение для работы с WiDi
RC_INTERNAL_ERROR // Произошла внутренняя ошибка
RC_WIDI_APPLICATION_ERROR // Неизвестная ошибка
```
После успешной инициализации можно приступать к поиску доступных WiDi адаптеров. Делается это с помощью функции *StartScanForAdapters*
```
HRESULT StartScanForAdapters();
```
Для уведомления о найденном адаптере используется сообщение *WM\_WIDI\_ADAPTER\_DISCOVERED*. Параметр lParam будет указатель на идентификатор адаптера. Данный идентификатор необходим для подключения к выбранному адаптеру.
После окончания поиска окно получит сообщение *WM\_WIDI\_SCAN\_COMPLETE*. Параметр wParam будет содержать код, анализ которого поможет определить, по какой причине было завершено сканирование:
```
RC_SUCCESS // Поиск успешно завершен
RC_UNABLE_TO_START_SCAN // Поиск не удалось запустить
RC_INTERNAL_ERROR // Произошла внутренняя ошибка
RC_WIDI_APPLICATION_ERROR // Произошла внутренняя ошибка приложения для работы с WiDi
RC_CONNECT_CANCELLED_SCAN // Поиск был прерван
```
Если было обнаружено одно и более устройство, можно приступать к подключению. Подключение осуществляется вызовом функции *StartConnectionToAdapter*.
```
HRESULT StartConnectionToAdapter(
BSTR AdapterUniqueID,
int SourceScreenResolution,
int TargetScreenResolution,
ScreenMode Mode
);
```
После успешного подключения окно получит сообщение *WM\_WIDI\_CONNECTED*. В случае возникновения проблем — *WM\_WIDI\_DISCONNECT\_FAILED*, параметр wParam будет содержать код:
```
RC_CONNECTION_DROPPED // Подключение не было установлено
RC_USER_DISCONNECT // Подключение было прервано пользователем
```
В параметр *lParam* будет передан идентификатор адаптера.
На этом пока все. Для получения более подробной информации о возможностях WiDi Extensions SDK Вы можете изучить документацию, которая поставляется в комплекте с SDK. Будут вопросы — задавайте здесь, в комментариях, либо на форуме [Intel Software Network](http://software.intel.com/ru-ru/forums/). | https://habr.com/ru/post/138795/ | null | ru | null |
# Анализ производительности CSS-анимаций
Что выбрать для анимирования элементов веб-страниц? JavaScript или CSS? Этот вопрос однажды вынужден будет задать себе каждый веб-разработчик. А может — и не однажды.
JavaScript-программисты создали множество библиотек для браузерной анимации. И, похоже, все вокруг оказались склонны к тому, чтобы использовать эти библиотеки в виде готового решения для анимации. Но давайте-ка притормозим. Правильно ли это? Следует ли анимировать элементы веб-страниц с помощью JavaScript? Может, можно положиться на стандартные механизмы CSS и добиться тем самым качественной и высокопроизводительной анимации?
[](https://habr.com/ru/company/ruvds/blog/501644/)
Так как вы это читаете, я могу предположить, что вы знакомы с JavaScript-анимацией. Поэтому предлагаю исследовать тему CSS-анимации в разных её проявлениях, а так же — предлагаю поговорить о производительности такой анимации.
Общие сведения
--------------
Анимация в CSS основана на некоторых свойствах элементов. Среди них можно отметить следующие:
* Свойство `position`, которое, в частности, может принимать значения `absolute` и `relative`.
* Свойство `transform`.
* Свойство `opacity`.
* Свойства `left`, `right`, `top`, `bottom`.
Для начала взглянем на пару экспериментальных проектов, в которых для анимирования элементов используются различные CSS-свойства.
[Вот](https://codepen.io/vpsk/pen/vYYwKwm) проект, в котором анимируется элемент с идентификатором `animate`, свойство которого `position` установлено в значение `absolute`. Изменениям подвергаются свойства элемента `top` и `left`.
*Страница экспериментального проекта*
Ниже показан код, который реализует эту анимацию.
```
#animate {
position: absolute;
top: 100px;
left: 30px;
width: 100px;
height: 100px;
border-radius: 50%;
background: red;
animation: move 3s ease infinite;
}
@keyframes move {
50% {
top: 200px;
left: 130px;
}
}
```
[Вот](https://codepen.io/vpsk/pen/qBBGNGZ) проект, в котором такая же анимация реализована с помощью CSS-свойства `transform`.
Эта анимация представлена следующим кодом:
```
#animate {
position: absolute;
top: 100px;
left: 30px;
width: 100px;
height: 100px;
border-radius: 50%;
background: red;
animation: move 3s ease infinite;
}
@keyframes move {
50% {
transform: translate(100px, 100px);
}
}
```
Давайте воспользуемся этими проектами для того чтобы сделать выводы о производительности CSS-анимаций, и о том, какие именно ресурсы системы используются для их реализации.
Если просто посмотреть на страницы проектов — можно решить, что реализовано в них одно и то же, хоть и с использованием различных подходов. Однако если измерить показатели производительности этих проектов с использованием инструментов разработчика Chrome, то окажется, что они отличаются.
Как браузер выводит страницу?
-----------------------------
Прежде чем мы углубимся в исследование производительности, нам нужно понять то, как браузер выводит страницу, и то, какие действия он выполняет в том случае, если на странице происходят какие-то изменения.
Вот как выглядит процесс вывода страницы.
*Вывод страницы*
Рассмотрим события, которые отражены на этом рисунке.
1. `Recalculate Style` — вычисление стилей, которые будут применены к элементам.
2. `Layout` — создание макетов элементов и их размещение на странице.
3. `Paint` — заполнение пикселей созданных слоёв, то есть — создание растровых изображений для каждого слоя. GPU будет использовать эти изображения для вывода страницы на экран.
4. `Composite Layer` — компоновка слоёв и вывод их на экран. То, что получится в результате, и будет готовой страницей.
Событие `Composite Layer` — это как раз то время, когда CPU обменивается данными с GPU для создания анимации. Используя CSS-свойства вроде `transform` и `opacity`, мы можем перенести нагрузку по формированию анимации с CPU на GPU.
Анимация и GPU
--------------
GPU — это, по сути, специализированный компьютер, используемый для работы с изображениями. Он может эффективно обрабатывать большие объёмы графической информации.
В результате, когда происходит событие `Composite Layer`, создаётся дополнительный слой. Это — механизм, благодаря которому можно избежать повторного рендеринга анимированного элемента и других элементов интерфейса.
Глядя на следующий рисунок, можно подумать о том, что анимированные элементы расположены на одном и том же слое.
*Анимированные элементы ([оригинал](https://miro.medium.com/max/2000/1*NAtxPqxYdYtC5n1XW9hYpQ.png))*
Но если взглянуть на слои так, будто они расположены в трёхмерном пространстве, окажется, что при реализации анимации с помощью свойства [transform](https://csstriggers.com/transform) для красного круга создаётся дополнительный слой. Это даёт возможность вывода высокопроизводительной плавной анимации.
*Для анимированного объекта создан дополнительный слой ([оригинал](https://miro.medium.com/max/2000/1*Mr1PfpUK5htSQSHxiNAwqQ.png))*
GPU держит дерево рендеринга объектов в памяти, и, не выполняя повторного рендеринга, может поместить соответствующий слой поверх других слоёв. В случае же анимирования объекта с использованием свойств `top` и `left`, тот же слой, из-за изменения свойств, рендерится снова и снова. Если поинтересоваться особенностями поведения этих CSS-свойств, то окажется, что [top](https://csstriggers.com/top) и [left](https://csstriggers.com/left) воздействуют на макет страницы, что приводит к необходимости выполнения повторной отрисовки страницы и повторной компоновки слоёв.
*Анимация с использованием свойства translate и с использованием свойств top и left*
Этот рисунок позволяет увидеть серьёзное отличие между анимацией, реализованной с помощью свойства `translate` и свойств `top` и `left`.
В случае с анимацией, созданной с помощью `top` и `left`, круг рендерится в каждой позиции до тех пор, пока не достигнет крайнего положения. После этого он начинает двигаться к исходному положению.
Ниже показана панель `Performance` инструментов разработчика Chrome со сведениями о процессе анимации.
*Анимация с использованием свойства translate ([оригинал](https://miro.medium.com/max/1400/1*KmWen8fUkU8lBD_ejhcjCA.png))*
*Анимация с использованием свойств top и left ([оригинал](https://miro.medium.com/max/1400/1*-_m_3wOsyVuneD2ukfo0Tw.png))*
Если посмотреть подробные сведения об отдельных задачах, представленных в панели `Performance`, можно сделать вывод о том, что в рамках этих задач выполняются разные действия. Так, в случае с top/left-анимацией, в рамках задачи выполняется пересчёт стилей, компоновка слоёв, обновление дерева слоёв, создание макета и рендеринг. В случае с translate-анимацией единственная задача, решаемая GPU, заключается в перемещении слоя без вывода чего-либо в DOM.
В результате, за счёт применения мощных возможностей GPU, при использовании translate-анимации освобождается главный поток. Это способствует повышению производительности приложения. Применение top/left-анимации приводит к созданию большой дополнительной нагрузки на главный поток.
*Нагрузка на главный поток, создаваемая translate-анимацией (слева) и top/left-анимацией (справа) ([оригинал](https://miro.medium.com/max/2000/1*6HEH7xC5P0-QKiOPcmnE7Q.png))*
Вышеприведённый рисунок наглядно демонстрирует ту нагрузку, которая ложится на главный поток при выполнении top/left-анимации. Это — результат постоянных изменений, которые необходимо обрабатывать для выполнения такой анимации.
Итоги
-----
В результате можно сделать вывод о том, что, применяя CSS-анимации, стоит обращать внимание на то, какие именно ресурсы системы задействуются при их выполнении. По возможности стоит использовать те из них, которые выполняются средствами GPU.
**А какие анимации вы используете в своих проектах?**
[](http://ruvds.com/ru-rub/?utm_source=habr&utm_medium=perevod&utm_campaign=css-animacija#order) | https://habr.com/ru/post/501644/ | null | ru | null |
# Что ждать от внедрения Istio? (обзор и видео доклада)
Istio — частный случай «сервисной сетки» (Service Mesh), понятия, о котором наверняка все слышали, и многие даже знают, что это такое. Мой доклад на [Kuber Conf 2021](https://cloud.yandex.ru/events/369) *(мероприятие Yandex.Cloud, которое проходило 24 июня в Москве)* посвящен возможным проблемам, к которым надо готовиться при внедрении Istio. Среди прочего я рассказал о том, как Istio влияет на трафик, какие есть возможности для его мониторинга, насколько безопасен mTLS.
Доклад отчасти отражает наш опыт работы с Istio как с одним из компонентов Kubernetes-платформы [Deckhouse](https://deckhouse.io/ru/), отчасти основан на результатах внутренних нагрузочных тестов.
Представляю [видео с докладом](https://youtu.be/9CUfaeT3T-A) (~30 минут) и основную выжимку в текстовом виде.
Что такое Service Mesh
----------------------
Для начала синхронизируем понимание, что такое Service Mesh.
Допустим, у вас есть приложение, оно живет своей жизнью, развивается. Вы нанимаете новых программистов, от бизнеса поступают новые задачи. Нормальная эволюция.
При этом объемы сетевого трафика растут, и в этой ситуации вы просто не можете не столкнуться с задачами по его управлению. Разберем эти задачи подробнее.
### Типовая сетевая задача №1
Возьмем небольшой кусочек архитектуры — фронтенд и бэкенд. С точки зрения кластера он выглядит как две группы Pod’ов, которые общаются друг с другом.
Предположим, одному из Pod’ов стало плохо — не терминально, но приложение глючит. Health check'и в Kubernetes этого не замечают: сохраняют Pod в балансировке, и трафик на него продолжает поступать. От этого становится только хуже.
Было бы здорово выявлять эти пограничные состояния, когда вроде бы почти всё окей, но все-таки что-то идет не так. А выявив — дать нашему Pod’у отдохнуть, временно перенаправив трафик на другие Pod’ы. Такой подход называется **circuit breaking**.
### Типовая сетевая задача №2
Вы написали новую версию бэкенда, прошли все тесты, на stage бэкенд показал себя хорошо. Но прежде, чем катить его в production, хорошо бы обкатать на настоящем трафике. То есть выделить группу пользователей для новой версии бэкенда и протестировать его на этой группе.
Если тесты прошли успешно — выкатываем бэкенд в production и обновляем все Pod’ы. Такая стратегия деплоя называется **canary deployment**. *(Подробнее о разных стратегиях деплоя в Kubernetes мы писали* [*здесь*](https://habr.com/ru/company/flant/blog/471620/)*.)*
### Типовая сетевая задача №3
Например, ваш кластер развернут в публичном облаке. Из соображений отказоустойчивости вы «размазали» Pod’ы по разным зонам. При этом фронтенд- и бэкенд-Pod’ы общаются друг с другом беспорядочно, не обращая внимание на зоны. В мире облачных платформ такое беспорядочное общение не будет для вас бесплатным. Например, в AWS это выльется в дополнительные финансовые расходы, в Яндекс.Облаке — в дополнительный latency.
Нужно сделать так, чтобы фронтенды выбирали такие бэкенды, которые находятся в их зоне, а остальные бэкенды оставались бы для них «запасными». Такой способ маршрутизации называется [**locality load balancing**](https://istio.io/latest/docs/tasks/traffic-management/locality-load-balancing/).
Решаем сетевые задачи систематически
------------------------------------
Подобные задачи по управлению сетевым трафиком можно перечислять ещё долго и каждый хотя бы раз сталкивался хотя бы с одной из них. Безусловно, у каждой из задач есть решение, которое можно реализовать на уровне приложения. Но проблема в том, что среднестатистическое приложение состоит из множества компонентов, или «шестеренок». И все они разные, к каждой нужен свой подход.
Именно **для *систематического* решения подобных задач и придумали Service Mesh**.
Service Mesh дает набор «кирпичей», из которых мы можем собирать собственные паттерны управления сетью. По-другому: Service Mesh — это фреймворк для управления любым TCP-трафиком с собственным декларативном языком. А в качестве бонуса Service Mesh предлагает дополнительные возможности для мониторинга (observability).
Благодаря Service Mesh вам не нужно задумываться о нюансах сетевого взаимодействия на уровне отдельных компонентов.
Вы можете рассматривать ваше приложение просто как дерево компонентов с очень примитивными связями. А все нюансы вынести за скобки и описать их с помощью Service Mesh.
Как это работает
----------------
Представим, что мы — большие любители «велосипедов»: мы не ищем готовые решения, потому что любим писать свои. И мы решили написать свой Service Mesh — *supermesh*.
Предположим, у нас есть приложение. Оно принимает запросы, генерирует новые — вот этим трафиком мы и хотим управлять. Но чтобы им управлять, нам нужно его перехватить. Для этого:
* проникаем в сетевое окружение приложения;
* внедряем туда наш перехватчик;
* DNAT’ом перенаправляем на него входящий и исходящий трафик.
Поскольку мы работаем с Kubernetes, наше приложение «живет» в Pod’e, то есть внутри контейнера. Это значит, что мы для удобства можем «подселить» к приложению наш перехватчик в качестве sidecar-контейнера.
Теперь с этим перехваченным трафиком нужно что-то сделать, как-то его модифицировать. Очевидное решение — использовать прокси (например, nginx, HAProxy или Envoy).
Мы можем написать и свой прокси, но мы не настолько велосипедисты, поэтому остановимся на [Envoy](https://www.envoyproxy.io/). Он хорошо вписывается в эту архитектуру, потому что умеет конфигурироваться удаленно, «на лету», и у него есть множество готовых удобных API.
В итоге мы можем перехватить трафик и влиять на него. Осталось сделать с ним что-то полезное, то есть реализовать какой-то из упомянутых выше паттернов управления — причем не абы какой, а такой, который выберет разработчик нашего приложения.
Мы могли бы передать разработчику «пульт управления» нашими sidecar’ами, чтобы он сам настраивал все нюансы. Но изначально вроде бы не этого хотели: нам нужна систематизация.
Очевидно, что нам не хватает какого-то промежуточного компонента — условного контроллера (*supermeshd*), который взял бы на себя управление, а разработчику предоставил декларативный язык, с помощью которого тот строил бы свои стратегии.
Теперь мы можем взять от разработчика набор паттернов, которые он хочет, а контроллер будет бегать по sidecar’ам и настраивать их. В мире Service Mesh такой контроллер называется **Control Plane**, а sidecar’ы с нашим перехватчиком — **Data Plane**.
Именно по такому принципу — естественно, с большими допущениями — и работает большинство реализаций Service Mesh: Kuma, Istio, [Linkerd](https://habr.com/ru/company/flant/blog/327536/) и пр.
В этом докладе я рассматриваю только Istio и делаю это «без объяснения причин». Кстати, согласно [прошлогоднему опросу CNCF](https://www.cncf.io/wp-content/uploads/2020/11/CNCF_Survey_Report_2020.pdf), это самое популярное Service Mesh-решение, которое используется в production.
Перед внедрением Istio к нему сразу же возникает ряд вопросов:
* Как он повлияет на приложение? А на кластер?
* Какие у него возможности по observability?
* Надежен ли его Mutual TLS?
* Что с федерацией?
* Как правильно засетапить Istio? А обновить?
* Что, если что-то сломается?
Конечно, вопросов гораздо больше. Постараюсь ответить хотя бы на некоторые из них.
Как Istio влияет на приложение
------------------------------
Раньше, когда не было Istio, всё было просто и прозрачно: пользователь генерирует запрос, фронтенд генерирует дочерний запрос к бэкенду.
Как только появляется Istio, схема усложняется:
По сравнению с чистой инсталляцией «хопов» стало гораздо больше. Понятно, что это не может быть бесплатным. И самая очевидная цена — это latency.
Разработчики Istio [обещают](https://istio.io/latest/docs/ops/deployment/performance-and-scalability/), что задержка не будет превышать 2,65 мс. Мне эти цифры показались не очень убедительными, поэтому я решил сделать свои замеры.
#### Нагрузочное тестирование
Для начала я написал примитивное клиент-серверное приложение. В качестве клиента использовал утилиту для нагрузочного тестирования [k6](https://k6.io/), а в качестве сервера — nginx, который просто отдает статичные файлы. k6 отправляла по 10 тыс. запросов с предварительным прогревом в сторону сервера. **Важно:** клиент и сервер работали на разных узлах, чтобы не мешать друг другу.
Из этого приложения я собрал несколько вариантов инсталляции:
* «чистую» схему, без Istio и всяких sidecar’ов;
* сетап с Envoy в качестве sidecar’а;
* сетап, в котором просто включен Istio;
* еще один сетап с Istio, в котором задействованы 1000 правил авторизации — чтобы понять, влияют ли какие-то дополнительные правила на задержку, и как именно.
Что еще я посчитал важным сделать:
* отключил логи на sidecar’ах;
* включил сбор метрик sidecar’ах Istio;
* использовал разные версии TLS;
* включал и выключал HTTP/2;
* включал и выключал keepalive на стороне клиента и между sidecar’ами;
* использовал JSON-файлы трех размеров: 500Б, 200КБ, 1,7МБ;
* экспериментировал с многопоточностью.
В итоге получилось 252 теста. Попробуем оценить собранные метрики.
**1. Классический сценарий:** примитивный клиент отправляет запросы серверу в один поток и не умеет держать keepalive.
Посмотрим на картину задержек:
Самый первый и очевидный вывод: **действительно, перехват трафика не бесплатен**. Причем в случае с Envoy в качестве sidecar’а и «тяжелым» файлом мы видим пятикратный рост задержки.
Уровень драматичности снижается, если мы посмотрим на полный round-trip (RTD) запроса. В самом худшем случае мы увидим троекратный оверхэд. А в некоторых случаях он почти не заметен:
Важно учитывать, что в моем случае естественный фон задержки у бэкенда крайне мал — 0,23 мс. В этом случае прирост в 2 мс кажется огромным — 800%. Но если у вас более сложный бэкенд, у которого задержка составляет десятки мс, то эти лишние 2 мс вы не заметите.
Второй вывод: **по сравнению с «голым» Envoy’ем Istio все-таки дает небольшие накладные расходы**. Возможно, это связано со сбором метрик и это стоит учитывать.
Третий вывод: **правила авторизации, как и любые другие дополнительные настройки Istio, влияют на latency**. Но это тоже не должно смущать, т. к. в реальной жизни вряд ли кому-то понадобится тысяча дополнительных правил.
Четвертый вывод: **рост задержки при росте размера файла**. Здесь задержка растет так же предсказуемо, и все пропорции по сравнению с «голой» инсталляцией сохраняются. То есть можно считать, что объем данных, которые мы прогоняем через Istio, на задержку не влияет.
**2. Сценарий с шифрованием Mutual TLS**
Результаты оказались везде более-менее одинаковыми, поэтому я покажу их на примере одной инсталляции, когда просто включен Istio:
Да, влияние есть. Но, опять же, это «копейки», которые можно не учитывать. Так что шифрование можно смело включать.
**3. Любопытные наблюдения**
Они не связаны напрямую с Istio, но я подумал, что ими не помешает поделиться.
Я решил: а что, если включить keepalive на клиентах? Не выиграю ли я в задержке? Потому что, во-первых, handshakes. Во-вторых, sidecar’ам надо будет поменьше думать.
Результаты покажу на примере того же сетапа с Istio:
Выигрыш хоть и небольшой, но есть. Мелочь, а приятно!
А что, если еще включить многопоточность?.. И вот тут я расстроился: при тестах на «средневесе» и «тяжеловесе» задержка выросла.
Разбираясь с этой проблемой, я нашел убедительное объяснение в [статье блога Cloudflare](https://blog.cloudflare.com/keepalives-considered-harmful/), почему keepalive — это не всегда хорошо.
Итак, два главных вывода о влиянии Istio на приложение:
* перехват трафика не бесплатен — можно смело закладывать накладные расходы по задержке порядка 2,5 мс;
* если ваша естественная задержка измеряется в десятках и сотнях мс, лишние 2,5 мс вы не заметите.
Как Istio влияет на кластер
---------------------------
У нашего Istio, как и у *supermeshd*, который мы ранее реализовали сами, тоже есть Control Plane. Называется он **istiod**, и это отдельный контроллер, который работает в кластере.
Также у Istio есть свой декларативный язык, с помощью которого можно строить паттерны по управлению сетью. Технически язык представляет собой набор ресурсов Kubernetes, за которыми istiod пристально следит. Еще он следит за набором системных ресурсов: Namespace’ами, Pod’ами, узлами и т. д. В этом смысле контроллер Istio ничем не отличается от любого другого контроллера или оператора. И на практике никаких проблем с ним мы не выявили. Можем идти дальше.
Observability
-------------
У Istio есть интеграция со сторонними инструментами для мониторинга. Например, с дашбордом [**Kiali**](https://kiali.io/), с помощью которого можно визуализировать приложение в виде графа, рассмотреть отдельные связи компонентов, как они устроены, что у них «болит» и т. д.
Есть хороший набор дашбордов для графиков **Grafana**.
Istio также предоставляет базовые возможности для внедрения трассировки на основе [**Jaeger**](https://www.jaegertracing.io/).
К сожалению, **ничего из этого у вас не заработает «из коробки»**. Для Kiali и Grafana нужно будет установить Prometheus (и саму Grafana). В случае с трассировкой придется, как минимум, установить где-то Jaeger, а как максимум — научить ваше приложение грамотно обрабатывать HTTP-заголовки со служебными данными от трассировки.
Безопасность (Mutual TLS)
-------------------------
Напомню, протокол Mutual TLS ([mTLS](https://en.wikipedia.org/wiki/Mutual_authentication#mTLS)) — это взаимная, или двусторонняя, аутентификация клиента и сервера. Он нужен, когда мы хотим, чтобы наши клиент и сервер достоверно знали друг друга, не общались со всякими «незнакомцами». Также mTLS нужен, когда мы хотим зашифровать трафик между нашими приложениями. Технически это достигается с помощью обычных SSL-сертификатов.
В мире Istio у каждого Pod’а есть сертификат, который подтверждает подлинность этого Pod’а, а именно — подлинность его идентификатора (ID). В терминологии Istio **идентификатор — это principal**. Он состоит из трех частей:
* ID кластера (Trust Domain),
* Namespace’а приложения,
* ServiceAccount’а, под которым работает Pod.
За выпуск сертификатов отвечает Control Plane, на основе собственного корневого сертификата. У каждой инсталляции Istio есть собственный корневой сертификат — root CA (его не стоит путать с корневым сертификатом самого кластера). На основе корневого сертификата выпускаются индивидуальные.
Давайте разберём весь жизненный цикл индивидуального сертификата.
Envoy в Istio не общается напрямую с Control Plane: он это делает через посредника, который называется **Istio agent** — утилита, написанная на Go, которая живет в одном контейнере с Envoy. Этот агент отвечает за ротацию сертификатов.
Istio-agent генерирует CSR с заявкой на ID (principal), который полагается нашему Pod’у. Но сначала этот ID нужно как-то сгенерировать. С Trust Domain всё просто: агент знает, в каком кластере работает Pod (переменная в ENV). С Namespace’ом и ServiceAccount’ом чуть сложнее…
Но вообще: что такое ServiceAccount? Остановимся на этом чуть подробнее.
#### ServiceAccount
У Kubernetes есть свой API, который подразумевает, что с ним никто анонимно общаться не будет. С другой стороны, API подразумевает, что к нему будут общаться Pod’ы. Рядовым приложениям это, как правило, не нужно: обычно с API Kubernetes общаются контроллеры, операторы и т. п. И чтобы решить этот вопрос, придумали специальные учетные записи, которые называются ServiceAccount.
ServiceAccount — это примитивный ресурс в K8s, который в момент создания никакой информации не несет. Он просто существует в каком-то Namespace’е, с каким-то именем. Как только такой ресурс появляется в кластере, Kubernetes на это реагирует и выпускает JWT-токен. Этот токен целиком описывает появившийся ServiceAccount. То есть Kubernetes подтверждает: «в моем кластере, в таком-то Namespace’е, с таким-то именем есть ServiceAccount» — и выдает специальный токен, который складывает в Secret (`mysa-token-123`).
Secret привязывается к ServiceAccount’у, который тем самым становится чем-то вроде ресурса со свидетельством о рождении. Данный ServiceAccount можно «привязать» к любому Pod’у, после чего, в ФС Pod’а будет автоматически примонтирован Secret с токеном, причем по заранее известному пути (`/run/secret/kubernetes.io/serviceaccount/token`). Собственно, данный токен и пригодится нам для того, чтобы узнать Namespace, в котором мы работаем, и ServiceAccount, от имени которого мы работаем.
Мы сгенерировали principal — теперь можем положить его в CSR.
Полученный CSR мы можем отправить в istiod. Но чтобы istiod поверил, что мы — это мы, в дополнение отправляем токен. Далее istiod проверяет этот токен через API K8s (`TokenReview`). Если K8s говорит, что всё хорошо, istiod подписывает CSR и возвращает в sidecar.
Для каждого Pod’а ротация сертификатов происходит раз в сутки.
Чтобы что-то взломать в этой системе, можно:
* украсть сертификат (он будет действовать не более суток);
* украсть токен ServiceAccount’а Pod’а, чтобы заказывать сертификаты от имени этого Pod’а;
* взломать API Kubernetes — тогда можно заказать сколько угодно токенов, от имени какого угодно Pod’а;
* украсть корневой сертификат Control Plane — самый примитивный и опасный взлом.
Всё это на самом деле довольно сложно реализовать. Поэтому можем считать, что mTLS в Istio безопасен.
Другие вопросы к Istio
----------------------
К сожалению, осталось еще много вопросов, не раскрытых в докладе. И по каждому из этих вопросов достаточно много нюансов. Порой эти нюансы либо очень плохо описаны в документации, либо не описаны вовсе — приходится ковыряться в коде и обращаться к разработчикам Istio.
Множество из этих нюансов мы учли в модуле Istio для нашей платформы [Deckhouse](https://deckhouse.io/ru/). С ее помощью вы можете за 8 минут развернуть готовый к использованию Kubernetes-кластер на любой инфраструктуре: в облаке, на «голом железе», в OpenStack и т. д.
Подробнее познакомиться с функциями, которые решает Istio в рамках Deckhouse, можно в [нашей документации](https://deckhouse.io/ru/documentation/v1/modules/110-istio/).
### Видео и слайды
Видео с выступления (~31 минута):
Презентация доклада:
P.S.
----
Читайте также в нашем блоге:
* «Назад к микросервисам вместе с Istio»: [часть 1 (знакомство с основными возможностями)](https://habr.com/ru/company/flant/blog/438426/), [часть 2 (маршрутизация, управление трафиком)](https://habr.com/ru/company/flant/blog/440378/), [часть 3 (аутентификация и авторизация)](https://habr.com/ru/company/flant/blog/443668/);
* «[Service Mesh: что нужно знать каждому Software Engineer о самой хайповой технологии](https://habr.com/ru/company/flant/blog/478306/)»;
* «[Сценарии использования service mesh](https://habr.com/ru/company/flant/blog/512352/)»;
* «[Представляем Kubernetes-платформу Deckhouse. Теперь в Open Source и для всех](https://habr.com/ru/company/flant/blog/569840/)». | https://habr.com/ru/post/569612/ | null | ru | null |
# Интернет вещей в Яндекс.Облаке: как устроены сервисы Yandex IoT Core и Yandex Cloud Functions
В октябре прошлого года состоялась первая облачная конференция Яндекса Yandex Scale. На ней было объявлено о запуске множества новых сервисов, в том числе Yandex IoT Core, который позволяет обмениваться данными с миллионами устройств Интернета вещей.
В этой статье я расскажу о том, зачем нужен и как устроен Yandex IoT Core, а также каким образом он может взаимодействовать с другими сервисами Яндекс.Облака. Вы узнаете об архитектуре, тонкостях взаимодействия компонентов и особенностях реализации функциональности — всё это поможет вам оптимизировать использование этих сервисов.
Для начала вспомним основные преимущества публичных облаков и PaaS — сокращение времени и затрат на разработку, а также затрат на поддержку и инфраструктуру, что актуально и для проектов Интернета вещей. Но есть и несколько менее очевидных полезных особенностей, которые вы можете получить в облаке. Это эффективное масштабирование и отказоустойчивость — важные аспекты при работе с устройствами, особенно в проектах для критической информационной инфраструктуры.
Эффективное масштабирование — это возможность свободно как увеличивать, так и уменьшать количество устройств, не испытывая технических проблем и видя предсказуемое изменение стоимости системы после изменений.
Отказоустойчивость — это уверенность в том, что сервисы спроектированы и развёрнуты таким образом, чтобы обеспечивать максимально возможную работоспособность даже в случае отказа части ресурсов.
А теперь давайте разберёмся в деталях.
Архитектура IoT-сценария
------------------------
Прежде всего посмотрим, как выглядит общая архитектура IoT-сценария.
В ней можно выделить две большие части:
* Первая — доставка данных в хранилище и доставка команд к устройствам. Когда вы строите IoT-систему, эту задачу необходимо решить в любом случае, какой бы проект вы не делали.
* Вторая — работа с принятыми данными. Тут всё похоже на любой другой проект, основанный на анализе и визуализации наборов данных. У вас есть хранилище с исходным массивом информации, работа с которым и позволит реализовать вашу задачу.
Первая часть примерно одинакова во всех IoT-системах: строится по общим принципам и ложится в общий сценарий, пригодный для большинства систем Интернета вещей.
Вторая часть практически всегда уникальна с точки зрения выполняемых функций, хотя и строится на стандартных компонентах. При этом без качественной, отказоустойчивой и масштабируемой системы взаимодействия с «железом» эффективность аналитической части архитектуры сводится практически к нулю, так как просто нечего будет анализировать.
Именно поэтому команда Яндекс.Облака приняла решение в первую очередь сосредоточить усилия на построении удобной экосистемы сервисов, позволяющих быстро, эффективно и надёжно доставлять данные от устройств в хранилища, и наоборот — отправлять команды в устройства.
Для решения этих задач мы работаем над функциональностью и интеграцией сервисов Yandex IoT Core, Yandex Functions и хранилищ данных в Облаке:
* Сервис Yandex IoT Core представляет собой мультитенантный отказоустойчивый масштабируемой MQTT-брокер с набором дополнительных полезных функций.
* Сервис Yandex Cloud Functions является представителем перспективного направления serverless и позволяет запускать ваш код в виде функции в безопасном, отказоустойчивом и автоматически масштабируемом окружении без создания и обслуживания виртуальных машин.
* Yandex Object Storage — это эффективное хранилище больших массивов данных и очень хорошо подходит для «исторических» архивных записей.
* В Облаке существует целое семейство сервисов для хранения и анализа данных, практически на любой вкус, но я хочу отметить сервис Yandex Managed Service for ClickHouse, как один из примеров «управляемых» баз данных. Это сервис для развёртывания и управления «колоночной» базой данных с открытым исходным кодом, имеющим встроенную функциональность работы с временными рядами, что актуально для оперативных данных, на базе которых обычно и нужно проводить большую часть анализа и строить отчёты.
Если сервисы хранения и анализа данных являются сервисами «общего назначения», о которых уже много написано, то Yandex IoT Core и его взаимодействие с Yandex Cloud Functions обычно вызывают много вопросов, особенно у людей, только начинающих разбираться с системами Интернета вещей и облачными технологиями. А так как именно эти сервисы обеспечивают отказоустойчивость и масштабирование работы с устройствами, посмотрим сначала, что у них «под капотом».
Как устроен Yandex IoT Core
---------------------------
Yandex IoT Core — это специализированный платформенный сервис для двустороннего обмена данными между облаком и устройствами, работающими по протоколу MQTT. Фактически этот протокол стал стандартом передачи данных в IoT. Он использует понятие поименованных очередей (топиков), куда, с одной стороны, вы можете записывать данные, а с другой стороны — асинхронно их получать, подписавшись на события этой очереди.
Сервис Yandex IoT Core является мультитенантным, что означает одну-единственную сущность, доступную для всех пользователей. То есть все устройства и все пользователи взаимодействуют с одним и тем же экземпляром сервиса.
Это позволяет, с одной стороны, обеспечить единообразие работы для всех пользователей, с другой — эффективное масштабирование и отказоустойчивость, чтобы поддерживать соединение с неограниченным количеством устройств и обрабатывать неограниченное как по объёму, так и по скорости количество данных.
Из этого следует, что у сервиса должны быть как механизмы резервирования, так и возможность гибкого управления используемыми ресурсами — чтобы реагировать на изменение нагрузки.
Кроме того, мультитенантность требует специальной логики разделения прав доступа к MQTT-топикам.
Давайте посмотрим, каким образом это реализовано.
Как и многие другие сервисы Яндекс.Облака, Yandex IoT Core логически поделён на две части — Control Plane и Data Plane:
Data Plane отвечает за логику работы по протоколу MQTT, а Control Plane отвечает за разграничение прав доступа к тем или иным топикам и использует для этого логические сущности Реестр (Registry) и Устройство (Device).
У каждого пользователя Яндекс.Облака может быть несколько реестров, каждый из которых может содержать собственное подмножество устройств.
Доступ к топикам предоставляется следующим образом:
Устройства могут отправлять данные только в свой топик событий и топик событий реестра:
```
$devices//events
$registries//events
```
и подписываться на сообщения только из своего топика команд и топика команд реестра:
```
$devices//commands
$registries//commands
```
Реестр может отправлять данные во все топики команд устройств и в топик команд реестра:
```
$devices//commands
$devices//commands
$registries//commands
```
и подписываться на сообщения из всех топиков событий устройств и топика событий реестра:
```
$devices//events
$devices//events
$registries//events
```
Чтобы работать со всеми описанными выше сущностями, у Data Plane есть gRPC-протокол и REST-протокол, на базе которых реализован доступ через GUI-консоли Яндекс.Облака и интерфейс командной строки CLI.
Что касается Data Plane, то он поддерживает протокол MQTT версии 3.1.1. Однако есть несколько особенностей:
1. При подключении нужно обязательно использовать TLS.
2. Поддерживается только TCP-соединение. WebSocket пока недоступен.
3. Доступна авторизация как по логину и паролю (где логин — это ID устройства или реестра, а пароли задаются пользователем), так и с помощью сертификатов.
4. Не поддерживается флаг Retain, при использовании которого MQTT-брокер сохраняет отмеченное флагом сообщение и отправляет его при следующей подписке на топик.
5. Не поддерживается постоянный сеанс (Persistent Session), при котором MQTT-брокер сохраняет информацию о клиенте (устройстве или реестре) для упрощения повторного подключения.
6. При subscribe и publish поддерживаются только первые два уровня обслуживания:
1. QoS0 — At most once. Нет гарантии доставки, но нет и повторной доставки одного и того же сообщения.
2. QoS1 — At least once. Доставка гарантирована, но есть вероятность повторного получения одного и того же сообщения.
Чтобы упростить подключение к Yandex IoT Core, мы регулярно добавляем новые примеры для разных платформ и языков в наш репозиторий на GitHub, а также описываем сценарии работы в документации.
Архитектура сервиса выглядит так:
Бизнес-логика сервиса включает четыре части:
1. Device management — реализация управления доступом к топикам. Является частью Control Plane.
2. MQTT Broker — реализация MQTT-протокола. Часть Data Plane.
3. Triggers — реализация интеграции с сервисом Yandex Cloud Functions. Часть Data Plane.
4. Shards — реализация специальной логики работы с MQTT-брокером в условиях балансировки трафика. Часть Data Plane.
Всё взаимодействие с «внешним миром» идёт через балансировщики нагрузки. Причём, в соответствии с философией dogfooding, используется Yandex Load Balancer, доступный всем пользователям Яндекс.Облака.
Каждая часть бизнес-логики состоит из нескольких наборов по три виртуальные машины — по одной в каждой зоне доступности (на схеме А, B и C). Виртуальные машины точно такие же, как у всех пользователей Яндекс.Облака. При увеличении нагрузки масштабирование происходит при помощи всего набора — добавляются сразу три машины в рамках одной части бизнес-логики. Это значит, что если один набор из трёх машин MQTT Broker не будет справляться с нагрузкой, то добавится ещё один набор из трёх машин MQTT Broker, при этом конфигурация других частей бизнес-логики останется прежней.
И только Logbroker не доступен публично. Он представляет собой сервис для эффективной отказоустойчивой работы с потоками данных. В его основе лежит Apache Kafka, однако он имеет множество других полезных функций: реализует процессы восстановления после сбоев (в том числе семантику exactly once, когда у вас есть гарантия доставки сообщения без дупликации) и сервисные процессы (такие как междатацентровая репликация, раздача данных на кластеры расчёта), а также обладает механизмом равномерного не дублирующегося распределения данных между подписчиками потока — своего рода балансировщик нагрузки.
Функции Device management в Control Plane мы рассмотрели выше. А вот с Data Plane всё намного интереснее.
Каждый экземпляр MQTT Broker работает независимо и ничего не знает о других экземплярах. Все пришедшие данные (publish от клиентов) брокеры отправляют в Logbroker, откуда их забирают шарды (Shards) и триггеры (Triggers). И именно в шардах происходит синхронизация между экземплярами брокеров. Шарды знают обо всех MQTT-клиентах и распределении их подписок (subscribe) по экземплярам MQTT-брокеров и определяют, куда отправить пришедшие данные.
Например, MQTT-клиент А подписан на топик у брокера А, а MQTT-клиент B подписан на тот же топик у брокера B. Если MQTT-клиент C сделает publish в тот же топик, но в брокер C, то именно шард транслирует данные из брокера C в брокеры A и B, в результате чего данные получат и MQTT-клиент А и MQTT-клиент B.
Последняя часть бизнес-логики, триггеры (Triggers), также получает все пришедшие от MQTT-клиентов данные и, если это настроено пользователем, передаёт их триггерам сервиса Yandex Cloud Functions.
Как видите, Yandex IoT Core имеет достаточно сложную архитектуру и логику работы, которую трудно повторить на локальных инсталляциях. Это позволяет ему как выдерживать потерю даже двух из трёх зон доступности, так и отрабатывать неограниченное количество подключений и неограниченные объёмы данных.
Причём вся эта логика скрыта от пользователя «под капотом», а снаружи всё выглядит очень просто — так, как будто вы работаете с одним-единственным MQTT-брокером.
Триггеры и сервис Yandex Cloud Functions
----------------------------------------
Yandex Cloud Functions — представитель так называемых «бессерверных» (serverless) сервисов в Яндекс.Облаке. Основная суть таких сервисов в том, чтобы пользователь не тратил своё время на настройку, развёртывание и масштабирование окружения для выполнения кода, а занимался только самым ценным для него — написанием самого кода, выполняющего нужную задачу. В случае с функциями это так называемый атомарный stateless-код, который может быть запущен по некоторому событию. «Атомарный» и «stateless» означают, что этот код должен выполнять некоторую относительно небольшую, но целостную задачу, при этом в коде не должно использоваться никаких переменных для того, чтобы сохранять значения между вызовами.
Существует несколько способов вызывать функции: прямой HTTP-вызов, вызов по таймеру (cron) или подписка на какое-либо событие. В качестве последнего сервисом уже поддерживается подписка на очереди сообщений (Yandex Message Queue), на события, генерируемые сервисом Object Storage, и (самое ценное для IoT-сценария) подписка на сообщения в Yandex IoT Core.
Несмотря на то, что с Yandex IoT Core можно работать с помощью любого MQTT-совместимого клиента, Yandex Cloud Functions является одним из наиболее оптимальных и удобных способов принимать и обрабатывать данные. Причина этого очень проста. Функция может вызываться на каждое пришедшее сообщение от любого устройства, причём функции будут выполняться параллельно друг другу (за счёт атомарности и stateless-подхода), а количество их вызовов будет естественным образов изменяться по мере изменения количества пришедших сообщений от устройств. Таким образом, пользователь может полностью абстрагироваться от вопросов настройки инфраструктуры и, более того, в отличие от тех же виртуальных машин, оплата будет происходить только за фактически выполненную работу. Это позволит существенно сэкономить при низкой нагрузке и получать понятную и предсказуемую стоимость при росте.
Механизм вызова функций по событиям (подписка на события) называется триггер (Trigger). Суть его изображена на схеме:
Сервис, генерирующий события для вызова функций, складывает их в очередь в Logbroker. В случае с Yandex IoT Core этим занимаются Triggers из Data Plane. Далее эти события забирает препроцессор, который ищет в базе данных запись для этого события с указанием функции, которую нужно вызвать. Если такая запись нашлась, то препроцессор кладёт информацию о вызове функции (ID функции и параметры вызова) в очередь в сервис Yandex Message Queue, откуда её забирает обработчик вызовов. Обработчик в свою очередь отправляет HTTP-запрос на вызов функции в сервис Yandex Cloud Functions.
При этом, опять-таки в соответствии с философией dogfooding, используется доступный всем пользователям сервис Yandex Message Queue, а вызов функций осуществляется точно таким же способом, которым могут вызывать свои функции любые другие пользователи.
Скажем несколько слов про Yandex Message Queue. Несмотря на то, что это, как и Logbroker, сервис очередей, между ними есть одно существенное отличие. При обработке сообщений из очередей обработчик сообщает очереди о том, что он закончил и сообщение можно удалять. Это важный механизм надёжности в таких сервисах, однако он усложняет логику работы с сообщениями.
Yandex Message Queue позволяет «распараллеливать» обработку каждого сообщения внутри очереди. Иначе говоря, сообщение из очереди, которое обрабатывается в данный момент, не блокирует возможность другому «потоку» забрать следующее событие из очереди на обработку. Это называется параллелизм на уровне сообщений.
А LogBroker оперирует группами сообщений, и пока группа не будет обработана вся, следующую группу на обработку забрать нельзя. Этот подход называется параллелизм на уровне партиций.
И именно использование Yandex Message Queue позволяет быстро и эффективно обрабатывать параллельно множество запросов на вызов функции по событиям от того или иного сервиса.
Несмотря на то, что триггеры представляют собой отдельный самостоятельный блок, они являются частью сервиса Yandex Cloud Functions. Нам осталось только разобраться с тем, как именно вызываются функции.
Все запросы на вызов функций (как внешние, так и внутренние) попадают в балансировщик нагрузки, который распределяет их по маршрутизаторам в разных зонах доступности (AZ), в каждой зоне развёрнуто несколько штук. Маршрутизатор при получении запроса первым делом идёт на сервис Identity and Access manager (IAM), чтобы удостовериться, что у источника запроса есть права на вызов данной функции. Далее он обращается к scheduler и спрашивает, на каком worker запустить функцию. Worker представляет собой виртуальную машину с настроенной средой выполнения изолированных друг от друга функций. Далее маршрутизатор, получив от scheduler адрес worker, на котором нужно выполнить функцию, отправляет на этот worker команду на запуск функции с определёнными параметрами.
Откуда берутся worker? Тут как раз и происходит вся магия serverless. Schedulers, анализируя нагрузку (количество и время работы функций), управляют (запускают и останавливают) виртуальными машинами с той или иной средой исполнения. Сейчас поддерживается NodeJS и Python. И здесь крайне важен один параметр — скорость запуска функций. Команда разработки сервиса проделала огромную работу, и сейчас виртуальная машина стартует максимум за 250 мс, при этом используется максимально безопасная среда изоляции функций друг от друга — виртуализация QEMU, на которой работает всё Яндекс.Облако. При этом, если для пришедшего запроса уже есть работающий worker, функция запускается практически мгновенно.
И, в соответствии всё с тем же подходом dogfooding, в качестве Load Balancer используется публичный сервис, доступный всем пользователям, а worker, scheduler и маршрутизатор — это обычные виртуальные машины, такие же, как у всех пользователей.
Таким образом, отказоустойчивость сервиса реализовывается на уровне балансировщика нагрузки и резервирования ключевых компонентов системы (маршрутизатор и scheduler), а масштабирование происходит за счёт развёртывания или сокращения количества worker. При этом каждая зона доступности работает независимо, что позволяет пережить потерю даже двух из трёх зон.
Полезные ссылки
---------------
В заключении хочу дать несколько ссылок, которые позволят изучить сервисы более детально:
* Yandex IoT Core: [cloud.yandex.ru/services/iot-core](https://cloud.yandex.ru/services/iot-core)
* Yandex Cloud Functions: [cloud.yandex.ru/services/functions](https://cloud.yandex.ru/services/functions)
* Yandex Message Queue: [cloud.yandex.ru/services/message-queue](https://cloud.yandex.ru/services/message-queue)
* Yandex Managed Service for ClickHouse: [cloud.yandex.ru/services/managed-clickhouse](https://cloud.yandex.ru/services/managed-clickhouse)
* Yandex Load Balancer: [cloud.yandex.ru/services/load-balancer](https://cloud.yandex.ru/services/load-balancer)
* Yandex Object Storage: [cloud.yandex.ru/services/storage](https://cloud.yandex.ru/services/storage) | https://habr.com/ru/post/491740/ | null | ru | null |
# Изучаем Docker, часть 3: файлы Dockerfile
В переводе третьей части серии материалов, посвящённых Docker, мы продолжим вдохновляться выпечкой, а именно — бубликами. Нашей сегодняшней основной темой будет работа с файлами Dockerfile. Мы разберём инструкции, которые используются в этих файлах.
→ [Часть 1: основы](https://habr.com/post/438796/)
→ [Часть 2: термины и концепции](https://habr.com/post/439978/)
→ [Часть 3: файлы Dockerfile](https://habr.com/post/439980/)
→ [Часть 4: уменьшение размеров образов и ускорение их сборки](https://habr.com/post/440658/)
→ [Часть 5: команды](https://habr.com/post/440660/)
→ [Часть 6: работа с данными](https://habr.com/post/441574/)
[](https://habr.com/ru/company/ruvds/blog/439980/)
*Бублики — это инструкции в файле Dockerfile*
Образы Docker
-------------
Вспомните о том, что контейнер Docker — это образ Docker, вызванный к жизни. Это — самодостаточная операционная система, в которой имеется только самое необходимое и код приложения.
Образы Docker являются результатом процесса их сборки, а контейнеры Docker — это выполняющиеся образы. В самом сердце Docker находятся файлы Dockerfile. Подобные файлы сообщают Docker о том, как собирать образы, на основе которых создаются контейнеры.
Каждому образу Docker соответствует файл, который называется Dockerfile. Его имя записывается именно так — без расширения. При запуске команды `docker build` для создания нового образа подразумевается, что Dockerfile находится в текущей рабочей директории. Если этот файл находится в каком-то другом месте, его расположение можно указать с использованием флага `-f`.
Контейнеры, как мы выяснили в первом материале этой серии, состоят из слоёв. Каждый слой, кроме последнего, находящегося поверх всех остальных, предназначен только для чтения. Dockerfile сообщает системе Docker о том, какие слои и в каком порядке надо добавить в образ.
Каждый слой, на самом деле, это всего лишь файл, который описывает изменение состояния образа в сравнении с тем состоянием, в котором он пребывал после добавления предыдущего слоя. В Unix, кстати, практически всё что угодно — это [файл](https://en.wikipedia.org/wiki/Everything_is_a_file).
Базовый образ — это то, что является исходным слоем (или слоями) создаваемого образа. Базовый образ ещё называют родительским образом.
*Базовый образ — это то, с чего начинается образ Docker*
Когда образ загружается из удалённого репозитория на локальный компьютер, то физически скачиваются лишь слои, которых на этом компьютере нет. Docker стремится экономить пространство и время путём повторного использования существующих слоёв.
Файлы Dockerfile
----------------
В файлах Dockerfile содержатся инструкции по созданию образа. С них, набранных заглавными буквами, начинаются строки этого файла. После инструкций идут их аргументы. Инструкции, при сборке образа, обрабатываются сверху вниз. Вот как это выглядит:
```
FROM ubuntu:18.04
COPY . /app
```
Слои в итоговом образе создают только инструкции `FROM`, `RUN`, `COPY`, и `ADD`. Другие инструкции что-то настраивают, описывают метаданные, или сообщают Docker о том, что во время выполнения контейнера нужно что-то сделать, например — открыть какой-то порт или выполнить какую-то команду.
Здесь мы исходим из предположения, в соответствии с которым используется образ Docker, основанный на Unix-подобной ОС. Конечно, тут можно воспользоваться и образом, основанным на Windows, но использование Windows — это менее распространённая практика, работать с такими образами сложнее. В результате, если у вас есть такая возможность, пользуйтесь Unix.
Для начала приведём список инструкций Dockerfile с краткими комментариями.
Дюжина инструкций Dockerfile
----------------------------
1. `FROM` — задаёт базовый (родительский) образ.
2. `LABEL` — описывает метаданные. Например — сведения о том, кто создал и поддерживает образ.
3. `ENV` — устанавливает постоянные переменные среды.
4. `RUN` — выполняет команду и создаёт слой образа. Используется для установки в контейнер пакетов.
5. `COPY` — копирует в контейнер файлы и папки.
6. `ADD` — копирует файлы и папки в контейнер, может распаковывать локальные .tar-файлы.
7. `CMD` — описывает команду с аргументами, которую нужно выполнить когда контейнер будет запущен. Аргументы могут быть переопределены при запуске контейнера. В файле может присутствовать лишь одна инструкция `CMD`.
8. `WORKDIR` — задаёт рабочую директорию для следующей инструкции.
9. `ARG` — задаёт переменные для передачи Docker во время сборки образа.
10. `ENTRYPOINT` — предоставляет команду с аргументами для вызова во время выполнения контейнера. Аргументы не переопределяются.
11. `EXPOSE` — указывает на необходимость открыть порт.
12. `VOLUME` — создаёт точку монтирования для работы с постоянным хранилищем.
Теперь поговорим об этих инструкциях.
Инструкции и примеры их использования
-------------------------------------
### ▍Простой Dockerfile
Dockerfile может быть чрезвычайно простым и коротким. Например — таким:
```
FROM ubuntu:18.04
```
### ▍Инструкция FROM
Файл Dockerfile должен начинаться с инструкции `FROM`, или с инструкции `ARG`, за которой идёт инструкция `FROM`.
Ключевое слово [FROM](https://docs.docker.com/engine/reference/builder/#from) сообщает Docker о том, чтобы при сборке образа использовался бы базовый образ, который соответствует предоставленному имени и тегу. Базовый образ, кроме того, ещё называют [родительским образом](https://docs.docker.com/develop/develop-images/baseimages/).
В этом примере базовый образ хранится в репозитории [ubuntu](https://hub.docker.com/_/ubuntu). Ubuntu — это название официального репозитория Docker, предоставляющего базовую версию популярной ОС семейства Linux, которая называется Ubuntu.
Обратите внимание на то, что рассматриваемый Dockerfile включает в себя тег `18.04`, уточняющий то, какой именно базовый образ нам нужен. Именно этот образ и будет загружен при сборке нашего образа. Если тег в инструкцию не включён, тогда Docker исходит из предположения о том, что требуется самый свежий образ из репозитория. Для того чтобы яснее выразить свои намерения, автору Dockerfile рекомендуется указывать то, какой именно образ ему нужен.
Когда вышеописанный Dockerfile используется на локальной машине для сборки образа в первый раз, Docker загрузит слои, определяемые образом `ubuntu`. Их можно представить наложенными друг на друга. Каждый следующий слой представляет собой файл, описывающий отличия образа в сравнении с тем его состоянием, в котором он был после добавления в него предыдущего слоя.
При создании контейнера слой, в который можно вносить изменения, добавляется поверх всех остальных слоёв. Данные, находящиеся в остальных слоях, можно только читать.
*Структура контейнера (взято из [документации](https://docs.docker.com/v17.09/engine/userguide/storagedriver/imagesandcontainers/#images-and-layers))*
Docker, ради эффективности, использует стратегию копирования при записи. Если слой в образе существует на предыдущем уровне и какому-то слою нужно произвести чтение данных из него, Docker использует существующий файл. При этом ничего загружать не нужно.
Когда образ выполняется, если слой нужно модифицировать средствами контейнера, то соответствующий файл копируется в самый верхний, изменяемый слой. Для того чтобы узнать подробности о стратегии копирования при записи, взгляните на [этот](https://docs.docker.com/v17.09/engine/userguide/storagedriver/imagesandcontainers/) материал из документации Docker.
Продолжим рассмотрение инструкций, которые используются в Dockerfile, приведя пример такого файла с более сложной структурой.
### ▍Более сложный Dockerfile
Хотя файл Dockerfile, который мы только что рассмотрели, получился аккуратным и понятным, он устроен слишком просто, в нём используется всего одна инструкция. Кроме того, там нет инструкций, вызываемых во время выполнения контейнера. Взглянем на ещё один файл, который собирает маленький образ. В нём имеются механизмы, определяющие команды, вызываемые во время выполнения контейнера.
```
FROM python:3.7.2-alpine3.8
LABEL maintainer="jeffmshale@gmail.com"
ENV ADMIN="jeff"
RUN apk update && apk upgrade && apk add bash
COPY . ./app
ADD https://raw.githubusercontent.com/discdiver/pachy-vid/master/sample_vids/vid1.mp4 \
/my_app_directory
RUN ["mkdir", "/a_directory"]
CMD ["python", "./my_script.py"]
```
Возможно, на первый взгляд этот файл может показаться довольно сложным. Поэтому давайте с ним разберёмся.
Базой этого образа является официальный образ Python с тегом 3.7.2-alpine3.8. Проанализировав [этот](https://github.com/docker-library/python/blob/ab8b829cfefdb460ebc17e570332f0479039e918/3.7/alpine3.8/Dockerfile) код можно увидеть, что данный базовый образ включает в себя Linux, Python, и, по большому счёту, этим его состав и ограничивается. Образы ОС Alpine весьма популярны в мире Docker. Дело в том, что они отличаются маленькими размерами, высокой скоростью работы и безопасностью. Однако образы Alpine не отличаются широкими возможностями, характерными для обычных операционных систем. Поэтому для того, чтобы собрать на основе такого образа что-то полезное, создателю образа нужно установить в него необходимые ему пакеты.
### ▍Инструкция LABEL
*Метки*
Инструкция [LABEL](https://docs.docker.com/engine/reference/builder/#label) (метка) позволяет добавлять в образ метаданные. В случае с рассматриваемым сейчас файлом, она включает в себя контактные сведения создателя образа. Объявление меток не замедляет процесс сборки образа и не увеличивает его размер. Они лишь содержат в себе полезную информацию об образе Docker, поэтому их рекомендуется включать в файл. Подробности о работе с метаданными в Dockerfile можно прочитать [здесь](https://docs.docker.com/config/labels-custom-metadata/).
### ▍Инструкция ENV
*Окружающая среда*
Инструкция [ENV](https://docs.docker.com/engine/reference/builder/#env) позволяет задавать постоянные переменные среды, которые будут доступны в контейнере во время его выполнения. В предыдущем примере после создания контейнера можно пользоваться переменной `ADMIN`.
Инструкция `ENV` хорошо подходит для задания констант. Если вы используете некое значение в Dockerfile несколько раз, скажем, при описании команд, выполняющихся в контейнере, и подозреваете, что, возможно, вам когда-нибудь придётся сменить его на другое, его имеет смысл записать в подобную константу.
Надо отметить, что в файлах Dockerfile часто существуют разные способы решения одних и тех же задач. Что именно использовать — это вопрос, на решение которого влияет стремление к соблюдению принятых в среде Docker методов работы, к обеспечению прозрачности решения и его высокой производительности. Например, инструкции `RUN`, `CMD` и `ENTRYPOINT` служат разным целям, но все они используются для выполнения команд.
### ▍Инструкция RUN
*Инструкция RUN*
Инструкция [RUN](https://docs.docker.com/engine/reference/builder/#run) позволяет создать слой во время сборки образа. После её выполнения в образ добавляется новый слой, его состояние фиксируется. Инструкция `RUN` часто используется для установки в образы дополнительных пакетов. В предыдущем примере инструкция `RUN apk update && apk upgrade` сообщает Docker о том, что системе нужно обновить пакеты из базового образа. Вслед за этими двумя командами идёт команда `&& apk add bash`, указывающая на то, что в образ нужно установить bash.
То, что в командах выглядит как `apk` — это сокращение от [Alpine Linux package manager](https://www.cyberciti.biz/faq/10-alpine-linux-apk-command-examples/) (менеджер пакетов Alpine Linux). Если вы используете базовый образ какой-то другой ОС семейства Linux, тогда вам, например, при использовании Ubuntu, для установки пакетов может понадобиться команда вида `RUN apt-get`. Позже мы поговорим о других способах установки пакетов.
Инструкция `RUN` и схожие с ней инструкции — такие, как `CMD` и `ENTRYPOINT`, могут быть использованы либо в exec-форме, либо в shell-форме. Exec-форма использует синтаксис, напоминающий описание JSON-массива. Например, это может выглядеть так: `RUN ["my_executable", "my_first_param1", "my_second_param2"]`.
В предыдущем примере мы использовали shell-форму инструкции RUN в таком виде: `RUN apk update && apk upgrade && apk add bash`.
Позже в нашем Dockerfile использована exec-форма инструкции `RUN`, в виде `RUN ["mkdir", "/a_directory"]` для создания директории. При этом, используя инструкцию в такой форме, нужно помнить о необходимости оформления строк с помощью двойных кавычек, как это принято в формате JSON.
### ▍Инструкция COPY
*Инструкция COPY*
Инструкция [COPY](https://docs.docker.com/engine/reference/builder/#copy) представлена в нашем файле так: `COPY . ./app`. Она сообщает Docker о том, что нужно взять файлы и папки из локального контекста сборки и добавить их в текущую рабочую директорию образа. Если целевая директория не существует, эта инструкция её создаст.
### ▍Инструкция ADD
Инструкция [ADD](https://docs.docker.com/engine/reference/builder/#add) позволяет решать те же задачи, что и `COPY`, но с ней связана ещё пара вариантов использования. Так, с помощью этой инструкции можно добавлять в контейнер файлы, загруженные из удалённых источников, а также распаковывать локальные .tar-файлы.
В этом примере инструкция `ADD` была использована для копирования файла, доступного по URL, в директорию контейнера `my_app_directory`. Надо отметить, однако, что [документация Docker](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/) не рекомендует использование подобных файлов, полученных по URL, так как удалить их нельзя, и так как они увеличивают размер образа.
Кроме того, [документация](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#add-or-copy) предлагает везде, где это возможно, вместо инструкции `ADD` использовать инструкцию `COPY` для того, чтобы сделать файлы Dockerfile понятнее. Полагаю, команде разработчиков Docker стоило бы объединить `ADD` и `COPY` в одну инструкцию для того, чтобы тем, кто создаёт образы, не приходилось бы помнить слишком много инструкций.
Обратите внимание на то, что инструкция `ADD` содержит символ разрыва строки — `\`. Такие символы используются для улучшения читабельности длинных команд путём разбиения их на несколько строк.
### ▍Инструкция CMD
*Инструкция CMD*
Инструкция [CMD](https://docs.docker.com/engine/reference/builder/#cmd) предоставляет Docker команду, которую нужно выполнить при запуске контейнера. Результаты выполнения этой команды не добавляются в образ во время его сборки. В нашем примере с помощью этой команды запускается скрипт `my_script.py` во время выполнения контейнера.
Вот ещё кое-что, что нужно знать об инструкции `CMD`:
* В одном файле Dockerfile может присутствовать лишь одна инструкция `CMD`. Если в файле есть несколько таких инструкций, система проигнорирует все кроме последней.
* Инструкция `CMD` может иметь exec-форму. Если в эту инструкцию не входит упоминание исполняемого файла, тогда в файле должна присутствовать инструкция `ENTRYPOINT`. В таком случае обе эти инструкции должны быть представлены в формате `JSON`.
* Аргументы командной строки, передаваемые `docker run`, переопределяют аргументы, предоставленные инструкции `CMD` в Dockerfile.
### ▍Ещё более сложный Dockerfile
Рассмотрим ещё один файл Dockerfile, в котором будут использованы некоторые новые команды.
```
FROM python:3.7.2-alpine3.8
LABEL maintainer="jeffmshale@gmail.com"
# Устанавливаем зависимости
RUN apk add --update git
# Задаём текущую рабочую директорию
WORKDIR /usr/src/my_app_directory
# Копируем код из локального контекста в рабочую директорию образа
COPY . .
# Задаём значение по умолчанию для переменной
ARG my_var=my_default_value
# Настраиваем команду, которая должна быть запущена в контейнере во время его выполнения
ENTRYPOINT ["python", "./app/my_script.py", "my_var"]
# Открываем порты
EXPOSE 8000
# Создаём том для хранения данных
VOLUME /my_volume
```
В этом примере, кроме прочего, вы можете видеть комментарии, которые начинаются с символа `#`.
Одно из основных действий, выполняемых средствами Dockerfile — это установка пакетов. Как уже было сказано, существуют различные способы установки пакетов с помощью инструкции `RUN`.
Пакеты в образ Alpine Docker можно устанавливать с помощью `apk`. Для этого, как мы уже говорили, применяется команда вида `RUN apk update && apk upgrade && apk add bash`.
Кроме того, пакеты Python в образ можно устанавливать с помощью [pip](https://pypi.org/project/pip/), [wheel](https://pythonwheels.com/) и [conda](https://medium.com/@chadlagore/conda-environments-with-docker-82cdc9d25754). Если речь идёт не о Python, а о других языках программирования, то при подготовке соответствующих образов могут использоваться и другие менеджеры пакетов.
При этом для того, чтобы установка была бы возможной, нижележащий слой должен предоставить слою, в который выполняется установка пакетов, подходящий менеджер пакетов. Поэтому если вы столкнулись с проблемами при установке пакетов, убедитесь в том, что менеджер пакетов установлен до того, как вы попытаетесь им воспользоваться.
Например, инструкцию `RUN` в Dockerfile можно использовать для установки списка пакетов с помощью `pip`. Если вы так поступаете — объедините все команды в одну инструкцию и разделите её символами разрыва строки с помощью символа `\`. Благодаря такому подходу файлы будут выглядеть аккуратно и это приведёт к добавлению в образ меньшего количества слоёв, чем было бы добавлено при использовании нескольких инструкций `RUN`.
Кроме того, для установки нескольких пакетов можно поступить и по-другому. Их можно перечислить в файле и передать менеджеру пакетов этот файл с помощью `RUN`. Обычно таким файлам дают имя `requirements.txt`.
### ▍Инструкция WORKDIR
*Рабочие директории*
Инструкция [WORKDIR](https://docs.docker.com/v17.09/engine/reference/builder/#workdir) позволяет изменить рабочую директорию контейнера. С этой директорией работают инструкции `COPY`, `ADD`, `RUN`, `CMD` и `ENTRYPOINT`, идущие за `WORKDIR`. Вот некоторые особенности, касающиеся этой инструкции:
* Лучше устанавливать с помощью `WORKDIR` абсолютные пути к папкам, а не перемещаться по файловой системе с помощью команд `cd` в Dockerfile.
* Инструкция `WORKDIR` автоматически создаёт директорию в том случае, если она не существует.
* Можно использовать несколько инструкций `WORKDIR`. Если таким инструкциям предоставляются относительные пути, то каждая из них меняет текущую рабочую директорию.
### ▍Инструкция ARG
Инструкция [ARG](https://docs.docker.com/engine/reference/builder/#arg) позволяет задать переменную, значение которой можно передать из командной строки в образ во время его сборки. Значение для переменной по умолчанию можно представить в Dockerfile. Например: `ARG my_var=my_default_value`.
В отличие от `ENV`-переменных, `ARG`-переменные недоступны во время выполнения контейнера. Однако `ARG`-переменные можно использовать для задания значений по умолчанию для `ENV`-переменных из командной строки в процессе сборки образа. А `ENV`-переменные уже будут доступны в контейнере во время его выполнения. Подробности о такой методике работы с переменными можно почитать [здесь](https://vsupalov.com/docker-build-time-env-values/).
### ▍Инструкция ENTRYPOINT
*Пункт перехода в какое-то место*
Инструкция [ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint) позволяет задавать команду с аргументами, которая должна выполняться при запуске контейнера. Она похожа на команду `CMD`, но параметры, задаваемые в `ENTRYPOINT`, не перезаписываются в том случае, если контейнер запускают с параметрами командной строки.
Вместо этого аргументы командной строки, передаваемые в конструкции вида `docker run my_image_name`, добавляются к аргументам, задаваемым инструкцией `ENTRYPOINT`. Например, после выполнения команды вида `docker run my_image bash` аргумент `bash` добавится в конец списка аргументов, заданных с помощью `ENTRYPOINT`. Готовя Dockerfile, не забудьте об инструкции `CMD` или `ENTRYPOINT`.
В документации к Docker есть несколько рекомендаций, касающихся того, какую инструкцию, `CMD` или `ENTRYPOINT`, стоит выбрать в качестве инструмента для выполнения команд при запуске контейнера:
* Если при каждом запуске контейнера нужно выполнять одну и ту же команду — используйте `ENTRYPOINT`.
* Если контейнер будет использоваться в роли приложения — используйте `ENTRYPOINT`.
* Если вы знаете, что при запуске контейнера вам понадобится передавать ему аргументы, которые могут перезаписывать аргументы, указанные в Dockerfile, используйте `CMD`.
В нашем примере использование инструкции `ENTRYPOINT ["python", "my_script.py", "my_var"]` приводит к тому, что контейнер, при запуске, запускает Python-скрипт `my_script.py` с аргументом `my_var`. Значение, представленное `my_var`, потом можно использовать в скрипте с помощью [argparse](https://docs.python.org/3/library/argparse.html). Обратите внимание на то, что в Dockerfile переменной `my_var`, до её использования, назначено значение по умолчанию с помощью `ARG`. В результате, если при запуске контейнера ему не передали соответствующее значение, будет применено значение по умолчанию.
Документация Docker рекомендует использовать exec-форму `ENTRYPOINT`: `ENTRYPOINT ["executable", "param1", "param2"]`.
### ▍Инструкция EXPOSE
*Инструкция EXPOSE*
Инструкция [EXPOSE](https://docs.docker.com/engine/reference/builder/#expose) указывает на то, какие порты планируется открыть для того, чтобы через них можно было бы связаться с работающим контейнером. Эта инструкция не открывает порты. Она, скорее, играет роль документации к образу, средством общения того, кто собирает образ, и того, кто запускает контейнер.
Для того чтобы открыть порт (или порты) и настроить перенаправление портов, нужно выполнить команду `docker run` с ключом `-p`. Если использовать ключ в виде `-P` (с заглавной буквой `P`), то открыты будут все порты, указанные в инструкции `EXPOSE`.
### ▍Инструкция VOLUME
*Инструкция VOLUME*
Инструкция [VOLUME](https://docs.docker.com/engine/reference/builder/#volume) позволяет указать место, которое контейнер будет использовать для постоянного хранения файлов и для работы с такими файлами. Об этом мы ещё поговорим.
Итоги
-----
Теперь вы знаете дюжину инструкций, применяемых при создании образов с помощью Dockerfile. Этим список таких инструкций не исчерпывается. В частности, мы не рассмотрели здесь такие инструкции, как `USER`, `ONBUILD`, `STOPSIGNAL`, `SHELL` и `HEALTHCHECK`. [Вот](https://kapeli.com/cheat_sheets/Dockerfile.docset/Contents/Resources/Documents/index) краткий справочник по инструкциям Dockerfile.
Вероятно, файлы Dockerfile — это ключевой компонент экосистемы Docker, работать с которым нужно научиться всем, кто хочет уверенно чувствовать себя в этой среде. Мы ещё вернёмся к разговору о них в следующий раз, когда будем обсуждать способы уменьшения размеров образов.
**Уважаемые читатели!** Если вы пользуетесь Docker на практике, просим рассказать о том, как вы пишете Docker-файлы.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/439980/ | null | ru | null |
# Пишем редактор мнемосхем для SCADA-системы на Fabric.js
Всем добрый день. Сегодня я расскажу как на fabric.js я написал редактор мнемосхем для SCADA-системы. Доля декстопных SCADA-систем медленно но верно уменьшается. Всё переводится на Web, и АСУ ТП тут не исключение.
Итак, что хотим получить в конечном итоге: Сервер SCADA выполняется в качестве службы Windows. Технологические данные получаем от ОРС-серверов. Для обслуживания http-запросов на сервере используем компонент idhttpServer. На клиентской стороне мнемосхему будем отображать в браузере. Графика только SVG, чтобы схема сама изменялась под разрешение экрана пользователя.
Соответственно, что хотим от редактора:
* Рисование простейших фигур: прямоугольники, круги, линии, текст.
* Вставка готовых SVG-изображений, созданных в других более продвинутых редакторах.
* Изменение размеров фигур, перемещение мышкой по экрану, перемещение стрелками клавиатуры.
* Копирование/вставка/удаление.
* Привязка объекта к данным, получаемым от оборудования (по ID).
* Сохранение в файл, открытие из файла.
Всё это можно было реализовать, написав редактор под Windows. Но сложность была в рендеринге мелких SVG-изображений. И я подумал, если отображать мнемосхему будем в браузере, то почему бы в браузере её и не нарисовать? Ведь браузер лучше всех SVG и рендерит.
Тут и нашелся [fabric.js](https://habrahabr.ru/post/162367/), который для этих целей почти подошел.
Добавление, копирование, вставка простых элементов делается тривиально, всё как написано в документации. Тут приводить это не буду.
А вот со вставкой и копированием SVG-изображений не всё гладко. Далее я буду описывать, как я обходил баги fabric.js.
Есть 2 способа вставить готовое SVG-изображение на canvas:
* всё SVG-изображение вставляется как единое целое (сгруппированное)
* изображение вставляется сразу разгруппированным. Каждый элемент можно по отдельности двигать.
Основная проблема в том, что когда у SVG-элемента `есть свойство `transform="translate(168 202)"`, то SVG рисуется на канве в координатах `168 202`, а указатели для изменения размера оказываются в другом месте, в координатах `x="0" y="0"`.
[Судя по этому](https://github.com/kangax/fabric.js/issues/1520) такая болячка у него с самого рождения. Значит, SVG-изображение вставляем уже сгруппированным.
```
var addShape = function(shapeName) {
fabric.loadSVGFromURL('./assets/' + shapeName + '.svg', function(objects, options) {
var loadedObject = fabric.util.groupSVGElements(objects, options);
loadedObject.set({
left: 0,
top: 0,
angle: 0
})
.setCoords();
canvas.add(loadedObject);
});
};
```
Тот же баг (или фича?) проявляется при копировании/вставке. Стандартный метод clone c SVG не работает. При вставке указатели для изменения размера не совмещаются со вставленным изображением, поэтому сначала приводим координаты исходного изображения к 0:
```
canvas.getActiveGroup().setTop(0);
canvas.getActiveGroup().setLeft(0);
```
Затем приведенное изображение представляем в виде текста, создаём новое изображение из текста, восстанавливаем координаты исходного изображения.
**Копирование во внутренний буфер:**
```
CopyClip = function() {
var activeObject = canvas.getActiveObject(),
activeGroup = canvas.getActiveGroup();
if (activeGroup) {
var tx_top = canvas.getActiveGroup().getTop();
var tx_left = canvas.getActiveGroup().getLeft();
var tx_Angle = canvas.getActiveGroup().getAngle();
canvas.getActiveGroup().setAngle(0);
canvas.getActiveGroup().setTop(0);
canvas.getActiveGroup().setLeft(0);
var tx = canvas.getActiveGroup().toSVG();
tx = 'xml version="1.0" standalone="no"?'
+tx+ '';
canvas.getActiveGroup().setAngle(tx_Angle);
canvas.getActiveGroup().setTop(tx_top);
canvas.getActiveGroup().setLeft(tx_left);
var _loadSVG = function(svg) {
fabric.loadSVGFromString(svg, function(objects, options) {
var obj = fabric.util.groupSVGElements(objects, options);
canvas.add(obj).centerObject(obj).renderAll();
obj.setCoords();
});
}
var _loadSVGWithoutGrouping = function(svg) {
fabric.loadSVGFromString(svg, function(objects) {
canvas.add.apply(canvas, objects);
canvas.renderAll();
});
};
Buff_clipb = tx;
canvas.getActiveGroup().setAngle(tx_Angle);
}
else if (activeObject) {
var tx_top = canvas.getActiveObject().getTop();
var tx_left = canvas.getActiveObject().getLeft();
var tx_Angle = canvas.getActiveObject().getAngle();
canvas.getActiveObject().setAngle(0);
canvas.getActiveObject().setTop(0);
canvas.getActiveObject().setLeft(0);
var tx = canvas.getActiveObject().toSVG();
tx = 'xml version="1.0" standalone="no"?'
+tx+ '';
canvas.getActiveObject().setAngle(tx_Angle);
canvas.getActiveObject().setTop(tx_top);
canvas.getActiveObject().setLeft(tx_left);
var _loadSVG = function(svg) {
fabric.loadSVGFromString(svg, function(objects, options) {
var obj = fabric.util.groupSVGElements(objects, options);
canvas.add(obj).centerObject(obj).renderAll();
obj.setCoords();
});
}
Buff_clipb = tx;
canvas.getActiveObject().setAngle(tx_Angle);
};
};
```
**Вставка из внутреннего буфера:**
```
PasteClip = function() {
var _loadSVG = function(svg) {
fabric.loadSVGFromString(svg, function(objects, options) {
var obj = fabric.util.groupSVGElements(objects, options);
canvas.add(obj).centerObject(obj).renderAll();
obj.setCoords();
});
}
_loadSVG(Buff_clipb);
};
```
С рисованием линий тоже не все гладко. Толщина линии в fabric.js зависит от длины линии, что довольно-таки странно. Поэтому, линию вставляем как SVG.
**Вставка линии**
```
function addLineGoriz(wid) {
var wid2;
wid2 = $("#spinner[name=Line_widht_value]").spinner("value");
console.log('Line_widht_value ', wid2);
var SVGValue_txt;
if (tek_Stroke_color[0] != "#")
{ tek_Stroke_color = "#"+tek_Stroke_color};
var Stroke_col = tek_Stroke_color;
SVGValue_txt = "";
SVGValue_txt = 'xml version="1.0" standalone="no"?'
+SVGValue\_txt+ '';
var _loadSVGWithoutGrouping = function(svg) {
fabric.loadSVGFromString(svg, function(objects) {
canvas.add.apply(canvas, objects);
canvas.renderAll();
});
};
_loadSVGWithoutGrouping(SVGValue_txt);
};
```
Двигать стрелками клавиатуры элементы очень удобно.
**Делается тривиально:**
```
$(document).keydown(function(eventObject){
var activeObject = canvas.getActiveObject(),
activeGroup = canvas.getActiveGroup();
if ($("[name=Line_widht_value]").is(":focus"))
{
var val_width=$( "#spinner[name=Line_widht_value]" ).spinner("value");
if (activeObject) {
activeObject.setStrokeWidth(val_width);
}
}
if ($("[name=opacity_value]").is(":focus"))
{
var val_width=$( "[name=opacity_value]" ).spinner("value");
if (activeObject) {
activeObject.set("opacity",val_width);
}
}
if ($("[name=font_size_value]").is(":focus"))
{
var val_size=$( "#spinnerfont[name=font_size_value]" ).spinner("value");
if (activeObject) {
activeObject.set('fontSize',val_size);
}
}
if ((!($("[name=nameobj]").is(":focus")))&& (!($("[name=Line_widht_value]").is(":focus")))&& (!($("[name=opacity_value]").is(":focus")))&&(!($("[name=nametxt]").is(":focus")))&& (!($("[name=font_size_value]").is(":focus"))) )
{
if (activeGroup)
{
if (eventObject.which == 37) {
activeGroup.setLeft(activeGroup.getLeft()-1);
}
if (eventObject.which == 39) {
activeGroup.setLeft(activeGroup.getLeft()+1);
}
if (eventObject.which == 38) {
activeGroup.setTop(activeGroup.getTop()-1);
}
if (eventObject.which == 40) {
activeGroup.setTop(activeGroup.getTop()+1);
}
if (eventObject.which == 46) {
var objectsInGroup = activeGroup.getObjects();
canvas.discardActiveGroup();
objectsInGroup.forEach(function(object) {
canvas.remove(object);
});
}
if (eventObject.which == 67) {
CopyClip();
}
if (eventObject.which == 86) {
PasteClip();
}
}
else if (activeObject) {
if (eventObject.which == 37) {
activeObject.setLeft(activeObject.getLeft()-1);
}
if (eventObject.which == 39) {
activeObject.setLeft(activeObject.getLeft()+1);
}
if (eventObject.which == 38) {
activeObject.setTop(activeObject.getTop()-1);
}
if (eventObject.which == 40) {
activeObject.setTop(activeObject.getTop()+1);
}
if (eventObject.which == 46) {
canvas.remove(activeObject);
}
if (eventObject.which == 67) {
CopyClip();
}
if (eventObject.which == 86) {
PasteClip();
}
}
}
});
```
Привязка к тэгам SCADA-системы осуществляется через id элемента.
```
function setIDObj() {
var activeObject = canvas.getActiveObject();
if (activeObject) {
activeObject.set({
id : $("input[name=nameobj]").val()
});
}
};
```
В SCADA для отображения аналоговых величин будем использовать текстовое поле text, для дискретных любое изображение. У изображения будем менять либо цвет, либо прозрачность. Т.е. создадим 2 изображения, одно привяжем ко включенному состоянию, другое к отключенному. Когда состояние включенное, установим у первого изображения прозрачность 1, у второго 0.
Сохранение. Сохранять будем в формате SVG. Для этого воспользуемся `canvas.toSVG().`
**Открытие мнемосхемы в новой вкладке:**
```
rasterizeSVG = function() {
window.open(
'data:image/svg+xml;utf8,' +
encodeURIComponent(canvas.toSVG()));
};
```
**Открытие из файла:**
```
var Loadfromfile = function(shapeName) {
fabric.loadSVGFromURL(shapeName + '.svg', function(objects, options) {
canvas.add.apply(canvas, objects);
canvas.renderAll();
});
};
```
Загружаем SVG из файла полностью разгруппированным. И видим, что у элементов со свойством `transform="translate(X Y)"` а указатели для изменения размера оказались в левом верхнем углу, тогда как само изображение в координатах X Y.
Придется для Web-сервера писать костыль, который бы обнулял координаты `translate` и переводил их в `x="X" y="Y"`.
В Web-сервер редактора мнемосхему будем сохранять методом POST.
Продолжение [во 2-й части.](https://habrahabr.ru/post/325640/)` | https://habr.com/ru/post/322990/ | null | ru | null |
# Axios или Fetch: чем пользоваться в 2019 году?
Axios — это широко известная JavaScript-библиотека. Она представляет собой HTTP-клиент, основанный на промисах и предназначенный для браузеров и для Node.js. Если вы работали в последние несколько лет JavaScript-программистом, то вы, совершенно определённо, этой библиотекой пользовались. В октябре 2019 года пакет Axios был загружен из npm 25 миллионов раз. Кажется, что будущее Axios безоблачно. Но что если я скажу вам, что Axios — это мёртвый проект. Именно этому было посвящено одно [обсуждение](https://www.reddit.com/r/javascript/comments/cp5qhm/askjs_the_sad_state_of_axios/) на Reddit. А именно, речь идёт о следующем:
* В GitHub-репозитории Axios наблюдается весьма низкий уровень активности разработчиков.
* Проблемы и PR игнорируются.
* Команда разработчиков хранит молчание.
Ситуацию ухудшает и широко обсуждаемая [уязвимость](https://snyk.io/blog/a-denial-of-service-vulnerability-discovered-in-the-axios-javascript-package-affecting-all-versions-of-the-popular-http-client/). Об этой уязвимости сообщено 2017 году. Авторы проекта игнорировали её более двух лет.
Когда библиотека Axios стала популярной, в браузерах не было API, реализующего HTTP-клиент, основанный на промисах. Стандартный интерфейс XML HTTP Request (XHR) был неудобным, работать с ним было тяжело. Разработчики с радостью приняли Axios из-за того, что эта библиотека облегчала им жизнь.
[](https://habr.com/ru/company/ruvds/blog/477286/)
В 2015 вышел API Fetch. Почему же мы, в 2019 году, до сих пор используем Axios? Давайте сравним эти две технологии.
Объём шаблонного кода
---------------------
### ▍Fetch
```
fetch('https://jsonplaceholder.typicode.com/todos/1')
.then(response => response.json())
.then(json => console.log(json))
// {
// "userId": 1,
// "id": 1,
// "title": "delectus aut autem",
// "completed": false
// }
```
### ▍Axios
```
axios.get("https://jsonplaceholder.typicode.com/todos/1")
.then(response => console.log("response", response.data))
// {
// "userId": 1,
// "id": 1,
// "title": "delectus aut autem",
// "completed": false
// }
```
При использовании Fetch приходится иметь дело с двумя промисами. А вот при работе с Axios у нас есть прямой доступ к JSON-результату в свойстве `data` объекта ответа.
Метод `json()` миксина [Body](https://developer.mozilla.org/en-US/docs/Web/API/Body) принимает поток [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) и полностью читает его. Он возвращает промис, который разрешается JSON-результатом разбора текста тела запроса.
Ещё больше шаблонного кода в Fetch приходится использовать при работе с POST-запросами.
### ▍Fetch
```
fetch("https://jsonplaceholder.typicode.com/posts", {
method: "POST",
body: JSON.stringify({
title: "Title of post",
body: "Post Body"
})
})
.then(res => {
if (!response.ok) throw Error(response.statusText);
return response.json();
})
.then(data => console.log(data))
.catch(error => console.log(error));
```
### ▍Axios
```
axios
.post("https://jsonplaceholder.typicode.com/posts", {
title: "Title of post",
body: "Body of post"
})
.then(response => console.log(response.data))
.catch(error => console.log(error));
```
Использование Axios позволяет избежать написания больших объёмов шаблонного кода и сделать код чище и понятнее.
Обработка ошибок
----------------
### ▍Fetch
```
fetch("https://jsonplaceholder.typicode.com/todos/100000")
.then(response => {
if (!response.ok) throw Error(response.statusText);
return response.json();
})
.then(data => console.log("data", data))
.catch(error => {
console.log("error", error);
});
// error Error: Not Found
```
### ▍Axios
```
axios
.get("https://jsonplaceholder.typicode.com/todos/100000")
.then(response => {
console.log("response", response);
})
.catch(error => {
console.log("error", error);
});
// error Error: Not Found
```
Библиотека Axios выдаёт сведения о сетевых ошибках, а API Fetch — нет. Работая с Fetch всегда нужно проверять свойство `response.ok`. Для того чтобы упростить решение данной задачи, проверку этой ошибки можно оформить в виде отдельной функции:
```
const checkForError = response => {
if (!response.ok) throw Error(response.statusText);
return response.json();
};
fetch("https://jsonplaceholder.typicode.com/todos/100000")
.then(checkForError)
.then(data => console.log("data", data))
.catch(error => {
console.log("error", error);
});
```
Отсутствующие возможности
-------------------------
Axios умеет следить за ходом выгрузки данных. Fetch это не поддерживает. Это может стать решающим фактором выбора технологии для тех, кто разрабатывает приложение, позволяющее пользователям выгружать на сервер фотографии или видеофайлы.
```
const config = {
onUploadProgress: event => console.log(event.loaded)
};
axios.put("/api", data, config);
```
Альтернативные библиотеки
-------------------------
Вот пара альтернатив Axios и API Fetch:
* [Ky](https://github.com/sindresorhus/ky) — миниатюрный и продуманный HTTP-клиент, основанный на `window.fetch`.
* [Superagent](https://www.npmjs.com/package/superagent) — маленькая прогрессивная клиентская HTTP-библиотека, основанная на `XMLHttpRequest`.
Итоги
-----
Чем стоит пользоваться в 2019 году? Это зависит от многого. Например, если вам нужно отслеживать прогресс выгрузки материалов на сервер, то вам лучше всего подойдёт Axios или Superagent. Если вы можете справиться с ограничениями Fetch — тогда вам лучше воспользоваться именно этим API. А для того, чтобы немного улучшить Fetch-код, попробуйте библиотеку-обёртку наподобие Ky.
**Уважаемые читатели!** Какими HTTP-клиентами вы пользуетесь в своих проектах?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/477286/ | null | ru | null |
# FAQ по Superjob API (публикация вакансий)
Недавно я [рассказывал о Headhunter API](https://habr.com/ru/post/464013/) для публикации вакансий, упомянув Superjob. Теперь, реализовав тот же функционал на Superjob API будет справедливо поделиться с вами полученным опытом.
Работа с API Superjob
=====================
Итак, есть задача по публикации вакансий на Superjob, вам понадобятся:
Актуальная версия API
---------------------
Здесь всё ожидаемо — версионность присутствует и передаётся в URLе:
```
https://api.superjob.ru/:version/method_name/:params
```
Регистрация приложения
----------------------
Тоже максимально простая процедура — создать аккаунт, создать приложение, получить токены. Без ожиданий, ~~регистрации и смс~~.
`redirect_uri`, передаваемый в параметрах, видимо, вообще не связан с Callback URL, указанном в настройках приложения. Его (Callback URL) можно даже и не указывать, всё будет работать.
А также
-------
Указать обязательные параметры
------------------------------
Обязанности, требования и условия — необязательные параметры вакансии, а вот название компании и описание её деятельности — обязательно нужно передавать в каждую вакансию.
В прошлый раз (на HeadHunter) была попытка публиковать ссылку внутри вакансии, здесь же нашёлся параметр `url`, однако, где он отображается в вакансии понять не удалось.
Запрашивать ссылку на созданную вакансию
----------------------------------------
Вместо ожидаемого superjob/vacancies/id ссылка формируется в виде vacancy-name-id.html, но в ответе приходит лишь id вакансии. Русский текст проходит транслитерацию неизвестным алгоритмом (или по одному из N ГОСТов), что делает невозможным формировать ссылку на своей стороне. Приходится делать отдельный запрос на роут api откуда уже возвращается полная ссылка.
Выбрать между графиком работы и типом занятости
-----------------------------------------------
Superjob объединяет эти два поля, предлагая из списка, например, частичную занятость или неполный день. Это неудобно когда есть парттаймеры, срочные договора и другие варианты развития событий.
---
Итоги
=====
Про форматирование и задачи без аналитики
-----------------------------------------
В прошлый раз я упомянул, что вакансии на HeadHunter поддерживают HTML и на сайте для этого прикручен WYSIWYG-редактор. В дополнение к задаче публикации ссылок в вакансиях (которая слегка провалилась), прилетела и задача прикрутить WYSIWYG для них в нашем приложении. Текст вакансии вместе с форматированием сохраняется в БД, поэтому в таком же виде он улетел на Superjob, который HTML не поддерживает. В принципе, ожидаемо, но главный факап в том, что посмотрев эту же вакансию на HeadHunter, обнаружилось, что он тоже не поддерживает присланное форматирование! Теги просто удаляются и на выходе остаётся голый текст. Как итог — WYSIWYG будет выпиливаться, а все записанные вакансии с HTML надо будет в трёх БД как-то распарсить и почистить лишнее.
Хочется написать много плохих слов о работе на аутсорсе, но как-нибудь в другой раз.
Про удобство
------------
Если сравнивать HeadHunter и Superjob, то очевидно, что с последним всё гораздо проще. Интеграция построилась очень быстро — тексты ошибок не сбивали с толку, всё удалось протестировать на нескольких окружениях из-за необязательности Callback URL.
Что меня расстроило — это отсутствие Superjob API на Github, зато повеселил там "простой клиент" на PHP в полторы тысячи строк. Для общения с техподдержкой есть обратная связь, однако, в форме обращения отсутствует категория вопросов по API. Ну такое.
Заключение
----------
В целом, вряд ли можно однозначно сказать что у кого-то лучше, у кого-то хуже. У Superjob есть к чему придраться, но в конечном счёте сервис предоставляет нормальный API, полностью решающий наши задачи. | https://habr.com/ru/post/465663/ | null | ru | null |
# Разделение, объединение и поворот PDF-документов на Python с помощью borb
Введение
--------
***Формат переносимых документов (PDF)*** не является форматом ***WYSIWYG (What You See is What You Get (То, Что Вы Видите, это То, Что Вы Получаете)).*** Он был разработан, чтобы быть независимым от платформы, независимым от базовой операционной системы и механизмов рендеринга.
Для достижения этой цели PDF был создан для взаимодействия с помощью чего-то более похожего на язык программирования, и для достижения результата полагается ряд инструкций и операций. Фактически, PDF основан *на* языке сценариев - PostScript, который был первым независимым от устройства *языком описания страниц*.
В этом руководстве мы будем использовать [*borb*](https://borbpdf.com/) - библиотеку Python, предназначенную для чтения, манипулирования и генерации PDF-документов. Он предлагает как низкоуровневую модель (что позволяет получить доступ к точным координатам и макету), так и высокоуровневую модель (где вы можете делегировать точные расчеты полей, позиций и т. д.).
> В этом руководстве мы рассмотрим, как разделить и объединить PDF-документы на Python с помощью borb, а также рассмотрим, как поворачивать страницы в PDF-документе.
>
>
Разделение и объединение PDF-документов являются основой для многих сценариев использования:
* Обработка счета-фактуры (вам не нужны условия, чтобы вы могли удалить эти страницы)
* Добавление сопроводительного письма к документам (отчет об испытаниях, счет-фактура, рекламные материалы)
* Агрегирование тестовых результатов из гетерогенных источников
* И т.д.
Установка borb
--------------
*Borb* можно загрузить из исходного кода на [GitHub](https://github.com/jorisschellekens/borb) или установить через pip:
```
$ pip install borb
```
Разделение PDF с помощью borb
-----------------------------
Чтобы продемонстрировать разделение, вам понадобится PDF-файл с несколькими страницами.
Мы начнем с создания такого PDF-файла с помощью borb. Этот шаг не является обязательным, вы, конечно, можете просто использовать PDF-файл, который у вас есть вместо этого:
```
from borb.pdf.canvas.color.color import HexColor
from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from decimal import Decimal
def create_document(heading_color: HexColor = HexColor("0b3954"),
text_color: HexColor = HexColor("de6449"),
file_name: str = "output.pdf"):
d: Document = Document()
N: int = 10
for i in range(0, N):
# Создайте новую страницу и добавьте ее в документ
p: Page = Page()
d.append_page(p)
# Установите отображение страницы на новой странице
l: PageLayout = SingleColumnLayout(p)
# Добавьте абзац, чтобы идентифицировать страницу
l.add(Paragraph("Page %d of %d" % (i+1, N),
font_color=heading_color,
font_size=Decimal(24)))
# Добавьте абзац фиктивного текста
l.add(Paragraph("""
Lorem Ipsum is simply dummy text of the printing and typesetting industry.
Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
when an unknown printer took a galley of type and scrambled it to make a type specimen book.
It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.
It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages,
and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
""",
font_color=text_color))
# Сохраните документ на диске
with open(file_name, "wb") as pdf_out_handle:
PDF.dumps(pdf_out_handle, d)
```
Этот пример кода генерирует PDF-документ, состоящий из 10 страниц:
* Каждая страница начинается с «Страницы x из 10». Это облегчит идентификацию страниц позже.
* Каждая страница содержит 1 абзац текста.
Разделение PDF-документов на Python
-----------------------------------
Теперь давайте разделим данный PDF. Начнем с его разделения на две части: первая половина содержит первые 5 страниц, а вторая половина содержит оставшиеся:
```
def split_half_half():
# Читать PDF
with open("output.pdf", "rb") as pdf_file_handle:
input_pdf = PDF.loads(pdf_file_handle)
# Создайте два пустых PDF-файла для хранения каждой половины разделения
output_pdf_001 = Document()
output_pdf_002 = Document()
# Разделение
for i in range(0, 10):
if i < 5:
output_pdf_001.append_page(input_pdf.get_page(i))
else:
output_pdf_002.append_page(input_pdf.get_page(i))
# Написать PDF
with open("output_001.pdf", "wb") as pdf_out_handle:
PDF.dumps(pdf_out_handle, output_pdf_001)
# Написать PDF
with open("output_002.pdf", "wb") as pdf_out_handle:
PDF.dumps(pdf_out_handle, output_pdf_002)
```
Мы извлекли первые 5 страниц в новый Document, а следующие 5 страниц во второй новый Document, фактически разделив оригинальную на две меньшие сущности.
> *Может быть упрощен с помощью метода get\_page(), так как его возвращаемый тип может быть непосредственно использован для withappendappend\_page().*
>
>
Вы можете проверить полученные PDF-файлы, чтобы убедиться, что код работает должным образом
Объединение PDF-документов в Python
-----------------------------------
Для работы со следующими примерами нам понадобятся два PDF-файла. Давайте использовать более ранний код для их генерации, если у вас его еще нет:
```
create_document(HexColor("247B7B"), HexColor("78CDD7"), "output_001.pdf")
create_document(file_name="output_002.pdf")
```
Интуиция, используемая для разделения, очень похожа на слияние - хотя мы можем добавлять целые документы в другие документы, а не только страницы. Однако иногда вам может потребоваться разделить документ (отрезать последнюю страницу), прежде чем объединять его с другой.
Мы можем объединить их полностью (объединяя оба PDF-файла), но мы также можем просто добавить некоторые страницы первого PDF-файла во второй, если предпочтем это таким образом - используя функцию append\_page(), как и раньше.
Давайте начнем с их полного объединения :
```
def concatenate_two_documents():
# Прочитайте первый PDF-файл
with open("output_001.pdf", "rb") as pdf_file_handle:
input_pdf_001 = PDF.loads(pdf_file_handle)
# Прочитайте второй PDF-файл
with open("output_002.pdf", "rb") as pdf_file_handle:
input_pdf_002 = PDF.loads(pdf_file_handle)
# Создайте новый PDF-файл, объединив два входных файла
output_document = Document()
output_document.append_document(input_pdf_001)
output_document.append_document(input_pdf_002)
# Написать PDF
with open("output.pdf", "wb") as pdf_out_handle:
PDF.dumps(pdf_out_handle, output_document)
```
Поворот страниц в PDF-документах на Python
------------------------------------------
Страница в PDF-документе может быть повернута на 90 градусов в любую сторону. Этот вид работы позволяет легко переключаться между альбомным и портретным режимами.
В следующем примере вы сможете повернуть страницу одного из входных PDF-файлов, которые мы создали ранее:
```
def rotate_first_page():
# Чтение PDF
with open("output_001.pdf", "rb") as pdf_file_handle:
input_pdf_001 = PDF.loads(pdf_file_handle)
# Поворот страницы
input_pdf_001.get_page(0).rotate_left()
# Запись PDF на диск
with open("output.pdf", "wb") as pdf_out_handle:
PDF.dumps(pdf_out_handle, input_pdf_001)
``` | https://habr.com/ru/post/580016/ | null | ru | null |
# Domain Fronting. версия 1.3
В данной статье я хочу немного поговорить о такой старой и знакомой заядлым пентестерам теме как Domain fronting. Тем более, что после недавних нововведений от компании Cloudflare эта избитая тема заиграла новыми красками.
Краткое содержание предыдущих серий
-----------------------------------
Давным-давно, во времена, когда «зловещие русские хакеры» были ещё совсем маленькими, а такое модное сейчас слово как APT (advanced persistent threat) не звучало из ~~каждого утюга~~ пентестерского телеграм-канала, у хакеров и сетевых профи существовала возможность прятаться от систем слежения, антивирусов и фильтрующих прокси (EDR/XDR тогда ещё и в помине не было) с помощью специальной техники прикрытия известными доменными именами, пользующимися доверием у пользователей и средств защиты. Если кратко, то можно представить эту схему так: мы коннектимся к серверам, например, яндекса по проколу https, а уже внутри http-протокола пишем ***Host:*** [***xaker.com***](http://xaker.com)***.*** Фронт яндекса видит этот заголовок и переадресует наше подключение уже на сервер [xaker.com](http://xaker.com)
Обычный Domain FrontingТаким образом, для антивируса или прокси-сервера, который запрещает нам напрямую подключаться к xaker.сom, это подключение будет вполне себе легитимным. В качестве фронт-доменов выбирались CDN-сервисы крупных провайдеров: Майкрософта, Амазона, Яндекса, Cloudlare.
Когда данная фишка сокрытия от зорких глаз товарища майора пошла в народ, и её подхватили различные малварщики, CDN и облачные провайдеры поняли, что с этим надо как-то бороться. Они стали выключать данную возможность в своих облаках для всех, кроме аккаунтов и доменов с корпоративной подпиской, то есть лиц, пользующихся определенным доверием.
В 2018-м году компания Cloudflare придумала и первой внедрила новую фичу в протокол TLS1.3 ESNI (encrypted server name identifier). Это когда поле SNI (server name identifier) в составе пакета client-hello отсылалось на сервер в зашифрованном виде, а шифровалось оно с помощью публичного ключа, который надо было предварительно запросить у сервера через DNS TXT запись домена. Т.е опять же, если кратко: сначала мы запрашиваем TXT запись ***\_esni.xaker.com***, получаем публичный ключ, потом этим ключом ***шифруем поле SNI*** в ssl пакете client-hello, и отправляем его на сервер. Как мы всею, надеюсь, знаем из школьных уроков криптографии, при таком подходе никто, кроме владельца закрытого ключа, т.е. серверов Cloudflare не мог расшифровать это поле и понять, кому же предназначены данные соединения.
Domain Fronting через Cloudflare с применением ESNIДополнительной фишкой данного соединения являлось то, что помимо обязательной зашифрованной части ESNI пакета client-hello **мы могли снабдить его и стандартной незашифрованной частью SNI**. **И вот в нём уже указать абсолютно любой домен, которым мы хотим прикрыться**. Мы подробно описывали эту технологию в 2019-м году в статьях на Хабре, показывая на примерах как подключиться к рутрекеру под прикрытием домена [kremlin.ru](http://kremlin.ru). Прочтите — вполне доходчиво и интересно.
> <https://habr.com/ru/post/475372/> - первая часть
>
> <https://habr.com/ru/post/477696/> - вторая часть
>
>
Когда эта TLS фишка опять же ~~пошла в народ~~ была взята на вооружение малварщиками, инженеры из Cloudflare ~~сказали «Ой»~~ спешно её закрыли (правда, как и в прошлый раз, оставив её работать для своих любимых клиентов с корпоративной подпиской). С 2020-го года прикрыться чужим доменом уже не представлялось возможным, но механизм с ESNI по-прежнему работал. То есть в составе SSL client-hello пакета уже не было открытой части server name, а была лишь только закрытая.
И вот, то ли весной, то ли летом 2022 года Cloudflare полностью убрала поддержку ESNI со своих серверов. Сделали они это не потому, что этим механизмом начали пользоваться все малварщики мира, а потому что на смену ESNI пришёл ECH (Encrypted Client Hello). О принципах работы данного механизма инженеры Cloudflare написали несколько статей. Там много нововведений, но если вкратце, то суть примерно такая же – сначала мы запрашиваем публичный ключ для домена, а затем шифруем этим ключом теперь уже весь client-hello пакет, включая и server name поле.
[Подробнее про переход с ESNI на ECH на русском](https://tcinet.ru/press-centre/articles/7563/)
Переходим к водным процедурам (практическим занятиям)
-----------------------------------------------------
Прежде всего, давайте проверим в браузере как работает ECH. Берём последний Google Chrome (на момент написания статьи — 108й) и проделываем с ним пару нехитрых конфигураций:
Включаем SecureDNS и выбираем провайдера
Через настройки включаем сам ECH
На этом конфигурирование Хрома завершено. Для проверки можно открыть специальную страницу проекта [defo.io](http://defo.io) (комьюнити, работающее над внедрением ECH) — <https://defo.ie/ech-check.php>
Заветная зелёная галочка сообщает нам, что соединение с сервером произошло с использованием ECH. Мы обращались к домену [defo.ie](http://defo.ie), именно это значение было в зашифрованной части ClientHello, а в качестве «прикрытия» использовали домен [cover.defo.ie](http://cover.defo.ie), что можно видеть, если посмотреть трафик в wireshark’е.
Так же проверить работу можно и на сайте Клаудфлары.
В качестве другого практического занятия попробуем собрать openssl и curl с поддержкой ECH. Благо, ребята из проекта DEFO уже [позаботились о нас и подробно описали как это сделать](https://github.com/sftcd/openssl/blob/ECH-draft-13a/esnistuff/building-curl-openssl-with-ech.md).
Просто следуем инструкциям, качаем с гитхаба соответсвующие сорцы и собираем у себя.
Новый curl имеет соответствующий параметр --echpublic, который как раз и инструктирует нашу сборку, относительно домена прикрытия. Наш пример с курлом из прошлых статей будет выглядеть так:
В данном случае сначала необходимо получить от DNS-сервера ECH-ключи (так называемый ECHConfig). Это можно сделать запросив соответствующую запись с DNS-сервера, обслуживающего интересующий нас домен. Необходимые нам ключи содержатся в ресурсной DNS-записи HTTPS (или TYPE65) и получить их можно, например, с помощью утилиты dig:
Получить ECHConfig необходимо непосредственно перед выполнением запроса, потому что, как и в случае с ESNI, ключи меняются примерно раз в полчаса.
Тут так же следует отметить, что для своих клиентов (доменов) сервера клаудфлары не генерируют отдельные ECHConfigs и не отдают их при соответствующих запросах, но ECHConfig для домена [crypto.cloudlare.com](http://crypto.cloudlare.com) будет работать для любых доменов, заведенных за Cloudflare. Видимо, даже в самой клаудфларе процесс внедрения ECH до сих пор не «устаканен» до конца.
Поближе к хакерству
-------------------
Итак, мы посмотрели вблизи на новый механизм ECH и как его можно применить на практике. Теперь давайте адаптируем какой-нибудь хакерский инструмент (curl не в счет) под эту новую технологию. В пошлый раз мы это делали с Rsocks-туннелером. Теперь же проведём данную операцию с другим похожим инструментом (также реализованным на GO), а именно - туннелером **Ligolo-ng** от французского ~~чатланина~~ разработчика (<https://github.com/nicocha30/ligolo-ng>).
Изначально ligolo-ng не умеет работать с websocket. А поддержка данного протокола необходима для работы через Cloudflare. Добавление websocket в ligolo-ng выходит за рамки данной статьи. Скажу лишь, что ничего особо нового тут не требуется, и для websocket я использовал те же стандартные подходы/библиотеки, что и для Rsocks.
Для того чтобы научить ligolo-ng работать с ECH необходимо использовать соответствующий форк GO от Cloudflare, обеспечивающий поддержку ECH (на момент написания статьи это GO 1.18.3 ) - <https://github.com/cloudflare/go>. Качаем его с гитхаба, собираем у себя и используем в качестве GOROOT при компиляции ligolo-ng.
После компиляции у нас получаются два исполняемых модуля: proxy – серверная часть и agent – клиентская часть туннелера.
Сервер запускаем как обычно, с указанием нужного порта и префикса https, который сообщит туннелеру, что работать нужно по протоколу websocket:
Агента также запускаем с указанием флага -ech, префикса https, и нашего домена, заведенного за клаудфлару:
Видим, что агент удачно зачекинился на сервере. Дальше всё стандартно. Стартуем туннелинг и работаем как через VPN с пингами и UDP-протоколом. Чудеса, да и только!
Что же при этом видит ~~Роскомнадзор~~ wireshark:
Он видит, что сначала был отправлен запрос на [dns.google.com](http://dns.google.com) (именно через DoH агент запрашивает ключи ECHConfigs), а затем пошёл запрос на IP-адрес серверов клаудфлары, но никаких имен серверов в этих пакетах нет.
В принципе, уже неплохо. Промежуточный узел видит только IP-адреса, но не домены назначения. Однако, нам этого мало. Необходимо провести операцию прикрытия, чтобы ни у кого не возникало даже мысли о блокировке нашего соединения. Поэтому мы делаем «ход конем». Открываем файл src/crypto/tls/ech.go из GO-форка, находим строчку
```
hello.serverName = hostnameInSNI(string(echConfig.rawPublicName))
```
и меняем её на что-то более благозвучное ~~настоящему комсомольцу~~ ИБ-ресёрчеру:
Пересобираем агента, запускаем и смотрим, что на сей раз видят ребята из Роскомнадзора.
А они видят, что теперь самый главный домен страны надежно защищен лучшим в мире CDN, немного удивляются конечно, но одновременно успокаивают себя тем фактом, что теперь "хоть что-то у нас в безопасности".
Заключение
----------
В данной статье мы познакомились с новой технологией шифрованния ClientHello-пакетов протокола TLS1.3 и увидели, что данную технологию можно применять как с точки зрения defensive (защита от слежки со стороны РКН и ему подобных), так и с точки зрения offensive (DomainFronting). Пока что форк Ligolo-NG с возможностями websocket и ECH размещен на гитхабе автора статьи в отельной ветке (<https://github.com/virusvfv/ligolo-ng/tree/websocket>), но сделан соответсвующий pull-request и вполне возможно, что он войдет в основную ветку проекта.
Вангую, что довольно-таки скоро, когда уже и эта фишка с ECH DomainFronting «уйдет в народ», ребята из клаудфлары опять скажут «Ой», и отключат возможность прикрытия произвольным сleartext SNI (outer server name), как это уже было с ESNI. Но всё-таки технология ECH не стоит на месте, стандарт TLS 1.3, как я полагаю, довольно скоро станет уже настоящим стандартом, его начнут поддерживать остальные CDN (Google, Amazon, Microsoft), а браузеры начнут работать по ECH уже из коробки. Что тогда будет делать РКН - увидим.
Но это будет потом. Впереди зима... | https://habr.com/ru/post/702420/ | null | ru | null |
# Angular: делаем код читаемым для бэкендера. Бонус: подмена API заглушками и кэширование запросов
Очень часто на проекте темпы разработки фронтенда опережают темпы разработки бэкенда. При такой ситуации возникает необходимость двух вещей:
1. возможность запускать фронт без бэкэнда, либо без отдельных эндпоинтов;
2. описывать бэкендеру, какие нужны эндпоинты, формат запроса, ответа, итд.
Хочу поделиться своим способом организации кода, отвечающего за запросы к API, который отлично решает эти две задачи, а также позволяет кэшировать запросы.
Создаем в корне проекта файл конфигурации api.config.json:
```
{
"apiUrl": "https://api.example.com",
"useFakeApiByDefault": false,
"fakeEndPoints": ["Sample"]
}
```
Здесь прописываем базовый урл для API, если параметр useFakeApiByDefault = true, то наше приложение будет использовать только заглушки вместо всех запросов. Если false — то заглушки будут использоваться только для запросов из массива fakeEndPoints.
Чтобы можно было импортировать JSON в код, добавляем в секцию CompilerOptions файла tsconfig.json две строчки:
```
"resolveJsonModule": true,
"esModuleInterop": true,
```
Создаем базовый класс BaseEndpoint.
/src/app/api/\_base.endpoint.ts:
```
import {ApiMethod, ApiService} from '../services/api/api.service';
import * as ApiConfig from '../../../api.config.json';
import {ErrorService} from '../services/error/error.service';
import {NgModule} from '@angular/core';
@NgModule({providers: [ApiService, ErrorService]})
export abstract class BaseEndpoint {
protected url: string;
protected name: string;
protected method: ApiMethod = ApiMethod.Post;
protected sampleResponse: ResponseModel;
protected cache: boolean = false;
protected responseCache: ResponseModel = null;
constructor(private api: ApiService, private error: ErrorService) {
}
public execute(request: Request): Promise {
if (this.cache && this.responseCache !== null) {
return new Promise((resolve, reject) => {
resolve(this.responseCache);
});
} else {
if (ApiConfig.useFakeApiByDefault || ApiConfig.fakeEndPoints.includes(this.name)) {
console.log('Fake Api Request:: ', this.name, request);
console.log('Fake Api Response:: ', this.sampleResponse);
return new Promise((resolve) => resolve(this.sampleResponse));
} else {
return new Promise((resolve, reject) => {
this.api.execute(this.url, this.method, request).subscribe(
(response: Response) => {
if (response.status === 200) {
if (this.cache) { this.responseCache = response.payload; }
resolve(this.payloadMap(response.payload));
} else {
this.error.emit(response.error);
reject(response.error);
}
}, response => {
this.error.emit('Ошибка при обращении к серверу')
reject('Ошибка при обращении к серверу'));
}
});
}
}
}
protected payloadMap(payload: ResponseModel): ResponseModel { return payload; }
}
abstract class Response {
public status: number;
public error: string;
public payload: T;
}
```
— типы экземпляров запроса и ответа. В ответ выдергивается уже payload.
Классы ApiService и ErrorService выкладывать не буду, дабы не раздувать пост, там ничего особенного. ApiService шлет http-запросы, ErrorService позволяет подписываться на ошибки. Для вывода ошибок нужно подписаться на ErrorService в том компоненте, где собственно хотим отображать ошибки (я подписываю главный layout, в котором делаю модал либо всплывающую подсказку).
Магия начинается, когда мы от этого класса наследуемся. Класс-наследник будет выглядеть так:
/src/app/api/get-users.endpoint.ts
```
import {BaseEndpoint} from './_base.endpoint';
import {Injectable} from '@angular/core';
import {UserModel} from '../models/user.model';
@Injectable()
export class GetUsersEndpoint extends BaseEndpoint {
protected name = 'GetUsers';
protected url= '/getUsers';
protected sampleResponse = [{
id: 0,
name: 'Ivan',
age: 18
},
{
id: 1,
name: 'Igor',
age: 25
}
protected payloadMap(payload) {
return payload.map(user => new UserModel(user));
}
}
export class GetUsersRequest {
page: number;
limit: number;
}
```
Ничего лишнего, из содержимого файла сразу понятно, какой урл, какой формат запроса (GetUserRequest), какой формат ответа.
Если в отдельной папке /api будут лежать такие файлы, каждый файл соответствует своему эндпоинту, я думаю можно показать эту папку бэкендеру, и теоретически, если очень лень писать документацию по api, можно обойтись без нее. Можно внутри папки /api файлы еще раскидать по папкам соответственно контроллерам.
Если в массив «fakeEndPoints» конфига добавить 'GetUsers', то запроса не будет, а ответ подмениться данными-заглушкой из sampleResponse.
Для того, чтобы фейковые запросы можно было отлаживать (во вкладке Network, естественно, мы ничего не увидим), я предусмотрел в базовом классе вывод в консоль двух строк:
```
console.log('Fake Api Request:: ', this.name, request);
console.log('Fake Api Response:: ', this.sampleResponse);
```
Если переопределить свойство класса cache=true, то запрос будет кэшироваться (первый раз делается запрос к API, затем всегда возвращается результат первого запроса). Правда здесь стоит доработать: нужно сделать, чтобы кэширование работало только если параметры запроса (содержимое экземпляра класса UserRequest).
Метод payloadMap переопределяем в том случае, если нам нужны какие-либо преобразования данных, полученных с сервера. Если метод не переопределять, то в возвращаемом Promise будут данные из payload.
Теперь получаем данные с API в компоненте:
```
import {Component, OnInit, ViewChild} from '@angular/core';
import {UserModel} from '../../models/user.model';
import {GetUsersEndpoint, GetUsersRequest} from '../../api/get_users.endpoint';
@Component({
selector: 'app-users',
templateUrl: './users.component.html',
styleUrls: ['./users.component.css'],
providers: [GetUsersEndpoint]
})
export class UsersComponent implements OnInit {
public users: UserModel[];
public request: GetUsersRequest = {page: 1, limit: 20};
constructor(private getUsersEndpoint: GetUsersEndpoint) {
}
private load() {
this.getUsersEndpoint.execute(this.request).then(data => {
this.users = data;
});
}
ngOnInit(): void {
this.load();
}
}
```
В такой реализации можно показывать заказчику результат выполнения его «хотелок», даже если под эти хотелки еще не допилен бэкенд. Поставил нужные эндпоинты на заглушку — и уже можно «пощупать» фичи и получить фидбэк.
В комментариях жду конструктивную критику, какие проблемы могут возникнуть при наращивании функционала, какие другие подводные камни могут вылезти.
В дальнейшем хочу переписать это решение с промисов на async/await. Думаю код получиться еще более элегантным.
В запасе есть еще несколько архитектурных решений по Angular, в ближайшей перспективе планирую поделиться. | https://habr.com/ru/post/501674/ | null | ru | null |
# GUI SVN клиент для Linux
Доброго времени пребывания, уважаемые Хабровцы 8)
Наткнулся я недавно, на бескрайних просторах, на очень полезную и долгожданную штуковину. Что за штуковина — читай сабж.
Выглядит всё это, как всем известный TortoiseSVN для Windows. Только называется RabbitVCS и уже для Linux.
Если не верите, смотрите скриншоты :)
Вы уж простите меня, что не стал я делать своих скриншотов, а честно взял их с офф. сайта. Который, кстати найти можно вот тут: [rabbitvcs.org](http://rabbitvcs.org/)
Написано сие чудо с использованием питона (что не удивительно). Работает достатошно быстро…
В настоящий момент я использую Ubuntu 9.10 Karmic. Поэтому, на всякий случай опишу, как сие чудо ставится на вышеописанную систему.
1. Открываете /etc/apt/sources.list
`sudo nano /etc/apt/sources.list`
2. В самом низу добавляете 2 строчки
`deb ppa.launchpad.net/rabbitvcs/ppa/ubuntu karmic main
deb-src ppa.launchpad.net/rabbitvcs/ppa/ubuntu karmic main`
3. Добавляете в систему необходимый ключ, чтобы можно было забирать и ставить пакеты с ppa.launchpad.net
`sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 34EF4A35`
Обращаю ваше внимание, что используемые цифры — правильные, и нужно использовать именно их.
4. Обновляете список пакетов
`sudo apt-get update`
5. Устанавливаете сам пакет
`sudo apt-get install rabbitvcs`
Пакет и зависимости — качаются. Ставятся. После установки просят перезагрузить наутилус — соглашаетесь.
В конце всего запускаем наутилус и о чудо! По клике правой кнопкой — появился долгожданный пункт меню :)
Удачи при установке.
Ещё раз напоминаю офф. сайт: [rabbitvcs.org](http://rabbitvcs.org/)
Ссылка сразу на скачивание: [wiki.rabbitvcs.org/wiki/download](http://wiki.rabbitvcs.org/wiki/download)
Ссылка на мануал установки для всех убунт: [launchpad.net/~rabbitvcs/+archive/ppa](https://launchpad.net/~rabbitvcs/+archive/ppa)
И конечно же… Пользуйтесь в радость! ;)
P.S. После рестарта наутилуса могут пропасть значки на рабочем столе, что лечится рестартом иксов. | https://habr.com/ru/post/77967/ | null | ru | null |
# Выразительный JavaScript: JavaScript и браузер
#### Содержание
* [Введение](http://habrahabr.ru/post/240219/)
* [Величины, типы и операторы](http://habrahabr.ru/post/240223/)
* [Структура программ](http://habrahabr.ru/post/240225/)
* [Функции](http://habrahabr.ru/post/240349/)
* [Структуры данных: объекты и массивы](http://habrahabr.ru/post/240813/)
* [Функции высшего порядка](http://habrahabr.ru/post/241155/)
* [Тайная жизнь объектов](http://habrahabr.ru/post/241587/)
* [Проект: электронная жизнь](http://habrahabr.ru/post/241776/)
* [Поиск и обработка ошибок](http://habrahabr.ru/post/242609/)
* [Регулярные выражения](http://habrahabr.ru/post/242695/)
* [Модули](http://habrahabr.ru/post/243273/)
* [Проект: язык программирования](http://habrahabr.ru/post/243277/)
* [JavaScript и браузер](http://habrahabr.ru/post/243311/)
* [Document Object Model](http://habrahabr.ru/post/243815/)
* [Обработка событий](http://habrahabr.ru/post/244041/)
* [Проект: игра-платформер](http://habrahabr.ru/post/244405/)
* [Рисование на холсте](http://habrahabr.ru/post/244545/)
* [HTTP](http://habrahabr.ru/post/245145/)
* [Формы и поля форм](http://habrahabr.ru/post/245731/)
* [Проект: Paint](http://habrahabr.ru/post/245767/)
* [Node.js](http://habrahabr.ru/post/245775/)
* [Проект: веб-сайт по обмену опытом](http://habrahabr.ru/post/246331/)
* [Песочница для кода](http://eloquentjavascript.net/code)
*Браузер – крайне враждебная программная среда
Дуглас Крокфорд, «Язык программирования JavaScript» (видеолекция)*
Следующая часть книги расскажет о веб-браузерах. Без них не было бы JavaScript. А если бы и был, никто бы не обратил на него внимания.
Технологии веба с самого начала были децентрализованными – не только технически, но и с точки зрения их эволюции. Различные разработчики браузеров добавляли новую функциональность «по случаю», непродуманно, и часто эта функциональность обретала поддержку в других браузерах и становилась стандартом.
Это и благословление и проклятие. С одной стороны, здорово не иметь контролирующего центра, чтобы технология развивалась различными сторонами, иногда сотрудничающими, иногда конкурирующими. С другой – бессистемное развитие языка привело к тому, что результат не является ярким примером внутренней согласованности. Некоторые части привносят путаницу и беспорядок.
#### Сети и интернет
Компьютерные сети появились в 1950-х. Если вы проложите кабель между двумя или несколькими компьютерами и разрешите им передавать данные, вы может делать много удивительных вещей. А если связь двух машин в одном здании позволяет делать много разного, то связь компьютеров по всей планете должна позволять ещё больше. Технология, позволяющая это сделать, была создана в 1980-х, и получившаяся сеть зовётся интернетом. И она оправдала ожидания.
Компьютер может использовать эту сеть, чтобы кидаться битами в другой компьютер. Чтобы общение вышло эффективным, оба компьютера должны знать, что эти биты означают. Значение любой заданной последовательности битов зависит от того, что пытаются ими выразить, и какой механизм кодирования используется.
Стиль общения по сети описывает сетевой протокол. Есть протоколы для отправки е-мейлов, для получения е-мейлов, для распространения файлов и даже для контроля над компьютерами, заражёнными вредоносным софтом.
К примеру, простой протокол чата может состоять из одного компьютера, отправляющего биты, представляющие текст «ЧАТ?» на другой, а второго отвечающего текстом «ОК!», для подтверждения того, что он понял протокол. Дальше они могут перейти к отправке друг другу текстов, чтения полученных текстов и вывода их на экран.
Большинство протоколов построено на основе других протоколов. Наш протокол чата из примера рассматривает сеть как потоковое устройство, в которое можно вводить биты и заказывать их приход на конкретный адрес в правильном порядке. А обеспечение этого процесса – само по себе является сложной задачей. Transmission Control Protocol (TCP) – протокол, решающий эту задачу. Все устройства, подключённые к интернету, говорят на нём, и большинство общения в интернете построено на его основе.
Соединение по TCP работает так: один компьютер ждёт, или «слушает», пока другие не начнут с ним говорить. Чтобы можно было слушать разные виды общения в одно и то же время, для каждого из них назначается номер (называемый портом). Большинство протоколов устанавливают порт, используемый по умолчанию. К примеру, если мы отправляем е-мейл по протоколу SMTP, компьютер, через который мы его шлём, должен слушать порт 25.
Тогда другой компьютер может установить соединение, связавшись с компьютером назначения по правильному порту. Если машина назначения доступна, и она слушает этот порт, соединение устанавливается. Слушающий компьютер зовётся сервером, а соединяющийся – клиентом.
Такое соединение работает как двусторонняя труба, по которой текут биты – обе машины могут помещать в неё данные. Когда биты переданы, другая машина может их прочесть. Это удобная модель. Можно сказать, что TCP обеспечивает абстракцию сети.
#### Веб
World Wide Web, всемирная паутина (это не то же самое, что весь интернет в целом) – набор протоколов и форматов, позволяющий нам посещать странички через браузер. Веб, «паутина» в названии обозначает, что страницы можно легко связать друг с другом, в результате чего образуется гигантская сеть-паутина, по которой движутся пользователи.
Чтобы добавить в Веб содержимое, вам нужно соединить машину с интернетом и заставить её слушать 80 порт, используя протокол передачи гипертекста, Hypertext Transfer Protocol (HTTP). Он позволяет другим компьютерам запрашивать документы по сети.
Каждый документ имеет имя в виде универсального локатора ресурсов, Universal Resource Locator (URL), который выглядит примерно так:
```
http://eloquentjavascript.net/12_browser.html
| | | |
протокол сервер путь
```
Первая часть говорит нам, что URL использует протокол HTTP (в отличие от, скажем, зашифрованного HTTP, который записывается как https://). Затем идёт часть, определяющая, с какого сервера мы запрашиваем документ. Последняя – строка пути, определяющая конкретный документ или ресурс.
У каждой машины, присоединённой к интернету, есть свой адрес IP, который выглядит как 37.187.37.82. Его иногда можно использовать вместо имени сервера в URL. Но цифры сложнее запоминать и печатать, чем имена – поэтому обычно вы регистрируете доменное имя, которое указывает на конкретную машину (или набор машин). Я зарегистрировал eloquentjavascript.net, указывающий на IP-адрес машины, которую я контролирую, поэтому можно использовать этот адрес для предоставления веб-страниц.
Если вы введёте указанный URL в адресную строку браузера, он попробует запросить и показать документ, находящийся по этому URL. Во-первых, браузеру надо выяснить, куда ссылается домен eloquentjavascript.net. Затем, используя протокол HTTP, он соединяется с сервером по этому адресу, и спрашивает его ресурс по имени /12\_browser.html
В главе 17 мы подробнее рассмотрим протокол HTTP.
#### HTML
HTML, или язык разметки гипертекста, Hypertext Markup Language – формат документа, использующийся для веб-страниц. HTML содержит текст и теги, придающие тексту структуру, описывающие такие вещи, как ссылки, параграфы и заголовки.
Простой HTML документ может выглядеть так:
```
Моя домашняя страничка
Моя домашняя страничка
======================
Привет, я Марейн и это моя домашняя страничка.
А ещё я книжку написал! Читайте её
[здесь](http://eloquentjavascript.net).
```
Теги, окружённые угловыми скобками < и >, описывают информацию о структуре документа. Всё остальное – просто текст.
Документ начинается с , и это говорит браузеру, что его надо интерпретировать как современный HTML, в отличие от разных диалектов прошлого.
У HTML документов есть заголовок и тело. Заголовок содержит информацию о документе, а тело – сам документ. В нашем случае мы объявили, что название страницы будет «Моя домашняя страничка», затем описали документ, содержащий заголовок (, то есть heading 1, заголовок 1, самый крупный. Теги с по обозначают заголовки меньших размеров) и два параграфа .
У тегов может быть несколько форм. Элемент вроде тела, параграфа и ссылки начинается открывающим тегом и заканчивается закрывающим . Некоторые открывающие теги, типа ссылки , содержат дополнительную информацию в виде имя=”значение”. Она называется «атрибутами». В нашем случае адрес ссылки задан как href=”http://eloquentjavascript.net”, где href означает «гипертекстовая ссылка», “hypertext reference”.
Некоторые теги ничего не окружают, и их не надо закрывать. Пример – тег картинки , который показывает картинку, находящуюся по заданному адресу URL.
Чтобы включать в текст документа угловые скобки, нужно пользоваться специальной записью, так как в HTML они имеют особое значение. Открывающая скобка (она же знак «меньше») записывается как "<" («less than», «меньше, чем»), закрывающая — ">" («greater than», «больше, чем»). В HTML амперсанд &, за которым идёт слово и точка с запятой, зовётся сущностью и заменяется символом, который кодируется этой последовательностью.
Это похоже на обратные слэши, используемые в строках JavaScript. Из-за специального значения амперсанда его самого в текст можно включать в виде &. В атрибуте, заключаемом в двойные кавычки, символ кавычек записывается как ".
HTML разбирается парсером довольно либерально по отношению к возможным ошибкам. Если какие-то теги пропущены, браузер их воссоздаёт. Как именно это происходит, записано в стандартах, поэтому можно ожидать, что все современные браузеры будут делать это одинаково.
Следующий документ будет обработан так же, как и предыдущий.
```
Моя домашняя страничка
Моя домашняя страничка
Привет, я Марейн и это моя домашняя страничка.
А ещё я книжку написал! Читайте её
[here](http://eloquentjavascript.net).
```
Отсутствуют теги , и . Браузер знает, что должен быть в , а — в . Кроме того, параграфы не закрыты, поскольку открытие нового параграфа или конец документа означают их принудительное закрытие. Также адрес не заключён в кавычки.
В этой книге мы опустим теги , и для краткости. Но я буду закрывать теги, и заключать атрибуты в кавычки.
Также обычно я буду опускать doctype. Я не советую делать это вам – браузеры иногда могут творить странные вещи, когда вы их опускаете. Считайте, что они присутствуют в примерах по умолчанию.
HTML и JavaScript
В контексте нашей книги самый главный тег HTML — . Он позволяет включать в документ программу на JavaScript.<br/>
<br/>
<pre><code class="html"><h1>Внимание, тест.</h1>
<script>alert("Привет!");
Такой скрипт запустится сразу, как только браузер встретит тег при разборе HTML. На странице появится диалог-предупреждение.<br/>
<br/>
Включать большие программы в HTML непрактично. У тега <script> есть атрибут src, чтобы запрашивать файл со скриптом (текст, содержащий программу на JavaScript) с адреса URL.<br/>
<br/>
<pre><code class="html"><h1>Внимание, тест.</h1>
<script src="code/hello.js">
В файле code/hello.js содержится та же простая программа «alert('Привет!');». Когда страница ссылается на другой URL и включает его в себя, браузер подгружает этот файл и включает их в страницу.
Тег script всегда надо закрывать при помощи , даже если он не содержит кода и ссылается на файл скрипта. Если вы забудете это сделать, оставшаяся часть страницы будет обработана как скрипт.
Некоторые атрибуты тоже могут содержать программу JavaScript. У тега (на странице он выглядит как кнопка) есть атрибут onClick, и его содержимое будет запущено, когда по кнопке щёлкают мышкой.
```
НЕ ЖМИ
```
Заметьте, что я использовал одинарные кавычки для строки в атрибуте onclick, поскольку двойные кавычки уже используются в самом атрибуте. Можно было бы использовать ", но это бы затруднило чтение.
Песочница
Запуск скачанных из интернета программ небезопасен. Вы не знаете ничего о тех людях, которые делали посещаемые вами сайты, и они не всегда доброжелательны. Запуская программы злых людей, вы можете заразить компьютер вирусами, потерять свои данные или дать доступ к своим аккаунтам третьим лицам.
Но привлекательность веба в том, что по нему можно сёрфить без обязательного доверия всем посещаемым страницам. Поэтому браузеры сильно ограничивают то, что может сделать программа JavaScript. Она не может открывать файлы на компьютере, или менять что-либо, не связанное со страницей, в которую она встроена.
Изолированное таким образом окружение называется песочницей – в том смысле, что программа безобидно играется в песочнице. Представляйте, однако, эту песочницу как клетку из толстых стальных прутьев.
Сложность в создании песочницы – позволять программам делать достаточно много, чтобы они были полезными, при этом ограничивая их от совершения опасных действий. Много из того, что делает пользователь, например общение с другими серверами или чтение содержимого буфера обмена, можно использовать для нарушения приватности.
Время от времени кто-то придумывает способ обойти ограничения браузера и сделать что-то вредное, от утечки некоей приватной информации до полного контроля над компьютером, где запущен скрипт. Разработчики исправляют эту дырку в браузере, и снова всё хорошо – до появления следующей проблемы, которая, можно надеяться, будет опубликована, и не тайно использоваться правительством или мафией.
Совместимость и браузерные войны
На ранних стадиях развития Веба браузер по имени Mosaic занимал большую часть рынка. Через несколько лет баланс сместился в сторону Netscape, который затем был сильно потеснён браузером Internet Explorer от Microsoft. В любой момент превосходства одного из браузеров его разработчики позволяли себе в одностороннем порядке изобретать новые свойства веба. Так как большинство людей использовали один и тот же браузер, сайты просто начинали использовать эти свойства, не обращая внимания на остальные браузеры.
Это были тёмные века совместимости, которые иногда называли «войнами браузеров». Веб-разработчики сталкивались с двумя или тремя несовместимыми платформами. Кроме того, браузеры около 2003 года были полны ошибок, причём у каждого они были свои. Жизнь людей, создававших веб-страницы, была тяжёлой.
Mozilla Firefox, некоммерческое ответвление Netscape, бросил вызов гегемонии Internet Explorer в конце 2000-х. Так как Microsoft особо не стремилась к конкуренции, Firefox отобрал солидную часть рынка. Примерно в это время Google представил свой браузер Chrome, а Apple – Safari. Это привело к появлению четырёх основных игроков вместо одного.
У новых игроков были более серьёзные намерения по отношению к стандартам и больше инженерного опыта, что привело к лучшей совместимости и меньшему количеству багов. Microsoft, видя сжатие своей части рынка, приняла эти стандарты. Если вы начинаете изучать веб-разработку сегодня – вам повезло. Последние версии основных браузеров работают одинаково и в них мало ошибок.
Нельзя сказать, что ситуация уже идеальная. Некоторые люди в вебе по причинам инерционности или корпоративных правил используют очень старые браузеры. Пока они не отомрут совсем, написание веб-страниц для них потребует мистических знаний об их недостатках и причудах. Эта книга не про причуды – она представляет современный, разумный стиль веб-программирования.
=================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================== | https://habr.com/ru/post/243311/ | null | ru | null |
# Восхождение на Эльбрус — Разведка боем. Техническая Часть 2. Прерывания, исключения, системный таймер
Продолжаем исследовать [Эльбрус](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81_2000) путем портирования на него [Embox](https://github.com/embox/embox).
Данная статья является второй частью технической статьи об архитектуре Эльбрус. В [первой части](https://habr.com/ru/company/embox/blog/447704/) речь шла о стеках, регистрах и так далее. Перед прочтением этой части рекомендуем изучить первую, поскольку в ней рассказывается о базовых вещах архитектуры Эльбрус. В этой части речь пойдет о таймерах, прерываниях и исключениях. Это, опять же, не официальная документация. За ней следует обращаться к разработчикам Эльбруса в [МЦСТ](http://www.mcst.ru/).
Приступая к изучению Эльбруса, нам хотелось побыстрее запустить таймер, ведь, как вы понимаете, вытесняющая многозадачность без него не работает. Для этого казалось достаточно реализовать контроллер прерываний и сам таймер, но мы столкнулись с ~~неожиданными~~ ожидаемыми трудностями, куда же без них. Стали искать возможности отладки и выяснили, что разработчики об этом позаботились, введя несколько команд, которые позволяют вызывать различные исключительные ситуации. Например, можно сгенерировать исключение специального вида через регистры PSR (Processor Status Register) и UPSR (User processor status register). Для PSR бит exc\_last\_wish — флаг генерации исключительной ситуации exc\_last\_wish при возврате из процедуры, а для UPSR — exc\_d\_interrupt, это флаг отложенного прерывания, которые вырабатываются операцией VFDI (Проверка флага отложенного прерывания).
Код следующий:
```
#define UPSR_DI (1 << 3) /* Определен в .h файле */
rrs %upsr, %r1
ors %r1, UPSR_DI, %r1 /* upsr |= UPSR_DI; */
rws %r1, %upsr
vfdi /* Вот здесь должно выработаться исключение */
```
Запустили. Но ничего не произошло, система где-то висела, в консоль ничего не выводилось. Собственно это мы и видели, когда пытались запустить прерывание от таймера, но тогда было много составляющих, а тут было понятно, что произошло нечто прерывающее последовательный ход выполнения нашей программы, и управление передалось на таблицу исключений (в терминах архитектуры Эльбрус правильнее говорить не о таблице прерываний а о таблице исключений). Мы предположили, что процессор все-таки выработал исключение, но там, куда он передал управление, лежит какой-то “мусор”. Как оказалось, передает он управление в то самое место куда мы положили образ Embox, а значит там лежала точка входа — функция entry.
Для проверки мы сделали следующее. Завели счетчик входов в entry(). Изначально стартуют все CPU с выключенными прерываниями, заходят в entry(), после чего мы оставляем активным только одно ядро, все остальные уходят в бесконечный цикл. После того как счетчик сравнялся с количеством CPU, считаем что все последующие попадания в entry — это исключения. Напоминаю, что раньше было так, как описано в [нашей самой первой статье про Эльбрус](https://habr.com/ru/company/embox/blog/421441/)
```
cpuid = __e2k_atomic32_add(1, &last_cpuid);
if (cpuid > 1) {
/* XXX currently we support only single core */
while(1);
}
/* copy of trap table */
memcpy((void*)0, &_t_entry, 0x1800);
kernel_start();
```
Сделали так
```
/* Since we enable exceptions only when all CPUs except the main one
* reached the idle state (cpu_idle), we can rely that order and can
* guarantee exceptions happen strictly after all CPUS entries. */
if (entries_count >= CPU_COUNT) {
/* Entering here because of expection or interrupt */
e2k_trap_handler(regs);
...
}
/* It wasn't exception, so we decide this usual program execution,
* that is, Embox started on CPU0 or CPU1 */
e2k_wait_all();
entries_count = __e2k_atomic32_add(1, &entries_count);
if (entries_count > 1) {
/* XXX currently we support only single core */
cpu_idle();
}
e2k_kernel_start();
}
```
И наконец увидели реакцию на вход в прерывание (просто с помощью printf вывели строчку).
Тут стоит объяснить, что изначально в первом варианте мы рассчитывали скопировать таблицу исключений, но во-первых, оказалось, что она находится по нашему адресу, а во-вторых, нам так и не удалось сделать корректное копирование. Пришлось переписывать линкер-скрипты, точку входа в систему, ну и обработчик прерывания, то есть понадобилась ассемблерная часть, о ней чуть позже.
Вот так теперь выглядит часть модифицированная часть линкер скрипта:
```
.text : {
_start = .;
_t_entry = .;
/* Interrupt handler */
*(.ttable_entry0)
. = _t_entry + 0x800;
/* Syscall handler */
*(.ttable_entry1)
. = _t_entry + 0x1000;
/* longjmp handler */
*(.ttable_entry2)
. = _t_entry + 0x1800;
_t_entry_end = .;
*(.e2k_entry)
*(.cpu_idle)
/* text */
}
```
то есть секцию входа мы убрали за таблицу исключений. Там же находится и секция cpu\_idle для тех CPU, которые не используются.
Вот так выглядит функция входа для нашего активного ядра, на котором будет выполняться Embox:
```
static void e2k_kernel_start(void) {
extern void kernel_start(void);
int psr;
/* Ждем пока остальные CPU “уснут” */
while (idled_cpus_count < CPU_COUNT - 1)
;
...
/* Отключаем операции с плавающей точкой, они разрешены по умолчанию */
e2k_upsr_write(e2k_upsr_read() & ~UPSR_FE);
kernel_start(); /* Входим в Embox */
}
```
Отлично, по инструкции VFDI выработалось исключение. Теперь нужно получить его номер, чтобы убедиться, что это правильное исключение. Для этого в Эльбрусе есть регистры информации о прерываниях TIR (Trap Info registers). Они содержат информацию о нескольких последних командах, то есть заключительной части трассы выполнения (trace). Trace собирается во время выполнения программы и «замораживается» при входе в прерывание. TIR включает в себя младшую (64 бита) и старшую (64 бита) части. В младшем слове содержатся флаги исключений, а в старшем слове указатель на инструкцию приведшую к исключению и номер текущего TIR’a. Соответственно, в нашем случае exc\_d\_interrupt это 4-ый бит.
Примечание у нас еще осталось некоторое непонимание касательно глубины (кол-ва) TIR’ов. В документации приводится:
> “Глубина памяти TIR, то есть количество регистров Trap Info, определяется
>
> TIR\_NUM macro, равным количеству стадий конвейера процессора, требуемых для
>
> выдачи всех возможных особых ситуаций. TIR\_NUM = 19;”
На практике же, мы видим глубину = 1, и поэтому используем только регистр TIR0.
Специалисты в МЦСТ нам пояснили, что все правильно, и для «точных» прерываний будет только TIR0, а для других ситуаций может быть и другое. Но поскольку пока речь идет только о прерываниях от таймера, нам это не мешает.
Хорошо, теперь разберем, что нужно для правильного входа/выхода из обработчика исключения. На самом деле необходимо сохранять на входе и восстанавливать на выходе 5 следующих регистров. Три регистра подготовки передачи управления — ctpr[1,2,3], и два регистра управления циклами — ILCR(Регистр исходного значения счетчика циклов) и LSR (Регистр состояния цикла).
```
.type ttable_entry0,@function
ttable_entry0:
setwd wsz = 0x10, nfx = 1;
rrd %ctpr1, %dr1
rrd %ctpr2, %dr2
rrd %ctpr3, %dr3
rrd %ilcr, %dr4
rrd %lsr, %dr5
/* sizeof pt_regs */
getsp -(5 * 8), %dr0
std %dr1, [%dr0 + PT_CTRP1] /* regs->ctpr1 = ctpr1 */
std %dr2, [%dr0 + PT_CTRP2] /* regs->ctpr2 = ctpr2 */
std %dr3, [%dr0 + PT_CTRP3] /* regs->ctpr3 = ctpr3 */
std %dr4, [%dr0 + PT_ILCR] /* regs->ilcr = ilcr */
std %dr5, [%dr0 + PT_LSR] /* regs->lsr = lsr */
disp %ctpr1, e2k_entry
ct %ctpr1
```
Собственно, на этом все, после выхода из обработчика исключения нужно восстановить эти 5 регистров.
Мы делаем это с помощью макроса:
```
#define RESTORE_COMMON_REGS(regs) \
({ \
uint64_t ctpr1 = regs->ctpr1, ctpr2 = regs->ctpr2, \
ctpr3 = regs->ctpr3, lsr = regs->lsr, \
ilcr = regs->ilcr; \
/* ctpr2 is restored first because of tight time constraints \
* on restoring ctpr2 and aaldv. */ \
E2K_SET_DSREG(ctpr1, ctpr1); \
E2K_SET_DSREG(ctpr2, ctpr2); \
E2K_SET_DSREG(ctpr3, ctpr3); \
E2K_SET_DSREG(lsr, lsr); \
E2K_SET_DSREG(ilcr, ilcr); \
})
```
Еще важно не забыть уже после восстановления регистров вызвать операцию DONE (Возврат из аппаратного обработчика прерываний). Эта операция нужна в частности для того, чтобы корректно обработать прерванные операции передачи управления. Это мы делаем с помощью макроса:
```
#define E2K_DONE \
do { \
asm volatile ("{nop 3} {done}" ::: "ctpr3"); \
} while (0)
```
Собственно возврат из прерывания мы делаем прямо в Си коде с помощью этих двух макросов.
```
/* Entering here because of expection or interrupt */
e2k_trap_handler(regs);
RESTORE_COMMON_REGS(regs);
E2K_DONE;
```
### Внешние прерывания
Начнем с того, как же разрешить внешние прерывания. В Эльбрусe в качестве контроллера прерываний используется APIC (точнее его аналог), в Embox уже был этот драйвер. Поэтому можно было подцепить к нему системный таймер. Есть два таймера, один какой-то очень похожий на [PIT](https://en.wikipedia.org/wiki/Programmable_interval_timer), другой [LAPIC Timer](https://en.wikipedia.org/wiki/Advanced_Programmable_Interrupt_Controller#APIC_timer), тоже достаточно стандартный, поэтому рассказывать о них не имеет смысла. И то, и то выглядело просто, и то и то в Embox уже было, но драйвер LAPIC-таймера выглядел более перспективно, к тому же реализация PIT таймера нам показалась более нестандартной. Следовательно, доделать казалось проще. К тому же в официальной документации были описаны регистры APIC и LAPIC, которые немного отличались от оригиналов. Приводить их нет смысла, поскольку можно посмотреть в оригинале.
Помимо разрешения прерывания в APIC необходимо разрешить обработку прерываний через регистры PSR/UPSR. В обоих регистрах есть флаги разрешения внешних прерываний и немаскируемых прерываний. *НО* тут очень важно отметить, что регистр PSR является *локальным* для функции (об этом говорилось в [первой технической части](https://habr.com/ru/company/embox/blog/447704/)). А это означает, что если вы его выставили внутри функции, то при вызове всех последующих функций он будет наследоваться, но при возврате из функции вернет свое первоначальное состояние. Отсюда вопрос, а как же управлять прерываниями?
Мы используем следующее решение. Регистр PSR позволяет включить управление через UPSR, который уже является глобальным (что нам и нужно). Поэтому мы разрешаем управление через UPSR непосредственно (важно!) перед функцией входа в ядро Embox:
```
/* PSR is local register and makes sense only within a function,
* so we set it here before kernel start. */
asm volatile ("rrs %%psr, %0" : "=r"(psr) :);
psr |= (PSR_IE | PSR_NMIE | PSR_UIE);
asm volatile ("rws %0, %%psr" : : "ri"(psr));
kernel_start();
```
Как-то случайно после рефакторинга я взял и вынес эти строчки в отдельную функцию… А регистр-то локальный для функции. Понятно, что все сломалось :)
Итак, в процессоре все необходимое, вроде бы, включили, переходим к контроллеру прерываний.
Как мы уже разобрались выше, информация о номере исключения находится в регистре TIR. Далее, 32-ой бит в этом регистре сообщает о том, что случилось внешнее прерывание.
После включения таймера последовало пару дней мучений, так как никакого прерывания получить не удалось. Причина была достаточной забавной. В Эльбрусе 64-битные указатели, а адрес регистра в APIC влазил в uint32\_t, поэтому мы их и использовали. Но оказалось, что если вам нужно, например, привести 0xF0000000 к указателю, то вы получите не 0xF0000000, а 0xFFFFFFFFF0000000. То есть, компилятор расширит ваш unsigned int знаком.
Здесь конечно нужно было использовать uintptr\_t, поскольку, как выяснилось, в стандарте C99 такого рода приведения типов implementation defined.
После того как мы наконец-то увидели поднятый 32-ой бит в TIR’e, стали искать как получить номер прерывания. Это оказалось довольно просто, хотя и совсем не так как на x86, это одно из отличий реализаций LAPIC. Для Эльбруса, чтобы достать номер прерывания, нужно залезть в специальный регистр LAPIC:
```
#define APIC_VECT (0xFEE00000 + 0xFF0)
```
где 0xFEE00000 — это базовый адрес регистров LAPIC.
На этом все, получилось подцепить и системный таймер и LAPIC таймер.
### Заключение
Информации, приведенной в первых двух технических частях статьи про архитектуру Эльбрус, достаточно для того, чтобы реализовать в любой ОС аппаратные прерывания и вытесняющую многозадачность. Собственно, приведенные скриншоты об этом свидетельствуют.
Это не последняя техническая часть про архитектуру Эльбрус. Сейчас мы осваиваем управление памятью (MMU) в Эльбрусе, надеемся скоро расскажем и о нем. Нам это то и нужно не только для реализации виртуальных адресных пространств, но и для нормальной работы с периферией, ведь через этот механизм можно отключить или включить кеширование определенной области адресного пространства.
Все, что написано в статье можно найти в репозитории [Embox](https://github.com/embox/embox). Также можно собрать и запустить, если конечно имеется аппаратная платформа. Правда, для этого нужен компилятор, а его можно получить только в [МЦСТ](http://www.mcst.ru/). Официальную документацию можно запросить там же. | https://habr.com/ru/post/447744/ | null | ru | null |
# Как не потерять ход времени, работая за компьютером. Приложение по мониторингу работы и ведению статистики
Я работаю педагогом в детском технопарке «Кванториум». В период самоизоляции мы так же, как и все перешли на дистанционное обучение. И в связи с тем, что дети стали еще больше времени проводить за компьютером, администрация решила сократить академический час и делать перерывы между работой — чтобы сохранить зрение. Мы написали приложение, которое подсчитывает время, проведенное за компьютером, ведет статистику в excel — полезно для родителей, и выдает звуковое оповещение о том, что пора сделать перерыв.
Приложение будем полезно тем, кто теряется во времени работая за пк и хочет вогнать себя во временные рамки или следить за тем, какая часть жизни теряется в цифровом пространстве.
[Ссылка на репозиторий](https://github.com/evg-voronov/chasovoy)
Под катом подробный разбор.
Для создания программы нужно решить следующие задачи:
* детекция лица через web камеру (используем mtcnn);
* подсчёт времени (библиотека time)
* запись данных в excel документ (библиотека openpyxl);
* звуковое оповещение;
* автозагрузка скрипта при включении ПК.
### Детекция лица с использованием web камеры
Мы рассматривали вариант отслеживать присутствие за компьютером по движению компьютерной мыши, возможно это проще и web камера останется свободной, но тогда мы не сможем учитывать просмотр сериалов или youtube роликов, к тому же использовать распознавание лиц гораздо интереснее.
Для детекции лица используем архитектуру mtcnn. Голова, расположенная под любым углом, в очках, при плохом освещении, даже если лицо не полностью попадает в кадр или прикрыто рукой, нейронная сеть работает исправно. Самостоятельно собирать ее не станем, подключим библиотеку с одноименным названием, которая решит нашу задачу используя несколько строчек кода.
Изначально использовали метод Виолы — Джонса. Точность намного хуже, чем у mtcnn, процессор загружает так же.
Вывод результата вынесем в отдельную функцию, она нужна только для того, чтобы посмотреть, как работает распознавание.
```
import cv2
import os
from mtcnn.mtcnn import MTCNN
def show_face_frame():
if faces:
bounding_box = faces[0]['box']
keypoints = faces[0]['keypoints']
cv2.rectangle(img,
(bounding_box[0], bounding_box[1]),
(bounding_box[0] + bounding_box[2],
bounding_box[1] + bounding_box[3]),
(0, 0, 255),
2)
cv2.circle(img, (keypoints['left_eye']), 3, (0, 0, 255), 2)
cv2.circle(img, (keypoints['right_eye']), 2, (0, 0, 255), 2)
cv2.circle(img, (keypoints['nose']), 3, (0, 0, 255), 2)
cv2.circle(img, (keypoints['mouth_left']), 3, (0, 0, 255), 2)
cv2.circle(img, (keypoints['mouth_right']), 3, (0, 0, 255), 2)
cv2.imshow('frame', img)
cap = cv2.VideoCapture(0)
detector = MTCNN()
while cap.isOpened():
_, img = cap.read()
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
faces = detector.detect_faces(img)
show_face_frame()
cv2.waitKey(300)
cap.release()
cv2.destroyAllWindows()
```
Большая задержка **cv2.waitKey(300)**, чтобы не загружать процессор. Обработка 3-4 кадров в секунду загружают i3-8145U в среднем на 15%.
### Подсчет времени
Программа не должна делать записи в журнал в следующих случаях:
* сел за компьютер на 5 сек что-то по бырику сделать;
* вышел налить кофе или размять ноги.
Для решения этих задач в программе используется два секундомера **time\_here** (отсчитывает время, когда лицо в кадре) и **time\_not\_here** (когда лица нет). Оба секундомера сбрасываются, когда производится запись в журнал. К тому же **time\_not\_here** сбрасывается каждый раз, когда лицо появляется в кадре.
В переменной **min\_time\_here** указано минимальное время, проведенное за компьютером, после которого стоит делать запись в журнал. Запись будет произведена после того, как человек отвлечётся от компьютера на время большее, чем указано в **min\_time\_not\_here**.
В коде ниже запись осуществляется, если провел минимум 5 минут за компьютером. Программа не будет учитывать то, что я отвлекаюсь меньше чем на 2 минуты.
```
import cv2
import time
import os
from mtcnn.mtcnn import MTCNN
cap = cv2.VideoCapture(0)
path = os.path.abspath(__file__)[:-11] # из абсолютного пути удаляем имя файла
here, not_here = 0, 0 # секундомеры
time_here, time_not_here = 0, 0 # количество времени
switch = True # переключатель определяет есть лицо в кадре или нет
min_time_here = 300 # минимально время проведенное за пк, после которого производится запись (в секундах)
min_time_not_here = 120 # максимальное время отвлечение от компьютера которое не учитывается программой (в секундах)
detector = MTCNN()
try:
while cap.isOpened():
_, img = cap.read()
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
faces = detector.detect_faces(img)
show_face_frame()
audio_message(path, here)
if faces and switch:
not_here = 0
switch = False
if here == 0:
here = time.time()
print('вы сели за компьютер в ' + time.strftime("%H:%M:%S", time.localtime(here)))
elif not faces and not switch:
not_here = time.time()
switch = True
if not_here != 0:
time_not_here = time.time() - not_here
if here != 0 and not switch:
time_here = time.time() - here
if time_here > min_time_here and time_not_here > min_time_not_here: # делаем запись если провели за ПК больше min_time_here
write_excel(path, here)
print('вы провели за компьютером ' + time.strftime('%H:%M:%S', time.gmtime(time.time() - here)))
time_here, time_not_here = 0, 0
here, not_here = 0, 0
elif time_not_here > min_time_not_here and time_here < min_time_here: # если за ПК провели меньше min_time_here, то ничего не записываем
print('запись не произведена')
time_here, time_not_here = 0, 0
here, not_here = 0, 0
cv2.waitKey(300)
except KeyboardInterrupt:
if time_here > min_time_here: # делаем запись если провели за ПК больше min_time_here
write_excel(path, here)
cap.release()
cv2.destroyAllWindows()
```
Если пользователь хочет выключить компьютер, для начала нужно прервать работу программы (ctrl+c) и время текущей работы попадет в журнал. Для этого используется обработчик исключений.
### Запись данных в excel документ
Для работы с excel поможет замечательная библиотека openpyxl, которая одновременно считывать и записывать данные.
Каждый день программа создает новый лист с текущей датой.
На 1 листе записывается посуточная информация, в какой день сколько времени провели за компьютером.
Функция **write\_excel** открывает документ записывает данные и сразу же закрывает.
Нельзя изменить документ через openpyxl, если он уже открыт пользователем. На этот случай добавлено исключение.
```
def write_excel(path_excel, time_start):
wb = openpyxl.load_workbook(path_excel + r'\dnevnik.xlsx')
today = time.strftime("%d.%m.%Y", time.localtime(time.time()))
if today not in wb.sheetnames: # если листа с сегодняшней датой еще не существует, то создаем его
wb.create_sheet(title=today)
sheet = wb[today]
sheet.column_dimensions['A'].width = 20
sheet.column_dimensions['B'].width = 20
sheet.column_dimensions['C'].width = 20
sheet.column_dimensions['D'].width = 31
sheet['A1'] = 'Начал работать за ПК'
sheet['B1'] = 'Время работы за ПК'
sheet['C1'] = 'Закончил работать'
sheet['D1'] = 'Сел за компьютер:'
sheet['D2'] = 'Всего провели за ПК времени:'
sheet = wb[today]
row = 2
all_time = 0
else: # если лист уже создан извлекаем информацию
sheet = wb[today]
row = sheet['E1'].value # номер строки в excel документе
all_time = sheet['E2'].value # общее время проведенное за ПК за один день
all_time = all_time.split(':')
all_time = int(all_time[0]) * 3600 + int(all_time[1]) * 60 + int(all_time[2]) # время переводим в секунды
row = row + 2 # плюсуем шапку таблицы и новую строку
sheet['A' + str(row)] = time.strftime("%H:%M:%S", time.localtime(time_start)) # записываем время когда сели за пк
sheet['C' + str(row)] = time.strftime("%H:%M:%S", time.localtime(time.time())) # когда вышли из-за пк
seconds = time.time() - time_start # время которое мы провели за компьютером
sheet['B' + str(row)] = time.strftime('%H:%M:%S', time.gmtime(seconds))
sheet['E1'] = row - 1 # вычитаем шапку таблицу
all_time = all_time + seconds
all_time = time.strftime('%H:%M:%S', time.gmtime(all_time))
sheet['E2'] = all_time
# заполняем первый лист
sheet_0 = wb.worksheets[0]
sheet_0['A' + str(len(wb.sheetnames))] = today
sheet_0['B' + str(len(wb.sheetnames))] = all_time
while True: # закрываем файл
try:
wb.save(path_excel + r'\dnevnik.xlsx')
except PermissionError:
input('Сначала закройте excel файл и подтвердите нажав enter')
else:
break
```
### Звуковое оповещение
Для разнообразия сгенерировали 8 аудиофайлов используя [синтезатор речи](https://apihost.ru/voice), которые запускаются рандомно после часа работы. Пока не сделаете перерыв, повторных звуковых оповещений не будет.
```
def audio_message(path, here):
if here == 0:
pass
elif time.strftime('%H:%M:%S', time.gmtime(time.time()-here)) == "01:00:00":
wav = random.choice(os.listdir(path + r'\audio'))
winsound.PlaySound(path + r'\audio\\' + wav, winsound.SND_FILENAME)
```
### Автозагрузка скрипта при включении ПК
Для того чтобы программа загружалась вместе с виндой можно создать батник, который будет запускать python скрипт. Батник должен находиться в директории:
*C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup*
C учетом того, что батник и исходный файл хранятся в разных директориях, нельзя использовать функцию **os.getcwd()** так как она вернет путь до батника. Мы используем **os.path.abspath(\_\_file\_\_)[:-11]**
**UPD:** [ak545](https://habr.com/ru/users/ak545/) предложил вариант получше **os.path.dirname(os.path.abspath(\_\_file\_\_))**
### В будущем
Хотелось, чтобы программа следила за моим лицом, а не за всеми, кто садиться за компьютер. Для этого будет использоваться FaceNet, которая способна распознавать лица.
Также в планах разработать красивый виджет вместо некрасивой черной консоли, и чтобы при выключении компьютера запись производилась автоматически, а не с помощью прерывания.
Спасибо за внимание. Если есть вопросы, пишите в комментарии или на <https://www.linkedin.com/in/evg-voronov/> | https://habr.com/ru/post/514414/ | null | ru | null |
# Following in the Footsteps of Calculators: Qalculate
Previously we did code reviews of large mathematical packages, for example, Scilab and Octave, whereby calculators remained aloof as small utilities, in which it is difficult to make errors due to their small codebase. We were wrong that we haven't paid attention to them. The case with posting the source code of the Windows calculator showed that actually everyone was interested in discussing types of errors hiding in it. Moreover, the number of errors there was more than enough to write an article about that. My colleagues and I, we decided to explore the code of a number of popular calculators, and it turned out that the code of the Windows calculator was not that bad (spoiler).
Introduction
------------
[Qalculate!](https://qalculate.github.io/) is a multi-purpose cross-platform desktop calculator. It is simple to use but provides power and versatility normally reserved for complicated math packages, as well as useful tools for everyday needs (such as currency conversion and percent calculation). The project consists of two components: [libqalculate](https://github.com/Qalculate/libqalculate) (library and CLI) and [qalculate-gtk](https://github.com/Qalculate/qalculate-gtk) (GTK + UI). The study involved only the libqalculate code.
To easily compare the project with Windows Calculator, which we have recently checked, I'm citing the output of the Cloc utility for libqalculate:
Considering it subjectively, there are more errors in it and they are more critical than in the Windows calculator code. Nevertheless, I would recommend making conclusions on your own, having read this code overview.
By the way, here's a link to an article about the check of the calculator from Microsoft: "[Counting Bugs in Windows Calculator](https://habr.com/en/company/pvs-studio/blog/443400/)".
The analysis tool is the [PVS-Studio](https://www.viva64.com/en/pvs-studio/) static code analyzer. It is a set of solutions for code quality control, search for bugs and potential vulnerabilities. Supported languages include: C, C++, C# and Java. You can run the analyzer on Windows, Linux and macOS.
Copy-paste and Typos Again!
---------------------------
[V523](https://www.viva64.com/en/w/v523/) The 'then' statement is equivalent to the 'else' statement. Number.cc 4018
```
bool Number::square()
{
....
if(mpfr_cmpabs(i_value->internalLowerFloat(),
i_value->internalUpperFloat()) > 0) {
mpfr_sqr(f_tmp, i_value->internalLowerFloat(), MPFR_RNDU);
mpfr_sub(f_rl, f_rl, f_tmp, MPFR_RNDD);
} else {
mpfr_sqr(f_tmp, i_value->internalLowerFloat(), MPFR_RNDU);
mpfr_sub(f_rl, f_rl, f_tmp, MPFR_RNDD);
}
....
}
```
The code is absolutely the same in the *if* and *else* blocks*.* Adjacent code fragments are very similar to this one, but different functions are used in them: *internalLowerFloat()* and *internalUpperFloat()*. It is safe to assume that a developer copied the code and forgot to correct the name of the function here.
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions '!mtr2.number().isReal()' to the left and to the right of the '||' operator. BuiltinFunctions.cc 6274
```
int IntegrateFunction::calculate(....)
{
....
if(!mtr2.isNumber() || !mtr2.number().isReal() ||
!mtr.isNumber() || !mtr2.number().isReal()) b_unknown_precision = true;
....
}
```
In this case, duplicated expressions appeared due to the fact that in one place *mtr2* was written instead of *mtr.* Thus, a call of the *mtr.number().isReal()* function is absent in the condition.
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions 'vargs[1].representsNonPositive()' to the left and to the right of the '||' operator. BuiltinFunctions.cc 5785
We would have never found defects in this code manually! But here there are. Moreover, in the original file these fragments are written in a single line. The analyzer has detected a duplicated expression *vargs[1].representsNonPositive()*, which may indicate a typo or, consequently, a potential error.
Here's the entire list of suspicious places, which one can barely puzzle out.
* V501 There are identical sub-expressions 'vargs[1].representsNonPositive()' to the left and to the right of the '||' operator. BuiltinFunctions.cc 5788
* V501 There are identical sub-expressions 'append' to the left and to the right of the '&&' operator. MathStructure.cc 1780
* V501 There are identical sub-expressions 'append' to the left and to the right of the '&&' operator. MathStructure.cc 2043
* V501 There are identical sub-expressions '(\* v\_subs[v\_order[1]]).representsNegative(true)' to the left and to the right of the '&&' operator. MathStructure.cc 5569
Loop With Incorrect Condition
-----------------------------
[V534](https://www.viva64.com/en/w/v534/) It is likely that a wrong variable is being compared inside the 'for' operator. Consider reviewing 'i'. MathStructure.cc 28741
```
bool MathStructure::isolate_x_sub(....)
{
....
for(size_t i = 0; i < mvar->size(); i++) {
if((*mvar)[i].contains(x_var)) {
mvar2 = &(*mvar)[i];
if(mvar->isMultiplication()) {
for(size_t i2 = 0; i < mvar2->size(); i2++) {
if((*mvar2)[i2].contains(x_var)) {mvar2 = &(*mvar2)[i2]; break;}
}
}
break;
}
}
....
}
```
In the inner loop, the *i2* variable represents a counter, but due to a typo an error was made — the *i* variable from the outer loop is used in the loop exit condition.
Redundancy or an Error?
-----------------------
[V590](https://www.viva64.com/en/w/v590/) Consider inspecting this expression. The expression is excessive or contains a misprint. Number.cc 6564
```
bool Number::add(const Number &o, MathOperation op)
{
....
if(i1 >= COMPARISON_RESULT_UNKNOWN &&
(i2 == COMPARISON_RESULT_UNKNOWN || i2 != COMPARISON_RESULT_LESS))
return false;
....
}
```
3 years ago after I got an eyeful of such code, I wrote a cheat sheet for me and other developers: "[Logical Expressions in C/C++. Mistakes Made by Professionals](https://www.viva64.com/en/b/0390/)".When I come across such code, I make sure that the note hasn't become less relevant. You can look into the article, find a pattern of the error corresponding to the code, and find out all the nuances.
In the case of this example, we'll go to the section «Expression == || !=» and find out that the expression *i2 == COMPARISON\_RESULT\_UNKNOWN* affects nothing.
Dereferencing Unchecked Pointers
--------------------------------
[V595](https://www.viva64.com/en/w/v595/) The 'o\_data' pointer was utilized before it was verified against nullptr. Check lines: 1108, 1112. DataSet.cc 1108
```
string DataObjectArgument::subprintlong() const {
string str = _("an object from");
str += " \"";
str += o_data->title(); // <=
str += "\"";
DataPropertyIter it;
DataProperty *o = NULL;
if(o_data) { // <=
o = o_data->getFirstProperty();
}
....
}
```
In one function the *o\_data* pointer is dereferenced both without and with a check. This can be redundant code, or a potential error. I'm leaning toward the latter.
There are two similar places:
* V595 The 'o\_assumption' pointer was utilized before it was verified against nullptr. Check lines: 229, 230. Variable.cc 229
* V595 The 'i\_value' pointer was utilized before it was verified against nullptr. Check lines: 3412, 3427. Number.cc 3412
free() or delete []?
--------------------
[V611](https://www.viva64.com/en/w/v611/) The memory was allocated using 'new' operator but was released using the 'free' function. Consider inspecting operation logics behind the 'remcopy' variable. Number.cc 8123
```
string Number::print(....) const
{
....
while(!exact && precision2 > 0) {
if(try_infinite_series) {
remcopy = new mpz_t[1]; // <=
mpz_init_set(*remcopy, remainder);
}
mpz_mul_si(remainder, remainder, base);
mpz_tdiv_qr(remainder, remainder2, remainder, d);
exact = (mpz_sgn(remainder2) == 0);
if(!started) {
started = (mpz_sgn(remainder) != 0);
}
if(started) {
mpz_mul_si(num, num, base);
mpz_add(num, num, remainder);
}
if(try_infinite_series) {
if(started && first_rem_check == 0) {
remainders.push_back(remcopy);
} else {
if(started) first_rem_check--;
mpz_clear(*remcopy);
free(remcopy); // <=
}
}
....
}
....
}
```
The memory for the *remcopy* array is allocated and released in different ways, which is a serious error.
Lost Changes
------------
```
bool expand_partial_fractions(MathStructure &m, ....)
{
....
if(b_poly && !mquo.isZero()) {
MathStructure m = mquo;
if(!mrem.isZero()) {
m += mrem;
m.last() *= mtest[i];
m.childrenUpdated();
}
expand_partial_fractions(m, eo, false);
return true;
}
....
}
```
The *m* variable in the function is passed by reference, which means its modification. However, the analyzer has detected that the code contains the variable with the same name, which overlaps the scope of function's parameter, allowing for loss of changes.
Strange Pointers
----------------
[V774](https://www.viva64.com/en/w/v774/) The 'cu' pointer was used after the memory was released. Calculator.cc 3595
```
MathStructure Calculator::convertToBestUnit(....)
{
....
CompositeUnit *cu = new CompositeUnit("", "....");
cu->add(....);
Unit *u = getBestUnit(cu, false, eo.local_currency_conversion);
if(u == cu) {
delete cu; // <=
return mstruct_new;
}
delete cu; // <=
if(eo.approximation == APPROXIMATION_EXACT &&
cu->hasApproximateRelationTo(u, true)) { // <=
if(!u->isRegistered()) delete u;
return mstruct_new;
}
....
}
```
The analyzer warns that the code calls a method of the *cu* object right after deallocating memory. But when trying to grapple with it, the code turns out to be even more strange. Firstly, calling *delete cu* happens always — both in the condition and after that. Secondly, the code after the condition implies that the pointers *u* and *cu* are not equal, which means that after deleting the *cu* object it is quite logical to use the *u* object. Most likely, a typo was made in the code and the author of the code wanted to use only the *u* variable.
Usage of the find Function
--------------------------
[V797](https://www.viva64.com/en/w/v797/) The 'find' function is used as if it returned a bool type. The return value of the function should probably be compared with std::string::npos. Unit.cc 404
```
MathStructure &AliasUnit::convertFromFirstBaseUnit(....) const {
if(i_exp != 1) mexp /= i_exp;
ParseOptions po;
if(isApproximate() && suncertainty.empty() && precision() == -1) {
if(sinverse.find(DOT) || svalue.find(DOT))
po.read_precision = READ_PRECISION_WHEN_DECIMALS;
else po.read_precision = ALWAYS_READ_PRECISION;
}
....
}
```
Even though the code can be successfully compiled, it looks suspicious, as the *find* function returns the number of the type *std::string::size\_type*. The condition will be true if the point is found in any part of the string except if the point is at the beginning. It is a strange check. I'm not sure but, perhaps, this code should be rewritten as follows:
```
if( sinverse.find(DOT) != std::string::npos
|| svalue.find(DOT) != std::string::npos)
{
po.read_precision = READ_PRECISION_WHEN_DECIMALS;
}
```
Potential Memory Leak
---------------------
[V701](https://www.viva64.com/en/w/v701/) realloc() possible leak: when realloc() fails in allocating memory, original pointer 'buffer' is lost. Consider assigning realloc() to a temporary pointer. util.cc 703
```
char *utf8_strdown(const char *str, int l) {
#ifdef HAVE_ICU
....
outlength = length + 4;
buffer = (char*) realloc(buffer, outlength * sizeof(char)); // <=
....
#else
return NULL;
#endif
}
```
When working with the *realloc()* function it is recommended to use an intermediate buffer, as in case if it is impossible to allocate memory, the pointer to the old memory area will be irretrievably lost.
Conclusion
----------
The Qalculate! project tops the list of the best free calculators, whereas it contains many serious errors. On the other hand, we haven't checked out its competitors yet. We'll try to go over all popular calculators.
As for comparing with the quality of the calculator from the Windows world, the utility from Microsoft looks more reliable and well-worked so far.
Check your own «Calculator» — download [PVS-Studio](https://www.viva64.com/en/pvs-studio-download/) and try it for your project. :-) | https://habr.com/ru/post/443656/ | null | en | null |
# Правильная типизация: недооцененный аспект чистого кода
Здравствуйте, коллеги.
Не так давно наше внимание привлекла [почти готовая](https://www.manning.com/books/programming-with-types) книга издательства Manning «Programming with types», подробно рассматривающая важность правильной типизации и ее роль при написании чистого и долговечного кода.
При этом, в блоге автора мы обнаружили статью, написанную, по всей видимости, на ранних этапах работы над книгой и позволяющую составить впечатление об ее материале. Предлагаем обсудить, насколько интересны идеи автора и потенциально — вся книга
**Mars Climate Orbiter**
Космический аппарат Mars Climate Orbiter отказал при посадке и развалился в марсианской атмосфере, поскольку в программном компоненте, разработанном компанией Lockheed, давалось значение импульса, измеренное в фунт-силах-сек., тогда как другой компонент, разработанный NASA, принимал значение импульса в ньютонах-сек.
Можно представить компонент, разработанный NASA, примерно в таком виде:
```
// Не развалится при условии, что >= 2 N s
void trajectory_correction(double momentum)
{
if (momentum < 2 /* N s */)
{
disintegrate();
}
/* ... */
}
```
Также можно представить, что компонент Lockheed вызывал вышеприведенный код вот так:
```
void main()
{
trajectory_correction(1.5 /* lbf s */);
}
```
Фунт-сила-секунда (lbfs) равна примерно 4,448222 ньютонов в секунду (Ns). Таким образом, с точки зрения Lockheed, передавать 1,5 lbfs в `trajectory_correction` должно быть совершенно нормально: 1,5 lbfs равно примерно 6,672333 Ns, гораздо выше порогового значения 2 Ns.
Проблема заключается в интерпретации данных. В итоге компонент NASA сравнивает lbfs с Ns без преобразования и ошибочно интерпретирует ввод в lbfs как ввод в Ns. Поскольку 1,5 меньше 2, орбитальный аппарат развалился. Это известный антипаттерн, который называется «зацикленность на примитивах» (primitive obsession).
**Зацикленность на примитивах**
Зацикленность на примитивах проявляется, когда мы используем примитивный тип данных для представления значения в предметной области задачи и допускаем такие ситуации, как описанная выше. Если представлять почтовые коды как числа, телефонные номера как строки, Ns и lbfs как числа двойной точности, то именно такое и случается.
Гораздо безопаснее было бы определить простой тип `Ns`:
```
struct Ns
{
double value;
};
bool operator<(const Ns& a, const Ns& b)
{
return a.value < b.value;
}
```
Аналогичным образом можно определить простой тип `lbfs`:
```
struct lbfs
{
double value;
};
bool operator<(const lbfs& a, const lbfs& b)
{
return a.value < b.value;
}
```
Теперь можно реализовать типобезопасный вариант `trajectory_correction`:
```
// Не развалится, поскольку импульс >= 2 N s
void trajectory_correction(Ns momentum)
{
if (momentum < Ns{ 2 })
{
disintegrate();
}
/* ... */
}
```
Если вызвать это с `lbfs`, как в вышеприведенном примере, то код просто не скомпилируется из-за несовместимости типов:
```
void main()
{
trajectory_correction(lbfs{ 1.5 });
}
```
Обратите внимание, как информация о типах значений, которая обычно указывается в комментариях, (`2 /*Ns */, /* lbfs */`) теперь втягивается в систему типов и выражается в коде: (`Ns{ 2 }, lbfs{ 1.5 }`).
Разумеется, можно предусмотреть приведение `lbfs` к `Ns` в виде явного оператора:
```
struct lbfs
{
double value;
explicit operator Ns()
{
return value * 4.448222;
}
};
```
Вооружившись таким приемом, можно вызвать `trajectory_correction` при помощи статического приведения:
```
void main()
{
trajectory_correction(static_cast(lbfs{ 1.5 }));
}
```
Здесь правильность кода достигается путем умножения на коэффициент. Приведение также можно выполнить неявно (воспользовавшись ключевым словом `implicit`), и в этом случае приведение будет применяться автоматически. В качестве эмпирического правила здесь можно пользоваться одним из коанов Python:
> Явное лучше неявного
Мораль этой истории такова, что, хотя сегодня у нас и есть очень умные механизмы проверки типов, им все равно требуется предоставлять достаточно информации, чтобы отлавливать ошибки такого типа. Эта информация попадает в программу, если мы объявляем типы с учетом специфики нашей предметной области.
**Пространство состояний**
Беды случаются, когда программа завершает работу в *плохом состоянии*. Типы помогают сузить поле для их возникновения. Попробуем трактовать тип как множество возможных значений. Например, bool это множество `{true, false}`, где переменная данного типа может принимать одно из двух этих значений. Аналогично, `uint32_t` это множество `{0 ...4294967295}`. Рассматривая типы таким образом, можно определить пространство состояний нашей программы как произведение типов всех живых переменных в определенный момент времени.
Если у нас есть переменная типа `bool` и переменная типа `uint32_t`, то наше пространство состояний будет равно `{true, false} X {0 ...4294967295}`. Это всего лишь означает, что обе переменные могут находиться в любых возможных для них состояниях, а, поскольку переменных у нас две, программа может оказаться в любом комбинированном состоянии двух этих типов.
Все становится гораздо интереснее, если рассмотреть функции, инициализирующие значения:
```
bool get_momentum(Ns& momentum)
{
if (!some_condition()) return false;
momentum = Ns{ 3 };
return true;
}
```
В вышеприведенном примере мы берем Ns по ссылке и инициализируем, если выполняется некоторое условие. Функция возвращает `true`, если значение было правильно инициализировано. Если функция по какой-либо причине не может задать значение, то она возвращает `false`.
Рассматривая данную ситуацию с точки зрения пространства состояний, можно сказать, что пространство состояний – это произведение `bool X Ns`. Если функция возвращает true, это означает, что импульс был задан, и является одним из возможных значений `Ns`. Проблема вот в чем: если функция возвращает `false`, это означает, что импульс не был задан. Импульс так или иначе принадлежит ко множеству возможных значений Ns, но не является валидным значением. Часто случаются баги, при которых случайно начинает распространяться следующее недопустимое состояние:
```
void example()
{
Ns momenum;
get_momentum(momentum);
trajectory_correction(momentum);
}
```
Вместо этого мы попросту должны делать так:
```
void example()
{
Ns momentum;
if (get_momentum(momentum))
{
trajectory_correction(momentum);
}
}
```
Однако, есть и лучший способ, при котором это можно делать принудительно:
```
std::optional get\_momentum()
{
if (!some\_condition()) return std::nullopt;
return std::make\_optional(Ns{ 3 });
}
```
Если использовать `optional`, то пространство состояний у этой функции значительно уменьшится: вместо `bool X Ns` получим `Ns + 1`. Эта функция вернет либо валидное значение `Ns`, либо `nullopt`, чтобы обозначить отсутствие значения. Теперь у нас просто не может появиться недопустимого `Ns`, которое стало бы распространяться в системе. Также теперь становится невозможным забыть проверить возвращаемое значение, поскольку optional не может быть неявно преобразовано в `Ns` – нам понадобится специально распаковать его:
```
void example()
{
auto maybeMomentum = get_momentum();
if (maybeMomentum)
{
trajectory_correction(*maybeMomentum);
}
}
```
В принципе, мы стремимся, чтобы наши функции возвращали результат или ошибку, а не результат и ошибку. Таким образом мы исключим состояния, в которых у нас возникают ошибки, а также перестрахуемся от недопустимых результатов, которые затем могли бы просочиться в дальнейшие вычисления.
С такой точки зрения выбрасывание исключений – это нормально, так как соответствует вышеописанному принципу: функция или вернет результат, или выбросит исключение.
**RAII**
RAII означает Resource Acquisition Is Initialization («Получение ресурса есть инициализация»), но в большей степени этот принцип связан с высвобождением ресурсов. Название впервые возникло в C++, однако, этот паттерн может быть реализован на любом языке (см., например, `IDisposable` из .NET). RAII обеспечивает автоматическую очистку ресурсов.
Что такое ресурсы? Вот несколько примеров: динамическая память, соединения с базой данных, описатели ОС. В принципе, ресурс – нечто, забираемое из внешнего мира и подлежащее возвращению после того, как он нам станет не нужен. Мы возвращаем ресурс при помощи соответствующей операции: высвобождаем его, удаляем, закрываем, т.д.
Поскольку эти ресурсы являются внешними, они не выражены явно в нашей системе типов. Например, если мы выделим фрагмент динамической памяти, то получим указатель, по которому должны будем вызвать `delete`:
```
struct Foo {};
void example()
{
Foo* foo = new Foo();
/* Используем foo */
delete foo;
}
```
Но что случится, если мы забудем это сделать, или что-то помешает нам вызвать `delete`?
```
void example()
{
Foo* foo = new Foo();
throw std::exception();
delete foo;
}
```
В данном случае мы больше не вызываем `delete` и получаем утечку ресурса. В принципе, такая очистка ресурсов вручную является нежелательной. Для динамической памяти у нас есть `unique_ptr`, помогающий нам ею управлять:
```
void example()
{
auto foo = std::make_unique();
throw std::exception();
}
```
Наш `unique_ptr` – это объект стека, поэтому, стоит ему выйти из области видимости (когда функция выбросит исключение или при раскрутке стека, когда было выброшено исключение), вызывается его деструктор. Именно этот деструктор реализует вызов `delete`. Соответственно, нам больше не приходится управлять ресурсом-памятью – мы передаем эту работу обертке, которая ею владеет и отвечает за ее высвобождение.
Подобные обертки существуют (или их можно создать) для любых других ресурсов (например, OS HANDLE из Windows можно обернуть в тип, и в таком случае его деструктор будет вызывать `CloseHandle`).
Основной вывод в данном случае – никогда не заниматься очисткой ресурсов вручную; либо используем имеющуюся обертку, либо, если подходящей обертки для вашего конкретного сценария не существует – реализуем ее сами.
**Заключение**
Мы начали эту статью с известного примера, демонстрирующего важность типизации, а затем рассмотрели три важных аспекта использования типов, помогающих писать более безопасный код:
* Объявление и использование более сильных типов (в противовес зацикленности на примитивах).
* Сокращение пространства состояний, возврат результата или ошибки, а не результата или ошибки.
* RAII и автоматическое управление ресурсами.
Итак, типы отлично помогают сделать код безопаснее и приспособить его для переиспользования. | https://habr.com/ru/post/460149/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.