text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как мы в X-Ray х64 завозили
Предисловие
===========
Доброго времени суток, речь пойдёт о игровом движке X-Ray, а точнее о его форке [X-Ray Oxygen](https://github.com/xrOxygen/xray-oxygen) В декабре 2016 года был опубликован проект X-Ray Oxygen. Тогда я разрабатывал его один и не мечтал о том, чем он стал на данный момент.
В марте мне пришла в голову идея: "А почему бы не перенести это всё на x64?". Как вы поняли, именно об этой идее, а точнее её реализации, пойдёт речь.
Сборка проекта
==============
Первым шагом был перенос кода, чтоб собрать всё это дело под x64 платформу. После настройки проектов я столкнулся с первой проблемой… Нет, не Ptr функции, а ассемблерные вставки...
```
__forceinline void fsincos( const float angle , float &sine , float &cosine )
{ __asm {
fld DWORD PTR [angle]
fsincos
mov eax , DWORD PTR [cosine]
fstp DWORD PTR [eax]
mov eax , DWORD PTR [sine]
fstp DWORD PTR [eax]
} }
```
Прелесть такого кода заключалась в оптимизации, но MSBuilder в x64 его не поддерживал и не поддерживает до сих пор. Большую часть такого кода можно было заменить на std аналоги, были места, которые можно было с лёгкостью поменять на [Intrinsics'ы](https://software.intel.com/sites/landingpage/IntrinsicsGuide/), к примеру, как:
```
__asm pause;
```
Можно было смело заменить на:
```
_mm_pause();
```
Так же в движке иногда встречались аналоги функций на нативном коде (Хвала системе CPUID). Но бывали места, от которых приходилось просто избавляться. К примеру [MMX инструкции](https://ru.wikipedia.org/wiki/MMX) канули в лету. К счастью, они нигде и не вызывались, а просто компилировались и и валялись без дела.
Работоспособность
=================
После всех правок по сборке наступил следующий этап: Как всё это запустить?
Первым предателем стал [LuaJIT](http://luajit.org). К несчастью, LuaJIT стал нормально (ну, почти...) работать в x64 только с версии 2.0.5. И то были небольшие проблемы с аллокацией памяти из малых разрядов. Но, тогда я не знал об этом и первым делом выпилил LuaJIT и накатил ванильный Lua 5.1. Да, это исправило проблему, но скорость… Помним, скорбим. Позже мне на форуме сообщили, что можно попробовать использовать LuaJIT 2.0.4. И да, это помогло, я запустил игру и смог выйти в главное меню!
Но… Счастье было недолгим… Привет смещениям структур, типам данных и xrCDB. Игра не загружала уровень, полетели материалы на объектах и движку это сильно не нравилось. Спустя пару дней я отчаялся окончательно и решил попросить помощи у более опытного программиста под ником Giperion. Я не рассчитывал на его участие в проекте, моей мечтой был просто совет. Но, таким образом, я получил опытного разработчика в проект. С этого момента сформировалась команда.
Следующей проблемой стал [OPCODE](http://www.codercorner.com/Opcode.htm) и типы данных. Пришлось переводить все udword'ы (unsigned int) на uqword'ы (unsigned long long). Только для того, чтобы понять это, пришлось провести под отладчиком около 4 часов.
Но, это было лишь частью проблемы. Настала очередь материалов. Что мы имеем:
```
union
{
u32 dummy; // 4b
struct
{
u32 material : 14; //
u32 suppress_shadows : 1; //
u32 suppress_wm : 1; //
u32 sector : 16; //
};
};
```
Такой код в x32 спасала волшебная `#pragma pack(4)`, но в x64 почему-то это не спасло. Пришла очередь выравнивания, путём деббага мы выяснили, что для некоторых случаев данные в структуре были валидны, а для других нет. Переделали структуру и сделали конвертер-валидатор. Структура получила следующий вид:
```
union
{
size_t dummy;
struct
{
size_t material:14; //
size_t suppress_shadows:1; //
size_t suppress_wm:1; //
size_t sector:16; //
size_t dumb : 32; // Да, это волшебный дамб в x64.
};
```
А валидатор был таким:
```
...
if (rebuildTrisRequired)
{
TRI_DEPRECATED* realT = reinterpret_cast (T);
for (int triIter = 0; triIter < tris\_count; ++triIter)
{
TRI\_DEPRECATED& oldTri = realT[triIter];
TRI& newTri = tris[triIter];
newTri = oldTri;
}
}
else
{
std::memcpy(tris, T, tris\_count \* sizeof(TRI));
}
...
```
Таким образом, пришлось поменять часть вызовов из-за флага rebuildTrisRequired, но игра смогла запуститься.
Но, со временем настала проблема с партиклами:
```
real_ptr = malloc( sizeof( Particle ) * ( max_particles + 1 ) );
particles = (Particle*)((DWORD)real_ptr + (64 - ((DWORD)real_ptr & 63)));
```
Этот код не вызывал проблем с оригинальными партиклами. Они были слишком простыми и спокойно вмещались в выделяемую для них память. Но с более сложными и красочными партиклами, которые делали модмейкерами, пришли вылеты по памяти. x64 и вылеты по памяти, как так-то?! Код был переделан, вылеты ушли:
```
particles = alloc(max\_particles);
```
Игровые проблемы
================
Первой проблемой стал, опять, LuaJIT
Полетела userdata для smart cover'ов. Эта проблема была исправлена почти самой последней. Просто переносом правок из релизнувшегося LuaJIT 2.0.5.
Следующая проблема: Физика и вычисление float'ов. `control87` и `_controlfp` для вычисления `infinity` в x64 были заблокированы… Была огромная проблема с дропом предметов, один раз к трём они падали правильно. Иногда улетали в космос, иногда под террейн. Проблема крылась всего в одной переменной, которой давалось значение infinity. Ситуацию исправил FLT\_MAX, одинаковый для всех платформ.
```
surface.mu = dInfinty // x32
surface.mu = FLT_MAX // x64
```
Последней проблемой стала скорость партиклов. Обратим внимание на следующий код:
```
DWORD angle = 0xFFFFFFFF;
...
if (angle != *((DWORD*)&m.rot.x))
{
angle = *((DWORD*)&m.rot.x);
fsincos(angle, sina, cosa);
}
```
Вроде бы всё в порядке. Но, 0xFFFFFFFF в x64 имеет другое значение, при конвертации в тип с плавающей запятой. Дело в том, что fsincos имеет Double аналог, а x64 предпочитает double данные. И это значение в double имеет значение намного больше. Ситуацию спасло преобразование в float.
```
DWORD angle = 0xFFFFFFFF;
...
if (angle != *((DWORD*)&m.rot.x))
{
angle = *((DWORD*)&m.rot.x);
// fsincos(angle, sina, cosa);
fsincos(*(float*)∠, sina, cosa);
}
```
Заключение
==========
В заключение я хочу сказать всего лишь одно: порт в x64 принёс много новых знаний, которые пригодятся в дальнейшем. Я рассказал вам о многих проблемах при портировании. А дальше всё будет зависить от вас, если вы решите проделать это в каких-либо OpenSource проектах.
Спасибо за прочтение! | https://habr.com/ru/post/421823/ | null | ru | null |
# Борьба с несбалансированностью классов с помощью модуля NEARMISS
В этой статье я расскажу об одном из методов для устранения дисбаланса предсказываемых классов. Важно уточнить, что многие методы, которые строят вероятностные модели, прекрасно работают и без устранения несбалансированности. Однако, когда мы переходим к построению невероятностных моделей или когда рассматриваем задачу классификации с большим количеством классов, стоит озаботиться решением проблемы дисбаланса классов.
Если не бороться с этой проблемой, то модель будет перегружена бо́льшим классом, в следствии будет игнорировать меньший класс, неправильно классифицировать его, поскольку модели будет не хватать примеров и свойств редкого класса. Таким образом, несбалансированность классов напрямую влияет на точность и качество результатов машинного обучения.
Метод **NearMiss**— это метод недостаточной выборки. Он пробует сбалансировать распределение классов путём случайного исключения наблюдений из бо́льших классов. Если экземпляры из двух разных классов очень похожи между собой, метод удаляет наблюдение из мажоритарного класса.
Давайте рассмотрим работу этого метода на практике. Для начала установим необходимые нам библиотеки через стандартный pip в cmd:
```
pip install pandas
pip install numpy
pip install sklearn
pip install imblearn
```
Я буду использовать набор данных о сессиях, связанных с поведением пользователей на веб-страницах онлайн-магазина.
```
import pandas as pd
import numpy as np
df = pd.read_csv('online_shoppers_intention.csv')
df.shape
```
(12330, 18)
Столбец для прогнозирования называется «Revenue» и может принимать 2 значения: True (пользователь совершил покупку) и False (пользователь не совершил покупку). Посмотрим, какое количество наблюдений приходится на каждый из классов.
```
df['Revenue'].value_counts()
```
Как видно, классы являются несбалансированными, поскольку делятся примерно в соотношении 85% и 15%.
Разделим наблюдения на обучающую и тестовую выборки:
```
Y = df['Revenue']
X = df.drop('Revenue', axis = 1)
feature_names = X.columns
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.3, random_state = 97)
```
Посмотрим на размерность сформированных наборов данных:
```
print('Размерность набора данных X_train: ', X_train.shape)
print('Размерность набора данных Y_train: ', Y_train.shape)
print('Размерность набора данных X_test: ', X_test.shape)
print('Размерность набора данных Y_test: ', Y_test.shape)
```
Далее воспользуемся логистической регрессией и выведем отчёт с основными показателями классификации.
```
from sklearn.linear_model import LogisticRegression
lregress1 = LogisticRegression()
lregress1.fit(X_train, Y_train.ravel())
prediction = lregress1.predict(X_test)
print(classification_report(Y_test, prediction))
```
Отметим, что точность модели 88%. Колонка «recall» показывает меру полноты классификатора, способность классификатора правильно находить все положительные экземпляры. Из неё видно, что отзыв миноритарного класса гораздо меньше, то есть модель более склонна к классу большинства.
Перед применением метода NearMiss выведем количество наблюдений каждого класса:
```
print('Перед применением метода кол-во меток со значением True: {}'.format(sum(y_train == True)))
print('Перед применением метода кол-во меток со значением False: {}'.format(sum(y_train == False)))
```
Перед применением метода количество меток со значением True: 1334
Перед применением метода количество меток со значением False: 7297
Теперь воспользуемся методом и выведем количество наблюдений каждого класса.
```
from imblearn.under_sampling import NearMiss
nm = NearMiss()
X_train_miss, Y_train_miss = nm.fit_resample(X_train, Y_train.ravel())
print('После применения метода кол-во меток со значением True: {}'.format(sum(Y_train_miss == True)))
print('После применения метода кол-во меток со значением False: {}'.format(sum(Y_train_miss == False)))
```
После применения метода количество меток со значением True: 1334
После применения метода количество меток со значением False: 1334
Видно, что метод сравнял классы, уменьшив размерность доминирующего класса. Воспользуемся логистической регрессией и выведем отчёт с основными показателями классификации.
```
lregress2 = LogisticRegression()
lregress2.fit(X_train_miss, Y_train_miss.ravel())
prediction = lregress2.predict(X_test)
print(classification_report(Y_test, prediction))
```
Значение отзывов меньшинства повысилось до 84%. Но из-за того, что выборка большего класса значительно уменьшилась, понизилась точность модели до 61%. Таким образом, этот метод действительно помог справиться с несбалансированностью классов. | https://habr.com/ru/post/562322/ | null | ru | null |
# Погружение в разработку на Ethereum. Часть 4: деплой и дебаг в truffle, ganache, infura
В [прошлой статье](https://habrahabr.ru/post/339080/) мы рассмотрели разработанное приложение на Ethereum. Но обошли стороной вопрос как происходит процесс разработки. Ясно, что это не просто написание кода, который сразу работает. Большую часть времени придется потратить на то, чтобы доводить код, который “почти готов”, до рабочего состояния. Деплой, тестирование, отладка — все это в той или иной мере уже затрагивалось здесь например в этих неплохих статьях: [раз](https://habrahabr.ru/post/342534/), [два](https://habrahabr.ru/post/335710/), [три](https://habrahabr.ru/post/327236/) (список не полный). В этой статье мы дадим небольшой обзор и возможно в чем-то повторимся, но постараемся сфокусироваться на тех моментах, которые нам показались важными или недосказанными. Плюс за последнее время некоторые штуки изменились, и огромное количество инструкций оказалось устаревшим. Постараемся немного подправить ситуацию.
Проект в truffle
----------------
Для тестирования и деплоя смарт контрактов мы пользуемся [Truffle](http://truffleframework.com/), он скрывает часть низкоуровневой работы за абстракциями, что очень удобно. Описанная версия — 4.0.6. Это не единственный фреймворк, есть еще [Embark](https://embark.readthedocs.io/) и [Dapple](https://dapple.readthedocs.io/en/master/), но по ним ничего сказать не можем, не приходилось работать. Для инициализации проекта надо выполнить команду (выполнится в текущей папке, поэтому предварительно создайте папку проекта и перейдите в нее):
```
$ truffle init
```
Создается только базовая структура из папок `contracts`, `migrations` и `tests`. В `contracts` и `migrations` вы можете увидеть смарт контракт `Migrations`, который отвечает за логику деплоя (в терминах трюфеля — миграции). А логика примерно такая: в папке `migrations` вы складываете скрипты и называете их по шаблону `1_description.js`, `2_another_one.js` … `n_etc.js`. Самое важное в названии — это индекс, который идет в начале, после этого можно добавлять любое описание, которое нужно только для читабельности. Индекс же используется для выполнения миграций в порядке нумерации. Смарт контракт `Migrations` используется для того, чтобы сохранять какие из скриптов миграций уже выполнились. Так что если в процессе разработки добавлять новые контракты и новую логику деплоя, то предыдущий успешный прогресс передеплоивать не надо. Лично мы этим не пользуемся, вместо этого имеем фиксированное количество миграций, редактируем и запускаем их каждый раз заново с помощью `truffle migration --reset`.
Вы можете вручную создавать файлы контрактов, миграций и тестов, но в truffle есть и специальные команды:
```
$ truffle create contract ExampleContract
$ truffle create migration ExampleMigration
$ truffle create test ExampleContract
```
Можете проверить, что у вас создались соответствующие файлы. Но содержимое совсем базовое, поэтому пока в этой фиче нет особого преимущества по сравнению с созданием тех же файлов вручную.
Работа с проектом
-----------------
В более ранних версиях инициализация `truffle init` создавала сразу небольшой пример (Metacoin и ConvertLib). Чтобы в последних версиях увидеть этот и другие примеры, можно воспользоваться фичей, называемой Truffle Boxes. Боксы созданы для того, чтобы получить полноценный пример проекта Truffle и его взаимодействия с разными web-средствами, например ReactJS. [Здесь](http://truffleframework.com/boxes/) перечислен список боксов, как официальных, так и созданных сообществом. Создайте директорию для нового проекта и перейдите в нее. Затем выполним команду:
```
$ truffle unbox metacoin
```
получите ту структуру проекта, которая в старых версиях создавалась по умолчанию после `truffle init`. Это пример с базовым токеном Metacoin, который можно пересылать от пользователя к пользователю и с помощью библиотеки ConvertLib смотреть баланс в эфире при фиксированном курсе обмена. Кроме того, что тут показано как создавать и использовать смарт контракт и библиотеку, здесь есть еще и пример тестов на JavaScript и Solidity (подробнее о написании тестов можете почитать [здесь](https://habrahabr.ru/post/321362/), обратите внимание, что там как раз рассматривается более старая версия Truffle). Давайте бегло рассмотрим как можно в тестовом режиме собрать и проверить этот проект. Для начала запустим development консоль:
```
$ truffle develop
```
Увидите подобный текст:
```
Truffle Develop started at http://localhost:9545/
Accounts:
(0) 0x627306090abab3a6e1400e9345bc60c78a8bef57
(1) 0xf17f52151ebef6c7334fad080c5704d77216b732
(2) 0xc5fdf4076b8f3a5357c5e395ab970b5b54098fef
(3) 0x821aea9a577a9b44299b9c15c88cf3087f3b5544
(4) 0x0d1d4e623d10f9fba5db95830f7d3839406c6af2
(5) 0x2932b7a2355d6fecc4b5c0b6bd44cc31df247a2e
(6) 0x2191ef87e392377ec08e7c08eb105ef5448eced5
(7) 0x0f4f2ac550a1b4e2280d04c21cea7ebd822934b5
(8) 0x6330a553fc93768f612722bb8c2ec78ac90b3bbc
(9) 0x5aeda56215b167893e80b4fe645ba6d5bab767de
Mnemonic: candy maple cake sugar pudding cream honey rich smooth crumble sweet treat
truffle(develop)>
```
Что делает эта команда? Она поднимает тестовое окружение и дает доступ к нему через консоль. Тестовое окружение — это то, что вы могли видеть в более старых руководствах под названием TestRPC. На самом деле это оно и есть, просто команда Truffle взяла его под свое управление и переименовала в [Ganache](http://truffleframework.com/ganache/). Но об этом напишем далее, а пока перейдем к консоли. Выполним полный цикл команд для компиляции, миграции и тестирования:
```
truffle(develop)> compile
```
**Результат**
```
Compiling ./contracts/ConvertLib.sol...
Compiling ./contracts/MetaCoin.sol...
Compiling ./contracts/Migrations.sol...
Writing artifacts to ./build/contracts
```
```
truffle(develop)> migrate
```
**Результат**
```
Using network 'develop'.
Running migration: 1_initial_migration.js
Deploying Migrations...
... 0x29619f8ba9b9e001bef885c8ca2fbee45beab738adc41c7f9e2e8273fbc67e9f
Migrations: 0x8cdaf0cd259887258bc13a92c0a6da92698644c0
Saving successful migration to network...
... 0xd7bc86d31bee32fa3988f1c1eabce403a1b5d570340a3a9cdba53a472ee8c956
Saving artifacts...
Running migration: 2_deploy_contracts.js
Deploying ConvertLib...
... 0x02318651545ac96670af626ef7795cb928d7504afc3f856258058ce579d47fe6
ConvertLib: 0x345ca3e014aaf5dca488057592ee47305d9b3e10
Linking ConvertLib to MetaCoin
Deploying MetaCoin...
... 0x486c572bbb2df30bb166f5507423d394807b5b92041860968a7d5eb162e42e48
MetaCoin: 0xf25186b5081ff5ce73482ad761db0eb0d25abfbf
Saving successful migration to network...
... 0x059cf1bbc372b9348ce487de910358801bbbd1c89182853439bec0afaee6c7db
Saving artifacts...
```
```
truffle(develop)> test
```
**Результат**
```
Using network 'develop'.
Compiling ./contracts/ConvertLib.sol...
Compiling ./contracts/MetaCoin.sol...
Compiling ./test/TestMetacoin.sol...
Compiling truffle/Assert.sol...
Compiling truffle/DeployedAddresses.sol...
TestMetacoin
✓ testInitialBalanceUsingDeployedContract (62ms)
✓ testInitialBalanceWithNewMetaCoin (47ms)
Contract: MetaCoin
✓ should put 10000 MetaCoin in the first account
✓ should call a function that depends on a linked library (54ms)
✓ should send coin correctly (117ms)
5 passing (796ms)
```
Можно повызывать методы задеплоенных контрактов вручную, например так:
```
truffle(develop)> var metaCoin
truffle(develop)> MetaCoin.deployed().then( function(instance) { metaCoin = instance } );
truffle(develop)> metaCoin.getBalance(web3.eth.coinbase)
BigNumber { s: 1, e: 4, c: [ 10000 ] }
truffle(develop)> _.toNumber()
10000
truffle(develop)> metaCoin.sendCoin( web3.eth.accounts[2], 3000 )
{ tx: '0x9f59085a9f22c0bd691b890370bcffd7eedce1327a3bb525a2de3edf9db0d279',
receipt:
{ transactionHash: '0x9f59085a9f22c0bd691b890370bcffd7eedce1327a3bb525a2de3edf9db0d279',
transactionIndex: 0,
blockHash: '0x24e8913b6f707bb5e5acbaa054fef9dabd548a561dc988763209f0aeed9a57b5',
blockNumber: 12,
gasUsed: 51024,
cumulativeGasUsed: 51024,
contractAddress: null,
logs: [ [Object] ] },
logs:
[ { logIndex: 0,
transactionIndex: 0,
transactionHash: '0x9f59085a9f22c0bd691b890370bcffd7eedce1327a3bb525a2de3edf9db0d279',
blockHash: '0x24e8913b6f707bb5e5acbaa054fef9dabd548a561dc988763209f0aeed9a57b5',
blockNumber: 12,
address: '0xf25186b5081ff5ce73482ad761db0eb0d25abfbf',
type: 'mined',
event: 'Transfer',
args: [Object] } ] }
truffle(develop)> metaCoin.getBalance(web3.eth.coinbase)
BigNumber { s: 1, e: 3, c: [ 7000 ] }
truffle(develop)> _.toNumber()
7000
```
Как видите все выполняется мгновенно и можно отследить изменения: отправили 3000 с основного адреса на другой, видим, что баланс уменьшился. Выходить из консоли командой:
```
truffle(develop)> .exit
```
Подключение к ноде
------------------
Truffle development это режим с собственной тестовой нодой. Для подключения к реальной сети или тестнету используется команда `truffle console`, которая полностью аналогична `develop`, но не поднимает тестовое окружение. Чтобы продемонстрировать это, не обязательно запускать `geth`, можно воспользоваться например уже упомянутой [Ganache](https://github.com/trufflesuite/ganache-cli), заменившей собой TestRPC. Запустим командой:
```
$ ganache-cli
```
Есть еще и [GUI версия](http://truffleframework.com/ganache/). Принципиального отличия нет, но в этой версии можно сразу видеть всю информацию, события и балансы. Может быть очень удобно в некоторых ситуациях. Можете использовать любую из этих версий
Но если вы просто сделали `truffle unbox metacoin` и еще никак не меняли конфигурационные файлы, то подключиться не получится
```
$ truffle console
No network available. Use `truffle develop` or add network to truffle.js config.
```
Поэтому добавим в `truffle.js` следующее:
```
module.exports = {
networks: {
development: {
host: "localhost",
port: 8545,
network_id: "*"
}
}
};
```
Вы можете увидеть еще и `truffle-config.js`. Это то же самое, но для Windows. Лишний для вашей системы файл можно удалить.
Этот конфиг даст возможность трюфелю подключаться к любой сети, доступной на localhost:8545. Это значения по умолчанию для geth и ganache-cli. Если вы используете GUI-версию Ganache, зайдите в настройки и при необходимости измените порт и перезапустите (кнопка “save and restart”).
Если застряли на окне с логотипом, то скорее всего у вас на этом же порту уже что-то запущено, geth, ganache-cli/testrpc или что-то еще
Теперь можно подключиться, выполняем команду:
```
$ truffle console
```
И можно попробовать например сделать:
```
truffle(development)> migrate --reset
```
В GUI-версии вы сразу сможете увидеть изменение баланса аккаунта, с которого прошел деплой, если зайдете во вкладку blocks — то увидите смайненные блоки и сколько газа расходовалось на транзакции в них. Щелкнув по каждому из них можно получить еще более подробную информацию. Вкладка transactions таким же образом покажет вам все прошедшие транзакции.
**Много скриншотов**
В консольной версии будет та же информация, но в виде стены логов:
**Развернуть**
```
net_version
eth_accounts
eth_accounts
net_version
net_version
eth_sendTransaction
Transaction: 0x29619f8ba9b9e001bef885c8ca2fbee45beab738adc41c7f9e2e8273fbc67e9f
Contract created: 0x922194d35a507e5905fa4f2c9e7172ee8535272a
Gas usage: 269607
Block Number: 1
Block Time: Mon Feb 05 2018 10:28:17 GMT+0300 (MSK)
eth_newBlockFilter
eth_getFilterChanges
eth_getTransactionReceipt
eth_getCode
eth_uninstallFilter
eth_sendTransaction
Transaction: 0xfafc4352cc1dde57e46954d7ebd3a59232599081a253dd8705847a380ae5b06b
Gas usage: 41981
Block Number: 2
Block Time: Mon Feb 05 2018 10:28:17 GMT+0300 (MSK)
eth_getTransactionReceipt
eth_accounts
net_version
net_version
eth_sendTransaction
```
Используйте что считаете удобнее.
Кстати если вы читали другие инструкции по этой же теме, то наверное уже знаете, что не обязательно вызывать консоль, чтобы компилировать и деплоить, можно просто вызвать например
```
truffle migrate --reset
```
И это будет полным аналогом того, что мы сделали выше. Такой же принцип и для всех других команд трюфеля. Полный список команд [здесь](http://truffleframework.com/docs/advanced/commands).
Пакеты
------
Ни в каком языке вы не обойдетесь лишь core-функциональностью. Изобретать велосипеды непродуктивно и опасно, а со смарт контрактами, где вы рискуете чужими деньгами, это особенно критично. Поэтому возникает вопрос где взять эту уже проверенную дополнительную функциональность. В Truffle для этого есть система пакетов, которые доступны в двух вариантах установки (не считая обычного копипаста): с помощью npm и с помощью ethpm.
До этого на примере Metacoin мы видели простейший токен. Токены используются довольно часто, даже Crypto Kitties — это по сути токены, хоть и оригинального стандарта. Основной стандарт токенов сейчас — это [ERC20](https://theethereum.wiki/w/index.php/ERC20_Token_Standard). Чтобы соответствовать стандарту токен должен реализовывать набор функций, которые могут обеспечивать универсальное и безопасное использование в кошельках, биржах и т.д. Тут очень полезен оказывается пакет [zeppelin-solidity от OpenZeppelin](https://github.com/OpenZeppelin/zeppelin-solidity) — набор библиотек для часто используемых паттернов в смарт контрактах. В [этой статье](https://habrahabr.ru/post/335710/) например уже было описано использование этого пакета. Рассмотрим не использование, а способы установки и подключения. Для начала тот, который описан в инструкции на гитхабе проекта. В корне проекта truffle выполните:
```
$ npm init -y
$ npm install -E zeppelin-solidity
```
После чего в папке `node_modules` у вас появится `zeppelin-solidity`, из которого в смарт контракте можно подключать требуемые файлы, например ownable, строчкой
```
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
```
Но существует еще один способ установки пакетов, который разработан специально для пакетов в Ethereum: EthPM. Пакеты хранятся на IPFS. Список пакетов доступен по [ссылке](https://www.ethpm.com/registry/packages). Он интегрирован в трюфель и чтобы установить тот же самый zeppelin-solidity можно выполнить:
```
$ truffle install zeppelin
```
Добавится папка `installed_contracts`, подключать ее содержимое так же, как и из папки `node_modules`:
```
import ‘zeppelin/contracts/ownership/Ownable.sol’;
```
Но если вы сравните версии, которые установлены тем и другим способом, то обнаружите, что они разные. И по крайней в данный момент версия npm новее (на момент написания 1.6.0 против 1.3.0 в EthPm). Так что хоть идеологически EthPM и интереснее, но пока наверное лучше устанавливать пакеты с помощью npm
Отладка
-------
Обычно когда при выполнении смарт контракта происходит ошибка, сообщения оказываются очень неинформативными. Для примера сделаем контракт с намеренной ошибкой:
```
$ mkdir FaultyContract && cd FaultyContract
$ truffle init
$ truffle create contract FaultyContract
$ truffle create migration deploy
```
В файле contracts/FaultyContract.sol добавьте недостающий код:
```
pragma solidity ^0.4.4;
contract FaultyContract {
int public result;
function divideXbyY( int x, int y ) public {
y -= y;
result = x/y;
}
}
```
Как видите здесь неизбежно деление на 0.
В файле `migration/xxxx_deploy.js` (xxxx — сгенерированный id, может быть разный) добавьте недостающий код для деплоя:
```
var FaultyContract = artifacts.require("./FaultyContract.sol");
module.exports = function( deployer ) {
deployer.deploy( FaultyContract );
}
```
Откроем develop консоль, скомплируем и задеплоем наш контракт
```
$ truffle develop
truffle(develop)> migrate
```
Получим контракт и вызовем проблемную функцию:
```
truffle(develop)> var faultyContract;
truffle(develop)> FaultyContract.deployed().then( function(instance) { faultyContract = instance } );
truffle(develop)> faultyContract.divideXbyY(16, 4);
Error: VM Exception while processing transaction: invalid opcode
at Object.InvalidResponse (/usr/lib/node_modules/truffle/build/cli.bundled.js:43303:16)
at /usr/lib/node_modules/truffle/build/cli.bundled.js:331156:36
at /usr/lib/node_modules/truffle/build/cli.bundled.js:314196:9
at XMLHttpRequest.request.onreadystatechange (/usr/lib/node_modules/truffle/build/cli.bundled.js:329855:7)
at XMLHttpRequestEventTarget.dispatchEvent (/usr/lib/node_modules/truffle/build/cli.bundled.js:70159:18)
at XMLHttpRequest._setReadyState (/usr/lib/node_modules/truffle/build/cli.bundled.js:70449:12)
at XMLHttpRequest._onHttpResponseEnd (/usr/lib/node_modules/truffle/build/cli.bundled.js:70604:12)
```
Как видите не, очень информативно, неизвестно в каком месте ошибка и что значит `invalid opcode`. В Truffle с версии 4 доступна команда `debug` (пока бета), позволяющая заново перевыполнить транзакцию построчно. Но для этого нужно получить хеш транзакции, а в ошибке даже его нет. Чтобы увидеть хеш, запустите еще один экземпляр `truffle develop` с флагом `--log`:
```
$ truffle develop --log
```
Эта команда позволяет видеть логи того, что происходит в основной develop-консоли, и в том числе там можно найти хеш транзакций. Запустим функцию еще раз
```
truffle(develop)> faultyContract.divideXbyY(16, 4);
```
В окне с логом будет что-то похожее на
```
develop:testrpc eth_sendTransaction +0ms
develop:testrpc +27ms
develop:testrpc Transaction: 0x21073e12e7c8fb785347d7bd5d974d4954379dcace7b53d452c03b39ca007b9e +1ms
develop:testrpc Gas usage: 6721975 +0ms
develop:testrpc Block Number: 6 +0ms
develop:testrpc Block Time: Tue Feb 06 2018 10:32:27 GMT+0300 (MSK) +0ms
develop:testrpc Runtime Error: invalid opcode +0ms
develop:testrpc +0ms
```
Возьмем хеш транзакции и передадим его в команду debug:
```
truffle(develop)> debug 0x21073e12e7c8fb785347d7bd5d974d4954379dcace7b53d452c03b39ca007b9e
```
Вам должны вывестись подсказки дальнейших команд. Чтобы понять хотя бы в какой строчке ошибка, можно использовать команду `n` (step next):
```
debug(develop:0x21073e12...)> n
FaultyContract.sol | 0x345ca3e014aaf5dca488057592ee47305d9b3e10:
8: int public result;
9:
10: function divideXbyY( int x, int y ) public {
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
debug(develop:0x21073e12...)>
```
Каждый шаг будет отображаться несколько строк из кода и подчеркиваться часть, которая в данный момент исполняется. Есть возможность перейти на совсем низкий уровень и по-очереди выполнять каждый opcode (команды виртуальной машины Ethereum) и смотреть состояние стека. Сделаем еще один шаг и попробуем вывести состояние стека:
```
debug(develop:0x21073e12...)>
FaultyContract.sol | 0x345ca3e014aaf5dca488057592ee47305d9b3e10:
9:
10: function divideXbyY( int x, int y ) public {
11: y -= y;
^
debug(develop:0x21073e12...)> p
FaultyContract.sol | 0x345ca3e014aaf5dca488057592ee47305d9b3e10:
(55) DUP1
00000000000000000000000000000000000000000000000000000000c6329782
000000000000000000000000000000000000000000000000000000000000009b
0000000000000000000000000000000000000000000000000000000000000010
0000000000000000000000000000000000000000000000000000000000000004 (top)
```
Видим, что последними в стеке лежат наши x и y, 16 и 4. Это конечно не сильно удобный способ и нужно разбираться с опкодами и как они выполняются в виртуальной машине Ethereum. Если интересно — можете глянуть например [yellow paper](http://gavwood.com/paper.pdf) (H.2. Instruction Set). Но у нас задача просто найти строчку с ошибкой. Продолжим выполнять `next step`, пока не получим что-то подобное:
```
10: function divideXbyY( int x, int y ) public {
11: y -= y;
12: result = x/y;
^^^
debug(develop:0x21073e12...)>
Transaction halted with a RUNTIME ERROR.
This is likely due to an intentional halting expression, like assert(), require() or revert(). It can also be due to out-of-gas exceptions. Please inspect your transaction parameters and contract code to determine the meaning of this error.
truffle(develop)>
```
Тут хотя бы можно увидеть, что ошибка произошла где-то в части деления. И можно смотреть на стек и инструкции, если разбираетесь. Это к сожалению все, что предлагает трюфель по части дебага. Ну, хоть что-то.
В этом плане для одиночных контрактов и несложных связей можем посоветовать [Remix IDE](https://remix.ethereum.org) (в [этой статье](https://habrahabr.ru/post/341466/) например автор пользуется ей для деплоя), там есть практически полноценный дебаг с возможностью видеть значения переменных на каждом шаге. Интерфейс интуитивный, смотрите как уже рассмотренный пример можно будет отладить там:
В консоли внизу видим ошибку, нажимаем дебаг:
И можем прокручивать туда-сюда и видеть значения переменных в человеческом виде.
Удаленные ноды Infura
---------------------
В прошлой статье мы рассматривали плагин Metamask, который позволяет подключаться к блокчейну без использования локального синхронизированного Ethereum-клиента. Это возможно благодаря сервису [Infura](https://infura.io/). Вы тоже можете получить доступ к нодам Infura и подключаться к ним через truffle. Для этого во-первых нужно [зарегистрироваться на их сайте](https://infura.io/signup), в письме вам придут ссылки с персональными токенами для доступа. Давайте попробуем задеплоить пример Metacoin на Ropsten без локальной ноды.
Создаем тестовый проект как обычно:
```
$ mkdir metacoin && cd metacoin
$ truffle unbox metacoin
```
Далее нам понадобится дополнительный пакет [HDWalletProvider](https://github.com/trufflesuite/truffle-hdwallet-provider), с помощью которого Truffle может подписывать транзакции
```
$ npm init
$ npm install
$ npm install truffle-hdwallet-provider
```
Добавим провайдер в настройки трюфеля таким кодом:
```
var HDWalletProvider = require("truffle-hdwallet-provider");
var mnemonic = "correct horse battery staple correct horse battery staple correct horse battery staple"
module.exports = {
networks: {
development: {
host: "localhost",
port: 8545,
network_id: "*"
},
ropsten: {
provider: function() {
return new HDWalletProvider(mnemonic, "https://ropsten.infura.io/<ваш токен из письма>")
},
network_id: 3,
gas: 4000000,
gasPrice: 21000000000
}
}
};
```
Пришлось задать gas и gasPrice, потому что по крайней мере у нас значения по умолчанию не подошли. Не забудьте вставить токен из письма, а еще придумайте свою мнемонику из 12 разных (а не как в примере) слов — она используется для генерации аккаунтов и если кто-то ей завладеет, то сможет сгенерировать те же самые аккаунты и воспользоваться ими без вашего ведома. Например если вы попробуете использовать мнемонику в этой статье, то сможете воспользоваться тем эфиром (0.3), который мы туда переслали (если его не израсходует кто-то еще). В этом конфиге также оставлен `development`, выбирать между этими двумя сетями можно запуская truffle с соответствующим названием после флага `--network`:
```
$ truffle console --network ropsten
```
Перед тем как вызывать `migrate`, требуется пополнить баланс сгенерированного аккаунта. Узнаем адрес и баланс командами:
```
truffle(ropsten)> web3.eth.getAccounts( function(e,r) { console.log(r[0]); } );
undefined
0x0bb542704819b5e6a28deb2b73245be57ce0e78b
truffle(ropsten)> web3.eth.getBalance('0x0bb542704819b5e6a28deb2b73245be57ce0e78b', function(e, r) { console.log( web3.fromWei( r.toNumber() ) ); })
undefined
0
```
Перешлите на ваш аккаунт немного Ropsten-эфира для того, чтобы можно было заплатить за деплой. После того, как он дошел (можно проверять предыдущей командой), можно попробовать выполнить `migrate`:
```
truffle(ropsten)> migrate
```
Результат должен быть таким:
```
Compiling ./contracts/ConvertLib.sol...
Compiling ./contracts/MetaCoin.sol...
Compiling ./contracts/Migrations.sol...
Writing artifacts to ./build/contracts
Using network 'ropsten'.
Running migration: 1_initial_migration.js
Deploying Migrations...
... 0x93cf7dbde8c362534dc912926fc4d7df54c9c1f5e0a7dcfd964a0177b42bc7be
Migrations: 0x02519d13f61bdcad838d938611e6722c3d1f8034
Saving successful migration to network...
... 0xec501a78cc11c723ab60186167765aa7c422177153cd72a976e66441db2b5b95
Saving artifacts...
Running migration: 2_deploy_contracts.js
Deploying ConvertLib...
... 0xf172d9a9ff9f1fdfdfabc816d89f5a5e710ba26e3a2ad9e1661c9dea56564f04
ConvertLib: 0xd04bffb73bf546985938a596565141d3a3bf7f0d
Linking ConvertLib to MetaCoin
Deploying MetaCoin...
... 0x4d9814f1d9a959e83828bf26319dd91d73be977395d88e9e8239bb4c4ed5b0eb
MetaCoin: 0x20fd16643d857ce544a91ae4c80385af99dad196
Saving successful migration to network...
... 0x0dff866460d24d56d94dcf5f833aa4fa8ae289cb708ff5c9012ce21447575ce8
Saving artifacts...
truffle(ropsten)>
```
Видим хеш транзакций, можно проверить, что они действительно попали на Ropsten через etherscan.io (например [ropsten.etherscan.io/tx/0x93cf7dbde8c362534dc912926fc4d7df54c9c1f5e0a7dcfd964a0177b42bc7be](https://ropsten.etherscan.io/tx/0x93cf7dbde8c362534dc912926fc4d7df54c9c1f5e0a7dcfd964a0177b42bc7be))
Что дальше?
-----------
Надеемся вы узнали что-то новое из этой статьи или хотя бы освежили знания.
Что касается следующей статьи, то как показала практика, сложно сделать реальный полезный проект без связи с внешним миром через Oraclize и IPFS. Об этом и планируем написать.
Погружение в разработку на Ethereum:
[Часть 1: введение](https://habrahabr.ru/post/336132/)
[Часть 2: Web3.js и газ](https://habrahabr.ru/post/336770/)
[Часть 3: приложение для пользователя](https://habrahabr.ru/post/339080/) | https://habr.com/ru/post/348656/ | null | ru | null |
# Haskell — невозможное возможно?
Известно, что задача определения того, истинна ли некоторая функция `Integer -> Bool` хотя бы для одного числа вычислительно неразрешима. Однако, нечто, на первый взгляд кажущееся как раз таким оракулом (а именно, функцией `(Integer -> Bool) -> Maybe Integer`) будет описано в этой статье.
Для начала, зададим свой тип натуральных чисел, практически дословно следуя их обычному математическому определению (почему это нужно будет видно в дальнейшем):
```
data Nat = Zero | Succ Nat deriving (Eq, Ord, Show)
```
Другими словами, натуральное число — это либо ноль, либо некоторое натуральное число, увеличенное на единицу (`Succ` от слова successor).
Также, для удобства, определим основные операции (сложение, умножение, конвертация из `Integer`) над числами в таком представлении:
```
instance Num Nat where
Zero + y = y
Succ x + y = Succ (x + y)
Zero * y = Zero
Succ x * y = y + (x * y)
fromInteger 0 = Zero
fromInteger n = Succ (fromInteger (n-1))
```
Пока, вроде бы, ничего особенного в плане отличий этого типа от обычного `Integer`.
Вспомним, что мы хотим функцию вида `(Nat -> Bool) -> Maybe Nat`, результатом которой будет число, на котором поданная на вход функция возвращает `True`, или `Nothing` если такого числа нет. Первым приближением может быть, например, подобная функция:
```
lyingSearch :: (Nat -> Bool) -> Nat
lyingSearch f | f Zero = Zero
| otherwise = Succ (lyingSearch (f . Succ))
```
На самом деле, почти очевидно, что в случае существования искомого числа эта функция вернёт верный ответ. Действительно, если `f Zero == True`, то возвращаемым значением будет `Zero` — верно. Иначе функция вернёт `x+1`, где `x` — значение, на котором истинна функция `f(x+1)` — тоже верно.
Однако, не зря у этой функции название `lyingSearch`: в случае, когда искомого числа нет, функция будет на каждом шаге уходить в рекурсию и вернёт, по сути, бесконечность: `Succ (Succ (Succ (...`, где вложенность никогда не окончится. Из-за ленивости `Haskell` это — нормальная ситуация. Но ведь бесконечность не является искомым ответом — следовательно в данном случае функция «солжёт».
Что интересно, полностью работающее решение можно сделать на базе приведённой выше функции `lyingSearch`. Рассмотрим функцию `search`, определённую так:
```
search f | f possibleMatch = Just possibleMatch
| otherwise = Nothing
where
possibleMatch = lyingSearch f
```
На первый взгляд непонятно, как такое будет работать, и будет ли. Проверим на простых примерах:
```
ghci> search (\x -> x*x == 16) -- такое работало и для lyingSearch
Just (Succ (Succ (Succ (Succ Zero))))
ghci> search (\x -> x*x == 15)
Nothing
```
То есть, функция `search` верно определила, что не существует натурального числа с квадратом равным пятнадцати.
На самом деле, если разобраться, то всё просто. Получив от `lyingSearch` возможный результат (который всегда является допустимым значением типа `Nat`) мы просто подаём его на вход функции `f` и проверяем возвращаемое значение. Если искомое число существует, то (как уже выяснено ранее) `possibleMatch` — как раз это число, и следовательно проверка пройдёт успешно. Иначе, т.к. `f` завершается для любого входного значения, мы получим `False` и вернём `Nothing`.
Функция `search` действительно работает для любого предиката (функции `Nat->Bool`), и завершается за конечное время (разумеется, при условии, что `f` также завершается для любого значения типа `Nat`). Однако, условие завершения `f` для любого переданного аргумента очень сильное, и именно оно сильно ограничивает множество допустимых предикатов: например, при `f x = x*x + 1 == x` будет бесконечный цикл. Казалось бы, что здесь не так, ведь такая функция завершается для любого числа? Оказывается, для любого кроме уже упомянутой бескочности: слева и справа от знака равенства будут бесконечно вложенные `Succ (Succ (Succ (...`, и соответственно невозможно будет определить, равны ли левая и правая части. Именно по этой причине невозможно использовать данную функцию для создания аналогичной для типа `Integer`.
Теперь уже можно простыми словами объяснить, почему и каким образом всё работает для всегда завершающихся функций. Ведь если `f` завершается на переданной ей бесконечности, то есть последовательности `Succ (Succ (Succ (...`, значит она в любом случае использует (раскрывает) не более некоторого фиксированного числа конструкторов `Succ`.
Аналогичным по сути способом можно создавать функции вроде `search` и для других типов. Относительно простым примером также являются действительные числа, представленные каждое в виде бесконечного списка цифр (см. статью [Seemingly Impossible Functional Programs](http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/)). На hackage есть обобщающий пакет [infinite-search](http://hackage.haskell.org/package/infinite-search), который предоставляет соответствующую монаду и сопутствующие функции.
**P.S.:** эта статья является несколько дополненным «пересказом» [Searchable Data Types](http://lukepalmer.wordpress.com/2010/11/17/searchable-data-types/), поэтому как перевод не помечена. | https://habr.com/ru/post/201446/ | null | ru | null |
# Почему "=" означает присваивание?
Давайте посмотрим на следующий код:
```
a = 1
a = a + 1
print(a)
```
В среде ФП часто критикуют данный момент императивного программирования: «Как так может быть, что a = a + 1? Это всё равно что сказать „1 = 2“. В мутабельном присваивании нет смысла».
Здесь мы наблюдаем несовпадение обозначения: «равно» должно обозначать «равенство», когда на практике оно обозначает «присвоить». Я согласен с этой критикой и считаю, что это неудачная нотация. Но также мне известно, что в некоторых языках вместо `a = a + 1` пишут выражение `a := a + 1`. Почему же эта запись не является нормой?
На этот вопрос обычно отвечают «потому что так сделано в C». Но это похоже на перекладывание ответственности на кого-то другого: кто из нас знает, *почему* так сделано в C? Давайте разбираться вместе!
Большая четвёрка
----------------
В начале 1960-ых существовало четыре доминирующих высокоуровневых языка: COBOL, FORTRAN II, ALGOL-60, и LISP. В то время, программисты разбивали присваивание на два класса: *инициализацию* (*initialization*) — когда вы впервые определяете переменную, и *переприсвоение* (*reassignment*) — когда вы вы изменяется значение существующей переменной.
Итак, давайте добавим комментарии к нашему примеру на Python и получим следующий код:
```
a = 1 # Инициализация
a = a + 1 # Переприсвоение
print(a)
```
В то время люди не пользовались конкретно этими терминами для обозначения операций, но по сути это было как раз то, что делал каждый программист. В таблице ниже вы можете увидеть, какие из операторов использовались для каждого языка, и как выполнялась проверка на равенство.
| Язык | Инициализация | Присваивание | Равенство |
| --- | --- | --- | --- |
| FORTRAN | = | = | .EQ. |
| COBOL | INITIALIZE | MOVE [[1]](#1) | EQUAL |
| ALGOL | N/A | := | = |
| LISP | let | set | equal |
В ALGOL не было отдельного оператора для инициализации — вместо этого вы создавали переменную определенного типа и затем использовали оператор для присвоения ей чего-либо. Вы могли написать `integer x; x := 5;`, но не `x := 5;`. Единственный язык из списка, который использовал `=` для присваивания, это FORTRAN — и он выглядит подходящим кандидатом для ответа на наш вопрос.
Но мы-то с вами знаем, что C происходит от ALGOL; что, в свою очередь, означает, что по какой-то причине было решено отказаться от оператора присваивания `:=` и изменить значение оператора `=` с проверки на равенство…
ALGOL порождает CPL
-------------------
ALGOL-60, скорее всего, является одним из самых влиятельных языков программирования в истории computer science. Вероятно, что при всём этом он также является одним из самых бесполезных языков. В основной спецификации языка намеренно не было предусмотрено никакой функциональности для ввода/вывода. Вы могли «захардкодить» вводы и измерять выводы, но если вам нужно было сделать с ними что-либо полезное, вам требовалось найти компилятор, который расширял бы базовый язык. ALGOL был спроектирован с целью исследования алгоритмов и поэтому он «ломался», когда вы пытались сделать на нём что-либо ещё.
Однако, он оказался настолько «крепким» языком, что другие захотели обобщить его для использования в бизнесе и в промышленности. Первую подобную попытку предприняли Кристофер Страчи и Кембриджский университет. Получившийся в итоге язык CPL добавил к функциональности ALGOL достаточное количество инновационных возможностей, о большей части которых мы в дальнейшем глубоко пожалели. Одной из них было определение с инициализацией, в котором переменная могла быть инициализирована и присвоена в одном выражении. Теперь вместо того, чтобы писать `x; x := 5;` вы могли просто написать `integer x = 5`. Просто супер!
Но здесь мы переключились с `:=` на `=`. Это происходит потому, что в CPL было три типа инициализации переменной:
* = означало инициализацию по значению.
* ≃ означала инициализацию по ссылке, поэтому если x ≃ y, то переприсваивание x также изменяет y. Но если вы написали x ≃ y + 1 и попробовали переприсвоить x, то программа бы «упала».
* ≡ означает инициализацию через подстановку, т.е. превращение x в функцию, не принимающую аргументов (niladic function), которая вычисляет правостороннее значение каждый раз, когда её используют. При этом нигде не объясняется, что должно случиться, если вы попробуете переприсвоить x — и я, поверьте, тоже не слишком хочу знать это.
Проблема: теперь `=` использовался и для инициализации, и для равенства. К счастью, на практике в CPL эти варианты использования символа были четко разграничены: если вы где-либо писали `=`, то было однозначно понятно, что имелось в виду.
Всего год спустя Кен Айверсон создаст APL, который станет использовать символ `←` для всех видов присваиваний. Поскольку на большинстве клавиатур такой клавиши нет и никогда не было, от него быстро откажется и сам автор — его следующий язык, J, тоже будет использовать для присваиваний символ `=:`[[2]](#2). Однако, APL глубоко повлиял на S, который в свою очередь глубоко повлиял на R — вот почему `<-` является предпочтительным оператором присваивания в R.
CPL порождает BCPL
------------------
CPL был замечательным языком, обладавшим всего одним небольшим недостатком: ни у кого не получалось написать его реализацию. Несколько человек смогли частично реализовать различные подмножества из его «фич», но этот язык оказался слишком большим и сложным для компиляторов той эпохи. Поэтому неудивительно, что Мартин Ричардс решил избавиться от ненужной сложности ящика и создал BCPL. Первый компилятор BCPL появился в 1967 году… а первый компилятор CPL — лишь в 1970-м.
Среди многих других упрощений оказались и правила «трёх типов инициализации», которые приказали долго жить. Ричардс считал, что выражения-подстановки были вещью узкоспециальной, и их можно было заменить функциями (то же самое, по его мнению, касалось и присваиваний). Поэтому он совместил их всех в простое `=`, за исключением наименований адресов глобальной памяти, которые использовали `:`. Как и в случае CPL, `=` представляло собой проверку на равенство. Для присвоения (*reassignment*), он использовал `:=` — аналогично тому, как это сделали CPL и ALGOL. Многие из последовавших после языков также следовали этому соглашению: `=` для инициализации, `:=` для присваивания, `=` для равенства. Но в широкие массы это пошло тогда, когда Никлаус Вирт создал Pascal — вот почему сегодня мы называем подобные обозначения «в стиле Pascal».
Насколько мне известно, BCPL был также первым «слабо типизированным» языком, поскольку единственным типом данных было машинное слово (*data word*)[[3]](#3). Это позволило сделать компилятор куда более портабельным за счет потенциального увеличения количества логических ошибок, но Ричардс надеялся на то, что улучшения в процессе и наименования с описанием позволят противостоять этому. Помимо все этого, именно в BCPL впервые появились фигурные скобки с целью определения блоков.
BCPL порождает B
----------------
Кен Томпсон хотел, чтобы BCPL мог выполняться на PDP-7. Несмотря на то, что у BCPL был «компактный компилятор», он всё ещё был в четыре раза больше, чем минимальный объем рабочей памяти на PDP-7 (16 кБ вместо 4 кБ). Поэтому Томпсону требовалось создать новый, более минималистичный язык. Также по личным эстетическим причинам он хотел минимизировать количество символов в исходном коде. Это и повлияло на дизайн языка B сильнее всего; вот почему в нём появились такие операторы, как ++ и --.
Если вы оставите в стороне использование поименованных адресов глобальной памяти, в BCPL всегда использовались следующие обозначения: `=` для инициализации и `:=` для переприсваивания (*reassignment*). Томпсон решил, что эти вещи можно совместить в единый токен, который можно использовать для всех видов присваивания, и выбрал =, поскольку оно было короче. Однако, это привнесло некоторую неоднозначность: если `x` уже был объявлен, то чем было `x = y` — присваиванием или проверкой на равенство? И это ещё не всё — в некоторых случаях предполагалось, что это обе операции сразу! Поэтому он был вынужден добавить новый токен `==` как единую форму выражения смысла «равняется этому». Как выражался сам Томпсон:
> Поскольку присваивание в типовой программе встречается примерно в два раза чаще, чем сравнение на равенство, уместно было сделать оператор присваивания вполовину короче.
За время, прошедшее между появлением BCPL и B, была создана Simula 67, первый объектно-ориентированный язык. Simula последовала соглашениям ALGOL о строгом разделении шагов инициализации и переприсвоения. Алан Кей примерно в это же время начал работу над Smalltalk, который добавил блоки, но последовал такому же синтаксису.
Томпсон (к которому присоединился Денис Ритчи) выпустил первую версию B примерно в 1969 году. Так что вплоть до 1971 года (примерно) большинство новых языков использовали для присваивания обозначение `:=`.
B порождает C
-------------
… остальное – уже история.
Хорошо, есть ещё кое-что, о чём стоит рассказать. ML вышел год спустя, и, насколько мне известно, был первым языком, который привлек серьезное внимание к чистым функциям и отсутствию мутаций. Но в нем по-прежнему был спасательный круг в виде ссылочных ячеек (*reference cells*), которые можно было переприсваивать новым значениям при помощи оператора `:=`.
Начиная с 1980, мы наблюдаем рост популярности новых императивных языков, ориентированных на корректность — в частности, Eiffel и Ada, оба из которых используют для операции присваивания символ `:=`.
Если посмотреть на всю картину в целом, `=` никогда не был «естественным выбором» для оператора присваивания. Почти все языки в семейном дереве ALGOL использовали вместо этого для присваивания `:=`, *возможно* в силу того, что `=` было столь тесно ассоциировано с равенством. В наши дни большинство языков использует = поскольку его использует C, и мы можем проследить эту историю до CPL, который представлял собой *тот ещё бардак*.
Примечания
----------
1. В этом месте COBOL становится очень странным. У них есть несколько операторов, которые могут неявно мутировать, вроде ADD TO и COMPUTE. COBOL — плохой язык.
2. Мне нравится думать, что это было своеобразным приколом над `:=`, хотя на самом деле этот оператор согласован с остальными частями языка, который использует `.` и `:` как суффиксы глаголов.
3. Позже в BCPL добавят ключевое слово для типа с плавающей запятой. И когда я говорю «позже», я имею в виду [2018 год](http://www.cl.cam.ac.uk/~mr10/bcplman.pdf). | https://habr.com/ru/post/353292/ | null | ru | null |
# «Мочим» объекты с помощью Cuckoo
*Пост написан по мотивам статьи [Mocking in Swift with Cuckoo](http://riis.com/blog/Mocking-in-Swift-with-Cuckoo/) by Godfrey Nolan*
По долгу своей "службы" мобильным разработчиком, предстала передо мной задача: разобраться с созданием и использованием Моков для юнит-тестирования. Моим коллегой была рекомендована библиотека [Cuckoo](https://github.com/SwiftKit/Cuckoo). Стал я с ней разбираться и вот что из этого вышло.
Документация
============
Прочитав документацию на гитхабе мне, к сожалению, не удалось "завести" Cuckoo в моем проекте. Через CocoaPods этот фреймворк был установлен, но вот с Run-скриптом возникли проблемы: предложенный пример не создавал файл `GeneratedMocks.swift` в папке с тестами, и я бы и не разобрался почему, если бы не нашел через гугл статью, которую упомянул в начале поста.
Итак, пройдем все этапы вместе и разберемся с некоторыми нюансами.
Тестовый проект
===============
Естественно, нам нужен какой-нибудь проект в который мы подключим Cuckoo и напишем несколько тестов. Откройте Xcode, и создайте новый Single View Application: язык — Swift, обязательно поставьте галочку `Include Unit Tests`, имя проекта — `UrlWithCuckoo`.
Добавьте в проект новый Swift-файл и назовите его `UrlSession.swift`. Вот полный код:
```
import Foundation
class UrlSession {
var url:URL?
var session:URLSession?
var apiUrl:String?
func getSourceUrl(apiUrl:String) -> URL {
url = URL(string:apiUrl)
return url!
}
func callApi(url:URL) -> String {
session = URLSession()
var outputdata:String = ""
let task = session?.dataTask(with: url as URL) { (data, _, _) -> Void in
if let data = data {
outputdata = String(data: data, encoding: String.Encoding.utf8)!
print(outputdata)
}
}
task?.resume()
return outputdata
}
}
```
Как видите, это простой класс с тремя свойствами и двумя методами. Именно для этого класса мы и будем создавать Мок.
Подключаем Cuckoo
=================
Я использую в работе CocoaPods, поэтому для подключения Cuckoo добавлю в каталог с проектом Podfile такого вида:
```
platform :ios, '9.0'
use_frameworks!
target 'UrlWithCuckooTests' do
pod 'Cuckoo'
end
```
Естественно нужно запустить `pod install` в терминале из каталога с проектом, и после завершения установки открыть в Xcode `UrlWithCuckoo.xcworkspace`.
Следующим шагом добавляем Run-скрипт в Build Phases нашего "таргета" тестирования (нужно нажать "+" и выбрать "New Run Script Phase"):
Вот полный текст скрипта:
```
# Define output file; change "${PROJECT_NAME}Tests" to your test's root source folder, if it's not the default name
OUTPUT_FILE="./${PROJECT_NAME}Tests/GeneratedMocks.swift"
echo "Generated Mocks File = ${OUTPUT_FILE}"
# Define input directory; change "${PROJECT_NAME}" to your project's root source folder, if it's not the default name
INPUT_DIR="./${PROJECT_NAME}"
echo "Mocks Input Directory = ${INPUT_DIR}"
# Generate mock files; include as many input files as you'd like to create mocks for
${PODS_ROOT}/Cuckoo/run generate --testable "${PROJECT_NAME}" \
--output "${OUTPUT_FILE}" \
"${INPUT_DIR}/UrlSession.swift"
```
Как видите, в комментариях в скрипте написано о необходимости заменить `${PROJECT_NAME}` и `${PROJECT_NAME}Tests`, но в нашем примере в этом нет необходимости.
Генерируем Мок(и)
=================
Дальше нам нужно, чтоб этот скрипт сработал и создал в каталоге с тестами файл `GeneratedMocks.swift`, и просто сбилдить проект (`Cmd+B`) для этого недостаточно. Нужно сделать Build For -> Testing (`Shift+Cmd+U`):
Проверьте что в каталоге `UrlWithCuckooTests` появился файл `GeneratedMocks.swift`. Его (файл) также нужно добавить в сам проект: просто перетащите его из Finder в Xcode в `UrlWithCuckooTests`:
Наши Моки готовы, поговорим о некоторых нюансах.
#### 1. Сложные файловые структуры
Если у вас в проекте присутствует нормальная файловая структура и файлы разложены по подпапкам, а не просто находятся в корневом каталоге, то в скрипт нужно внести некоторые корректировки.
Допустим вы используете в своем проекте [MVP](https://habrahabr.ru/company/badoo/blog/281162/) и вам нужен Мок для вью-контроллера модуля `MainModule` (он у вас в проекте, конечно же, лежит по адресу `/Modules/MainModule/MainModuleViewController.swift`). В этом случае вам нужно поменять последнюю строку в скрипте из нашего примера `"${INPUT_DIR}/UrlSession.swift"` на `"${INPUT_DIR}/Modules/MainModule/MainModuleViewController.swift"`.
Также если вы хотите, чтоб файл `GeneratedMocks.swift` попадал не просто в корневой каталог тестов, а, например, в подпапку `Modules`, то вам нужно подкорректировать в скрипте вот эту строку: `OUTPUT_FILE="./${PROJECT_NAME}Tests/GeneratedMocks.swift"`.
#### 2. Нужны Моки нескольких классов
Очень вероятно (ожидаемая вероятность — 99.9%), что вам понадобятся Моки нескольких классов. Их можно сделать просто перечислив в конце скрипта файлы из которых нужно сделать Моки, разделив их обратными слэшами:
```
"${INPUT_DIR}/UrlSession.swift" \
"${INPUT_DIR}/Modules/MainModule/MainModuleViewController.swift" \
"${INPUT_DIR}/MyAwesomeObject.swift"
```
#### 3. Аннотации типов
В классах к которым вы создаете Моки у всех свойств должны быть аннотации типов. Если у вас есть что-то типа такого:
```
var someBoolVariable = false
```
То при генерации Мока вы получите ошибку:
И в файле `GeneratedMocks.swift` будет фигурировать `__UnknownType`:
К сожалению Cuckoo не умеет определять тип по значению по умолчанию, и в таком случае необходимо явно указывать тип свойства:
```
var someBoolVariable: Bool = false
```
Пишем тесты
===========
Теперь напишем несколько простых тестов используя наш Мок. Откроем файл `UrlWithCuckooTests.swift` и удалим из него два метода, которые создаются по умолчанию: `func testExample()` и `func testPerformanceExample()`. Они нам не понадобятся. И, конечно, не забудьте:
```
import Cuckoo
```
#### 1. Свойства
Сначала напишем тесты для свойств. Создаем новый метод:
```
func testVariables() {
}
```
Инициализируем в нем наш Мок и пару дополнительных констант:
```
let mock = MockUrlSession()
let urlStr = "http://habrahabr.ru"
let url = URL(string:urlStr)!
```
Теперь нам нужно написать stub-ы для свойств:
```
// Arrange
stub(mock) { (mock) in
when(mock.url).get.thenReturn(url)
}
stub(mock) { (mock) in
when(mock.session).get.thenReturn(URLSession())
}
stub(mock) { (mock) in
when(mock.apiUrl).get.thenReturn(urlStr)
}
```
Stub — это что-то типа подмены возвращаемого результата. Грубо говоря, мы описываем что вернет свойство нашего Мока, когда мы к нему обратимся. Как видите, мы используем `thenReturn`, но можем использовать и `then`. Это даст возможность не только вернуть значение, но и выполнить дополнительные действия. Например, наш первый stub можно описать и вот так:
```
// Arrange
stub(mock) { (mock) in
when(mock.url).get.then { (_) -> URL? in
// some actions here
return url
}
}
```
И, собственно, проверки (на значения и на `nil`):
```
// Act and Assert
XCTAssertEqual(mock.url?.absoluteString, urlStr)
XCTAssertNotNil(mock.session)
XCTAssertEqual(mock.apiUrl, urlStr)
XCTAssertNotNil(verify(mock).url)
XCTAssertNotNil(verify(mock).session)
XCTAssertNotNil(verify(mock).apiUrl)
```
#### 2. Методы
Теперь протестируем вызовы методов нашего Мока. Создадим два тестовых метода:
```
func testGetSourceUrl() {
}
func testCallApi() {
}
```
В обоих методах также инициализируем наш Мок и вспомогательные константы:
```
let mock = MockUrlSession()
let urlStr = "http://habrahabr.ru"
let url = URL(string:urlStr)!
```
Также в методе `testCallApi()` добавим счетчик вызовов:
```
var callApiCount = 0
```
Дальше в обоих методах напишем stub-ы.
`testGetSourceUrl()`:
```
// Arrange
stub(mock) { (mock) in
mock.getSourceUrl(apiUrl: urlStr).thenReturn(url)
}
```
`testCallApi()`:
```
// Arrange
stub(mock) { mock in
mock.callApi(url: equal(to: url, equalWhen: { $0 == $1 })).then { (_) -> String in
callApiCount += 1
return "{'firstName': 'John','lastName': 'Smith'}"
}
}
```
Проверяем первый метод:
```
// Act and Assert
XCTAssertEqual(mock.getSourceUrl(apiUrl: urlStr), url)
XCTAssertNotEqual(mock.getSourceUrl(apiUrl: urlStr), URL(string:"http://google.com"))
verify(mock, times(2)).getSourceUrl(apiUrl: urlStr)
```
*(в последней строке мы проверяем, что метод вызывался два раза)*
И второй:
```
// Act and Assert
XCTAssertEqual(mock.callApi(url: url),"{'firstName': 'John','lastName': 'Smith'}")
XCTAssertNotEqual(mock.callApi(url: url), "Something else")
verify(mock, times(2)).callApi(url: equal(to: url, equalWhen: { $0 == $1 }))
XCTAssertEqual(callApiCount, 2)
```
*(тут мы тоже проверяем количество вызовов, причем двумя способами: с помощью `verify` и счетчика вызовов `callApiCount`, который мы объявляли ранее)*
Запускаем тесты
===============
После запуска проекта на тестирование (`Cmd+U`) мы увидим вот такую картину:
Все работает, отлично. :)
И напоследок
============
Ссылка на то что у нас в итоге получилось: <https://github.com/ssuhanov/UrlWithCuckoo>
Спасибо за внимание. | https://habr.com/ru/post/322572/ | null | ru | null |
# Миссия AllMyChanges
Когда [наш проект](https://allmychanges.com/?utm_source=habrahabr&utm_campaign=our-mission) только зарождался, он базировался на гипотезе, что почти для любой библиотеки можно найти changelog, а если найти нельзя, то можно построить его из коммит-мессаджей. Но реальность оказалась не столь радужной, как нам того хотелось: то файл changelog в каком нибудь безобразном формате попадётся, то его перестали вести, а продукт меж тем развивается, то что нибудь ещё. И тогда мы поняли, что распарсить мир – мало, надо его менять.
Изменить что-то за один миг — необычайно сложная задача
-------------------------------------------------------
Поэтому мы не ставим себе такую цель. Миссия [AllMyChanges](https://allmychanges.com/?utm_source=habrahabr&utm_campaign=our-mission) в том, чтобы дать разработчикам всего мира понять, что `ChangeLog` это их способ взаимодействия с внешним миром, такой же канал, как блог или твиттер-аккаунт.
[](https://www.flickr.com/photos/d_t_vos/15962916323 "Mr. Speaker by Dick Vos, on Flickr")
До появления нашего сервиса, сложно было сравнивать простой ChangeLog с блогом, поскольку не было способа подписаться на обновления. Ведь ссылку на rss фид блога можно закинуть в rss читалку, на соцпрофиль можно подписаться, зафолловив человека, а подписаться на изменения библиотеки было сложно.
Некоторые разработчики, видя такую проблему, пытаются выстраивать коммуникации с пользователями своих библиотек или API, используя блоги. Туда они пишут о релизах, иногда постят котиков и другие новости, может быть и не относящиеся непосредственно к релизам. Но так поступают немногие, ведь вести блог для каждой своей opensource библиотечки весьма накладно и, согласитесь, куда проще
дописывать секции в `ChangeLog.md` файлик и коммитить его в репозиторий.
GitHub, со своей стороны, тоже пытается дать разработчикам интерфейс для коммуникации, построенный вокруг репозиториев. Называется он [GitHub Releases](https://github.com/blog/1547-release-your-software). Работает это примерно так: вы проставляете git тег с версией, затем, вместо того, чтобы дописывать ChangeLog, идете в интерфейс GitHub и дописываете там описание того, что же случилось за релиз. Ко всему этому можно приложить некие бинарные артефакты, например собранные под разные платформы. Для релизов, сделанных с помощью GitHub Releases генерится RSS фид, иного способа подписаться на новости проекта пока нет, за исключением сторонних сервисов вроде [Sibbell](http://bit.ly/1RnQuyz) или [AllMyChanges](https://allmychanges.com/?utm_source=habrahabr&utm_campaign=our-mission). Правда, Sibbel работает только с GitHub Releases, а в AllMyChanges нет такого ограничения, он работает с любыми источниками.
Кстати, по нашим подсчетам, сервис релизов на гитхабе используют уже около 10% от всех проектов, что добавлены на AllMyChanges. Именно поэтому с недавних пор, мы поддержали GitHub Releases, как ещё один источник данных. Они поступают по той узкой трубе, что справа:
[](https://www.flickr.com/photos/identity-chris-is/71240905 "Window and ... pipes by Christopher Tweed, on Flickr")
Коммуникации это наше ваше всё
------------------------------
Большая потребность в канале коммуникации существует и у разработчиков API. Многие из них не хотят этого признавать и всячески скрывают информацию о том, что и когда у них в API меняется, но есть и хорошие ребята, которые отлично понимают, что лишь только регулярное взаимодействие с пользователями позволяет выстроить здоровое сообщество разработчиков.
Кстати, подобная же ситуация сейчас обстоит на рынке мобильных приложений. Многие компании сейчас осознают, что релиз-ноутсы это отличный канал коммуникаций и начинают использовать их по назначению не только передавая важную информацию о произошедших в софте изменениях, но и развлекая своих пользователей. Посмотрите, к примеру на то, что пишут разработчики [Slack](https://allmychanges.com/p/ios/slack/?utm_source=habrahabr&utm_campaign=our-mission) и [Trello](https://allmychanges.com/p/ios/Trello/?utm_source=habrahabr&utm_campaign=our-mission).
Итак, миссия AllMyChanges состоит в том, чтобы уменьшить количество парней которые пишут в своих release notes: "This update includes minor improvements" и отворачиваются к стенке, засыпая с чувством выполненного долга. Не будьте в их числе, рассказывайте своим пользователям о том, что происходит, рекомендуйте им подписываться на обновления ченьджлога на [AllMyChanges](https://allmychanges.com/?utm_source=habrahabr&utm_campaign=our-mission). | https://habr.com/ru/post/260823/ | null | ru | null |
# Как подружить SRE с разработкой, а на сдачу улучшить качество сервиса
В декабре 2019-го в Dodo новые фичи стали выкатываться неприлично долго. Когда у разработчиков спросили, что им мешает держать высокую скорость поставки фич, в топе ответов оказались жалобы на нестабильную работу тестовых стендов и медленную обработку тикетов. Команда SRE сильно удивилась — о некоторых проблемах знали, но не думали, что они настолько серьёзные. Кроме того, между разработчиками и SRE взаимоотношения были, мягко говоря, не очень хорошие.
Меня зовут Катя, я People&Proccess Lead в команде SRE (можете считать меня скрам-мастером). Сегодня расскажу вам удивительную историю про SRE и разработчиков и как нам удалось за полгода значительно изменить ситуацию.
Это статья не про волшебные пендали, а про то, как постепенное изменение мышления, подхода, процессов и отношения позволило улучшить опыт взаимодействия разработчиков с командой SRE, уменьшить тойл и снизить градус разобщённости.
Что такое SRE
-------------
#### Чтобы быть на одном уровне понимания, давайте сначала уточним, что означает SRE.
[SRE](https://en.wikipedia.org/wiki/Site_reliability_engineering) — это подход, который придумали в Google. Он предполагает применение практик разработки по отношению к инфраструктуре и операционным задачам.
У зрелой команды SRE минимум ручной работы, всё максимально автономно. Разработчик нажимает кнопочку «создать стенд для команды» и оно работает. Мониторинг, алерты и всё остальное работает автоматически для новых сервисов.
Если сравнивать с традиционными взглядами на системное администрирование и инфраструктуру, то тут обычно главное — ручная работа, а скрипты её частично оптимизируют. SRE, напротив, стремятся минимизировать ручную операционную работу (toil, далее — тойл) через автоматизацию. При этом главное по-прежнему – надёжность продакшена.
Что такое toil*Тойл (Toil) — работа, обладающая хотя бы тремя из перечисленных качеств: ручная, повторяющаяся, её можно автоматизировать, реактивная (решает проблему здесь и сейчас, без долгосрочной пользы), не делает продукт лучше, объём имеет линейную зависимость от количества подопечных (продуктов, сервисов, людей). Почему тойл — это плохо, можно узнать из* [*книги Site Reliability Engineering от Google*](https://landing.google.com/sre/sre-book/chapters/eliminating-toil/)*.*
Тойл в работе SRE всё равно присутствует, но не должен превышать 40% от общей деятельности инженера.
#### Тойл в Dodo
Для нашей команды SRE — это по большей части реакция на проблемы на продакшен-окружении (On Call) и поддержка для всего IT (On Duty). On Call не вызывал у нас особых проблем, а вот с On Duty они были.
Что значит поддержка для всего IT:
* поддержка инфраструктуры на продакшен-окружении;
* поддержка инфраструктуры для тестовых стендов;
* выполнение просьб и задач от коллег по Dodo IS: разработчиков, QA, аналитиков, продакт-оунеров (*дальше будем называть их всех разработчиками*);
* консультации разработчиков по дизайну отказоустойчивых приложений и использованию инфраструктурных инструментов.
В среднем именно просьб и задач от разработчиков больше всего в On Duty.
И такого тойла у нас было слишком много.
Решаем проблему, меняя подход
-----------------------------
Когда проблема с выкаткой фичей из-за нестабильных тестовых стендов и медленной обработки тикетов затронула весь Dodo Engineering, стало понятно, что решать её надо комплексно и сразу со всех сторон. Фокус на чем-то одном в этот раз не сработает: если чинить развалившемуся самолету только двигатели, его крылья сами не встанут на место, в итоге взлететь так и не получится.
Вместе с продакт-оунером, который только появился в команде SRE, мы решили начать со слома парадигмы. Уйти от подхода «каждый сам по себе» и взять за ориентир принцип «Разработчики — наши клиенты». Что делать для улучшения ситуации естественным образом вытекало из этого основополагающего принципа. И пусть внутри команды эта мысль не была популярна, мы верили, что это сработает.
Искреннее желание помочь
------------------------
Если вы заботитесь о своих клиентах и вам действительно не всё равно, как им живётся, результат не заставит себя ждать. Даже если проблемы будут продолжаться, желание помочь способно коренным образом изменить отношение клиентов к сервису и людям, которые его обеспечивают.
### Фокусируемся на решении проблемы, а не препирательствах
Задолго до внедрения подхода SRE внутри команды сложилась токсичная атмосфера, которая выливалась наружу. К сожалению, раньше слишком часто вместо реальной помощи разработчикам отвечали разными вариантами фразы «сам дурак».
Такое положение дел не способствовало сплочению SRE и разработчиков, вызывало эмоциональные, но абсолютно не конструктивные споры, а самое главное — дело не сдвигалось с мёртвой точки: спрашивающий не получал ответа, проблема не решалась, разработка тормозилась. Иногда разработчики вообще не приходили к SRE с проблемой, и не потому что могли решить её сами, а потому что были уверены, что не получат помощь.
Здесь требовалась методичная работа с командой SRE:
* лидеры рассказывали, почему важно решать проблемы людей, почему препирательства бесполезны и вредны в первую очередь для них самих;
* они вдохновляли людей своим примером: стали голосом команды SRE вовне. Сами шли и помогали, отвечали на вопросы, транслировали информацию от команды;
* обращали внимание на ошибки ребят во внешних коммуникациях и поощряли клиентоориентированную, конструктивную реакцию;
* боролись с токсичностью, троллингом и неконструктивными спорами внутри самой команды SRE.
Борьба с токсичностью — отдельная большая тема, углубляться в неё в этой статье не хочется. Исправлять надо не людей, а среду, в которой они находятся, процессы, которые есть вокруг. Хорошо, что в этой борьбе нам удалось обойтись малой кровью. За это отдельная благодарность ребятам. <3
### Идём в гембу
Нам надо было разобраться, что именно не так:
* что значит «нестабильность тестовых стендов» — какого рода проблемы встречаются разработчикам и почему именно такие?
* где узкое место при выполнении тикетов, из-за чего они долго висят?
Поэтому, по заветам великой Тойоты, мы решили пойти в [гембу](https://ru.wikipedia.org/wiki/%D0%93%D1%8D%D0%BC%D0%B1%D0%B0). Для этого было самое время: недовольство растёт, а мы даже не замечаем проблем. Два человека из команды SRE буквально пересели к командам разработки и вместе с ними решали все возникавшие проблемы со стендами.
Что это дало:
* убедились, что проблемы не надуманные, а действительно существуют;
* зафиксировали и классифицировали сами проблемы, чтобы понимать, что именно нужно чинить;
* посмотрели, как разработчики диагностируют и решают проблемы со стендами. Выяснили, что они не понимают, как работают их стенды, система целиком и отдельные приложения в частности;
* команды, с которыми точечно работали SRE, стали более самостоятельными: они научились справляться с большинством возникающих проблем;
* в этих командах разработки заметно улучшилось отношение к SRE.
Последний результат стал неожиданностью: никто и не надеялся, что во взаимоотношениях удастся так быстро что-то изменить.
> Когда мы смогли сгруппировать проблемы со стендами, оказалось, что инфраструктура не при чём. Чаще всего дело было в рассинхроне данных между различными частями системы. Командам разработчиков нужно было прилагать дополнительные усилия, чтобы поддерживать консистентность данных на своих стендах. Почти никто из них не подозревал о такой проблеме, только единицы знали, как синхронизировать данные между сервисами, чтобы сделать окружение снова консистентным.
>
>
### Помогаем клиенту понять, что ему на самом деле надо
Думаю, многие из читателей сталкивались с ситуацией, когда гораздо важнее знать «зачем это делать», чем «что делать». Разработчики — народ прокачанный и толковый, но и они попадают в ловушку [XY-проблемы](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0_XY), когда просят о чём-то команду SRE.
Это не делает их менее крутыми специалистами, а свидетельствует лишь о том, что их экспертиза в инфраструктуре на порядок ниже, чем у SRE. И это нормально.
Поэтому мы взяли себе за правило, что лучше лишний раз спросить и разобраться, что именно происходит, чем слепо делать то, что просят. Такой подход не только помогает избегать двойной работы, но и даёт клиенту лишний раз убедиться, что нам не всё равно. Мы здесь, чтобы помочь решить проблему наилучшим способом, а не отвязаться побыстрее.
> Уточняющие вопросы и объяснения, как поступать в том или ином случае, помогли разработчикам стать более осведомлёнными — они стали лучше понимать, как решать проблемы с собственными стендами. Самые крутыши и вовсе стали контрибьюторами в инфраструктурные репозитории.
>
>
### Делаем бесшовные обновления для всех
Мы всегда уделяли повышенное внимание бесшовности и общей незаметности любых обновлений и переездов на продакшене — бизнес должен работать 24/7, даунтайм при технических работах допустим, только если других вариантов нет. Но когда технические работы касались dev-инфраструктуры, никто даже и не задумывался о том, чтобы делать это бесшовно: ну, подождут немного, ничего страшного.
Такой взгляд на доступность тестовых стендов прямо противоречит клиентоориентированному подходу — десятки разработчиков не должны прекращать свою работу и тратить время и нервы, пока технические работы не закончатся. Теперь любая задача, где ожидается даунтайм на тестовых стендах, проходит через фильтр бесшовности. Лучше мы потратим на задачу чуть больше времени, но проведём работы незаметно для наших клиентов.
Открытость между SRE и разработчиками
-------------------------------------
Открытость — один из главных принципов Dodo. Открытость внутри организации позволяет всем быть в одном контексте и принимать правильные решения.
Открытость рождает доверие: когда между людьми есть доверие, вместе они могут свернуть горы.
Открытость и доверие как внутри команды SRE, так и между SRE и разработчиками практически отсутствовали: разработчики не знали, что происходит в команде SRE, чем вообще ребята занимаются и почему, находились в постоянном стрессе от непредсказуемости перемен и технических работ на тестовых стендах. Это надо было менять как можно скорее.
Мы взяли курс на открытость по отношению к разработчикам:
* организовали Platform Update. Проводим его раз в две недели и рассказываем о наших новостях, о произошедших серьёзных инцидентах, о текущих задачах, проектах и планах на будущее;
* начали выступать на внутреннем [митапе DevForum](https://habr.com/ru/company/dododev/blog/462033/);
* стали предупреждать заранее о технических работах на тестовых стендах, если приходится делать их с даунтаймом.
Маркетинговый подход
--------------------
### Рекламируем и продвигаем свои продукты
В гембе мы выяснили, что разработчики не пользуются нашими инструментами, потому что либо плохо понимают, как они работают, либо вообще не знают о них.
Например, мы сделали классный инструмент для управления включением и выключением тестовых стендов через команды в Slack, а массово про него не рассказали, только лично с кем-то делились. О нём почти никто не знал, разработчики жаловались, что неудобно управлять включением и выключением стенда.
Стали рассказывать буквально обо всём и в прямом смысле рекламировать наши «продукты»:
* придумывали «баннеры» с картинками и мемами, добавляли в них call to action, короткие инструкции;
* распечатывали и развешивали в «проходных локациях» (у кофе-машины и на лестнице);
* использовали разные каналы продвижения: Slack, Platform Update, документацию.
### Собираем обратную связь
Мы хотели держать руку на пульсе, и надо было регулярно собирать обратную связь, чтобы понимать, что делаем не фигню. Например, каждый раз, когда очередной инструмент был готов, отдавали его разработчикам — они пробовали, оставляли фидбэк, а мы потом дорабатывали этот инструмент, чтобы улучшить их пользовательский опыт.
Ещё раз в квартал мы стали проводить опрос разработчиков и прямо их спрашивать, что не так, какие есть отзывы и пожелания.
Какие полезные инструменты появились в итоге
--------------------------------------------
Улучшили /request
-----------------
У нас уже был `/request` — специально написанный бот в Slack, который упрощал работу с задачами от разработчиков.
Все запросы в виде тикетов складываются в **трекер задач**.
В каждый момент времени (только в рабочие часы) **обработкой карточек** занимается только один человек — SRE, дежурящий на этой неделе.
У этого инструмента было несколько проблем:
* в название карточки часто записывался большой текст, из-за чего с ней было неудобно работать;
* если по карточке требовалось уточнение, ответа от разработчиков приходилось ждать долго, до нескольких дней;
* невозможно было понять срочность и приоритет (например, какие из тикетов могут блокировать релиз);
* мы не могли анализировать поступающие задачи, чтобы понять, что автоматизировать в первую очередь.
На принтскрине видно, что вся информация вместо описания попадала в название.Cделали красивую форму, в которой можно было указать отдельно название, отдельно описание, категорию и выбрать приоритет.
Благодаря тому, что у карточки появились категории, мы смогли их классифицировать и видели, какие задачи поступают чаще и точно нуждаются в автоматизации.
У карточек появились приоритеты, и теперь не нужно самому разбираться, что делать в первую очередь.
Cделали автооповещение — все изменения и комментарии по карточке приходят разработчикам в Slack, им не нужно мониторить нашу доску. Они сразу видят, что карточка продвинулась дальше или что нужно ответить на вопрос.
### Cоздали дашборд в Grafana
По итогам похода в гембу собрали дашборд в Grafana для тестовых стендов, который помогает понять, что не так со стендом и как можно его починить без участия SRE.
Параллельно починили мониторинг на тестовых стендах, который до этого не работал и казалось, что он никому не нужен.
### Написали пару ботов для Slack
**Bender — инструмент для включения и выключения тестовых стендов.** Его просто не было. Для экономии денег на тестовых стендах ввели правило, что на ночь их надо выключать. Делалось это всё вручную, было неудобно мониторить состояние стенда, его регулярно забывали выключать. Сделали бота, который умеет показывать текущий статус стенда, включать и выключать его, настраивать расписание.
**Yunga — бот для деплоя в Kubernetes.** Теперь можно не выходя из мессенджера задеплоить свое приложение на любой тестовый стенд и даже на продакшен.
Да, у нас бот-дривен-девелопмент!
#### Результаты
За первые полгода нам удалось заметно изменить многое. Это показали результаты опросов.
Результаты первого опроса в 2019 году.Результаты опроса летом 2020 года выглядят лучше.Два года спустя. Полёт нормальный — наш подход работает!* С внутренними клиентами можно и нужно работать так же, как и с внешними. Тогда они будут счастливы, а ваша работа будет более продуктивной и вдохновляющей.
* Даже самую закостенелую неприязнь между разработчиками и бывшей командой инфраструктуры можно и нужно лечить.
Надеюсь, наш опыт будет вам полезен. И делитесь в комментариях, как в ваших компаниях налажено взаимодействие между разработчиками и SRE (или командой инфраструктуры, сисадминами, девопсами).
Полезные ссылки:
[Книжки про SRE](https://sre.google/books/)
[Презентация Павла Притчина, СТО Dodo Egineering, про опыт внедрения SRE](https://drive.google.com/file/d/16_4Vm9fzSNZiSy1SIGcjVz5_xZfQxoHW/view)
**UPD.** По просьбам читалей добавили метрики Lead Time (наш трекер называет эту метрику Cycle Time) за период с декабря 2019 по август 2020:
Lead Time для тикетов от разработчиковПо Lead Time с декабря 2019 по август 2020 сохраняются довольно сильные колебания, но общий тренд - на снижение | https://habr.com/ru/post/583384/ | null | ru | null |
# Хакаем CAN шину авто. Виртуальная панель приборов
В первой статье [«Хакаем CAN шину авто для голосового управления»](https://habr.com/ru/post/399043/) я подключался непосредственно к CAN шине Comfort в двери своего авто и исследовал пролетающий траффик, это позволило определить команды управления стеклоподъемниками, центральным замком и др.
В этой статье я расскажу как собрать свою уникальную виртуальную или цифровую панель приборов и получить данные с любых датчиков в автомобилях группы VAG (Volkswagen, Audi, Seat, Skoda).
Мною был собран новый CAN сниффер и CAN шилд для Raspberry Pi на базе модуля MCP2515 TJA1050 Niren, полученные с их помощью данные я применил в разработке цифровой панели приборов с использованием 7″ дисплея для Raspberry Pi. Помимо простого отображения информации цифровая панель реагирует на кнопки подрулевого переключателя и другие события в машине.
В качестве фреймворка для рисования приборов отлично подошел Kivy для Python. Работает без Иксов и для вывода графики использует GL.
1. CAN сниффер из Arduino Uno
2. Подслушиваем запросы с помощью диагностической системы VAG-COM (VCDS)
3. Разработка панели приборов на основе Raspberry Pi и 7″ дисплея
4. Софт панели приборов на Python и Kivy (UI framework)
5. Видео работы цифровой панели приборов на базе Raspberry Pi
Под катом полная реализация проекта, будет интересно!
Водительская дверь открыта
### CAN сниффер из Arduino Uno
Чтобы послушать, что отправляет VCDS в CAN шину я собрал сниффер на макетке из Arduino и модуля MCP2515 TJA1050 Niren.
Схема подключения следующая:
Для прослушивания трафика использовал анализатор [CanHackerV2](https://www.mictronics.de/projects/usb-can-bus/) и прошивку arduino-canhacker для Arduino, которая реализует API совместимое с этой программой. Прошивка в гите <https://github.com/autowp/arduino-canhacker>.
CanHackerV2 позволяет смотреть пролетающий трафик, записывать и проигрывать команды с заданным интервалом, что очень сильно помогает в анализе данных.
### Подслушиваем запросы с помощью диагностической системы VAG-COM (VCDS)
Описание VCDS с официального сайта [ru.ross-tech.com](http://ru.ross-tech.com):
*Программно-аппаратный сканер VCDS предназначен для диагностики электронных систем управления, устанавливаемых на автомобилях группы VAG. Доступ ко всем системам: двигатель, ACP, АБС, климат-контроль, кузовая электроника и т.п., считывание и стирание кодов неисправностей, вывод текущих параметров, активация, базовые установки, адаптация, кодирование и т.п.*
Подключив сниффер к линиям CAN\_L и CAN\_H в диагностическом шнурке я смог увидеть какие запросы делает VCDS и что отвечает авто.
Особенность авто группы VAG в том, что OBD2 разъем подключен к CAN шине через шлюз и шлюз не пропускает весь гуляющий по сети трафик, т.е. подключившись в OBD2 разъем сниффером вы ничего не увидите. Чтобы получить данные в OBD2 разъёме нужно отправлять шлюзу специальные запросы. Эти запросы и ответы видно при прослушивании трафика от VCDS. Например вот так можно получить пробег.
В VCDS можно получить информацию почти с любого датчика в машине. Меня в первую очередь интересовала информация, которой вообще нет на моей приборке, это:
* температура масла
* какая именно дверь открыта
Скорость, обороты, температура ОЖ, пробег, расход, место в баке и другие запросы я тоже получил, для справки размещу.
```
// Двери
714 03 22 22 0D 55 55 55 55
77E 05 62 22 0D 55 65 AA AA - все закрыты
77E 05 62 22 0D 00 65 AA AA - все открыты
77E 05 62 22 0D 54 65 AA AA - водительская открыта
77E 05 62 22 0D 51 65 AA AA - пассажирская открыта
77E 05 62 22 0D 50 65 AA AA - водительская и пассажирская открыта
77E 05 62 22 0D 45 65 AA AA - задняя левая открыта
77E 05 62 22 0D 15 65 AA AA - задняя правая открыта
77E 05 62 22 0D 44 65 AA AA - водительская и задняя левая открыта
77E 05 62 22 0D 40 65 AA AA - водительская, пассажирская, задняя левая открыты
01010101 = 0x55 (все закрыты)
0 бит - водительская
2 бит - пассажирская
4 бит - задняя левая
6 бит - задняя правая
// Ручник
714 03 22 22 05 55 55 55 55
77E 05 62 22 05 21 AA AA AA - нажат
77E 05 62 22 05 20 AA AA AA - не нажат
// Наружная температура
714 03 22 22 0С 55 55 55 55
77E 04 62 22 0C 55 AA AA AA - -7.5°С
77E 04 62 22 0C 65 AA AA AA - 0.5 101°С
77E 04 62 22 0C 66 AA AA AA - 1 = 102°С
77E 04 62 22 0C 68 AA AA AA - 2 = 104°С
// Наружная температура отображаемая
714 03 22 10 14 55 55 55 55
77E 04 62 10 14 84 AA AA AA - 16°С
// Запас хода
714 03 22 22 94 55 55 55 55
77E 05 62 22 94 00 8E AA AA - 142км
// Уровень топлива
714 03 22 22 06 55 55 55 55
77E 04 62 22 06 2C AA AA AA - 44л
77E 04 62 22 06 16 AA AA AA - 22л
// Положение стрелки указателя уровня топлива
714 03 22 22 96 55 55 55 55
77E 05 62 22 96 01 9A AA AA - 41.0°
// Температура ОЖ
714 03 22 F4 05 55 55 55 55
77E 04 62 F4 05 85 AA AA AA - 52.5°С
77E 04 62 F4 05 87 AA AA AA - 54°С
77E 04 62 F4 05 С5 AA AA AA - 100.5°С
// Обороты двигателя
714 03 22 F4 0C 55 55 55 55
77E 05 62 F4 0C 0B C6 AA AA - 753.5 об/мин; 0BC6 = 3014/4 = 753
77E 05 62 F4 0C 0B DC AA AA - 759 об/мин; 0BDC = 3036
77E 05 62 F4 0C 0B E8 AA AA - 762 об/мин; 0BE8 = 3048
77E 05 62 F4 0C 1C 32 AA AA - 1804.5 об/мин
// Температура масла
714 03 22 20 2F 55 55 55 55
77E 04 62 20 2F 36 AA AA AA - -4°С
77E 04 62 20 2F 67 AA AA AA - 45°С
77E 04 62 20 2F 68 AA AA AA - 46°С
// Температура в салоне
746 03 22 26 13 55 55 55 55
7B0 05 62 26 13 00 5B AA AA - 9.1, 91 == 0x5B
7B0 05 62 26 13 00 5C AA AA - 9.2°С
7B0 05 62 26 13 00 5D AA AA - 9.3°С
// Время
714 03 22 22 16 55 55 55 55
77E 05 62 22 16 11 1E AA AA - 17:30
// Кнопки подрулевого переключателя
714 03 22 22 1B 55 55 55 55
77E 05 62 22 1B 80 AA AA AA - не нажата
77E 05 62 22 1B 81 AA AA AA - нажата вверх
77E 05 62 22 1B 84 AA AA AA - нажата вниз
// Средний расход 2
714 03 22 22 99 55 55 55 55
77E 03 62 22 99 00 91 AA AA - 14.5л/100км
// Текущий расход
714 03 22 22 98 55 55 55 55
77E 05 62 22 98 00 00 AA AA - 0.0л/100км
// Пробег
714 03 22 22 03 55 55 55 55
77E 05 62 22 03 24 С0 AA AA - 94080 км 0x24С0 * 10
```
### Разработка панели приборов на основе Raspberry Pi и 7″ дисплея
В качестве аппаратной части я выбрал Raspberry Pi. Была идея использовать Android планшет, но показалось, что на Raspberry Pi будет проще и быстрее. В итоге докупил официальный 7″ дисплей, и сделал CAN шилд из модуля TJA1050 Niren.
OBD2 штекер использовал от старого ELM327 адаптера.
Используются контакты: CAN\_L, CAN\_H, +12, GND.
Тесты в машине прошли успешно и теперь нужно было все собрать. Плату дисплея, Raspberry Pi и блок питания разместил на куске черного пластика, очень удачно подобрал пластмассовые втулки, с ними ничего не болтается и надежно закреплено.
Местом установки выбрал бардачок на торпедо, которым я не пользуюсь. По примеркам в него как раз помещается весь бутерброд.
Напильником довел лист черного пластика до размера крышки бардачка, к нему прикрепил бутерброд и дисплей. Для прототипа сойдет, а 3D модель с крышкой для дисплея и всеми нужными крепежами уже в разработке.
### Софт панели приборов на Python и Kivy (UI framework)
Параллельно со сборкой самой панели приборов я вел разработку приложения для отображения информации с датчиков. В самом начале я не планировал какой либо дизайн.
*Первая версия панели приборов*
По мере разработки решил визуализировать данные более наглядно. Хотел гоночный дизайн, а получилось, что-то в стиле 80-х.
*Вторая версия панели приборов*
Продолжив поиски более современного дизайна я обратил внимание какие цифровые приборки делают автопроизводители и постарался сделать что-то похожее.
*Третья версия панели приборов*
Ранее, я никогда не разрабатывал графические приложения под Linux поэтому не знал с чего начать. Вариант на вебе простой в разработке, но слишком много лишних компонентов: иксы, браузер, nodejs, хотелось быстрой загрузки. Попробовав Qt PySide2 я понял, что это займет у меня много времени, т.к. мало опыта. Остановился на Kivy — графический фреймворк для Python, простой в понимании с полной библиотекой графических элементов и дающий возможность быстро создать мобильный интерфейс.
Kivy позволяет запускать приложение без Иксов, прямо из консоли, в качестве рендера используется OpenGL. Благодаря этому полная загрузка системы может происходить за 10 секунд.
```
import can
import os
import sys
from threading import Thread
import time
os.environ['KIVY_GL_BACKEND'] = 'gl'
os.environ['KIVY_WINDOW'] = 'egl_rpi'
from kivy.app import App
from kivy.properties import NumericProperty
from kivy.properties import BoundedNumericProperty
from kivy.properties import StringProperty
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.widget import Widget
from kivy.uix.scatter import Scatter
from kivy.animation import Animation
messageCommands = {
'GET_DOORS_COMMAND': 0x220D,
'GET_OIL_TEMPERATURE' : 0x202F,
'GET_OUTDOOR_TEMPERATURE' : 0x220C,
'GET_INDOOR_TEMPERATURE' : 0x2613,
'GET_COOLANT_TEMPERATURE' : 0xF405,
'GET_SPEED' : 0xF40D,
'GET_RPM' : 0xF40C,
'GET_KM_LEFT': 0x2294,
'GET_FUEL_LEFT': 0x2206,
'GET_TIME': 0x2216
}
bus = can.interface.Bus(channel='can0', bustype='socketcan')
```
**Полный код панели в одном python файле**
```
# -*- coding: utf-8 -*-
import can
import os
import sys
from threading import Thread
import time
os.environ['KIVY_GL_BACKEND'] = 'gl'
os.environ['KIVY_WINDOW'] = 'egl_rpi'
from kivy.app import App
from kivy.properties import NumericProperty
from kivy.properties import BoundedNumericProperty
from kivy.properties import StringProperty
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.widget import Widget
from kivy.uix.scatter import Scatter
from kivy.animation import Animation
messageCommands = {
'GET_DOORS_COMMAND': 0x220D,
'GET_OIL_TEMPERATURE' : 0x202F,
'GET_OUTDOOR_TEMPERATURE' : 0x220C,
'GET_INDOOR_TEMPERATURE' : 0x2613,
'GET_COOLANT_TEMPERATURE' : 0xF405,
'GET_SPEED' : 0xF40D,
'GET_RPM' : 0xF40C,
'GET_KM_LEFT': 0x2294,
'GET_FUEL_LEFT': 0x2206,
'GET_TIME': 0x2216
}
bus = can.interface.Bus(channel='can0', bustype='socketcan')
class PropertyState:
def __init__(self, last, current):
self.last = last
self.current = current
def lastIsNotNow(self):
return self.last is not self.current
class CanListener(can.Listener):
def __init__(self, dashboard):
self.dashboard = dashboard
self.speedStates = PropertyState(None,None)
self.rpmStates = PropertyState(None,None)
self.kmLeftStates = PropertyState(None,None)
self.coolantTemperatureStates = PropertyState(None,None)
self.oilTempratureStates = PropertyState(None,None)
self.timeStates = PropertyState(None,None)
self.outDoorTemperatureStates = PropertyState(None,None)
self.doorsStates = PropertyState(None,None)
self.carMinimized = True
def on_message_received(self, message):
messageCommand = message.data[3] | message.data[2] << 8
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_SPEED']:
self.speedStates.current = message.data[4]
if self.speedStates.lastIsNotNow():
self.dashboard.speedometer.text = str(self.speedStates.current)
self.speedStates.last = self.speedStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_RPM']:
self.rpmStates.current = message.data[5] | message.data[4] << 8
if self.rpmStates.lastIsNotNow():
self.dashboard.rpm.value = self.rpmStates.current/4
self.rpmStates.last = self.rpmStates.current
if message.arbitration_id == 0x35B:
self.rpmStates.current = message.data[2] | message.data[1] << 8
if self.rpmStates.lastIsNotNow():
self.dashboard.rpm.value = self.rpmStates.current/4
self.rpmStates.last = self.rpmStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_KM_LEFT']:
self.kmLeftStates.current = message.data[5] | message.data[4] << 8
if self.kmLeftStates.lastIsNotNow():
self.dashboard.kmLeftLabel.text = str(self.kmLeftStates.current)
self.kmLeftStates.last = self.kmLeftStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_COOLANT_TEMPERATURE']:
self.coolantTemperatureStates.current = message.data[4]
if self.coolantTemperatureStates.lastIsNotNow():
self.dashboard.coolantLabel.text = str(self.coolantTemperatureStates.current-81)
self.coolantTemperatureStates.last = self.coolantTemperatureStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_OIL_TEMPERATURE']:
self.oilTempratureStates.current = message.data[4]
if self.oilTempratureStates.lastIsNotNow():
self.dashboard.oilLabel.text = str(self.oilTempratureStates.current-58)
self.oilTempratureStates.last = self.oilTempratureStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_TIME']:
self.timeStates.current = message.data[5] | message.data[4] << 8
if self.timeStates.lastIsNotNow():
self.dashboard.clock.text = str(message.data[4]) + ":" + str(message.data[5])
self.timeStates.last = self.timeStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_OUTDOOR_TEMPERATURE']:
self.outDoorTemperatureStates.current = float(message.data[4])
if self.outDoorTemperatureStates.lastIsNotNow():
self.dashboard.outDoorTemperatureLabel.text = str((self.outDoorTemperatureStates.current - 100)/2)
self.outDoorTemperatureStates.last = self.outDoorTemperatureStates.current
if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_DOORS_COMMAND']:
self.doorsStates.current = message.data[4]
if self.doorsStates.lastIsNotNow():
self.doorsStates.last = self.doorsStates.current
self.dashboard.car.doorsStates=message.data[4]
# all doors closed -> minimize car
if self.doorsStates.current == 0x55:
self.dashboard.minimizeCar()
self.carMinimized = True
else:
if self.carMinimized:
self.dashboard.maximizeCar()
self.carMinimized = False
class Dashboard(FloatLayout):
def __init__(self,**kwargs):
super(Dashboard,self).__init__(**kwargs)
# Background
self.backgroundImage = Image(source='bg.png')
self.add_widget(self.backgroundImage)
# RPM
self.rpm = Gauge(file_gauge = "gauge512.png", unit = 0.023, value=0, size_gauge=512, pos=(0,0))
self.add_widget(self.rpm)
self.rpm.value = -200
# Speedometer
self.speedometer = Label(text='0', font_size=80, font_name='hemi_head_bd_it.ttf', pos=(0,-15))
self.add_widget(self.speedometer)
# KM LEFT
self.kmLeftLabel = Label(text='000', font_name='Avenir.ttc', halign="right", text_size=self.size, font_size=25, pos=(278,233))
self.add_widget(self.kmLeftLabel)
# COOLANT TEMPEARATURE
self.coolantLabel = Label(text='00', font_name='hemi_head_bd_it.ttf', halign="right", text_size=self.size, font_size=27, pos=(295,-168))
self.add_widget(self.coolantLabel)
# OIL TEMPERATURE
self.oilLabel = Label(text='00', font_name='hemi_head_bd_it.ttf', halign="right", text_size=self.size, font_size=27, pos=(-385,-168))
self.add_widget(self.oilLabel)
# CLOCK
self.clock = Label(text='00:00', font_name='Avenir.ttc', font_size=27, pos=(-116,-202))
self.add_widget(self.clock)
# OUTDOOR TEMPERATURE
self.outDoorTemperatureLabel = Label(text='00.0', font_name='Avenir.ttc', halign="right", text_size=self.size, font_size=27, pos=(76,-169))
self.add_widget(self.outDoorTemperatureLabel)
# CAR DOORS
self.car = Car(pos=(257,84))
self.add_widget(self.car)
def minimizeCar(self, *args):
print("min")
anim = Animation(scale=0.5, opacity = 0, x = 400, y = 240, t='linear', duration=0.5)
anim.start(self.car)
animRpm = Animation(scale=1, opacity = 1, x = 80, y = -5, t='linear', duration=0.5)
animRpm.start(self.rpm)
def maximizeCar(self, *args):
print("max")
anim = Animation(scale=1, opacity = 1, x=257, y=84, t='linear', duration=0.5)
anim.start(self.car)
animRpm = Animation(scale=0.5, opacity = 0, x = 80, y = -5, t='linear', duration=0.5)
animRpm.start(self.rpm)
class Car(Scatter):
carImage = StringProperty("car362/car.png")
driverDoorClosedImage = StringProperty("car362/driverClosedDoor.png")
driverDoorOpenedImage = StringProperty("car362/driverOpenedDoor.png")
passangerDoorClosedImage = StringProperty("car362/passangerClosedDoor.png")
passangerDoorOpenedImage = StringProperty("car362/passangerOpenedDoor.png")
leftDoorClosedImage = StringProperty("car362/leftClosedDoor.png")
leftDoorOpenedImage = StringProperty("car362/leftOpenedDoor.png")
rightDoorClosedImage = StringProperty("car362/rightClosedDoor.png")
rightDoorOpenedImage = StringProperty("car362/rightOpenedDoor.png")
doorsStates = NumericProperty(0)
size = (286, 362)
def __init__(self, **kwargs):
super(Car, self).__init__(**kwargs)
_car = Image(source=self.carImage, size=self.size)
self.driverDoorOpened = Image(source=self.driverDoorOpenedImage, size=self.size)
self.passangerDoorOpened = Image(source=self.passangerDoorOpenedImage, size=self.size)
self.leftDoorOpened = Image(source=self.leftDoorOpenedImage, size=self.size)
self.rightDoorOpened = Image(source=self.rightDoorOpenedImage, size=self.size)
self.driverDoorClosed = Image(source=self.driverDoorClosedImage, size=self.size)
self.passangerDoorClosed = Image(source=self.passangerDoorClosedImage, size=self.size)
self.leftDoorClosed = Image(source=self.leftDoorClosedImage, size=self.size)
self.rightDoorClosed = Image(source=self.rightDoorClosedImage, size=self.size)
self.add_widget(_car)
self.add_widget(self.driverDoorOpened)
self.add_widget(self.passangerDoorOpened)
self.add_widget(self.leftDoorOpened)
self.add_widget(self.rightDoorOpened)
self.bind(doorsStates=self._update)
def _update(self, *args):
driverDoorStates = self.doorsStates&1
passangerDoorStates = self.doorsStates&4
leftDoorStates = self.doorsStates&16
rightDoorStates = self.doorsStates&64
if driverDoorStates != 0:
try:
self.remove_widget(self.driverDoorOpened)
self.add_widget(self.driverDoorClosed)
except:
pass
else:
try:
self.remove_widget(self.driverDoorClosed)
self.add_widget(self.driverDoorOpened)
except:
pass
if passangerDoorStates != 0:
try:
self.remove_widget(self.passangerDoorOpened)
self.add_widget(self.passangerDoorClosed)
except:
pass
else:
try:
self.remove_widget(self.passangerDoorClosed)
self.add_widget(self.passangerDoorOpened)
except:
pass
if leftDoorStates != 0:
try:
self.remove_widget(self.leftDoorOpened)
self.add_widget(self.leftDoorClosed)
except:
pass
else:
try:
self.remove_widget(self.leftDoorClosed)
self.add_widget(self.leftDoorOpened)
except:
pass
if rightDoorStates != 0:
try:
self.remove_widget(self.rightDoorOpened)
self.add_widget(self.rightDoorClosed)
except:
pass
else:
try:
self.remove_widget(self.rightDoorClosed)
self.add_widget(self.rightDoorOpened)
except:
pass
class Gauge(Scatter):
unit = NumericProperty(1.125)
zero = NumericProperty(116)
value = NumericProperty(10) #BoundedNumericProperty(0, min=0, max=360, errorvalue=0)
size_gauge = BoundedNumericProperty(512, min=128, max=512, errorvalue=128)
size_text = NumericProperty(10)
file_gauge = StringProperty("")
def __init__(self, **kwargs):
super(Gauge, self).__init__(**kwargs)
self._gauge = Scatter(
size=(self.size_gauge, self.size_gauge),
do_rotation=False,
do_scale=False,
do_translation=False
)
_img_gauge = Image(source=self.file_gauge, size=(self.size_gauge, self.size_gauge))
self._needle = Scatter(
size=(self.size_gauge, self.size_gauge),
do_rotation=False,
do_scale=False,
do_translation=False
)
_img_needle = Image(source="arrow512.png", size=(self.size_gauge, self.size_gauge))
self._gauge.add_widget(_img_gauge)
self._needle.add_widget(_img_needle)
self.add_widget(self._gauge)
self.add_widget(self._needle)
self.bind(pos=self._update)
self.bind(size=self._update)
self.bind(value=self._turn)
def _update(self, *args):
self._gauge.pos = self.pos
self._needle.pos = (self.x, self.y)
self._needle.center = self._gauge.center
def _turn(self, *args):
self._needle.center_x = self._gauge.center_x
self._needle.center_y = self._gauge.center_y
a = Animation(rotation=-self.value*self.unit + self.zero, t='in_out_quad',duration=0.05)
a.start(self._needle)
class requestsLoop(Thread):
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.start()
canCommands = [
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_DOORS_COMMAND'] >> 8, messageCommands['GET_DOORS_COMMAND'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_SPEED'] >> 8, messageCommands['GET_SPEED'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_KM_LEFT'] >> 8, messageCommands['GET_KM_LEFT'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_RPM'] >> 8, messageCommands['GET_RPM'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_OIL_TEMPERATURE'] >> 8, messageCommands['GET_OIL_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_FUEL_LEFT'] >> 8, messageCommands['GET_FUEL_LEFT'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_OUTDOOR_TEMPERATURE'] >> 8, messageCommands['GET_OUTDOOR_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x746, data=[0x03, 0x22, messageCommands['GET_INDOOR_TEMPERATURE'] >> 8, messageCommands['GET_INDOOR_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_COOLANT_TEMPERATURE'] >> 8, messageCommands['GET_COOLANT_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_TIME'] >> 8, messageCommands['GET_TIME'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False)
]
def run(self):
while True:
for command in self.canCommands:
bus.send(command)
time.sleep(0.005)
class BoxApp(App):
def build(self):
dashboard = Dashboard();
listener = CanListener(dashboard)
can.Notifier(bus, [listener])
return dashboard
if __name__ == "__main__":
# Send requests
requestsLoop()
_old_excepthook = sys.excepthook
def myexcepthook(exctype, value, traceback):
if exctype == KeyboardInterrupt:
print "Handler code goes here"
else:
_old_excepthook(exctype, value, traceback)
sys.excepthook = myexcepthook
# Show dashboard
BoxApp().run()
```
Алгоритм работы следующий, используется 3 потока:
1. В главном потоке работаем с графическими элементы (спидометр, тахометр, часы, температуры и др) на экране
2. Во втором потоке каждые 5 мс делаем опрос следующего датчика
3. В третьем потоке слушаем CAN шину, получив ответ парсим его и обновляем соответствующий графический элемент
Работает стабильно, самый долгий процесс в разработке был связан с рисованием дизайна. На данный момент обкатываю решение и потихоньку пишу мобильное приложение для iOS, чтобы любой мог попробовать цифровую панель приборов.
Проект цифровой панель приборов открытый. Рад буду предложениям и комментариям!
<https://github.com/aivs/blackCockpit>
### Видео работы цифровой панели приборов на базе Raspberry Pi
ОБНОВЛЕНО 24.06.2019
### Приложение на телефон Виртуальная панель приборов
Для телефона написал приложение — виртуальная панель приборов, данные от машины передаются через ELM327 Wi-Fi адаптер. Адаптер подключается в OBD2 разъем, делает запросы по CAN шине и возвращается ответы в приложение по Wi-Fi.
Приложение VAG Virtual Cockpit уже в AppStore. Пока, что только под iPhone/iPad, но Android версия планируется. Приложение решил сделать платным с минимальной символической стоимостью.
Если есть желание поддержать проект, то вот ссылка на приложение, принимаю любые замечания и предложения!
[VAG Virtual Cockpit](https://apps.apple.com/om/app/vag-virtual-cockpit/id1468103297)
 | https://habr.com/ru/post/442184/ | null | ru | null |
# C++ и Численные Методы: Приближенное интегрование по Ньютону-Котесу
**Методы Ньютона-Котеса** — это совокупность техник приближенного интегрирования, основанных на:
* разбиении отрезка интегрирования на равные промежутки;
* аппроксимации подинтегральной функции на выбранных промежутках многочленами;
* нахождении суммарной площади полученных криволинейных трапеций.
В этой статье будут рассмотрены несколько методов Ньютона-Котеса:
* метод трапеций;
* метод Симпсона;
* метод Ромберга.
Метод трапеций
--------------
Метод трапеций — простейший из рассмотренных. В качестве примера возьмем следующий интеграл:
Точность приближения зависит от числа N отрезков, на которые разбивается промежуток интегрирования. Таким образом, длина промежутка:
Площадь трапеции может быть вычислена по формуле:
Суммируя все вышесказанное, приближенное значение интеграла вычисляется по формуле:
Функция, вычисляющая интеграл методом трапеций должна принимать 4 параметра:
* границы отрезка интегрирования;
* подинтегральную функцию;
* число N промежутков разбиения.
```
double trapezoidalIntegral(double a, double b, int n, const std::function &f) {
const double width = (b-a)/n;
double trapezoidal\_integral = 0;
for(int step = 0; step < n; step++) {
const double x1 = a + step\*width;
const double x2 = a + (step+1)\*width;
trapezoidal\_integral += 0.5\*(x2-x1)\*(f(x1) + f(x2));
}
return trapezoidal\_integral;
}
```
Метод Симпсона
--------------
Метод Симпсона заключается в интегрировании интерполяционного многочлена второй степени функции f(x) с узлами интерполяции a, b и m = (a+b)/2 — параболы p(x).Для повышения точности имеет смысл разбить отрезок интегрирования на N равных промежутков(по аналогии с методом трапеций), на каждом из которых применить метод Симпсона.
Площадь параболы может быть найдена суммированием площадей 6 прямоугольников равной ширины. Высота первого из них должна быть равна f(a), с третьего по пятый — f(m), шестого — f(m). Таким образом, приближение методом Симпсона находим по формуле:
```
double simpsonIntegral(double a, double b, int n, const std::function &f) {
const double width = (b-a)/n;
double simpson\_integral = 0;
for(int step = 0; step < n; step++) {
const double x1 = a + step\*width;
const double x2 = a + (step+1)\*width;
simpson\_integral += (x2-x1)/6.0\*(f(x1) + 4.0\*f(0.5\*(x1+x2)) + f(x2));
}
return simpson\_integral;
}
```
Метод Ромберга
--------------
Пусть T(x) — приближение интеграла, полученное методом трапеций с шагом x. Получим 3 таких приближения, уменьшая размер шага в 2 раза при каждом вычислении.
Построим теперь симметричную относительно оси y параболу, проходящую через точки T(1) и T(1/2) чтоб экстраполировать полученные значения для x стремящегося к 0.
Следовательно, каждый член первого столбца R(n, 0) приближений Ромберга эквивалентен решениям полученным методом трапеций, а каждое решение второго столбца R (n, 1) — методом Симпсона. Таким образом, формулы для приближенного интегрирования методом Ромберга:
Реализация на C++:
```
std::vector> rombergIntegral(double a, double b, size\_t n, const std::function &f) {
std::vector> romberg\_integral(n, std::vector(n));
romberg\_integral.front().front() = trapezoidalIntegral(a, b, 1, f);
double h = b-a;
for(size\_t step = 1; step < n; step++) {
h \*= 0.5;
double trapezoidal\_integration = 0;
size\_t stepEnd = pow(2, step - 1);
for(size\_t tzStep = 1; tzStep <= stepEnd; tzStep++) {
const double deltaX = (2\*tzStep - 1)\*h;
trapezoidal\_integration += f(a + deltaX);
}
romberg\_integral[step].front() = 0.5\*romberg\_integral[step - 1].front() + trapezoidal\_integration\*h;
for(size\_t rbStep = 1; rbStep <= step; rbStep++) {
const double k = pow(4, rbStep);
romberg\_integral[step][rbStep] = (k\*romberg\_integral[step][rbStep-1] - romberg\_integral[step-1][rbStep-1])/(k-1);
}
}
return romberg\_integral;
}
``` | https://habr.com/ru/post/479202/ | null | ru | null |
# Workers архитектуры Clean Swift
Привет, читатель!
Ранее мы разобрали как устроен **VIP** цикл и как совершать переходы между с ценами с передачей данных. Теперь нужно разобраться как разгрузить наш **Interactor** от переизбытка логики и вынести ее часть для повторного использования другими сценами. И в этом нам помогут **Worker’ы**. Тема достаточно скромная по объему, но важная для упоминания.
Теория
------
**Worker’ы** — это вспомогательные классы/структуры (не путать с сервисами или хелперами) задача которых взять на себя часть бизнес логики **Interactor’a**. Если методы в **Interactor’е** разрастаются, значит пора выносить объемную логику в **Worker**. В **Clean Swift** их используют для работы с логикой хранения данных, с сетью, с отдельными слоями приложения и так далее. Другими словами — все объемное, низкоуровневое и не относящееся к бизнес логике приложения.
**Worker’ы** делятся на два основных типа:
1. **Локальные**, которые используются только внутри сцены
2. **Глобальные**, которые доступны для любой сцены
Локальные **Worker’ы** размещаются непосредственно внутри сцены и именуются в ее честь — **SceneNameWorker**. Глобальные **Worker’ы** размещаются в корневой директории **Workers** и именуются под свою тематику. Так же локальные **Worker’ы** могут выступать как “декораторы над глобальными”, с расширенной логикой для нужд сцены.
В случае, если используется разделение проекта на слои (**Presentation**, **Business Logic**, **Persistency**, **Network Logic**), то роль соединяющего моста между слоем **Presentation** и **Business Logic** можно отдать **Worker’ам**. Таким образом мы разгрузим **Interactor**, получим более предсказуемое поведение и удобство в повторном использовании.
Практика
--------
Работу **Worker’ов** мы рассмотрим на примере работы с сетью. У нас будет два экрана — на первом отображается список пользователей, а на втором список постов этого пользователя. Все данные будут браться по **API**. Эту задачу мы разобьем на три **Worker’a**, два локальный и один глобальный, который будет выступать точкой входа для двух других. Реализацию самих методов в статье я скрою, а кто захочет опробовать на практике, то в конце статьи будет ссылка на готовый проект.
*Данная структура проекта не является эталонной для работы с сетью и никак не отображает того, как с ней нужно работать в **Clean Swift**. Все это сделано лишь для наглядного примера роли локальных и глобальных **Worker’ов**.*
Для начала создадим глобальный **Worker** — **NetworkWorker**. Разместим его в директории **Workers**, на уровне с директорией **Scenes**. В примере ниже, есть метод **sendRequest(to:params:completion)**, который будет являться общим для локальных **Worker’ов**. Он выполняет рутинную задачу — формирует ссылку из параметров, отправляет запрос и пересылает результат в **completion**.
```
struct NetworkWorker {
// MARK: - Private Properties
private let session = URLSession.shared
// MARK: - Public Methods
/// Глобальный Worker. Отправка запроса к API
///
/// - Parameters:
/// - to: Ссылка, на которую делать запрос
/// - params: Список параметров ссылки
/// - completion: Возвращает данные или ошибку
func sendRequest(to: URL, params: [String: String], completion: @escaping (Data?, Error?) -> Void) {
// ...
}
}
```
Для первой сцены нам необходимо получить по **API** список всех пользователей. Для этого мы создаем локальный **HomeWorker**, который будет конфигурировать в себе параметры для загрузки пользователей и вызывать **sendRequest(to:params:completion)** в **NetworkWorker** с этими параметрами. Теперь в **Interactor’е** сцены нам нужно вызвать **fetchUsers(completion:)** и отправить полученные данные на обработку в **Presenter**.
При нажатии на ячейку таблицы, с именем пользователя, мы будем совершать переход и передачу выбранного пользователя на другую сцену.
```
struct HomeWorker {
// MARK: - Private Properties
private let networkWorker = NetworkWorker()
private let usersURL = URL(string: "https://jsonplaceholder.typicode.com/users")
// MARK: - Public Methods
/// Локальный Worker. Запрос к API на загрузку списка пользователей
///
/// - Parameter complete: Возвращает загруженный список пользователей
func fetchUsers(_ complete: @escaping ([User]?) -> Void) {
// ...
}
}
```
На странице с постами пользователя мы создаем **PostsWorker**, но только с методом **fetchPosts(userId:completed:)**. В него мы передаем ID пользователя, посты которого нужно загрузить. В методе формируем параметры и вызываем **sendRequest(to:params:completion)** в **NetworkWorker’е**. И по той же схеме, что и ранее, вызываем метод **fetchPosts(userId:completed:)** в **Interactor’е** сцены, передавая полученные данные в **Presenter**.
```
struct PostsWorker {
// MARK: - Private Properties
private let networkWorker = NetworkWorker()
private let postsURL = URL(string: "https://jsonplaceholder.typicode.com/posts")
// MARK: - Public Methods
/// Запрос к API на загрузку списка постов пользователя
///
/// - Parameters:
/// - userId: ID пользователя, посты которого нужно загрузить
/// - completed: Возвращает список загруженных постов
func fetchPosts(userId: Int, _ completed: @escaping ([Post]?) -> Void) {
// ...
}
}
```
Теперь вся реализация у нас вынесена в отдельные файлы, которые можно повторно использовать, при этом не нагружая бизнес логику в **Interactor’e**.
Заключение
----------
Хоть **Worker’ы** очень просты и не раскрывают никаких потаенных знаний об архитектуре, все же их использование важно в **Clean Swift**. При написании **Worker’ов** стоит не забывать про протоколы, структурные паттерны и DI. Иначе у вас быстро образуется бардак из **Worker’ов**, куда по кусочкам выносилось все, что только можно было вынести.
Вот и все. Спасибо, что дочитали до конца, ниже есть ссылка на полный проект.
### Серия статей
1. [Общее представление об архитектуре Clean Swift](https://habr.com/ru/post/453986/)
2. [Router и Data Passing в архитектуре Clean Swift](https://habr.com/ru/post/454032/)
3. Workers архитектуры Clean Swift (вы здесь)
4. [Unit тестирование в архитектуре Clean Swift](https://habr.com/ru/post/483882/)
5. Пример простого интернет-магазина на архитектуре Clean Swift
[Ссылка на проект](https://github.com/AlekseyPleshkov/CleanSwiftWorker)
Помощь в написании статьи: [Bastien](https://habr.com/ru/users/bastien/) | https://habr.com/ru/post/465991/ | null | ru | null |
# Как писать на Objective-C в 2018 году. Часть 1
Большинство iOS-проектов частично или полностью переходят на Swift. Swift — замечательный язык, и за ним будущее разработки под iOS. Но язык нераздельно связан с инструментарием, а в инструментарии Swift есть недостатки.
В компиляторе Swift по-прежнему находятся баги, которые приводят к его падению или генерации неправильного кода. У Swift нет стабильного ABI. И, что очень важно, проекты на Swift собираются слишком долго.
В связи с этим существующим проектам может быть выгоднее продолжать разработку на Objective-C. А Objective-C уже не тот, что был раньше!
В этом цикле статей мы покажем полезные возможности и улучшения Objective-C, с которыми писать код становится намного приятнее. Каждый, кто пишет на Objective-C, найдет для себя что-нибудь интересное.
`let` и `var`
-------------
В Objective-C больше не нужно явно указывать типы переменных: еще в Xcode 8 появилось расширение языка `__auto_type`, а до Xcode 8 выведение типов было доступно в Objective-C++ (при помощи ключевого слова `auto` с появлением C++0X).
Для начала добавим макросы `let` и `var`:
```
#define let __auto_type const
#define var __auto_type
```
```
// Было
NSArray \*const items = [string componentsSeparatedByString:@","];
void(^const completion)(NSData \* \_Nullable, NSURLResponse \* \_Nullable, NSError \* \_Nullable) = ^(NSData \* \_Nullable data, NSURLResponse \* \_Nullable response, NSError \* \_Nullable error) {
// ...
};
// Стало
let items = [string componentsSeparatedByString:@","];
let completion = ^(NSData \* \_Nullable data, NSURLResponse \* \_Nullable response, NSError \* \_Nullable error) {
// ...
};
```
Если раньше писать `const` после указателя на Objective-C класс было непозволительной роскошью, то теперь неявное указание `const` (через `let`) стало само собой разумеющимся. Особенно заметна разница при сохранении блока в переменную.
Для себя мы выработали правило использовать `let` и `var` для объявления всех переменных. Даже когда переменная инициализируется значением `nil`:
```
- (nullable JMSomeResult *)doSomething {
var result = (JMSomeResult *)nil;
if (...) {
result = ...;
}
return result;
}
```
Единственное исключение — когда надо гарантировать, что переменной присваивается значение в каждой ветке кода:
```
NSString *value;
if (...) {
if (...) {
value = ...;
} else {
value = ...;
}
} else {
value = ...;
}
```
Только таким образом мы получим предупреждение компилятора, если забудем присвоить значение в какой-то из веток.
И напоследок: чтобы использовать `let` и `var` для переменных типа `id`, нужно отключить предупреждение `auto-var-id` (добавить `-Wno-auto-var-id` в "Other Warning Flags" в настройках проекта).
Автовывод типа возвращаемого значения блока
-------------------------------------------
Немногие знают, что компилятор умеет выводить тип возвращаемого значения блока:
```
let block = ^{
return @"abc";
};
// `block` имеет тип `NSString *(^const)(void)`
```
Это очень удобно. Особенно если вы пишете "реактивный" код с использованием [ReactiveObjC](https://github.com/ReactiveCocoa/ReactiveObjC). Но есть ряд ограничений, при которых нужно явно указывать тип возвращаемого значения.
1. Если в блоке есть несколько операторов `return`, возвращающих значения разных типов.
```
let block1 = ^NSUInteger(NSUInteger value){
if (value > 0) {
return value;
} else {
// `NSNotFound` имеет тип `NSInteger`
return NSNotFound;
}
};
let block2 = ^JMSomeBaseClass *(BOOL flag) {
if (flag) {
return [[JMSomeBaseClass alloc] init];
} else {
// `JMSomeDerivedClass` наследуется от `JMSomeBaseClass`
return [[JMSomeDerivedClass alloc] init];
}
};
```
2. Если в блоке есть оператор `return`, возвращающий `nil`.
```
let block1 = ^NSString * _Nullable(){
return nil;
};
let block2 = ^NSString * _Nullable(BOOL flag) {
if (flag) {
return @"abc";
} else {
return nil;
}
};
```
3. Если блок должен возвращать `BOOL`.
```
let predicate = ^BOOL(NSInteger lhs, NSInteger rhs){
return lhs > rhs;
};
```
Выражения с оператором сравнения в языке C (и, следовательно, в Objective-C) имеют тип `int`. Поэтому лучше взять за правило всегда явно указывать возвращаемый тип `BOOL`.
Generics и `for...in`
---------------------
В Xcode 7 в Objective-C появились generics (точнее, lightweight generics). Надеемся, что вы их уже используете. Но если нет, то можно посмотреть [сессию WWDC](https://developer.apple.com/videos/play/wwdc2015/401/) или прочитать [здесь](https://medium.com/ios-os-x-development/generics-in-objective-c-8f54c9cfbce7) или [здесь](https://useyourloaf.com/blog/using-objective-c-lightweight-generics/).
Мы для себя выработали правило всегда указывать generic-параметры, даже если это `id` (`NSArray \*`). Таким образом можно легко отличить legacy-код, в котором generic-параметры еще не указаны.
Имея макросы `let` и `var`, мы ожидаем, что сможем использовать их в цикле `for...in`:
```
let items = (NSArray \*)@[@"a", @"b", @"c"];
for (let item in items) {
NSLog(@"%@", item);
}
```
Но такой код не скомпилируется. Скорее всего, `__auto_type` не стали поддерживать в `for...in`, потому что `for...in` работает только с коллекциями, реализующими протокол `NSFastEnumeration`. А для протоколов в Objective-C нет поддержки generics.
Чтобы исправить этот недостаток, попробуем сделать свой макрос `foreach`. Первое, что приходит в голову: у всех коллекций в Foundation есть свойство `objectEnumerator`, и макрос мог бы выглядеть так:
```
#define foreach(object_, collection_) \
for (typeof([(collection_).objectEnumerator nextObject]) object_ in (collection_))
```
Но для `NSDictionary` и `NSMapTable` метод протокола `NSFastEnumeration` итерируется по ключам, а не по значениям (нужно было бы использовать `keyEnumerator`, а не `objectEnumerator`).
Нам понадобится объявить новое свойство, которое будет использоваться только для получения типа в выражении `typeof`:
```
@interface NSArray<__covariant ObjectType> (ForeachSupport)
@property (nonatomic, strong, readonly) ObjectType jm_enumeratedType;
@end
@interface NSDictionary<__covariant KeyType, __covariant ObjectType> (ForeachSupport)
@property (nonatomic, strong, readonly) KeyType jm_enumeratedType;
@end
#define foreach(object_, collection_) \
for (typeof((collection_).jm_enumeratedType) object_ in (collection_))
```
Теперь наш код выглядит намного лучше:
```
// Было
for (MyItemClass *item in items) {
NSLog(@"%@", item);
}
// Стало
foreach (item, items) {
NSLog(@"%@", item);
}
```
**Сниппет для Xcode**
```
foreach (<#object#>, <#collection#>) {
<#statements#>
}
```
Generics и `copy`/`mutableCopy`
-------------------------------
Еще одно место, где в Objective-C отсутствует типизация, — это методы `-copy` и `-mutableCopy` (а также методы `-copyWithZone:` и `-mutableCopyWithZone:`, но их мы не вызываем напрямую).
Чтобы избежать необходимости явного приведения типов, можно переобъявить методы с указанием возвращаемого типа. Например, для `NSArray` объявления будут такими:
```
@interface NSArray<__covariant ObjectType> (TypedCopying)
- (NSArray \*)copy;
- (NSMutableArray \*)mutableCopy;
@end
```
```
let items = [NSMutableArray array];
// ...
// Было
let itemsCopy = (NSArray \*)[items copy];
// Стало
let itemsCopy = [items copy];
```
`warn_unused_result`
--------------------
Раз уж мы переобъявили методы `-copy` и `-mutableCopy`, было бы неплохо гарантировать, что результат вызова этих методов будет использован. Для этого в Clang есть атрибут [`warn_unused_result`](https://clang.llvm.org/docs/AttributeReference.html#nodiscard-warn-unused-result).
```
#define JM_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
```
```
@interface NSArray<__covariant ObjectType> (TypedCopying)
- (NSArray \*)copy JM\_WARN\_UNUSED\_RESULT;
- (NSMutableArray \*)mutableCopy JM\_WARN\_UNUSED\_RESULT;
@end
```
Для следующего кода компилятор сгенерирует предупреждение:
```
let items = @[@"a", @"b", @"c"];
[items mutableCopy]; // Warning: Ignoring return value of function declared with 'warn_unused_result' attribute.
```
`overloadable`
--------------
Немногие знают, что Clang позволяет переопределять функции в языке C (а следовательно, и в Objective-C). C помощью атрибута [`overloadable`](https://clang.llvm.org/docs/AttributeReference.html#overloadable) можно создавать функции с одинаковым названием, но с разными типами аргументов или с их разным количеством.
*Переопределяемые функции не могут отличаться только лишь типом возвращаемого значения.*
```
#define JM_OVERLOADABLE __attribute__((overloadable))
```
```
JM_OVERLOADABLE float JMCompare(float lhs, float rhs);
JM_OVERLOADABLE float JMCompare(float lhs, float rhs, float accuracy);
JM_OVERLOADABLE double JMCompare(double lhs, double rhs);
JM_OVERLOADABLE double JMCompare(double lhs, double rhs, double accuracy);
```
Boxed expressions
-----------------
В далеком 2012 году в [сессии WWDC 413](https://developer.apple.com/videos/play/wwdc2012/413/) Apple представила литералы для `NSNumber`, `NSArray` и `NSDictionary`, а также boxed expressions. Подробно о литералах и boxed expressions можно прочитать в [документации Clang](https://clang.llvm.org/docs/ObjectiveCLiterals.html).
```
// Литералы
@YES // [NSNumber numberWithBool:YES]
@NO // [NSNumber numberWithBool:NO]
@123 // [NSNumber numberWithInt:123]
@3.14 // [NSNumber numberWithDouble:3.14]
@[obj1, obj2] // [NSArray arrayWithObjects:obj1, obj2, nil]
@{key1: obj1, key2: obj2} // [NSDictionary dictionaryWithObjectsAndKeys:obj1, key1, obj2, key2, nil]
// Boxed expressions
@(boolVariable) // [NSNumber numberWithBool:boolVariable]
@(intVariable) // [NSNumber numberWithInt:intVariable)]
```
С помощью литералов и boxed expressions можно легко получить объект, представляющий число или булево значение. Но чтобы получить объект, оборачивающий структуру, нужно написать немного кода:
```
// Оборачивание `NSDirectionalEdgeInsets` в `NSValue`
let insets = (NSDirectionalEdgeInsets){ ... };
let value = [[NSValue alloc] initWithBytes:&insets objCType:@encode(typeof(insets))];
// ...
// Получение `NSDirectionalEdgeInsets` из `NSValue`
var insets = (NSDirectionalEdgeInsets){};
[value getValue:&insets];
```
Для некоторых классов определены вспомогательные методы и свойства (наподобие метода `+[NSValue valueWithCGPoint:]` и свойства `CGPointValue`), но это все равно не так удобно, как boxed expression!
И в 2015 году [Алекс Денисов](https://twitter.com/1101_debian) [сделал патч](https://lowlevelbits.org/nsvalue-and-boxed-expressions/) для Clang, позволяющий использовать boxed expressions для оборачивания любых структур в `NSValue`.
Чтобы наша структура поддерживала boxed expressions, нужно просто добавить атрибут [`objc_boxable`](https://clang.llvm.org/docs/AttributeReference.html#objc-boxable) для структуры.
```
#define JM_BOXABLE __attribute__((objc_boxable))
```
```
typedef struct JM_BOXABLE JMDimension {
JMDimensionUnit unit;
CGFloat value;
} JMDimension;
```
И мы можем использовать синтаксис `@(...)` для нашей структуры:
```
let dimension = (JMDimension){ ... };
let boxedValue = @(dimension); // Имеет тип `NSValue *`
```
Получать структуру обратно по-прежнему придется через метод `-[NSValue getValue:]` или метод категории.
В CoreGraphics определен свой макрос `CG_BOXABLE`, и boxed expressions уже поддержаны для структур `CGPoint`, `CGSize`, `CGVector` и `CGRect`.
Для остальных часто используемых структур мы можем добавить поддержку boxed expressions самостоятельно:
```
typedef struct JM_BOXABLE _NSRange NSRange;
typedef struct JM_BOXABLE CGAffineTransform CGAffineTransform;
typedef struct JM_BOXABLE UIEdgeInsets UIEdgeInsets;
typedef struct JM_BOXABLE NSDirectionalEdgeInsets NSDirectionalEdgeInsets;
typedef struct JM_BOXABLE UIOffset UIOffset;
typedef struct JM_BOXABLE CATransform3D CATransform3D;
```
Compound literals
-----------------
Еще одна полезная конструкция языка — [compound literal](https://en.cppreference.com/w/c/language/compound_literal). Compound literals появились еще в GCC в виде расширения языка, а позже были добавлены в стандарт C11.
Если раньше, встретив вызов `UIEdgeInsetsMake`, мы могли только гадать, какие отступы мы получим (надо было смотреть объявление функции `UIEdgeInsetsMake`), то с compound literals код говорит сам за себя:
```
// Было
UIEdgeInsetsMake(1, 2, 3, 4)
// Стало
(UIEdgeInsets){ .top = 1, .left = 2, .bottom = 3, .right = 4 }
```
Еще удобнее использовать такую конструкцию, когда часть полей равны нулю:
```
(CGPoint){ .y = 10 }
// вместо
(CGPoint){ .x = 0, .y = 10 }
(CGRect){ .size = { .width = 10, .height = 20 } }
// вместо
(CGRect){ .origin = { .x = 0, .y = 0 }, .size = { .width = 10, .height = 20 } }
(UIEdgeInsets){ .top = 10, .bottom = 20 }
// вместо
(UIEdgeInsets){ .top = 20, .left = 0, .bottom = 10, .right = 0 }
```
Конечно, в compound literals можно использовать не только константы, но и любые выражения:
```
textFrame = (CGRect){
.origin = {
.y = CGRectGetMaxY(buttonFrame) + textMarginTop
},
.size = textSize
};
```
**Сниппеты для Xcode**
```
(NSRange){ .location = <#location#>, .length = <#length#> }
(CGPoint){ .x = <#x#>, .y = <#y#> }
(CGSize){ .width = <#width#>, .height = <#height#> }
(CGRect){
.origin = {
.x = <#x#>,
.y = <#y#>
},
.size = {
.width = <#width#>,
.height = <#height#>
}
}
(UIEdgeInsets){ .top = <#top#>, .left = <#left#>, .bottom = <#bottom#>, .right = <#right#> }
(NSDirectionalEdgeInsets){ .top = <#top#>, .leading = <#leading#>, .bottom = <#bottom#>, .trailing = <#trailing#> }
(UIOffset){ .horizontal = <#horizontal#>, .vertical = <#vertical#> }
```
Nullability
-----------
В Xcode 6.3.2 в Objective-C появились [nullability-аннотации](https://clang.llvm.org/docs/AttributeReference.html#nullability-attributes). Разработчики Apple добавили их для импортирования Objective-C API в Swift. Но если что-то добавлено в язык, то надо постараться поставить это себе на службу. И мы расскажем, как используем nullability в Objective-C проекте и какие есть ограничения.
*Чтобы освежить знания, можно посмотреть [сессию WWDC](https://developer.apple.com/videos/play/wwdc2015/401/).*
Первое, что мы сделали, — это начали писать макросы `NS_ASSUME_NONNULL_BEGIN` / `NS_ASSUME_NONNULL_END` во всех `.m`-файлах. Чтобы не делать этого руками, мы патчим шаблоны файлов прямо в Xcode.
Мы стали также правильно расставлять nullability для всех приватных свойств и методов.
Если мы добавляем макросы `NS_ASSUME_NONNULL_BEGIN` / `NS_ASSUME_NONNULL_END` в уже существующий `.m`-файл, то сразу дописываем недостающие `nullable`, `null_resettable` и `_Nullable` во всем файле.
Все полезные предупреждения компилятора, связанные с nullability, включены по умолчанию. Но есть одно экстремальное предупреждение, которое хотелось бы включить: `-Wnullable-to-nonnull-conversion` (задается в "Other Warning Flags" в настройках проекта). Компилятор выдает это предупреждение, когда переменная или выражение с nullable-типом неявно приводится к nonnull-типу.
```
+ (NSString *)foo:(nullable NSString *)string {
return string; // Implicit conversion from nullable pointer 'NSString * _Nullable' to non-nullable pointer type 'NSString * _Nonnull'
}
```
К сожалению, для `__auto_type` (а следовательно, и `let` и `var`) это предупреждение не срабатывает. В типе, выведенном через `__auto_type`, отбрасывается nullability-аннотация. И, судя по комментарию разработчика Apple в [rdar://27062504](https://openradar.appspot.com/27062504), это поведение уже не изменится. Экспериментально замечено, что добавление `_Nullable` или `_Nonnull` к `__auto_type` ни на что не влияет.
```
- (NSString *)test:(nullable NSString *)string {
let tmp = string;
return tmp; // Нет предупреждения
}
```
Для подавления предупреждения `nullable-to-nonnull-conversion` мы написали макрос, который делает "force unwrap". Идея взята из макроса [`RBBNotNil`](https://gist.github.com/robb/d55b72d62d32deaee5fa). Но за счет поведения `__auto_type` удалось избавиться от вспомогательного класса.
```
#define JMNonnull(obj_) \
({ \
NSCAssert(obj_, @"Expected `%@` not to be nil.", @#obj_); \
(typeof({ __auto_type result_ = (obj_); result_; }))(obj_); \
})
```
Пример использования макроса `JMNonnull`:
```
@interface JMRobot : NSObject
@property (nonatomic, strong, nullable) JMLeg *leftLeg;
@property (nonatomic, strong, nullable) JMLeg *rightLeg;
@end
@implementation JMRobot
- (void)stepLeft {
[self step:JMNonnull(self.leftLeg)]
}
- (void)stepRight {
[self step:JMNonnull(self.rightLeg)]
}
- (void)step:(JMLeg *)leg {
// ...
}
@end
```
Отметим, что на момент написания статьи предупреждение `nullable-to-nonnull-conversion` работает неидеально: компилятор пока не понимает, что `nullable`-переменную после проверки на неравенство `nil` можно воспринимать как `nonnull`.
```
- (NSString *)foo:(nullable NSString *)string {
if (string != nil) {
return string; // Implicit conversion from nullable pointer 'NSString * _Nullable' to non-nullable pointer type 'NSString * _Nonnull'
} else {
return @"";
}
}
```
В Objective-C++ коде можно обойти это ограничение, использовав конструкцию `if let`, поскольку Objective-C++ допускает объявление переменных в выражении оператора `if`.
```
- (NSString *)foo:(nullable NSString *)stringOrNil {
if (let string = stringOrNil) {
return string;
} else {
return @"";
}
}
```
Полезные ссылки
---------------
Есть также ряд более известных макросов и ключевых слов, которые хотелось бы упомянуть: ключевое слово [`@available`](https://clang.llvm.org/docs/LanguageExtensions.html#objective-c-available), макросы `NS_DESIGNATED_INITIALIZER`, `NS_UNAVAILABLE`, `NS_REQUIRES_SUPER`, `NS_NOESCAPE`, `NS_ENUM`, `NS_OPTIONS` (или свои макросы для тех же атрибутов) и макрос [`@keypath`](https://github.com/jspahrsummers/libextobjc/blob/master/extobjc/EXTKeyPathCoding.h) из библиотеки libextobjc. Советуем также посмотреть остальные возможности библиотеки [libextobjc](https://github.com/jspahrsummers/libextobjc).
**Что еще почитать**<https://pspdfkit.com/blog/2017/even-swiftier-objective-c/>
<https://medium.com/@maicki/type-inference-with-auto-type-55a38ef56372>
<https://nshipster.com/__attribute__/>
<https://www.bignerdranch.com/blog/bools-sharp-corners/>
→ Код для статьи выложен в [gist](https://gist.github.com/artyom-stv/d14ee77734e170b8a7413ac6b3981aae).
Заключение
----------
В первой части статьи мы постарались рассказать об основных возможностях и простых улучшениях языка, которые существенно облегчают написание и поддержку Objective-C кода. В следующей части мы покажем, как можно еще увеличить свою продуктивность с помощью enum'ов как в Swift (они же Case-классы; они же [Алгебраические типы данных](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%B5%D0%B1%D1%80%D0%B0%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%82%D0%B8%D0%BF_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), ADT) и возможности реализации методов на уровне протокола. | https://habr.com/ru/post/431236/ | null | ru | null |
# STM32H7 — настройка тактирования без HAL
Не так давно компания STM выпустила на рынок очень мощную, по меркам микроконтроллеров, линейку кристаллов STM32H7. Что меня в ней привлекло:
* повышенная частота ядра до 400 МГц
* увеличенный объем ОЗУ, до 1 МБ
* 16 разрядный АЦП
* pin-to-pin совместимость с серий F7
Отлично подумал я, запаял на плату кристалл STM32H743IIT6 вместо STM32F746IGT6 и начал новый проект в SW4STM32.
Для расчета коэффициентов делителей и множителей системы тактирования микроконтроллера удобно пользоваться вкладкой Clock Configuration программы STM32CubeMX.
Настройки тактирования:
* внешний кварц — 8 МГц
* источник частоты для PLL1 — внешний кварц (HSE)
* делитель для PLL1 — 4 (DIVM1)
* множитель PLL1 — 400 (DIVN1)
* выходные делители — 2 (DIVP1, DIVQ1, DIVR1)
Соответственно, частота ядра (SYSCLK)- 400 МГц.
Кроме STM32CubeMX есть еще набор «STM32CubeH7 firmware package», который содержит большое количество примеров для работы с периферией для STM32H7. Именно из него была взята последовательность инициализации системы тактирования микроконтроллера.
Информация и комментарии взяты из следующих источников:
* SystemClock\_Config из STM32CubeH7 firmware package
* Reference manual STM32H743/753 and STM32H750 advanced ARM-based 32-bit MCUs
* — Datasheet STM32H743xI
Итак, начнем.
1. Включение внешнего кварца и ожидание готовности.
```
// Enable HSE
RCC->CR |= RCC_CR_HSEON;
// Wait till HSE is ready
while((RCC->CR & RCC_CR_HSERDY) == 0);
```
2. Указание источника частоты для PLL1 — внешний кварц.
```
//RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC -> PLLCKSELR |= RCC_PLLCKSELR_PLLSRC_HSE;
```
3. Значение делителя устанавливается равным 4.
```
//PLLM = 4
RCC -> PLLCKSELR &= ~RCC_PLLCKSELR_DIVM1_5; //0
RCC -> PLLCKSELR &= ~RCC_PLLCKSELR_DIVM1_4; //0
RCC -> PLLCKSELR &= ~RCC_PLLCKSELR_DIVM1_3; //0
RCC -> PLLCKSELR |= RCC_PLLCKSELR_DIVM1_2; //1
RCC -> PLLCKSELR &= ~RCC_PLLCKSELR_DIVM1_1; //0
RCC -> PLLCKSELR &= ~RCC_PLLCKSELR_DIVM1_0; //0
```
4. Множитель N и делители P, Q, R
```
//PLL1DIVR bits
//DIVN1[8:0] 0 - 8 PLLN = 400
//DIVP1[6:0] 9 - 15 PLLP = 2
//DIVQ1[6:0] 16 - 22 PLLQ = 2
//DIVR1[6:0] 24 - 30 PLLR = 2
RCC -> PLL1DIVR |= 0x0101038F;
```
5. Дробный делитель частоты PLL (если нужен)
```
// /* Configure PLL PLL1FRACN */
//__HAL_RCC_PLLFRACN_CONFIG(RCC_OscInitStruct->PLL.PLLFRACN);
RCC -> PLL1FRACR = 0;
```
6. Указание диапазона входной частоты PLL1
```
/* Select PLL1 input reference frequency range: VCI */
//__HAL_RCC_PLL_VCIRANGE(RCC_OscInitStruct->PLL.PLLRGE) ;
RCC->PLLCFGR |= RCC_PLLCFGR_PLL1RGE_3;
```
7. Указание диапазона выходной частоты PLL1
```
/* Select PLL1 output frequency range : VCO */
//__HAL_RCC_PLL_VCORANGE(RCC_OscInitStruct->PLL.PLLVCOSEL) ;
RCC->PLLCFGR &= ~RCC_PLLCFGR_PLL1VCOSEL;
```
8. Включение выходных делителей PLL1: P, Q, R
```
/* Enable PLL System Clock output. */
// __HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL1_DIVP);
//Bit 16 DIVP1EN: PLL1 DIVP divider output enable
RCC->PLLCFGR |= RCC_PLLCFGR_DIVP1EN;
/* Enable PLL1Q Clock output. */
//__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL1_DIVQ);
RCC->PLLCFGR |= RCC_PLLCFGR_DIVQ1EN;
/* Enable PLL1R Clock output. */
// __HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL1_DIVR);
RCC->PLLCFGR |= RCC_PLLCFGR_DIVR1EN;
```
9. Включение дробного делителя.
```
/* Enable PLL1FRACN . */
//__HAL_RCC_PLLFRACN_ENABLE();
RCC->PLLCFGR |= RCC_PLLCFGR_PLL1FRACEN;
```
10. Пуск PLL1 и ожидание готовности
```
/* Enable the main PLL. */
//__HAL_RCC_PLL_ENABLE();
RCC->CR |= RCC_CR_PLLON;
while((RCC->CR & RCC_CR_PLL1RDY) == 0);
```
PLL1 настроен и запущен. Теперь выбор источника частоты SYSCLK и настройка делителей шин.
11. Делитель на 2 HPRE
```
//RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
// MODIFY_REG(RCC->D1CFGR, RCC_D1CFGR_HPRE, RCC_ClkInitStruct->AHBCLKDivider);
//HPRE[3:0]: D1 domain AHB prescaler
//1000: rcc_hclk3 = sys_d1cpre_ck / 2
RCC -> D1CFGR |= RCC_D1CFGR_HPRE_3; //1
RCC -> D1CFGR &= ~RCC_D1CFGR_HPRE_2; //0
RCC -> D1CFGR &= ~RCC_D1CFGR_HPRE_1; //0
RCC -> D1CFGR &= ~RCC_D1CFGR_HPRE_0; //0
```
12. Без деления D1CPRE
```
//RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
//MODIFY_REG(RCC->D1CFGR, RCC_D1CFGR_D1CPRE, RCC_ClkInitStruct->SYSCLKDivider);
//D1CPRE[3:0]: D1 domain Core prescaler
//0xxx: sys_ck not divided (default after reset)
RCC -> D1CFGR &= ~RCC_D1CFGR_D1CPRE_3; //0
RCC -> D1CFGR &= ~RCC_D1CFGR_D1CPRE_2; //0
RCC -> D1CFGR &= ~RCC_D1CFGR_D1CPRE_1; //0
RCC -> D1CFGR &= ~RCC_D1CFGR_D1CPRE_0; //0
```
13. Задаем PLL1 как источник SYSCLK и ожидаем готовности
```
//RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
//MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_ClkInitStruct->SYSCLKSource);
//SW[2:0]: System clock switch
//011: PLL1 selected as system clock (pll1_p_ck)
RCC->CFGR &= ~RCC_CFGR_SW_2; //0
RCC->CFGR |= RCC_CFGR_SW_1; //1
RCC->CFGR |= RCC_CFGR_SW_0; //1
while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL1);
```
14. Делитель на 2 D1PPRE
```
//D1PCLK1 Configuration
//RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
//MODIFY_REG(RCC->D1CFGR, RCC_D1CFGR_D1PPRE, RCC_ClkInitStruct->APB3CLKDivider);
//Bits 6:4 D1PPRE[2:0]: D1 domain APB3 prescaler
//100: rcc_pclk3 = rcc_hclk3 / 2
RCC -> D1CFGR |= RCC_D1CFGR_D1PPRE_2;
RCC -> D1CFGR &= ~RCC_D1CFGR_D1PPRE_1;
RCC -> D1CFGR &= ~RCC_D1CFGR_D1PPRE_0;
```
15. Делитель на 2 D2PPRE1
```
//PCLK1 Configuration
//RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
//MODIFY_REG(RCC->D2CFGR, RCC_D2CFGR_D2PPRE1, (RCC_ClkInitStruct->APB1CLKDivider));
//Bits 6:4 D2PPRE1[2:0]: D2 domain APB1 prescaler
//100: rcc_pclk1 = rcc_hclk1 / 2
RCC -> D2CFGR |= RCC_D2CFGR_D2PPRE1_2;
RCC -> D2CFGR &= ~RCC_D2CFGR_D2PPRE1_1;
RCC -> D2CFGR &= ~RCC_D2CFGR_D2PPRE1_0;
```
16. Делитель на 2 D2PPRE2
```
//PCLK2 Configuration
//RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
//MODIFY_REG(RCC->D2CFGR, RCC_D2CFGR_D2PPRE2, (RCC_ClkInitStruct->APB2CLKDivider));
//Bits 10:8 D2PPRE2[2:0]: D2 domain APB2 prescaler
//100: rcc_pclk2 = rcc_hclk1 / 2
RCC -> D2CFGR |= RCC_D2CFGR_D2PPRE2_2;
RCC -> D2CFGR &= ~RCC_D2CFGR_D2PPRE2_1;
RCC -> D2CFGR &= ~RCC_D2CFGR_D2PPRE2_0;
```
17. Делитель на 2 D3PPRE
```
//D3PCLK1 Configuration
//RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
//MODIFY_REG(RCC->D3CFGR, RCC_D3CFGR_D3PPRE, (RCC_ClkInitStruct->APB4CLKDivider) );
//Bits 6:4 D3PPRE[2:0]: D3 domain APB4 prescaler
//100: rcc_pclk4 = rcc_hclk4 / 2
RCC -> D3CFGR |= RCC_D3CFGR_D3PPRE_2;
RCC -> D3CFGR &= ~RCC_D3CFGR_D3PPRE_1;
RCC -> D3CFGR &= ~RCC_D3CFGR_D3PPRE_0;
```
Для того чтобы убедиться, что конфигурирование и запуск прошли успешно используем выход микроконтроллера MCO2. На этом выходе должна быть частота 26.666 МГц при делителе выхода 15.
Отлично. Частота присутствует, значит все сделано правильно. | https://habr.com/ru/post/427435/ | null | ru | null |
# Что такое fluent-сеттер
Сегодня в PhpStorm я создал приватную переменную и заметил, что IDE предлагает мне создать два вида сеттера: обычный setter и fluent setter.
Термин «fluent setter» мне раньше не встречался, поэтому я создал оба варианта.
```
/* PHP */
class Foo {
private $var;
// Обычный setter
public function setVar($var) {
$this->var = $var;
}
// Это fluent setter
public function setVar($var) {
$this->var = $var;
return $this;
}
}
```
Ага, значит, **fluent setter, — это сеттер, который возвращает сам объект**.
Какая глупость. Кому может понадобиться конструкция вида
```
$object = $object->setVar(1);
// Это же то же самое, что и просто
$object->setVar(1);
// И даже если создавать новую переменную, польза сомнительная
$sameObject = $object->setVar(1);
```
Это на первый взгляд.
Чуть позже я догадался. Это то, что называют чейнингом в jQuery. Благодаря возвращённому объекту, мы можем сразу применить следующий сеттер.
```
/* Javascript */
$('#elementId').val(13).css('font-size', '20px').appendTo(element2);
// И в столбик мне нравится:
$('#elementId')
.val(13)
.css('font-size', '20px')
.appendTo(element2);
```
Fluent-сеттеры придуманы, чтобы код стал понятнее и чище.
Да, в Javascript это заметно. В Java и PHP — тоже. Тем более, там и так активно используются функции-сеттеры, так почему бы не делать их в fluent-варианте.
```
/* php */
$car->setColor('#f00')->setWeight('1200')->setPower(55000);
$car
->setColor('#f00')
->setWeight('1200')
->setPower(55000);
```
в Python, конечно, можно написать функции-сеттеры, но польза от них не очевидная. Мне лично будет удобнее использовать обычный питоновский сеттер, который выглядит не как функция, а как оператор присваивания. Делать же сеттеры вида set\_var() в Python, на мой взгляд, противоречит питоновским идеям простоты.
```
# python
# обычные @property
car.color = '#f00'
car.weight = 1200
car.power = 55000
# fluent-сеттеры, которые выглядят как функции. Так разве лучше? Лично меня смущает.
car.color('#f00').weight('1200').power(55000)
# Да и так тоже не лучше...
car.set_color('#f00').set_weight('1200').set_power(55000)
# Если писать в столбик, то надо слэши добавлять, и это ещё страшнее выглядит.
car.set_color('#f00') \
.set_weight('1200') \
.set_power(55000)
```
Позже я нашёл [статью](https://en.wikipedia.org/wiki/Fluent_interface) про Fluent Interface, где мне попался более приятный глазу [пример на python](https://en.wikipedia.org/wiki/Fluent_interface#Python).
Минутка самообразования закончена. | https://habr.com/ru/post/429020/ | null | ru | null |
# Использование XML-RPC в Drupal. Quickstart
В этой статье я расскажу как можно использовать эту замечательную технологию в не менее замечательной системе Друпал. В качестве примера попытаемся сделать систему, позволяющую отправлять сообщения на сайты под управлением Drupal из вашего jabber-клиента.
Чтобы сэкономить время, применим следующие инструменты:
* Drupal 6
* Services (модуль для Drupal 6)
* xmppphp — для создания jabber бота (для тестового приложения вполне сгодится)
* xmlrpc — упростим себе разработку
* jid — под которым будет работать бот
* небольшой вспомогательный класс
**Drupal**
Устанавливаем Друпал. После установки, включаем модуль Blog. Последующие сообщения будем размещать в блогах пользователей по следующей схеме. Человек добавляет бота себе в ростер, затем отправляет боту сообщение. Бот смотрит: есть ли такой пользователь (с таким же почтовым адресом)? Если есть, то добавляет сообщение от имени этого пользователя. Если таких нет, то регистрирует нового юзера и добавляем от его имени сообщение.
*Друпал живёт по адресу* [drupal.org](http://drupal.org/)
**Services**
Нужно заметить, что на страничке модуля, на момент написания статьи, рекомендован к использованию development snapshot. Его и установим. После установки, включаем всё, что касается сервисов. Модуль имеет различные возможности аутентификации. Оставляю выбор метода на ваш вкус, однако следует учесть, что в примере использовалась авторизация на основе имени и пароля пользователя.
*Модуль распологается здесь* [drupal.org/project/Services](http://drupal.org/project/Services)
**Jabber Bot**
C этим пунктом вопросов будет меньше всего, т.к. мы возьмём бота из примера. Берём любого консольного бота (их там аж две штуки) и дописываем несколько строк, которые будут инклудить наш вспомогательный класс.
Проект уютненько расположился на гугле-коде, и найти его можно
по этой ссылке: [code.google.com/p/xmpphp](http://code.google.com/p/xmpphp/)
Скачиваем, распаковываем, запускаем бота, используя jid для авторизации.
**Start the dance**
Друпал готов, сервисы запущены, бот приветливо ждёт новых сообщений. Теперь очередь дошла до программирования. Напишем несколько функций, которые помогут немного упростить задачу.
Создадим небольшой класс и тут нам понадобится библитека xmlrpc:
> `1. require\_once("xmlrpc/xmlrpc.inc");`
В конструкторе класса устанавливаем соединение:
> `1. function \_\_construct() {
> 2. $this->send\_message('system.connect');
> 3. }`
И соответственно, неплохо бы прописать отправку сообщений:
> `1. function send\_message($method, $message = array()) {
> 2. $XMLRPC = new xmlrpc\_client(\_PATH, \_SERV, \_PORT);
> 3. $XMLRPC ->return\_type = "phpvals";
> 4.
> 5. $msg = new xmlrpcmsg($method, $message);
> 6. $ret = $XMLRPC->send($msg);
> 7.
> 8. if(!$ret->faultCode()) {
> 9. $answer = $ret->value();
> 10. if (isset($answer['sessid']) && !isset(self::$session)) {
> 11. self::$session = $answer['sessid'];
> 12. }
> 13. return $ret->value();
> 14. } else return $ret->faultString();
> 15. }`
Теперь добавляем ноду. Для этого в качестве параметров передадим имя пользователя и сообщение для отправки:
> `1. function node\_save($user, $message) {
> 2. $node = array (
> 3. 'title' => '\*',
> 4. 'body' => $message,
> 5. 'type' => 'blog',
> 6. 'promote' => 1,
> 7. 'uid' => 0 ,
> 8. 'name' => 'Anonymouse' ,
> 9. );
> 10. $msg = array(
> 11. php\_xmlrpc\_encode( self::$session ),
> 12. php\_xmlrpc\_encode( $node )
> 13. );
> 14. return $this->send\_message('node.save', $msg);
> 15. }`
Вот, в общем-то, и всё, что было необходимо сделать. Возможно наблюдательный хаброюзер заметит, что параметр $user ни коим образом не был задействован. Я решил оставить работу с пользователями на совесть читателей. Но если кому-нибудь захочется поскорее прикрутить что-то похожее к своему блогу, то весь класс можно найти здесь: [github.com/mcnet/drupal.xmlrpc.class](http://github.com/mcnet/drupal.xmlrpc.class)
Удачи!
ЗЫ Я бы не рекомендовал использовать класс без некоторой доработки. В данный момент весь код представлен в качестве ознакомительного примера. | https://habr.com/ru/post/65714/ | null | ru | null |
# Массивы bash
*Предлагаю вашему вниманию перевод статьи Митча Фрейзера (Mitch Frazier) "[Bash Arrays](http://www.linuxjournal.com/content/bash-arrays)" с сайта linuxjournal.com.*
Если вы используете «стандартную» оболочку \*NIX-системы, возможно, вы не знакомы с такой полезной особенностью bash как массивы. Хотя массивы в bash не так круты, как в P-языках (Perl, Python и PHP) и других языках программирования, они часто бывают полезны.
Bash-массивы имеют только численные индексы, но они не обязательны к использованию, то есть вы не должны определять значения всех индексов в явном виде. Массив целиком может быть определен путем заключения записей в круглые скобки:
```
arr=(Hello World)
```
Отдельные записи могут быть определены с помощью знакомого всем синтаксиса (от Бейсика (да простит меня Дейкстра — прим. переводчика) до Фортрана):
```
arr[0]=Hello
arr[1]=World
```
Правда, обратное выглядит сравнительно более уродливо. Если нужно обратиться к определенной записи, тогда:
```
echo ${arr[0]} ${arr[1]}
```
Из страницы man:
"*Фигурные скобки нужны для предотвращения конфликтов при разворачивании полных путей к файлам.*"
Кроме того, доступны следующие странноватые конструкции:
```
${arr[*]} # Все записи в массиве
${!arr[*]}# Все индексы в массиве
${#arr[*]}# Количество записей в массиве
${#arr[0]}# Длина первой записи (нумерация с нуля)
```
${!arr[\*]} — сравнительно новое дополнение в bash и не является частью оригинальной реализации. Следующая конструкция демонстрирует пример простого использования массива. Обратите внимание на "[index]=value", это позволяет назначить конкретное значение конкретному номеру записи.
```
#!/bin/bash
array=(one two three four [5]=five)
echo "Array size: ${#array[*]}" # Выводим размер массива
echo "Array items:" # Выводим записи массива
for item in ${array[*]}
do
printf " %s\n" $item
done
echo "Array indexes:" # Выводим индексы массива
for index in ${!array[*]}
do
printf " %d\n" $index
done
echo "Array items and indexes:" # Выводим записи массива с их индексами
for index in ${!array[*]}
do
printf "%4d: %s\n" $index ${array[$index]}
done
```
Запуск скрипта породит следующий вывод:
Array size: 5
Array items:
one
two
three
four
five
Array indexes:
0
1
2
3
5
Array items and indexes:
0: one
1: two
2: three
3: four
5: five
Обратите внимание, что символ "@" может быть использован вместо "\*" в конструкциях типа {arr[\*]}, результат будет одинаковым за исключением разворачивания записи в кавычках. "$\*" и "$@" выведут записи в кавычках, "${arr[\*]}" вернет каждую запись как одно слово, "${arr[@]}" вернет каждую запись в виде отдельных слов.
Следующий пример покажет, как кавычки и конструкции без кавычек возвращают строки (особенно важно, когда в этих строках есть пробелы):
```
#!/bin/bash
array=("first item" "second item" "third" "item")
echo "Number of items in original array: ${#array[*]}"
for ix in ${!array[*]}
do
printf " %s\n" "${array[$ix]}"
done
echo
arr=(${array[*]})
echo "After unquoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
printf " %s\n" "${arr[$ix]}"
done
echo
arr=("${array[*]}")
echo "After * quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
printf " %s\n" "${arr[$ix]}"
done
echo
arr=("${array[@]}")
echo "After @ quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
printf " %s\n" "${arr[$ix]}"
done
```
Вывод при запуске:
Number of items in original array: 4
first item
second item
third
item
After unquoted expansion: 6
first
item
second
item
third
item
After \* quoted expansion: 1
first item second item third item
After @ quoted expansion: 4
first item
second item
third
item | https://habr.com/ru/post/511608/ | null | ru | null |
# Hyper-V — дитя маркетинга или реальная альтернатива?
Привет, Хабр! Сейчас я задам вам вопрос, а вы задумайтесь: Что, очень популярное и когда-то вызывавшее трепет лично у вас, сегодня вспоминается только для «поностальгировать»? Наверняка, кто-то вспомнит Dendy или Super Nintendo, а некоторые свой пейджер. Так вот, к чему это я… Есть выражение «ничто не вечно». В сегодняшней статье рассмотрим, действительно ли это так в сфере разработки и стоит отказываться от VMWare в пользу Hyper-V в вопросе виртуализации? А также затронем плюсы обеих платформ и процесс перехода с одной на другую. Заглядывайте под кат!
Передаю слово автору.
> #### Дисклеймер:
>
>
>
> 1. Данная статья носит информативный характер и не преследует желание похайпить, а просто желание поделиться своей историей, которая, возможно, будет кому-нибудь полезна. Некоторые вещи сугубо индивидуальны, а суждения — личные.
> 2. Нет, я не продался МS. Я просто долго искал статьи подобного плана как пищу для размышлений, но их не было. Пришлось делать самому.
> 3. Блог МS — у меня нет инвайта, а товарищам идея статьи понравилась, и они предложили ее выложить.
> 4. PR-а продукта не будет, будет рассказ про живое тестирование/внедрение.
>
**Лирическое отступление**Мы живем в удивительном времени. А, может быть, и в ужасном, смотря с какой стороны посмотреть. Сейчас возможно то, что буквально лет 20 назад я читал в фантастических книжках: будущее наступившее через 200–500–1000 лет. Полеты на другие планеты, выход за пределы нашей солнечной системы, «цветущие яблони на Марсе» — все это казалось далеким и несбыточным.
А теперь у нас есть (ну практически есть) космический ядерный двигатель, план полететь на Марс в 2024 году и спутник за пределами нашей солнечной системы.
Так, собственно, к чему я это все веду. Это я к тому, что все это стало возможным благодаря (или вопреки) стремительно развивающимся компьютерным технологиям. Об одной из таких технологий сейчас и поговорим.
Эпиграф
-------
Жила была одна компания. Ни большая, ни маленькая, ни высокая, ни низкая. Такой прям вылитый средний бизнес. Жила она себе с несколькими стойками оборудования, старого, от матери доставшегося. И наступил момент все это хозяйство обновлять. Посчитали товарищи стоимость оборудования, подумали, да надумали внедрять виртуализацию. А год был давний, из представителей славного рода универсальных виртуализаций только VMWare и была. В общем ее и внедрили. Шло время, менялись задачи, росли другие представители славного рода виртуализации. И пришло время снова выбирать себе представителя…
Главный вопрос ИТ-профессионала – «Зачем?»
(или «А нафига?»)
--------------------------------------------------------------
Позвольте представиться. Меня зовут Антон и я руковожу отделом инфраструктурных решений в одном их крупных российских ретейлеров. Как и в любой уважающей себя организации у нас используется виртуализация и, конечно же, наша всеми «любимая» 1С. Внедряли мы VMware давно, жили с ней, в принципе, неплохо (хотя историй добавивших мне седых волос тоже хватает), но, как и при любом развитии периодически приходится осматриваться вокруг, чтобы узнавать об альтернативных решениях.
А началась наша история перехода с того, что я увидел Hyper-V в одном углу вместе с VMware у квадранта Gartner. Тут-то я и призадумался. По итогу раздумий получилась вот такая табличка «за/против» перехода. А еще знаменитые косяки VMware с CBT… Прямо мнямка. Да еще и два раза в двух разных релизах. Прям огонь!
**Минутка хайпа**Тут же вспоминается анекдот:
«Как узнать, что человек ярый веган. Никак. Он сам вам об этом расскажет.»
Так же и тут — как узнать ярого красноглазика. Никак. Он сам расскажет, что Linux — это божья благодать, а Windows — порождение князя тьмы.
Хейтеры 2x354 тут же встанут в стойку и, брызгая жидкостями, начнут рассказывать, как обновления Microsoft ломают к чертям вообще всю ОС. Это да, тут спорить не буду, есть у товарищей любовь к таким вот веселым подарочкам. Но в целом, процесс эволюции на мой взгляд у компании Microsoft доведен до совершенства. Революция — это не их, а вот эволюция — конек. И каждый выбирает то, что ему ближе.
Сразу оговорюсь — сравнение «by feature» тоже было, только в жизни никто «в здравом уме и крепкой памяти» не будет строить кластера по предельным значениям. Да и похожи они на самом деле практически как братья близнецы, а принципиальной разницы между тем, сколько сотен ядер можно отдать одной виртуальной машине я лично не вижу.
**Минута холивара**Почему «Killer feature» от VMware во многом просто маркетинг?
Fault Tolerance. Серьезно? Вы читали ограничения? Вы реально это используете в продакшене? Если да, то мне вас искренне по-человечески жаль… За все время ни разу не видел, чтобы это кому-нибудь реально пригодилось…
Проброс USB и PCI-девайсов. Тоже очень спорный момент. Эти вещи лишают виртуалку основного преимущества виртуализации — свободной миграции между хостами. Проброс PCI мы использовали, но как только смогли отказаться — облегченно выдохнули. Для проброса USB уже давным-давно придуманы и сделаны как софтовые, так и аппаратные решения. Сильно проще.
Кэширование данных на чтение на локальные SSD. Да, когда вышла очень радовался этой возможности. Но в реальности прирост не увидел даже на синтетических данных. А в рабочей среде периодически ловил дикие зависания этой системы (тут я не утверждаю, что вина системы —возможно это мои кривые руки что-то не так настроили). И вишенка на торте: кэширует эта система только блоки определенного размера, и надо потратить много времени на сбор информации о размере запроса к диску, думать какая именно виртуалка должна быть приоритетна в использовании этой технологии.
Зато у Hyper-V есть штатная возможность уменьшить диск. Знаете, сколько раз я мечтал о таком в VMware? Гораздо больше чем можно себе это представить.
Да, еще момент. Переход на другой гипервизор — это индивидуальное решение, но вот мой список стоп-факторов, при наличии которых на мой взгляд точно не стоит переходить на Hyper-V. Ну или очень внимательно все продумать и протестировать.
1. У вас основная ОС на Linux-серверах.
2. Вам нужно запускать экзотику.
3. Вам нужны готовые виртуальные сервера от вендеров (думаю это просто вопрос времени).
4. Вы не любите Microsoft.
5. VMware вы получили на халяву вместе с оборудованием.
#### Табличка размышлений
| За переход на Hyper-V | Против перехода на Hyper-V |
| --- | --- |
| Сокращение расходов на лицензии VMware | Известность платформы VMware |
| На базе этой же платформы построен Azure | Размер дистрибутива (спойлер: Nano Server не является аналогом esxi — это немного другая идеология и позиционирование) |
| Интересная сетевая виртуализация | Простая схема лицензирования |
| Репликация на другие СХД виртуалок штатными методами | Поддержка большого числа разных ОС |
| Бонусы при покупке комплекта для построения виртуализации (набор CIS, в который входят Windows Datacenter + System Center) | VMware уже работает |
| Различные плюшки при разворачивании Windows-серверов | Нет поддержки именно гипервизора как отдельного продукта |
| Можно уменьшать диски на лету | VDI тут можно использовать только для лабы/тестов. Для продакшена это не подходит |
| Более оперативная поддержка новых версий Windows | Наличие интересных законченных решений для виртуализации, когда ты у одного вендора покупаешь и железо и софт, и получаешь одну консоль управления и одно окно техподдержки |
| Это Microsoft | Это Microsoft |
«Прыжок веры»
-------------
Думал и гадал бы я еще долго, но тут сошлись звезды, и мы обновили парк серверов. А старые остались, причем неплохие, только уже медленные по нынешним меркам и к тому же морально устаревшие. И было принято стратегическое решение сделать ферму для разработки на базе Hyper-V. Перетащили сервера на новую площадку, обновили все прошивки серверов и понеслась.
**План тестирования был прост:**
1. Берем сервер.
2. Устанавливаем на него esxi. Ничего не меняем, настройки по умолчанию.
3. Разворачиваем виртуальную машину.
4. Производим тесты 5 раз:
a) Для 1С тест Гилева.
b) Для SQL — скрипт на запись.
5. Настраиваем по Best Practice’s.
6. Производим тесты 5 раз:
a) Для 1С тест Гилева.
b) Для SQL — скрипт на запись.
7. Устанавливаем Hyper-V. Ничего не меняем, настройки по умолчанию.
8. Разворачиваем виртуальную машину.
9. Производим тесты 5 раз:
a) Для 1С тест Гилева.
b) Для SQL — скрипт на запись.
10. Настраиваем по Best Practice’s.
11. Производим тесты 5 раз:
a) Для 1С тест Гилева.
b) Для SQL — скрипт на запись.
12. Ставим на физическую машину Windows Server, настраиваем по Best Practice’s и проводим тесты.
13. Сравниваем и думаем.
*Оборудование: Dell FC 630, 2 процессора Intel Xeon E5-2643 v4 (чисто под 1С), 512Гб памяти.
Диски: san-сеть на базе Dell SC 200 с Read-Intensive SSD.*
**Получили вот такие результаты:**
| VMWare без Best Practices | Тест Гилева | Тест SQL |
| --- | --- | --- |
| 1 | 22.42 | 12.2 |
| 2 | 18.6 | 17.51 |
| 3 | 18.12 | 7.12 |
| 4 | 26.74 | 7.18 |
| 5 | 26.32 | 4.22 |
| VMWare с Best Practices | Тест Гилева | Тест SQL |
| 1 | 26.46 | 4.28 |
| 2 | 26.6 | 6.38 |
| 3 | 26.46 | 4.22 |
| 4 | 26.46 | 6.56 |
| 5 | 26.6 | 4.2 |
| HyperV без Best Practices | Тест Гилева | Тест SQL |
| 1 | 27.17 | 4.32 |
| 2 | 26.46 | 6.08 |
| 3 | 26.04 | 4.24 |
| 4 | 26.18 | 5.58 |
| 5 | 25.91 | 6.01 |
| HyperV с Best Practices | Тест Гилева | Тест SQL |
| 1 | 26.18 | 6.02 |
| 2 | 27.62 | 6.04 |
| 3 | 26.46 | 6.2 |
| 4 | 26.74 | 4.23 |
| 5 | 26.74 | 6.02 |
| Физика | Тест Гилева | Тест SQL |
| 1 | 35.97 | 4.06 |
| 2 | 32.47 | 4.04 |
| 3 | 31.85 | 6.14 |
| 4 | 32.47 | 5.55 |
| 5 | 32.89 | 5.43 |
#### Легенда
Тест Гилева — больше значит лучше, абстрактные «попугаи».
Тест SQL — меньше значит лучше, время исполнения.
**Что настраивали:**
**1. Шаги по подготовке хоста DELL Poweredge 630.**
1.1. [Настраиваем](http://en.community.dell.com/techcenter/virtualization/w/wiki/3033.dell-vmware-vsphere-performance-best-practices) хост по рекомендациям от DELL
1.1.1. Включить Processor Settings -> Virtualization Technology — включено.
1.1.2. Включить Processor Settings -> Logical Processor — включено.
1.1.3. Включить System Profile Settings -> Turbo Boost (в документации Turbo Mode) — включено.
1.1.4. Отключить Memory Setting -> Node Interleaving (включает NUMA) — отключено.
1.1.5. Включить Power Management -> Maximum Performance — похоже включено.
1.1.6. Отключить ненужные девайсы в Integrated Devices — не трогал.
1.1.7. Отключить System Profile Settings -> С1E — отключено.
1.1.8. Включить Processor Settings -> Hardware Prefetcher — включено.
1.1.9. Включить Processor Settings -> Adjacent Cache Line Prefetch — включено.
1.1.10. Включить Processor Settings -> DCU Streamer Prefetcher — включено.
1.1.11. Включить Processor Settings -> Data Reuse — не нашел.
1.1.12. Включить Processor Settings -> DRAM Prefetcher — не нашел.
1.2 [Настраиваем](http://en.community.dell.com/techcenter/extras/m/white_papers/2043800) хост по рекомендации
1.2.1 Настроить Fibre Chanel HBA.
1.2.1.1 При загрузке хоста зайти в QLogic Fast!UTIL (CTRL+Q).
1.2.1.2 Выбрать первый порт.
1.2.1.3 Сбросить настройки Configuration Settings -> Restore Default Settings.
1.2.1.4 Включить Configuration Settings -> Adapter Settings -> Host Adapter BIOS -> Host Adapter BIOS -> Enable.
1.2.1.5 Включить Configuration Settings -> Adapter Settings -> Host Adapter BIOS -> Connection Options -> 1.
1.2.1.6 Включить Configuration Settings -> Advanced Adapter Settings -> Enable LIP Reset -> Yes.
1.2.1.7 Включить Configuration Settings -> Advanced Adapter Settings -> Enable LIP Full Login -> Yes.
1.2.1.8 Включить Configuration Settings -> Advanced Adapter Settings -> Login Retry Count -> 60.
1.2.1.9 Включить Configuration Settings -> Advanced Adapter Settings -> Port Down Retry Count -> 60.
1.2.1.10 Включить Configuration Settings -> Advanced Adapter Settings -> Link Down Timeout -> 30.
1.2.1.11 Настроить второй порт по пунктам 1.2.1.3 – 1.2.1.10.
**2. Шаги по тестированию на платформе VMware без best practices.**
2.1 Устанавливаем VMware 5.5 со всеми апдейтами.
2.2 Делаем необходимые настройки на VMware (в кластер не включаем, тестим отдельно).
2.3 Устанавливаем Windows 2016 и все обновления.
2.4 Устанавливаем «1С: Предприятие». Настраиваем, если нужно пока ставим по дефолту, версия 1С — 8.3.10. (последняя).
2.5 На отдельной машине устанавливаем Windows 2016 с сервером SQL 2016 — со всеми апдейтами.
2.6 Проводим тесты (5 раз).
**3. Шаги по тестированию на платформе VMware по [best practices](http://www.vmware.com/pdf/Perf_Best_Practices_vSphere5.5.pdf).**
3.1.1 Поместить swap-файл на SSD диск. Cluster -> Swap file location -> Store the swap file in the same directory as VM. Configuration -> VM Swapfile location -> Edit.
3.1.2 Рекомендуется включить vSphere Flash Infrastructure layer – не знаю, насколько это реализуемо в наших реалиях.
3.1.3 Настроить SAN Multipathing через Host -> Configuration -> Storage -> Manage Paths -> Path Selection -> Round Robin.
3.1.4 Включить Host -> Configuration -> Power management -> Properties -> High Perfomance.
3.2 Настраиваем VM согласно рекомендациям:
3.2.1 Используем paravirtual диски: VM -> SCSI Controller -> Change Type -> Paravirtual.
3.2.2 Желательно использовать Thick provision eager zeroed.
3.2.3 Включаем VM -> Options -> CPU/MMU Virtualization -> Use Intel VTx for instruction set and Intel EPT for MMU Virtualization.
3.2.4 Отключаем VM BIOS -> Legacy diskette, VM BIOS -> Primary Mater CD ROM.
**4. Шаги по тестированию на платформе Windows Server без best practices:**
4.1 Устанавливаем Windows Server 2016 Datacenter на хост и все обновления.
4.2 Делаем необходимые настройки на хосте.
4.3 Устанавливаем виртуальную машину с Windows и все обновления.
4.4 Устанавливаем «1С: Предприятие». Настраиваем, если нужно пока ставим по дефолту, версия 1С — 8.3.10 (последняя).
4.5 На отдельной машине устанавливаем Windows Server 2016 с сервером SQL 2016 со всеми апдейтами.
**5. Шаги по тестированию на платформе Windows Server по best practices**
*Best practices изложены [тут](http://en.community.dell.com/techcenter/extras/m/white_papers/20438008), [тут](http://en.community.dell.com/techcenter/extras/m/white_papers/20437917) и [тут](http://en.community.dell.com/techcenter/extras/m/white_papers/20437923).*
5.1 Настраиваем Host согласно рекомендациям:
5.1.1 [Активировать](https://docs.microsoft.com/ru-ru/windows-server/get-started/mpio-on-nano-server) MPIO:
`Enable-WindowsOptionalFeature – Online – FeatureName MultiPathIO
(Get-WindowsOptionalFeature – Online – FeatureName "MultiPathIO").State`
5.2 Настраиваем VM согласно рекомендациям:
5.2.1 Используем Generation2 VM.
5.2.2 Используем fixed диски в VM.
Если жизнь на Марсе?
--------------------
Вроде жизнь удалась, тесты показывают, что расчеты и ставки были верны и теперь наступит та самая искомая нирвана… Так я думал и надеялся до тех пор, пока мы в тестовом режиме не поставили кластер для разработчиков.
Врать не буду, установка действительно происходит просто и незатейливо. Система сама проверяет все, что ей нужно для счастья, и если чего нет, то отправляет вас за этим в ближайший гастроном показывает подробный отчет о том, что не так и даже дает советы по устранению проблемы. В этом плане мне продукт от Microsoft понравился гораздо больше.
Тут же вспомнилась история о пятидневной переписке с техподдержкой VMware о проблеме при переходе на 5.5. Оказалось, веселая штука. Если ты заводишь на SQL-сервере отдельную учетную запись для подключения vSphere, то пароль у нее должен быть не длиннее 14 символов (или 10, сейчас уже не помню), ибо дальше система банально обрезает и выкидывает как ненужную часть кусок пароля. Действительно, вполне себе обоснованное поведение.
Но все веселье началось позже. Один сервер вылетел и отказался видеть сетевую карту (в итоге ОС тут оказалась не при чем). Потом сервера начали терять кворум. Потом сервера хаотически стали вылетать из кластера. VMM толком не работал и зачастую просто не мог подсоединится к ферме. Потом сервера стали вставать на паузу в кластере. Потом при миграции машины стали видеться на двух хостах. В целом ситуация была близка к катастрофе, как мы думали.
Но, собравшись с духом, мы, все-таки, решили повоевать. И знаете, что? Все получилось. И оказалось, что проблемы с сетевой картой были аппаратные, проблема с кластером решились после правильной настройки сети. А после того, как мы переставили хостовые ОС и VMM на английские версии вообще все стало хорошо. И тут мне стало грустно… 2017 год, а все еще нужно ставить английскую Windows чтобы было меньше проблем. Это epic fail на мой взгляд. Зато бонусом получили гораздо более простой поиск по тексту ошибок.
В итоге кластер завелся, VMM работает корректно, а мы начали раздавать виртуалки пользователям.
Кстати, отдельного котла в аду заслуживает тот, кто придумал интерфейс и логику VMM… Сказать, что он непонятный — это ничего не сказать. При первом открытии у меня появилось полное ощущение что я смотрю на приборную доску корабля пришельцев. Вроде формы знакомые, но понимания что тут что и зачем нет никакого. Хотя возможно через много лет я привыкну. Или просто заучу действия как обезьянка.
Каково это, когда все-таки завел трактор?
-----------------------------------------
В целом эмоции и ощущения у меня от перехода положительные. Шаблоны и их возможности для ОС от Microsoft не идут ни в какое сравнение с аналогами у VMware. Они прям очень удобные, с огромным количеством всяких свистелок и рюшечек, которые в целом достаточно толковые. Пока гоняем кластер для разработчиков, привыкаем к новой жизни.
Еще очень сильно, но очень приятно удивил вопрос миграцией машин из VMWare. Изначально я читал форумы, искал софт, думал как это будет. Оказалось, за меня уже все придумали. Мы в два счета подключили в VMM vCenter и прямо из VMM сказали «дорогой товарищ, дайте, пожалуйста, вот тех конфеток, уж больно они вкусные смигрируй мне пожалуйста вот эту виртуалку на новый гипервизор.» И самое что забавное — смигрировал. С первого раза. Без бубна и ошибок. И в итоге миграция, на тест которой я планировал выделить неделю уложилась в 40 минут, из которых 20 была сама миграция.
**Чего не хватает:**
1. Маленького дистрибутива, заточенного именно под виртуализацию (аналога esxi).
2. Нормальной консоли управления (консоль неудобная, особенно после управлялки от VMware, но есть надежда на проект Гонолулу. Во всяком случае, глядя на техническое превью, возникает понимание что продукт должен дать то самое удобство управления).
3. Технической поддержки продукта виртуализации. Да, я знаю, что есть Premium Support, но это совсем не то, чего хочется.
Подводя итоги (если вам лень читать статью):
--------------------------------------------
1. Сейчас производительность двух платформ примерно одинакова.
2. Производительность 1С такая же.
3. В Hyper-V виртуальные диски можно как увеличивать, так и уменьшать. Причем онлайн.
4. Очень, ну прямо очень, простая миграция с VMWare.
5. Беда с поддержкой в привычном ее понимании.
6. VMM крайне неудобная штука, особенно после vCenter. Но с другой стороны VMM это просто графическая оболочка для скриптов PowerShell, так что можно рулить всем этим через привычный Powershell CLI.
7. Переход требует переучиваться и разбираться с тонкостями именно Hyper-V. Многие вещи и идеологические подходы разнятся.
8. Шикарные шаблоны виртуальных машин с Windows. Удивительно удобно.
9. Экономия денег.
10. Более интересная на мой взгляд реализация Software-defined storage, но это «на любителя».
11. Уважение за то, что весь Azure построен на собственных технологиях, которые потом приходят on-premise.
12. Простая и очень плотная интеграция с облаком.
13. Неплохая виртуализация сети, с многими любопытными моментами.
14. На мой взгляд VDI – это не к Microsoft и Hyper-V. Но с другой стороны стрим проложений (RemoteApp) сделан весьма добротно, и для большинства компаний мало чем будет хуже, чем тот же Citrix.
15. Слабая поддержка сторонними вендорами готовых образов виртуалок для Hyper-V (предположу, что явление временное).
16. Весьма странная новая лицензионная политика (по ядрам).
Об авторе
---------
Антон Литвинов – последние 6 лет работает в компании 585/Золотой. Прошел путь от сетевого инженера до руководителя отдела инфраструктурных решений и в итоге совмещает в себе мистера Джекила и доктора Хайда — фуллстак инженера и руководителя. В ИТ уже примерно 20 лет. | https://habr.com/ru/post/346776/ | null | ru | null |
# Как мы в Smart Engines учили Sailfish OS распознаванию
Всем привет! Как вы уже знаете по нашим статьям, мы в Smart Engines занимаемся распознаванием, причем распознавать мы стараемся на чем угодно и в любых условиях. Мы поддерживаем все популярные операционные системы: iOS, Android, Windows, Linux, MacOS, Solaris. Поддерживаем мы и отечественного производителя: Эльбрус и AstraLinux. Наши алгоритмы оптимизированы под ARMv7-v8, AArch64, x86, x86\_64, SPARC, E2K, MIPS.
Поэтому, когда мы увидели нарастающую популярность российской операционной системы Sailfish Mobile OS RUS, мы не смогли обойти ее стороной. Sailfish Mobile OS RUS — это POSIX-совместимая операционная система для мобильных устройств, развиваемая отечественной компанией «Открытая Мобильная Платформа» для решения задач корпоративных пользователей и государственных учреждений. По состоянию на февраль 2018 года является единственной мобильной операционной системой, включенной в реестр Отечественного ПО и прошедшей сертификацию ФСБ по классу АК1/КС1.
В этой статье мы расскажем о своем опыте портирования нашей библиотеки распознавания [Smart IDReader](http://smartengines.ru/smart-idreader/) (технология [Hieroglyph](http://smartengines.biz/ocr-products/)) на Sailfish OS. В ней будет код, ссылки и видео. Мы хотим, чтобы эта статья была технически информативной и полезной в качестве общей инструкции для тех, кто портирует С++ приложения на Sailfish OS.
Мы выражаем благодарность коллегам из [Открытой Мобильной Платформы](http://omprussia.ru/) (ОМП) Кириллу Чувилину и Алексею Андрееву за консультации в разработке приложения и предоставление двух устройств INOI R7 для тестирования и демонстрации.
TL;DR — портировать было быстро и просто. Суммарно потребовалось меньше одной рабочей человеко-недели с момента скачивания Sailfish OS SDK до снятия первого видео с демонстрацией распознавания документов на устройстве INOI R7 (видео будут в конце статьи).
### Установка инструментария
Первым шагом была установка Sailfish OS SDK. Скачать установочный пакет можно с [официального сайта](https://sailfishos.org/wiki/Application_SDK#Latest_SDK_Release), но мы выбрали метод еще проще и установили SDK из AUR — пользовательского репозитория Arch Linux (самого популярного Linux-дистрибутива среди разработчиков Smart Engines), в котором, как обычно, все есть и устанавливается одной командой:
```
yaourt -S sailfishos-sdk-bin
```
Средства для разработки включают в себя три основных компонента:
1. Окружение и система сборки — Oracle VM VirtualBox образ, содержащий установленные компиляторы и библиотеки для сборки приложений для устройства или эмулятора.
2. SailfishOS Emulator, аналогичный эмуляторам для других мобильных платформ (iOS, Android, ...)
3. IDE — всем известный Qt Creator, доделанный для поддержки взаимодействия с системой сборки и запуска программы на устройстве или эмуляторе.
Соединение с виртуальной машиной для сборки происходит через SSH. Единственной проблемой было то, что при установке SDK для виртуальной машины и IDE жестко проставляется порт `2222`, который уже использовался для других целей на компьютере разработчика. В VirtualBox этот порт меняется понятным образом, а вот в IDE поменять его из GUI было нельзя. К счастью, его можно было поменять в `mersdk.xml` файле локальных настроек:
```
2222
```
Об этой проблеме после ее решения было сообщено Кириллу, а других проблем с инструментарием в дальнейшем не возникало.
### Сборка С++ ядра распознавания
Наше ядро распознавания написано на С++ и в данном случае очевидным выбором для портирования на Sailfish OS была сборка ядра в виде статических библиотек.
Короткая, но информативная инструкция по ручной сборке библиотек находится на странице [Building Sailfish OS packages manually](https://sailfishos.org/develop/tutorials/building-sailfish-os-packages-manually/) официальной документации. По ней стало понятно, что требуется просто подключиться по SSH к виртуальной машине, а затем вызвать обычные команды сборки с указанием правильной архитектуры. Опишем процесс по шагам.
1. Запускаем виртуальную машину Sailfish OS Build Engine (достаточно headless режима)
2. Подключаемся к ней:
```
ssh -p 2222 -i /opt/SailfishOS/SDK/vmshare/ssh/private_keys/engine/mersdk mersdk@localhost
```
Кстати, внешняя пользовательская home-директория по умолчанию доступна в виртуальной машине по адресу `/home/src1`.
3. Получаем список поддерживаемых платформ:
```
[mersdk@SailfishSDK ~]$ sdk-assistant list
Toolings:
SailfishOS-2.1.3.7
Targets:
SailfishOS-2.1.3.7-armv7hl # Устройство
SailfishOS-2.1.3.7-i486 # Эмулятор
```
В отличие от примера на сайте, в именах платформ может присутствовать номер версии, которые тоже нужно будет учитывать. Далее сборка будет проводиться для устройства (SailfishOS-2.1.3.7-armv7hl), но для эмулятора весь процесс аналогичен.
Для требуемой архитектуры соответствующее окружение обеспечивается командой `sb2` (Scratchbox2), поэтому все нужно делать через нее:
```
sb2 -t SailfishOS-2.1.3.7-armv7hl
```
4. Устанавливаем необходимые для сборки пакеты. В нашем случае это были CMake, GCC, G++ и Zip:
```
sb2 -t SailfishOS-2.1.3.7-armv7hl -m sdk-install -R zypper in cmake gcc gcc-c++ zip
```
5. Создаем папку сборки и вызываем `CMake`, причем передаем ему правильный `CMAKE_SYSROOT`, чтобы компиляторы искались в нужном нам месте:
```
mkdir build && cd build
sb2 -t SailfishOS-2.1.3.7-armv7hl -m sdk-build cmake -DCMAKE_SYSROOT=/srv/mer/targets/SailfishOS-2.1.3.7-armv7hl ..
```
6. Собираем проект:
```
sb2 -t SailfishOS-2.1.3.7-armv7hl -m sdk-build make install -j8
```
Вот и все! Таким образом, сборка под Sailfish OS практически не отличается от сборки под Linux — требуется лишь подключиться к виртуальной машине и вызывать команды с правильным окружением.
### Создание и настройка Qt проекта
Процесс создания проекта тривиален и про него можно почитать, например, в [хабе](https://habrahabr.ru/post/305510/) Sailfish OS на Хабрахабре. После этого нужно было сделать только одно — добавить пути к заголовочным файлам и статическим библиотекам в .pro файл следующим образом:
```
INCLUDEPATH += /path/to/install.armv7-linux.release/include
LIBS += -L/path/to/install.armv7-linux.release/lib \
-lsomeStaticLibrary \
-lanotherStaticLibrary
```
После этого проект с вызовом нашего С++ ядра распознавания успешно скомпилировался и запустился.
### Написание GUI с QML и Sailfish Silica
GUI приложений для Sailfish OS пишется с помощью Qt на C++ и QML: как со стандартной библиотекой QtQuick, так и специальной [Sailfish SIlica](https://sailfishos.org/develop/docs/silica/).
Практически вся требуемая информация по этим технологиям присутствует в их официальной документации. К дополнительным полезным ссылкам относятся [хаб разработки под Sailfish OS](https://habrahabr.ru/hub/Sailfish_dev/) на Хабре, шпаргалки по [цветам и отступам](https://sailfishos.org/wp-content/uploads/2016/06/theme_cheatsheet.png), [иконкам](https://sailfishos.org/wp-content/uploads/2016/06/icon_reference.png) и [основным компонентам](https://sailfishos.org/wp-content/uploads/2016/06/component_cheatsheet.png), а также бесплатный [вводный курс](http://stepik.org/course2341) на Stepik.
Для отрисовки графических примитивов мы использовали [Canvas](http://doc.qt.io/qt-5/qml-qtquick-canvas.html#details) и его метод `onPaint`. Выбор документа горизонтальной прокруткой — SlideshowView (спасибо Алексею за пример реализации). Отображение результатов распознавания — [SilicaListView](https://sailfishos.org/develop/docs/silica/qml-sailfishsilica-sailfish-silica-silicalistview.html/) с ListModel.
Помимо написания основных GUI элементов важно научиться вызывать С++ классы из QML кода, что довольно просто и понятно описано на странице [Integrating QML and C++](http://doc.qt.io/qt-5/qtqml-cppintegration-topic.html) официальной документации Qt: делаем С++ класс, регистрируем его в С++, импортируем его в QML. Для оборачивания С++ структур в QML самым очевидным способом показалось использование `Q_GADGET`, про что даже есть [статья](https://habrahabr.ru/post/307816/) на Хабре.
### Взаимодействие с камерой устройства: детективно-научное расследование
Понимание того, как правильно взаимодействовать с API камеры, было единственной трудностью во всем процессе разработки демо-приложения и заслуживает отдельного пункта — потребовалось небольшое исследование с мозговым штурмом, гипотезами и экспериментами.
Сценарий использования наших библиотек распознавания видеопотока в реальном времени обычно такой: пока пользователь видит превью камеры и держит перед ней объект (например, паспорт РФ или банковскую карту), в библиотеку распознавания один за одним поступают приходящие с камеры кадры и распознаются. При этом, во время распознавания каждого кадра пользователю показывается промежуточная информация о расположении документа, его полей и т.д. Тем самым, требуется одновременно захватывать кадры с камеры и показывать превью пользователю.
При создании камеры и превью в QML вопросов не возникло: создаем [Camera](http://doc.qt.io/qt-5/qml-qtmultimedia-camera.html#details) и ссылаемся на нее в [VideoOutput](http://doc.qt.io/qt-5/qml-qtmultimedia-videooutput.html#details):
```
Camera {
id: camera
position: Camera.BackFace
// ...
}
VideoOutput {
anchors.fill: parent
source: camera
}
```
Осталось найти способ перехватывать приходящие с камеры кадры и передавать их в С++ на распознавание.
В качестве первого способа мы попробовали стандартный [QVideoProbe](http://doc.qt.io/qt-5/qvideoprobe.html#details), специально существующий для получения приходящих с камеры кадров. Однако, вызов `probe.setSource(camera)` возвращал `false`, после чего в callback для перехвата кадров ничего не приходило. Судя по информации в интернете, такая проблема актуальна и для Android устройств, что может свидетельствовать о простом отсутствии реализации QVideoProbe для Sailfish OS. Надеемся, что в скором времени это исправится.
Второй способ — наследование от [QAbstractVideoSurface](http://doc.qt.io/qt-5/qabstractvideosurface.html#details) и реализация метода `present(const QVideoFrame &frame)`, который передает пришедший кадр на распознавание. После вызова `camera.setViewFinder(&videoSurface)` кадры действительно начали приходить (в формате NV21) и даже распознаваться, если держать документ перед камерой… вот только превью в VideoOutput пропало и пользователь потерял возможность видеть, что же снимает его камера. Победить эту проблему быстро не удалось и мы вместе с Кириллом и Алексеем из ОМП начали искать третью альтернативу.
К счастью, третий способ коллективными усилиями был найден довольно быстро. Им оказалась связка из [QAbstractVideoFilter](https://doc.qt.io/qt-5.10/qabstractvideofilter.html#details), который методом `createFilterRunnable()` создает [QVideoFilterRunnable](https://doc.qt.io/qt-5.10/qvideofilterrunnable.html#details), в свою очередь реализующий функционал обработки кадра. После этого реализованный фильтр нужно добавить в QML и сослаться на него в имеющемся VideoOutput:
```
RecognitionVideoFilter {
id: recognitionVideoFilter
// ...
}
VideoOutput {
anchors.fill: parent
source: camera
filters: [ recognitionVideoFilter ]
}
```
Скомпилировалось, запустилось. Превью видео есть, но кадры по прежнему не приходят. И вдруг, Кирилл поделился ~~инсайдерской~~ информацией о том, что для работы фильтров на устройстве необходимо обновить QtMultimedia плагин, который оказался доступен по [ссылке](http://repo.merproject.org/obs/home:/minlexx/sailfish_latest_armv7hl/armv7hl/). После этого все заработало — кадры в формате BGRA начали приходить в ядро. Небольшая деталь — функция `QAbstractVideoSurface::run` блокирует превью камеры (что логично, потому что фильтр подразумевает изменение кадра, а нам нужно его только прочитать и распознать), поэтому для плавного превью потребовалось запускать распознавание в отдельном потоке — например, через [QtConcurrent::run(...)](http://doc.qt.io/qt-5/qtconcurrentrun.html).
Вот и все! Оставалось только дописать GUI приложения, что не составило особого труда.
### Демонстрация на Mobile World Congress 2018 в Барселоне и другие видео
В этом году наша компания уже второй раз [представила](http://smartengines.ru/news59/) свои технологии распознавания на ежегодной выставке Mobile World Congress 2018 в Барселоне, снова поразившей нас своим масштабом: более 107 000 посетителей из 205 стран, 2400 стендов компаний, расположенных на 120 000 квадратных метрах павильонов. Как и в [прошлом году](https://habrahabr.ru/company/smartengines/blog/322400/), она произвела на нас крайне положительное впечатление.
Конечно, мы не упустили возможности как пойти похвастаться нашей демкой на стенде финской компании Jolla, являющейся оригинальным разработчиком Sailfish OS, так и показать работу программы "вживую" коллегам из Открытой Мобильной Платформы, которые даже сняли несколько видео и [выложили их в группе ВКонтакте](https://vk.com/wall-40681615_13027):
* [Первое видео](https://vk.com/wall-40681615_13027?z=video-40681615_456239058%2Fc8289b04eeba5f5b74%2Fpl_post_-40681615_13027)
* [Второе видео](https://vk.com/wall-40681615_13027?z=video-40681615_456239059%2F7aaabf72d4e37f7cb3%2Fpl_post_-40681615_13027)
* [Третье видео](https://vk.com/wall-40681615_13027?z=video-40681615_456239060%2Fbcfdd0d4cfaf70aee8%2Fpl_post_-40681615_13027)
А вот видео с первой рабочей версией программы:
Много других видео с демонстрациями технологий Smart Engines можно посмотреть на [нашем YouTube канале](https://www.youtube.com/channel/UCAhRdZxFYK0kmjnqdmNGePA/videos).
### Заключение
В этой статье мы рассказали о своем опыте портирования библиотеки распознавания Smart IDReader на Sailfish OS, включая написание демо-приложения. Мы были приятно удивлены количеством релевантной официальной документации и качеством инструментария. Конечно, пара технических вопросов возникла, но их удалось оперативно победить. Надеемся, что наш опыт будет полезен и другим. | https://habr.com/ru/post/352512/ | null | ru | null |
# Constraints в PostgreSQL, или о том, как попытаться спокойно жить
Данный материал был создан на основе одноимённого [доклада на PGConf.Online](https://pgconf.ru/2021/288643), вошедшего в число самых популярных выступлений конференции. Поскольку тема ограничений по-прежнему сохраняет свою актуальность, а смотреть видео с мероприятий любят не все, появилась эта статья.
### Концепция “тупого хранилища”
В последние годы разработчики ПО всё чаще утверждают, что база в их проекте “всего лишь тупое хранилище, и поэтому никакой логики в ней нет”. Откуда такой подход? Обычно он объясняется сложностями миграции, развёртывания, неудобствами при работе с системами контроля исходного кода. Не стоит списывать со счетов и простую человеческую лень: раз всё и так нормально, зачем связываться с логикой в СУБД? Создали таблицы (или, ещё лучше, пусть ORM их создаст!), и всё отлично.
### NoSQL для документов
Случай с NoSQL ещё проще – не надо ничего создавать, контролировать и напрягать мозги, всё уже автоматизировано, *оно само работает*. Этого вполне достаточно, если из базы нужно просто доставать документы по идентификатору, но если требуется решать задачи посложнее, то всё-таки выбирают SQL СУБД. Их использование, однако, ограничивается созданием таблиц и индексов, логика на стороне СУБД и в этом случае видится избыточной.
### СУБД: не только технология, но и бизнес-инструмент
Такой подход является очень распространённым (люди вообще ленивы!). Тем не менее, крайне наивно дистанцироваться от хороших возможностей только из-за нежелания заморачиваться и приобретать новые навыки. СУБД – это очень изощрённая система хранения (чтобы понять это, достаточно [почитать про уровни изоляции или процедуры резервного копирования](https://edu.postgrespro.ru/postgresql_internals-14.pdf)). СУБД помогает синхронизировать бизнес-процессы и избежать реальных убытков, иногда в очень крупном размере.
### Ecommerce: проблемы в системах учёта
Конечно, если у вас на складе товар в одном экземпляре, а вы его продали сразу двум покупателям, ваш бизнес от этого не сильно пострадает. В самом худшем случае вы из-за этой ситуации потеряете одного клиента-физлицо. Но что будет, если случатся более серьёзные неприятности? Осенью 2020 года я слышал о скандале внутри крупного российского онлайн-ритейлера. Тогда на складе обнаружили целые залежи товаров, ожидающих отправки покупателям ещё с весны. Виноваты, как всегда, были все сразу и никто конкретно.
### “Сюрпризы” в коде
Концепция “СУБД – тупое хранилище” не может предотвратить такие случаи. Более того, она создаёт для них предпосылки. Это всего лишь вопрос времени, когда случится подобное. Даже лучший в мире разработчик рано или поздно совершит ошибку. Проект может существовать с этой ошибкой годами, до момента, пока не будут созданы условия, в которых она проявится. Тушить такой внезапный пожар всегда проблематично. Необходимо иметь в виду, что даже давно проверенный старый код однажды может преподнести неприятные сюрпризы.
### Почему “умная” база лучше?
Как же уберечься от подобного рода неприятностей или хотя бы уменьшить вероятность их возникновения? Стоит вернуться к логике в СУБД, сделать её “умным” хранилищем. С помощью ограничений (constraints) можно сделать так, чтобы СУБД не допускала перевод себя в явно некорректное состояние. Конечно, определить все некорректные состояния раз и навсегда вряд ли получится. Однако, можно хотя бы составить список условий, в которых база точно никогда не должна находиться.
### Когда ограничения стоят денег
Однажды знакомый разработчик ошибся при расчёте обменного курса криптовалют и отправил нескольким получателям по триста тысяч долларов каждому вместо ожидаемых трёхсот. Это могла бы предотвратить обычная нудная проверка, если бы она была. “Для такой-то пары значение отправленной суммы должно быть не больше 1/5 от значения полученной”, - если бы такое ограничение было вовремя установлено, можно было бы сберечь время и нервы:
```
check(case when in_ticker='BTC' and out_ticker='ETH'
then out_amt/in_amt>5
else true
end)
```
Намного приятнее и спокойнее разбираться, почему платёж не ушёл, чем выяснять, почему он ушёл не туда или с неправильной суммой.
### Дело не только в производительности
Таких жизненных историй я знаю очень много, поэтому стандартные возражения против ограничений целостности кажутся мне нелепыми. Естественно, ограничения снижают производительность, зато никому не придется продавать почку, если что-то пойдет не так. (Вряд ли кому-то захочется иметь дело с взысканием миллионного ущерба на работе.) Знаю, что многие молодые разработчики искренне верят в надежность своего кода. C годами это проходит, но зачем же ждать так долго?
### Двойная защита для любых ценностей
Мой опыт подсказывает, что в реальном приложении, работающем с деньгами или другими материальными ценностями, любая проверка должна дублироваться. При этом желательно, чтобы код для каждой из проверок писали разные люди, которые не знакомы друг с другом и думают по-разному. Если вернуться к вышеупомянутому примеру с криптовалютами, одна проверка должна быть для грубой оценки – “не более 1/5”, а вторая – проверять, чтобы вычисленный курс не отличался от реального более чем на 2%:
```
(select abs(1-(select (out_amt/in_amt)/r.rate from rates r
where r.ask_ticker='TCKR1' and r.bid_ticker='TCKR2'))<0.02)
```
Зачем дублировать проверки? Рано или поздно какая-то из этих проверок сломается, и в отсутствие “запасной” проверки придётся работать без ограничений, а это чревато убытками.
### Паранойя или управление рисками?
Расскажу ещё об одном случае из моей практики. Мне нужно было убедиться, что заказы не размещаются повторно. Для этого я создал уникальный индекс по идентификатору товара плюс предусмотрел простенькую проверку того, не был ли такой же товар добавлен в таблицу ранее. Казалось бы, паранойя на грани сумасшествия: зачем проверять то, что и так проверяется, причем не строго корректным образом (корректная реализация проверки на уникальность хоть и несложна, но, тем не менее, немного нетривиальна)? Тем не менее, в процессе очередной реорганизации уникальный индекс по недосмотру был заменен на обычный. Двойные продажи товаров начались бы, если бы не резервная проверка. Замена индекса обнаружилась только дней десять спустя, тем не менее, проблемных ситуаций не возникло. Так что у паранойи тоже есть практичная сторона. Конечно, такие дублирующиеся проверки подходят не для всех случаев. Но если нарушение бизнес-процессов грозит заметными потерями, благоразумно иметь две проверки или даже больше.
В наиболее критичных ситуациях отдельные разработчики рекомендуют ставить не менее трех серверов и выполнять операцию только если минимум два из них приходят к консенсусу (замечание в сторону: именно такое поведение автоматически получается в случае использования блокчейна).
### Почему гибкость не всегда хороша
Ещё одно распространённое возражение против ограничений – отсутствие гибкости. Разумеется, база данных станет негибкой! Но при применении ограничений в этом и состоит наша цель. Так, например, при описании таблицы с примыкающими диапазонами дат (“с -infinty по 2020-01-01, с 2020-01-01 по 2020-06-01, с 2020-06-01 по 2021-01-01, с 2021-01-01 по infinity”) вставить в середину отдельный диапазон не так-то просто. Для этого потребуются либо отложенные (deferrable) проверки и не просто вставка нужной строки, но и изменение соседних, либо придётся обновить таблицу целиком.
```
create constraint trigger check_daterange_consistency_iu
after insert or update on fees deferrable initially deferred
for each row execute procedure check_fees_table_consistency();
create or replace function wb.check_fees_table_consistency()
returns trigger as
$code$
begin
perform pg_advisory_xact_lock(hashtext('fees'),
hash_record(row(new.period_start, new.period_end)));
if new.period_start<>'-infinity'
and not exists(select * from fees f where f.period_end=new.period_start)
then
raise sqlstate '23Q01' using message=format('Invalid period_start:%s',new);
end if;
if new.period_end<>'infinity'
and not exists(select * from fees f where f.period_start=new.period_end)
then
raise sqlstate '23Q01' using message=format('Invalid period_start:%s',new);
end if;
if exists(select * from fees f
where (f.period_start,f.period_end)overlaps(new.period_start, new.period_end)
and f.period_start<>new.period_start
and f.period_end<>new.period_end )
then
raise sqlstate '23Q01' using message=format('Invalid date range:%s',new);
end if;
end
$code$
language plpgsql
```
Но ведь именно это и является целью ограничений – ни в коем случае не допустить непримыкающих диапазонов дат. Нам необходимо гарантировать, что диапазоны, во-первых, примыкают к друг другу и, во-вторых, не перекрываются.
В реальной жизни настолько жесткие ограничения встречаются не столь часто, как хотелось бы. Если бы большее число компаний и организаций пользовались возможностями СУБД в полном объёме, мы реже слышали бы о гигантских убытках и недовольных пользователях.
### Осиротевшие строки и неопределённость
Какова же стандартная практика? Обычно у каждой таблицы есть первичный ключ, хотя встречаются – и даже слишком часто – таблицы и без него. Реже, но всё же довольно часто применяют ограничение not null. Что касается внешних ключей (foreign keys), вполне можно наблюдать базы без них. А если в базе нет внешних ключей, и она уже достаточно стара и велика, есть 100% вероятности, что в её дочерних таблицах есть осиротевшие строки. Это плохо само по себе, плюс закономерно предположить, что если родитель для одной строки потерян, то и для другой он может быть указан некорректно.
### “Экзотические” ограничения и ecommerce
Некоторые ограничения практически не встречаются. Например, EXCLUDE позволяет не допускать перекрывающихся диапазонов. Проверка JSON или XML на соответствие схеме также довольно экзотична. Совсем редки проверки в триггерах, хотя последние предназначены в том числе и для нестандартных проверок. Так, стандартными средствами СУБД невозможно обеспечить ограничение целостности вроде “каждый заказчик может иметь не более трех неоплаченных заказов” или “сумма неоплаченных заказов не должна превышать определенного значения”. Для реализации этого ограничения сначала потребуется написать триггер на добавление либо обновление удаление строки в таблице “Заказы”. Потом в нём обязательно нужно использовать блокировку, чтобы предотвратить обновление строки пользователя в транзакции, либо придётся использовать advisory-блокировку, используя хеш от идентификатора пользователя в качестве ключа блокировки. (Пример можно видеть выше в тексте триггерной функции:
```
pg_advisory_xact_lock(hashtext('fees'),
hash_record(row(new.period_start, new.period_end)));
```
Использование advisory-блокировки является отступлением от стандарта, но при большом количестве операций модификации она даёт выигрыш по производительности.
### Триггеры и финтех
Не получится обойтись без триггеров и в случае проверки значения. Например, в России рублевый счет коммерческой нефинансовой организации в банке обязательно должен начинаться на 40702810. Проверку можно описать как CHECK, но в более сложных случаях придется обратиться к таблице-справочнику (40701 – финансовые организации, 40703 – некоммерческие, 408 – частные лица и т.п.). Правда, подобный триггер обычно имеет достаточно простой вид:
```
if not exists(select * from account_chart ac where ac.prefix=substring(new.account from 1 for 5)) then
raise sqlstate ‘23Q03’ using message=’Invalid account for …’;
end if;
```
### ASSERTION: круто, но не реализовано
В стандарте SQL описано такое полезное ограничение уровня БД, как ASSERTION. Будь оно реализовано, оно позволяло бы делать замечательные вещи. Так, ограничение на количество неоплаченных заказов было бы совершенно тривиальным. Ограничения по суммам продаж, по датам отгрузки тоже не представляли бы никакой проблемы. К сожалению, это ограничение не реализовано в Postgres. В оправдание Postgres можно сказать, что оно вообще не реализовано ни в одной из популярных СУБД. Честно говоря, не очень понятно, как его вообще можно эффективно реализовать.
### Зачем писать триггеры?
Таким образом, если требуются достаточно нестандартные ограничения, придётся создавать триггеры или регулярно запускать скрипты проверки. (Это справедливо для ситуаций вида “не больше трех неоплаченных заказов”, “оплаченный заказ не может оставаться неотгруженным более суток” и им подобных.) Почему требуются какие-то дополнительные скрипты? Потому что со временем вполне корректные состояния могут оказываться некорректными. Например, товар, предназначенный для отправки, не может находиться на складе позднее какой-то даты:
```
for r in select * from goods g
where g.shipment_date is null
and g.received_date>current_date-1
loop
perform send_notification_to_manager_on_stalled_delivery(r);
end loop;
```
Так как штатных триггеров по времени в СУБД не предусмотрено, придётся эмулировать их самостоятельно. Можно даже создать целый фреймворк для этого, но это уже тема другого разговора.
### Основные тезисы
Какие основные тезисы этой статьи стоит запомнить? Я бы остановился на нескольких:
* База данных – это не “тупое хранилище”.
* База данных не должна допускать явно некорректные операции.
* База данных должна обнаруживать некорректные состояния.
### Вывод
Понятно, что реализация подхода “база данных – умное хранилище” требует дополнительных усилий. Тем не менее, без этих усилий обойтись не удастся, если данные в СУБД являются частью сколько-нибудь серьезного бизнеса. Даже если проверки и другие ограничения не решат всех проблем, они позволят обнаруживать их раньше. А время – деньги. | https://habr.com/ru/post/672004/ | null | ru | null |
# Разблокировка ошибочно заблокированных джобов в DataStage
При работе с клиентом IBM WebSphere DataStage довольно нередки случаи краха приложения клиента, влекущие за собой блокировку джоба (будем называеть Job именно так, избегая более русского, но в то же время более общего термина **etl-процедуры** или **процедуры переливки данных**). Если джоб заблокирован, его нельзя будет перекомпилировать, посколько DataStage клиент будет сообщать о невозможности монопольного захвата ресурсов джоба.
В этом разделе я расскажу как можно, не перезагружая сервер DataStage, разблокировать джоб.
Для выполнения всех перечисленных операций, вам потребуется запустить DataStage Administrator, выбрать в нем нужный проект и перейти в коммандный режим.
Затем, необходимо вывести список всех блокированных ресурсов. Для этого введите в поле Command следующую комманду:
`LIST.READU`
В появившемся окошке Command Output нас интересуют две колонки: Inode и Userno. Именно по этим идентификаторам можно выполнять разблокировку джоба, используя комманды
`UNLOCK INODE НОМЕР_INODE ALL`
или
`UNLOCK USER НОМЕР_USERNO ALL`
Возможно, выполнение этих комманд у вас завершится неудачно. В этом случае необходимо разблокировать комманды, которые заблокированы для текущего проекта по-умолчанию (достаточно только один раз для каждого проекта).
Вот так:
`SET.FILE UV VOC UV.VOC
COPY FROM UV.VOC TO VOC UNLOCK` | https://habr.com/ru/post/90718/ | null | ru | null |
# Храните ваши клятвы; Отношения с Node
Клятвы могут быть прекрасны. [Алексис Селлир](http://cloudhead.io/), сыскавший славу за разработку «LESS» (и «less.js»), начинает становиться звездой Open Source, выпустив в свет [**Vows**](http://vowsjs.org/), — каркас для разработки на Node.JS, управляемой асинхронным поведением.
[](http://vowsjs.org/)
Если такую спецификацию BDD мы подадим на вход:
> `1.
> 2. *// division-by-zero-test.js*
> 3. **var** vows = require('vows'),
> 4. assert = require('assert');
> 5.
> 6. *// Create a Test Suite*
> 7. vows.describe('Division by Zero').addBatch({
> 8. 'when dividing a number by zero': {
> 9. topic: **function** () { **return** 42 / 0 },
> 10.
> 11. 'we get Infinity': **function** (topic) {
> 12. assert.equal (topic, Infinity);
> 13. }
> 14. },
> 15. 'but when dividing zero by zero': {
> 16. topic: **function** () { **return** 0 / 0 },
> 17.
> 18. 'we get a value which': {
> 19. 'is not a number': **function** (topic) {
> 20. assert.isNaN (topic);
> 21. },
> 22. 'is not equal to itself': **function** (topic) {
> 23. assert.notEqual (topic, topic);
> 24. }
> 25. }
> 26. }
> 27. }).run(); *// Run it*
> 28.`
То на выходе мы получим великолепно читаемый отчёт:
С макросами в итоге мы получаем удобный DSL-синтаксис, например:
> `1.
> 2. { 'GET /': {
> 3. topic: api.get('/'),
> 4. 'shoud respond with a 200 OK': assertStatus(200)
> 5. },
> 6. 'POST /': {
> 7. topic: api.post('/'),
> 8. 'shoud respond with a 405 Method not allowed': assertStatus(405)
> 9. },
> 10. 'GET /resources (no api-key)': {
> 11. topic: api.get('/resources'),
> 12. 'shoud respond with a 403 Forbidden': assertStatus(403)
> 13. },
> 14. 'GET /resources?apikey=af816e859c249fe'
> 15. topic: api.get('/resources?apikey=af816e859c249fe'),
> 16. 'shoud return a 200 OK': assertStatus(200),
> 17. 'should return a list of resources': **function** (res) {
> 18. assert.isArray (res.body);
> 19. }
> 20. }
> 21. }
> 22. *// or even*
> 23. {
> 24. 'GET /': respondsWith(200),
> 25. 'POST /': respondsWith(405),
> 26. 'GET /resources (no key)': respondsWith(403)
> 27. }
> 28.`
На сайте проекта подробно описаны процесс установки, примеры использования и т.д. Кстати, сделан сайт очень прилично, с использованием HTML5-разметки.
от переводчика: Название статьи на английском языке обыгрывает название проекта — Vows (клятвы). | https://habr.com/ru/post/98671/ | null | ru | null |
# MFC В 2022
Зачем и почему
--------------
Как бы мне не хотелось ответить на этот вопрос... Но ответа я не знаю. На рабочем проекте была задача написать редактор на MFC. Да, да... На MFC. Для тех, кто не знает, MFC - графическая библиотека от Microsoft, на которой стояли Microsoft Office и Visual Studio до 2010 года и выглядит примерно вот так:
Документация
------------
Хоть и компания Microsoft любит делать подробную документацию для своих творений, но с MFC ситуация оказалась иная. Хоть он и имеет в районе 100 страниц на msdn (я знаю, что сайт переехал, но привычки не меняются), но это только на первый взгляд. Как только вам приходится делать что-то серьёзное, касаемо самих контролов, можете о ней забыть. Придётся выкачивать символы и исходный код данной библиотеки и разбираться в отладчике, вникая в аспекты UI библиотеки построенной на событиях. Ладно, у меня слишком много накипело и вводную я могу писать вечно, так что перейдём к сути.
Убийца #1 - Visual Manager
--------------------------
Если кто-то заходил дальше диалоговых окон, то знает что есть режимы SDI и MDI, которые представляют собой полноценное окно с табами(и без них). И их визуализацией занимается как раз таки Visual Manager (нет), у которого даже есть множество тем, начиная с WinXP и заканчивая Windows 7. (+VS и MSOffice)
На самом деле VisualManager выполняет весьма скудную роль в этом деле. Он контролирует Ribbon, PropertyGrid, MDI Tabs, Toolbar (который **CMFCToolbar**. Их там несколько, ребят), Header и Caption Bar. Но если же вы хотите сделать нечто следующее:
То вам придётся знакомится с событиями **WM\_PAINT**, **WM\_CLRCTL** (а ещё и иногда с \*\_NC\_ аналогами этих событий) и перегружать все наши любимые кнопки, текстбоксы и статики. Помимо этого, добавлять в DocablePane функции, которые будут указывать для DC цвет текста и фона для **CTreeCtrl**.
Убийца #2 - PropertyGrid
------------------------
Думаю, всем известно, что пропы это весьма обширная UI часть и везде нам не нравится их реализация. Помните, я говорил, что Visual Manager отвечает за их отрисовку? В данном случае, лучше бы он этого не делал. Почему? Представьте что вам нужен кастомный проп, в котором должна быть кнопка, или несколько... Но... У пропа всего 1 hwnd, что не позволяет вам быстрой перегрузкой докинуть кнопку в его содержимое. И тут уже идёт магия с созданием алгоритмов просчёта позиции.
Ситуация 2: Диалоговые окна.
К несчастью, при использовании **CMFCPropertyGridCtrl** в диалоговых окнах, можно встретить неправильный width:
Данная проблема решается перегрузкой класса следующим образом:
```
class CDialogPropertyGridControl : public CMFCPropertyGridCtrl
{
public:
CDialogPropertyGridControl()
{
m_nLeftColumnWidth = 100;
}
void make_fixed_header()
{
HDITEM hdItem = { 0 };
hdItem.mask = HDI_FORMAT;
GetHeaderCtrl().GetItem(0, &hdItem);
hdItem.fmt |= HDF_FIXEDWIDTH;
GetHeaderCtrl().SetItem(0, &hdItem);
}
void SetLeftColumnWidth(int cx)
{
m_nLeftColumnWidth = cx;
AdjustLayout();
}
void OnSize(UINT f, int cx, int cy)
{
EndEditItem();
if (cx > 50)
m_nLeftColumnWidth = cx - 50; //<- 2nd column will be 50 pixels
AdjustLayout();
}
DECLARE_MESSAGE_MAP()
};
```
Честно говоря, быстрее выйдет написать свой PropertyGrid, если Вам придётся часто с ним работать. Т.к. если не брать в расчёт предыдущие аспекты, сам по себе он вызывает очень громоздкий код, который придётся обвешивать get/set на каждый чих. За два вечера я смог написать базовый проп под свои нужды, который работает напрямую с передаваемой переменной и имеет тот же функционал:
Убийца #3 - RibbonBar
---------------------
Честно говоря, Ribbon в MFC весьма прогрессивнее в плане работы, чем все остальные компоненты. Даже его внутренность построенная на xml, в отличии от тех же диалоговых окон. Но, я так думал, пока не пришлось добавлять на него кастомный элемент. И как было бы не смешно, им оказался RadioBtn. Да, забавный факт, но там нет понятия всеми любимых радио-кнопок.
### Шаг 1 - Новый класс для Ribbon
Для начала надо объяснить MFC, что мы будем использовать кастомый конструктор для Ribbon. Перегружаем функцию **LoadFromResource**
```
BOOL XRibbonBar::LoadFromResource(LPCTSTR lpszXMLResID, LPCTSTR lpszResType /*= RT_RIBBON*/, HINSTANCE hInstance /*= NULL*/)
{
ASSERT_VALID(this);
CMFCRibbonInfo info;
CMFCRibbonInfoLoader loader(info);
if (!loader.Load(lpszXMLResID, lpszResType, hInstance))
{
TRACE0("Cannot load ribbon from resource\n");
return FALSE;
}
XRibbonConstructor constr(info);
constr.ConstructRibbonBar(*this);
return TRUE;
}
```
### Шаг 2 - Конструктор
А тут уже объясняем, в чём не прав стандартный конструктор MFC
```
CMFCRibbonBaseElement* XRibbonConstructor::CreateElement(const CMFCRibbonInfo::XElement& info) const
{
if (info.GetElementType() == CMFCRibbonInfo::e_TypeButton_Check)
{
const CMFCRibbonInfo::XElementButtonCheck& infoElement = (const CMFCRibbonInfo::XElementButtonCheck&)info;
// RadioBox
if (strstr(info.m_strKeys, "RB"))
{
// Make friends list
string TryStr = info.m_strKeys.operator LPCSTR();
TryStr = TryStr.substr(2);
int ID = atoi_17(TryStr);
XRibbonRadioBox* pNewElement = new XRibbonRadioBox(infoElement.m_ID.m_Value, infoElement.m_strText);
ConstructBaseElement(*pNewElement, info);
return pNewElement;
}
}
return CMFCRibbonConstructor::CreateElement(info);
}
```
*strstr(info.m\_strKeys, "RB") - Это флаг в визуальном редакторе, благодаря которому мы можем впихнуть кучу UserInfo*
P.S.
----
Хочется сказать большое спасибо людям с **CodeProject** и **StackOverflow** за огромное количество подсказок при глубокой работе с данным UI API.
Большую часть кода по компонентам MFC я перевёл в общий стандарт и опубликовал по ссылке ниже. Скорее всего, данный репозиторий будет со временем пополняться. Надеюсь, кому-то данная библиотека решений сократит пару десятков часов.
<https://github.com/ForserX/XMFC> | https://habr.com/ru/post/686980/ | null | ru | null |
# Как завладеть сетью /16 с помощью libpcap и libdnet. Работаем с протоколом SNMP
[](https://habr.com/ru/company/ruvds/blog/697854/)
Всем привет. Эксперименты с [эмуляцией сети](https://habr.com/ru/company/ruvds/blog/688314/) продолжаются. В этот раз, как и обещал, будем делать вид, что в нашей виртуальной сети завелась машина с честным snmp-агентом.
SNMP — довольно старый протокол и знаком каждому сисадмину. На этот протокол в своё время возлагали весьма большие надежды, но в последнее время его использование сильно ограничено — как правило, это чтение переменных стандартных mib-ов на железках, не имеющих нормальных операционок (читай linux, ios и т.д.). А вот с хостов, соответственно — под управлением нормальных операционных систем, предпочитают забирать информацию с помощью cli или агентов на python/perl/bash, которые могут залезть в интимные места файловой системы /proc, парсить логи, запускать вспомогательные процессы и отдавать результаты в json/xml в неограниченных объёмах по защищённым ssl каналам.
С точки зрения системного администратора протокол действительно Simple. Всего-то пара типов запросов — get/getnext да оперативное информирование — trap. Есть ещё set, но про него в основном все знают только в теории, т.к. из-за слабой безопасности практиковать даже не пытаются. Ну и вишенка на торте — стандартные mib немного не успевают за жизнью, а в .enterprises уже никто не хочет ковыряться, даже производители.
Однако, несмотря на свои недостатки, данный протокол ещё остаётся безотказной «рабочей лошадкой» для большинства систем мониторинга. Да, стандартные MIB не позволяют в полной мере отразить топологию сети содержащей различные криптошлюзы, туннели, виртуальные роутеры, асимметричные маршруты и т.д., но базовую структуру сети собрать можно даже на коленке — утилитами командной строки snmpget и snmpwalk. Также некоторым достоинством является использование протокола UDP и кодирование ASN1 позволяющие передать всю необходимую информацию в объёме одного крохотного пакета без установки сессии. Плюс реализация snmp-агента может быть весьма небольшой по размеру и встраиваться в системы с очень ограниченными ресурсами.
Разумеется, вышеприведённой информации недостаточно, чтобы создать рукотворный «мираж» в виде фантомного хоста сети, который будет корректно отзываться на snmp-запросы. Попытаемся погрузиться в теорию — сначала лайтовенько [«SNMP: Simple? Network Management Protocol»](https://www.ranecommercial.com/legacy/note161.html), потом чуток поглубже [«ASN.1 простыми словами»](https://habr.com/ru/post/150757/). Мы уже в полушаге от создания собственной реализации net-snmp. Впрочем, кого я обманываю? В первой части я уже написал, что использовал библиотеку csnmp :), значит, идём на гитхаб и берём её там. Но статьи всё же прочитайте.
▍ Подготовка
------------
Достаём из архивов исходники предыдущей части, будем их дописывать.
Скачиваем [csnmp](https://github.com/nikandfor/csnmp) (Copyright © 2019 Nikifor Seryakov) и распаковываем рядом с каталогом, где ведутся эксперименты. Для нашего проекта будут задействованы `asn1.h, asn1.c, snmp.h, snmp.c`. Возникает вопрос — почему не скопировать их в наш каталог, как мы поступили с LaBrea, и таким образом облегчить объём исходников? Дело в том, что все исходные файлы LaBrea в самом начале имеют обширнейшие комментарии с реквизитами и ссылками на создателей, лицензионные ограничения и т.д., а вот csnmp прекрасно обходится без всего вот этого :). Единственным источником идентификации автора и правил использования является файл LICENSE. Поэтому я и предлагаю сохранить исходники csnmp в полном объёме.
Компиляция немного меняется:
`$ gcc -o netemu -ldnet -lpcap netemu.c pkt.c bget.c ../csnmp/asn1.c ../csnmp/snmp.c`
И кажется пора рисовать Makefile…
▍ Обрабатываем snmpget
----------------------
В данном примере будет показан самый минимум — ответ на SNMP\_GET по OID system.sysDescr.0. Для существенного облегчения задачи будем использовать протокол SNMPv1 UDP/161. Безопасность и раньше в snmp была не очень, а здесь я даже не смотрю в поле community :). Конечно, данную проверку прикрутить несложно, но для демонстрации работы с пакетами snmp это избыточно.
В начало файла добавляем ссылки на заголовочные файлы, пути должны соответствовать реальному размещению исходников csnmp:
```
#include "../csnmp/asn1.h"
#include "../csnmp/snmp.h"
```
Немного корректируем функцию ip\_handler — находим в области обработки протокола ICMP объявление `struct addr a;` и переносим в самое начало функции. Это необходимо
чтобы мы могли воспользоваться этой переменной при обработке пакета UDP.
Там, где мы выводим заголовки пакета UDP, добавляем следующий код:
```
addr_aton("10.0.0.5", &a);
if ((pkt->pkt_ip->ip_dst == a.addr_ip)
&& (ntohs(pkt->pkt_udp->uh_dport) == 161)) send_snmp_reply(pkt);
```
Здесь я думаю всё понятно — по прилёту пакета snmp (udp/161) будем отзываться, только если в качестве приёмника там фигурирует адрес `10.0.0.5`.
Готовим функцию send\_snmp\_reply. Но предварительно необходимо объявить пару функций из csnmp. Дело в том, что мы не планируем отправку пакетов средствами csnmp, нам от неё необходим только разбор пакетов, манипуляции с переменными и формирование пакета в буфер. И как раз работа с буфером скрыта в недрах snmp.c и не задекларирована в snmp.h. Вносить какие-либо изменения в snmp.h не будем, а просто объявим их у себя:
```
extern int snmp_dec_pdu(const char *buf, int buf_len, snmp_pdu_t *p);
extern int snmp_enc_pdu(char **buf, int *i, int *buf_len, snmp_pdu_t *p);
void send_snmp_reply(struct pkt *pkt)
{
snmp_pdu_t p = {};
snmp_dec_pdu(pkt->pkt_udp_data, ntohs(pkt->pkt_udp->uh_ulen) - UDP_HDR_LEN, &p);
/* show snmp request */
snmp_dump_pdu(NULL, &p);
snmp_var_t *v;
switch (p.command) {
case SNMP_CMD_GET:
p.command = SNMP_CMD_RESPONSE;
for (int i = 0; i < p.vars_len; i++) {
v = &p.vars[i];
snmp_free_var_value(v);
if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,1,0}, 9)) == 0) {
v->type = SNMP_TP_OCT_STR;
v->value = asn1_new_str("APC Web/SNMP Management Card", 0);
}
else
v->type = SNMP_TP_NO_SUCH_OBJ;
}
break;
case SNMP_CMD_GET_NEXT:
break;
default:
break;
}
if (p.command == SNMP_CMD_RESPONSE) {
p.error = (asn1_error_t){0};
int buf_len = 20 * (1<<10);
char *buf = malloc(buf_len);
int pdu_len = 0;
snmp_enc_pdu(&buf, &pdu_len, &buf_len, &p);
/* show snmp reply */
snmp_dump_pdu(NULL, &p);
struct pkt *new = NULL;
if ((new = pkt_new()) == NULL) return;
eth_pack_hdr(new->pkt_eth,
pkt->pkt_eth->eth_src, /* orig src MAC becomes new dest MAC */
io.mymac, /* my own mac becomes new src MAC */
ETH_TYPE_IP);
ip_pack_hdr(new->pkt_ip,
0, /* tos */
(IP_HDR_LEN + UDP_HDR_LEN + pdu_len), /* IP hdr length */
rand_uint16( io.rnd ), /* ipid */
0, /* frag offset */
IP_TTL_DEFAULT,
IP_PROTO_UDP, /* ip protocol of original pkt */
pkt->pkt_ip->ip_dst, /* orig dst becomes new src addr */
pkt->pkt_ip->ip_src);
new->pkt_udp_data = (u_char *)(new->pkt_ip_data + UDP_HDR_LEN);
new->pkt_end = (u_char *)new->pkt_eth_data + ntohs(new->pkt_ip->ip_len);
udp_pack_hdr(new->pkt_udp,
htons(pkt->pkt_udp->uh_dport),
htons(pkt->pkt_udp->uh_sport),
UDP_HDR_LEN + pdu_len);
memcpy(new->pkt_udp_data, buf, pdu_len);
free(buf);
ip_checksum(new->pkt_ip, new->pkt_end - new->pkt_eth_data);
int ret_code = eth_send(io.eth, new->pkt_eth, new->pkt_end - (u_char *)new->pkt_eth);
if (ret_code < 0)
printf("*** Problem sending packet\n");
}
snmp_free_pdu_vars(&p);
snmp_free_pdu(&p);
}
```
Какая длинная функция получилась, попробую объяснить (если захотите, нарубите её на кусочки самостоятельно).
Вначале объявляем переменную `p` типа `snmp_pdu_t` и парсим в неё информацию из полученного пакета. Делаем это как раз функцией `snmp_dec_pdu` спрятанной от пользователей csnmp.
Далее на консоль показываем — что именно мы получили и приступаем непосредственно к формированию ответа. Ответ мы будем формировать корректируя уже готовую переменную p — почти также, как мы ранее обращались с пакетом icmp echo request.
Условный оператор switch на основании значений `p.command` раскидывает логику обработки запроса по нескольким веткам. Допустимые варианты данном контексте: `SNMP_CMD_GET, SNMP_CMD_GET_NEXT, SNMP_CMD_SET, SNMP_CMD_GET_BULK`. Мы пока что реализуем `SNMP_CMD_GET`, а также оставим заготовку для `SNMP_CMD_GET_NEXT` — всё остальное идёт в `default`.
Как уже писал выше, сначала сменим тип snmp-пакета — он теперь должен стать `SNMP_CMD_RESPONSE`. Далее в цикле пробежимся по переменным в данном запросе, почистим их значения, и если запрашиваемый oid равен `.1.3.6.1.2.1.1.1.0` (system.sysDescr.0) то готовим ответ типа Octet String. Как видно исходники — это всё вставляется в поля `type` и `value`.
Значения `OID`, их типы, описания можно посмотреть в вашей локальной системе (`/usr/share/snmp/mibs/SNMPv2-MIB.txt`) или поискать в интернете по ключам: «SNMPv2 MIB», «RFC 3418:12/2002».
Цикл с пробежкой по переменным я честно скопипастил из демо-кода csnmp. На мой взгляд, было бы достаточно поработать только с переменной имеющей индекс 0, но, кажется, автор csnmp более продвинут в этом вопросе, поэтому пока оставил так.
Сама переменная типа `snmp_var_t` это структура из 3-х полей: `oid` — структура типа `snmp_oid_t` (точнее, `ans1_oid_t`) хранящая «имя» snmp-переменной; `type` — целое число, определяющее тип значения; `value` — указатель на само значение, т.е. адрес в памяти, где оно располагается.
В случае если желаемый `oid` не совпал с нашими возможностями, мы просто ставим тип переменной `SNMP_TP_NO_SUCH_OBJ` и следуем к формированию пакета и возврату его обратно.
Отправку пакета завернул в условие `if (p.command == SNMP_CMD_RESPONSE)`. Это логично и правильно — если мы не заинтересовались пакетом, то не сменили его тип на ответ, а следовательно — и отвечать на него не считаем нужным.
Формирование пакета также производим с помощью «скрытой» функции `snmp_enc_pdu`. Далее кропотливая сборка пакета, вычисление размеров на каждом уровне и отправка — всё это было описано в предыдущей статье, здесь только отличие в протоколе UDP.
Ну и в финале мы очищаем переменные — если глянуть декларацию `asn1_new_str` (мы с её помощью формировали значение для отправки ответа), то становится понятно, что внутри этой функции выделяется память, которую нужно в итоге освободить и, кстати, в следующем разделе это будет видно более явно. Также необходимо очистить и саму pdu — там тоже достаточно компонентов с динамически выделяемой памятью.
Код написан, пора пробовать.
Отлично! Всё работает как и ожидалось. Было точное совпадение OID — получите искомое, не совпало — ну нет, значит нет. Переходим на следующий этап.
▍ Обрабатываем snmpgetnext
--------------------------
Обработка запросов типа snmpgetnext будет также вписана в нашу мегафункцию `void send_snmp_reply(struct pkt *pkt)` — помнится, для этого там было зарезервировано местечко.
Вставляем:
```
case SNMP_CMD_GET_NEXT:
p.command = SNMP_CMD_RESPONSE;
v = &p.vars[0];
// спрашивают, что у нас идёт за system.sysDescr.0
if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,1,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysObjectID.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,2,0}, 9);
v->type = SNMP_TP_OID;
v->value = asn1_new_oid((int[10]){1,3,6,1,4,1,318,1,3,7}, 10);
}
// запрос system.sysObjectID.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,2,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysUpTime.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,3,0}, 9);
v->type = SNMP_TP_TIMETICKS;
v->value = malloc(sizeof(int));
*(int *)v->value = ((((5*24) + 11)*60 + 35)*60 + 24)*100 + 22; // 5 days, 11:35:24.22
}
// запрос system.sysUpTime.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,3,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysContact.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,4,0}, 9);
v->type = SNMP_TP_OCT_STR;
v->value = asn1_new_str("Comparitech", 0);
}
// запрос system.sysContact.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,4,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysName.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,5,0}, 9);
v->type = SNMP_TP_OCT_STR;
v->value = asn1_new_str("APC-3425", 0);
}
// запрос system.sysName.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,5,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysLocation.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,6,0}, 9);
v->type = SNMP_TP_OCT_STR;
v->value = asn1_new_str("3425EDISON", 0);
}
// запрос system.sysLocation.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,6,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем system.sysServices.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,7,0}, 9);
v->type = SNMP_TP_INT;
v->value = malloc(sizeof(int));
*(int *)v->value = 72;
}
// запрос system.sysServices.0
else if (asn1_cmp_oids(v->oid, asn1_crt_oid((int[9]){1,3,6,1,2,1,1,7,0}, 9)) == 0) {
snmp_free_var(v);
// возвращаем inerfaces.ifTable.ifEntry.ifIndex.1
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,2,1,0}, 9);
v->type = SNMP_TP_INT;
v->value = malloc(sizeof(int));
*(int *)v->value = 1;
}
// запрос что-нибудь начинающееся с system
else if (asn1_oid_has_prefix(v->oid, asn1_crt_oid((int[7]){1,3,6,1,2,1,1}, 7))) {
snmp_free_var(v);
// возвращаем system.sysDescr.0
v->oid = asn1_crt_oid((int[9]){1,3,6,1,2,1,1,1,0}, 9);
v->type = SNMP_TP_OCT_STR;
v->value = asn1_new_str("APC Web/SNMP Management Card", 0);
}
else
v->type = SNMP_TP_NO_SUCH_OBJ;
break;
default:
```
Пробежимся по коду. С ходу меняем значение `p.command` на `SNMP_CMD_RESPONSE` — это уже знакомо. Далее берём только значение переменной с индексом 0 — решил тут сильно не загромождать код, думаю для тестового прототипа это допустимо.
Ну а дальше муторная и монотонная (конкретно в данной демонстрашке — разумеется, боевой код так писать нельзя) работа по сверке запрошенного `oid` и подготовке ответа: освобождение памяти от переменной, формирование `oid` следующего элемента, его тип и значение. Тут хорошо видно как обрабатывать значения различных типов, а также фигурирует более явное выделение памяти посредством `malloc`.
На освобождение памяти хочу обратить особое внимание. Если помните, в прошлый раз чистили только значения (`snmp_free_var_value`), а сейчас переменную целиком (`snmp_free_var`). Всё дело в протоколе snmp — при вызове snmpget мы просим дать значение конкретного `oid`, т.е. он не меняется, а при snmpgetnext нужно дать значение следующего элемента. Соответственно, в ответе у нас будет изменены не только тип и значение, но также будет совсем другой `oid`. Именно это и требует от нас тотальной зачистки.
Также особого внимания заслуживают два последних условия:
Когда мы обрабатываем последний `oid` на нашем уровне, в данном случае `.1.3.6.1.2.1.1.7.0`, мы не возвращаем в качестве следующего элемента `SNMP_TP_NO_SUCH_OBJ`, что кажется вполне логичным, а возвращаем первый элемент из соседней веточки. На самом деле мы с помощью snmpwalk можем пройтись по любому уровню дерева snmp как ближе к корню, так и почти на конце какой-либо ветки — он не будет выходить за пределы запроса — при получении ответа с `oid` вне запрошенного уровня он завершает опрос. А вот если бы мы вернули `SNMP_TP_NO_SUCH_OBJ`, то запрос snmpwalk с более высокого уровня прервался на нашей веточке и не пробежался по соседним. Также этот `oid` должен вернуться при обращении к oid большим чем `.1.3.6.1.2.1.1.7.0`
В последнем условии производится сравнение запроса только на префикс. Это тоже особое поведение snmp-демона — при обращении в начальные области нашей ветки должен вернуться `oid` первого элемента — это `.1.3.6.1.2.1.1.1.0`. Другими словами, все запросы к `system(.1.3.6.1.2.1.1)` или `system.sysDescr(.1.3.6.1.2.1.1.1)` должны вернуть нам ссылку и значение `system.sysDescr.0(.1.3.6.1.2.1.1.1.0)`, а вот обращение реально существующей `system.sysDescr.0(.1.3.6.1.2.1.1.1.0)` вернёт следующий элемент — `system.SysObjectID.0(.1.3.6.1.2.1.1.2.0)`
Приступаем к тестированию:
Длинный вывод я подрезал, но уже видно, что snmpwalk ничего не заподозрил!
Следующая проверка
Результат, на первый взгляд, не совсем корректный, однако если сравнить `oid` запроса и `oid` элемента, который был возвращён в последний раз, то становится понятно — элемент вышел за уровень запроса и snmpwalk остальное перестало интересовать.
Ну а напоследок один каверзный запрос:
Внимательно изучаем отладочный вывод: snmpwalk умный парень — хоть и получил сразу ответ идти в соседнюю ветку, но на этом не успокоился, а произвёл контрольный вопрос через snmpget — так есть кто живой с этим `oid` или нет? Кстати, если сейчас попробуете на других `oid`, то получите совсем другой результат, это потому что в первой части статьи написана обработка snmpget только для `system.sysDescr.0` :)
▍ Финал
-------
На этом достаточно знакомства с богатым внутренним миром такого «простого» протокола как SNMP. А для решения моей основной задачи осталось совсем немного — определится с различными структурами хранения oid и их значений, привязка к базе ip-адресов, сделать чтобы всё это извлекалось и обрабатывалось в разумные временные рамки. Это реализуется простыми и понятными алгоритмами — хэши/деревья/ключи-значения и пр. но уже не в рамках данной статьи.
Всем приятных pet-проектов :)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=alef13&utm_content=kak_zavladet_setyu_16_s_pomoshhyu_libpcap_i_libdnet_rabotaem_s_protokolom_snmp) | https://habr.com/ru/post/697854/ | null | ru | null |
# Как перестать использовать MVVM
На недавнем [DroidCon Moscow 2016](http://droidcon.moscow/ru/#program) был доклад о MVVM c Databinding Library и доклад о библиотеке [Moxy](https://github.com/Arello-Mobile/Moxy), помогающей работать с MVP. Дело в том, что за последние полгода мы успели опробовать оба подхода на живых проектах. И я хочу рассказать о своём пути от освоения Databinding Library и выпуска в продакшн проекта на MVVM до осознания, **почему я больше не хочу использовать этот паттерн**.
> Посвящается всем, кого зацепила Databinding Library и кто решил строить приложение на MVVM, – вы отважные люди!
Databinding Library
-------------------
Начав разбираться с [Databinding Library](https://developer.android.com/topic/libraries/data-binding/index.html), я был под впечатлением. Те, кто уже знаком с ней, меня поймут, а для остальных, вот как выглядит работа с этой библиотекой:
Использование Databinding Library позволяет:
* Избавиться от вызовов `findViewById` и `setOnClickListener`. То есть, указав id в *xml*, можно обращаться к *view* через `binding.viewId`. И можно устанавливать вызовы методов прямо из *xml*;
* Связать данные напрямую с элементами *view*. Мы вызываем `binding.setUser(user)`, а в *xml* указываем, к примеру, `android:text = “@{user.name}”`;
* Создавать кастомные атрибуты. Например, если мы хотим загружать изображения в ImageView при помощи библиотеки Picasso, то можем создать *BindingAdapter* для атрибута “imageUrl”, а в *xml* писать `bind:url=”@{user.avatarUrl}”`.
Такой BindingAdapter будет выглядеть так:
```
@BindingAdapter("bind:imageUrl")
public static void loadImage(ImageView view, String url) {
Picasso.with(view.getContext()).load(url).into(view);
}
```
* Cделать состояние *view* зависимым от данных. Например, отображается ли индикатор загрузки, будет зависеть от того, есть ли данные.
Последний пункт особенно приятен для меня потому, что состояния всегда были сложной темой. Если на экране нужно отобразить три состояния (загрузка, данные, ошибка), это ещё ладно. Но, когда появляются различные требования к состоянию элементов в зависимости от данных (например, отображать текст только если он не пустой, или менять цвет в зависимости от значения), может понадобиться либо большой *switch* cо всеми возможными вариантами состояний интерфейса, либо много флагов и кода в методах установки значений элементам.
Поэтому то, что Databinding Library позволяет упростить работу с состояниями, – огромный плюс. К примеру, написав в *xml* `android:visibility=”@{user.name != null ? View.VISIBLE : View.GONE}”`, мы можем больше не думать о том, когда надо скрыть или показать TextView с именем пользователя. Мы просто задаём имя, а видимость изменится автоматически.
ViewModel
---------
Но, начав использовать *databinding* активнее, вы получите в *xml* всё больше и больше кода. И, чтобы не превращать *layout* в свалку, мы создадим класс, в который вынесем этот код. А в *xml* будут оставаться только вызовы свойств. Приведу маленький пример. Предположим, есть класс User:
```
public class User {
public firstname;
public lastname;
}
```
А в UI мы хотим видеть полное имя и пишем в *xml*:
Это не очень хочется видеть в *xml*, и мы создаём класс, в который выносим эту логику:
```
public class UserViewModel extends BaseObservable {
private String name;
@Bindable
public String getFullname() {
return name;
}
public void setUser(User user) {
name = user.firstname + user.lastname;
notifyPropertyChanged(BR.name);
}
}
```
Создатели библиотеки предлагают называть такие классы **ViewModel** (прям, как в паттерне MVVM, удивительно).
> В примере класс наследуется от BaseObservable, a в коде вызывает notifyPropertyChanged(), но это не единственный способ. Можно также обернуть поля в ObservableField, и зависимые элементы UI будут обновляться автоматически. Но я считаю такой способ менее гибким и редко его использую.
Теперь в *xml* у нас будет:
Гораздо лучше, не правда ли?
Итак, у нас появился ViewModel класс, который выступает в роли прослойки между данными и *view*. Он занимается преобразованиями данных, управляет тем, какие поля (и связанные элементы UI) и когда обновляются, содержит логику того, как одни поля зависят от других. Это позволяет очистить *xml* от кода. Кроме того, удобно использовать этот класс для обработки событий из *view* (нажатия и т.п).
И тут к нам приходит мысль: **Если у нас уже есть *databinding*, есть ViewModel класс, содержащий логику отображения, то почему бы не использовать паттерн MVVM?**
Эта мысль приходит неизбежно. Потому что то, что мы имеем в данный момент очень и очень близко к тому, что из себя представляет паттерн MVVM. Давайте кратко его рассмотрим.
MVVM
----
В паттерне [Model-View-ViewModel](https://msdn.microsoft.com/en-us/library/hh848246.aspx) три основных компонента:
* **Model**. Бизнес-логика приложения, предоставляющая данные для отображения.
* **View**. Отвечает за внешний вид, расположение и структуру всех UI-элементов, которые пользователь видит на экране.
* **ViewModel**. Выступает мостом между View и Model и обрабатывает логику отображения. Запрашивает у Model данные и передает их View в виде, который View может легко использовать. Также содержит обработку событий, совершенных пользователем приложения во View, таких, как нажатие на кнопку. Кроме того, ViewModel отвечает за определение дополнительных состояний View, которые надо отображать, например, идет ли загрузка.
Связь и взаимодействие между собой этих компонентов мы видим на картинке:
Стрелками показаны зависимости: View знает о ViewModel, а ViewModel знает о Model, но модель ничего не знает о ViewModel, которая ничего не знает о View.
Процесс такой: ViewModel запрашивает данные у Model и обновляет её когда необходимо. Model уведомляет ViewModel, что данные есть. ViewModel берёт данные, преобразует их и уведомляет View, что данные для UI готовы. Связь между ViewModel и View осуществляется путём автоматического связывания данных и отображения. В нашем случае это достигается через использование Databinding Library. При помощи *databinding*’а View обновляется, используя данные из ViewModel.
> Наличие автоматического связывания (databinding) является главным отличием этого паттерна от паттерна [PresentationModel](http://martinfowler.com/eaaDev/PresentationModel.html) и [MVP](https://ru.wikipedia.org/wiki/Model-View-Presenter) (в MVP Presenter изменяет View путём вызова на ней методов через предоставленный интерфейс).
MVVM в Android
--------------
Так я начал использовать MVVM в своем проекте. Но, как часто бывает в программировании, теория и практика – не одно и тоже. И после завершения проекта у меня осталось чувство неудовлетворенности. **Что-то было не так в этом подходе, что-то не нравилось, но я не мог понять, что именно**.
Тогда я решил нарисовать схему MVVM на Android:
Рассмотрим, что в итоге получается:
**ViewModel** содержит поля, используемые в *xml* для биндинга данных (`android:text=”@{viewmodel.username}”`), обрабатывает события вызванные на View (`android:onClick=”@{viewmodel::buttonClicked}”`). Она запрашивает данные у Model, преобразует их, и при помощи *databinding*’a эти данные попадают во View.
**Fragment** одновременно выполняет две роли: входная точка, обеспечивающая инициализацию и связь с системой, и View.
То, что Fragment (или Activity) рассматриваются как View в понимании паттернов MVP и MVVM, уже стало распространённой практикой, поэтому я не стану на этом останавливаться.
Чтобы пережить повороты и пересоздание Activity, мы оставляем ViewModel жить на то время, пока пересоздаётся View (в нашем случае Fragment). Достигается это с использованием [dagger](https://google.github.io/dagger/) и пользовательских [scopes](http://frogermcs.github.io/dependency-injection-with-dagger-2-custom-scopes/). Не стану вдаваться в подробности, уже написано много хороших статей про *dagger*. Своими словами, происходит следующее:
* ViewModel создается при помощи *dagger* (и её инстанс живёт в нём), и фрагмент берет её когда нужно.
* Когда фрагмент умирает при повороте, он вызывает *detachView()* у ViewModel.
* ViewModel продолжает жить, её фоновые процессы тоже, и это очень удобно.
* Потом, когда фрагмент пересоздан, он вызывает *attachView()* и передаёт себя в качестве View (используя интерфейс).
* Если же фрагмент умирает полностью, а не из-за поворота, то он убивает *scope* (обнуляется нужный компонент *dagger*, и ViewModel может быть собрана *garbage collector*’ом вместе с этим компонентом) и ViewModel умирает. Это реализовано в **BaseFragment**.
> Зачем фрагмент передаёт себя во ViewModel, используя интерфейс **MvvmView**? Это нужно для того, чтобы мы могли **вызывать команды «вручную»** на View. Не всё можно сделать при помощи Databinding Library.
При необходимости сохранения состояния в случае, когда система убила приложение, мы можем сохранять и восстанавливать состояние ViewModel, используя *savedInstanceState* фрагмента.
Примерно так всё работает.
Внимательный читатель спросит: «A чего мучаться с *dagger custom scopes*, если можно просто использовать Fragment как контейнер и вызвать в нём `setRetainInstance(true)`?» Да, так сделать можно. Но, рисуя схему, я учитывал, что в качестве View можно использовать Activity или ViewGroup.
> Недавно я нашел [хороший пример реализации MVVM](https://github.com/patloew/countries), полностью отражающий нарисованную мной структуру. За исключением пары нюансов, всё сделано очень хорошо. Посмотрите, если интересно.
Проблема двойственности
-----------------------
Нарисовав схему и обдумав всё, я понял, что именно меня не устраивало во время работы с этим подходом. Взгляните на схему снова. Видите толстые стрелки «*databinding*» и «*manual commands to view*»? Вот оно. Сейчас расскажу подробнее.
Раз у нас есть *databinding*, то большую часть данных мы можем просто устанавливать в View при помощи *xml* (создав нужный BindingAdapter, если понадобится). Но **есть случаи, которые не укладываются в этот подход**. К таким относятся диалоги, *toast*’ы, анимации, действия с задержкой и другие сложные действия с элементами View.
Вспомним пример с TextView:
Что, если нам нужно установить этот текст, используя `view.post(new Runnable())`? (Не думаем зачем, думаем как)
Можно сделать BindingAdapter, в котором создать атрибут «byPost», и сделать, чтобы учитывалось наличие перечисленных атрибутов у элемента.
```
@BindingAdapter(value = {"text", "byPost"}, requireAll = true)
public static void setTextByPost(TextView textView, String text, boolean byPost) {
if (byPost) {
textView.post(new Runnable {
public void run () {
textView.setText(text);
}
})
} else {
textView.setText(text);
}
}
```
И теперь каждый раз, когда у TextView будут указаны оба атрибута, будет использоваться этот BindingAdapter. Добавим атрибут в *xml*:
ViewModel теперь должно иметь свойство, указывающее на то, что в момент установки значения мы должны использовать `view.post()`. Добавим его:
```
public class UserViewModel extends BaseObservable {
private String name;
private boolean usePost = true; // only first time
@Bindable
public String getFullname() {
return name;
}
@Bindable
public boolean getUsePost() {
return usePost;
}
public void setUser(User user) {
name = user.firstname + user.lastname;
notifyPropertyChanged(BR.name);
notifyPropertyChanged(BR.usePost);
usePost = false;
}
}
```
Видите, сколько всего нужно сделать, чтобы реализовать очень даже простое действие?
**Поэтому гораздо проще делать подобные вещи прямо на View**. То есть использовать интерфейс MvvmView, который реализуется нашим фрагментом, и вызывать методы View (так же, как это обычно делается в MVP).
> Вот тут и проявляется **проблема двойственности: мы работаем с View двумя разными способами**. Один – автоматический (через состояние данных), второй – ручной (через вызовы команд на view). Лично мне это не по душе.
Проблема состояний
------------------
Теперь расскажу о ещё одной проблеме. Представим ситуацию с поворотом телефона.
1. Мы запустили приложение. ViewModel и View (фрагмент) живы.
2. Повернули телефон – фрагмент умер, а ViewModel живёт. Все её фоновые задачи продолжают работать.
3. Новый фрагмент создался, присоединился. View через *databinding* получила сохраненное состояние (поля) из ViewModel. Всё круто.
4. Но что если в тот момент, когда фрагмент (View) отсоединён, фоновый процесс завершился с ошибкой, и мы хотим показать *toast* об этом? Фрагмент (выполняющий роль View) мёртв, и вызвать метод на нём нельзя.
5. Мы потеряем этот результат.
Получается, что **нужно как-то хранить не только состояние View, представленное набором полей ViewModel, но также и методы, которые ViewModel вызывает на View**.
Эту проблему можно решить, заводя во ViewModel поля-флаги на каждый отдельный такой случай. Это не очень-то красиво и не универсально. Но работать будет.
Про состояния
-------------
Проблема состояний натолкнула меня на мысли, что *состояние объекта можно воссоздать двумя путями: набором параметров, характеризующим состояние, или набором действий, которые необходимо совершить, чтобы привести объект в нужное состояние*.
Представьте себе кубик Рубика. Его состояние можно описать 9 цветами на одной из граней. А можно набором движений, которые приведут его из начального состояния в требуемое.
Может понадобиться всего один поворот, а может и намного больше девяти. Получается, в зависимости от ситуации, какой-то способ описания состояния лучше или хуже (меньше данных нужно).
Moxy
----
Обдумывая способы воссоздания состояния, я не мог не вспомнить о библиотеке Moxy. Мои коллеги параллельно делали проект, используя паттерн MVP и эту библиотеку. Подробно я о ней рассказывать не стану, уже есть [отличная статья от авторов](https://habrahabr.ru/post/276189/).
В контексте моих рассуждений интересна одна **особенность Moxy – она хранит состояние *view* как набор команд, вызванных на этой *view***. И, когда я узнал об этом впервые, мне это показалось странным.
Но теперь, после всех размышлений (которыми я поделился с вами выше), я думаю, что это очень удачное решение.
Потому что:
* Не всегда можно (удобно) представить состояние только данными (полями).
* В MVP общение с View идёт через вызовы команд. Почему бы это не использовать?
* В реальности количество полей *view*, нужных, чтобы воссоздать ее состояние, может быть куда больше числа вызванных на ней команд.
Кроме того, этот подход даёт ещё один плюс. Он также, как и Databinding Library, по-своему решает проблему большого количества разных состояний. Тоже не придется писать огромный *switch*, изменяющий UI в зависимости от набора полей или названия одного из состояний, так как изменения воссоздаются набором вызовов методов.
И всё же я не могу совсем ничего больше не сказать про Moxy. По моему мнению и мнению моих коллег, на сегодняшний день она является лучшей библиотекой, которая помогает наладить работу с паттерном MVP. Она использует генерацию кода, чтобы минимизировать трудозатраты разработчика. Вы можете не думать о реализации паттерна, а думать о функционале своего проекта. А это хорошо.
Но хватит про MVP. Всё-таки речь у нас про MVVM, и пора подвести итоги.
Выводы
------
Мне нравится MVVM как паттерн, и я не оспариваю его плюсы. Но в большинстве своём они те же самые, что у других паттернов, либо являются делом вкуса разработчика. Да и основной плюс даёт всё же *databinding*, а не сам паттерн.
Ведомый симпатией к MVVM, я реализовал проект на нём. Долго изучал тему, обдумывал, обсуждал и вынес для себя набор минусов этого паттерна:
* MVVM заставляет работать с View одновременно двумя путями: через *databinding* и через методы View.
* С MVVM нельзя красиво решить проблему состояний (необходимости сохранения вызова метода View, вызванного когда View была отсоединена от ViewModel).
* Необходимо продвинутое использование Databinding Library, что требует времени на освоение.
* Код в *xml* далеко не всем нравится.
Да, с этими минусами можно свыкнуться. Но после долгих раздумий я пришел к выводу, что **не хочу работать с паттерном, который создает раздробленность подходов**. И решил, что следующий проект буду писать, используя MVP и Moxy.
Использовать ли вам этот паттерн – решайте сами. ~~Но я вас предупредил.~~
#### PS: Databinding Library
Закончим, пожалуй, тем же, с чего и начали – Databinding Library. Мне она по-прежнему нравится. Но использовать её я собираюсь только в ограниченном количестве:
* Чтобы не писать `findViewById` и `setOnClickListener`.
* И чтобы создавать удобные *xml*-атрибуты при помощи BindingAdapter-ов (например, `bind:font=”Roboto.ttf”`).
И всё. Это даст плюсы, но не станет манить в сторону MVVM.
Если вы тоже планируете работать с Databinding Library, то вот вам немного полезной информации:
* Вызывайте `binding.executePendingBindings()` в `onViewCreated()` после задания переменных биндингу. Это поможет, если вы хотите менять что-то в только что созданных *view* из кода. Не придётся писать `view.post()`, узнав, что *view* ещё не готова.
* В тег переменную передать (как можно в ) нельзя: <https://code.google.com/p/android/issues/detail?id=175338>.
* Лямбды в *xml* в Databinding Library с особенностями. Нельзя писать без скобок (`() -> method()`). Нельзя блок кода. Зато можно опустить параметры, если не используются в методе (`android:onClick=”@{() -> handler.buttonClicked()}”`).
* backtick (`) можно юзать вместо двойных кавычек (“).
* В BindingAdapter-aх пишите только атрибуты (`@BindingAdapter(“attributeName”)`), *namespace* всё равно игнорируется. И в *xml* не важно, какой будет *namespace*. Но часто используют *bind*, чтобы отличать (`bind:attributeName=”...”`).
* Сгенерированные databinding-классы искать тут: app/build/intermediates/classes/debug
* Готовые адаптеры можно посмотреть [тут](http://androidxref.com/7.0.0_r1/xref/frameworks/data-binding/extensions/baseAdapters/src/main/java/android/databinding/adapters/).
* Что почитать кроме документации:
<https://realm.io/news/data-binding-android-boyar-mount/>
<https://www.bignerdranch.com/blog/descent-into-databinding/>
<https://halfthought.wordpress.com/2016/03/23/2-way-data-binding-on-android/> | https://habr.com/ru/post/312548/ | null | ru | null |
# Postgres-вторник №5: «PostgreSQL и Kubernetes. CI/CD. Автоматизация тестирования»
В конце минувшего года состоялся очередной прямой эфир российского PostgreSQL-сообщества [#RuPostgres](https://www.meetup.com/postgresqlrussia/), в рамках которого его сооснователь Николай Самохвалов поговорил с техническим директором «Фланта» Дмитрием Столяровым про эту СУБД в контексте Kubernetes.
Мы публикуем стенограмму основной части этой дискуссии, а на [YouTube-канале сообщества](https://www.youtube.com/channel/UC0SBGSNmBLrTZIkbN-lJHnw) опубликована полная видеозапись:
Базы данных и Kubernetes
------------------------
***НС**: Мы не будем сегодня про VACUUM и CHECKPOINT'ы. Хотим поговорить про Kubernetes. Я знаю, что у тебя уже много лет опыта. Смотрел твои видео и некоторые даже кусочками пересматривал… Давай сразу с места в карьер: зачем вообще Postgres или MySQL в K8s?*
**ДС**: Однозначного ответа на этот вопрос нет и не может быть. Но вообще, это простота и удобство… потенциальные. Всем ведь хочется managed-сервисов.
***НС**: Чтобы как [RDS](https://aws.amazon.com/rds/), только у себя?*
**ДС**: Да: чтобы как RDS, только где угодно.
***НС**: «Где угодно» — это хорошее замечание. В больших компаниях всё расположено в разных местах. А почему тогда, если это большая компания, не взять готовое решение? Например, есть у Nutanix свои разработки, у других компаний (VMware…) — тот же «RDS, только у себя».*
**ДС**: Но это мы говорим про отдельно взятую реализацию, которая будет работать только в определённых условиях. А если речь про Kubernetes, то здесь огромное разнообразие инфраструктуры (которая может быть в K8s). По сути это стандарт для API к облаку…
***НС**: Ещё и бесплатно!*
**ДС**: Это не так важно. Бесплатность важна не очень большому сегменту рынка. Важно другое… Ты, наверное, вспоминаешь доклад «[Базы данных и Kubernetes](https://habr.com/ru/company/flant/blog/431500/)»?
***НС**: Да.*
**ДС**: Я понял, что его восприняли очень неоднозначно. Часть людей подумали, что я говорю: «Ребята, поехали всеми БД в Kubernetes!», — а другие решили, что это всё жуткие велосипеды. А я-то хотел сказать вообще о другом: «Смотрите, что происходит, какие есть проблемы и как их можно решать. Сейчас ехать базами в Kubernetes? Production'ом? Ну, только если вы любите… заниматься определёнными вещами. А вот для dev'а — могу сказать, что рекомендую. Для dev'а очень важна динамичность создания/удаления окружений».
*НС: Под dev'ом ты имеешь в виду все окружения, которые не prod? Staging, QA…*
**ДС**: Если говорим про perf-стенды, то уже, наверное, нет, потому что там требования специфичны. Если говорим про особые случаи, где на staging нужна очень большая БД, то тоже, наверное, нет… Если это статичное окружение, долгоживущее, то какая выгода от того, что база расположена в K8s?
***НС**: Никакой. Но где мы видим статичные окружения? Статичное окружение устарело уже завтра.*
**ДС**: Staging может быть статичным. У нас есть клиенты…
***НС**: Да, у меня тоже есть. Большая проблема, если у тебя есть база на 10 Тб, а staging — 200 Гб…*
**ДС**: У меня есть очень крутой кейс! На staging находится prod'овая база, в которую вносят изменения. И предусмотрена кнопка: «выкатить в production». Эти изменения — дельты — доливаются (кажется, просто по API'шке синхронизируются) в production. Это очень экзотичный вариант.
***НС**: Я видел стартапы в Долине, которые сидят в RDS'е или даже в Heroku ещё — это истории 2-3-летней давности, — и они скачивают дамп себе на лаптоп. Потому что база пока всего лишь 80 Гб, а на лаптопе есть место. Потом они докупают диски каждому, чтобы по 3 базы иметь, чтобы разные разработки вести. Вот так бывает тоже. Также видел, что не боятся prod копировать в staging — очень сильно зависит от компании. Но видел и что очень боятся, и что часто не хватает времени и рук. Но прежде, чем мы перейдём к этой теме, хочется услышать про Kubernetes. Я правильно понимаю, что в prod'е пока ни у кого?*
**ДС**: У нас небольшие базы есть в prod'е. Речь про объемы в десятки гигабайт и некритичные сервисы, для которых лень было делать реплики (да и нет такой потребности). И при условии, что под Kubernetes'ом есть нормальное хранилище. Эта база работала в виртуальной машине — условно в VMware, поверх СХД. Мы её поместили в [PV](https://kubernetes.io/docs/concepts/storage/persistent-volumes/) и теперь можем переносить её с машины на машину.
***НС**: Базы такого размера, до 100 Гб, на хороших дисках и при хорошей сети можно раскатать за несколько минут, правильно? Скорость в 1 Гб в секунду — это уже не экзотика.*
**ДС**: Да, для линейной операции это не проблема.
***НС**: Окей, про prod мы должны только думать. А если мы рассматриваем Kubernetes для не-prod-окружений — как делать? Я вижу, что в Zalando [делают оператор](https://github.com/zalando/postgres-operator), в Crunchy [пилят](https://github.com/CrunchyData/postgres-operator), есть ещё какие-то варианты. И есть [OnGres](https://ongres.com/) — это наш хороший знакомый Alvaro из Испании: они делают по сути не просто [оператор](https://habr.com/ru/company/flant/blog/326414/), а целый дистрибутив ([StackGres](https://gitlab.com/ongresinc/stackgres)), в который помимо самого Postgres'а ещё и бэкап решили запихать, прокси Envoy…*
**ДС**: Envoy для чего? Балансировки именно трафика Postgres?
***НС**: Да. То есть они это видят как: если взять Linux-дистрибутив и ядро, то обычный PostgreSQL — это ядро, а они хотят сделать дистрибутив, который будет дружелюбен к облакам и крутиться в Kubernetes. Они стыкуют компоненты (бэкапы и т.п.) и отлаживают, чтобы они хорошо работали.*
**ДС**: Очень круто! По сути это софт, чтобы сделать свой managed Postgres.
***НС**: У Linux-дистрибутивов вечные проблемы: как делать драйверы, чтобы всё железо поддерживалось. А у них идея, что они в Kubernetes будут работать. Я знаю, что в операторе Zalando мы недавно увидели завязку на AWS и это уже не очень хорошо. Не должно же быть завязки на конкретную инфраструктуру — в чём тогда смысл?*
**ДС**: Не знаю, в какой ситуации конкретно Zalando завязался, но в Kubernetes сейчас storage сделан так, что нельзя generic-способом снять дисковый бэкап. Недавно в стандарте — в последней версии [спецификации CSI](https://habr.com/ru/company/flant/blog/465417/) — сделали возможность снапшотов, но где она реализована? Честно, всё ещё настолько сырое… Мы пробуем CSI поверх AWS, GCE, Azure, vSphere, но чуть начинаешь использовать, как видно, что оно ещё не готово.
***НС**: Поэтому и приходится иногда завязываться на инфраструктуру. Думаю, это ещё продолжается ранняя стадия — проблемы роста. Вопрос: что бы ты посоветовал новичкам, которые хотят попробовать PgSQL в K8s? Какой оператор, может быть?*
**ДС**: Проблема в том, что Postgres для нас — это 3%. У нас есть ещё очень большой список разного софта в Kubernetes, не буду даже всё перечислять. Например, Elasticsearch. Операторов — куча: какие-то развиваются активно, другие — нет. Мы для себя составили требования, что должно быть в операторе, чтобы мы воспринимали его всерьёз. В операторе именно для Kubernetes — не в «операторе, чтобы делать что-то в условиях Amazon'а»… По факту мы достаточно массово (= почти у всех клиентов) используем единственный оператор — [для Redis](https://github.com/spotahome/redis-operator) *(скоро опубликуем статью и о нём)*.
***НС**: А для MySQL тоже нет? Я знаю, что Percona… так как они теперь занимаются и MySQL, и MongoDB, и Postgres, они должны будут какой-то универсальный запилить: для всех баз, для всех облачных провайдеров.*
**ДС**: Мы не успели посмотреть на операторы для MySQL. Для нас это сейчас не главный фокус. MySQL нормально работает в standalone. Зачем оператор, если можешь просто запустить БД… Можно запустить Docker-контейнер с Postrges, а можно запустить его по-простому.
***НС**: Об этом тоже был вопрос. Вообще без оператора?*
**ДС**: Да, в 100% у нас PostgreSQL запущен без оператора. Пока что так. Мы активно используем оператор для Prometheus, для Redis. У нас есть в планах найти оператор для Elasticsearch — он больше всего «горит», потому что хотим его в 100% случаях ставить в Kubernetes. Так же, как мы хотим прийти к тому, чтобы MongoDB тоже всегда ставить в Kubernetes. Тут появляются определённые хотелки — есть ощущение, что в этих случаях можно что-то сделать. А про Postgres мы даже не смотрели. Конечно, знаем про существование разных вариантов, но по факту у нас standalone.
БД для тестирования в Kubernetes
--------------------------------
***НС**: Давай перейдём к теме тестирования. Как раскатывать изменения в базе — с точки зрения DevOps-перспективы. Есть микросервисы, много баз, всё время где-то что-то меняется. Как обеспечить нормальный CI/CD, чтобы с позиции СУБД всё было в порядке. Какой у тебя подход?*
**ДС**: Не может быть одного ответа. Есть несколько параметров. Первый — это размер базы, которую мы хотим раскатать. Ты сам упомянул, что в компаниях по-разному относятся к тому, чтобы копия prod-базы была на dev и stage.
***НС**: А в условиях GDPR, я думаю, они относятся всё более и более аккуратно… Могу сказать, что в Европе уже начали штрафовать.*
**ДС**: Но зачастую можно написать софт, который делает дамп с production'а и его обфусцирует. Получаются prod'овые данные (снапшот, дамп, бинарная копия…), но они анонимизированные. Вместо этого могут быть и скрипты генерации: это могут быть фикстуры или просто скрипт, который генерирует большую базу. Проблема-то какая: сколько времени создаётся базовый образ? И сколько времени развернуть его на нужном окружении?
Мы пришли к схеме: если у клиента есть фикстурный набор данных (минимальная версия базы), то по умолчанию используем их. Если речь идёт о review-окружениях, когда мы создали branch, у нас развернулся экземпляр приложения — мы туда раскатываем маленькую базу. Но хорошо получился и [вариант](https://habr.com/ru/company/flant/blog/417509/), когда с production'а раз в сутки (ночью) снимаем дамп и собираем на его основании Docker-контейнер с PostgreSQL и MySQL с этими загруженными данными. Если из этого образа надо 50 раз развернуть базу, это делается достаточно просто и быстро.
***НС**: Простым копированием?*
**ДС**: Данные хранятся прямо в Docker-образе. Т.е. у нас есть готовый образ, пусть на 100 Гб. Благодаря слоям в Docker мы можем быстро разворачивать этот образ нужное количество раз. Способ тупой, но работает неплохо.
***НС**: Дальше, когда тестируете, оно прямо внутри Docker'а меняется, да? Copy-on-write внутри Docker'а — выбрасываем и заново поехали, всё хорошо. Класс! И вы это уже используете вовсю?*
**ДС**: Давно.
***НС**: Мы очень похожими вещами занимаемся. Только мы не Docker'овский copy-on-write используем, а какой-нибудь ещё.*
**ДС**: Он не generic. А Docker'ный работает повсеместно.
***НС**: По идее, да. Но у нас тоже там есть модули, можно разные модули сделать и работать с разными файловыми системами. Здесь какой момент. Мы со стороны Postgres'а на всё это по-другому смотрим. Теперь я посмотрел со стороны Docker'а и увидел, что у вас всё работает. Но если база — огромная, например, 1 Тб, то это уже всё долго: и операции ночью, и запихивать всё в Docker… А если 5 Тб запихивать в Docker… Или всё нормально?*
**ДС**: Какая разница: это же блобы, просто биты и байты.
***НС**: Разница такая: вы это через dump и restore делаете?*
**ДС**: Совсем необязательно. Способы генерации этого образа могут быть разные.
***НС**: Для некоторых клиентов мы сделали так, что вместо регулярной генерации базового образа мы его постоянно поддерживаем в актуальном состоянии. Он по сути является репликой, но данные получает не с мастера напрямую, а через архив. Бинарный архив, куда WAL'ы накатываются каждый день, там же бэкапы снимаются… Эти WAL'ы потом долетают — с небольшой задержкой (буквально 1-2 секунды) — до базового образа. С него мы любым способом клонируем — сейчас по умолчанию у нас ZFS.*
**ДС**: Но с ZFS вы ограничены одним узлом.
***НС**: Да. Но у ZFS есть ещё волшебный [send](https://docs.oracle.com/cd/E18752_01/html/819-5461/gbchx.html): с ним можно послать снапшот и даже (я это еще не очень тестировал, но…) можно досылать дельту между двумя `PGDATA`. На самом деле, у нас ещё один инструмент, который мы не особо рассматривали для таких задач. В PostgreSQL есть [pg\_rewind](https://www.postgresql.org/docs/12/app-pgrewind.html), работающий как «умный» rsync, пропускающий многое из того, что можно не смотреть, потому что там точно ничего не менялось. Мы можем между двумя серверами сделать быструю синхронизацию и отмотать назад точно так же.*
*Так вот, мы стараемся с этой, более DBA'ной, стороны сделать инструмент, который позволяет сделать то же самое, о чём ты говорил: у нас есть одна база, но мы хотим 50 раз что-то протестировать, чуть ли не одновременно.*
**ДС**: 50 раз означает, что вам нужно заказать 50 Spot'овых инстансов.
***НС**: Нет, на одной машине всё делаем.*
**ДС**: Но как вы развернёте 50 раз, если эта одна база, скажем, терабайтовая. Скорее всего ей нужно условно 256 Гб RAM?
***НС**: Да, памяти иногда нужно много — это нормально. Но такой пример из жизни. На production-машине 96 ядер и 600 Гб. При этом для БД используются 32 ядра (даже 16 ядер сейчас иногда) и памяти 100-120 Гб.*
**ДС**: И туда влезает 50 копий?
***НС**: Так копия-то одна, дальше работает copy-on-write (ZFS'ный)… Расскажу подробнее.*
*У нас, например, база на 10 Тб. Диск для неё сделали, ZFS ещё сжал её размер процентов на 30-40. Поскольку мы не делаем нагрузочное тестирование, нам точное время отклика не важно: пусть будет до 2 раз тормознее — это окей.*
*Мы даем возможность программистам, QA, DBA и т.п. выполнять тестирование в 1-2 потока. Например, они могут запустить какую-то миграцию. Она не требует сразу 10 ядер — ей нужен 1 бэкенд Postgres'а, 1 ядро. Миграция запустится — может, [autovacuum](https://www.postgresql.org/docs/12/routine-vacuuming.html#AUTOVACUUM) ещё запустится, тогда второе ядро задействуется. У нас выделено 16-32 ядер, так что 10 человек могут одновременно работать, никаких проблем нет.*
*Поскольку физически `PGDATA` одинаковая, получается так, что мы обманываем Postgres на самом деле. Фишка в чем: запускается, например, 10 Postgres'ов одновременно. Проблема обычно какая? Ставят [shared\_buffers](https://www.postgresql.org/docs/current/runtime-config-resource.html), допустим, в 25%. Соответственно, это 200 Гб. Больше трёх таких уже не запустишь, потому что память кончится.*
*Но мы в какой-то момент поняли, что это не нужно: мы ставим shared\_buffers в 2 Гб. у PostgreSQL есть [effective\_cache\_size](https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-EFFECTIVE-CACHE-SIZE), и в реальности только он влияет на [планы](https://en.wikipedia.org/wiki/Query_plan). Его мы и ставим в 0,5 Тб. И даже не важно, что их на самом деле нет: он строит планы, как будто они есть.*
*Соответственно, когда мы тестируем какую-то миграцию, можно собрать все планы — мы увидим, как оно будет происходить на production. Секунды там будут другие (тормознее), но данные, которые мы реально считываем, и сами планы (какие там JOIN'ы и т.п.) получаются точно такими же, как на production. И параллельно можно запускать множество таких проверок на одной машине.*
**ДС**: Ты не считаешь, что здесь есть несколько проблем? Первая — это решение, которое работает только на PostgreSQL. Такой подход — очень частный, он не generic. Вторая — Kubernetes (и всё, куда сейчас идут облачные технологии) предполагает множество узлов, и эти узлы — эфемерные. А в твоём случае это stateful, персистентный узел. Эти вещи у меня вызывают противоречия.
***НС**: Первое — согласен, это чисто Postgres'овая история. Думаю, если у нас есть какой-нибудь direct IO и буферный пул почти под всю память, такой подход не подойдет — планы будут другие. Но мы пока только с Postgres'ом и работаем, про других не думаем.*
*Про Kubernetes. Ты же сам везде рассказываешь, что у нас база персистентная. Если инстанс упал, главное — сохранить диск. Вот у нас тоже вся платформа в Kubernetes, а компонент с Postgres — отдельно (хотя и он там однажды будет). Поэтому всё так: инстанс упал, но мы сохранили его PV и просто подключили к другому (новому) инстансу, как будто бы ничего не случилось.*
**ДС**: С моей точки зрения, мы создаём pod'ы в Kubernetes. K8s — эластичный: узлы заказываются сами по мере необходимости. Задача — просто создать pod и сказать, что ему нужно X ресурсов, а дальше K8s сам разберётся. Но поддержка хранилищ в Kubernetes по-прежнему нестабильна: в [1.16](https://habr.com/ru/company/flant/blog/467477/), в [1.17](https://habr.com/ru/company/flant/blog/476998/) (этот релиз вышел *недели* назад) эти фичи становятся только бетой.
Пройдет полгода-год — оно станет более-менее стабильным, или хотя бы будет заявлено таковым. Тогда возможность снапшотов и resize'а уже решает вашу задачу полностью. Потому что у вас есть база. Да, она может быть не очень быстрой, но скорость зависит от того, что «под капотом», потому что некоторые реализации умеют копирование и copy-on-write на уровне дисковой подсистемы.
***НС**: Тут же надо ещё, чтобы все движки (Amazon, Google…) успели начать поддерживать эту версию — это ведь тоже какое-то время занимает.*
**ДС**: Пока мы их не используем. Мы используем своё.
Локальная разработка под Kubernetes
-----------------------------------
***НС**: Сталкивался ли ты с такой хотелкой, когда нужно на одной машине поднять все pod'ы и сделать такое маленькое тестирование. Чтобы по-быстрому получить proof of concept, посмотреть, что приложение работает в Kubernetes, не выделяя под это кучу машин. Есть Minikube, да?*
**ДС**: Мне кажется, этот кейс — на одном узле развернуть — про локальную разработку исключительно. Или какие-то проявления такого паттерна. Есть [Minikube](https://habr.com/ru/company/flant/blog/333470/), есть [k3s](https://k3s.io/), [KIND](https://github.com/kubernetes-sigs/kind). Мы идём к тому, что будем Kubernetes IN Docker использовать. Сейчас начали с ним работать для тестов.
***НС**: Я раньше думал, что это попытка завернуть все pod'ы в один Docker-образ. Но оказалось, что это совсем о другом. Всё равно там отдельные контейнеры, отдельные pod'ы — просто в Docker'е.*
**ДС**: Да. И там достаточно забавная имитация сделана, но смысл такой… У нас есть утилита для деплоя — [werf](https://werf.io/). Мы хотим в ней сделать режим — условно `werf up`: «Подними мне локальный Kubernetes». И далее запустить там условный `werf follow`. Тогда разработчик сможет править в IDE, а в системе запущен процесс, который видит изменения и пересобирает образы, передеплоивает их в локальный K8s. Так мы хотим попытаться решить проблему локальной разработки.
Снапшоты и клонирование БД в реалиях K8s
----------------------------------------
***НС**: Если вернуться к copy-on-write. Я заметил, что у облаков тоже есть снапшоты. Они работают по-разному. Например, в GCP: у тебя на восточном побережье США есть многотерабайтный инстанс. Делаешь периодически снапшоты. Поднимаешь из снапшота копию диска на западном побережье — через несколько минут уже всё готово, работает очень быстро, только кэш надо заполнить в памяти. Но эти клоны (снапшоты) — для того, чтобы за'provision'ить новый том. Это круто, когда нужно много инстансов создать.*
*А вот для тестов, мне кажется, снапшоты, про которые ты рассказываешь в Docker'е или я рассказываю в ZFS, btrfs и даже LVM… — они позволяют как раз на одной машине не делать реально новые данные. В облаке ты ещё платить за них каждый раз будешь и ждать уже не секунды, а минуты (а в случае [lazy load'а](https://aws.amazon.com/about-aws/whats-new/2019/11/amazon-ebs-fast-snapshot-restore-eliminates-need-for-prewarming-data-into-volumes-created-snapshots/), возможно, и часы).*
*Вместо этого можно за секунду-две получить эти данные, погонять тест и выбросить. Эти снапшоты решают разные задачи. В первом случае — чтобы отмасштабироваться и новые реплики получить, а во втором — для тестов.*
**ДС**: Не соглашусь. Сделать нормально клонирование томов — это задача облака. Я не смотрел их реализацию, но знаю, как это делаем мы на железе. У нас есть Ceph, в нём можно любому физическому тому ([RBD](https://docs.ceph.com/docs/master/rbd/)) сказать *clone* и получить за десятки миллисекунд второй том с такими же характеристиками, [IOPS](https://en.wikipedia.org/wiki/IOPS)'ами и т.п. Надо понимать, что там внутри хитрый copy-on-write. Почему облаку не делать так же? Уверен, что они так или иначе стараются это сделать.
***НС**: Но у них всё равно уйдут секунды, десятки секунд, чтобы поднять инстанс, привести туда Docker и т.д.*
**ДС**: Почему обязательно целый инстанс поднимать? У нас же есть инстанс на 32 ядра, на 16… и в него сколько-то влезает — например, четыре. Когда мы пятый заказываем, уже поднимется инстанс, а потом он удалится.
***НС**: Да, интересно, в Kubernetes получается другая история. У нас БД не в K8s, и один инстанс. Зато на клонирование многотерабайтной базы уходит не более двух секунд.*
**ДС**: Это круто. Но мой изначальный посыл в том, что это не generic-решение. Да, оно классное, но подходит только Postgres и только на одном узле.
***НС**: Оно подходит не только для Postgres: это планы, как я описывал, будут так работать только в нём. Но если не заморачиваться по поводу планов, а нам просто нужны все данные для функционального тестирования, тогда это подойдет для любой СУБД.*
**ДС**: Много лет назад мы делали подобное на LVM-снапшотах. Это классика. Такой подход очень активно использовался. Просто stateful-узлы — это боль. Потому что их нужно не ронять, всегда о них помнить…
***НС**: Не видишь ли ты здесь какой-то возможности гибрида? Допустим, stateful — это pod какой-то, он работает на нескольких людей (много тестировщиков). Том у нас один, но благодаря файловой системе клоны — локальные. Если pod упал, диск остался — поднимется pod, информацию обо всех клонах считает, всё обратно поднимет и скажет: «Вот ваши клоны на этих портах запущены, работайте с ними дальше».*
**ДС**: Технически это означает, что в рамках Kubernetes это один pod, внутри которого мы запускаем много Postgres'ов.
***НС**: Да. У него есть лимит: допустим, одновременно с ним работают не более 10 человек. Если нужно 20 — запустим второй такой pod. Полностью реально склонируем его, получив второй полный том, на нём будут такие же 10 «тонких» клонов. Не видишь такой возможности?*
**ДС**: Надо добавить сюда вопросы безопасности. Такой вариант организации подразумевает, что у этого pod'а высокие привилегии (capabilities), потому что он может выполнять нестандартные операции над файловой системой… Но повторюсь: я считаю, что в среднесрочной перспективе в Kubernetes починят storage, в облаках починят всю историю с томами — всё будет «просто работать». Будет resize, клонирование… Есть том — мы говорим: «Создай новый на основе того», — и через полторы секунды получаем что надо.
***НС**: Не верю в полторы секунды для многих терабайт. На Ceph ты делаешь сам, а говоришь про облака. Пойди в облако, на EC2 сделай клон тома EBS многих терабайт и посмотри, какая производительность будет. Это не займет несколько секунд. Мне очень интересно, когда они дойдут до такого показателя. Понимаю, о чем ты говоришь, но позволю себе не согласиться.*
**ДС**: Ок, но я сказал, что в среднесрочной перспективе, не краткосрочной. В течение нескольких лет.
Про оператор для PostgreSQL от Zalando
--------------------------------------
В середине этой встречи к ней также подключился Алексей Клюкин, бывший разработчик из компании Zalando, который рассказал про историю оператора PostgreSQL:
> Здорово, что вообще эта тема затронута: и Postgres, и Kubernetes. Когда мы начинали её делать в Zalando в 2017-м году, это была такая тема, которой все хотели заниматься, но никто не делал. У всех уже появлялся Kubernetes, но когда спрашивали, как быть с базами данных, то даже такие люди, как [Kelsey Hightower](https://github.com/kelseyhightower), проповедовавшие K8s, говорили примерно следующее:
>
>
>
> *«Идите в managed-сервисы и используйте их, не запускайте БД в Kubernetes. Иначе ваш K8s решит, например, сделать апгрейд, потушит все узлы, и ваши данные улетят далеко-далеко».*
>
>
>
> Мы решили сделать оператор, который будет, вопреки этому совету, запускать БД Postgres в Kubernetes. И у нас было хорошее основание — [Patroni](https://github.com/zalando/patroni). Это автоматический failover для PostgreSQL, сделанный правильно, т.е. использующий etcd, consul или ZooKeeper в качестве хранилища информации о кластере. Такого хранилища, которое будет отдавать всем, кто спрашивает, например, какой сейчас лидер, одну и ту же информацию — несмотря на то, что у нас всё распределённое, — чтобы не было split brain'а. Плюс, у нас был [Docker-образ](https://github.com/zalando/patroni/tree/master/docker) для него.
>
>
>
> Вообще, потребность в auto failover у компании появилась после миграции из внутреннего железного дата-центра в облако. Облако было основано на собственном решении PaaS (Platform-as-a-Service). Оно Open Source'ное, но чтобы его поднять, надо было сильно потрудиться. Называлось [STUPS](https://stups.io/).
>
>
>
> Изначально никакого Kubernetes'а не было. Точнее, когда разворачивалось собственное решение, K8s уже был, но настолько сырым, что для production не годился. Это был, по-моему, 2015 или 2016 год. К 2017-му году Kubernetes стал более-менее зрелым — появилась необходимость миграции туда.
>
>
>
> И у нас уже был Docker-контейнер. Была PaaS, которая использовала Docker. Почему бы не попробовать K8s? Почему бы не написать свой оператор? Мурат Кабилов, который пришел к нам из Авито, начал это как проект по собственной инициативе — «поиграть», — и проект «взлетел».
>
>
>
> Но вообще я хотел рассказать про AWS. Почему там был исторически код, связанный с AWS…
>
>
>
> Когда вы запускаете что-либо в Kubernetes, надо понимать, что K8s — это такой work in progress. Он постоянно развивается, улучшается и периодически даже ломается. Нужно следить внимательно за всеми изменениями в Kubernetes, нужно быть готовым в случае чего погрузиться в него и узнать, как работает в деталях — возможно, больше, чем вам бы хотелось. Это, в принципе, у любой платформы, на которой вы запускаете свои БД…
>
>
>
> Итак, когда мы делали оператор, у нас был Postgres, который работал с внешним томом (в данном случае — EBS, поскольку мы работали в AWS). База данных росла, в какой-то момент потребовалось сделать resize: например, изначальный размер EBS — 100 Тб, база доросла до него, теперь хотим сделать EBS в 200 Тб. Как? Допустим, можно сделать dump/restore на новый инстанс, но это долго и с простоем.
>
>
>
> Поэтому хотелось такой resize, который будет увеличивать раздел EBS'а и потом говорить файловой системе системе использовать новое пространство. И мы это сделали, но в то время у Kubernetes'а не было никакого API для операции resize'а. Поскольку мы работали на AWS, написали код для его API.
>
>
>
> Никто не мешает сделать то же самое для других платформ. В операторе нет завязки, что его можно запустить только на AWS, а на всём остальном он работать не будет. В общем, это Open Source-проект: если кто-нибудь хочет ускорить появление использования нового API — милости просим. Есть [GitHub](https://github.com/zalando/postgres-operator), pull-запросы — команда Zalando старается довольно оперативно на них реагировать и продвигать оператор. Насколько знаю, проект [участвовал](https://summerofcode.withgoogle.com/archive/2019/organizations/6187982082539520/) в Google Summer of Code и каких-то других похожих инициативах. Zalando над ним очень активно работает.
>
>
P.S. Бонус!
-----------
Если вас интересует тема PostgreSQL и Kubernetes, то обращаем также внимание, что на прошлой неделе состоялся следующий Postgres-вторник, где с Николаем общался **Александр Кукушкин из Zalando**. Видео с него доступно [здесь](https://www.youtube.com/watch?v=FE0xi7SBqsg).
P.P.S.
------
Читайте также в нашем блоге:
* «[Базы данных и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/431500/)»;
* «[Миграция Cassandra в Kubernetes: особенности и решения](https://habr.com/ru/company/flant/blog/475036/)»;
* «[Беспростойная миграция MongoDB в Kubernetes](https://habr.com/ru/company/flant/blog/461149/)»;
* «[Беспростойная миграция RabbitMQ в Kubernetes](https://habr.com/ru/company/flant/blog/450662/)». | https://habr.com/ru/post/479438/ | null | ru | null |
# Совершенная страница 404
Добрый день, уважаемые коллеги. Хочу поделиться с вами своей наработкой — [совершенная страница 404](http://sytchev.ru/404.zip). Это ни что иное, как дописанный код статьи Яна Ллойда «Совершенная страница 404» ([оригинал](http://www.alistapart.com/articles/perfect404/), [по русски](http://www.webmascon.com/topics/development/18a.asp)).
По сравнению с оригинальным кодом страница имеет следующие преимущества:1. Адаптирована к поисковым запросам популярных российский поисковиков, в том числе теперь скрипт может прочитать запросы с поисковика, введенные русскими буквами.
2. При отправке сообщения о битой ссылке, пользователь не переводится на новую страницу, а получает благодарность на этой же (спасибо, Ajax).
**Для тех, кто не знаком со статьей Ллойда, расскажу всё с начала:**1. Страница 404-ой ошибки не говорит, о том, что всё плохо. Она помогает найти нужную вам страницу, попутно извиняясь.
2. Если вы пришли на сайт с одного из популярных поисковиков (yandex, rambler, mail.ru, google, bing.com, nigma), то страница определит ваш поисковый запрос и поможет пользователю найти ту самую страницу. К примеру, ваш сайт занимается продажей тренажеров ЗП-300 и ЗП-800. Если пользователь искал ЗП-300 — вы сможете сразу выдать ссылку на страницу с этим тренажером. И так для каждого популярного наименования.
3. В случае если пользователь пришел с сайта, администратором которого вы являетесь, то у него будет возможность одним нажатием кнопки проинформировать вас о «плохой» ссылке.
4. В случае если пользователь пришел с обычного сайта, то он сможет одним нажатием кнопки проинформировать вас о «плохой» ссылке, дабы вы уже сами решали эту проблему с админами криво ссылающегося сайта.
Пользуйтесь на здоровье. Все места, на которые вам надо обратить внимание, отмечены комментарием, начинающимся с «//!».
Я всегда открыт для критики. Буду признателен, если укажите на ошибки в коде, если я вдруг какие-то не отловил.
**Update:** [рабочий пример](http://sytchev.ru/404.html)
**Update2:** Исправил код. Заменил чистый referrer, чтобы не попасть под XSS
**Update3:** В примерах если вы смотрите на переход с поисковика через IE у вас скрипт может написать, что пользователь искал кракозябры. Это не баг скрипта. В реальных условиях всё показывается как надо. Прсто на странице со ссылками IE автоматом старается заменить символы с процентами на родные.Чтобы посмотреть результат с поисковика в IE надо руками ввести адрес
`http://baseowl.ru/search.php?q=%D0%BB%D0%B8%D0%B2%D0%B0%D0%BC`
**Update4:** Последние исправления были сделаны в **00:30** по Москве. Те, кто скачал архив раньше этого времени — скачайте его ещё раз — вы получите исправленную версию. | https://habr.com/ru/post/64250/ | null | ru | null |
# PipelineDB: работа с потоками данных
В предыдущих публикациях мы уже затрагивали проблему обработки событий в реальном масштабе времени. Сегодня мы хотели бы вновь вернутся к этой теме и рассказать о новом и весьма интересном инструменте — потоковой СУБД [PipelineDB](https://www.pipelinedb.com/).
PipelineDB основана на кодовой базе PostgreSQL 9.4 и полностью с ней совместима. Её первый релиз состоялся в июле 2015 года, а в январе 2016 вышла в свет [enterprise-версия](https://www.pipelinedb.com/enterprise).
Ниже мы сравним PipelineDB с существующими решениями аналогичного плана, приведём краткую инструкцию по установке и первичной настройке, а также разберём практический пример.
Обработка данных в реальном времени: экскурс в историю
------------------------------------------------------
Принцип работы PipelineDB можно сформулировать так: «постоянные запросы, кратковременные данные». В реляционных СУБД всё обстоит ровно наоборот: «кратковременные запросы, постоянные данные. В PipelineDB данные не хранятся, а поступают в потоке; их обработка происходит «на лету», в движении.
Первые попытки создания инструментов для обработки данных в движении восходят к концу 1980-х годов, когда появились так называемые активные базы данных ([Active Database Systems](http://www.cs.man.ac.uk/~norm/papers/surveys.pdf)). Они представляли собой расширения к существующим СУБД для обработки событий [при помощи триггеров и правил](https://en.wikipedia.org/wiki/Event_condition_action). В качестве примера решений подобного плана можно назвать [HiPAC](https://www.researchgate.net/publication/234790486_The_HiPAC_Project_combining_active_database_and_timing_constraints), [Starburst](http://ilpubs.stanford.edu:8090/16/1/1992-8.pdf) или [ODE](http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=709BA1E82DD3AEB35CB456A4A6ADC0CA?doi=10.1.1.31.2534&rep=rep1&type=pdf).
Широкого распространения они, однако, не получили: сфера их применения была достаточно узкой, а синтаксис правил — слишком сложным и запутанным.
В 1990-х — начале 2000-х появились системы управления потоками данных ([Data Stream Management Systems](https://en.wikipedia.org/wiki/Data_stream_management_system)): [TelegraphCQ](http://telegraph.cs.berkeley.edu/telegraphcq/v0.2/) (форк PostgreSQL), [StreamBase](http://www.streambase.com/), [StreamSQL](http://www.sqlstream.com/). Принцип работы этих инструментов заключался в следующем: при помощи так называемых оконных операторов (window operators) потоки преобразовывались в таблицы, по отношению к которому затем можно было применять SQL-запросы.
Появление таких решений было несомненным шагом вперёд, но они не могли обеспечить высокую скорость и производительность при работе с большими потоками данных.
Инструменты, ориентированные на обработку данных без хранения, получили распространение в течение последних 5 — 6 лет. Из самых известных примеров следует выделить, в частности, [Storm](https://storm.apache.org/) и [Heron](http://twitter.github.io/heron/). Из появившихся относительно недавно — [Apache Calcite](https://calcite.apache.org/). Все эти решения характеризуются сложностью установки и настройки, а также очень высоким порогом вхождения.
Преимущества PipelineDB перед упомянутыми выше инструментами очевидны:
* простота настройки: чтобы начать работу, достаточно просто скачать и установить необходимые пакеты;
* простота освоения (следствие совместимости с PostgreSQL).
Рассмотрим, как в PipelineDB строится работа с потоками данных. Начнём с анализа двух важнейших понятий: «непрерывное представление» и «поток».
Потоки и непрерывные представления
----------------------------------
«Поток» и «непрерывное представление» — главные абстракции PipelineDB.
**Поток** — это последовательность событий. Запись событий в поток осуществляется точно так же, как запись в таблицы в реляционных ДБ (подробнее об этом см. [здесь](http://docs.pipelinedb.com/streams.html)). Когда событие поступает в поток, к нему добавляется временная метка (timestamp).
Потоки в PipelineDB выполняют вспомогательную функцию, которая заключается в поставке данных для непрерывных представлений. В отличии от таблиц, для потоков не нужно создавать схемы. В поток можно записывать данные, пока он взаимодействует хотя бы с одним непрерывным представлением.
**Непрерывное представление** (англ. continuous view) — это выборка из потоков и таблиц, обновляемая по мере поступления новых данных. В непрерывные представления попадают события, отбираемые по определённым параметрам.
Чтобы лучше понять, как работает PipelineDB, приведём несколько примеров непрерывных представлений.
Вот так, например, можно создать непрерывное представление для ежедневного подсчёта числа уникальных посетителей, приходящих на сайт по внешним ссылкам:
```
CREATE CONTINUOUS VIEW uniques AS
SELECT date_trunc('day', arrival_timestamp) AS day,
referrer::text, COUNT(DISTINCT user_id::integer)
FROM users_stream GROUP BY day, referrer;
```
Ещё один пример — подсчёт числа показов рекламы на сайте за последние 5 минут:
```
CREATE CONTINUOUS VIEW imps AS
SELECT COUNT(*) FROM imps_stream
WHERE (arrival_timestamp > clock_timestamp() - interval '5 minutes');
```
Как видим, непрерывные представления имеют следующую форму:
```
CREATE CONTINUOUS VIEW name AS query
```
При создании непрерывного представления по отношению к потокам выполняется операция SELECT; с её помощью отбираются данные, соответствующие требуемым параметрам.
Основные теоретические сведения, необходимые для понимания принципов работы PipelineDB, мы изложили. Переходим к практической части. Сначала мы опишем процедуру установки и первичной настройки PipelineDB, а затем перейдём к практическому примеру.
Установка и первичная настройка
-------------------------------
Процедуру установки PipelineDB мы будем описывать на материале OC Ubuntu 14.04. Если вы используете другой дистрибутив Linux, обратитесь к [официальной документации](http://docs.pipelinedb.com/installation.html).
Чтобы установить PipelineDB, достаточно выполнить две команды:
```
$ wget https://www.pipelinedb.com/download/0.9.3/ubuntu14
$ sudo dpkg -i ubuntu14
```
После этого инициализируем сервер PipelineDB:
```
$ pipeline-init -D [имя директории]
```
В опции -D можно указывается имя новой директории, которая будет создана автоматически. Вот список содержимого этой директории:
```
base pg_hba.conf pg_replslot pg_subtrans pipelinedb.auto.conf
global pg_ident.conf pg_serial pg_tblspc pipelinedb.conf
pg_clog pg_logical pg_snapshots pg_twophase postmaster.opts
pg_commit_ts pg_multixact pg_stat PG_VERSION postmaster.pid
pg_dynshmem pg_notify pg_stat_tmp pg_xlog
```
Основные настройки PipelineDB хранятся в файле pipelinedb.conf. Они почти не отличаются от соответствующих настроек PostgreSQL.
По умолчанию PipelineDB не может принимать соединения с удалённых хостов. Чтобы изменить эту настройку, откроем файл pipelinedb.conf, найдём в нём раздел Connections and Authentication, расскомментируем первую строку и отредактируем её следующим образом:
```
listen_addresses = '*'
```
После этого пропишем конкретные хосты в файле pg\_hba.conf:
```
host all all /<подсеть> md5
```
Если нам нужно принимать соединения со всех возможных хостов, эта строка должна выглядеть так:
```
host all all 0.0.0.0/0 md5
```
Вот и всё. PipelineDB готова к работе.
Чтобы запустить её в фоновом режиме, выполним следующую команду:
```
$ pipeline-ctl -D [имя директории] -l pipelinedb.log start
```
Практический пример: анализируем статистику Википедии
-----------------------------------------------------
Мы разобрали необходимую теорию, а также описали процедуры установки и первичной настройки PipelineDB. Переходим к особенностям использования PipelineDB на практике.
Мы рассмотрим интересный пример, который приводится в официальной документации PipelineDB: анализ статистики обращений к страницам Википедии и смежных проектов в час (Wiktionary, Wikisources, Wikibooks и другим). Эта статистика размещена [в открытом доступе](https://dumps.wikimedia.org/other/pagecounts-raw/). Информация о каждом обращении представлена в виде записи, состоящей из следующих полей:
```
время обращения | проект | число просмотров за | всего обслужено байт
```
Нас будут интересовать максимальное, минимальное и среднее количество обращений к странице в течение часа, а также 99-й перцентиль обращений.
Активируем выполнение непрерывных запросов:
```
$ psql -h localhost -p 5432 -d pipeline -c "ACTIVATE"
```
После этого создадим непрерывное представление:
```
$ psql -h localhost -p 5432 -d pipeline -c "CREATE CONTINUOUS VIEW wiki_stats AS
SELECT hour::timestamp, project::text,
count(*) AS total_pages,
sum(view_count::bigint) AS total_views,
min(view_count) AS min_views,
max(view_count) AS max_views,
avg(view_count) AS avg_views,
percentile_cont(0.99) WITHIN GROUP (ORDER BY view_count) AS p99_views,
sum(size::bigint) AS total_bytes_served
FROM wiki_stream
GROUP BY hour, project;"
CREATE CONTINUOUS VIEW
```
В приведённой команде указано, что мы будем получать данные для непрерывного представления из потока wiki\_stream. Чтобы создать такой поток, нам потребуется загрузить с сайта данные, разархивировать, записать в стандартный вывод, а после этого передать PipelineDB с помощью команды COPY:
```
$ curl -sL http://pipelinedb.com/data/wiki-pagecounts | gunzip | \
psql -h localhost -p 5432 -d pipeline -c "
COPY wiki_stream (hour, project, title, view_count, size) FROM STDIN"
```
Отметим, что объём данных очень велик (они хранятся в виде архивов по 80-90 MБ каждый), и их загрузка может занять продолжительное время. Загрузку можно остановить в любой момент нажатием стандартной комбинации клавиш Ctrl+C.
По завершении загрузки выполним команду:
```
$ psql -h localhost -p 5432 -d pipeline -c "
SELECT * FROM wiki_stats ORDER BY total_views DESC";
```
Результат будет представлен в виде таблицы (приводим лишь небольшой фрагмент):
Заключение
----------
PipelineDB — интересный и перспективный продукт. Надеемся, что он будет успешно развиваться и в дальнейшем.
Если у вас есть опыт использования PipelineDB на практике — будем рады, если вы поделитесь опытом в комментариях.
Для желающих узнать больше приводим несколько полезных ссылок:
* [официальная документация PipelineDB](http://docs.pipelinedb.com/);
* [блог разработчиков PipelineDB](https://www.pipelinedb.com/blog);
* [анализ данных с PipelineDB: практический кейс](http://about.smartnews.com/en/2015/09/09/20150909how-smartnews-utilizes-pipelinedb/);
* [PipelineDB в контейнере: практический кейс](https://clusterhq.com/2016/03/24/pipelinedb-persistance/).
Всех, кто по тем или иным причинам не может оставлять комментарии здесь, приглашаем [в наш блог](https://blog.selectel.ru/pipelinedb-rabota-s-potokami-dannyx/). | https://habr.com/ru/post/306978/ | null | ru | null |
# Топология и комплексный анализ для ничего не подозревающего разработчика игр: сжатие единичных 3D-векторов
Как вы уже могли понять из моих предыдущих статей, мне нравится использовать разработку игр как оправдание для демонстрации сложной математики, для которой в противном случае у большинства людей не было бы применения. И эта статья не исключение! Я хочу показать очень крутую технику, соответствующую любопытным для меня пунктам:
* процесс достаточно нагляден
* он намного быстрее, чем обычная техника, выполняющая ту же задачу
* он использует очень необычное свойство представления вещественных чисел в формате с плавающей запятой, что подразумевает, что...
* **он не работает в классическом анализе**. Чтобы этот алгоритм работал в теории, нужно попасть в удивительный мир неклассической математики! И если уж это не разбудило ваше любопытство, то я уж и не знаю, что ещё поделать.
Эта статья довольно длинная и теоретическая, потому что она требует глубоко изучить объяснения, так что не торопитесь и перечитывайте те части, которые показались вам не столь очевидными с первого раза.
Немного о контексте (GPU)
-------------------------
Один из важных аспектов, на который стоит обращать внимание в разработке игр, а в более широком смысле — и в любой области с активным использованием графики — это пропускная способность GPU. Центральный процессор и GPU — отдельные физические устройства, и для обмена данными им требуется синхронизация. Если вы уже занимались параллельной обработкой, то знаете, что когда двум устройствам нужно синхронизироваться, это означает потерю значительного количества времени. Взаимодействие CPU-GPU в этом плане ничем не отличается, поэтому мы стремимся минимизировать передачу данных, как в количестве операций, так и в объёме передаваемых данных.
Минимизация количества операций передачи данных обычно выполняется при помощи буферизации: мы стремимся уместить все данные в как можно меньшее количество массивов, а затем передаём всё за один раз, чтобы больше не нужно было о них волноваться. Минимизация объёма данных в операциях передачи — совершенно другая тема, и решения этой задачи почти всегда индивидуальны. В качестве крайнего примера этого можно посмотреть, [как движку рендеринга Destiny удаётся уместить позицию, нормали поверхности, флаги материалов и полные анизотропные BSDF-параметры в 96 бит, т.е. в три числа с плавающей запятой](http://advances.realtimerendering.com/s2013/Tatarchuk-Destiny-SIGGRAPH2013.pdf) (стр. 62 и дальше). Однако хороших результатов можно добиться и общими методами, к которым потом добавляются индивидуальные решения для оптимизации.
Сегодня мы обсудим **сжатие без потерь отдельных единичных 3D-векторов**. В этом предложении содержится несколько ключевых слов:
* **Единичные 3D-векторы**: 3D-векторы, имеющие длину 1
* **сжатие без потерь**: уменьшение размера описания единичных 3D-векторов без потерь точности. Это противоположно сжатию *с потерями*
* **отдельных**: кодирование и декодирование вектора выполняется без информации о его соседях. Если бы ситуация была обратной, то это могло бы быть что-то вроде *пакетного* сжатия, при котором сжимаются не отдельные векторы, а их массивы
Прежде чем двигаться дальше, я должен упомянуть превосходную статью [*“A Survey of Efficient Representations for Independent Unit* *Vectors”*](http://jcgt.org/published/0003/02/01/) авторов Cigolle, Donow, Evangelakos, Mara, McGuire и Meyer, из которой я черпал вдохновение для своего поста. Сразу должен сказать, что **алгоритм, о котором я расскажу, менее эффективен, чем представленный в статье алгоритм *oct***. Если вы стремитесь в максимальной эффективности, то прочитайте статью и используйте *oct*. Цель моего поста — показать красоту использования очень необычной математики, создав при этом, как мы увидим позже, очень удобный алгоритм.
Топология прямо в вашей видеоигре
---------------------------------
*В случае единичной сферы важны только θ и φ, потому что ρ всегда равно 1, а потому избыточно.*
Отправной точкой алгоритма является наблюдение о том, что единичные 3D-векторы эквивалентны точкам на сфере. Как вы вероятно знаете, сфера — это двухмерная поверхность, то есть для уникальной идентификации точек на сфере требуется всего две координаты. Очень распространённым примером этого являются сферические координаты, при которых точка на сфере задаётся двумя углами, θ и φ.
Интересно, что довольно неприятное свойство заключается в том, что хотя и сфера, и заполненный квадрат (одно возможное пространство для 2D-координат) являются 2D-объектами, между ними на самом деле нет соответствия. Это означает, что не существует способа привязать уникальную точку на сфере к каждой уникальной точке квадрата (по крайней мере, непрерывным образом); говорится, что они *негомеоморфны* (проще говоря, у одного есть граница, а у другого нет). Неприятным результатом этого становится то, что некоторые 2D-координаты теряются в том смысле, что разные координаты соответствуют одинаковых точкам на сфере (например, в случае сферических координат, когда φ равен 0, соответствующая точка будет северным полюсом, вне зависимости от координаты θ). С точки зрения сжатия мы теряем ценные битовые паттерны, которыми мы могли бы описать точки сферы!
Если вам хочется больше математики и вы желаете доказать, что квадрат и сфера негомеоморфны, то можно воспользоваться тем фактом, что сфера в отличие от квадрата не стягиваема, а стягиваемость является топологическим свойством; так же для доказательства можно использовать теорему Борсука-Улама. Ещё мне говорили, что в доказательстве могут помочь гомотопические группы, но это уже находится за пределами моей области знаний.
Однако эта проблема возникает не только со сферическими координатами; от неё будет страдать любое непрерывное 2D-представление точек сферы. Тем не менее, запомните это на будущее.
Сферические координаты обладают также и другими плохими свойствами:
* Они имеют плохое распределение по сфере. Если сгенерировать случайные сферические координаты и преобразовать их обратно в 3D-точки, они образуют скопления вокруг полюсов и будут довольно разреженными возле экватора. Это является следствием того, что 3D-векторы рядом с экватором будут менее точно различимы.
*Распределение на сфере 10 000 равномерно распределённых сферических координат*
* Их упаковка и распаковка затратны. Для упаковки (3D → 2D) требуется одна операция *acos* и одна *atan2*, которые являются довольно затратными обратными тригонометрическими функциями, а для распаковки (2D → 3D) требуются две операции *cos* и две операции *sin*, которые тоже далеко не экономны.
Изучите упомянутую выше статью, чтобы узнать о других сравнениях сферических координат и иных способов сжатия.
Задача сохранения битовых паттернов… и скорости
-----------------------------------------------
Способ, который мы рассмотрим, имеет большое преимущество — его вычисление гораздо быстрее, более чем в два раза, чем неоптимизированный наивный бенчмарк (протестировано на упаковке и распаковке 10 миллионов случайных векторов на C++ в Visual Studio 19 на Intel Core i5 7th gen). Кроме того, способ не имеет сингулярности, то есть каждая упакованная точка соответствует единственной распакованной точке, в отличие от упомянутых выше сферических координат.
Как говорилось ранее, между единичной сферой и единичным квадратом нет гомеоморфизма, то есть мы не можем должным образом привязать каждую уникальную точку в квадрате к другой уникальной точке на сфере. Но давайте рассмотрим следующие построения — пока нас будет волновать только северная полусфера, в которой находятся точки с положительной или нулевой координатой Z.
*Мы «сплюснули» северную полусферу в диск, **отбросив координату Z каждой точки** (или присвоив ей значение 0).*
Мы нашли способ привязать каждую точку северной полусферы к каждой точке единичного диска. Несколько примечательных точек:
* северный полюс попадает в (0, 0).
* каждая точка на границе полусферы остаётся такой же. Если конкретнее, то полусфера и диск имеют одинаковую границу. Это логично, ведь точки на границе полусферы имеют Z = 0, то есть отбрасывая координату Z, мы ничего не меняем.
### Сжатие диска: простая комплексная задача
Следующее построение требует небольшого введения. На всякий случай скажу, что комплексные числа — это расширение пространства вещественных чисел (обычных чисел наподобие 0, 1, 129,43, пи, 335/117, квадратного корня 2, и так далее), в котором используется особое число *i*, называемое *мнимой единицей*. Комплексные числа имеют вид *a + ib*, где *a* и *b* — некие вещественные числа (соответственно, вещественная и мнимая части), а *i* имеет свойство *i*² = -1. Это позволяет нам сопоставить комплексные числа с точками на 2D-плоскости. Если взять за *z* комплексное число вида *z = a + ib*, то можно представить *z* точкой с координатами (*a*, *b*) на плоскости. Функции извлечения «вещественной части» и «мнимой части» комплексного числа *z* обозначаются как *Re(z)* и *Im(z)*.
*Комплексное число *z* и представляющие его значения.*
Кроме вещественной и мнимой частей комплексного числа можно также учитывать длину и угол, образуемый им с осью X. Это называется *полярным представлением*. Полярная длина и полярный угол — это норма *|z|* и аргумент *Arg(z)*. Удобное свойство обоих представлений заключается в том, что **сложение комплексных чисел выполняется сложением вещественной и мнимой частей**, а **умножение комплексных чисел выполняется умножением норм и сложением аргументов**.
Здесь нам интересны две операции: возведение в квадрат и получение квадратного корня комплексного числа. Возведение в квадрат комплексного числа выполняется точно так же, как и у вещественных чисел: просто умножаем его на себя, по сути **возводя в квадрат норму и удваивая аргумент**. Учтите, что если норма комплексного числа меньше 1, то при возведении в квадрат её длина останется меньше единицы; таким образом, если взять каждое комплексное число на диске, имеющее положительную вещественную часть, и возвести их всех в квадрат, то мы по сути получим в результате весь диск.
*Слева показано несколько комплексных чисел в половине диска с положительной вещественной частью (координатой X). Справа показан результат возведения в квадрат всех этих точек. Половина диска теперь заполняет весь диск!*
С «удвоением аргумента» связана одна хитрость: оно зависит от стороны оси X, на которой лежит точка. Правило показано ниже.
*Комплексное число с положительной мнимой частью (координата Y) поворачивается влево, а комплексное число с отрицательной мнимой частью (координата Y) поворачивается вправо.*
Как и в случае с вещественными числами, квадратный корень — это операция, обратная возведению в квадрат: для заданного комплексного числа *z*, квадратными корнями (их два) являются числа *c*, такие, что *c² = z*. Как и в случае с вещественными числами, если *c* — квадратный корень *z*, тогда *-c* тоже им является. То из чисел *c* и *-c*, аргумент которого равен половине аргумента *z*, называется главным значением квадратного корня (это схоже со взятием положительного квадратного корня вещественного числа вместо отрицательного квадратного корня).
Если вы понимаете, что при возведении в квадрат комплексного числа возводится в квадрат его норма и удваивается его аргумент, то легко догадаетесь, что главное значение квадратного корня берёт квадратный корень из нормы и делит пополам аргумент (следуя показанному выше правилу, но с перевёрнутыми стрелками). Как и в случае с возведением в квадрат, при взятии квадратного корня комплексного числа с нормой меньше 1 норма остаётся меньше 1; следовательно, это «сжимает» единичный диск в его половину положительных вещественных чисел.
*Слева показано несколько точек на единичном диске. Справа показан результат взятия квадратного корня всех этих точек. Весь диск теперь умещается в половину самого себя!*
В этом и заключается основа алгоритма: по сути, мы сжимаем весь единичный диск в одну его половину — в половину с положительной вещественной частью. Как вы помните, недавно мы сплющили верхнюю половину сферы в единичный диск; теперь стоит посмотреть, что мы с этим будем делать.
### Соединяем всё вместе
Давайте суммируем то, что только что сделали: мы сплющили половину сферы в один единичный диск, отбросив координату Z всех его точек, и сжали единичный диск в его собственную половину с положительной вещественной частью при помощи комплексного главного значения квадратного корня. По сути, мы сплюснули половину сферы в половину диска! Теперь с небольшими изменениями мы можем сделать то же самое для сжатия оставшейся половины сферы в оставшуюся половину диска.
Нижняя половина сферы (все точки сферы с отрицательной координатой Z) аналогично сплющиваются в единичный диск повторным отбрасыванием координат Z. Однако для всех комплексных чисел *z* в диске мы берём значение, противоположное главному квадратному корню *z* (т.е. мы берём *-c* вместо *c*). Так как главное значение квадратного корня всегда имеет положительную вещественную часть, противоположное ему значение всегда будет иметь отрицательную вещественную часть; по сути, мы сплющили оставшуюся половину сферы в оставшуюся половину диска, и на этом этап сжатия завершён!
*Полный этап сжатия. Заметьте, что северная и южная полусферы (синяя и оранжевая) сплюснуты в две копии единичного диска, а затем ужаты в две половины одного единичного диска.*
Алгоритм сжатия выглядит следующим образом:
```
function packUnitVector(unit)
disk = new Complex(unit.x, unit.y)
packed = principalSquareRoot(disk)
return unit.z < 0 ? -packed : packed
```
И вот так, всего в трёх строках псевдокода, мы применили всю рассмотренную нами теорию для создания эффективного алгоритма. Если в вашей среде нет формулы главного значения квадратного корня, то её можно найти [в Википедии](https://en.wikipedia.org/wiki/Square_root#Algebraic_formula) (особое внимание следует уделить выбору знака мнимой части). Вот справочная реализация на C++, которую я использую в своём коде:
```
// Principal complex square root of 'x + iy'
float2 csqrt(float x, float y)
{
float r = sqrt(x * x + y * y);
return float2(sqrt((r + x) / 2), (y < 0 ? -1 : 1) * sqrt((r - x) / 2));
}
```
### Возвращаемся обратно
Мы справились со сжатием, теперь приступим к распаковке.
Распаковка заключается в обратном порядке выполнения всех шагов сжатия:
* разворачиваем и положительную, и отрицательную половины вещественных частей единичного диска в два полных диска
* сопоставляем каждый полный диск с соответствующей ему полусферой
Если вкратце, то мы начинаем с упакованного значения *p*, возводим его в квадрат, чтобы вернуться к точке на диске, получаемой из одной из полусфер, а затем используем знак *Re(p)*, чтобы выяснить, из какой полусферы взята точка в диске. При помощи уравнения *x² + y² + z² = 1*, задающего точки на единичной сфере, мы можем воссоздать отсутствующую координату Z упакованной точки.
Следует учесть, что вычисление квадрата упакованного значения всегда будет давать нам правильную точку диска вне зависимости от её исходной полусферы (верхней или нижней), потому что *z² =* *(-z)²*.
Алгоритм распаковки имеет следующий вид:
```
function unpackUnitVector(packed):
disk = packed * packed
unit = new Vec3()
unit.x = disk.real()
unit.y = disk.imag()
unit.z = sqrt(1 - unit.x * unit.x - unit.y * unit.y) * (packed.real() < 0 ? -1 : 1)
return unit
```
И таким образом мы получили алгоритм, очень эффективно создающий 2D-представление единичных 3D-векторов, который в отличие от сферических координат, не теряет никаких битовых паттернов и не имеет сингулярности. Если не учитывать пару хитростей оптимизации, позволяющих ускорить вычисления, это практически готовая версия алгоритма.
… или нет? Если вы следили внимательно, то заметили, что здесь что-то не так. Я сказал, что сфера и единичный квадрат негомеоморфны, и тем не менее каким-то образом смог привязать уникальную точку в диске к каждой уникальной точке на сфере? Кроме того, мы пока не упоминали никакой неклассической математики, так что же происходит?
И в самом деле, наш алгоритм имеет серьёзный недостаток: он работает для каждой точки всей сферы, за исключением точек на северной полусфере с Y = 0 и X <= 0, которые при упаковке и распаковке ошибочно сопоставляются с соответствующей точкой на северной полусфере.
Причина этого заключается в том, что при отбрасывании их координаты Z соответствующее комплексное число является отрицательным вещественным числом, оно не имеет мнимой части. Когда мы берём главное значение квадратного корня отрицательного вещественного числа, то в свою очередь получаем полностью мнимое комплексное число, которое не имеет вещественной части (это схоже с тем, что главное значение квадратного корня -1 равно *i*). Затем мы пытаемся сохранить знак координаты Z в том, что по сути является нулём.
*Проблемная полоса. Точки с Y = 0 и X <= 0 упаковываются в линию чисто мнимых чисел с неопределимыми вещественными частями.*
Давайте посмотрим, что происходит, когда мы упаковываем две такие точки (не забывайте, что x <= 0).
>
> ```
> | North point | South point
> unit | (x, 0, z) | (x, 0, -z)
> disk | x + 0i | x + 0i
> packed | 0 + √(-x)i | -0 - √(-x)i
> ```
>
Так как мнимая часть проекции на диск обеих точек равна нулю, мы не можем хранить знак координаты Z в знаке вещественной части главного значения квадратного корня, потому что она сама равна нулю. Мы можем просто остановиться на этом, приняв тот факт, что алгоритм не работает для этих точек — или можем двинуться дальше.
Забываем то, чему научились
---------------------------
В каждой известной мне области и ветви математики принимается, что 0 = -0. Это следует из определения *-a*, противоположного элементу *a*, гласящего, что *"-a — это единственное число, дающее 0 при суммировании с a"*. Так как 0 является также нулевым элементом относительно сложения (*0 +a = a + 0 = a*), то единственное, что нужно прибавить к 0, чтобы получить 0 — это сам 0.
Однако в разработке ПО всё по-другому. В большинстве представлений чисел с плавающей запятой наряду с экспонентом и мантиссой используется дополнительный бит для хранения знака. Это означает, что когда экспонент и мантисса равны 0, то знаковый бит можно использовать для различения положительного и отрицательного нулей. В большинстве языков программирования (если не во всех) оба этих нуля обрабатываются как один единственный ноль (просто попробуйте выполнить *0 == -0*), но разница существует, и это можно увидеть, если попробовать вывести в терминал “-0” и “0” — именно так они и выведутся.
Для нас это чрезвычайно важно: значение нуля на самом деле можно использовать для хранения информации о знаке! На самом деле, она и так хранится правильно; в нашем случае проблема заключается в том, что она считывается неверно. Если посмотреть на предпоследнюю строку в алгоритме распаковки, то мы увидим следующее:
```
packed.real() < 0 ? -1 : 1
```
Эта операция считывает знак вещественной части упакованного значения, чтобы определить, к какой полусфере принадлежит точка — к северной или южной. Однако в случае, когда *packed.real()* равно 0 или -0, знак игнорируется оператором сравнения и тернарный оператор всегда возвращает 1. Правильным способом считывания знака будет *настоящий* запрос состояния знакового бита, например, с помощью *std::signbit* из C++ или *np.signbit* из Numpy в Python — функция зависит от языка. Помните, что знаковый бит равен 1, когда число отрицательно, и равен 0, когда число положительно.
Таким образом, мы получаем исправленную и стопроцентно работающую функцию:
```
function unpackUnitVector(packed):
disk = packed * packed
unit = new Vec3()
unit.x = disk.real()
unit.y = disk.imag()
unit.z = sqrt(1 - unit.x * unit.x - unit.y * unit.y) * (signbit(packed.real()) ? -1 : 1)
return unit
```
Вот и всё! Теперь алгоритм завершён. Неклассическая математика проявляется в том, что мы используем факт отличия 0 от -0, что ложно для всех известных мне областей математики. Однако существует способ сделать эту странность логичной в теоретическом, математически строгом смысле.
Пространства, которые играют не по правилам: прямая с двумя точками начала координат
------------------------------------------------------------------------------------
Чтобы лучше понимать изложенное ниже вам стоит знать концепции классов эквивалентности и окрестностей. Это необязательно, но так будет понятнее.
Мы можем обеспечить логичность этой странности со «знаковым нулём», начав с интересного топологического пространства: прямой с двумя точками начала координат.
*Прямая с двумя точками начала координат — это обычная вещественная числовая ось, которая каким-то образом отрастила себе дополнительный 0.*
Прямая с двумя точками начала координат получается, когда мы берём две вещественные числовые оси и склеиваем каждое число с равным ему противоположным, за исключением 0. Формально прямая с двумя точками начала координат является факторпространством R² с отношением эквивалентности, идентифицирующим два числа, если они равны *и* не являются 0. Результатом становится прямая вещественных чисел с двумя разными нулями, равноудалёнными от любой точки, но одновременно отличными друг от друга. Формально любые две окрестности каждого из нулей всегда имеют непустое пересечение.
Мы можем расширить это и попробовать определить «дископодобный» объект, который использовали в этой статье. Ранее мы принудительно сохраняли знак координаты Z точки в вещественную часть главного значения квадратного корня её проекции на комплексный диск, даже если эта вещественная часть равна 0. Это значит, что мы использовали не комплексные числа, а другое, похожее на них понятие: комплексное число, мнимая часть которого является вещественным числом, а вещественная часть которого является точкой на прямой с двумя точками начала координат, поэтому мы можем отличать вещественную часть, равную +0 и -0. На самом деле мы используем **комплексные числа с двумя точками начала координат!**
И в самом деле, мы не нашли биекцию (взаимно однозначное отображение) между сферой и единичным диском, но нашли биекцию между сферой и единичным диском с двумя точками начала координат. Я не проверял, является ли эта биекция гомеоморфизмом (гомеоморфизм — это биекция, непрерывная обоих направлениях), но возможно, когда-нибудь этим займусь.
### Немного топологии в конце
В заключение хочу подчеркнуть, что хотя использованная нами комплексная плоскость с двумя точками начала координат не следует из того же построения, что и прямая с двумя началами координат, на самом деле она является эквивалентом другой комплексной плоскости с двумя точками начала координат, построенной аналогично прямой с двумя началами координат.
В случае прямой с двумя точками начала координат мы склеили две копии вещественной числовой оси во всех местах, кроме 0. Мы можем сделать то же самое с двумя копиями комплексной плоскости, склеив вместе каждую пару равных комплексных чисел, не являющихся 0, и аналогично получить комплексную плоскость с двумя точками начала координат. Это построение отличается от построения новой комплексной плоскости из прямой с двумя точками начала координат и обычной вещественной числовой оси: первая является факторпространством, а последняя — произведением пространств. Однако единственное различие между двумя получившимися пространствами заключается в способе *записи* разных нулей в каждом пространстве: в первом они счтываются как (*0 + 0i)a* и (*0 + 0i)b* (два нуля, взятые из двух разных пространств, не склеенных вместе), а в последнем они считываются как *(0a + 0i)* и *(0b +* *0i)*. На самом деле оба пространства являются гомеоморфными, так что можно спокойно использовать одно там, где требуется другое.
Вывод
-----
Надеюсь, вам понравился этот экскурс в мир причудливой и непонятной математики. Снова подчеркну тот факт, что, строго говоря, этот алгоритм проявляет себя хуже, чем алгоритм *oct* из статьи, упомянутой мной в начале. Хотя он близок или даже быстрее по времени выполнения, его распределение точек на сфере далеко не так хорошо. Я написал эту статью затем, чтобы показать, как кажущаяся инопланетной математика, похожая на абстрактную чушь, на самом деле может иметь очень интересное применение в реальном мире; более того, я нахожу эту абстрактную чушь восхитительной. Надеюсь, вы извлекли из статьи что-то полезно, спасибо за прочтение! | https://habr.com/ru/post/482348/ | null | ru | null |
# Компактная С++ библиотека для программирования конечно-разностных методов в операторном стиле. Часть 1. Семантика
Представлена семантика разработанной библиотеки pde++ для программирования конечно-разностных методов в операторном стиле. Основными объектами библиотеки являются сеточная функция, сеточная ячейка и сеточные операторы, арифметические соотношения между которыми максимально приближают программный код к его математической нотации. Библиотека pde++ представлена всего несколькими заголовочными файлами, не имеет внешних зависимостей и использует концепцию ленивых вычислений.
Большое число задач математического моделирования сводится к численному решению дифференциальных уравнений в частных производных (ДУЧП) сеточными методами. В теории разностных схем (Самарский А.А.) соответствующие сеточные операторы образуют линейное пространство над сеточными функциями, для которых нет прямого представления в языках программирования общего назначения, таких как C++. Как следствие, при программной реализации широко используется практика записи результата применения сеточных операторов к сеточным функциям с помощью многомерных массивов или матриц.
Практика показывает, что отмеченный выше подход является весьма полезным в вопросах овладения навыками реализации численных методов, прежде всего, за счет своей наглядности при работе с заранее выписанными аппроксимациями ДУЧП в индексном виде. Существенных проблем не возникает также при распространении данной техники на обобщенные ДУЧП, если предполагается однократно реализовать разностную схему с параметрами и повторно использовать соответствующий программный код без его дальнейших модификаций.
В общем же случае, вычислительная программа может модифицироваться в различных направлениях, поэтому описанная выше техника потребует написания значительного объема программного кода, а это, в свою очередь, увеличит вероятность опечаток и несогласованной записи одинаковых сеточных операторов в разных программных модулях. Также стоит отметить проблему дублирования программного кода при вариативности пространственных измерений (1D, 2D, 3D) и способов аппроксимации ДУЧП.
Таким образом, альтернативой является разработка и использование специализированных программных библиотек с высокоуровневыми абстракциями предметной области, приближающих программный код к его математической нотации. В библиотеке Blitz++ такой абстракцией является тензорные вычисления на разностных шаблонах, реализованные на базе использования техники шаблонного метапрограммирования. Библиотека [freePOOMA](http://www.nongnu.org/freepooma/) расширяет концепцию Blitz++ разностными аналогами дифференциальных операторов дивергенции и градиента и возможностью работы на многопроцессорных вычислительных системах. К сожалению, данные библиотеки уже давно не поддерживаются, обладая при этом рядом ограничений (будут рассмотрены в следующей части) при их использовании для достаточно классических конечно-разностных аппроксимаций ДУЧП, рассмотренных в настоящей работе.
Разработанная автором библиотека с открытым исходным кодом pde++ идейно вдохновлена библиотекой [freePOOMA](http://www.nongnu.org/freepooma/) и предназначена для записи в операторном виде конечно-разностных схем для скалярных и векторных сеточных функций, заданных в 2D постановке (1D и 3D в работе) на равномерных прямоугольных сетках.
**Внимание:** код проверялся только под Windows.
```
#include "pdepp.h"
double sln_u(double x, double y)
{
return x * x + y * y;
}
//скалярные сеточные-функции
void test_pdepp_1()
{
//2d-область [a, b] x [a, b]
double a = 0;
double b = 1;
//число внутренних узлов равномерной сетки
int n = 10;
double h = (b - a) / (n + 1);
//инициализация сеточных функции (автоматически добавляется по одной граничной ячейке)
ScalarMeshFunc u(a, b, n, n);
ScalarMeshFunc r(a, b, n, n);
//поиндексный доступ к ячейкам
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
ScalarCell &c = u(i, j);
c.val() = sln\_u(c.x(), c.y());
}
}
//сеточные операторы
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ASSERT\_DBL\_EQ(dx\_left(u(i, j)), (u(i, j) - u(i - 1, j)) / h);
ASSERT\_DBL\_EQ(dx\_right(u(i, j)), (u(i + 1, j) - u(i, j)) / h);
ASSERT\_DBL\_EQ(dy\_left(u(i, j)), (u(i, j) - u(i, j - 1)) / h);
ASSERT\_DBL\_EQ(dy\_right(u(i, j)), (u(i, j + 1) - u(i, j)) / h);
ASSERT\_DBL\_EQ(laplacian(u(i, j)), dx\_left(dx\_right(u(i, j))) + dy\_left(dy\_right(u(i, j))));
ASSERT\_DBL\_EQ(laplacian(u(i, j)), u(i, j).dx\_left().dx\_right() + u(i, j).dy\_left().dy\_right());
ASSERT\_DBL\_EQ(laplacian(u(i, j)), dx\_right(dx\_left(u(i, j))) + dy\_right(dy\_left(u(i, j))));
ASSERT\_DBL\_EQ(laplacian(u(i, j)), u(i, j).dx\_right().dx\_left() + u(i, j).dy\_right().dy\_left());
r(i, j) = laplacian(u(i, j));
ASSERT\_DBL\_EQ(r(i, j), 4.);
}
}
//итераторы
//все значения сетки
ScalarMeshFunc f(a, b, n, n);
f.all() = 0;
//итератор по внутренним ячейкам в диапазоне индексов
Interval2d I(1, n, 1, n);
f(I) = 4;
r(I) = laplacian(u(I)) - f(I);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ASSERT\_DBL\_EQ(r(i, j), 0.);
}
}
}
```
```
#include "pdepp.h"
double sln_u(double x, double y)
{
return x * x + y * y;
}
double sln_v(double x, double y)
{
return x * x * x + y * y * y;
}
//векторные сеточные-функции
void test_pdepp_2()
{
//2d-область [a, b] x [a, b]
double a = 0;
double b = 1;
//число внутренних узлов равномерной сетки
int n = 10;
double h = (b - a) / (n + 1);
//инициализация сеточной функции
VectorMeshFunc U(a, b, n, n);
//поиндексный доступ к ячейкам
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
VectorCell &c = U(i, j);
c.comp(0).val() = sln\_u(c.x(), c.y());
c.comp(1).val() = sln\_v(c.x(), c.y());
}
}
//сеточный оператор дивергенции
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ASSERT\_DBL\_EQ(div\_left(U(i, j)), (U(i, j).comp(0) - U(i - 1, j).comp(0)) / h + (U(i, j).comp(1) - U(i, j - 1).comp(1)) / h);
ASSERT\_DBL\_EQ(div\_left(U(i, j)), U(i, j).comp(0).dx\_left() + U(i, j).comp(1).dy\_left());
ASSERT\_DBL\_EQ(div\_left(U(i, j)), dx\_left(U(i, j).comp(0)) + dy\_left(U(i, j).comp(1)));
ASSERT\_DBL\_EQ(div\_right(U(i, j)), (U(i + 1, j).comp(0) - U(i, j).comp(0)) / h + (U(i, j + 1).comp(1) - U(i, j).comp(1)) / h);
ASSERT\_DBL\_EQ(div\_right(U(i, j)), U(i, j).comp(0).dx\_right() + U(i, j).comp(1).dy\_right());
ASSERT\_DBL\_EQ(div\_right(U(i, j)), dx\_right(U(i, j).comp(0)) + dy\_right(U(i, j).comp(1)));
}
}
//преобразование векторной функции в скалярную через оператор дивергенции
ScalarMeshFunc u(a, b, n, n);
Interval2d I(1, n, 1, n);
u(I) = div\_left(U(I));
u(I) = div\_right(U(I));
//сеточный оператор градиента
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
VectorCell &c = grad\_left(u(i, j));
ASSERT\_DBL\_EQ(c.comp(0), (u(i, j) - u(i - 1, j)) / h);
ASSERT\_DBL\_EQ(c.comp(0), u(i, j).dx\_left());
ASSERT\_DBL\_EQ(c.comp(0), dx\_left(u(i, j)));
ASSERT\_DBL\_EQ(c.comp(1), (u(i, j) - u(i, j - 1)) / h);
ASSERT\_DBL\_EQ(c.comp(1), u(i, j).dy\_left());
ASSERT\_DBL\_EQ(c.comp(1), dy\_left(u(i, j)));
c = grad\_right(u(i, j));
ASSERT\_DBL\_EQ(c.comp(0), (u(i + 1, j) - u(i, j)) / h);
ASSERT\_DBL\_EQ(c.comp(0), u(i, j).dx\_right());
ASSERT\_DBL\_EQ(c.comp(0), dx\_right(u(i, j)));
ASSERT\_DBL\_EQ(c.comp(1), (u(i, j + 1) - u(i, j)) / h);
ASSERT\_DBL\_EQ(c.comp(1), u(i, j).dy\_right());
ASSERT\_DBL\_EQ(c.comp(1), dy\_right(u(i, j)));
}
}
//преобразование скалярной функции в векторную через оператор градиента
U(I) = grad\_left(u(I));
U(I) = grad\_right(u(I));
ScalarMeshFunc f(a, b, n, n);
f(I) = div\_left(grad\_right(u(I)));
f(I) = div\_right(grad\_left(u(I)));
VectorMeshFunc F(a, b, n, n);
F(I) = grad\_left(div\_right(U(I)));
F(I) = grad\_right(div\_left(U(I)));
}
```
**Файл pdepp.h**
```
//(с) 2016-2019 Шарипов Тимур, SharipovTR@gmail.com
//Распространяется As Is
#pragma once
#include
#include
#include "NumericAssert.h"
#include "Arrays.h"
//#define USE\_STD\_MOVE
template
class MeshCell {
public:
int dim\_;
MeshCell() : dim\_(0), x\_(0), y\_(0),
left\_(0), right\_(0), up\_(0), down\_(0),
op\_(OpEqual) {
}
MeshCell(const DerivCell &rhs) : dim\_(rhs.dim\_), x\_(rhs.x\_), y\_(rhs.y\_),
left\_(rhs.left\_), right\_(rhs.right\_),
up\_(rhs.up\_), down\_(rhs.down\_),
op\_(rhs.op\_) {}//todo:op?
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
MeshCell(DerivCell &&rhs) : dim\_(std::move(rhs.dim\_)), x\_(std::move(rhs.x\_)), y\_(std::move(rhs.y\_)),
left\_(std::move(rhs.left\_)), right\_(std::move(rhs.right\_)),
up\_(std::move(rhs.up\_)), down\_(std::move(rhs.down\_)),
op\_(std::move(rhs.op\_)) {}//todo:op?
#endif
virtual ~MeshCell() {}
virtual ScalarCell ∁(int i) = 0;
virtual const ScalarCell ∁(int i) const = 0;
virtual DerivCell \*This() = 0;
void set\_x(double x) {
x\_ = x;
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_x(x);
}
}
double x() const {
return x\_;
}
void set\_y(double y) {
y\_ = y;
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_y(y);
}
}
double y() const {
return y\_;
}
void set\_left(DerivCell \*left) {
left\_ = left;
if (!left)
return;
left->right\_ = This();
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_left(&left->comp(i));
}
}
DerivCell \*left() {
return left\_;
}
void set\_right(DerivCell \*right) {
right\_ = right;
if (!right)
return;
right->left\_ = This();
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_right(&right->comp(i));
}
}
DerivCell \*right() {
return right\_;
}
void set\_up(DerivCell \*up) {
up\_ = up;
if (!up)
return;
up->down\_ = This();
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_up(&up->comp(i));
}
}
DerivCell \*up() {
return up\_;
}
void set\_down(DerivCell \*down) {
down\_ = down;
if (!down)
return;
down->up\_ = This();
if (dim\_ > 1)
for(int i = 0; i < dim\_; i++) {
comp(i).set\_down(&down->comp(i));
}
}
DerivCell \*down() {
return down\_;
}
DerivCell operator - () {
return DerivCell(\*This(), -1);
}
virtual DerivCell &Instance(int i) = 0;
virtual ScalarCell &InstanceAsScalar(int i) = 0;
virtual VectorCell &InstanceAsVector(int i) = 0;
DerivCell &dx\_left(bool recur = true);
DerivCell &dx\_right(bool recur = true);
DerivCell &dy\_right(bool recur = true);
DerivCell &dy\_left(bool recur = true);
DerivCell &laplacian(bool recur = true);
VectorCell &grad\_left(bool recur = true);
VectorCell &grad\_right(bool recur = true);
ScalarCell ÷\_left(bool recur = true);
ScalarCell ÷\_right(bool recur = true);
DerivCell &operator = (const DerivCell &rhs) {
if (!me().left\_ && !me().right\_ && !me().up\_ && !me().down\_) {
me().dim\_ = rhs.dim\_;
me().x\_ = rhs.x\_;
me().y\_ = rhs.y\_;
me().left\_ = rhs.left\_;
me().right\_ = rhs.right\_;
me().up\_ = rhs.up\_;
me().down\_ = rhs.down\_;
me().op\_ = rhs.op\_;
} else {
for (int i = 0; i < dim\_; i++) {
me().comp(i).val() = rhs.comp(i).val();
}
}
return \*This();
}
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
DerivCell &operator = (DerivCell &&rhs) {
if (me().left\_ || me().right\_ || me().up\_ || me().down\_)
return \*This();
dim\_ = std::move(rhs.dim\_);
x\_ = std::move(rhs.x\_);
y\_ = std::move(rhs.y\_);
left\_ = std::move(rhs.left\_);
right\_ = std::move(rhs.right\_);
up\_ = std::move(rhs.up\_);
down\_ = std::move(rhs.down\_);
op\_ = std::move(rhs.op\_);
return \*This();
}
#endif
DerivCell &operator = (const T &val) {
for(int i = 0; i < dim\_; i++) {
me().comp(i).val() = val;
}
return \*This();
}
#define DECLARE\_CELL\_OP(OPERAND)\
DerivCell &operator OPERAND (const DerivCell &rhs) {\
for(int i = 0; i < dim\_; i++) {\
me().comp(i).val() OPERAND rhs.comp(i).val();\
}\
return \*This();\
}\
DerivCell &operator OPERAND (const T &val) {\
for(int i = 0; i < dim\_; i++) {\
me().comp(i).val() OPERAND val;\
}\
return \*This();\
}
DECLARE\_CELL\_OP( += )
DECLARE\_CELL\_OP( -= )
DECLARE\_CELL\_OP( \*= )
DECLARE\_CELL\_OP( /= )
#undef DECLARE\_CELL\_OP
DerivCell & PlusEq() {
return SetOp(OpPlus, 0);
}
DerivCell &MinusEq() {
return SetOp(OpMinus, 0);
}
DerivCell &MultEq() {
return SetOp(OpMult, 1);
}
DerivCell &DivideEq() {
return SetOp(OpDivide, 1);
}
DerivCell &Eval() {
if (OpEqual == op\_) {
return \*This();
}
switch(op\_) {
case OpPlus:
op\_ = OpEqual;
\*This() += ft();
break;
case OpMinus:
op\_ = OpEqual;
\*This() -= ft();
break;
case OpMult:
op\_ = OpEqual;
\*This() \*= ft();
break;
case OpDivide:
op\_ = OpEqual;
\*This() /= ft();
break;
default:
DASSERT(0 && "Unknown arithmetic operation");
}
return \*This();
}
protected:
enum Operation {
OpEqual,
OpPlus,
OpMinus,
OpMult,
OpDivide
} op\_;
double x\_;
double y\_;
DerivCell \*left\_;
DerivCell \*right\_;
DerivCell \*up\_;
DerivCell \*down\_;
std::auto\_ptr scal\_[7];//todo: через shared\_ptr
std::auto\_ptr vec\_[7];//todo: через shared\_ptr
DerivCell &me() {
return (OpEqual == op\_) ? \*This() : ft();
}
DerivCell &ft() {
static DerivCell res(\*This());//todo
return res;
//return Instance(6);
}
DerivCell &SetOp(Operation op, int ft\_val) {
Eval();
op\_ = op;
ft() = ft\_val;
return \*This();
}
};
template
DerivCell &
MeshCell::dx\_left(bool recur) {
DerivCell &res = Instance(0);
for(int i = 0; i < dim\_; i++) {
DASSERT(left\_ != 0);
DASSERT(left\_->x\_ != x\_);
res.comp(i).val() = (comp(i).val() - left\_->comp(i).val()) / (x\_ - left\_->x\_);
}
if (recur) {
if (left\_ && left\_->left\_)
res.set\_left(&left\_->dx\_left(false));
if (right\_ && right\_->left\_)
res.set\_right(&right\_->dx\_left(false));
if (up\_ && up\_->left\_)
res.set\_up(&up\_->dx\_left(false));
if (down\_ && down\_->left\_)
res.set\_down(&down\_->dx\_left(false));
}
return res;
}
template
DerivCell &
MeshCell::dx\_right(bool recur) {
DerivCell &res = Instance(1);
for(int i = 0; i < dim\_; i++) {
DASSERT(right\_ != 0);
DASSERT(right\_->x\_ != x\_);
res.comp(i).val() = (right\_->comp(i).val() - comp(i).val()) / (right\_->x\_ - x\_);
}
if (recur) {
if (left\_ && left\_->right\_)
res.set\_left(&left\_->dx\_right(false));
if (right\_ && right\_->right\_)
res.set\_right(&right\_->dx\_right(false));
if (up\_ && up\_->right\_)
res.set\_up(&up\_->dx\_right(false));
if (down\_ && down\_->right\_)
res.set\_down(&down\_->dx\_right(false));
}
return res;
}
template
DerivCell &
MeshCell::dy\_left(bool recur) {
DerivCell &res = Instance(2);
for(int i = 0; i < dim\_; i++) {
DASSERT(down\_ != 0);
DASSERT(down\_->y\_ != y\_);
res.comp(i).val() = (comp(i).val() - down\_->comp(i).val()) / (y\_ - down\_->y\_);
}
if (recur) {
if (left\_ && left\_->down\_)
res.set\_left(&left\_->dy\_left(false));
if (right\_ && right\_->down\_)
res.set\_right(&right\_->dy\_left(false));
if (up\_ && up\_->down\_)
res.set\_up(&up\_->dy\_left(false));
if (down\_ && down\_->down\_)
res.set\_down(&down\_->dy\_left(false));
}
return res;
}
template
DerivCell &
MeshCell::dy\_right(bool recur) {
DerivCell &res = Instance(3);
for(int i = 0; i < dim\_; i++) {
DASSERT(up\_ != 0);
DASSERT(up\_->y\_ != y\_);
res.comp(i).val() = (up\_->comp(i).val() - comp(i).val()) / (up\_->y\_ - y\_);
}
if (recur) {
if (left\_ && left\_->up\_)
res.set\_left(&left\_->dy\_right(false));
if (right\_ && right\_->up\_)
res.set\_right(&right\_->dy\_right(false));
if (up\_ && up\_->up\_)
res.set\_up(&up\_->dy\_right(false));
if (down\_ && down\_->up\_)
res.set\_down(&down\_->dy\_right(false));
}
return res;
}
template
DerivCell &
MeshCell::laplacian(bool recur) {
DerivCell &res = Instance(4);
res = dx\_left(recur).dx\_right(false) + dy\_left(recur).dy\_right(false);//todo
return res;
}
template
ScalarCell &
MeshCell::div\_left(bool recur) {
ScalarCell &res = InstanceAsScalar(5);
if (dim\_ >= 1)
res = comp(0).dx\_left(recur);
if (dim\_ >= 2)
res += comp(1).dy\_left(recur);
if (recur) {
if (left\_ && left\_->left\_ && left\_->down\_)
res.set\_left(&left\_->div\_left(false));
if (right\_ && right\_->left\_ && right\_->down\_)
res.set\_right(&right\_->div\_left(false));
if (up\_ && up\_->left\_ && up\_->down\_)
res.set\_up(&up\_->div\_left(false));
if (down\_ && down\_->left\_ && down\_->down\_)
res.set\_down(&down\_->div\_left(false));
}
return res;
}
template
ScalarCell &
MeshCell::div\_right(bool recur) {
ScalarCell &res = InstanceAsScalar(6);
if (dim\_ >= 1)
res = comp(0).dx\_right(recur);
if (dim\_ >= 2)
res += comp(1).dy\_right(recur);
return res;
}
template
VectorCell &
MeshCell::grad\_left(bool recur) {
VectorCell &res = InstanceAsVector(0);
res.comp(0) = dx\_left(recur);
res.comp(1) = dy\_left(recur);
return res;
}
template
VectorCell &
MeshCell::grad\_right(bool recur) {
VectorCell &res = InstanceAsVector(1);
res.comp(0) = dx\_right(recur);
res.comp(1) = dy\_right(recur);
return res;
}
template
class VectorCell;
template
class ScalarCell : public MeshCell, ScalarCell, VectorCell > {
public:
explicit ScalarCell(T v = 0) {
dim\_ = 1;
val() = v;
}
ScalarCell(const ScalarCell &rhs, double mult = 1) : MeshCell(rhs),
val\_(mult \* rhs.val()) {
dim\_ = 1;
}
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
ScalarCell(ScalarCell &&rhs) : MeshCell(std::move(rhs)), val\_(std::move(rhs.val\_)) {}
#endif
virtual ~ScalarCell() {}
ScalarCell \*This() {
return this;
}
ScalarCell ∁(int i) {
DASSERT\_LE(i, 1);
return \*this;
}
const ScalarCell ∁(int i) const {
DASSERT\_LE(i, 1);
return \*this;
}
const T &val() const {
return val\_;
}
T &val() {
return val\_;
}
const T &val(int i) const {
return comp(i).val();
}
T &val(int i) {
return comp(i).val();
}
operator const T &() const {
return val();
}
operator T &() {
return val();
}
ScalarCell &Instance(int i) {
std::auto\_ptr &res = scal\_[i];
if (!res.get())
res.reset(new ScalarCell(\*this));
return \*res;
}
ScalarCell &InstanceAsScalar(int i) {
return Instance(i);
}
VectorCell &InstanceAsVector(int i) {
std::auto\_ptr > &res = vec\_[i];
if (!res.get())
res.reset(new VectorCell);
res->set\_x(x\_);
res->set\_y(y\_);
return \*res;
}
ScalarCell &operator = (const T &val) {
return MeshCell::operator=(val);
}
ScalarCell &operator = (const ScalarCell &rhs) {
me().val\_ = rhs.val\_;
return MeshCell::operator=(rhs);
}
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
ScalarCell &operator = (ScalarCell &&rhs) {
val\_ = std::move(rhs.val\_);
return MeshCell::operator=(std::move(rhs));
}
#endif
public:
T val\_;
};
//==================================================================================
template
class VectorCell : public MeshCell, ScalarCell, VectorCell > {
public:
std::vector \*> comp\_;//todo->auto\_ptr
VectorCell() {
Resize(2);
for(int i = 0; i < dim\_; i++) {
comp\_[i] = new ScalarCell;
}
}
explicit VectorCell(const T &val) {
Resize(2);
for(int i = 0; i < dim\_; i++) {
comp\_[i] = new ScalarCell(val);
}
}
VectorCell(const VectorCell &rhs, double mult = 1) : MeshCell(rhs) {
DASSERT\_EQ(dim\_, 2);
Resize(dim\_);
for(int i = 0; i < dim\_; i++) {
comp\_[i] = new ScalarCell(rhs.comp(i), mult);
}
}
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
VectorCell(VectorCell &&rhs) : MeshCell(std::move(rhs)), comp\_(std::move(rhs.comp\_)) {}
#endif
virtual ~VectorCell() {
Resize(0);
}
void Resize(int dim) {
for(int i = 0, n = comp\_.size(); i < n; i++) {
delete comp\_[i];
}
dim\_ = dim;
if (dim > 0) {
comp\_.resize(dim\_);
}
}
VectorCell \*This() {
return this;
}
ScalarCell ∁(int i) {
return \*comp\_[i];
}
const ScalarCell ∁(int i) const {
return \*comp\_[i];
}
VectorCell &Instance(int i) {
std::auto\_ptr &res = vec\_[i];
if (!res.get())
res.reset(new VectorCell(\*this));
return \*res;
}
ScalarCell &InstanceAsScalar(int i) {
std::auto\_ptr > &res = scal\_[i];
if (!res.get())
res.reset(new ScalarCell);
res->set\_x(x\_);
res->set\_y(y\_);
return \*res;
}
VectorCell &InstanceAsVector(int i) {
return Instance(i);
}
ScalarCell &operator()(int at) {
return comp(at);
}
const ScalarCell &operator()(int at) const {
return comp(at);
}
VectorCell &operator = (const T &val) {
return MeshCell::operator=(val);
}
VectorCell &operator = (const VectorCell &rhs) {
for (int i = 0; i < dim\_; i++) {
me().comp(i) = rhs.comp(i);
}
return MeshCell::operator=(rhs);
}
#if defined(USE\_STD\_MOVE) && (\_MSC\_VER > 1500)
VectorCell &operator = (VectorCell &&rhs) {
me().comp\_ = std::move(rhs.comp\_);
return MeshCell::operator=(std::move(rhs));
}
#endif
const T &max() const {
T ret = comp(0).val();
int i\_max = 0;
for(int i = 1; i < dim\_; i++) {
if (ret < comp(i).val()) {
ret = comp(i).val();
i\_max = i;
}
}
return comp(i\_max).val();
}
const T &min() const {
T ret = comp(0).val();
int i\_min = 0;
for(int i = 1; i < dim\_; i++) {
if (comp(i).val() < ret) {
ret = comp(i).val();
i\_min = i;
}
}
return comp(i\_min).val();
}
};
#define DECLARE\_CELL\_OP(OPERAND)\
template\
ScalarCell operator OPERAND (const ScalarCell &c1, const ScalarCell &c2)\
{\
ScalarCell res(c1);\
res OPERAND= c2;\
return res;\
}\
template\
VectorCell operator OPERAND (const VectorCell &c1, const VectorCell &c2)\
{\
VectorCell res(c1);\
res OPERAND= c2;\
return res;\
}\
template\
VectorCell operator OPERAND (const VectorCell &c, double val)\
{\
VectorCell res(c);\
res OPERAND= val;\
return res;\
}\
template\
VectorCell operator OPERAND (double val, const VectorCell &c)\
{\
VectorCell res(c);\
res OPERAND= val;\
return res;\
}
DECLARE\_CELL\_OP(+)
DECLARE\_CELL\_OP(-)
DECLARE\_CELL\_OP(\*)
DECLARE\_CELL\_OP( / )
#undef DECLARE\_CELL\_OP
//----------------------------------------------------------------------------------
template
bool operator < (const VectorCell &lhs, const VectorCell &rhs) {
for (int i = 0; i < lhs.dim\_; i++)
if (lhs(i) >= rhs(i))
return 0;
return 1;
}
//----------------------------------------------------------------------------------
template
bool operator <= (const VectorCell &lhs, const VectorCell &rhs) {
for (int i = 0; i < lhs.dim\_; i++)
if (lhs(i) > rhs(i))
return 0;
return 1;
}
//==================================================================================
struct Interval2d {
public:
int lb\_x, ub\_x;
int lb\_y, ub\_y;
Interval2d() :
lb\_x(0),
ub\_x(0),
lb\_y(0),
ub\_y(0) {}
Interval2d(int \_lb\_x, int \_ub\_x, int \_lb\_y, int \_ub\_y) {
Init(\_lb\_x, \_ub\_x, \_lb\_y, \_ub\_y);
}
void Init(int \_lb\_x, int \_ub\_x, int \_lb\_y, int \_ub\_y) {
lb\_x = \_lb\_x;
ub\_x = \_ub\_x;
lb\_y = \_lb\_y;
ub\_y = \_ub\_y;
}
int nx() const {
return ub\_x - lb\_x + 1;
}
int ny() const {
return ub\_y - lb\_y + 1;
}
};
//==================================================================================
#define FOREACH\_INTERVAL(I,i,j)\
for(int i = I.lb\_x, j; i <= I.ub\_x; i++)\
for(j = I.lb\_y; j <= I.ub\_y; j++)
template
class MeshCellStack {
public:
static MeshCellStack &Instance() {
static MeshCellStack instance;
return instance;
}
std::list cells;
};
template
class MeshOperator {
public:
Interval2d I;
MeshOperator(double val = 0) : val\_(val) {}
virtual bool IsStencil() const {
return false;
}
virtual int CountOfDependentVars() const {
return 1;
}
virtual MeshCell \*GetRef(int i, int j) const {
return 0;
}
virtual MeshCell &Eval(int i, int j) const {
MeshCell \*r = GetRef(i, j);
if (r) {
return \*r;
}
static MeshCell res;//todo: будет ошибка в OpenMP
Eval(&res, i, j);
return res;
}
virtual void Eval(MeshCell \*res, int i, int j) const {
\*res = val\_;
}
MeshCell &max() const {
int i\_max = I.lb\_x;
int j\_max = I.lb\_y;
//todo: брать val: скаляр или вектор
MeshCell ret = Eval(i\_max, j\_max);
FOREACH\_INTERVAL(I, i, j) {
MeshCell = Eval(i, j);
if (ret < it) {
i\_max = i;
j\_max = j;
ret = it;
}
}
return Eval(i\_max, j\_max);
}
MeshCell &min() const {
int i\_min = I.lb\_x;
int j\_min = I.lb\_y;
//todo: брать val: скаляр или вектор
MeshCell ret = Eval(i\_min, j\_min);
FOREACH\_INTERVAL(I, i, j) {
MeshCell = Eval(i, j);
if (it < ret) {
i\_min = i;
j\_min = j;
ret = it;
}
}
return Eval(i\_min, j\_min);
}
private:
double val\_;
};
template
class MeshOperatorBind : public MeshOperator {
public:
typedef MeshCellOut &(\*GlobalCellFunc\_ref)(MeshCellIn &, bool recur);
typedef MeshCellOut (\*GlobalCellFunc\_copy)(MeshCellIn &, bool recur);
MeshOperatorBind(const MeshOperator &rhs, GlobalCellFunc\_copy func) : rhs\_(rhs), func\_copy\_(func), func\_ref\_(0), mult\_(1) {
I = rhs.I;
}
MeshOperatorBind(const MeshOperator &rhs, GlobalCellFunc\_ref func) : rhs\_(rhs), func\_copy\_(0), func\_ref\_(func), mult\_(1) {
I = rhs.I;
}
bool IsStencil() const {
return true;
}
MeshCellOut \*GetRef(int i, int j) const {
if (mult\_ != 1.)
return 0;
MeshCellIn \*arg = rhs\_.GetRef(i, j);
return (arg && func\_ref\_) ? &func\_ref\_(\*arg, !rhs\_.IsStencil()) : 0;
}
virtual void Eval(MeshCellOut \*res, int i, int j) const {
MeshCellIn \*arg = rhs\_.GetRef(i, j);
if (arg) {
\*res = func\_copy\_ ? func\_copy\_(\*arg, !rhs\_.IsStencil()) : func\_ref\_(\*arg, !rhs\_.IsStencil());
} else {
MeshCellIn &arg = rhs\_.Eval(i, j);
\*res = func\_copy\_ ? func\_copy\_(arg, !rhs\_.IsStencil()) : func\_ref\_(arg, !rhs\_.IsStencil());
}
\*res \*= mult\_;
}
MeshOperatorBind &operator - () {
mult\_ = -1;
return \*this;
}
private:
//MeshProxy как наследник должен переопределить Eval
const MeshOperator &rhs\_;
GlobalCellFunc\_copy func\_copy\_;
GlobalCellFunc\_ref func\_ref\_;
double mult\_;
};
//==================================================================================
template
class MeshProxy : public MeshOperator {
public:
MeshFunc &mesh
MeshProxy(MeshFunc &\_mesh, const Interval2d &\_I, double mult = 1) : mesh(\_mesh), mult\_(mult) {
I = \_I;
}
virtual ~MeshProxy() {}
virtual MeshDeriv \*This() = 0;
int CountOfDependentVars() const {
return 1;
}
MeshCellOut \*GetRef(int i, int j) const {
return (1. == mult\_) ? &mesh(i, j) : 0;
}
virtual void Eval(MeshCellOut \*res, int i, int j) const {
\*res = mesh(i, j);
if (mult\_ != 1.)
\*res \*= mult\_;
}
bool IsEqual(const MeshProxy &rhs) const {
if (I.lb\_x != rhs.I.lb\_x)
return 0;
if (I.lb\_y != rhs.I.lb\_y)
return 0;
FOREACH\_INTERVAL(I, i, j) {
if (mesh\_(i, j) != rhs.mesh\_(i, j) || mult\_ != rhs.mult\_)
return 0;
}
return 1;
}
MeshDeriv &operator - () {
mult\_ = -1;
return \*This();
}
MeshDeriv &operator =(const MeshOperator &rhs) {
FOREACH\_INTERVAL(I, i, j) {
MeshCellOut &c = mesh(i, j);
if (rhs.CountOfDependentVars() <= 1)
rhs.Eval(&c, i, j);
else
c = rhs.Eval(i, j);
}
MeshCellStack::Instance().cells.clear();
return \*This();
}
MeshDeriv &operator +=(const MeshOperator &rhs) {
FOREACH\_INTERVAL(I, i, j) {
MeshCellOut &c = mesh(i, j);
c += rhs.Eval(i, j);
}
return \*This();
}
MeshDeriv &operator -=(const MeshOperator &rhs) {
FOREACH\_INTERVAL(I, i, j) {
MeshCellOut &c = mesh(i, j);
c -= rhs.Eval(i, j);
}
return \*This();
}
MeshDeriv &operator \*=(const MeshOperator &rhs) {
FOREACH\_INTERVAL(I, i, j) {
MeshCellOut &c = mesh(i, j);
c \*= rhs.Eval(i, j);
}
return \*This();
}
MeshDeriv &operator /=(const MeshOperator &rhs) {
FOREACH\_INTERVAL(I, i, j) {
MeshCellOut &c = mesh(i, j);
c /= rhs.Eval(i, j);
}
return \*This();
}
#define DECLARE\_MESH\_OP(OPERAND)\
MeshDeriv &operator OPERAND(double val) {\
FOREACH\_INTERVAL(I, i, j) {\
mesh(i, j) OPERAND val;\
}\
return \*This();\
}
DECLARE\_MESH\_OP( = )
DECLARE\_MESH\_OP( += )
DECLARE\_MESH\_OP( -= )
DECLARE\_MESH\_OP( \*= )
DECLARE\_MESH\_OP( /= )
#undef DECLARE\_MESH\_OP
void ToVector(dblArray1d \*v, int lb = 0) {//todo: template T
const int nx = I.nx();
const int n = lb + nx \* I.ny();
if (v->size() != n)
v->resize(n);
int at = lb;
FOREACH\_INTERVAL(I, i, j) {
(\*v)[at++] = mesh(i, j);
}
}
void FromVector(const dblArray1d &v, int lb = 0) {//todo: template T
if (I.nx() \* I.ny() != v.size() - lb)
;//THROW("Size of mesh must and (v.size() - lb) must be equals")//todo
int at = lb;
FOREACH\_INTERVAL(I, i, j) {
mesh(i, j) = v[at++];
}
}
private:
double mult\_;
};
//==================================================================================
template
class MeshFunc : public array2d {
public:
double a\_;
double b\_;
double hx\_;
double hy\_;
MeshFunc(double a = 0, double b = 0, int nx = 0, int ny = 0) {
if (nx > 0 && ny > 0)
Resize(a, b, nx, ny);
}
virtual ~MeshFunc() {}
void Resize(double a, double b, int nx, int ny);
double a() const {
return a\_;
}
double b() const {
return b\_;
}
int nx() const {
return nx\_ - 2;
}
int ny() const {
return ny\_ - 2;
}
double hx() const {
return hx\_;
}
double hy() const {
return hy\_;
}
double x(int i, int j) {
return at(i, j).x();
}
double y(int i, int j) {
return at(i, j).y();
}
Interval2d I\_all() const {
return Interval2d(0, nx\_ - 1, 0, ny\_ - 1);
}
Interval2d I\_int() const {
return Interval2d(1, nx\_ - 2, 1, ny\_ - 2);
}
virtual MeshDeriv \*This() = 0;
operator MeshProxy() {
return without\_bnd();
}
MeshProxy without\_bnd() {
return MeshProxy(\*This(), I\_int());
}
MeshProxy all() {
return MeshProxy(\*This(), I\_all());
}
MeshDeriv &operator =(MeshDeriv &rhs) {
all() = rhs.all();
return \*This();
}
MeshDeriv &operator +=(MeshDeriv &rhs) {
all() += rhs.all();
return \*This();
}
MeshDeriv &operator -=(MeshDeriv &rhs) {
all() -= rhs.all();
return \*This();
}
MeshDeriv &operator \*=(MeshDeriv &rhs) {
all() \*= rhs.all();
return \*This();
}
MeshDeriv &operator /=(MeshDeriv &rhs) {
all() /= rhs.all();
return \*This();
}
MeshProxy dx\_left(const Interval2d &I) {
return ::dx\_left(MeshProxy(\*this, I));
}
MeshProxy dx\_right(const Interval2d &I) {
return ::dx\_right(MeshProxy(\*this, I));
}
MeshProxy laplacian(const Interval2d &I) {
return ::laplacian(MeshProxy(\*this, I));
}
MeshScalarOperator ÷\_left(const Interval2d &I) {
return ::div\_left(MeshProxy(\*this, I));
}
MeshScalarOperator ÷\_right(const Interval2d &I) {
return ::div\_right(MeshProxy(\*this, I));
}
MeshVectorOperator &grad\_left(const Interval2d &I) {
return ::grad\_left(MeshProxy(\*this, I));
}
MeshVectorOperator &grad\_right(const Interval2d &I) {
return ::grad\_right(MeshProxy(\*this, I));
}
};
template
void
MeshFunc::Resize(double a, double b, int nx, int ny) {
a\_ = a;
b\_ = b;
array2d::Resize(nx + 2, ny + 2);
hx\_ = (b\_ - a\_) / (nx + 1);
hy\_ = (b\_ - a\_) / (ny + 1);
for(int i = 0, j; i <= nx + 1; i++) {
for(j = 0; j <= ny + 1; j++) {
MeshCell &cell = at(i, j);
cell.set\_x(a\_ + i \* hx\_);
cell.set\_y(a\_ + j \* hy\_);
if (i > 0)
cell.set\_left(&at(i - 1, j));
else
cell.set\_left(0);//иначе, если повторное вызывать Resize с другими размерами, останется мусор
if (i <= nx)
cell.set\_right(&at(i + 1, j));
else
cell.set\_right(0);
if (j > 0)
cell.set\_down(&at(i, j - 1));
else
cell.set\_down(0);
if (j <= ny)
cell.set\_up(&at(i, j + 1));
else
cell.set\_up(0);
}
}
}
//==================================================================================
template
class ScalarMeshFunc;
template
class ScalarMeshProxy : public MeshProxy, ScalarMeshFunc, ScalarMeshProxy, ScalarCell, ScalarCell > {
public:
ScalarMeshProxy(ScalarMeshFunc &mesh, const Interval2d &\_I) : MeshProxy(mesh, \_I) {}
ScalarMeshProxy \*This() {
return this;
}
ScalarMeshProxy &operator=(const ScalarMeshProxy &rhs) {
DASSERT\_GE(I.lb\_x, rhs.I.lb\_x);
DASSERT\_GE(I.lb\_y, rhs.I.lb\_y);
DASSERT\_LE(I.ub\_x, rhs.I.ub\_x);
DASSERT\_LE(I.ub\_y, rhs.I.ub\_y);
return MeshProxy::operator =(rhs);
}
ScalarMeshProxy &operator=(const MeshOperator > &rhs) {
return MeshProxy::operator =(rhs);
}
ScalarMeshProxy &operator=(const T &val) {
return MeshProxy::operator =(val);
}
};
template
class Scalar2VectorMeshProxy : public MeshProxy, ScalarMeshFunc, ScalarMeshProxy, ScalarCell, VectorCell > {
public:
Scalar2VectorMeshProxy \*This() {
return this;
}
Scalar2VectorMeshProxy &operator=(const Scalar2VectorMeshProxy &rhs) {
return MeshProxy::operator =(rhs);
}
};
//==================================================================================
template
class VectorMeshFunc;
template
class ScalarMeshFunc
: public MeshFunc, ScalarCell, ScalarMeshProxy, ScalarMeshFunc, VectorMeshFunc > {
public:
ScalarMeshFunc(double a = 0, double b = 0, int nx = 0, int ny = 0)
: MeshFunc(a, b, nx, ny) {}
ScalarMeshFunc \*This() {
return this;
}
ScalarCell &operator()(int i, int j) {
return at(i, j);
}
const ScalarCell &operator()(int i, int j) const {
return at(i, j);
}
ScalarMeshProxy operator()(const Interval2d &I) {
return ScalarMeshProxy(\*this, I);
}
};
template
std::ostream &operator << (std::ostream &os, const MeshOperator &mesh) {
const Interval2d &I = mesh.I;
StreamTable st;
st.SetCols(I.ub\_y - I.lb\_y + 1, 10);
FOREACH\_INTERVAL(I, i, j) {
st << mesh.Eval(i, j);
}
//os << st.os();
return os;
}
//==================================================================================
template
class VectorMeshProxy : public MeshProxy, VectorMeshFunc, VectorMeshProxy, VectorCell, VectorCell > {
public:
VectorMeshProxy(VectorMeshFunc &mesh, const Interval2d &\_I) : MeshProxy(mesh, \_I) {}
VectorMeshProxy \*This() {
return this;
}
VectorMeshProxy &operator=(const VectorMeshProxy &rhs) {
DASSERT\_GE(I.lb\_x, rhs.I.lb\_x);
DASSERT\_GE(I.lb\_y, rhs.I.lb\_y);
DASSERT\_LE(I.ub\_x, rhs.I.ub\_x);
DASSERT\_LE(I.ub\_y, rhs.I.ub\_y);
return MeshProxy::operator =(rhs);
}
VectorMeshProxy &operator=(const MeshOperator > &rhs) {
return MeshProxy::operator =(rhs);
}
VectorMeshProxy &operator=(const T &val) {
return MeshProxy::operator =(val);
}
};
template
class Vector2ScalarMeshProxy : public MeshProxy, VectorMeshFunc, VectorMeshProxy, VectorCell, ScalarCell > {
public:
Vector2ScalarMeshProxy \*This() {
return this;
}
Vector2ScalarMeshProxy &operator=(const Vector2ScalarMeshProxy &rhs) {
return MeshProxy::operator =(rhs);
}
};
/\*template
class Vector2VectorMeshProxy : public MeshProxy, VectorMeshFunc, VectorMeshProxy, VectorCell, VectorCell > > {
public:
Vector2VectorMeshProxy \*This() {
return this;
}
Vector2VectorMeshProxy &operator=(const Vector2VectorMeshProxy &rhs) {
return MeshProxy::operator =(rhs);
}
};\*/
template
class VectorMeshFunc
: public MeshFunc, VectorCell, VectorMeshProxy, ScalarMeshFunc, VectorMeshFunc > {
public:
VectorMeshFunc(double a = 0, double b = 0, int nx = 0, int ny = 0)
: MeshFunc(a, b, nx, ny) {}
VectorMeshFunc \*This() {
return this;
}
VectorCell &operator()(int i, int j) {
return at(i, j);
}
const VectorCell &operator()(int i, int j) const {
return at(i, j);
}
VectorMeshProxy operator()(const Interval2d &I) {
return VectorMeshProxy(\*this, I);
}
};
//==================================================================================
#define DECLARE\_MESH\_OP(CLASS,OPERAND,OPFUNC)\
template\
class CLASS : public MeshOperator {\
public:\
MeshCell &res\_;\
CLASS(const MeshOperator &op1, const MeshOperator &op2, MeshCell &res) : op1\_(op1), op2\_(op2), res\_(res) {\
I = op1.I;/\*todo\*/\
}\
\
bool IsStencil() const {\
return op1\_.IsStencil() || op2\_.IsStencil();\
}\
int CountOfDependentVars() const {\
return op1\_.CountOfDependentVars() + op2\_.CountOfDependentVars() + 1;\
}\
virtual void Eval(MeshCell \*res, int i, int j) const {\
\*res = op1\_.Eval(i, j);\
\*res OPERAND= op2\_.Eval(i, j);\
}\
virtual MeshCell &Eval(int i, int j) const {\
res\_ = op1\_.Eval(i, j);\
res\_ OPERAND= op2\_.Eval(i, j);\
return res\_;\
}\
private:\
const MeshOperator &op1\_;\
const MeshOperator &op2\_;\
};\
inline CLASS > operator OPERAND (const MeshOperator > &op1, const MeshOperator > &op2)\
{\
std::list > &stack = MeshCellStack >::Instance().cells;\
stack.push\_back(ScalarCell());\
return CLASS >(op1, op2, stack.back());\
}\
inline CLASS > operator OPERAND (const MeshOperator > &op1, const MeshOperator > &op2)\
{\
std::list > &stack = MeshCellStack >::Instance().cells;\
stack.push\_back(VectorCell());\
return CLASS >(op1, op2, stack.back());\
}
DECLARE\_MESH\_OP(OperatorPlus, +, PlusEq())
DECLARE\_MESH\_OP(OperatorMinus, -, MinusEq())
DECLARE\_MESH\_OP(OperatorMult, \*, MultEq())
DECLARE\_MESH\_OP(OperatorDivide, / , DivideEq())
#undef DECLARE\_MESH\_OP
//----------------------------------------------------------------------------------
template
ScalarCell fabs(ScalarCell &u, bool recur) {
ScalarCell res(u);
res.val() = ::fabs(res.val());
return res;
}
template
VectorCell fabs(VectorCell &u, bool recur) {
VectorCell res(u);
for(int i = 0; i < res.dim\_; i++) {
res.comp(i).val() = fabs(res.comp(i).val());
}
return res;
}
#define SCALAR\_OPERATOR(T) MeshOperatorBind, ScalarCell >
#define VECTOR\_OPERATOR(T) MeshOperatorBind, VectorCell >
#define SCALAR\_2\_VECTOR\_OPERATOR(T) MeshOperatorBind, VectorCell >
#define VECTOR\_2\_SCALAR\_OPERATOR(T) MeshOperatorBind, ScalarCell >
template
SCALAR\_OPERATOR(T) fabs(MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::fabs);
}
template
VECTOR\_OPERATOR(T) fabs(MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::fabs);
}
//----------------------------------------------------------------------------------
template
ScalarCell &dx\_left(ScalarCell &u, bool recur = true) {
return u.dx\_left(recur);
}
template
VectorCell &dx\_left(VectorCell &u, bool recur = true) {
return u.dx\_left(recur);
}
template
SCALAR\_OPERATOR(T) dx\_left(const MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::dx\_left);
}
template
VECTOR\_OPERATOR(T) dx\_left(const MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::dx\_left);
}
//----------------------------------------------------------------------------------
template
ScalarCell &dx\_right(ScalarCell &u, bool recur = true) {
return u.dx\_right(recur);
}
template
VectorCell &dx\_right(VectorCell &u, bool recur = true) {
return u.dx\_right(recur);
}
template
SCALAR\_OPERATOR(T) dx\_right(const MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::dx\_right);
}
template
VECTOR\_OPERATOR(T) dx\_right(const MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::dx\_right);
}
//----------------------------------------------------------------------------------
template
ScalarCell &dy\_left(ScalarCell &u, bool recur = true) {
return u.dy\_left(recur);
}
template
VectorCell &dy\_left(VectorCell &u, bool recur = true) {
return u.dy\_left(recur);
}
template
SCALAR\_OPERATOR(T) dy\_left(const MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::dy\_left);
}
template
VECTOR\_OPERATOR(T) dy\_left(const MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::dy\_left);
}
//----------------------------------------------------------------------------------
template
ScalarCell &dy\_right(ScalarCell &u, bool recur = true) {
return u.dy\_right(recur);
}
template
VectorCell &dy\_right(VectorCell &u, bool recur = true) {
return u.dy\_right(recur);
}
template
SCALAR\_OPERATOR(T) dy\_right(const MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::dy\_right);
}
template
VECTOR\_OPERATOR(T) dy\_right(const MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::dy\_right);
}
//----------------------------------------------------------------------------------
template
ScalarCell &laplacian(ScalarCell &u, bool recur = true) {
return u.laplacian(recur);
}
template
VectorCell &laplacian(VectorCell &u, bool recur = true) {
return u.laplacian(recur);
}
template
SCALAR\_OPERATOR(T) laplacian(const MeshOperator > &f) {
return SCALAR\_OPERATOR(T)(f, &::laplacian);
}
template
VECTOR\_OPERATOR(T) laplacian(const MeshOperator > &f) {
return VECTOR\_OPERATOR(T)(f, &::laplacian);
}
//----------------------------------------------------------------------------------
template
ScalarCell ÷\_left(VectorCell &v, bool recur = true) {
return v.div\_left(recur);
}
template
VECTOR\_2\_SCALAR\_OPERATOR(T) div\_left(const MeshOperator > &f) {
return VECTOR\_2\_SCALAR\_OPERATOR(T)(f, &::div\_left);
}
//----------------------------------------------------------------------------------
template
ScalarCell ÷\_right(VectorCell &v, bool recur = true) {
return v.div\_right(recur);
}
template
VECTOR\_2\_SCALAR\_OPERATOR(T) div\_right(const MeshOperator > &f) {
return VECTOR\_2\_SCALAR\_OPERATOR(T)(f, &::div\_right);
}
//----------------------------------------------------------------------------------
template
VectorCell &grad\_left(ScalarCell &u, bool recur = true) {
return u.grad\_left(recur);
}
template
SCALAR\_2\_VECTOR\_OPERATOR(T) grad\_left(const MeshOperator > &f) {
return SCALAR\_2\_VECTOR\_OPERATOR(T)(f, &::grad\_left);
}
/\*template
Vector2VectorMeshProxy grad\_left(VECTOR\_OPERATOR(T) &f) {
return Vector2VectorMeshProxy(f, &::grad\_left);
}\*/
//----------------------------------------------------------------------------------
template
VectorCell &grad\_right(ScalarCell &u, bool recur = true) {
return u.grad\_right(recur);
}
template
SCALAR\_2\_VECTOR\_OPERATOR(T) grad\_right(const MeshOperator > &f) {
return SCALAR\_2\_VECTOR\_OPERATOR(T)(f, &::grad\_right);
}
/\*
template
Vector2VectorMeshProxy grad\_right(VECTOR\_OPERATOR(T) &f) {
return Vector2VectorMeshProxy(f, &::grad\_right);
}\*/
//==================================================================================
template
const T &max(const VectorCell &c) {
return c.max();
}
template
const T &min(const VectorCell &c) {
return c.min();
}
template
T &max(const MeshOperator > &m) {
return m.max();
}
template
T &min(const MeshOperator > &m) {
return m.min();
}
template
VectorCell &max(const MeshOperator > &m) {
return m.max();
}
template
VectorCell &min(const MeshOperator > &m) {
return m.min();
}
```
**Файл Arrays.h**
```
//(с) 2016-2019 Шарипов Тимур, SharipovTR@gmail.com
//Распространяется As Is
#ifndef __ARRAYS_H
#define __ARRAYS_H
#pragma once
#include "NumericAssert.h"
#include
/\*\*
\* Dynamic 0-based 1D array (storage is std::vector)
\*/
template
class array1d : public std::vector {
public:
typedef std::vector baseClass;
typedef std::size\_t index;
array1d(index n = 0) : baseClass(n) {}
const T &operator()(index i) const {
return baseClass::operator[](i);
}
T &operator()(index i) {
return baseClass::operator[](i);
}
void Resize(index /\*lb\*/, index ub) {
baseClass::resize(ub + 1);
}
};
#define RS2D(i,j,ny) ((i) \* (ny) + (j))
/\*\*
\* Dynamic 0-based row-oriented 2D array (storage is only one std::vector)
\*/
template
class array2d : public std::vector {
public:
typedef std::vector baseClass;
typedef std::size\_t index;
array2d(index nx = 0, index ny = 0) {
Resize(nx, ny);
}
array2d(int n, const T v[]) {
Resize(n, n);
std::copy(v, v + n \* n, baseClass::begin());
}
array2d(const array2d &rhs) {
Resize(rhs.nx\_, rhs.ny\_);
std::copy(rhs.begin(), rhs.end(), begin());
}
void Resize(index nx, index ny) {
if (nx > 0 && ny > 0)
baseClass::resize(nx \* ny);
nx\_ = nx;
ny\_ = ny;
}
void resize(int nx, int ny, bool reserved) {
Resize(nx, ny);
}
index Size() const {
DASSERT\_EQ(nx\_, ny\_);
return nx\_;
}
void Clear() {
baseClass::clear();
nx\_ = 0;
ny\_ = 0;
}
const T &at(index i, index j) const {
DASSERT(CHR(i, 0, nx\_));
DASSERT(CHR(j, 0, ny\_));
return baseClass::operator[](RS2D(i, j, ny\_));
}
virtual T &at(index i, index j) {
return baseClass::operator[](RS2D(i, j, ny\_));
}
const T &operator()(index i, index j) const {
return at(i, j);
}
T &operator()(index i, index j) {
return at(i, j);
}
void FillRow(index irow, T val) {
DASSERT(CHR(irow, 0, nx\_));
typename baseClass::iterator beg = baseClass::begin() + RS2D(irow, 0, ny\_);
std::fill(beg, beg + ny\_, val);
}
std::vector &operator =(const std::vector &rhs) {
std::copy(rhs.begin(), rhs.end(), baseClass::begin());
return \*this;
}
public:
index nx\_;
index ny\_;
};
```
**Файл NumericAssert.h**
```
//(с) 2016-2019 Шарипов Тимур, SharipovTR@gmail.com
//Распространяется As Is
#pragma once
#include "assert.h"
#include
#include
#define TO\_STR(x) #x
#define ASSERT\_OP(opname,op,val1,val2)\
if (!(val1 op val2)) do {\
std::stringstream ss;\
ss << TO\_STR(ASSERT##opname) << " failed:" << "\n";\
ss << #val1 << ": " << val1 << "\n";\
ss << #val2 << ": " << val2 << "\n";\
ss << TO\_STR(val1 - val2) << ": " << val1 - (val2);\
std::string s(ss.str());\
std::cout << s.c\_str();\
} while(0)
#define ASSERT\_EQ(val1, val2) ASSERT\_OP(\_EQ, ==, val1, val2)
#define ASSERT\_NE(val1, val2) ASSERT\_OP(\_NE, !=, val1, val2)
#define ASSERT\_LE(val1, val2) ASSERT\_OP(\_LE, <=, val1, val2)
#define ASSERT\_LT(val1, val2) ASSERT\_OP(\_LT, < , val1, val2)
#define ASSERT\_GE(val1, val2) ASSERT\_OP(\_GE, >=, val1, val2)
#define ASSERT\_GT(val1, val2) ASSERT\_OP(\_GT, > , val1, val2)
#define ASSERT\_NEAR(val1,val2,margin)\
do {\
ASSERT\_LE((val1), (val2) + margin);\
ASSERT\_GE((val1), (val2) - margin);\
} while(0)
#define ASSERT\_DBL\_EQ(val1,val2)\
ASSERT\_NEAR(val1, val2, 1.e-12);
#ifdef \_DEBUG
#define DASSERT assert
#define DASSERT\_EQ(val1, val2) ASSERT\_EQ(val1, val2)
#define DASSERT\_NE(val1, val2) ASSERT\_NE(val1, val2)
#define DASSERT\_LE(val1, val2) ASSERT\_LE(val1, val2)
#define DASSERT\_LT(val1, val2) ASSERT\_LT(val1, val2)
#define DASSERT\_GE(val1, val2) ASSERT\_GE(val1, val2)
#define DASSERT\_GT(val1, val2) ASSERT\_GT(val1, val2)
#define DASSERT\_NEAR(val1,val2,margin) ASSERT\_NEAR(val1,val2,margin)
#define DASSERT\_NEAR\_SMALL(val1,val2) ASSERT\_NEAR\_SMALL(val1,val2)
#define DASSERT\_DBL\_EQ(val1,val2) ASSERT\_DBL\_EQ(val1,val2)
#else
#define DASSERT
#define DASSERT\_EQ(val1, val2)
#define DASSERT\_NE(val1, val2)
#define DASSERT\_LE(val1, val2)
#define DASSERT\_LT(val1, val2)
#define DASSERT\_GE(val1, val2)
#define DASSERT\_GT(val1, val2)
#define DASSERT\_NEAR(val1,val2,margin)
#define DASSERT\_NEAR\_SMALL(val1,val2)
#define DASSERT\_DBL\_EQ(val1,val2)
#endif
``` | https://habr.com/ru/post/442316/ | null | ru | null |
# Копируем заголовок и URL в удобном виде
Около года назад я опубликовал топик [Удобное дополнение к IE при написании обзоров](http://habrahabr.ru/blogs/ie/68067/), в котором рассказывал о своей небольшой программке, которая позволяет одним щелчком мыши скопировать заголовок и URL страницы в удобном виде. В комментариях хабраюзеры говорили, что могут написать аналогичный пример для Firefox. Но дальше слов дело не пошло. К счастью, за бугром нашелся человек, который написал аналогичное расширение и для [красной панды](http://alexanderklimov.ru/2010/07/25/krasnaya-panda-firefox/)...
Расширение называется Copy Link Text (CoLT) и найте его можно на сайте <http://www.borngeek.com/firefox/colt/>. После несложной операции установки и перезапуска браузера можно приступать к работе с раширением. Откройте любую страницу в Firefox и щелкните правой кнопкой мыши в любом месте страницы для вызова контекстного меню. Вы увидите новую команду **Копировать заголовок страницы и адрес как...** с подменю.
На выбор вам предлагается целых пять вариантов — два основных и три дополнительных. Вкратце рассмотрим их.
* **HTML Link** — работает аналогично моему приложению под IE. Пример: `[Хабрахабр](http://habrahabr.ru/)`
* **Plain Text** — в виде обычного текста. Включает в себя заголовок и ссылку без тегов. Пример: `Изменим окна к лучшему :-) - user.alexanderklimov.ru`
* **BBCode** — подойдет для форумов. Пример: [url=http://developer.alexanderklimov.ru/]Сайт для программистов[/url]
* **FuseTalk** — честно признаюсь, что не знаю такого формата. Пример: [L=Блог Александра Климова]http://blog.alexanderklimov.ru/[/L]
* **Wikipedia** — понятно без комментариев. Пример: [http://blog.borngeek.com/ this link to my blog]
Обратите внимание, что при установке и во время работы с расширением мы видим полностью локализованные строки на русском. Расширение было локализовано на несколько десятков языков при помощи добровольцев, которые прислали автору свои переводы. К сожалению, на моей рабочей машине (русская Windows XP, русская версия FF) обнаружился небольшой косяк. В контекстном меню вместо русских символов появилась какая-то абракадабра. Возможно, проблемы с кодировкой. К счастью, оказалось, что проблему легко решить, не обладая навыками хакера/программиста.
Достаточно вызвать окно **Дополнения**, перейти на вкладку **Расширения** и нажать на кнопку **Настройки** в расширении CoLT
Далее в новом окне выбираете пункт меню, который выводится кракозябрами, щелкаете на кнопке **Изменить** и редактируете строчку по своему желанию. В моем примере я использовал английский вариант, как в оригинале.
На мой взгляд расширение получилось даже более удобным и функциональным, чем в IE. Пользуйтесь на здоровье. | https://habr.com/ru/post/96518/ | null | ru | null |
# Советы начинающим веб-разработчикам
Я занимаюсь созданием сайтов в том или ином виде с 1995 года. После 25 лет работы, думаю, что накопил опыта и теперь располагаю достаточными знаниями. Ниже в произвольном порядке изложено несколько моментов, о которых я бы хотел, чтобы начинающие разработчики поразмыслили.
* Порой сайт — это всего лишь сайт.
* Браузер уже является клиентом; HTML — это язык, на котором он разговаривает.
* Веб строится вокруг визуализации на стороне сервера.
* Вы можете предоставить данные несколькими способами; рассмотрите HTML как один из способов представления данных.
* Масштабирование на стороне вашего сервера поможет всем, в то время как масштабирование на стороне клиента, помогает только тем, у кого мощное железо и быстрое соединение.
* Не каждый имеет (или может использовать) мышку.
* Не каждый имеет (или может использовать) клавиатуру.
* Не каждый имеет (или может использовать) тачскрин.
* Не у каждого цвета и картинки отображаются так же, как и у вас.
* Не каждый имеет такие возможности обработки информации, какие имеете вы.
* Бесчеловечно перекладывать все на других.
* Родной для браузера HTML намного быстрее чем все, что бы вы там не написали на JavaScript.
* HTML уже идеально представляет узлы DOM.
* HTML — полноценный фреймворк.
* Вы вполне можете менять оформление в CSS.
* Прежде чем создавать компонент пользовательского интерфейса, проверьте, есть ли он в HTML. Если доступного нет, вероятно, есть тому причина. Добавление DOM к `div` или `span` не лучший выход.
* Не все должно быть “одностраничным приложением”.
* Даже если вам нужно сохранить состояние клиента между загрузками страниц (например, для воспроизведения музыки или видео), вы можете доверить браузеру выполнять большую часть тяжелой работы через поиск (fetch)новой страницы, и заменяя контент-контейнер на уровне DOM.
* Бесконечный скроллинг бесчеловечен. Люди должны быть в состоянии долистать “до конца”. Описанные в религиозных текстах мучения и то менее жестоки.
* Если вы должны сделать бесконечный скроллинг (а вы его не делаете), убедитесь, что внизу ничего не понадобится.
* Дайте людям постоянный, но произвольный стимул, и вы сформируете у них привычку. Подсадить людей на свой продукт может и кажется отличной идеей, но табачные компании идут по этому же пути.
* Если вы разрабатываете с учетом CDN, то обход сервера не будет медленным.
* Можно использовать несколько языков одновременно. Главное не делать все изоморфным.
* Всегда проверяйте свои данные на стороне сервера; все, что приходит от клиента должно вызывать подозрение.
* Разработчику «изоморфный» код разрушает барьер между клиентом и сервером. Для вредоносного клиента это означает, что он потенциально может контролировать сервер. Знайте, откуда приходят данные.
* Браузеры меняются. Полагаться на поведение конкретного браузера означает, что вы полагаетесь на этот, один, браузер в данный момент времени. Кодируйте по стандарту и везде тестируйте.
* Используйте полифиллы для браузеров, которые еще не поддерживают используемый вами стандарт.
* Копировать других — нормально; так мы учимся. Просто не делайте это бездумно.
Несколько человек заинтересовались, что я имел в виду, говоря “сохранить состояние клиента между загрузками страниц”. Это не хрестоматийно, но я имею в виду, что вы можете сделать что-то вроде этого:
```
Div replacement test
window.addEventListener('DOMContentLoaded', () => {
[].slice.call(document.getElementsByClassName("replace")).forEach(elem => {
elem.addEventListener('click', event => {
event.preventDefault();
fetch(elem.href)
.then(response => response.text())
.then(text => {
let parser = new DOMParser();
var other = parser.parseFromString(text, 'text/html');
document.title = other.querySelector('title').innerHTML;
var content = document.getElementById('content')
content.innerHTML = other.querySelector('#content').innerHTML
})
})
})
})
Here is the content container. [The other document](replaced.html)
```
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя платные онлайн-курсы SkillFactory:
* [Курс по Machine Learning (12 недель)](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=20062002)
* [Курс «Профессия Data Scientist» (24 месяца)](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DSPR&utm_term=regular&utm_content=20062002)
* [Курс «Профессия Data Analyst» (18 месяцев)](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DAPR&utm_term=regular&utm_content=20062002)
* [Курс «Python для веб-разработки» (9 месяцев)](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=20062002)
### Читать еще
* [Крутые Data Scientist не тратят время на статистику](https://habr.com/ru/company/skillfactory/blog/507052/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024/)
* [Шпаргалка по сортировке для Data Science](https://habr.com/ru/company/skillfactory/blog/506888/)
* [Data Science для гуманитариев: что такое «data»](https://habr.com/ru/company/skillfactory/blog/506798/)
* [Data Scienсe на стероидах: знакомство с Decision Intelligence](https://habr.com/ru/company/skillfactory/blog/506790/) | https://habr.com/ru/post/507476/ | null | ru | null |
# Как и зачем я сдавал сертификацию Oracle — Java SE 11 Developer
Меня зовут Аксёнов Вячеслав и я бэкенд разработчик, пишу на Java/Kotlin, расскажу про то, как я сдавал сертификацию на знания Java SE 11 от Oracle. И какие нюансы я понял в процессе подготовки.
Заветный документ### Предыстория. Зачем я решил сдавать?
Начну с того, что идея по сдаче именно этой сертификации сидела у меня в голове очень давно. Перед глазами был пример моей жены, у которой есть крайне солидный опыт ETL разработки и сертификат Oracle по базам данных в придачу. Когда ей надоело заниматься построением сложных запросов, она захотела перейти в разработку и писать на Java.
Процесс собеседования Java разработчика до миддла имеет примерно стандартный вид - секция с алгоритмами, секция с java core и конечно секция с знаниями БД. В ее случае на секции БД собеседующие посмотрели на сертификат, на предыдущий опыт и предложили ей самой их пособеседовать. Это конечно просто курьезный случай и все такое, но передо мной есть пример того, как сертификат отлично сработал и помог срезать углы при найме.
Я включил фантазию и представил как может в моем случае помочь сертификат от того же оракла, но по Java. Погуглил и наткнулся на скидку в 90% в честь юбилея Java на сайте оракл и до конца этого периода оставалось всего 2 недели. Что делать? Конечно надо сдавать! Но надо же готовиться? Да не, еще целых 2 недели, успеешь - сказал мне внутренний голос. Так прошла неделя и я начал что-то подозревать...
Для понимания моего бэкграунда - 6 лет специалитета в МГТУ им Н. Э. Баумана, совмещенных с youtube деятельностью, которая никак не относилась к разработке, но занимала все свободное время. После окончания универа прохождение лютого полугодового экспресс курса по java от сотрудников Сбера, которые искали джунов навырост. И опыт работы в размере 2х лет на Java 7-8-11.
### Как изменился процесс сдачи?
Дальше нужно несколько слов рассказать про саму сертификацию - как она проходит в период пандемии, на что делается упор при проверке и какие вопросы сейчас есть.
Я уверен, что процесс получения сертификации оракла сейчас выглядит удобнее и приятнее всего, что было раньше:
* Во первых - раньше было 2 экзамена по 180 минут - сейчас один на час
* Во вторых - раньше в каждом экзамене было 90 вопросов (в сумме 180), а сейчас всего 50.
То есть со стороны потраченных умственных усилий на сдачу стало проще.
Но это все не значит, что готовиться не нужно. Потому что вся эпопея с сертификацией следующая - она не проверяет твои **знания Java**. Она проверяет - **знание слабых мест** и скользких моментов. По крайней мере таким было мое ощущение.
А также - знания использования последних модных фич из Java старше 8.
### Нюансы по поводу сдачи сейчас, в период ковида
Я очень хорошо тащил задачи по работе и считал себя вполне солидным специалистом, которому горы по плечо и море по колено, не то что ваша сертификация. Поэтому готовиться мне было откровенно лень. Но оставалась неделя и надо было начинать хоть что-то делать. Я подумал, что смогу хакнуть систему и воспользоваться ковидными условиями и возможностями сдачи по удаленке и смогу сдавать без подготовки пока не сдам.
Если у кого-то будет такая же идея, то вынужден вас огорчить - после исследования документации выяснилось, что пересдавать можно минимум через месяц и в сумме 2-3 раза в год. Таким образом мой план уверенно отправился на свалку.
Ну что поделать, значит нужно сдавать прямо сейчас и с первого раза. Oracle предоставляет "подробные" и полные курсы подготовки к сертификации и так как был праздник, то в период акции они были бесплатными. Честно говоря, в моем случае эти лекции оказались чуть более бесполезными, чем полностью. Там действительно поверхностно покрываются многие темы и фишки java и фичи последних версий. Но для меня это никак не укладывалось в голове. Потому что я некоторыми вещами совсем не пользовался, а просто зазубривать мне не хотелось.
Вся структура сертификации строится следующим образом - есть 5-10 тем, которые важны. И на каждую из этих тем есть по 2-4 вопроса. И в сумме нужно набрать 68% правильных ответов. Значит, что достаточно 34 правильных ответа.
Дальше включаем математику - как набрать эти правильные ответы и мой путь, который я выбрал - полная фокусировка на тех темах, которые я уже знаю и с которыми в реальной жизни работаю и полный игнор тех тем, которые я в реальной жизни не использовал и не видел.
Таким образом проигнорировав глубокие детали для 2-3 тем, которые мне не понравились я освободил себя от 60% работы, которая меня не устраивала. И начал усиленно учить остальное.
### Сам процесс сдачи
Так прошли оставшиеся дни до конца акции. Дальше тянуть было нельзя, нужно было сдавать.
По моему непрофессиональному мнению сайт оракл имеет довольно сложную логику интерфейса и продраться через него до желаемого оказалось не так то просто. Закладывайте часть своих моральных сил на всю организацию.
В конце концов дошел до страницы с регистрацией непосредственно на экзамен, к моему удивлению запись была очень ограничена - выделяются квоты по часам на каждый день, нельзя просто прийти и в свободном ключе выбрать любое время и сдать как удобно. Насколько я понял, ограничен ресурс проверяющих и поэтому дело выглядит довольно близко к атмосфере настоящего экзамена. Хорошо, что ехать никуда не надо.
Дальше интереснее - будет предложена программа в которой будет выполняться сам экзамен. Программа проверит наличие других запущенных программ, подключенных девайсов и наличие вебкамеры. Вебкамера обязательна!
Сам процесс прохождения теста выглядит следующим образом - вы подключаетесь за 15-30 минут до начала и в приложении встаете в очередь на проверку.
В этот момент человек с другой стороны проверяет ваши документы и ставит вас в очередь, все это время важно не отходить, потому что курирующий ваш экзамен человек может подключиться в любой момент. Напомню, что все это время у вас включена камера.
Дальше подключится куратор, который будет наблюдать за вами на всем протяжении экзамена. Рядом с вами должен находиться только компьютер и ваши документы. Никаких других девайсов, шпаргалок, книг и прочих предметов быть не должно. А в комнату не должен никто заходить и не должно быть слышно подозрительных звуков, которые могут вас скомпрометировать. Если бы я занимался раздачей советов, то посоветовал бы к моменту сдачи рассчитывать только на свои силы и не пытаться обмануть куратора. С одной стороны его не видно и может быть ему без разницы как вы сдаете, но с другой стороны все может быть и наоборот. Аннулировать сдачу ничего не стоит. Так что я бы не провоцировал.
### Примеры вопросов
Сам экзамен идет ровно по таким вопросам и темам, которые объявляются в процессе подготовки, а [конкретно](https://education.oracle.com/java-se-11-developer/pexam_1Z0-819).
Примеры вопросов:
```
8 public class SuperClass {
9 private final int x = 1;
10 static final int y;
11 public SuperClass() {
12 System.out.println(x);
13 System.out.println(y);
14 }
15 public static void main(String[] args) {
16 new SuperClass();
17 }
18 }
```
```
Какой будет результат?
А - компилятор упадет на 13 строке
B - компилятор упадет на 16 строке
C - 1
D - компилятор упадет на 9 строке
E - 10
Правильный ответ: A
```
Следующий пример:
```
char[][] arrays = {{'g', 'j'}, {'h', 'k'}, {'i', 'l'}};
for (char[] xx : arrays) {
for (char yy : xx) {
System.out.print(yy);
}
System.out.print(" ");
}
```
```
какой результат?
А - gj hk il
B - ghi jkl
C - gh ij kl
D - compilation fails
E - ArrayIndexOfBoundsException in runtime
Правильный ответ - A
```
И такого рода вопросов с подвохами или на “проверь как умеешь компилировать в уме” их много.
### Итоги
Вся подготовка привела к моей сдаче сертификации с первого раза на 87% и добавлением новой плашки в свое резюме. :)
Если вы имеете какой-никакой опыт коммерческой разработки с Java 8+, то вам достаточно будет выделить 1-2 недели своего времени и получить сертификацию, которая потенциально сильно облегчит ваш процесс найма.
Буду рад вашим историям в комментариях - как наличие сертификации повлияло на вашу профессиональную жизнь :) | https://habr.com/ru/post/576400/ | null | ru | null |
# Разработка библиотеки: от API до публичного релиза
Давайте посмотрим на библиотеки не с той стороны, которая нам привычнее всего, то есть пользовательской, а с точки зрения разработчика библиотеки мобильной разработки. Поговорим, каких подходов стоит придерживаться, разрабатывая свою библиотеку. Начнем, конечно, с проектирования такого API, которым вы сами хотели бы пользоваться, который был бы удобен. Подумаем, что нужно учесть, чтобы сделать не просто работающий код, а по-настоящему хорошую библиотеку, и дойдем до того, как выпускать настоящий взрослый публичный релиз. Поможет нам в этом **Ася Свириденко**, которая поделится своим немалым опытом разработки мобильной библиотеки SpeechKit в [Яндексе](https://habr.com/company/yandex/).
Материал будет полезен не только тем, кто занимается разработкой библиотеки или фреймворка, но еще и тем, кто хочет выделить часть из своего приложения в отдельный модуль, а потом его переиспользовать, или, например, поделиться своим кодом с остальным сообществом разработчиков, выложив его в публичный доступ.
Для всех остальных рассказ будет наполнен неподдельными историями из жизни команды мобильного SpeechKit, так что должно быть весело.
### Содержание
* [Минутка SpeechKit](#speechkit).
* [Проектирование](#disain) удобного, понятного API, которым хочется пользоваться.
* [Разработка](#develop). Что добавить в код, чтобы он не просто работал и выполнял функциональность, но и помогал вашим пользователям.
* [Запуск](#deploy) — о чем надо не забыть, когда катишь релиз.
Минутка SpeechKit
-----------------
Не буду спрашивать, слышали ли вы про SpeechKit, потому что даже внутри Яндекса не все знают, что это такое.
**SpeechKit — это дверь во все речевые технологии Яндекса**. С помощью этой библиотеки можно интегрировать в свое приложение речевые технологии: распознавание и синтез речи, голосовую активацию.
Вы наверняка слышали про голосового ассистента Алису — она как раз работает на базе SpeechKit. Сам SpeechKit не включает в себя распознавание или синтез, это происходит на сервере. Но именно через нашу библиотеку всё можно интегрировать в приложение.
Следом обычно идет вопрос — если все на сервере происходит, что делает библиотека? Зачем она нужна?
Библиотека делает очень многое:
1. **Синхронизация всех процессов.** Например, используя голосовой ассистент, пользователь нажимает на кнопку, что-то говорит, прерывает ассистента, делает запросы — это все идет через библиотеку. Для пользователя нашей библиотеки это прозрачно, они не должны обо всем этом переживать.
2. **Сетевое взаимодействие.** Так как все происходит на сервере, то нужно получать оттуда данные, обрабатывать их, отдавать пользователю. Сейчас SpeechKit умеет в рамках одного сетевого соединения ходить в несколько разных серверов: один занимается распознаванием, другой выделением смысла, третий распознаванием музыки и т.д. Это все скрыто внутри библиотеки, пользователям не надо об этом беспокоиться.
3. **Работа с источниками аудио.** Мы имеем дело с речью человека, и работа с аудио тоже происходит внутри SpeechKit. Причем мы можем не только писать со стандартного устройства, но и принимать данные, откуда угодно. Это может быть файл или стрим — со всем этим мы умеем работать.
SpeechKit используется во внутренних командах. Сейчас его интегрировали 16 команд Яндекса. И нам даже известно о нескольких внешних командах, которые тоже это сделали.
Проектирование
--------------
Давайте задумаемся, что мы подразумеваем под удобным приложением. Обычно, это продуманный и понятный UX, решение наших задач, стабильная работа и пр.
Когда мы говорим, что библиотека удобная, в первую очередь мы подразумеваем, что у нее такой API, которым понятно пользоваться. Как этого достичь?
### Базовые принципы
Это некоторые аспекты, которые я извлекла из своего опыта работы над SpeechKit.
* **Прежде всего, помните о том, что ваши пользователи — разработчики**.
С одной стороны, это хорошо, потому что обычным пользователям вы не объясните: «Понимаете, у нас бэкенд лежит, и поэтому ничего не работает, а так мы в порядке!» Вы можете объяснить это разработчикам — вы многое можете объяснить разработчикам!
С другой стороны, вы получаете таких пользователей, которые обязательно воспользуются возможностью найти дыру и что-то сломать, если вы её оставите. Мы все с вами используем библиотеки и пытаемся выжать из них по максимуму. Они заявляют, что делают только это, это и это, а мы думаем: «Нет, сейчас мы тут немножко подшаманим, это передадим, и все будет, как надо».
Помимо этого, то, что пользователи — разработчики, означает, что у вас всегда будет гора советов и рекомендаций, как вам разрабатывать, и как сделать так, чтобы все было лучше.
Второй важный момент полностью соотносится с первым.
* **Всё, что не разрешено в вашей библиотеке, должно быть запрещено,
чтобы не было нежелательных лазеек.**
Если ваши пользователи начинают делать с библиотекой что-то, чего вы не предполагали — это прямой путь к багам, причем к тем, которые тяжело отлаживать. Постарайтесь использовать все, что дает язык и та технология, которую вы используете: public/private, final, deprecated, readonly. Уменьшайте области видимости, запрещайте наследование и использование каких-то методов, помечайте свойства, которые нельзя менять — предусмотрите все, что можно, чтобы не дать сделать то, на что ваша библиотека просто не рассчитана.
* **Не допускайте двоякости в трактовке API вашей библиотеки.**
Если этот конкретный класс может быть создан единственным способом — запретите все остальные. Если это свойство не может быть null — укажите это явно. В iOS есть nullable/nonnull, designated initializer, то же самое есть в Java и Android. Используйте все это, для того чтобы пользователь открыл файл, открыл ваш класс, пробежался по нему глазами и сразу понял, что можно сделать, а что никак нельзя.
### Кейс SpeechKit API
На примере SpeechKit расскажу, как мы делали рефакторинг версии 2 в версию 3. Мы сильно изменили API и постарались использовать все эти принципы.
Необходимость возникла из-за того, что **API был сложный и «теоретический»**. В нем были глобальные компоненты, которые надо было сперва вызвать — не вызвал — все не работает. Очень странно задавались настройки. API был достаточно «теоретический», потому что SpeechKit изначально был частью Навигатора, а потом этот кусочек и вынесли в библиотеку. API по сути работал с кейсами, использующимися в Навигаторе.
Постепенно количество пользователей росло, и мы начали понимать, что им действительно нужно: какие методы, коллбэки, параметры. К нам приходили с запросами, которые API не позволял реализовать. Это повторялось раз за разом, и стало понятно, что API не выдерживает. Так мы ввязались в рефакторинг.
**Процесс рефакторинга был долгий (полгода) и мучительный (все были недовольны)**. Основная сложность была не в том, чтобы взять гору кода и переписать. Нельзя было просто уйти на рефакторинг, а надо было поддерживать все активные версии, которые были в использовании. Мы не могли просто сказать своим пользователям: «Ребята, да, у вас не работает, да, вам нужна эта фича — мы все сделаем в версии 3, подождите, пожалуйста, полгода!»
В итоге рефакторинг занял много времени, и процесс был мучительный, причем для пользователей тоже. Потому что в итоге мы поменяли API без обратной совместимости. Пришли к ним и сказали: «Вот новый прекрасный SpeechKit, пожалуйста, возьмите его!» — в ответ услышали: «Нет, у нас не запланирован переход на вашу версию 3.0 вообще». Например, у нас была команда, которая переходила на эту версию в течение года. Поэтому целый год мы поддерживали для них предыдущую версию.
Но результат того стоил. Мы **получили простую интеграцию и меньше багов**. Это то, о чем я упомянула, в базовых принципах проектирования API. Если вы уверены, что ваш API используется правильно, в этой части точно нет никаких проблем: все классы вызываются правильно, все параметры правильные. Найти баги гораздо легче, меньше кейсов, где что-то может пойти не так.
Ниже пример, как выглядел основной класс, который занимается распознаванием, до рефакторинга.
```
// SpeechKit v2
@interface YSKRecognizer: NSObject
@property (nonatomic, strong, readonly, getter=getModel) NSString* model;
@property (nonatomic, assign, getter=isVADEnabled) BOOL VADEnabled;
- (instancetype)initWithLanguage:(NSString *)language model:(NSString *)m;
- (void)start;
- (void)cancel;
- (void)cancelSync;
@end
@interface YSKInitializer: NSObject
- (instancetype)init;
- (void)dealloc;
- (void)start;
+ (BOOL)isInitializationCompleted;
@end
extern NSString *const YSKInactiveTimeout;
extern NSString *const YSKVADEnabled;
@interface YSKSpeechKit: NSObject
+ (instancetype)sharedInstance;
– (void)setParameter:(NSString *)name withValue:(NSString *)value;
@end
```
Это обычный класс, который наследуется от NSObject. Рассмотрим отдельно каждую его деталь. Понятно, что мы можем от него отнаследоваться, переопределить в нем какие-то методы — все, что можно делать с NSObject.
Дальше при создании ему передаются две строки (language и model). Что это за строки? Если передать в language «Hello, world», то на выходе будет перевод, или что? Не очень понятно.
Помимо этого, так как это наследник NSObject, мы можем вызвать у него init, new и т.д. А что будет? Он заработает, или будет ждать каких-то параметров?
Конечно, я знаю ответы на эти вопросы, я знаю этот код. Но люди, которые на это смотрят впервые, совершенно не понимают, к чему это все. Даже методы с setter и getter совершенно не выглядят так, как это могло бы выглядеть в iOS. Методы start, cancel, cancelSync (а тот, который просто cancel — он aSync?) — что будет, если их вызвать вместе? Очень много вопросов к этому коду.
Дальше идет объект, про который я говорила (YSKInitializer), который обязательно надо стартовать, чтобы все заработало — это вообще какая-то магия. Видно, что этот код писали разработчики, которые не пишут под iOS, а занимаются C++.
Дальше настройки для этого рекогнайзера задавались через глобальные компоненты, которые передавались в другой глобальный объект, и по сути нельзя было создать два разных рекогнайзера с разным наборов параметров. А это был, наверное, один из самых востребованных кейсов, который не поддерживал API.
### Чем v3 лучше v2
Что мы получили, когда сделали рефакторинг и перешли на версию 3?
* **Полностью нативный API.**
Теперь у нас API под iOS выглядел как iOS-API, API под Android — как Android.
> Важный момент, который мы не сразу осознали, — гайдлайны платформы гораздо важнее единообразия API вашей библиотеки.
>
>
Например, классы под Android создаются с помощью билдеров, потому что это очень понятный для Android-разработчиков паттерн. В iOS это не так популярно, поэтому используется другой подход: создаем объекты со специальным классом настроек.
Помню, как мы долго спорили на эту тему. Нам казалось важным, чтобы разработчик взял наш код на iOS или Android, и совпадение было бы 99%. Но это не так. Пусть лучше код будет похож на ту платформу, для которой он разрабатывается.
* **Простая и понятная инициализация**.
Нужен этот объект — вот его настройки, создаешь их, передаешь — профит! То есть нет каких-то скрытых глобальных настроек, которые надо куда-то передавать.
* **Отсутствие глобальных компонентов.**
Мы выкинули глобальные компоненты, которые всех путали, пугали и вызывали много вопросов даже у самих разработчиков этой библиотеки, не только у пользователей.
Теперь тот же самый класс в новой версии выглядит так (это все еще Objective-C — на Swift нельзя тогда было перейти).
```
// SpeechKit v3
NS_ASSUME_NONNULL_BEGIN
__attribute__((objc_subclassing_restricted))
@interface YSKOnlineRecognizer: NSObject
@property (nonatomic, copy, readonly) YSKOnlineRecognizerSettings \*settings;
- (instancetype)initWithSettings:(YSKOnlineRecognizerSettings \*)s audioSource:(id)as
NS\_DESIGNATED\_INITIALIZER;
+ (instancetype)new \_\_attribute\_\_((unavailable("Use designated initializer.")));
- (instancetype)init \_\_attribute\_\_((unavailable("Use designated initializer.")));
@end
NS\_ASSUME\_NONNULL\_END
@protocol YSKRecognizing
- (void)prepare;
- (void)startRecording;
- (void)cancel;
@end
@interface YSKOnlineRecognizerSettings: NSObject
@property (nonatomic, copy, readonly) YSKLanguage \*language;
@property (nonatomic, copy, readonly) YSKOnlineModel \*model;
@property (nonatomic, assign) BOOL enableVAD;
- (instancetype)initWithLanguage:(YSKLanguage \*)l model:(YSKOnlineModel \*)m NS\_DESIGNATED\_INITIALIZER;
@end
@interface YSKLanguage: YSKSetting
+ (instancetype)russian;
+ (instancetype)english;
@end
```
Это наследник NSObject, но теперь мы явно говорим о том, что от него нельзя наследоваться. Все методы, которые характерны для этого объекта, перенесены в специальный протокол. Он создается с помощью настроек и audioSource. Теперь все настройки инкапсулированы в один объект, который передается конкретно сюда, чтобы задать настройки для конкретного рекогнайзера.
Более того, мы вынесли отсюда работу с аудио, то есть рекогнайзер теперь — это не та компонента, которая пишет аудио. Эта компонента занимается вопросами распознавания, а передать сюда можно любой источник.
Другие методы создания через new или через init запрещены, потому что этому классу нужны настройки по умолчанию. Будьте добры, если вы хотите его использовать, создайте хотя бы какие-то настройки по умолчанию.
Главное, что те настройки, которые сюда передаются, иммутабельны, то есть вы не можете поменять их в процессе работы. Не надо пытаться, когда что-то распознается, подменить модель или язык. Соответственно, мы не даем пользователям возможность изменить объект с настройками, который уже передан.
Макросы NS\_ASSUME\_NONNULL\_BEGIN/NS\_ASSUME\_NONNULL\_END для того, чтобы подчеркнуть, что эти настройки не могут быть null: audioSource не может быть null — это все должно иметь какое-то определенное значение, чтобы работать.
Как я говорила, методы start и cancel (cancelSync ушел) переехали в отдельный протокол. В библиотеке есть места, в которых можно использовать не наш рекогнайзер, а любой другой. Например, мы используем нативный от Apple, который реализует этот протокол и в который может передать наши компоненты.
Настройки здесь NSCopying для того, чтобы мы могли их копировать, и их нельзя было поменять в процессе работы. В init обязательные параметры язык, модель и NS\_DESIGNATED\_INITIALIZER. Здесь не показана часть кода, которая идентична deprecate методов, но идея ясна. Это обязательные параметры, с которыми создаются настройки. Они должны быть, и должны быть ненулевые.
Весь остальной набор — это порядка 20 настроек рекогнайзера задаются здесь же. Даже настройки языка или модели — это тоже отдельные классы, которые не позволяют передать что-то абстрактное, с чем мы не умеем работать. То есть мы явно говорим: «Пожалуйста, не давайте нам то, с чем мы не умеем работать. Компилятор вам не даст это сделать».
Итак, мы поговорили про то, что можно сделать с API. В разработке тоже есть свои нюансы.
Разработка
----------
В первую очередь библиотека должна делать то, ради чего вы ее писали, — хорошо выполнять свою функциональность. Но вы можете сделать свой код по-настоящему хорошей библиотекой. Предлагаю несколько ремарок, которые были собраны мной в процессе разработки SpeechKit.
### Код не только для себя
**Собирать Debug информацию** абсолютно точно нужно, потому что вы не хотите, чтобы пользователи сказали, что их сервис не работает из-за вашей библиотеки.
В iOS есть debug information level, который показывает, какую информацию надо собирать. По умолчанию он будет собирать абсолютно все, что может найти: все вызовы, все значения. Это здорово, но это очень большой объем данных. Настройка -gline-tables-only позволяет собирать информацию именно о вызовах функций. Этого более, чем достаточно, для того чтобы найти проблему и исправить ее.
Включается это в настройках Xcode (Build Settings), так и называется debug information level. К примеру, мы, включив эту настройку, уменьшили размер бинарного файла SpeechKit с 600 Мбайт до 90 Мбайт. Это не очень нужная информация и мы ее просто выкинули.
Вторая важная вещь — **скрывайте приватные символы**. Все вы знаете, что каждый раз, выкладывая библиотеку в iTunes, вы рискуете получить новое предупреждение, что вы что-то используете не так, что-то не добавляете. Поэтому, если вы используете библиотеки, которые Apple считает приватными, не забудьте их скрыть. Для вас это ничего не значит, вы также можете с ними работать, но как только ваши пользователи попробуют залить приложение с вашей библиотекой в iTunes, они получат ошибку. Не каждый попросит вас это исправить, большинство просто откажется от использования вашего решения.
**Не допускайте конфликтов символов**: добавляйте префиксы ко всему, что у вас есть, к своим классам, к категориям. Если в библиотеке есть категория UIColor+HEX, будьте уверены, что у ваших пользователей есть ровно такая же категория, и когда они интегрируют вашу библиотеку, они получат конфликты символов. И опять, не все захотят рассказать вам и сказать об этом.
Другой вопрос, когда вы сами используете сторонние библиотеки в своей библиотеке. Тут есть пара нюансов, о которых стоит помнить. Во-первых, если вы используете что-то, что появилось в версии старше, чем ваша библиотека, не забудьте использовать [Weak Linking](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html) (включается Xcode -> Build Phases -> Link Binary With Libraries -> Status). Это позволяет не падать, если вдруг этой библиотеки нет.
В документации Apple подробно описано, как это работает. Но weak linking не значит, что библиотека не загрузится, если она не используется. То есть если вашим пользователям важно время старта приложения, и, возможно, не нужна та часть вашей библиотеки, которая использует стороннюю библиотеку и занимает время на старте, weak linking вам не поможет. С ним библиотека все равно загружается, используется она или нет.
Если вы хотите загружать в runtime, это поможет избавиться от проблемы линковки на старте, то надо использовать dlopen и динамическую загрузку. Это требует достаточно много возни, и нужно сначала понять, имеет ли это смысл. У Facebook выложен достаточно [интересный код](https://github.com/facebook/facebook-objc-sdk/blob/master/FBSDKCoreKit/FBSDKCoreKit/Internal_NoARC/FBSDKDynamicFrameworkLoader.m) примера того, как они динамически линковали.
Последнее — **старайтесь не использовать внутри глобальные сущности**. В каждой платформе есть какие-то глобальные компоненты. Их желательно не тянуть в свою библиотеку. Это кажется очевидным, потому что это глобальный объект, и пользователи вашей библиотеки могут взять его и настроить так, как им хочется. Вы используете его у себя в библиотеке, вам надо как-то сохранить его состояние, перенастроить, потом восстановить состояние. Тут много нюансов, и есть где ошибиться. Помните об этом и старайтесь избегать.
У нас, например, в SpeechKit до третьей версии внутри библиотеки шла работа с аудио, и мы явно настраивали и активировали аудио-сессию. Аудио-сессия в iOS — это такая штука, которая есть у каждого приложения, — не говорите, что у вас его нет. Она создается на старте, отвечает за взаимодействие приложения и системного медиа-демона и говорит, что ваше приложение хочет делать с аудио. Это объект singleton в прямом смысле этого слова. Мы спокойно его брали, настраивали, как нам надо, но это приводило к тому, что у пользователей были мелкие проблемы вроде изменения громкости звука. Еще метод аудио-сессий, который отвечает за установку настроек, достаточно долгий. Он занимает порядка 200 мс, и это заметное подтормаживание на активации или деактивации.
В третьей версии я радостно вынесла аудио-сессию из библиотеки. После этого практически все пользователи всех сервисов, у которых был интегрирован SpeechKit, сказали, как они страшно недовольны. Теперь должны знать, что есть какая-то аудио-сессия, которую надо специальным образом настроить для нашего SpeechKit.
> Вывод отсюда такой: все равно старайтесь не использовать глобальные сущности, но будьте готовы к тому, что ваши пользователи не всегда будут рады вашим решениям.
>
>
### Делаем пользователям удобно
Как еще можно помочь вашим пользователям?
* **Добавляйте логи: разные уровни, динамическое включение**.
Самый простой способ — это подкладывание файла, на наличие которого запускается мега debug-режим. Это действительно помогает сделать отладку в ситуации, когда у ваших пользователей есть пользователи, у которых происходит ошибка, и вам надо понять, что же именно произошло.
* **Поддерживайте все версии ОС пользователей.**
Помните о том, что когда вы говорите о поддержке версий в библиотеке — это не то же самое, что поддержка версий в обычном приложении. В обычном приложении мы смотрим статистику, что, например, всего 2% наших пользователей используют iOS 8, и значит можно перестать поддерживать iOS 8. В библиотеке не так, здесь отказ от версии ОС означает полностью отказ от вашего пользователя и всех его пользователей. Это может быть половина ваших пользователей в принципе.
Поэтому вам надо мониторить, какие версии используют те приложения, которые используют вашу библиотеку, и на основании этого уже делать вывод, поддерживаете вы что-то или нет. Мы очень долго не отказывались от iOS 7. Мне кажется, уже были люди, которые отказались от iOS 8 и были готовы отказаться от iOS 9. Мы все еще поддерживали iOS 7, потому что у нас был браузер, который до последнего держал всех пользователей, а мы с ним тесно работали и не могли его бросить в такой ситуации.
Опять-таки ваши пользователи не скажут: «Давайте мы выключим эту функциональность на той версии, которая её не поддерживает», — нет, они просто уберут вашу библиотеку и найдут ту, которая поддерживает весь ряд версий.
* **Добавляйте минимальную инкрементацию в новых версиях.**
Это очень «не очень» для разработчиков библиотеки. В релиз хочется выпустить все, что готово. Ты сделал фичи, пофиксил баги — сейчас всю пачку положим и выкатим в релиз. Релиз — тоже процесс. Для ваших пользователей это не так. Когда они находятся в процессе тестирования своего продукта и готовятся его к выпуску, они не хотят получить от вас сборку с новыми фичами, которые нужно дополнительно тестировать.
У нас действительно были случаи, когда мы откатывали какие-то релизы, делили их на части и выкатывали уже кусочками. Тогда те команды, для которых мы реализовывали изменения, могли взять именно ту версию, в которой есть маленькие изменения, а не все сразу.
> Это действительно не очень удобно для разработки, но минимальная инкрементация в версиях сделает ваших пользователей немножко, но счастливее.
>
>
### Тестов много не бывает
Это верно и для обычного приложения, и для библиотеки. Но в случае опять библиотеки есть особенности.
**Автотесты**, конечно, нужны, но помимо них здорово иметь **тестовое приложение** для вашей библиотеки. Оно поможет вам самостоятельно интегрировать то, что вы написали, и понять, какие проблемы или подводные камни могут возникнуть. Вы сможете ощутить на себе, каково же вашим пользователям.
Если ваша библиотека хоть как-то взаимодействует с сетью, включает шифрование, есть хоть что-то, что связано с данными и с безопасностью, отдайте ее на **проверку безопасникам**. Вы абсолютно точно не хотите быть той библиотекой, в которой найдут уязвимость, — это клеймо на всю жизнь. Практически во всех крупных компаниях есть целый отдел, который занимается проверкой продуктов на безопасность — отдайте им. Если у вас такого нет, есть **внешний аудит**. Если вы не можете себе позволить внешний найдите тесты в сети, прогоните их, убедитесь, что ваша библиотека не допускает утечек пользовательских данных.
Последнее, что очень важно в тестах — с самого начала постарайтесь добавлять **замеры всего, чего только можно**: времени, энергопотребления, всего, что характерно для вашей конкретной библиотеки. Вам все равно в итоге придется это сделать, так почему бы не подумать о замерах с самого начала.
Это не оградит от изменений и от необходимости ускорять библиотеку, но поможет разобраться, что же пошло не так. Если у вас есть графики, это поможет в режиме реального времени мониторить, какая же функциональность добавила задержки по времени или увеличила энергопотребление.
На это практически никогда нет времени, потому что это не функциональность библиотеки, это не то, ради чего вы ее разрабатываете. Но это то, что поможет вам поддерживать ее в надлежащем состоянии и в хорошем качестве.
[Здесь](https://habr.com/company/yandex/blog/311046/) можно почитать, как мы в Яндексе измеряем энергопотребление мобильных устройств. Про замеры времени была забавная история. Нам, как разработчикам библиотеки, сложно измерять поведение в конкретных кейсах, потому что не все сценарии SpeechKit используются всеми командами. Чтобы засечь время, мы использовали наше тестовое приложение. Были написаны специальные кейсы использования, например, рекогнайзера или компоненты для синтеза речи, каждый шаг записывались и сохранялись логи, а в итоге строились классные графики.
Все было бы ничего, но мы работаем с аудио, и чтобы все проверить, в определенных случаях действительно проигрывается звуковая дорожка. Причем, надо же сделать очень много замеров, поэтому тест оставили на ночь: поставили колонки, положили рядом какой-то девайс, и запустили аудиофайлы. Утром все оказалось выключено, на следующую ночь это повторилось, и потом снова. Дело было вовсе не в каких-то волшебных существах, которые ходили по офису, — просто уборщицы пугались. Там действительно был очень странный текст, который читался с интервалами.
В итоге было решено сделать локальный тестовый стенд, который мы назвали Шкафом. Это натуральный шкаф, только звукоизолированный. В нем лежит много устройств, целая ферма с устройствами, каждый из которых можно много раз запускать в течение рабочего дня, потому что это никому не помешает.
Запуск
------
Наконец мы подошли последней важной части — это запуск. Код написан, спроектирован хороший API, чтобы пользователям было удобно. Как же теперь это все выпустить в релиз.
Начну с локальных релизов для пользователей внутри Яндекса. Схема тут такая же, как и в разработке обычного приложения: регулярные, ежемесячные или еженедельные релизы.
Процесс состоит из привычных стадий, но при разработке библиотеки в каждом из этих пунктов есть свои особенности.
### Планирование
Для меня это самая болезненная часть, потому что у библиотеки несколько продуктовых команд. В обычном приложении один менеджер продукта, который ставит задачи, которые команда приоритезирует и по одной начинает делать.
Если продуктовых команд несколько, то от каждой из них поступают запросы, которые надо обрабатывать в режиме реального времени. Дам совет: если есть человек, который умеет разбираться с множеством, поступающих в один момент, задач, постарайтесь забрать его в свою команду. Потому что должен быть кто-то между всеми внешними менеджерами и разработкой — тот, кто возьмет на себя функциональность по приоритезации задач.
Вторая важная особенность особенно характерная для SpeechKit возникает, когда в реализации задачи задействованы другие внутренние команды, например, бэкенд. Нужно учитывать, что может возникнуть задержка, что что-то будет не готово вовремя или готово не совсем так. И именно вы должны предупредить об пользователей, потому что именно вы как библиотека — вход в технологии. Пользователям не нужно знать, что за вашей спиной еще n команд. Они не будут говорить с ними о сроках, они говорят об этом разработчикам библиотеки. Это вы знаете про сроки и про важность продуктовых фичей, это вам нужно донести внутренним командам и заказчикам функциональности, что могут возникнуть какие-то накладки по времени.
### Разработка
Разработка, как в любом приложении, начинается обычно как в стартапе: просто работаем днями, ночами, нам не важны все эти процессы. Потом вспоминаются слова об Agile-методологии и начинается построение процессов работы команды.
После того, как мы поработали как стартап, мы поняли, что есть проблема — непредсказуемость. Никто не мог сказать, какие именно фичи и когда будут запущены. А это было очень важно!
Тогда мы решили попробовать **Scrum**. Он действительно помог, мы стали планировать некоторое множество задач, реализовывать их, выпускать в релиз. То есть мы вроде как справились с задачей сделать релизы предсказуемыми. Я говорю «вроде как», потому что не надо забывать о проблеме нескольких продуктовых команд.
Scrum продержался недолго, потому что мы планировали, развивали задачи, спринт — вы знаете все эти слова — но во время спринта прилетали продуктовые задачи, баги. Мы пытались с этим работать. У нас даже было правило — не брать в спринт никаких задач, если это не баг в продакшене у какой-то команды. Угадайте, сколько раз это правило сработало? Примерно ноль, потому что нельзя сказать другой команде: «Да, у вас регресс и вы нашли у нас баг, но мы исправим его, когда вы уже будете в паблике с этим багом». Так нельзя, и нам приходилось брать это в работу, и брать какие-то фичи, которые в этот момент были высокоприоритетные, и Scrum ломался полностью. Процесс был просто ужасающий! Бывало, что весь скоуп перекраивался к середине спринта.
Сейчас мы перешли на некое подобие Канбана. Есть доска с задачами, которые выставлены в порядке приоритета, и мы просто берем верхние задачи. С одной стороны, мы потеряли в предсказуемости нашего релиза. Мы теперь не можем сказать, использующим нашу библиотеку командам, что, если задача попала на доску, то она точно будет в следующем релизе. Но зато мы можем точно сказать, что в релиз попадут самые важные задачи. Сейчас это для нас приоритетнее.
### Поддержка
Стоит помнить, что когда вы выпускаете релиз — это не просто одна версия, которую вы отправили и которую кто-то взял в использование. Возможно, те изменения, которые вы сделали в этом релизе, нужны еще и в других версиях, которые используются другими командами. Это то, что я говорила про минимальную инкрементацию версий. Вы не можете сказать своим пользователям: «Мы исправили ошибку в версии 4, а у вас версия 3 — просто переходите на четвертую». Можно иногда и так сделать, но лучше этим не злоупотреблять. Если в релизе какие-то баги или мелкие дополнения, посмотрите, у кого какие версии, и **выпустите фиксы на все версии**, которые сейчас используются.
Отсюда следует следующий пункт — **все ваши релизы должны быть быстрые**. Настройте Continuous Integration так, чтобы можно было действительно нажимать одну большую красную кнопку и отправлять на те версии, на которые надо, потому что **релизов будет много**.
### Приоритезируй это
Немножко про то, как мы решали проблему с приоритезацией задач. Выделю два типа задач.
1. **Продуктовые задачи.**
Здесь все ясно — в первую очередь нужно смотреть на **важность для компании**. Если бы к нам как-то пришел Аркадий и попросил заняться киллер-фичей для Яндекса, мы бы, конечно, все оставили и делали бы её. Хотя он никогда так не делал.
**Время релиза других команд** важный параметр для приоритета продуктовых задач. Если одна фича понадобится через месяц, а другая — через неделю, то, кажется, очевидно, что делать. Но не забывайте предупредить команду, которая ждет первую фичу, что начали делать что-то более приоритетное.
2. **Хотелки пользователей.**
Немного сложнее обстоит дело с хотелками пользователей, потому что, как я говорила, ваши пользователи — разработчики, они хотят сделать вашу библиотеку лучше, они знают, как ее сделать лучше, они лучше вас знают, как сделать ее лучше!
Мы поступали следующим образом. Сначала смотрели, **насколько полезно другим командам**. То есть если это полезно не только тому, кто предлагает, но и еще кому-то, то мы за это беремся.
Другой очень важный и самый холиварный вопрос — **сохраняется ли консистентность библиотеки**. Что только не пытались втянуть в SpeechKit за это время. Мы оборонялись, как могли, потому что мы — библиотека, которая делает что-то конкретное. Не надо пытаться сделать все — помните об этом, даже если кому-то одному это сделает жизнь легче.
Дальше смотрим, **насколько это упростит жизнь пользователю**. Если работа приведет к тому, что пользователь вместо 4 строчек кода вызывает 2, кажется, что это не совсем правильный подход к приоритезации. Если же огромное полотно кода заменится на один вызов, или станет возможно делать что-то, что до этого было нельзя сделать, то берем это на доску.
Последнее — **как долго это реализовывать**. Когда фича интересная, хотелка классная, но делать ее месяц, то нужно тщательно все взвесить.
Документация. Это. Серьёзно
---------------------------
Особенно для библиотеки, потому что ей пользуется кто-то, кто не писал этот код. Поэтому обязательно добавляйте **документацию в коде**. Она должна быть написана в файлах, чтобы люди могли открыть, почитать, посмотреть help и увидеть, как это все использовать.
Добавляйте **быстрый запуск**. Мы все ищем библиотеки так: находим что-то, берем кусочек кода из GitHub, вставляем его к себе, запускаем. Работает — ура, не работает — ищем дальше. Наличие быстрого запуска в документации поможет быть ближе к пользователям, вашу библиотеку будет проще интегрировать и понять, что она может.
После этого приводите **примеры использования**, чтобы можно было понять, как сделать что-то более хитрое и сложное с вашей библиотекой, понять как настраивать параметры, вызовы и т.д.
Публичный релиз
---------------
Последнее важное, о чем не стоит забывать, когда выпускаете публичный релиз:
* **Сервер.** Обязательно предупредите команду бэкенда, чтобы сервер выдержал нагрузку и рост числа пользователей. Если есть какая-то специфичная внутренняя информация, не отдавайте трафик наружу, скажите это вашему бэкенду.
* **Лицензия**. Когда мы выпускаем наружу наш код, его могут использовать не совсем корректно. Если у вас открытый исходный код, добавляйте OpenSource лицензию, если нет, то обратитесь к юристам, которые напишут хорошую лицензию, чтобы оградить вас от возможных претензий.
* **Поддержка.** Помните, что поддержка полностью ляжет на ваши плечи. У вас не будет первой или второй линии, которая объяснит пользователям, что надо передать в функцию. Это все делаете вы. У меня поддержка пользователей SpeechKit иногда занимает больше половины рабочего времени.
Итоги
=====
* Не давайте пользователям возможность вас сломать, учитывайте это в своем API.
* Пишите код, который облегчит жизнь вашим пользователям, а не только будет выполнять необходимую функциональность.
* Релизный цикл должен быть подстроен под несколько команд.
* Помните о том, что ваша библиотека обязательно изменит чью-то жизнь к лучшему :) Вы делаете за кого-то работу, ваш код можно будет переиспользовать.
Yandex.SpeachKit на GitHub под [iOS](https://github.com/yandexmobile/yandex-speechkit-ios), под [Android](https://github.com/yandexmobile/yandex-speechkit-android), и [документация](https://tech.yandex.ru/speechkit/mobilesdk/doc/intro/speechkit-mobilesdk-about-docpage/) Mobile SDK.
> [AppsConf](http://appsconf.ru/moscow/2019) — самая полезная конференция по мобильной разработке — станет еще полезнее **22 и 23 апреля 2019 года**, а сейчас самое время забронировать билет, или собраться и [подать заявку](https://conf.ontico.ru/lectures/propose?conference=ac2019) на доклад.
>
>
>
> Какие у Программного комитета планы на апрельскую конференцию я [рассказывал](https://habr.com/company/oleg-bunin/blog/429910/) совсем недавно. Ася, например, обещает подготовить новый увлекательный доклад.
>
> | https://habr.com/ru/post/429912/ | null | ru | null |
# SASS: Оптимизируем media screen
Приветствую!
Примерно месяц назад я написал статью, в которой выдвинул идею об оптимизации `@media screen`. Идея заключается в том, чтобы иметь возможность писать значения для всех экранов в одну строку. Более подробно можете почитать [по ссылке](https://habrahabr.ru/post/350466/). Большинство комментариев — это критика относительно реализации, к сожалению идей никто не подкинул. Но если посмотреть с другой стороны, из каждой критики можно вытащить идею, поэтому опираясь на мнение читателей, я поставил себе цель написать миксин, который:
* легко читается (максимально повторяющий синтаксис sass/scss/css);
* легко поддерживать (чтобы через год ты понимал, что там написано);
* гибкий (поддержка максимального количества описаний `@media`);
Давайте посмотрим, что у меня вышло ([репозиторий Github](https://github.com/Dolgik89/-media-screen))!
**Синтаксис**
```
.class{
@include media($properties, $orientation);
}
```
Миксин **media** поддерживает два параметра $properties и $orientation.
**$properties** — массив css правил.
**$orientation** — ориентация экрана (необязательный).
### $properties
```
.class{
@include media((
width: 100%;
height: (lg: 800px, md: 600px, sm: 300px),
transform: (all: translateX(100px) translateY(100px), sm: translateX(50px) translateY(50px)),
color: (sm-md: $white, md-lg: $gray),
font-size: (320: 12px, min-480: 18px, 480-md: 24px, print: 14pt)
));
}
```
Давайте разберем код подробней…
Параметр **$properties** является массивом, поэтому все свойства берутся в ().
```
width: 100%;
```
Обычное правило для всех экранов. компилируется в
```
.class{
width: 100%;
}
```
Интересное дальше:
```
height: (lg: 800px, md: 600px, sm: 300px)
```
Здесь мы описываем высоту для экранов с максимальной шириной **lg**, **md** и **sm** (задаются разработчиком, об этом позже).
Результат компиляции:
```
@media only screen and (max-width: 1024px) {
.class{
height: 800px;
}
}
@media only screen and (max-width: 768px) {
.class{
height: 600px;
}
}
@media only screen and (max-width: 640px) {
.class{
height: 300px;
}
}
```
Так же обратите внимание на код ниже:
```
transform: (all: translateX(100px) translateY(100px), sm: translateX(50px) translateY(50px))
```
В данном примере присутствует экран **all**, я думаю вы догадались, что это все экраны. Есть принципиальная разница между **all** и обычным правилом, как **width: 100%**. Но об этом так же немного позже.
```
color: (sm-md: $white, md-lg: $gray)
```
Здесь я постарался максимально гибко соединить диапазоны экранов между `min-width` и `max-width`. Т.е. код, представленный выше скомпилирует минимальную ширину **sm** (640) — максимальную ширину **md** (768), и для экранов в этом диапазоне задаст белый цвет текста, или серый для **md** (768) — **lg** (1024).
Скомпилированный вариант:
```
.class{
@media only screen and (min-width: 768px) and (max-width: 1024px) {
color: gray;
}
}
.class{
@media only screen and (min-width: 640px) and (max-width: 768px) {
color: white;
}
}
```
Так же бывают случаи, когда мы не можем опираться только на заданные экраны. Поэтому есть возможность задавать кастомную ширину динамически. Так же если вам внезапно понадобится указать вместо максимальной ширины минимальную, или наоборот, такая возможность так же присутствует:
```
font-size: (880: 12px, min-480: 18px, 480-md: 24px, print: 14pt)
```
Первый экран **max-width: 880px**. По умолчанию ширина проставляется именно максимальная (так же легко поменять). Для этого экрана получим `font-size: 12px;`
Второй экран **min-480** указывает на то, что будем отталкиваться от минимальной ширины экрана 480px (приставка min-), и в итоге получим `font-size: 18px` для всех экранов шире 480px.
**480-md** — создаст кастомный минимальный размер 480px и максимальный **md** (768). Т.е. это вариант диапазона экранов, как в предыдущем примере, только с произвольным значением.
Обратите внимание, что если написать 480-768 мы получим экран -288px, т.е. знак "-" отработает как минус. Поэтому такой пример стоит взять в кавычки «480-768», если конечно вы намерено не писали операцию с "-" (кстати +, \*, / так же будет работать).
```
print: 14pt
```
**print** — является неизменным параметром и предназначен для печати:
```
@media print {
.class{
font-size: 14pt;
}
}
```
Надеюсь на данном этапе все понятно… Если нет, с радостью разъясню в комментариях.
### Давайте перейдем к параметру $orientation
Тут все намного проще. Есть два варианта ориентации экрана **landscape** и **portrait**. Собственно, в случае необходимости, вторым параметром прописываем именно эти значения.
```
.class{
@include media((
width: 100%;
height: (all: 100%, md: 50%)
), portrait);
}
```
В итоге мы получим:
```
.class{
width: 100%;
}
@media only screen and (orientation:portrait){
.class{
height: 100%;
}
}
@media only screen and (max-width: 768px) and (orientation:portrait){
.class{
height: 50%;
}
}
```
На этом примере можно четко увидеть разницу между **all** и стандартным правилом. В случае **width: 100%** правило при любых обстоятельствах подпадает под все экраны. В случае **all** — все экраны с ориентацией **portrait**/**landscape**.
### Настройки
Две стандартные переменные, которые нужно отредактировать — это **$breakpoints** и **$media-direction**. Вот как они выглядят по умолчанию:
```
$breakpoints: (
lg: 1024,
md: 768,
sm: 640
) !default; //- размеры экранов
$media-direction: max !default; - направление по умолчанию (max/min)
```
Т.е. для того чтобы создать себе нужное количество экранов с нужными названиями, размерами и первоначальным направлением (**min**/**max**) необходимо создать новые переменные в удобном для вас месте:
```
$breakpoints: (
desktop: 1280,
ipad: 1024,
tablet: 768,
mobile: 640
);
$media-direction: min;
```
Этого достаточно чтобы начать работу.
**Как еще можно использовать данный миксин?**
Если параметр **$properties** поместить в переменную, тогда можно получить отличную функцию. Например:
```
$title-style: (
line-height: (lg: 24px, md: 20px, sm: 16px),
font-size: (lg: 20px, md: 16px, sm: 12px;),
text-align: (all: left, sm: center)
...
)
.block{
h2{
color: gray;
@include media($title-style);
}
h3{
color: black;
@include media($title-style, landscape);
}
}
```
Получаем своего рода **extend** класс. Согласитесь, это может быть очень удобно.
### Подведем итоги
#### Плюсы
* легко читаемый — код максимально повторяет синтаксис CSS;
* легко поддерживаемый — экраны прописаны достаточно понятно, и разобраться в коде не будет проблем;
* гибкий — мы получили возможность описывать `@media screen` для всех экранов, диапазоны экранов, минимальную/максимальную ширину динамически, в любой момент есть возможность прописать кастомную ширину, а так же не отходя от кода настраивать правила для печати.
#### Минусы
* Отсутствует описание экрана по высоте. К этой части я пока не добрался, и если данный миксин будет вам интересен, я обязательно допишу и такую возможность. Так что не забывайте писать комментарии, чтобы я мог понимать насколько для вас это актуально и полезно.
* Отсутствует возможности прописывать `@include mixin` для разных экранов. На данный момент такую возможность реализовать в приведенном выше миксине посредством Sass в принципе невозможно. Насколько это критично, я оставлю вам на размышление, решайте сами, стоит ли жертвовать подобной функцией или нет. Лично для меня это вообще не критично, так как я не могу припомнить, чтобы я вообще когда-нибудь прописывал `@include mixin` внутри `@media screen`.
### Вывод
Думаю, цель достигнута. Миксин получился достаточно удобным и лаконичным.
Если вы со мной ~~не~~ согласны, пишите комментарии. В любом случае с удовольствием выслушаю ваш совет по улучшению данного миксина, или попробую извлечь что-то полезное из вашей критики.
P.S. Скачать миксин вы можете в репозитории Github по [ссылке](https://github.com/Dolgik89/-media-screen). **\_mixin.scss** — тот файл, который вам нужен. Так же файл **package.json** содержит в себе плагины для Gulp, которые было бы неплохо подключить:
* **gulp-autoprefixer** добавит префиксы браузеров, там где это необходимо;
* **gulp-group-css-media-queries** отлично группирует `@media screen`;
* **gulp-minify-css** оптимизирует css, можно сказать, что данный плагин необходим.
Уверен, что для webpack или для любого другого сборщика, вы без труда найдете аналоги.
Спасибо за внимание! | https://habr.com/ru/post/352686/ | null | ru | null |
# Особенности дизайна сайта для мобильных устройств
Речь пойдет о мобильных устройствах, которые на данное время занимают большой % на рынке WAP’a (телефоны без ОС, Symbian и прочие), об Android и iPhone сегодня говорить не будем
Давайте посмотрим на [модели телефонов](http://waplog.net/ru/html/stat/20659/models/) и [разрешения экранов](http://waplog.net/ru/html/stat/20659/screens/) посетителей одного крупного WAP-портала. Как видно среди браузеров лидирует с большим отрывом Opera Mini (ей надо посвящать целую тему, сейчас рассматривать не будем), а дальше обычные мобильные телефоны с или без ОС. Android и iPhone там нет из-за очень низкого %
Посмотрим на экраны. Хватает первых двух позиций: 240х320, 128х160. Что это нам говорит?
* логотип должен быть до 120 пикселей шириной
* padding и margin должны использоваться в пределах разумного (40 пикселей с левого края, это что-то)
* не большое количество графики (телефон с расширением экрана 128х160 думаете потянет тяжелую страницу?)
Так выглядит шапка сайта:
> `</fontxml version="1.0" encoding="UTF-8"?>
>
> DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.0//EN" "http://www.wapforum.org/DTD/xhtml-mobile10.dtd">
>
> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="ru">
>
> <head><title>Domain.comtitle>
>
> <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8"/>
>
> <link rel="stylesheet" href="style.css" type="text/css" />
>
> <link rel="shortcut icon" href="favicon.ico" />
>
> head>`
Третью снизу строчку иногда не пишут, а копируют на страницу весь css в тег | https://habr.com/ru/post/108498/ | null | ru | null |
# Veeam CDP для самых маленьких
Функция CDP (она же Continuous Data Protection) для многих сейчас видится манной небесной. Ведь она позволяет свести риски потери данных к около-нулевым значениям (RTO и RPO - единицы секунд), при этом не используя тормозящие всё вокруг себя снапшоты, и не зависеть от ограничений классических вариантов репликации.
Вот об этом мы сегодня и поговорим: что это за магия такая, как она работает и как мы её реализовали в Veeam Backup & Replication v11.
**Achtung!** Прочтение данной статьи никак не освобождает вас от необходимости [изучить официальную документацию](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_replication.html?ver=110). Написанное ниже следует понимать скорее как выжимку из ключевых моментов с дополнениями, нежели как более правильную или альтернативную версию документации. И пока далеко не ушли, очень советую особенно тщательно изучить раздел [Requirements and Limitations](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_requirements.html?ver=110). Ещё никогда он не был настолько важен, как в случае с CDP. Почему-то именно здесь у многих появилось какое-то очень своё видение этой технологии, что мешает трезво оценивать её реальные возможности. Особенно часто все любят упускать слово Clusters. Может в это весна виновата, но суть одна: нет кластеров - нет мультиков. Совсем.
Зачем CDP нужен этому миру
--------------------------
Начинаем по порядку: а какие проблемы может решить CDP и кому он нужен?
Отвечать будем по порядку поступления вопросов, чтобы ответ на предыдущий помогал понять ответ на следующий. Итак, CDP - это ещё один вид репликации виртуальных машин. Вот так всё просто. На этом всё. Всем спасибо, все свободны. Шутка.
CDP удобнее всего сравнивать с асинхронной репликацией стораджей. То есть ваши виртуалочки спокойно работают, а где-то там далеко внизу одно хранилище реплицирует данные на другое, как бы гарантируя вам, что в случае сбоя вы потеряете минимум информации и просто продолжите работать в новом месте.
Соответственно, проблема, которую помогает нам решить CDP - это обеспечение минимальных значений RTO и RPO. Получается, что это история для самых важных приложений, где допустимый простой может измеряться минутами или даже секундами. А лучше, чтобы его вообще не было. Разные умные люди считают, что под эти требования попадает не более 5% нагрузок. Просто от их функционирования зависят остальные 95%, так что обеспечение их бесперебойной работы становится основной задачей IT отдела.
Хорошо, но чем тогда нас не устраивают классические реплики? В том же Hyper-V, технически, можно реализовать репликацию каждые пять секунд. Вот же оно! Но нет. Вся проблема в снапшотах и задержках, которые они тянут за собой. Как ни крути, но создание снапшота - это весьма небанальный процесс (просто посмотрите на [эту **обзорную** схему](https://docs.microsoft.com/en-us/windows/win32/vss/overview-of-processing-a-backup-under-vss) работы VSS), происходящий сначала на уровне машины, а потом и хоста. Который неизбежно приводит к задержкам и накладным расходам. А потом снапшот надо удалить, а в процессе всех этих операций не угробить машину и работающие на ней приложения (что очень запросто, уж поверьте). Да и в целом, весь этот процесс выглядит довольно громоздко: надо создавать пачку снапшотов (на уровне ОС, потом на уровне гипервизора, а потом ещё и на уровне датасторы может понадобиться), выхватить пачку получившихся данных (не просто прочитать файлик, а получить его в виде дельты двух состояний), куда-то их все махом переложить, корректно удалить снапшоты в обратном порядке и дать отмашку гостевой ОС, что можно продолжать спокойно работать.
Так что если снапшоты можно исключить, их надо исключить.
Как работает CDP
----------------
Видя всё это безобразие, разработчики из VMware как-то сели крепко подумать и решили выпустить некое API, которое сейчас известно под именем VAIO. Фактически, это технология, позволяющая сделать классический I/O фильтр, который даёт возможность следить за I/O потоками гостевых машин и делать что-то с этим знанием. Причём с момента включения этого фильтра ни один изменившейся на диске байт не останется без нашего внимания. А дальше дело за малым: берём эти блоки, копируем из одной машину в другую - и мы восхитительны. Буквально пара недель работы программистов, неделька на тестирование, и можно релизить.
Хотелось бы так, но нет. На практике всё несколько сложнее. Давайте разбираться.
Вот так выглядит общая схема работы. Для видавшего виды VBR пользователя здесь знакомо только слово Proxy. И, пожалуй, да, на прокси вся схожесть с классическими схемами работы и заканчивается.
Погнали по списку:
* **Координатор**. Умывальников начальник и мочалок командир. Управляет всеми процессами, отвечает за связь с vCenter, говорит другим компонентам, что делать, и всячески следит, чтобы всё было хорошо. На местах выглядит как Windows сервис. Единственный, кто знает про существование таких вещей, как vCenter и виртуальные машины. Все остальные работают только с дисками. Поэтому всё, что не связано с репликацией контента, делает координатор. Например, создаёт виртуалку на таргете, к которой мы прицепим реплицируемые диски.
* **Source filter**. Та самая штука, которая занимается перехватом IO запросов. Соответственно, работает уже на ESXi. Дабы повысить надёжность и производительность, один инстанс фильтра работает с одним виртуальным диском. Фильтры держат связь с демоном.
Технически, фильтр - это библиотека, живущая внутри процесса виртуальной машины. И если с ним что-то случается (залипла память, скрешился и т.п.), то следом прилетает виртуалке, внутри которой он работает. Поэтому жизнеспособности фильтров было уделено огромное внимание. Ну и если вы сомневаетесь по поводу прямоты рук создателей фильтра: такие штуки можно устанавливать на хосты только после прохождения строгой сертификации получившегося изделия со стороны VMware.
> **Важно:** *VBR производит установку на кластер. Довести фильтр до каждого хоста - это уже задача самой VMware. Причём если вы добавляете новую ноду в кластер, то наш бандл на него будет установлен автоматически. Зачем? Давайте представим, что произойдёт, если в кластере появится новая нода и для какой-то из машин сработает vMotion на эту ноду? Всё верно - CDP реплика сломается. Однако вся эта автоматика не отменяет необходимости пройти через Manage I/O filters визард - для актуализации настроек. Поэтому, если добавили ноду, то быстренько проходим “Manage I/O filters” визард, который обнаружит новичка и всё настроит.*
>
>
* **Source Daemon**. Используется один на каждый хост. В отличие от мифического фильтра, который где-то там работает, демон - это вполне конкретный процесс на хосте. Отвечает за связь с координатором и общается с прокси на предмет поиска оптимального маршрута трафика. Работает по медленному TCP, так как шустрый UDP не гарантирует доставку. И да, это именно тот случай, где это критично и необходимо.
Зачем нужна прокладка в виде демона и почему бы фильтру самому не работать с прокси? Это ограничение технологии со стороны VMware, не позволяющее фильтру работать с внешней сетью. То есть фильтр с демоном связь установить может, а с прокси нет. Это называется by design, и ничего с этим не поделаешь. Во всяком случае, сейчас. И напомню: демон не знает ни про какие виртуальные машины. Он работает с потоками данных от дисков. И ничего другого в его мире не существует. Поэтому диски одной машины могут обрабатываться сразу несколькими прокси. Мы, конечно, стараемся отвозить диски одной машины через один прокси, но если она не справляется, то подключится другая. И это нормально!
* **Source Proxy**. Агрегирует в себе всю информацию, полученную от фильтров через демонов. Хранит всё строго в RAM, с возможностью подключения дискового кэша, если оперативка кончилась. По этому очень (ОЧЕНЬ!) требователен к RAM, дисковому кешу и задержкам на сети. Так что только SSD и прочее адекватное железо.
Прокси занимается составлением так называемых микроснапшотов, которые отправляются дальше. Данные перед передачей обязательно дедуплицируются: если в каком-то секторе произошло 100500 перезаписей, то до прокси дойдут все, но с самого прокси будет отправлена только одна последняя. Так же, само собой, всё сжимается и шифруется.
На местах прокси представляют собой Windows машины, которые могут взаимозаменять друг друга, переключать нагрузку и так далее.
* **Target Proxy**. Всё то же самое, но в обратном порядке. Принимает трафик от сорсных проксей, расшифровывает, разжимает, отправляет дальше. Так же может быть как физический, так и виртуальный.
* **Target Daemon**. Занимается записью данных на датастор. Полная копия сорсного демона.
* **Target Filter**. В нормальном состоянии находится в выключенном виде. Начинает работать только во время фейловера и фейлбека, но об этом позже.
Таргетные компоненты от сорсных в данном случае отличаются только названием и своим местом в логической схеме. Технически они абсолютно идентичны и могут меняться ролями на ходу. И даже одновременно работать в двух режимах, чтобы одна машина реплицировалась с хоста, а другая на хост. Но я вам ничего такого не говорил и делать не советовал. Также в момент переключения реплики в фейлбек таргеты переключаются на роль сорсов, а в логах появится соответствующая запись.
Немного промежуточных деталей
-----------------------------
Сейчас хочется немного отвлечься на разные детали, понимание которых даст нам более полную картину в будущем.
Как мы видим, процессы, связанные с CDP, довольно плотно интегрированы в сам хост. Так что при выполнении многих операций надо быть предельно внимательным. Например, апгрейд/удаление VAIO драйвера происходит строго через maintenance mode. Установка, что хорошо, такого не требует. На случай отсутствия DRS предусмотрена защита, которая не даст запуститься процессу, однако это же IT, и бывает тут всякое. Поэтому действовать надо осторожно и внимательно.
И ловите бонус: фильтр с хоста можно удалить командой:
`esxcli software remove -n=veecdp`.
Но есть проблема: как я писал выше, установкой фильтров на хост занимается VMware в автоматическом режиме, поэтому при выходе из mm фильтр появится снова. Так что правильно удалять фильтр через кластер. Наименее зубодробительный способ - это через powercli:
`Get-VAIOFilter |Remove-VAIOFilter`
И дальше по обстановке.
Мой любимчик - DNS. Должен работать как часы, по принципу “каждый-каждого”, ибо все мы знаем, что It’s always DNS. Если у вас на VBR сервере используется один DNS сервер, а в vCenter и на хостах другой, то в этом нет никакой проблемы до тех пор, пока они могут резолвить неймспейсы друг друга. То есть vCenter должен уметь зарезолвить VBR и хосты. А хосты должны уметь резолвить VBR и vCener. И так далее.
И, конечно же, не забудем обрадовать ненавистников разного рода устанавливаемых на гостевую ОС агентов и сервисов. Для CDP ничего такого делать не надо, и даже админские креды никому больше не нужны (если только вы готовы отказаться от VSS точек с application consistent состоянием). Наконец-то угнетатели повержены и можно спать спокойно. Всё работает исключительно за счёт магии VAIO API.
Retention
---------
Самое время упомянуть альфу и омегу запросов в саппорт - [ретенш](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_retention.html?ver=110). А между прочим, их тут сразу целых два! Вот это поворот! (с)
На длинной дистанции мы используем **Long-term retention**, гарантирующий консистентность на уровне приложений(application aware). Делается это с помощью VSS и требует предоставления админской учётки от гостевой ОС. Выглядит это как создание точек отката с определённой периодичностью (например, раз в 12 часов), которые хранятся несколько дней.
И второе - это **Short-term Retention**, где гранулярность отката может доходить до 2 (двух!) секунд, но гарантируется только crash-consistent восстановление. Для short-term указывается значение RPO - как часто сохранять состояние дисков - и сколь долго хранить эти изменения. Можно понимать это как количество времени, которое мы будем хранить наши RPO точки. На скриншоте ниже мы будем хранить данные с нарезкой по 15 секунд за последние 4 часа.
Расписание, само собой, гибко настраивается, позволяя, например, обеспечивать crash-consistent только в офисное время, а в ночное переключаться на редкие, но application-consistent точки.
Если подходить глобально, то вариантов сделать фейловер у нас два: прямо сейчас по кнопке Failover now… или создав Failover Plan. Соответственно, если случилась авария, то мы можем сделать фейловер нашей реплики в следующих режимах:
* Откат на последнее состояние (crash-consistent)
* Восстановиться на нужный нам момент времени в режиме Point-in-time (crash-consistent)
* Откатиться на Long term точку (здесь можно выбрать между application-aware и crash-consistent)
А failback и permanent failover делаются по правилам обычных старомодных реплик, так что останавливаться на этом не буду. Всё есть в [документации](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_failback.html?ver=110).
> **Совет:** *в выборе нужного момента времени при Point-in-time ресторе очень удобно двигать ползунок стрелочками на клавиатуре ;)*
>
>
Как работает CDP ретеншн
------------------------
И прежде чем мы начнём обсуждать, почему вы поставили хранить три точки отката, а на диске их двадцать восемь, давайте посмотрим, что вообще будет храниться на таргетной датасторе.
* **.VMDK** Тут без сюрпризов. Обычный диск вашей машины, который создаётся в момент первого запуска репликации.
* **.TLOG** и **.META** - логи и метаданные транзакций. Всё для того, чтобы ничего не потерялось. Также они позволяют сделать откат на произвольный момент времени.
* **VM-000X.VMDK** Дельта диски, коих может быть огромное количество. И не думайте, что каждый дельта диск - это точка отката. Это просто хранилища блоков данных, жестко связанные с файлами логов транзакций. Примерно как в базах данных. Когда вы будете делать фейловер, Veeam выстроит цепочку из нужных дельта дисков и первоначального VMDK. А с помощью лога транзакций найдёт необходимые блоки данных, которые фильтр применит к базовому диску при запуске машины. Это тот единственный момент, когда нам нужно включить Target Filter.
Short-term retention
--------------------
Теперь рассмотрим, как это работает.
* В первый момент времени на таргете нет ничего, поэтому, чтобы начать работать, нам надо взять и в лоб поблочно скопировать VMDK файл с сорса на таргет.
Интересный факт: в интерфейсе VBR иконки успешно переехавших машин окрашиваются в синий. В то время как их менее успешные товарищи остаются серыми. Если время, которое вы выделили на первичную синхронизацию, уже прошло, а машины так и не посинели, то надо разбираться, что им мешает. Правильный и простой вариант действий в этом случае: обратиться в сапорт. Более долгий и увлекательный - копаться в логах самому. Только учтите, что на тему CDP логов можно ещё одну статью смело писать, так что лучше доверьте это дело профессионалам.
> **Совет:** *если тащить по сети огромный VMDK вам нет никакого удовольствия, то* [Seeding и Mapping](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_policy_seeding_mapping.html?ver=110) *вам в помощь. Они позволяют перевести ваши файлы на таргетный хост хоть на флешке в кармане, в дальнейшем подключив их к заданию.*
>
>
Абсолютно реальна ситуация, при которой на реплицируемой машине в момент первой синхронизации будет настолько большая нагрузка, что таргет будет не успевать записывать все приходящие блоки (оригинальный диск + новые блоки). Особенно если там используется сторадж значительно медленнее сорсного. Поэтому когда накапливается большое количество блоков, для которых не было получено подтверждение о доставке, сеть останавливается, и не надо этого бояться. Как только придёт достаточное количество подтверждений, сеть запускается заново. А подтверждение - это когда таргетный демон рапортует об успешной записи всего микроснапшота (про это чуть ниже) на сторадж. Ситуация не слишком частая, но бывает и такое.
Возникает закономерный вопрос: каков размер этих самых блоков? Он динамический и зависит от размера диска. Для простоты можно считать, что 1 Тб диска соответствует 1 Мб блока.
| | | |
| --- | --- | --- |
| 1 ТБ -> 1 МБ | 7 ТБ -> 8 МБ | 64 ТБ -> 64 МБ |
| 2 ТБ -> 2 МБ | 10 ТБ -> 16 МБ | 100 ТБ -> 128 МБ |
| 3 ТБ -> 4 МБ | 37 ТБ -> 64 МБ | |
| 4 ТБ -> 4 МБ | 62 ТБ -> 64 МБ | |
* Как только VMDK перевезён, можно начинать создавать дельта диски. Для чего фильтр и демон начинают отслеживать IO машины, отправляя по сети всё, что пишется на машине.
* Этот поток сознания, приходя на сорс прокси, проходит через процедуру отбрасывания лишних блоков. То есть если некий блок за период репликации был перезаписан несколько раз, то в дельту уйдёт исключительно последнее его состояние, а не вообще все. Это позволяет сохранять вагон ресурсов и два вагона пропускной способности вашей сети.
* Рядом с дельта диском создаётся транзакцонный лог.
* Если лог становится слишком большим, то создаётся новый дельта диск.
* И так всё работает до достижения выбранного Retention policy. После чего Veeam смотрит на содержимое лога.
* Если это просто устаревшая точка восстановления, которая нам больше не нужна, то данные из неё вносятся в наш базовый диск, и файлы удаляются.
* Если оказывается, что в логе нет вообще ничего, необходимого для создания новых точек восстановления, такой файл сразу удаляется.
> **Примечание:** *Соблюдение Retention Policy довольно важно. Однако поддержка CDP реплики в боевом состоянии ещё важнее. Поэтому в механизм заложена потенциальная возможность временного расширения периода хранения до 125% от первоначального.*
>
>
Long-term retention
-------------------
Служит логическим продолжением short-term retention. То есть всё работает ровно так, как и написано выше, пока не наступает момент создать long-term точку.
* В этот момент создаётся особый дельта диск. Внешне он не отличается от других, однако во внутренней логике он помечается как long-term delta.
* Репликация продолжает идти своим чередом.
* Когда подходит время для срабатывания short term, то все предыдущие логи и дельта диски (если их несколько) просто удаляются.
* Теперь всё считается от этой long-term точки. Она остаётся нетронутой и высится как глыба.
* Затем создаётся новая long-term точка, и цикл замыкается.
* Когда подходит время, то самая первая long-term точка инжектируется в базовый VMDK.
Про логику транзакций
---------------------
Путь данных с оригинальной машины до реплицированной можно разбить на два логических участка, водораздел которых проходит по source proxy.
В первой части наши данные - это просто набор транзакций, которые по большому счёту представляют собой неструктурированный поток сознания дисковых IO операций. Попадая на сорсной прокси, этот поток структурируется, обрабатывается и отправляется дальше в виде состояния блоков диска в определённый момент времени. У себя мы называем это микроснапшотом. Да, название так себе, но, как говорится, так исторически сложилось.
Отсюда два важных следствия:
* Если мы не успеваем передать данные на участке фильтр-демон-прокси, они считаются безвозвратно потерянными, и сделать с этим уже ничего нельзя.
* На втором участке задержка уже не критична. Если даже в какой-то момент времени мы не успеваем получить подтверждение от таргетного демона, то данные остаются в кеше сорсного и таргетного прокси и будут переданы ещё раз. Если кажется, что такое кеширование избыточно, то это кажется. Сети сейчас, конечно, быстрые, но зачем лишний раз лезть далеко, если можно попросить данные ближе? В логе джобы в этот момент возникнет предупреждение, что RPO нарушено, но ничего критичного ещё не случилось. Позднее данные будут довезены до таргета.
Что под капотом у фильтров
--------------------------
Теперь, когда мы разобрались на базовом уровне в устройстве и принципах работы CDP, давайте посмотрим более внимательно на работу отдельных компонентов. А именно фильтров. Ведь именно от их красивой работы зависит всё остальное. И как мы все прекрасно понимаем, ровно и красиво может быть только в лабораторных условиях. Именно там у нас всегда стабильный поток IO операций, нет резких всплесков нагрузки, сетевые пакеты никуда не пропадают, и все графики выглядят как прямая рельса, уходящая за горизонт.
Именно из-за таких расхождений с реальностью у фильтров есть два режима работы. Clean Mode и Dirty Mode. В первом варианте у нас всё хорошо, и все измененные блоки мы успеваем отправить вовремя, а на принимающей стороне успевают их принять и уложить в требуемое место. Но как только над нами сгущаются тучи и мы не успеваем передать очередную порцию данных, CDP фильтр переключается во второй режим. Вернее, он получает команду от демона, что у того переполнена очередь на отправку и новые данные хранить негде. После чего фильтр перестаёт передавать данные, а только ведёт учёт изменённых блоков. Такие блоки данных помечаются как DirtyBlockMap. Единственное, что можно сделать в этой ситуации - это ждать возвращения стабильного канала связи и отмашки, что всё успешно записалось на таргет. Как только принимается решение, что связь удовлетворяет нашим потребностям, помеченные блоки передаются ещё раз, и в случае успеха фильтр переключается обратно в Clean Mode.
Немного сухих цифр: кэш каждого из фильтров - на всё про всё 32 МБ. Вроде мало, но больше и не надо. Задача фильтра - считать блок и как можно быстрее поставить в очередь сорс демона. Там кэш - уже 2 ГБ заранее выделенного RAM. Дисковый кеш прокси задаётся пользователем вручную. И в целом надо помнить, что архитектура CDP подразумевает максимальное наполнение кеша всех из компонентов в надежде, что данные всё же получится отвезти на таргет. И только когда кончается вся свободная память, реплика останавливается с ошибкой.
Вот так вот можно изобразить на любимых всеми квадратиках с буквами режимы работы. В данном примере у нас установлено RPO 10 секунд, из которых пять секунд (половина RPO) мы отслеживаем изменения данных, а вторую половину времени пытаемся передать последнее их состояние. То есть, промежуточные, как я говорил выше, нас не интересуют.
А вот что случается, когда мы не получаем подтверждение доставки от таргета. Данные мы собрали, однако передать их не можем. В этот момент Veeam начинает сохранять в сторонку номера таких блоков. И только номера, никаких данных. Почему? Потому что когда связь восстановится, нам надо передать актуальное состояние блоков.
> **Примечание:** *Чтобы администратор спал спокойней, предусмотрены два оповещения, скрывающихся под кнопкой RPO Reporting. Фактически они просто считают, сколько данных за указанный промежуток времени мы можем потерять. И бьют в набат, если что-то пошло не так.*
>
>
Инфраструктура
--------------
Обычно, когда заходит речь о проработке какой-либо инфраструктуры, все сразу начинают думать про CPU и RAM. Но только не в этот раз! Здесь надо начинать с поиска вашего сетевика, чтобы он сделал вам сеть с наикратчайшим маршрутом, с 10 Gbit+ линками, и не забыл включить MTU 9000 (Release Jumbo frames!!!) на всём протяжении маршрута. Согласно нашим тестам, такой набор нехитрых действий позволяет добиться прироста производительности почти на 25%. Неплохо, да?
Но не бросаем сетевика на полдороге и тащим его к тем, кто занимается серверами: для VMkernel должны стоять выделенные физичеcкие NIC. Если нет - не приходите жаловаться на тормоза. Ибо сеть, скорее всего, будет забита под потолок своих возможностей. Но вообще, чисто технически, минимально нужны гигабитные карточки и задержки в пределах 80 мс.
Теперь сетевика можно уже отпустить и переключиться, например, на таргетный сторадж. Тут всё очень просто: всегда используйте выделенный сторадж. Процесс записи невозможно как-то замедлить, попросить подождать пока идёт транзакция от другого приложения, и так далее. Нет, сторадж будет молотить на весь свой ценник и вряд ли будет очень рад дополнительным нагрузкам. Хотя, конечно, тут всё зависит от вашего железа. Ну и роли прокси, конечно же, лучше выдавать выделенным машинам. Насчёт того, физическим или виртуальным - тут мнения расходятся. Лично я за физические, но правильно будет протестировать на месте.
И общий совет на все случаи жизни: десять маленьких CDP политик всегда будут работать лучше и стабильней, чем одна большая. Что такое маленькая политика? Это до 50 машин или 200 дисков. В мире большого энтерпрайза это считается за немного. Технически, опять же, здесь ограничений нет, и проводились успешные тесты аж до 1500 машин и 5000 дисков. Так что лучше, опять же, протестировать на месте и найти оптимальный для себя вариант.
Немного о прокси
----------------
И хотя кажется, что прокси серверам в схеме CDP отведена роль тупых молотильщиков трафика, без их успешного взаимодействия всё остальное теряет смысл. И задачи там решаются достаточно серьёзные, так что не будем принижать их вклад в общее дело.
Что хочется сказать про этих ребят:
* Дисковый кеш - это исключительно запасной план на случай закончившейся оперативки. Всё придумано и сделано так, будто находится исключительно в RAM. Поэтому, пожалуйста, не жадничайте и дайте серверам памяти.
* Не надо заставлять один и тот же прокси сервер выступать в роли сорсного и таргетного. Ничего хорошего из этого не выйдет. Запретить вам так сделать мы не можем, однако будем долго отговаривать.
* В идеальном мире на один ESXi - один прокси.
* А вот физический или виртуальный на том же хосте - этого вам никто не скажет, и надо тестировать. Часто бывает, что виртуальный оказывается быстрее физического.
* Да и вообще, общая логика такова, что чем больше вы сможете развернуть прокси серверов, тем лучше будет результат. Особенно если речь идёт о репликации между удалёнными дата центрами.
Также самые внимательные заметят, что на шаге назначения проксей есть кнопка Test с таинственным набором цифр внутри.
Давайте разбираться что же это такое и откуда оно взялось. Все эти скорости и количества являются ничем иным, как усреднёнными максимумами за последний час, полученными от vCenter. То есть это не мы что-то там померили в моменте, ловко запустив какие-то таинственные тесты, а такова родная статистика хостов за последний час.
Давайте теперь пройдёмся по строчкам.
**Source Proxy CPU**: количество ядер CPU на всех доступных проксях, которые могут работать в качестве сорса. Видим vCPU, но читаем как ядра CPU.
**Source Proxy RAM**. Здесь уже посложней будет. Цифра перед скобками показывает, сколько оперативки нам может понадобиться для данной CDP политики.
Формула расчёта довольно простая: RPO\* пропускную способность.
Пропускную способность кого/чего? Да всех дисков всех вируталок, участвующих в этой политике. Напоминаю, что берётся максимальное значение за последний час.
То есть предположим, что наш RPO - 15 секунд, и что диски выдают 150 Мб/сек. Значит, нам понадобится 2250 Мб RAM.
А цифра в скобках - это вся доступная оперативка на всех наших проксях, Но, как обычно, есть нюансы. Во-первых, половина RAM считается зарезервированной под нужды ОС и других приложений. Это можно подправить ключиком в реестре в любую сторону (сие остаётся полностью на вашей совести). Во-вторых, учтите, что в случае возникновения задержек на сети или задумчивости хранилища, данные будут сохраняться в кеше до двух минут, после чего будет включена аварийная сирена. И если в течение этих двух минут память переполнится, то подключится медленный дисковый кэш.
**Source Proxy Bandwidth**. Здесь опять всё просто. Число перед скобками мы получаем от vCenter, а число в скобках считается на основе доступного количества ядер с округлением до целого. Если мы шифруем трафик, то это 150 Мб/с на ядро. Если не шифруем, то 200 Мб/с на ядро.
**Target Proxy CPU.** Всё ровно так же, как у сорса: взяли и посчитали все доступные ядра на доступных проксях.
**Target Proxy RAM**. Хочется, как и в предыдущем пункте, сказать, что всё такое же, но нет. Здесь в формулу для расчёта внесён поправочный коэффициент 0.5. А значит, что если мы за те же 15 секунд хотим обработать 150 Мб/c от дисков, то понадобится нам уже только 1125 RAM (вместо 2250, как это было с сорсом).
**Target Proxy Bandwith**. Здесь тоже не обошлось без скидок. Считаем, что одно ядро при шифровании трафика будет обрабатывать 350 Мб/c, а без шифрования - все 400 Мб/c.
И помним важное: таргет и прокси меняются ролями в момент фейловера. То есть вся схема начинает работать в обратную сторону. Поэтому на таргете и есть неактивный фильтр, который оживает в момент фейловера. А фильтр на бывшем сорсе, соответственно, выключается.
Быстрое Ч.А.В.О. в конце
------------------------
**Как добавить в CDP Policy выключенную машину?**
Никак. Виртуалка выключена > фильтр не работает > передавать нечего.
**Какие версии vSphere поддерживаются?**
Ну я же просил - читайте [документацию](https://helpcenter.veeam.com/docs/backup/vsphere/cdp_replication.html?ver=110), там всё есть. Но пользуйтесь пока я добрый: 6.5, 6.7, 7.0
**Хочу минимальное RPO, чтобы ну вообще ничего не потерялось.**
Если у вас железо хорошее (прям хорошее-хорошее, а не вам кажется, что хорошее), то вполне реально добиться RPO в 2 секунды. А так, в среднем по больнице, вполне реально обеспечивать 10-15 секунд.
**А что с vRDM?**
Всё отлично поддерживается.
**А можно CDP прокси назначить и другие роли?**
Назначайте, мы не против. Только следите за соответствием доступных ресурсов предполагаемым нагрузкам.
**А можно CDP реплику, как и обычную, использовать для создания бекапов?**
Нет. Во всяком случае сейчас.
**Я могу запустить CDP реплику из консоли vCenter?**
Нет. С точки зрения vCenter там какой-то фарш из дельта дисков, поэтому он выдаст ошибку зависимостей.
**А если я руками удалю CDP реплику из Inventory в vCenter?**
Умрут все id и всё сломается. А вы чего ожидали?
**А если таргетная стора будет чем-то очень загружена?**
Veeam будет присылать на почту уведомления, что очень старается, но у вас ботлнек на принимающей стороне и нельзя впихнуть невпихуемое.
**А что с Hyper-V?**
Это вопрос к Microsoft.
Немного полезных ESXi команд
----------------------------
Убить daemon сервис:
```
# ps | grep iof
# kill -9
```
Остановить/запустить daemon сервис:
```
# /etc/init.d/iofilterd-vvr stop/start
```
Полюбопытствовать насчет последних логов демона:
```
# tail -n 100 -f /var/log/iofilterd-vvr.log
```
Выяснить, сколько памяти потребили все демоны:
```
# vsish -e get /sched/memClients/[iofilterd-PID]/SchedGroupID
```
```
# memstats -r group-stats -s name:min:max:eMin:rMinPeak:consumed:flags -g [iofilterd-ScheddGroupID] -u mb
```
Проверить установку пакета фильтра. Он выглядит как обычный vib
```
# esxcli software vib list | grep veecdp
``` | https://habr.com/ru/post/548900/ | null | ru | null |
# Основы создания 2D персонажа в Unity 3D 4.3. Часть 3: прыжки (и падения)
[Часть 1: заготовка персонажа и анимация покоя](http://habrahabr.ru/post/211472/)
[Часть 2: бегущий персонаж](http://habrahabr.ru/post/211847/)
**Часть 3: прыжки (и падения)**
Всем привет. Продолжаем серию уроков по созданию 2D персонажа. В предыдущих двух частях мы сделали персонажа, который может находиться в двух состояниях: покой и бег вправо-влево. Возможно, для очень простой игры этого будет достаточно. Но мы не будем останавливаться на достигнутом и сегодня научим нашего персонажа прыгать.
Наша цель звучит просто, но в ее реализации будут некоторые тонкости. Во-первых, нам надо как-то определить, что персонаж находится в состоянии прыжка. Это будет немного сложнее, чем определение состояния бега. Во-вторых, нужно прикрутить соответствующую анимацию. Здесь мы могли бы поступить аналогично анимациям покоя и бега — циклично воспроизводить соответствующие кадры анимации, пока персонаж находится в состоянии прыжка. Но мы реализуем более гибкий вариант. Состояние прыжка на самом деле состоит из двух состояний: взлет и свободное падение. Кроме того, бывают частные случаи — только взлет и только падение. Если мы прикрутим одну общую анимацию для этих двух состояний (например, поджатые ноги и развевающийся на ветру плащ) — это может выглядеть нормально, но не совсем реалистично. В реальности, когда человек прыгает, положение его тела, рук, ног отличается при взлете и при падении. Мы создадим такую анимацию, которая будет учитывать скорость взлета/падения и в зависимости от нее переключать соответствующий кадр анимации.
Загрузим наш проект и сцену. В папке *Assets* — *Sprites* у нас остался последний неиспользованный спрайт *Jump*. Проделаем с ним уже знакомую операцию по нарезке спрайта на коллекцию изображений. Затем в окне *Hierarchy* выберем *Character* и перейдем в окно *Animation*. Для прыжка нам понадобиться несколько файлов анимаций, а точнее — семь. Это равно числу кадров в спрайте *Jump*. Давайте создадим эти анимации, называя их *Jump1*, *Jump2* и т.д.
Теперь добавим в каждую анимацию по одному изображению из спрайта *Jump*, по порядку: спрайт *Jump\_0* в анимацию *Jump1*, спрайт *Jump\_1* в анимацию *Jump2*…
В окне *Animator* (не *Animation*!) у нас автоматически создались элементы для новых анимаций, но они нам теперь не понадобятся. Выделим их и удалим клавишей *Delete* (анимации также удалятся из соответствующего списка в окне *Animation*, но чуть позже мы их вернем). Создадим в *Animator*'е два новых параметра: *Ground* с типом *Bool* и *vSpeed* с типом *Float*. Первый будет обозначать, находится ли персонаж на земле или в прыжке, а второй будет хранить текущее значение скорости персонажа по оси Y, то есть скорость взлета/падения. В зависимости от нее мы будем применять соответствующую анимацию из наших семи анимаций прыжка.
Теперь кликнем правой кнопкой по любому свободному месту в окне *Animator* и выберем *Create State* — *From New Blend Tree*. В окне *Inspector* переименуем созданный элемент как *Jump*.
Создадим два перехода между анимациями: *Any State* -> *Jump* и *Jump* -> *Idle*. То есть, из любого состояния мы можем перейти в состояние прыжка, а из состояния прыжка перейти в состояние покоя. Напоминаю, как делаются переходы: клик правой кнопкой по первой анимации, *Make Transition*, клик левой кнопкой по второй анимации. Для первого перехода зададим условие *Ground* — *false*, для второго *Ground* — *true*.
Теперь кликнем дважды по *Jump*. Откроется элемент *Blend Tree*. В него мы добавим наши семь анимаций прыжка, а переключение между ними будут происходить в зависимости от значения параметра *vSpeed*. По умолчанию в *Blend Tree* сейчас установлен параметр *Speed* — поменяем его на *vSpeed* в окне *Inspector*.
В этом же окне нажмем на плюсик и выберем *Add Motion Field*. Это нужно проделать семь раз. Создадутся семь полей для наших семи анимаций. Снимем флаг *Automate Thresholds*, чтобы можно было вручную устанавливать значения параметра *vSpeed*, при достижении которых будет производиться смена анимации в *Blend Tree*. Перетащим в каждое поле по анимации и зададим значения *vSpeed*. Вот что должно получиться (кстати, после этих действий удаленные из списка в окне *Animation* анимации *Jump1*-*Jump6* вновь появятся):
С анимацией пока закончим. Теперь нам надо научится определять, когда персонаж находится на земле, а когда — в воздухе, то есть в прыжке. Перейдем в окно *Scene*. Создадим пустой игровой объект, назовем его *GroundCheck*. Выделяем его в окне *Hierarchy* и перетаскиваем мышью на *Character* (все в том же окне *Hierarchy*!). Теперь объект *GroundCheck* будет дочерним по отношению к *Character* и будет перемещаться вместе с ним, а объект *Character* приобретет соответствующую стрелку, скрывающую дочерние объекты. Кликнем по стрелке и вновь выберем объект *GroundCheck*. Назначим ему иконку, чтобы видеть объект на сцене. На скриншоте я указал, как это сделать:
В окне *Scene* переместим *GroundCheck* в ноги персонажа. Тем самым, мы сделали объект, который будет использован для определения нахождения персонажа на земле.
Теперь нам надо определить, а что же является землей? Очевидно, это наша платформа, но игра об этом пока не знает. Кстати, давайте создадим копию платформы для тестирования прыжка (лучшим способ будет создание префаба на основе платформы, но сейчас давайте просто выделим *Platform* и нажмем *Ctrl+D*). Разместим вторую платформу правее и выше первой.
Выделим любую из платформ и обратим внимание на верхнюю часть окна *Inspector*. Там есть поле *Layer* со значение *Default*. Оно обозначает принадлежность объекта к тому или иному слою. Кликнем на *Default*, выберем *Add Layer*, зададим в поле *User Layer 8* имя *Ground*. Снова выделим платформу, и вместо слоя *Default* установим слой *Ground*. Для второй платформы тоже установим слой *Ground*.
Таким образом мы определили, что наши платформы будут землей. Объект *GroundCheck* будет проверяться на предмет пересечения с объектами слоя *Ground*, т.е. с нашими платформами. Если будет обнаружено пересечение — персонаж находится на земле. Делаться это будет в скрипте *CharacterControlleScript*, созданном в предыдущей части. Давайте откроем его на редактирование.
В начало скрипта добавим новые переменные в добавок к уже существующим:
```
//находится ли персонаж на земле или в прыжке?
private bool isGrounded = false;
//ссылка на компонент Transform объекта
//для определения соприкосновения с землей
public Transform groundCheck;
//радиус определения соприкосновения с землей
private float groundRadius = 0.2f;
//ссылка на слой, представляющий землю
public LayerMask whatIsGround;
```
А в начало метода *FixedUpdate* следующие строки:
```
//определяем, на земле ли персонаж
isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundRadius, whatIsGround);
//устанавливаем соответствующую переменную в аниматоре
anim.SetBool ("Ground", isGrounded);
//устанавливаем в аниматоре значение скорости взлета/падения
anim.SetFloat ("vSpeed", rigidbody2D.velocity.y);
//если персонаж в прыжке - выход из метода, чтобы не выполнялись действия, связанные с бегом
if (!isGrounded)
return;
```
Теперь добавим в скрипт метод *Update*, в котором будем обрабатывать нажатие клавиши прыжка. Мы будем делать это в методе *Update* для большей точности управления — этот метод вызывается каждый фрейм игры, в отличии от *FixedUpdate*, который вызывается через одинаковое определенное время и обычно, при хорошем FPS, вызовы происходят реже вызовов *Update*.
```
private void Update()
{
//если персонаж на земле и нажат пробел...
if (isGrounded && Input.GetKeyDown (KeyCode.Space))
{
//устанавливаем в аниматоре переменную в false
anim.SetBool("Ground", false);
//прикладываем силу вверх, чтобы персонаж подпрыгнул
rigidbody2D.AddForce(new Vector2(0, 600));
}
}
```
Итого, полностью скрипт будет выглядеть так:
**CharacterControllerScript**
```
using UnityEngine;
using System.Collections;
public class CharacterControllerScript : MonoBehaviour
{
//переменная для установки макс. скорости персонажа
public float maxSpeed = 10f;
//переменная для определения направления персонажа вправо/влево
private bool isFacingRight = true;
//ссылка на компонент анимаций
private Animator anim;
//находится ли персонаж на земле или в прыжке?
private bool isGrounded = false;
//ссылка на компонент Transform объекта
//для определения соприкосновения с землей
public Transform groundCheck;
//радиус определения соприкосновения с землей
private float groundRadius = 0.2f;
//ссылка на слой, представляющий землю
public LayerMask whatIsGround;
///
/// Начальная инициализация
///
private void Start()
{
anim = GetComponent();
}
///
/// Выполняем действия в методе FixedUpdate, т. к. в компоненте Animator персонажа
/// выставлено значение Animate Physics = true и анимация синхронизируется с расчетами физики
///
private void FixedUpdate()
{
//определяем, на земле ли персонаж
isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundRadius, whatIsGround);
//устанавливаем соответствующую переменную в аниматоре
anim.SetBool ("Ground", isGrounded);
//устанавливаем в аниматоре значение скорости взлета/падения
anim.SetFloat ("vSpeed", rigidbody2D.velocity.y);
//если персонаж в прыжке - выход из метода, чтобы не выполнялись действия, связанные с бегом
if (!isGrounded)
return;
//используем Input.GetAxis для оси Х. метод возвращает значение оси в пределах от -1 до 1.
//при стандартных настройках проекта
//-1 возвращается при нажатии на клавиатуре стрелки влево (или клавиши А),
//1 возвращается при нажатии на клавиатуре стрелки вправо (или клавиши D)
float move = Input.GetAxis("Horizontal");
//в компоненте анимаций изменяем значение параметра Speed на значение оси Х.
//приэтом нам нужен модуль значения
anim.SetFloat("Speed", Mathf.Abs(move));
//обращаемся к компоненту персонажа RigidBody2D. задаем ему скорость по оси Х,
//равную значению оси Х умноженное на значение макс. скорости
rigidbody2D.velocity = new Vector2(move \* maxSpeed, rigidbody2D.velocity.y);
//если нажали клавишу для перемещения вправо, а персонаж направлен влево
if(move > 0 && !isFacingRight)
//отражаем персонажа вправо
Flip();
//обратная ситуация. отражаем персонажа влево
else if (move < 0 && isFacingRight)
Flip();
}
private void Update()
{
//если персонаж на земле и нажат пробел...
if (isGrounded && Input.GetKeyDown (KeyCode.Space))
{
//устанавливаем в аниматоре переменную в false
anim.SetBool("Ground", false);
//прикладываем силу вверх, чтобы персонаж подпрыгнул
rigidbody2D.AddForce(new Vector2(0, 600));
}
}
///
/// Метод для смены направления движения персонажа и его зеркального отражения
///
private void Flip()
{
//меняем направление движения персонажа
isFacingRight = !isFacingRight;
//получаем размеры персонажа
Vector3 theScale = transform.localScale;
//зеркально отражаем персонажа по оси Х
theScale.x \*= -1;
//задаем новый размер персонажа, равный старому, но зеркально отраженный
transform.localScale = theScale;
}
}
```
Сохраняем скрипт, возвращаемся в Unity. В *Hierarchy* выделяем *Character*. Перетаскиваем объект *GroundCheck* в поле *Ground Check* скрипта *CharacterControllerScript*, а в поле *What Is Ground* устанавливаем *Ground*.
Итак, в нашем скрипте, в методе *FixedUpdate* проверяется пересечение объекта *GroundCheck* с объектами, принадлежащими слою *Ground*. Это достигается при помощи метода *Physics2D.OverlapCircle*. В аргументах этого метода также задан радиус определения пересечения. Затем, в переменную аниматора *Ground* устанавливается результат определения нахождения на земле, а в переменную *vSpeed* — текущая скорость персонажа по оси Y. В зависимости от этой скорости применяется та или иная анимация прыжка из семи анимаций в *Blend Tree*. Сам прыжок задается в методе *Update* при нажатии на пробел, путем придания вертикальной силы компоненту *Rigidbody2D*.
Прежде чем запускать игру давайте немного изменим значение гравитации, а то скорость прыжков получится медленной, как на Луне. Заходим в меню *Edit* — *Project Settings* — *Physics 2D*. В окне *Inspector* устанавливаем значение *Gravity* *Y* = -30. Запускаем игру! Если все сделано правильно, увидим примерно следующее:
Капитан Коготь умеет бегать и прыгать. При прыжке, в зависимости от состояния (взлет/падение) и от скорости применяется соответствующая анимация. На видео хорошо заметно, что при прыжке в окне *Animator* происходят переключения между анимациями в элементе *Blend Tree*. При этом, если персонаж просто падает с платформы (т.е. в прыжке нету фазы взлета, пробел не нажимался) — работают только те анимации, для переключения которых заданы отрицательные значения скорости, что делает поведение персонажа более реалистичным. Конечно, для лучшего эффекта необходимо больше анимаций и более тонкая настройка значений скорости.
Что ж, на этом все. Основа для 2D персонажа создана. Какие к ней прикрутить дополнительные возможности — зависит уже от конкретной игры. Спасибо за внимание! | https://habr.com/ru/post/212309/ | null | ru | null |
# Изменить сохранения Spark Часть вторая: реализация партишенера
***Автор:*** *Иван Калининский, участник профессионального сообщества Сбера SberProfi DWH/BigData.*
*Профессиональное сообщество SberProfi DWH/BigData отвечает за развитие компетенций в таких направлениях, как экосистема Hadoop, Teradata, Oracle DB, GreenPlum, а также BI инструментах Qlik, SAP BO, Tableau и др.*
Начну описание партишенера с UML-диаграммы:
Рисунок 1. UML-диаграмма классов OrderBucketsPartitionerНаверняка вы видели, как Spark разбирает запрос, строит план и выполняет его. Сопоставим эту схему с нашей конкретной реализацией (когда будете знакомиться с реализацией классов, возвращайтесь к этой схеме, чтобы увидеть соответствие):
Рисунок 2. Сопоставление схемы обработки запроса и конкретной реализации.Нужен метод, который позволил бы использовать партишенер для любого датафрейма. Пока не будем связываться с SQL (разве кто-то делает dataframe.repartition(...) с помощью SQL?).
Добавим такой метод в Scala Dataframe API, используя паттерн «Pimp my library».
Для этого создадим новый объект ru.kalininskii.orderbucketing.OrderBucketing. Он будет содержать implicit class с пока единственным методом repartitionWithOrderAndSort:
OrderBucketing
```
package ru.kalininskii.orderbucketing
import org.apache.spark.sql.{Column, DataFrame, PlanHelper}
import org.apache.spark.sql.catalyst.expressions.{Ascending, Expression, SortOrder}
import ru.kalininskii.orderbucketing.plans.logical.RepartitionWithOrderAndSort
object OrderBucketing {
implicit class DataFramePartOps(ds: DataFrame) {
def repartitionWithOrderAndSort(numLines: Int,
numPartitions: Int,
orderColumn: Column,
partitionColumns: Seq[Column],
sortColumns: Seq[Column]): DataFrame = {
def toSortOrder(col: Column): SortOrder = {
col.expr match {
case order: SortOrder => order.copy(direction = Ascending)
case expr: Expression => SortOrder(expr, Ascending)
case _ => throw new Exception(s"Can not get order from $col")
}
}
val orderExpression = toSortOrder(orderColumn)
val partitionExpressions = partitionColumns.map(_.expr)
val sortExpressions = sortColumns.map(toSortOrder)
val logicalPlan = RepartitionWithOrderAndSort(
orderExpression,
partitionExpressions,
sortExpressions,
numLines,
numPartitions,
None,
ds.queryExecution.logical)
PlanHelper.planToDF(ds.sparkSession, logicalPlan)
}
}
}
```
Как можно видеть из кода выше, метод принимает аргумент partitionColumns: Seq[Column], в котором поля явного и неявного секционирования объединены. Так и должно быть, партишенер разделяет записи по секциям независимо от их внешнего представления.
Объект PlanHelper пока что также обойдётся одним методом, planToDF. Этот метод вызывает приватный метод для пакета org.apache.spark.sql, поэтому, чтобы он мог выполняться, объект тоже должен находиться в этом пакете:
PlanHelper
```
package org.apache.spark.sql
import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan
object PlanHelper {
def planToDF(spark: SparkSession, logicalPlan: LogicalPlan): DataFrame = {
Dataset.ofRows(spark, logicalPlan)
}
}
```
Тип для описания одной секции RDD, а также ключа RDD, который понадобится нам в определённый момент, поместим в package object, чтобы он был доступен всему нашему пакету и не только
package object rangebucketing
```
package ru.kalininskii
import org.apache.spark.sql.catalyst.InternalRow
package object rangebucketing {
type BucketsDistribution = (Int, InternalRow, Either[(InternalRow, Seq[String]), (InternalRow, InternalRow, Int)])
type OrderAndSortKey = (InternalRow, InternalRow, InternalRow)
}
```
Теперь нужно определить планы, начиная с логического. И в них переопределить метод *simpleString*, так как иначе он выведет в план весь переданный объект *distribution.*Логический план для этого репартиционирования будет виден при использовании метода explain, и можно будет убедиться, что он действительно применяется. Кроме того, он встроен в формирование планов выполнения запросов и будет предоставлять информацию о физическом секционировании набора данных в переменной *partitioning****.***
RepartitionWithOrderAndSort
```
package ru.kalininskii.orderbucketing.plans.logical
import org.apache.spark.sql.catalyst.expressions.{Expression, SortOrder}
import org.apache.spark.sql.catalyst.plans.logical.{LogicalPlan, RepartitionOperation}
import ru.kalininskii.orderbucketing.BucketsDistribution
import ru.kalininskii.orderbucketing.plans.physical.OrderBucketsPartitioning
/**
* Этот класс разделяет данные по условю уникальных точных значений [[Expression]]
*
* @param orderExpression выражение, по интервалам значений которого будет производиться разделение
* в пределах одного значения [[partitionExpressions]]
* @param partitionExpressions выражения, по значениям которых будет производиться разделение.
* @param sortExpressions выражения, по значениям которых будет производиться локальная сортировка.
* @param numLines количество записей в одной секции RDD (и в записанном файле)
* @param numPartitions предполагаемое количество секций, может отличаться
* @param distribution информация об имеющемся распределении, которое надо воспроизвести
* @param child план получения набора данных, который нужно секционировать
*/
case class RepartitionWithOrderAndSort(
orderExpression: SortOrder,
partitionExpressions: Seq[Expression],
sortExpressions: Seq[SortOrder],
numLines: Int,
numPartitions: Int,
distribution: Option[Seq[BucketsDistribution]],
child: LogicalPlan
) extends RepartitionOperation {
override def nodeName: String = s"Repartition plan with " +
s"${distribution.map(_ => "predefined").getOrElse("unknown")} distribution:"
override def simpleString: String = {
s"$nodeName ${partitionExpressions.mkString("partition by [", ", ", "], ")}" +
s"global order by ${orderExpression.child}, " +
s"${sortExpressions.map(_.child).mkString("local sort by [", ", ", "], ")}" +
numLines + " rows per task, " + numPartitions + " initial tasks"
}
val partitioning: OrderBucketsPartitioning = OrderBucketsPartitioning(
orderExpression, partitionExpressions, sortExpressions, numLines, numPartitions, distribution)
override def maxRows: Option[Long] = child.maxRows
override def shuffle: Boolean = true
}
```
Класс *Partitioning* и его расширения в структуре пакетов Spark относятся к физическим планам (*org.apache.spark.sql.catalyst.plans.physical*), но скорее представляют собой контейнеры для характеристик конкретного датафрейма.
Все встроенные реализации создаются кейс классом (см. Термины и определения) *org.apache.spark.sql.catalyst.plans.logical.RepartitionByExpression,*получая значения полей, переданных в указанный кейс класс.
И в нашем случае, *OrderBucketsPartitioning* можно считать описанием операции над таблицей, прочитанной из файловой системы или объектного хранилища. Не будет ошибкой отнести класс к логическому плану, ведь метод *dataframe.explain(true)* именно его выводит в каждом дереве логического плана).
В реализации есть неприятный момент: трейт (см. Термины и определения) *Distribution* в исходном коде Spark объявлен как *sealed*, а значит не может быть расширен. Поэтому в методе *satisfies0* я буду использовать *OrderedDistribution*, хотя она не лучшим образом подходит для описания полученного распределения.
OrderBucketsPartitioning
```
package ru.kalininskii.orderbucketing.plans.physical
import org.apache.spark.sql.catalyst.expressions.{Expression, SortOrder, Unevaluable}
import org.apache.spark.sql.catalyst.plans.physical.{Distribution, OrderedDistribution, Partitioning}
import org.apache.spark.sql.types.{DataType, IntegerType}
import ru.kalininskii.orderbucketing.BucketsDistribution
/**
* Этот класс передаёт данные для партиционирования по диапазонам в пределах партиций
*
* @param orderExpression выражение, по интервалам значений которого будет производиться разделение
* в пределах одного значения [[partitionExpressions]]
* @param partitionExpressions выражения, по значениям которых будет производиться разделение
* @param sortExpressions выражения, по значениям которых будет производиться локальная сортировка
* @param numLines количество записей в одной секции RDD (и в записанном файле)
* @param numPartitions предполагаемое количество секций, может отличаться
* @param distribution информация об имеющемся распределении, которое надо воспроизвести
*/
case class OrderBucketsPartitioning(
orderExpression: SortOrder,
partitionExpressions: Seq[Expression],
sortExpressions: Seq[SortOrder],
numLines: Int,
numPartitions: Int,
distribution: Option[Seq[BucketsDistribution]])
extends Expression with Partitioning with Unevaluable {
override def nodeName: String = s"Repartition with " +
s"${distribution.map(_ => "predefined").getOrElse("unknown")} distribution:"
override def simpleString: String = {
s"$nodeName ${partitionExpressions.mkString("partition by [", ", ", "], ")}" +
s"global order by ${orderExpression.child}, " +
s"${sortExpressions.map(_.child).mkString("local sort by [", ", ", "], ")}" +
numLines + " rows per task, " + numPartitions + " initial tasks"
}
override def children: Seq[Expression] = partitionExpressions :+ orderExpression
override def nullable: Boolean = false
override def dataType: DataType = IntegerType
override def satisfies0(required: Distribution): Boolean = {
super.satisfies0(required) || {
required match {
case o: OrderedDistribution =>
orderExpression.semanticEquals(o.ordering.head)
case _ => false
}
}
}
}
```
Далее два основных класса, *org.apache.spark.sql.execution.exchange.ShuffleExchangeOrderExec* и *org.apache.spark.sql.partitioning.OrderBucketsPartitioner*. Они используют методы с ограниченной видимостью, поэтому должны находиться в пределах пакета org.apache.spark.sql. Эти классы выполняют трансформации RDD, относятся к планам выполнения.
Основное *отличие org.apache.spark.sql.execution.exchange.ShuffleExchangeOrderExec* от оригинала заключается в том, что для семплирования используется RDD, в котором *MutablePair* использует обе части:
* первую - для значений полей секционирования ([P]);
* вторую - для значения поля упорядочивания ([O]).
С моей точки зрения, это уменьшит объём данных для дальнейшей обработки и позволит использовать полученные структуры для других наборов данных. Полученные структуры в любом случае должны быть переданы на драйвер, а затем переданы исполнителям (так работает broadcast), поэтому разумно с самого начала уменьшать их, насколько это возможно.
ShuffleExchangeOrderExec
```
package org.apache.spark.sql.execution.exchange
import org.apache.spark._
import org.apache.spark.rdd.RDD
import org.apache.spark.serializer.Serializer
import org.apache.spark.sql.catalyst.InternalRow
import org.apache.spark.sql.catalyst.errors._
import org.apache.spark.sql.catalyst.expressions.codegen.LazilyGeneratedOrdering
import org.apache.spark.sql.catalyst.expressions.{Attribute, UnsafeProjection}
import org.apache.spark.sql.catalyst.plans.physical._
import org.apache.spark.sql.execution._
import org.apache.spark.sql.execution.metric.{SQLMetric, SQLMetrics}
import org.apache.spark.sql.partitioning.OrderBucketsPartitioner
import org.apache.spark.util.MutablePair
import ru.kalininskii.orderbucketing.OrderAndSortKey
import ru.kalininskii.orderbucketing.plans.physical.OrderBucketsPartitioning
import scala.reflect.ClassTag
/**
* Выполняет shuffle, который описывается newPartitioning
* Код частично заимствован из [[ShuffleExchangeExec]]
*/
case class ShuffleExchangeOrderExec(newPartitioning: OrderBucketsPartitioning,
child: SparkPlan,
partitioner: Option[Partitioner] = None) extends Exchange {
override lazy val metrics: Map[String, SQLMetric] = Map(
"dataSize" -> SQLMetrics.createSizeMetric(sparkContext, "data size"))
override def nodeName: String = "ExchangeWithOrder"
override def outputPartitioning: Partitioning = newPartitioning
private val serializer: Serializer = SparkEnv.get
.serializerManager.getSerializer(implicitly[ClassTag[OrderAndSortKey]],
implicitly[ClassTag[InternalRow]])
override protected def doPrepare(): Unit = {}
/**
* Возвращает зависимость RDD [[ShuffleDependency]], которая перемешает записи
* по схеме, определенной в `newPartitioning`. Партиции RDD, свзязанные с
* возвращенной ShuffleDependency будут входными данными для shuffle.
*/
private[exchange] def prepareShuffleDependency()
: ShuffleDependency[OrderAndSortKey, InternalRow, InternalRow] = {
val rdd = child.execute()
val part: Partitioner = partitioner
.getOrElse(ShuffleExchangeOrderExec.preparePartitioner(rdd, child.output, newPartitioning))
ShuffleExchangeOrderExec.prepareShuffleDependency(rdd, child.output, newPartitioning, serializer, part)
}
/**
* Возвращает [[ShuffledOrderRDD]], а это и есть набор данных после перемешивания.
* [[ShuffledOrderRDD]], как и прочие наследники ShuffledRDD, основан на переданной [[ShuffleDependency]]
*/
private[exchange] def preparePostShuffleRDD(
shuffleDependency
: ShuffleDependency[OrderAndSortKey, InternalRow, InternalRow]
): ShuffledOrderRDD = {
new ShuffledOrderRDD(shuffleDependency)
}
/**
* ShuffledOrderRDD может быть кеширован для переиспользования
*/
private var cachedShuffleRDD: ShuffledOrderRDD = _
protected override def doExecute(): RDD[InternalRow] = attachTree(this, "execute") {
// Returns the same ShuffleRowRDD if this plan is used by multiple plans.
if (cachedShuffleRDD == null) {
cachedShuffleRDD = preparePostShuffleRDD(prepareShuffleDependency())
}
cachedShuffleRDD
}
}
object ShuffleExchangeOrderExec {
def preparePartitioner(rdd: RDD[InternalRow],
outputAttributes: Seq[Attribute],
partitioning: OrderBucketsPartitioning): Partitioner = {
// Internally, ValuesAndRangePartitioner runs a job on the RDD that samples keys to compute
// partition bounds. To get accurate samples, we need to copy the mutable keys.
val rddForSampling = rdd.mapPartitionsInternal { iter =>
val projectionPart = UnsafeProjection.create(partitioning.partitionExpressions, outputAttributes)
val projectionOrder = UnsafeProjection.create(partitioning.orderExpression.child :: Nil, outputAttributes)
val mutablePair = new MutablePair[InternalRow, InternalRow]()
iter.map(row => mutablePair.update(projectionPart(row).copy(), projectionOrder(row).copy()))
}
implicit val ordering: LazilyGeneratedOrdering =
new LazilyGeneratedOrdering(Seq(partitioning.orderExpression),
outputAttributes.filter(_.references equals partitioning.orderExpression.child.references))
new OrderBucketsPartitioner(
rddForSampling,
partitioning.numLines,
partitioning.numPartitions,
partitioning.distribution)
}
private def getPartitionKeyExtractor(outputAttributes: Seq[Attribute],
partitioning: OrderBucketsPartitioning,
i: Int): InternalRow => OrderAndSortKey = {
val projectionPart = UnsafeProjection.create(partitioning.partitionExpressions, outputAttributes)
val projectionOrder = UnsafeProjection.create(partitioning.orderExpression.child :: Nil, outputAttributes)
val projectionSort = UnsafeProjection.create(partitioning.sortExpressions.map(_.child), outputAttributes)
row => (projectionPart(row), projectionOrder(row), projectionSort(row).copy())
}
/**
* Возвращает зависимость RDD [[ShuffleDependency]], которая перемешает записи
* по схеме, определенной в `newPartitioning`. Партиции RDD, свзязанные с
* возвращенной ShuffleDependency будут входными данными для shuffle.
*/
private def prepareShuffleDependency(rdd: RDD[InternalRow],
outputAttributes: Seq[Attribute],
partitioning: OrderBucketsPartitioning,
serializer: Serializer,
part: Partitioner
)
: ShuffleDependency[OrderAndSortKey, InternalRow, InternalRow] = {
val rddWithKeys: RDD[Product2[OrderAndSortKey, InternalRow]] = {
rdd.mapPartitionsWithIndexInternal((i, iter) => {
val mutablePair = new MutablePair[OrderAndSortKey, InternalRow]()
val keyGen = getPartitionKeyExtractor(outputAttributes, partitioning, i)
iter.map { row => mutablePair.update(keyGen(row), row.copy) }
})
}
def keyOrdering[A <: Product3[InternalRow, InternalRow, InternalRow]]: Ordering[A] = {
val allExprs = outputAttributes
.filter(attr => partitioning.sortExpressions.map(_.child.references).contains(attr.references))
implicit val sortOrdering: Ordering[InternalRow] =
new LazilyGeneratedOrdering(partitioning.sortExpressions, allExprs)
Ordering.by(_._3)
}
implicit val order: Ordering[OrderAndSortKey] = keyOrdering
// Now, we manually create a ShuffleDependency.
new ShuffleDependency[OrderAndSortKey, InternalRow, InternalRow](
rddWithKeys,
part,
serializer,
Some(order)
)
}
}
```
Для того, чтобы не менять схему датафрейма и скрыть подробности реализации секционирования и сортировки, используется класс *org.apache.spark.sql.execution.exchange.ShuffledOrderRDD*
ShuffledOrderRDD
```
package org.apache.spark.sql.execution.exchange
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.catalyst.InternalRow
import org.apache.spark.sql.execution.{CoalescedPartitioner, ShuffledRowRDDPartition}
import org.apache.spark._
import ru.kalininskii.orderbucketing.OrderAndSortKey
/**
* Специализированный класс-наследник [[org.apache.spark.rdd.ShuffledRDD]]
* Поддерживает локальную сортировку по указанным полям
*/
class ShuffledOrderRDD(var dependency: ShuffleDependency[OrderAndSortKey, InternalRow, InternalRow])
extends RDD[InternalRow](dependency.rdd.context, Nil) {
private[this] val numPreShufflePartitions = dependency.partitioner.numPartitions
private[this] val partitionStartIndices: Array[Int] = (0 until numPreShufflePartitions).toArray
private[this] val part: Partitioner =
new CoalescedPartitioner(dependency.partitioner, partitionStartIndices)
override def getDependencies: Seq[Dependency[_]] = List(dependency)
override val partitioner: Option[Partitioner] = Some(part)
override def getPartitions: Array[Partition] = {
assert(partitionStartIndices.length == part.numPartitions)
Array.tabulate[Partition](partitionStartIndices.length) { i =>
val startIndex = partitionStartIndices(i)
val endIndex =
if (i < partitionStartIndices.length - 1) {
partitionStartIndices(i + 1)
} else {
numPreShufflePartitions
}
new ShuffledRowRDDPartition(i, startIndex, endIndex)
}
}
override def getPreferredLocations(partition: Partition): Seq[String] = {
val tracker = SparkEnv.get.mapOutputTracker.asInstanceOf[MapOutputTrackerMaster]
val dep = dependencies.head.asInstanceOf[ShuffleDependency[_, _, _]]
tracker.getPreferredLocationsForShuffle(dep, partition.index)
}
override def compute(split: Partition, context: TaskContext): Iterator[InternalRow] = {
val shuffledRowPartition = split.asInstanceOf[ShuffledRowRDDPartition]
// The range of pre-shuffle partitions that we are fetching at here is
// [startPreShufflePartitionIndex, endPreShufflePartitionIndex - 1].
val reader =
SparkEnv.get.shuffleManager.getReader(
dependency.shuffleHandle,
shuffledRowPartition.startPreShufflePartitionIndex,
shuffledRowPartition.endPreShufflePartitionIndex,
context)
reader.read().asInstanceOf[Iterator[Product2[OrderAndSortKey, InternalRow]]].map(_._2)
}
override def clearDependencies() {
super.clearDependencies()
dependency = null
}
}
```
И вот, долгожданный класс, который будет определять границы и отыскивать номер партиции RDD.
Основным полем в нём является **private** **var** *rangeBounds*: Map[P, (Array[O], Int)].
Это карта, ключом которой является InternalRow со значениями полей секционирования, а значением – кортеж из массива верхних границ партиций RDD (тоже InternalRow, но с другим содержимым) и стартового номера партиции для секции (в дальнейшем может называться "смещение").
Сэмплинг производится стандартным способом (RDD.sample), поэтому может упускать значения из маленьких партиций. Напомню, что класс создавался для обработки больших объемов данных, поэтому может неэффективно работать на нескольких десятках или сотнях строк.
Отбор границ также производится в RDD, при этом количество партиций RDD для каждой секции, явной или неявной, определяется динамически на основании собранной информации о количестве строк в сэмпле.
После получения всех отобранных границ, на драйвере выполняется алгоритм со следующими инвариантами:
1. Нулевая партиция резервируется для не вошедших в статистику ключей (секций Hive и неявных секций). В случаях, когда нулевая партиция получает слишком большой объём данных, измените поля явного и неявного секционирования или откажитесь от них полностью;
2. Значения явных и неявных секций могут следовать в неотсортированном порядке, но этот порядок должен был зафиксирован с использованием переменной "смещения". Смещение - это значение типа Int, оно входит в кортежMap[P, (Array[O], *Int*)];
3. Стартовый номер секции – смещение, начинается с одного (см. п.1 – нулевая партиция зарезервирована, и для каждого следующего ключа прирастает на количество границ + 1, что соответствует реальному количеству партиций для секции (см. п.4);
4. Массив значений поля упорядочивания не содержит самой последней верхней границы, это логично, чтобы не создавать всегда пустую дополнительную секцию.
Поиск партиции осуществляется сначала по ключу карты (конкретное значение всех полей секционирования), затем в массиве значений, последовательным или двоичным поиском, в зависимости от длины массива. Все записи, для которых ключ отсутствует в карте, отправляются в нулевую партицию RDD, что может привести к неприемлемо большому объёму этой партиции, если поля явного или неявного партиционирования выбраны неудачно и имеют слишком высокую селективность. В этом случае лучше не секционировать таблицу вообще, оставив только разделение на бакеты по полю упорядочивания.
Выбор границы одной партиции RDD, начиная с прототипа, осуществляется так: значения меньше либо равные верхней границе (она, как мы помним, определена заранее и известна), и больше, чем предыдущая верхняя граница, или предыдущая верхняя граница отсутствует (это первый файл в явной или неявной секции).
Я знаком с концепцией интервального секционирования в Oracle, и между этими двумя реализациями есть отличие в строгости неравенств. В Oracle секции определяются по условию «меньше конкретного значения» и неявному условию «больше или равно предыдущего конкретного значения».
Это связано с тем, что секционирование Oracle работает с конкретными интервалами: для времени это чаще всего сутки, для числовых значений – миллионы или миллиарды и так далее.
Поэтому очень удобно, к примеру, что можно указать для разделения по суткам: values less than ‘2021-12-01 00:00:00’ – при этом видно, что в новую партицию попадёт начало суток (и месяца), а сколь угодно близкое, но меньшее значение будет в партиции, относящейся к ‘2021-11-30’.
В нашем случае дело совсем в другом: пользователь ничего не должен знать об интервалах и файлах, его интересуют только конкретные данные и это задача явного секционирования (первый уровень).
Таким образом, задача разделения интервалов значений – обеспечить примерно равный размер файлов, лёгкость нахождения нужных файлов и совершенно прозрачное взаимодействие, если пользователь обращается напрямую к традиционным структурам. Поэтому границы интервалов определяются «на лету», хранятся в отдельной структуре и сопоставлены с физическими файлами. Каждая секция имеет свой индивидуальный набор границ. Кроме того, укажем на достаточно важный момент: если одну из границ, в нашем случае, верхнюю, мы определяем явно, то другая, нижняя граница не очень важна, но лучше, чтобы её можно было легко найти, если в дальнейшем она будет отсутствовать в карте данных. Для нижней границы это действительно так, потому что значение нужно прочитать из начала файла или из начала сегмента данных, в случае колоночного формата хранения.
OrderBucketsPartitioner
```
package org.apache.spark.sql.partitioning
import java.io.{IOException, ObjectInputStream, ObjectOutputStream}
import org.apache.spark.{Partitioner, SparkEnv}
import org.apache.spark.rdd.RDD
import org.apache.spark.serializer.JavaSerializer
import org.apache.spark.sql.catalyst.InternalRow
import org.apache.spark.util.{CollectionsUtils, Utils}
import scala.collection.mutable.ArrayBuffer
import scala.reflect.ClassTag
import scala.util.hashing.byteswap32
/**
* Наследник [[org.apache.spark.Partitioner]] который разделяет по точным значениям некоторых выражений (полей).
* И интервалов значений одного выражения (поля)
*
* @note The actual number of partitions created by the RangePartitioner might not be the same
* as the `partitions` parameter, in the case where the number of sampled records is less than
* the value of `partitions`.
*/
class OrderBucketsPartitioner[P: ClassTag, O: Ordering : ClassTag
](rdd: RDD[_ <: Product2[P, O]],
val numLines: Int,
val partitions: Int,
val distribution: Option[Seq[(Int, P, Either[(O, Seq[String]), (O, O, Int)])]])
extends Partitioner {
// We allow partitions = 0, which happens when sorting an empty RDD under the default settings.
require(partitions >= 0, s"Number of partitions cannot be negative but found $partitions.")
private var ordering = implicitly[Ordering[O]]
private def getDistribution: Option[Map[P, (Array[O], Int)]] = distribution flatMap {
case Seq() => None
case distr =>
val (inner, outer) = distr.partition(_._3.isLeft)
//внешние границы из распределения.
val (singleFileBounds, manyFileBounds): (Seq[(P, (Int, (O, O, Int)))], Seq[(P, (Int, (O, O, Int)))]) =
outer
.map { case (index, p, right) => (p, (index, right.right.get)) }
.partition { case (_, (_, (_, _, filesNum))) => filesNum == 1 }
//Нужно определить внутренние границы, только для тех, где больше одного файла
val outerBounds: Map[P, Seq[(Int, (O, O, Int))]] = manyFileBounds
.groupBy(_._1)
.map { case (p, values) => p -> values.map(bounds => bounds._2) }
// границы единичных файлов уже определены
val singleBounds: Array[(P, Array[(Int, Array[O])])] = singleFileBounds
.groupBy(_._1)
.map { case (p, values) =>
(p, values.map(bounds => (bounds._2._1, Array(bounds._2._2._2))).toArray) }
.toArray
//внутренние границы получаются из rdd фильтром, сэмплированием, обработкой
val innerBounds: Array[(P, Array[(Int, Array[O])])] =
OrderBucketsPartitioner.getInnerBounds(rdd, numLines, partitions, outerBounds)
//заранее определённые внутренние границы
val givenBounds: Array[(P, Array[(Int, Array[O])])] = inner
.map { case (index, p, left) => (p, (index, Array(left.left.get._1))) }
.groupBy(_._1)
.map { case (p, values) => p -> values.map(bounds => bounds._2).toArray }
.toArray
//теперь оба массива склеиваются, группируются, получаем все границы,
// отсортированные по возрастанию, без самой верхней,
val fixedBounds: Map[P, (Array[O], Int)] = (givenBounds ++ innerBounds ++ singleBounds)
.groupBy(_._1)
.map { case (p, values) =>
val (indexes, bounds) = values.flatMap(_._2).unzip
p -> (bounds.flatten.sorted.init,
indexes.min)
}
Some(fixedBounds)
}
// Карта с массивами верхних границ для первых (partitions - 1) партиций
private var rangeBounds: Map[P, (Array[O], Int)] = getDistribution.getOrElse {
if (partitions <= 1) {
Map.empty[P, (Array[O], Int)]
} else {
val groupedBounds = OrderBucketsPartitioner.getBounds(rdd, numLines, partitions)
//индексы смещений, чтобы обеспечить уникальный номер партиции, если массив границ пустой, то это одна партиция
val overallIndex = groupedBounds.scanLeft(1) { case (sum, (_, orders)) => sum + math.max(orders.length + 1, 1) }
groupedBounds
.zip(overallIndex)
.map { case ((part, orders), index) => (part, (orders, index)) }
.toMap
}
}
def getRangeBounds: Map[P, (Array[O], Int)] = rangeBounds
//весь массив плюс одна нулевая партиция для не попавших в сэмпл тасков
// партиции, не попавшие в сэмплы должны быть небольшими, поэтому ничего страшного не будет
// даже если они попадут в один таск, так будет даже лучше - меньше файлов
def numPartitions: Int = rangeBounds.values.map(_._1.length + 1).sum + 1
private var binarySearch: (Array[O], O) => Int = CollectionsUtils.makeBinarySearch[O]
def getPartition(key: Any): Int = {
val (p, k, _) = key.asInstanceOf[(P, O, InternalRow)]
val (bounds, shift) = rangeBounds.getOrElse(p, (Array.empty[O], 0))
var partition = 0
if (bounds.length < 16) {
// If we have less than 16 partitions naive search
while (partition < bounds.length && ordering.gt(k, bounds(partition))) {
partition += 1
}
} else {
// метод бинарного поиска определён только один раз
partition = binarySearch(bounds, k)
// binarySearch either returns the match location or -[insertion point]-1
if (partition < 0) {
partition = -partition - 1
}
if (partition > bounds.length) {
partition = bounds.length
}
}
shift + partition
}
override def equals(other: Any): Boolean = other match {
case r: OrderBucketsPartitioner[_, _] =>
r.rangeBounds == rangeBounds
case _ =>
false
}
override def hashCode(): Int = {
val prime = 31
var result = 1
var i = 0
val arr = rangeBounds.values.map(_._1).toArray.flatten
while (i < arr.length) {
result = prime * result + arr(i).hashCode()
i += 1
}
result = prime * result
result
}
@throws(classOf[IOException])
private def writeObject(out: ObjectOutputStream): Unit = Utils.tryOrIOException {
val sfactory = SparkEnv.get.serializer
sfactory match {
case _: JavaSerializer => out.defaultWriteObject()
case _ =>
out.writeObject(ordering)
out.writeObject(binarySearch)
val ser = sfactory.newInstance()
Utils.serializeViaNestedStream(out, ser) { stream =>
stream.writeObject(scala.reflect.classTag[Map[P, (Array[O], Int)]])
stream.writeObject(rangeBounds)
}
}
}
@throws(classOf[IOException])
private def readObject(in: ObjectInputStream): Unit = Utils.tryOrIOException {
val sfactory = SparkEnv.get.serializer
sfactory match {
case _: JavaSerializer => in.defaultReadObject()
case _ =>
ordering = in.readObject().asInstanceOf[Ordering[O]]
binarySearch = in.readObject().asInstanceOf[(Array[O], O) => Int]
val ser = sfactory.newInstance()
Utils.deserializeViaNestedStream(in, ser) { ds =>
implicit val classTag: ClassTag[Map[P, (Array[O], Int)]] = ds.readObject[ClassTag[Map[P, (Array[O], Int)]]]()
rangeBounds = ds.readObject[Map[P, (Array[O], Int)]]()
}
}
}
}
object OrderBucketsPartitioner {
/**
* Рассчитывает коэффициент сэмлирования используя обратную логарифмическую пропорцию,
* чем больше набор данных, тем меньше часть, которая будет взята из него
*
* @param numLines - количество записей в файле - опасное предположение, но сделать его можно
* @param numParts - приблизительно оцененное количество партиций
*/
private def getSampleCoefficient(numLines: Int, numParts: Int): Double = {
val numLinesD = numLines.toDouble
(1e4 / (numLinesD * math.log(numLinesD * numParts))) min 1.0
}
/**
* возвращаяет сэмпл RDD
*
* @param rdd - основной набор данных
* @param sampleCoefficient - 0 < коэффициент <= 1.0
*/
private def getSampleRDD[O: Ordering : ClassTag,
P: ClassTag](rdd: RDD[_ <: Product2[P, O]],
sampleCoefficient: Double): RDD[_ <: Product2[P, O]] = {
val sampledRdd: RDD[_ <: Product2[P, O]] = if (sampleCoefficient < 1.0) {
val seed = byteswap32(-rdd.id - 1)
rdd.sample(withReplacement = false, sampleCoefficient, seed)
} else {
rdd
}
sampledRdd
}
/**
* выполняется в каждой партиции сэмлпа RDD
* получает верхние границы для каждого файла (таска, партиции RDD)
*
* @param iter неотсортированный итератор со значениями партиций и поля упорядочивания
* @param initStep шаг, равный желаемому количеству записей в одном файле
* @param weight количество реальных записей на строку сэмпла
* @return границы
*/
private def determineBoundsWithinPartition[P: ClassTag, O: Ordering : ClassTag
](iter: Iterator[(P, O)],
weight: Double,
initStep: Int): Iterator[(P, Array[O])] = {
prepareMap(iter)
.map { case (p, ordered) =>
val partitions: Int = math.ceil(ordered.length * weight / initStep).intValue()
val bounds: Array[O] = extractBounds(ordered, partitions, weight)
(p, bounds)
}.iterator
}
private def prepareMap[O: Ordering : ClassTag, P: ClassTag](iter: Iterator[(P, O)]): Map[P, Array[O]] = {
val mappedParts = iter.toArray
.groupBy(_._1)
.map { case (p, opArray) => (p, opArray.map(_._2).sorted) }
mappedParts
}
//отбор самих значений
private def extractBounds[O: Ordering : ClassTag](values: Array[O],
partitions: Int,
weight: Double)(implicit ordering: Ordering[O]): Array[O] = {
val numCandidates = values.length
val partCount = numCandidates * weight
var cumWeight = 0.0
val step: Int = (partCount / partitions).intValue()
var target = step
val innerBounds = ArrayBuffer.empty[O]
var i = 0
var j = 0
var prevInnerBound = Option.empty[O]
while ((i < numCandidates) && (j < partitions - 1)) {
val key = values(i)
cumWeight += weight
if (cumWeight >= target) {
// Skip duplicate values.
if (prevInnerBound.isEmpty || ordering.gt(key, prevInnerBound.get)) {
innerBounds += key
target += step
j += 1
prevInnerBound = Some(key)
}
}
i += 1
}
innerBounds.toArray
}
/**
* сэмплирует RDD и получает карту, где ключи - значения полей партиционирования,
* значения - массивы с верхними границами поля упорядочивания
*
* @param rdd основной набор данных
* @param numLines желаемое количество записей в одном файле
* @param numParts предполагаемое количество записей
* @return границы
*/
private def getBounds[P: ClassTag, O: Ordering : ClassTag](rdd: RDD[_ <: Product2[P, O]],
numLines: Int,
numParts: Int): Array[(P, Array[O])] = {
val sampleCoefficient = getSampleCoefficient(numLines, numParts) //rdd.partitions.length
val sampledRdd: RDD[_ <: Product2[P, O]] = getSampleRDD(rdd, sampleCoefficient)
val weight = 1.0 / sampleCoefficient
sampledRdd
.map(row => (row._1, row._2))
.partitionBy(new Partitioner {
override def numPartitions: Int = numParts
override def getPartition(key: Any): Int = Utils.nonNegativeMod(key.hashCode, numParts)
})
.mapPartitions(iter => determineBoundsWithinPartition(iter, weight, numLines))
.collect()
}
/**
* фильтрует RDD на равенство полей к нужным значениям и по нахождению в пределах внешних границ
*
* @param rdd основной набор данных
* @param bounds границы RDD
* @return тщательно отфильтрованный RDD
*/
private def filterRDDByOuterBounds[P: ClassTag, O: Ordering : ClassTag
](rdd: RDD[_ <: Product2[P, O]],
bounds: Map[P, Seq[(Int, (O, O, Int))]]): RDD[_ <: Product2[P, O]] = {
val ordering = implicitly[Ordering[O]]
//получаем Option[Array[Tuple3]] и проверяем exists
rdd
.filter { item =>
bounds
.get(item._1)
.exists(_.exists(b => ordering.lteq(b._2._1, item._2) && ordering.lteq(item._2, b._2._2)))
}
}
/**
* выполняется в каждой партиции сэмлпа RDD
* получает верхние границы для каждого файла (таска, партиции RDD)
*
* @param iter неотсортированный итератор со значениями партиций и поля упорядочивания
* @param initStep шаг, равный желаемому количеству записей в одном файле
* @param weight количество реальных записей на строку сэмпла
* @return границы
*/
private def determineInnerBoundsWithinPartition[P: ClassTag, O: Ordering : ClassTag
](iter: Iterator[(P, O)],
weight: Double,
initStep: Int,
outerBounds: Map[P, Seq[(Int, (O, O, Int))]]): Iterator[(P, Array[(Int, Array[O])])] = {
val ordering = implicitly[Ordering[O]]
prepareMap(iter)
.map { case (p, orderedValues) =>
(p, outerBounds(p).toArray.map { case (index, (lowerO, upperO, partitions)) =>
val ordered = orderedValues
.dropWhile(ordering.lt(_, lowerO))
.takeWhile(ordering.lteq(_, upperO))
val innerBounds: Array[O] = extractBounds(ordered, partitions, weight)
(index, innerBounds :+ upperO)
})
}.iterator
}
/**
* сэмплирует RDD и получает карту, где ключи - значения полей партиционирования,
* значения - массивы с верхними границами поля упорядочивания
* Важно, чтобы можно было использовать верхние границы в пределах партиции,
* чтобы не допустить поглощения возможных внутренних партиций
*
* @param rdd основной набор данных
* @param numLines желаемое количество записей в одном файле
* @param numParts предполагаемое количество записей
* @param bounds внешние границы RDD
* @return границы
*/
private def getInnerBounds[P: ClassTag, O: Ordering : ClassTag](rdd: RDD[_ <: Product2[P, O]],
numLines: Int,
numParts: Int,
bounds: Map[P, Seq[(Int, (O, O, Int))]]
): Array[(P, Array[(Int, Array[O])])] = {
val sampleCoefficient = getSampleCoefficient(numLines, numParts) //rdd.partitions.length
val filterRdd: RDD[_ <: Product2[P, O]] = filterRDDByOuterBounds(rdd, bounds)
val sampledRdd: RDD[_ <: Product2[P, O]] = getSampleRDD(filterRdd, sampleCoefficient)
val weight = 1.0 / sampleCoefficient
sampledRdd
.map(row => (row._1, row._2))
.partitionBy(new Partitioner {
override def numPartitions: Int = numParts
override def getPartition(key: Any): Int = Utils.nonNegativeMod(key.hashCode, bounds.size)
})
.mapPartitions(iter => determineInnerBoundsWithinPartition(iter, weight, numLines, bounds))
.collect()
}
}
```
Чтобы связать физический план и само выполнение, нам нужно будет создать объект, расширяющий SparkStrategy.
RepartitionStrategy
```
package ru.kalininskii.rangebucketing.strategy
import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan
import org.apache.spark.sql.execution.{SparkPlan, SparkStrategy, exchange}
import ru.kalininskii.rangebucketing.plans.logical.RepartitionByRangeBuckets
object RepartitionStrategy extends SparkStrategy {
override def apply(plan: LogicalPlan): Seq[SparkPlan] = plan match {
case r: RepartitionByRangeBuckets =>
exchange.ShuffleExchangeBucketsExec(r.partitioning, planLater(r.child)) :: Nil
case _ => Nil
}
}
```
Теперь можно сделать инъекцию расширения в SparkSession:
Extension injection
```
spark = SparkSession
.builder()
.appName("PARTITION_TEST")
.master("local[*]")
.config(sparkConf)
.withExtensions(e => {
e.injectPlannerStrategy(_ => RepartitionStrategy)
})
.getOrCreate()
```
Если инъекции или способа реализации партишенера не будет, то мы увидим такую ошибку:
Сообщение об ошибке
```
assertion failed: No plan for RepartitionWithOrderAndSort [ts_part#55], id#13 ASC NULLS FIRST, 4000, 24
+- Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, substring(cast(ts#18 as string), 0, 10) AS ts_part#55]
+- InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18], StorageLevel(disk, memory, deserialized, 1 replicas)
+- LocalTableScan [id#13, name#14, amount#15, value#16, divider#17, ts#18]
java.lang.AssertionError: assertion failed: No plan for RepartitionWithOrderAndSort [ts_part#55], id#13 ASC NULLS FIRST, 4000, 24
+- Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, substring(cast(ts#18 as string), 0, 10) AS ts_part#55]
+- InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18], StorageLevel(disk, memory, deserialized, 1 replicas)
+- LocalTableScan [id#13, name#14, amount#15, value#16, divider#17, ts#18]
at scala.Predef$.assert(Predef.scala:170)
at org.apache.spark.sql.catalyst.planning.QueryPlanner.plan(QueryPlanner.scala:93)
at org.apache.spark.sql.catalyst.planning.QueryPlanner$$anonfun$2$$anonfun$apply$2.apply(QueryPlanner.scala:78)
at org.apache.spark.sql.catalyst.planning.QueryPlanner$$anonfun$2$$anonfun$apply$2.apply(QueryPlanner.scala:75)
at scala.collection.TraversableOnce$$anonfun$foldLeft$1.apply(TraversableOnce.scala:157)
at scala.collection.TraversableOnce$$anonfun$foldLeft$1.apply(TraversableOnce.scala:157)
at scala.collection.Iterator$class.foreach(Iterator.scala:891)
at scala.collection.AbstractIterator.foreach(Iterator.scala:1334)
at scala.collection.TraversableOnce$class.foldLeft(TraversableOnce.scala:157)
at scala.collection.AbstractIterator.foldLeft(Iterator.scala:1334)
at org.apache.spark.sql.catalyst.planning.QueryPlanner$$anonfun$2.apply(QueryPlanner.scala:75)
at org.apache.spark.sql.catalyst.planning.QueryPlanner$$anonfun$2.apply(QueryPlanner.scala:67)
at scala.collection.Iterator$$anon$12.nextCur(Iterator.scala:435)
at scala.collection.Iterator$$anon$12.hasNext(Iterator.scala:441)
at org.apache.spark.sql.catalyst.planning.QueryPlanner.plan(QueryPlanner.scala:93)
at org.apache.spark.sql.execution.QueryExecution.sparkPlan$lzycompute(QueryExecution.scala:72)
at org.apache.spark.sql.execution.QueryExecution.sparkPlan(QueryExecution.scala:68)
at org.apache.spark.sql.execution.QueryExecution.executedPlan$lzycompute(QueryExecution.scala:77)
at org.apache.spark.sql.execution.QueryExecution.executedPlan(QueryExecution.scala:77)
at org.apache.spark.sql.execution.QueryExecution$$anonfun$toString$3.apply(QueryExecution.scala:207)
at org.apache.spark.sql.execution.QueryExecution$$anonfun$toString$3.apply(QueryExecution.scala:207)
at org.apache.spark.sql.execution.QueryExecution.stringOrError(QueryExecution.scala:99)
at org.apache.spark.sql.execution.QueryExecution.toString(QueryExecution.scala:207)
at org.apache.spark.sql.execution.command.ExplainCommand.run(commands.scala:167)
at org.apache.spark.sql.execution.command.ExecutedCommandExec.sideEffectResult$lzycompute(commands.scala:70)
at org.apache.spark.sql.execution.command.ExecutedCommandExec.sideEffectResult(commands.scala:68)
at org.apache.spark.sql.execution.command.ExecutedCommandExec.executeCollect(commands.scala:79)
at org.apache.spark.sql.Dataset.explain(Dataset.scala:485)
at ru.kalininskii.rangebucketing.RangeBucketingPartitionTest$$anonfun$1.apply(RangeBucketingPartitionTest.scala:49)
at ru.kalininskii.rangebucketing.RangeBucketingPartitionTest$$anonfun$1.apply(RangeBucketingPartitionTest.scala:42)
```
*Сгенерируем набор данных с псевдослучайными значениями и применим к нему созданный партишенер*:
Датафрейм
```
val dataFrameSource = getRandomDF(0, rangeLimit, 3, 0).persist()
.withColumn("ts_part", fn.expr("substring(ts,0,10)"))
dataFrameSource.printSchema()
val dfRep = dataFrameSource
.repartitionWithOrderAndSort(numLines, rangeLimit / numLines,
fn.col("event_time"), List(fn.col("ts_part")), List(fn.col("id")))
.persist()
dfRep.explain(true)
```
В планах выполнения видны новые пункты, на всех этапах их можно отследить
План запроса с применением партишенера
```
== Parsed Logical Plan ==
'Repartition with unknown distribution: ['ts_part], 'id ASC NULLS FIRST, 4000, 24
+- 'Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, 'substring('ts, 0, 10) AS ts_part#55]
+- Project [_1#6 AS id#13, _2#7 AS name#14, _3#8 AS amount#15, _4#9 AS value#16, _5#10 AS divider#17, _6#11 AS ts#18]
+- LocalRelation [_1#6, _2#7, _3#8, _4#9, _5#10, _6#11]
== Analyzed Logical Plan ==
id: int, name: string, amount: decimal(38,18), value: decimal(38,18), divider: string, ts: timestamp, ts_part: string
Repartition with unknown distribution: [ts_part#55], id#13 ASC NULLS FIRST, 4000, 24
+- Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, substring(cast(ts#18 as string), 0, 10) AS ts_part#55]
+- Project [_1#6 AS id#13, _2#7 AS name#14, _3#8 AS amount#15, _4#9 AS value#16, _5#10 AS divider#17, _6#11 AS ts#18]
+- LocalRelation [_1#6, _2#7, _3#8, _4#9, _5#10, _6#11]
== Optimized Logical Plan ==
InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18, ts_part#55], StorageLevel(disk, memory, deserialized, 1 replicas)
+- ExchangeByRangeBuckets repartition with unknown distribution:(ts_part#55, id#13 ASC NULLS FIRST, 4000, 24, None)
+- *(1) Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, substring(cast(ts#18 as string), 0, 10) AS ts_part#55]
+- InMemoryTableScan [amount#15, divider#17, id#13, name#14, ts#18, value#16]
+- InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18], StorageLevel(disk, memory, deserialized, 1 replicas)
+- LocalTableScan [id#13, name#14, amount#15, value#16, divider#17, ts#18]
== Physical Plan ==
InMemoryTableScan [id#13, name#14, amount#15, value#16, divider#17, ts#18, ts_part#55]
+- InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18, ts_part#55], StorageLevel(disk, memory, deserialized, 1 replicas)
+- ExchangeByRangeBuckets repartition with unknown distribution:(ts_part#55, id#13 ASC NULLS FIRST, 4000, 24, None)
+- *(1) Project [id#13, name#14, amount#15, value#16, divider#17, ts#18, substring(cast(ts#18 as string), 0, 10) AS ts_part#55]
+- InMemoryTableScan [amount#15, divider#17, id#13, name#14, ts#18, value#16]
+- InMemoryRelation [id#13, name#14, amount#15, value#16, divider#17, ts#18], StorageLevel(disk, memory, deserialized, 1 replicas)
+- LocalTableScan [id#13, name#14, amount#15, value#16, divider#17, ts#18]
```
Тесты должны показать, что классы планов на самом деле используются (простые юнит-тесты планов Spark):
Использование классов
```
val logicalPlanString = "Repartition plan with unknown distribution: " +
"partition by ['ts_part], " +
"global order by 'event_time, " +
"local sort by ['id], " +
"4000 rows per task, 24 initial tasks"
val analyzedPlanString = "Repartition plan with unknown distribution: " +
"partition by [ts_part#64], " +
"global order by event_time#21, " +
"local sort by [id#15], " +
"4000 rows per task, 24 initial tasks"
val sparkPlanString = "ExchangeWithOrder Repartition with unknown distribution: " +
"partition by [ts_part#64], " +
"global order by event_time#21, " +
"local sort by [id#15], " +
"4000 rows per task, 24 initial tasks"
assert(dfRep.queryExecution.logical.toString contains logicalPlanString)
assert(dfRep.queryExecution.analyzed.toString contains analyzedPlanString)
assert(dfRep.queryExecution.sparkPlan.toString contains sparkPlanString)
```
Количество секций всегда будет равно 28
Количество партиций RDD
```
println(dfRep.rdd.getNumPartitions)
28
dfRep.rdd.getNumPartitions should be(28)
```
Выведем датафрейм с номерами партиций, нулевая партиция должна отсутствовать, потому что не содержит ни одного значения. Количество – колонка «cnt\_» - всегда немного меньше и количество достаточно равномерное, отклонение, как правило, остаётся в пределах пяти процентов.
Количество записей в партициях RDD
```
+----------+-----------+-----------------------+-----------------------+----+
|ts_part |rdd_part_id|range_min_event_time |range_max_event_time |cnt_|
+----------+-----------+-----------------------+-----------------------+----+
|2021-09-05|10 |2021-09-05 21:57:56.186|2021-09-05 21:57:56.454|3672|
|2021-09-05|11 |2021-09-05 21:57:56.455|2021-09-05 21:57:56.547|3400|
|2021-09-05|12 |2021-09-05 21:57:56.548|2021-09-05 21:57:56.642|3761|
|2021-09-05|13 |2021-09-05 21:57:56.643|2021-09-06 21:57:56.447|3601|
|2021-09-05|14 |2021-09-06 21:57:56.448|2021-09-06 21:57:56.544|3601|
|2021-09-05|15 |2021-09-06 21:57:56.545|2021-09-06 21:57:56.641|3856|
|2021-09-05|16 |2021-09-06 21:57:56.642|2021-09-07 21:57:56.449|3711|
|2021-09-05|17 |2021-09-07 21:57:56.45 |2021-09-07 21:57:56.549|3703|
|2021-09-05|18 |2021-09-07 21:57:56.55 |2021-09-07 21:57:56.647|3776|
|2021-09-06|19 |2021-09-05 21:57:56.186|2021-09-05 21:57:56.454|3763|
|2021-09-06|20 |2021-09-05 21:57:56.455|2021-09-05 21:57:56.564|3916|
|2021-09-06|21 |2021-09-05 21:57:56.565|2021-09-06 21:57:56.241|3557|
|2021-09-06|22 |2021-09-06 21:57:56.242|2021-09-06 21:57:56.459|3721|
|2021-09-06|23 |2021-09-06 21:57:56.46 |2021-09-06 21:57:56.563|3714|
|2021-09-06|24 |2021-09-06 21:57:56.564|2021-09-07 21:57:56.246|3520|
|2021-09-06|25 |2021-09-07 21:57:56.247|2021-09-07 21:57:56.455|3671|
|2021-09-06|26 |2021-09-07 21:57:56.456|2021-09-07 21:57:56.556|3716|
|2021-09-06|27 |2021-09-07 21:57:56.557|2021-09-07 21:57:56.647|3670|
|2021-09-07|1 |2021-09-05 21:57:56.188|2021-09-05 21:57:56.454|3690|
|2021-09-07|2 |2021-09-05 21:57:56.455|2021-09-05 21:57:56.556|3704|
|2021-09-07|3 |2021-09-05 21:57:56.557|2021-09-05 21:57:56.644|3601|
|2021-09-07|4 |2021-09-05 21:57:56.645|2021-09-06 21:57:56.45 |3685|
|2021-09-07|5 |2021-09-06 21:57:56.451|2021-09-06 21:57:56.55 |3767|
|2021-09-07|6 |2021-09-06 21:57:56.551|2021-09-06 21:57:56.644|3846|
|2021-09-07|7 |2021-09-06 21:57:56.645|2021-09-07 21:57:56.452|3782|
|2021-09-07|8 |2021-09-07 21:57:56.453|2021-09-07 21:57:56.555|3775|
|2021-09-07|9 |2021-09-07 21:57:56.556|2021-09-07 21:57:56.647|3820|
+----------+-----------+-----------------------+-----------------------+----+
```
Сохраним и выведем, чтобы убедиться, что все файлы соответствуют исходными секциям
Проверка соответствия
```
dfRep
.withColumn("rdd_part_id", fn.spark_partition_id())
.groupBy(fn.col("ts_part") as "ts_part", fn.col("rdd_part_id"))
.agg(fn.min("event_time") as "range_min_event_time",
fn.max("event_time") as "range_max_event_time",
fn.count(fn.lit(0)) as "cnt_")
.orderBy("ts_part", "rdd_part_id")
.show(100, false)
dfRep
.sortWithinPartitions(fn.col("id"))
.write
.mode(SaveMode.Overwrite)
.partitionBy("ts_part")
.format("parquet")
.option("path", "/test/pa/sometable/snp")
.saveAsTable("testschema.sometable")
val dfT = spark.table("testschema.sometable")
println(dfT.count)
dfT
.withColumn("file_name",
fn.regexp_replace(fn.input_file_name(), ".*/test/pa/sometable/snp", ""))
.groupBy(fn.col("ts_part") as "ts_part", fn.col("file_name"))
.agg(fn.min("event_time") as "range_min_event_time",
fn.max("event_time") as "range_max_event_time",
fn.count(fn.lit(0)) as "cnt_")
.orderBy("file_name")
.show(100, false)
```
```
+----------+---------------------------------------------------------------------------------------+-----------------------+-----------------------+----+
|ts_part |file_name |range_min_event_time |range_max_event_time |cnt_|
+----------+---------------------------------------------------------------------------------------+-----------------------+-----------------------+----+
|2021-09-05|/ts_part=2021-09-05/part-00010-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.186|2021-09-05 21:57:56.454|3672|
|2021-09-05|/ts_part=2021-09-05/part-00011-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.455|2021-09-05 21:57:56.547|3400|
|2021-09-05|/ts_part=2021-09-05/part-00012-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.548|2021-09-05 21:57:56.642|3761|
|2021-09-05|/ts_part=2021-09-05/part-00013-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.643|2021-09-06 21:57:56.447|3601|
|2021-09-05|/ts_part=2021-09-05/part-00014-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.448|2021-09-06 21:57:56.544|3601|
|2021-09-05|/ts_part=2021-09-05/part-00015-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.545|2021-09-06 21:57:56.641|3856|
|2021-09-05|/ts_part=2021-09-05/part-00016-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.642|2021-09-07 21:57:56.449|3711|
|2021-09-05|/ts_part=2021-09-05/part-00017-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.45 |2021-09-07 21:57:56.549|3703|
|2021-09-05|/ts_part=2021-09-05/part-00018-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.55 |2021-09-07 21:57:56.647|3776|
|2021-09-06|/ts_part=2021-09-06/part-00019-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.186|2021-09-05 21:57:56.454|3763|
|2021-09-06|/ts_part=2021-09-06/part-00020-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.455|2021-09-05 21:57:56.564|3916|
|2021-09-06|/ts_part=2021-09-06/part-00021-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.565|2021-09-06 21:57:56.241|3557|
|2021-09-06|/ts_part=2021-09-06/part-00022-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.242|2021-09-06 21:57:56.459|3721|
|2021-09-06|/ts_part=2021-09-06/part-00023-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.46 |2021-09-06 21:57:56.563|3714|
|2021-09-06|/ts_part=2021-09-06/part-00024-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.564|2021-09-07 21:57:56.246|3520|
|2021-09-06|/ts_part=2021-09-06/part-00025-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.247|2021-09-07 21:57:56.455|3671|
|2021-09-06|/ts_part=2021-09-06/part-00026-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.456|2021-09-07 21:57:56.556|3716|
|2021-09-06|/ts_part=2021-09-06/part-00027-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.557|2021-09-07 21:57:56.647|3670|
|2021-09-07|/ts_part=2021-09-07/part-00001-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.188|2021-09-05 21:57:56.454|3690|
|2021-09-07|/ts_part=2021-09-07/part-00002-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.455|2021-09-05 21:57:56.556|3704|
|2021-09-07|/ts_part=2021-09-07/part-00003-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.557|2021-09-05 21:57:56.644|3601|
|2021-09-07|/ts_part=2021-09-07/part-00004-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-05 21:57:56.645|2021-09-06 21:57:56.45 |3685|
|2021-09-07|/ts_part=2021-09-07/part-00005-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.451|2021-09-06 21:57:56.55 |3767|
|2021-09-07|/ts_part=2021-09-07/part-00006-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.551|2021-09-06 21:57:56.644|3846|
|2021-09-07|/ts_part=2021-09-07/part-00007-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-06 21:57:56.645|2021-09-07 21:57:56.452|3782|
|2021-09-07|/ts_part=2021-09-07/part-00008-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.453|2021-09-07 21:57:56.555|3775|
|2021-09-07|/ts_part=2021-09-07/part-00009-28321a07-711d-4936-b305-680199f90649.c000.snappy.parquet|2021-09-07 21:57:56.556|2021-09-07 21:57:56.647|3820|
+----------+---------------------------------------------------------------------------------------+-----------------------+-----------------------+----+
```
Как видим, интервалы сохранились, для этого не потребовалось никаких дополнительных действий. Количество файлов для этого случая всегда на один меньше, чем количество секций в RDD. Однако в общем случае это не так, ведь в нулевую секцию могут попасть данные из очень небольших физических партиций. dfT.inputFiles.length should *be*(dfRep.*rdd*.getNumPartitions - 1)
Количество записей осталось прежним:
Количество записей в сохраненных файлах
```
val savedCount = dfT.count
savedCount shouldEqual rangeLimit
```
И схема датафрейма не изменилась, партишенер не меняет порядок полей и их типы.
Схемы совпадают
```
dfT.printSchema()
```
```
root
|-- id: integer (nullable = true)
|-- name: string (nullable = true)
|-- amount: decimal(38,18) (nullable = true)
|-- value: decimal(38,18) (nullable = true)
|-- divider: string (nullable = true)
|-- ts: timestamp (nullable = true)
|-- event_time: timestamp (nullable = true)
|-- ts_part: string (nullable = true)
```
```
dfT.schema should be (dataFrameSource.schema)
```
Для того, чтобы убедиться, что сортировка работает, выведем все записи с "id" меньшим 32, без дополнительной сортировки. Мы увидим, что в пределах файла записи отсортированы по возрастанию поля "id", несмотря на то, что были специально перемешаны при создании датафрейма.
Проверка локальной сортировки
```
dfT
.withColumn("file_name",
fn.regexp_replace(fn.input_file_name(), ".*/test/pa/sometable/snp", ""))
.select("id", "file_name")
.where("id < 32")
.show(32, false)
```
```
+---+---------------------------------------------------------------------------------------+
|id |file_name |
+---+---------------------------------------------------------------------------------------+
|9 |/ts_part=2021-09-06/part-00022-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|15 |/ts_part=2021-09-06/part-00022-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|19 |/ts_part=2021-09-06/part-00022-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|25 |/ts_part=2021-09-07/part-00004-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|4 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|13 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|14 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|16 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|28 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|31 |/ts_part=2021-09-07/part-00006-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|8 |/ts_part=2021-09-05/part-00012-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|12 |/ts_part=2021-09-05/part-00012-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|21 |/ts_part=2021-09-05/part-00012-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|30 |/ts_part=2021-09-05/part-00012-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|10 |/ts_part=2021-09-05/part-00015-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|27 |/ts_part=2021-09-05/part-00015-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|0 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|1 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|3 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|20 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|22 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|26 |/ts_part=2021-09-06/part-00024-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|18 |/ts_part=2021-09-07/part-00001-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|5 |/ts_part=2021-09-05/part-00010-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|6 |/ts_part=2021-09-05/part-00010-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|23 |/ts_part=2021-09-05/part-00010-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|24 |/ts_part=2021-09-05/part-00010-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|29 |/ts_part=2021-09-05/part-00010-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|2 |/ts_part=2021-09-06/part-00019-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|7 |/ts_part=2021-09-06/part-00019-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|11 |/ts_part=2021-09-06/part-00019-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
|17 |/ts_part=2021-09-06/part-00019-ec8ffbb5-474a-4ce1-bcdb-cc5665800031.c000.snappy.parquet|
+---+---------------------------------------------------------------------------------------+
```
Добавлю полные тестовые классы и pom.xml для сборки Maven:
Тесты
```
package ru.kalininskii.orderbucketing
import java.sql.Timestamp
import java.time.LocalDateTime
import org.apache.spark.sql.{SaveMode, functions => fn}
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers._
import ru.kalininskii.orderbucketing.OrderBucketing._
import scala.util.Random
class OrderPartitionTest extends AnyFlatSpec with SparkBuilder {
val rangeLimit = 99999
val seed = 111
val numLines = 4000
private def getRandomDF(start: Int, limit: Int, days: Int, daysMinus: Int) = {
val rnd = new Random()
rnd.setSeed(seed)
val sparkSession = spark
import sparkSession.implicits._
val list = Range(start, limit)
.toList
.map(id => (Option(id), //id, Option для nullable = true
rnd.alphanumeric.take(rnd.nextInt(32)).mkString, //name
BigDecimal(rnd.nextInt().abs * rnd.nextDouble()), //amount
BigDecimal(rnd.nextLong().abs.longValue()), //value
rnd.alphanumeric.take(rnd.nextInt(3)).mkString, //divider
Timestamp.valueOf(LocalDateTime.now().minusSeconds((rnd.nextInt(days).abs max daysMinus) * 24 * 60 * 60)), //ts
Timestamp.valueOf(LocalDateTime.now().minusSeconds((rnd.nextInt(days).abs max daysMinus) * 24 * 60 * 60)) //event_time
))
Random.shuffle(list).toDF("id", "name", "amount", "value", "divider", "ts", "event_time")
}
override def beforeAll() {
super.beforeAll()
spark.sql("create database if not exists testschema location '/test'")
}
"Range buckets partitioner" must "partition correctly" in {
val dataFrameSource = getRandomDF(0, rangeLimit, 3, 0).persist()
.withColumn("ts_part", fn.expr("substring(ts,0,10)"))
dataFrameSource.printSchema()
val dfRep = dataFrameSource
.repartitionWithOrderAndSort(numLines, rangeLimit / numLines,
fn.col("event_time"), List(fn.col("ts_part")), List(fn.col("id")))
.persist()
dfRep.explain(true)
val logicalPlanString = "Repartition plan with unknown distribution: " +
"partition by ['ts_part], " +
"global order by 'event_time, " +
"local sort by ['id], " +
"4000 rows per task, 24 initial tasks"
val analyzedPlanString = "Repartition plan with unknown distribution: " +
"partition by [ts_part#64], " +
"global order by event_time#21, " +
"local sort by [id#15], " +
"4000 rows per task, 24 initial tasks"
val sparkPlanString = "ExchangeWithOrder Repartition with unknown distribution: " +
"partition by [ts_part#64], " +
"global order by event_time#21, " +
"local sort by [id#15], " +
"4000 rows per task, 24 initial tasks"
assert(dfRep.queryExecution.logical.toString contains logicalPlanString)
assert(dfRep.queryExecution.analyzed.toString contains analyzedPlanString)
assert(dfRep.queryExecution.sparkPlan.toString contains sparkPlanString)
println(dfRep.rdd.getNumPartitions)
dfRep.rdd.getNumPartitions should be(28)
dfRep
.withColumn("rdd_part_id", fn.spark_partition_id())
.groupBy(fn.col("ts_part") as "ts_part", fn.col("rdd_part_id"))
.agg(fn.min("event_time") as "range_min_event_time",
fn.max("event_time") as "range_max_event_time",
fn.count(fn.lit(0)) as "cnt_")
.orderBy("ts_part", "rdd_part_id")
.show(100, false)
dfRep
.sortWithinPartitions(fn.col("id"))
.write
.mode(SaveMode.Overwrite)
.partitionBy("ts_part")
.format("parquet")
.option("path", "/test/pa/sometable/snp")
.saveAsTable("testschema.sometable")
val dfT = spark.table("testschema.sometable")
val savedCount = dfT.count
savedCount shouldEqual rangeLimit
dfT
.withColumn("file_name",
fn.regexp_replace(fn.input_file_name(), ".*/test/pa/sometable/snp", ""))
.groupBy(fn.col("ts_part") as "ts_part", fn.col("file_name"))
.agg(fn.min("event_time") as "range_min_event_time",
fn.max("event_time") as "range_max_event_time",
fn.count(fn.lit(0)) as "cnt_")
.orderBy("file_name")
.show(100, false)
dfT.printSchema()
dfT.inputFiles.length should be(dfRep.rdd.getNumPartitions - 1)
dfT.schema should be(dataFrameSource.schema)
dfT
.withColumn("file_name",
fn.regexp_replace(fn.input_file_name(), ".*/test/pa/sometable/snp", ""))
.select("id", "file_name")
.where("id < 32")
.show(32, false)
}
}
```
Создание Hadoop Minicluster для тестов
```
package ru.kalininskii.orderbucketing
import java.io.File
import java.nio.file.Files
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs.FileUtil
import org.apache.hadoop.hdfs.MiniDFSCluster
import org.apache.log4j.{Level, Logger}
import org.scalatest.{BeforeAndAfterAll, TestSuite}
trait MiniHdfsBuilder extends BeforeAndAfterAll {
this: TestSuite =>
val baseDir: File = Files.createTempDirectory("test_hdfs").toFile.getAbsoluteFile
val fsConf: Configuration = new Configuration()
fsConf.set(MiniDFSCluster.HDFS_MINIDFS_BASEDIR, baseDir.getAbsolutePath)
val builder: MiniDFSCluster.Builder = new MiniDFSCluster.Builder(fsConf)
var hdfsCluster: MiniDFSCluster = _
override def beforeAll() {
super.beforeAll()
Logger.getLogger("org.apache.hadoop").setLevel(Level.WARN)
Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
Logger.getLogger("org.spark_project.jetty.server").setLevel(Level.WARN)
hdfsCluster = builder.build()
}
override def afterAll() {
try {
super.afterAll()
}
finally {
hdfsCluster.shutdown()
FileUtil.fullyDelete(baseDir)
}
}
}
```
Создание SparkSession для тестов
```
package ru.kalininskii.orderbucketing
import java.io.File
import org.apache.hadoop.fs.FileUtil
import org.apache.hadoop.hdfs.DistributedFileSystem
import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession
import org.scalatest.TestSuite
import ru.kalininskii.orderbucketing.strategy.RepartitionStrategy
trait SparkBuilder extends MiniHdfsBuilder {
this: TestSuite =>
var fileSystem: DistributedFileSystem = _
var spark: SparkSession = _
override def beforeAll() {
super.beforeAll()
//сессия уже может быть создана, поэтому нужно попробовать ее найти и остановить
spark = SparkSession
.builder()
.appName("DUMMY")
.master("local[*]")
.getOrCreate()
spark.stop()
fileSystem = hdfsCluster.getFileSystem()
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RANGE BUCKET TEST")
sparkConf.set("fs.defaultFS", fileSystem.getUri.toString)
spark = SparkSession
.builder()
.appName("PARTITION_TEST")
.master("local[*]")
.config(sparkConf)
.withExtensions(e => {
e.injectPlannerStrategy(_ => RepartitionStrategy)
})
.getOrCreate()
spark.sparkContext.setLogLevel("WARN")
}
override def afterAll(): Unit = {
spark.stop()
FileUtil.fullyDelete(new File("./metastore_db"))
FileUtil.fullyDelete(new File("./spark-warehouse"))
FileUtil.fullyDelete(new File("./derby.log"))
FileUtil.fullyDelete(new File("./chk"))
super.afterAll()
}
}
```
pom.xml для Maven
```
xml version="1.0" encoding="UTF-8"?
4.0.0
fine-grained
range-bucketing
0.1-SNAPSHOT
2.4.0
3.1.1
2.11.8
1.8
1.8
UTF-8
org.apache.spark
spark-core\_2.11
${spark.version}
provided
org.apache.spark
spark-sql\_2.11
${spark.version}
provided
org.scala-lang
scala-library
${scala.version}
provided
org.apache.hadoop
hadoop-minicluster
${hadoop.version}
test
org.apache.spark
spark-hive\_2.11
${spark.version}
test
org.scalatest
scalatest\_2.11
3.1.1
test
org.scalactic
scalactic\_2.11
3.1.1
test
src/main/scala
${project.artifactId}
org.apache.maven.plugins
maven-help-plugin
3.2.0
show-profiles
compile
active-profiles
org.apache.maven.plugins
maven-jar-plugin
3.2.0
true
true
net.alchim31.maven
scala-maven-plugin
3.2.2
compile
testCompile
${scala.version}
org.apache.maven.plugins
maven-surefire-plugin
2.7
true
org.scalatest
scalatest-maven-plugin
1.0
test
test
org.jacoco
jacoco-maven-plugin
0.8.5
prepare-agent
report
test
report
```
На этом статья закончена, а наша работа продолжается. Разработка расширения Spark требует множества решений, и не всегда они простые. Это видно и в исходном коде Spark, я думаю, разработчики сейчас реализовали бы многое иначе.
В любом случае, мы не обязаны пользоваться только существующими средствами, можно разработать что-то своё. Если вы хотите преобразовать данные, используя Spark, то можете выбрать готовое решение (HashPartitioner, RangePartitioner). И всё же, если если вы поняли, что нужно специфическое распределение данных, то не бойтесь сделать партишенер для своих нужд, и я уверен, что он будет лучше и полезнее!
Не пытайтесь заставить машину работать быстрее, постарайтесь сделать так, чтобы машина не выполняла ненужную работу, а нужной работы было как можно меньше. Тогда это будет не преждевременная, а осознанная и нужная оптимизация.
В следующей статье мы разберём сам DataSource, предназначенный для чтения данных, и средства работы с метаданными. | https://habr.com/ru/post/583018/ | null | ru | null |
# О пересмотре результатов конкурса по программированию на JS
Спасибо участникам [конкурса по программированию](http://habrahabr.ru/company/hola/blog/270847/) за долготерпение. Я пишу этот пост, чтобы признать и исправить серьёзную ошибку, которую мы допустили при подведении итогов.
Мы получили множество замечаний о методике тестирования решений. Ниже наши ответы на эти замечания.
Тесты на корректность неполны
-----------------------------
Спасибо двоим участникам конкурса, приславшим дополнения к нашему набору тестов на корректность. Благодаря этим дополнениям нам удалось выявить несколько решений, выдающих неправильные результаты в редких случаях.
Тесты на производительность дают искажённые результаты из-за особенностей методики тестирования
-----------------------------------------------------------------------------------------------
Мы запускали решения участников в «виртуальной машине», реализованной модулем `vm` в Node.js, чтобы предотвратить как использование `require`, так и другие возможные «сюрпризы» и попытки манипулировать тестовой системой. Однако оказалось, что модуль `vm` вносит серьёзные искажения в результаты тестирования. В частности, при использовании этого вида виртуализации доступ к глобальному пространству имён становится непропорционально медленным. Из-за этого простой перенос вспомогательных функций в тело функции `filter` может улучшить производительность в несколько раз. Большинство участников тестировали производительность своего кода простыми обёртками с использованием `require`, поэтому не оптимизировали его под особенности конкретного способа виртуализации. Мы считаем, что такой стилистический выбор, как размещение вспомогательных функций внутри или вне главной функции, не должен иметь настолько существенного влияния на результат.
Мы не знали об этой особенности модуля виртуализации Node.js, а, узнав, сочли её достаточно серьёзной для того, чтобы пересмотреть результаты. Теперь мы проводим тестирование в обычной виртуальной машине уровня ядра. Мы загружаем модули участников с помощью `require` и вызываем функцию `filter` один раз. На каждый проход теста запускается новый процесс Node.js.
К сожалению, это исправление приведёт к смене тройки лидеров. Мы приносим извинения тем, чья победа была объявлена ранее, и тем, кто изначально был лишён заслуженных призовых мест.
В тестах на производительность не встречаются символы `?` в правилах
--------------------------------------------------------------------
В отличие от тестов на корректность, которые призваны проверить правильность поведения программы даже в искусственно созданных редких ситуациях, тесты на производительность должны быть похожими на реальную жизнь. В частности, реальные пользователи едва ли когда-нибудь используют знак `?` в правилах. Большинство правил в нашем тесте на производительность не содержат даже звёздочек, а в остальных звёздочка используется вместо всей части либо до, либо после символа `@`, что также отражает типичное применение этой возможности.
В тестах на производительность недостаточно много правил
--------------------------------------------------------
Даже 100 правил — многовато для типичного продвинутого пользователя почты. В отличие от числа писем, мы не ожидаем хорошей масштабируемости при росте числа правил до таких нереалистичных чисел, как, например, 1000.
В тестах на производительность недостаточно много писем
-------------------------------------------------------
Мы решили использовать 100 000 писем, поскольку это реалистичное число для активного пользователя за год. В порядке эксперимента мы решили увеличить это число до 800 000 — бо́льшие размеры уже начинают вызывать нехватку оперативной памяти для некоторых решений при стандартных настройках V8. Увеличенный тест можно сгенерировать скриптом `generate_large_test.js` с опцией `xlarge`. Мы прогнали на нём все корректные решения и увидели, что от увеличения объёма входных данных расстановка лидеров несколько меняется.
И 100 000, и 800 000, и промежуточные значения — в принципе одинаково достойные варианты. Мы могли бы сделать выбор в пользу увеличенного теста, или же взять некое средневзвешенное значение. Однако мы решили оставить изначальный вариант с 100 000 писем, чтобы свести к минимуму изменение методики тестирования по сравнению с изначально опубликованным. Если вышеописанная проблема с виртуализацией вносила такие чудовищные искажения, что соревнование уже нельзя было назвать честным, то размер тестовых данных мог быть свободно выбран в некотором разумном диапазоне, и тот размер, который мы решили использовать, вполне разумен.
Тесты надо было публиковать заранее
-----------------------------------
Мы не публиковали тесты в начале конкурса, чтобы не создать ситуацию, при которой участники занимались бы оптимизацией под конкретные тесты, а некоторые и вовсе пытались бы обманывать тестовую систему. Скажем, увидев, что наш скрипт, генерирующий тесты на производительность, никогда не использует знак `?`, а знак `*` ставит только в начало или конец маски, хитрый участник мог бы написать один полностью корректный вариант алгоритма на случай тестирования на корректность (если число писем невелико), а при большом числе писем переключаться на более быстрый вариант, поддерживающий только те случаи, которые встречаются в тестах на производительность.
Тем не менее, мы решили в будущем публиковать больше информации о том, как будет проходить тестирование. Скажем, не показывая сами тестовые данные, мы могли бы объявить заранее их объём.
Итоги
-----
Новая система тестирования и окончательные итоги опубликованы в [репозитории на GitHub](https://github.com/hola/challenge_mail_filter). Исправленные результаты — [в следующем посте](http://habrahabr.ru/company/hola/blog/275111/).
Ещё раз приношу извинения всем, кого затронула эта история. | https://habr.com/ru/post/274961/ | null | ru | null |
# Отслеживание ошибок в приложении React с помощью Sentry
Сегодня я расскажу вам об отслеживании ошибок в реальном времени в приложении React. Приложение внешнего интерфейса обычно не используется для отслеживания ошибок. Некоторые компании часто откладывают отслеживание ошибок, возвращаясь к нему после документации, тестов и прочего. Однако, если вы можете изменить свой продукт в лучшую сторону, то просто сделайте это!
### **1. Зачем вам нужен Sentry?**
Я предполагаю, что вы заинтересованы в отслеживании ошибок в процессе производства
Вы думаете, что этого недостаточно?
Хорошо, давайте посмотрим на детали.
**Основные причины использования Sentry для разработчиков:**
* Позволяет избавляться от рисков при развертывании кода с ошибками
* Помощь QA в тестировании кода
* Получение быстрых уведомлений о проблемах
* Возможность быстрого исправления ошибок
* Получение удобного отображения ошибок в админ-панели
* Сортировка ошибок по сегментам пользователя / браузера
**Основные причины для CEO / Lead проекта**
* **Экономия денег (Sentry можно установить на ваших серверах)**
* Получение отзывов пользователей
* Понимание того, что не так с вашим проектом в режиме реального времени
* Понимание количества проблем, возникающих у людей с вашим приложением
* Помощь в поиске мест, где ваши разработчики допустили оплошность
Я думаю, что разработчики были бы заинтересованы в этой статье в первую очередь. Вы также можете использовать этот список причин, чтобы убедить начальство интегрировать Sentry.
Будьте осторожны с последним пунктом в списке для бизнеса.
Вы уже заинтересованы?
### Что такое Sentry?
Sentry – это приложения для отслеживания ошибок с открытым исходным кодом, которое помогает разработчикам отслеживать, исправлять сбои в режиме реального времени. Не забывайте и о том, что приложение позволяет повышать эффективности и улучшать пользовательское использование. Sentry поддерживает JavaScript, Node, Python, PHP, Ruby, Java и другие языки программирования.
### **2. Войдите и создайте проект**
* Откройте ваш Sentry аккаунт. Возможно, вам придется войти в систему. (Обращаю внимаю что Sentry можно установить на ваших серверах)
* Следующий шаг создать проект
* Выберите ваш язык из списка. (Мы собираемся выбрать React. Нажмите «Создать проект»)
Настройте ваше приложение. Базовый пример, как интегрировать Sentry в контейнер, вы можете увидеть ниже:
```
import * as Sentry from '@sentry/browser';
// Sentry.init({
// dsn: ""
// });
// should have been called before using it here
// ideally before even rendering your react app
class ExampleBoundary extends Component {
constructor(props) {
super(props);
this.state = { error: null };
}
componentDidCatch(error, errorInfo) {
this.setState({ error });
Sentry.withScope(scope => {
Object.keys(errorInfo).forEach(key => {
scope.setExtra(key, errorInfo[key]);
});
Sentry.captureException(error);
});
}
render() {
if (this.state.error) {
//render fallback UI
return (
Sentry.showReportDialog()}>Report feedback
);
} else {
//when there's not an error, render children untouched
return this.props.children;
}
}
}
```
В Sentry есть полезный Мастер, который поможет вам понять, что вы должны делать дальше. Вы можете выполнить следующие шаги. Я хочу показать вам, как создать первый обработчик ошибок. Отлично, мы создали проект! Перейдем к следующему шагу
### **3. Интеграция React и Sentry**
Вы должны установить npm пакет в ваш проект.
```
npm i @sentry/browser
```
Инициализируйте Sentry в вашем контейнере:
```
Sentry.init({
// dsn: #dsnUrl,
});
```
DSN находится в Projects -> Settings -> Client Keys. Вы можете найти клиентские ключи в строке поиска.
```
componentDidCatch(error, errorInfo) {
Sentry.withScope(scope => {
Object.keys(errorInfo).forEach(key => {
scope.setExtra(key, errorInfo[key]);
});
Sentry.captureException(error);
});
}
```
### **4. Отслеживание первой ошибки**
Я например использовал простое музыкально приложение с API Deezer. Вы можете видеть это [здесь](https://nozhenkod.github.io/sentry-music-app/). Нам нужно создать ошибку. Одним из способов является обращение к свойству "undefined"
Мы должны создать кнопку, которая вызывает **console.log** с **user.email**. После этого действия мы должны получить сообщение об ошибке: *Uncaught TypeError (не удается прочитать свойство из неопределенного `email`)* из-за отсутствия объекта пользователя. Вы также можете использовать **исключение Javascript**.
```
console.log(user.email)}>
Test Error button
```
Весь контейнер выглядит так:
```
import React, { Component } from "react";
import { connect } from "react-redux";
import { Input, List, Skeleton, Avatar } from "antd";
import * as Sentry from "@sentry/browser";
import getList from "../store/actions/getList";
const Search = Input.Search;
const mapState = state => ({
list: state.root.list,
loading: state.root.loading
});
const mapDispatch = {
getList
};
class Container extends Component {
constructor(props) {
super(props);
Sentry.init({
dsn: "https://fc0edcf6927a4397855797a033f04085@sentry.io/1417586",
});
}
componentDidCatch(error, errorInfo) {
Sentry.withScope(scope => {
Object.keys(errorInfo).forEach(key => {
scope.setExtra(key, errorInfo[key]);
});
Sentry.captureException(error);
});
}
render() {
const { list, loading, getList } = this.props;
const user = undefined;
return (
console.log(user.email)}
>
test error1
Sentry.showReportDialog()}>Report feedback1
Music Finder
============
getList(value)} enterButton />
{loading && }
{!loading && (
}}
renderItem={item => (
}
title={item.title}
description={item.artist.name}
/>
)}
/>
)}
);
}
}
export default connect(
mapState,
mapDispatch
)(Container);
```
После интеграции этой кнопки вы должны протестировать ее в браузере.
У нас есть первая ошибка
Whoo-hoo!
Если вы нажмете на ошибку заголовка, вы увидите трассировку стека.
Сообщения выглядят плохо. Конечно, мы видели сообщения об ошибках, не понимая, где этот код. По умолчанию речь идет об исходной карте в ReactJS, потому что они не настроены.
Я также хотел бы предоставить инструкции по настройке исходной карты, но это сделало бы эту статью намного длиннее, чем я планировал.
Вы можете изучить эту тему [здесь](https://docs.sentry.io/platforms/javascript/?platform=react#source-maps). Если вы заинтересованы в этой статье, [Dmitry Nozhenko](https://medium.com/@dmitrynozhenko) опубликует вторую часть об интеграции source map. Итак, нажимайте больше лайков и подписывайтесь на [Dmitry Nozhenko](https://medium.com/@dmitrynozhenko), чтобы не пропустить вторую часть.
**5. Использование** **Sentry** **с конечной точкой** **API**
Окей. Мы рассмотрели исключение javascript в предыдущих пунктах. Однако, что мы будем делать с ошибками XHR?
Sentry также имеет пользовательскую обработку ошибок. Я использовал его для отслеживания ошибок api.
```
Sentry.captureException(err)
```
Вы можете настроить имя ошибки, уровень, добавить данные, уникальные пользовательские данные с помощью вашего приложения, электронной почты и т. д.
```
superagent
.get(`https://deezerdevs-deezer.p.rapidapi.com/search?q=${query}`)
.set("X-RapidAPI-Key", #id_key)
.end((err, response) => {
if (err) {
Sentry.configureScope(
scope => scope
.setUser({"email": "john.doe@example.com"})
.setLevel("Error")
);
return Sentry.captureException(err);
}
if (response) {
return dispatch(setList(response.body.data));
}
});
```
Я хотел бы использовать общую функцию для API catch.
```
import * as Sentry from "@sentry/browser";
export const apiCatch = (error, getState) => {
const store = getState();
const storeStringify = JSON.stringify(store);
const { root: { user: { email } } } = store;
Sentry.configureScope(
scope => scope
.setLevel("Error")
.setUser({ email })
.setExtra("store", storeStringify)
);
// Sentry.showReportDialog(); - If you want get users feedback on error
return Sentry.captureException(error);
};
```
Импортируйте эту функцию в вызов api.
```
export default query => (dispatch, getState) => {
superagent
.get(`https://deezerdevs-deezer.p.rapidapi.com/search?q=${query}`)
.set("X-RapidAPI-Key", #id_key)
.end((error, response) => {
if (error) {
return apiCatch(error, getState)
}
if (response) {
return dispatch(setList(response.body.data));
}
});
};
```
Давайте проверим методы:
* **setLevel** позволяет вставить ошибку уровня в панель мониторинга sentry. Он имеет свойства — ‘fatal’, ‘error’, ‘warning’, ‘log’, ‘info, ‘debug’, ‘critical’).
* **setUser** помогает сохранить любые пользовательские данные (id, адрес электронной почты, план оплаты и т. д.).
* **setExtra** позволяет задать любые данные, которые вам нужны, например, магазин.
Если вы хотите получить отзывы пользователей об ошибке, вам следует использовать функцию showReportDialog.
```
Sentry.showReportDialog();
```
Вывод:
Сегодня мы описали один из способов интеграции Sentry в приложение React.
→ Телеграм-чат по [Sentry](https://t.me/sentry_ru) | https://habr.com/ru/post/511676/ | null | ru | null |
# Как я получил первый опыт разработки игры на Android
В этой статье я хочу поделиться своим опытом создания первой игры для платформы Android, рассказать весь путь от зарождения идеи до публикации.
#### Предыстория
С 2012 года я вплотную стал заниматься программированием, в частности разработкой программ под Windows на языке C#. За всё время я получил большой опыт разработки .NET приложений, участвовал в различных проектах, в том числе и командных. Так вышло, что мне захотелось заняться разработкой под Android. Передо мной стоял выбор C# (Xamarin) или Java. Так как я последние 3 года программировал на C# и хотелось, как можно быстрей приступить к разработке, а не разбираться в новой IDE и нюансах программирования на Java выбор был очевиден.
Идея «что разрабатывать?» родилась быстро и заключалось в разработке приложения для прослушивания и скачивания музыки в ВК. Приложение было почти завершено, но в связи с некоторыми проблемами так и не опубликовано. Спустя полгода, у меня появилось уйма «свободного» времени и я решил вернуться к разработке приложений под Android. Познакомившись с одним программистом и пообщавшись с ним о преимуществах и недостатках Java (Android) и C# (Xamarin), я начал под его руководством штудировать книги по Java и осваивать IDE IntelliJ IDEA.
#### Идея, или с чего всё началось
После двух недель ознакомления с принципами разработки (которые давались мне довольно легко) знакомый [дизайнер](http://pgraphics.ru) предложил вместо чтения книг и повторения примеров приступить сразу к разработке игры, а возможные проблемы, связанные с программированием, решать по мере их поступления. Именно так я и поступил, оставалось лишь придумать идею для игры, но уже через 5 минут её придумал сам дизайнер.
Игра направлена на развитие памяти и её суть заключается в следующем: игроку в течение нескольких секунд демонстрируются изображение с несколькими фигурами разной формы, цвета, размера и расположения, которые он должен успеть запомнить, после чего повторить. За каждый пройденный уровень игрок получает «звездочки», которые позволяют открыть новые более сложные уровни.
Для определения оценки (количества полученных звездочек) пройденного уровня было решено использовать 3 параметра: цвет фигуры, её местоположение и радиус. Для добавления сложности в игровой процесс было введено условие, что игроку необходимо повторить формы всех представленных фигур, с учётом их расположения на экране, иначе уровень будет считаться непройденным.
#### Дизайн
С разработкой графического интерфейса мне помог всё тот же дизайнер, который уже не первый раз участвовал в разработке UI/UX дизайн для мобильных приложений. Он разработал логотип, иконку, выбрал основные цвета, шрифты, размеры кнопок и др. Затем представил готовое решение интерфейса, нарисованное в векторе. Подготовил материалы для релиза («превьюшки», рекламные изображения и т.д.).
**Результаты работы можно увидеть на скриншотах:**
#### Разработка
После получения готового дизайна игры я сразу принялся за разработку. Сложности, с которыми пришлось столкнуться, были связаны лишь с реализацией рисования фигур. Всего нужно было реализовать 6 методов для рисования фигур (круг, квадрат, треугольник, пятиугольник, звезда, шестиугольник), два из которых уже реализованы в Java. Так же одним из условий было то, что фигура должна отрисовываться от центра во все стороны, и должна быть вписанной в окружность с радиусом, размер которого определял уже сам пользователь. Поскольку это был мой первый подобный проект, я решил самостоятельно реализовать методы рисования оставшихся четырех фигур, а не использовать готовые библиотеки. Для рисования фигур использовался *canvas.drawPath()* (метод рисования линий), мне оставалось только определить точки, через которые должны проходить путь линии. В связи с этим пришлось вспомнить школьную программу и открыть учебник по геометрии.
Следующим нюансом было то, что фигура может быть отрисована несколькими способами: с обозначенным центром, с рамкой, без рамки и центра, с рамкой и центром, при этом рамка может быть сплошной либо пунктирной. Для решения этой проблемы был создан интерфейс с тремя методами (рисование фигуры, рамки, рисование фигуры с рамкой). Данный интерфейс был использован при реализации классов рисования для фигур.
**Интерфейс для рисования фигуры**
```
public interface DrawFigure {
public void draw(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint);
public void drawWithBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint);
public void drawBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint);
}
```
**Класс рисования треугольника**
```
public class DrawThreeAngle implements DrawFigure {
private float mRadius;
private int[] angles = new int[]{30, 150, 270, 30};
private float[] xValues = new float[4];
private float[] yValues = new float[4];
@Override
public void draw(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint) {
mRadius = Tools.getRadius(startPoint, finishPoint);
Path threeanglePath = new Path();
for (int i = 0; i < angles.length; i++) {
xValues[i] = startPoint.x + (float) (mRadius * Math.cos(Math.toRadians(angles[i])));
yValues[i] = startPoint.y + (float) (mRadius * Math.sin(Math.toRadians(angles[i])));
if (i==0){
threeanglePath.moveTo(xValues[i], yValues[i]);
}
else {
threeanglePath.lineTo(xValues[i], yValues[i]);
}
}
threeanglePath.close();
canvas.drawPath(threeanglePath, mPaint);
}
@Override
public void drawWithBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint) {
draw(canvas, startPoint, finishPoint, mPaint);
drawBorder(canvas, startPoint, finishPoint, mPaint, borderPaint);
}
@Override
public void drawBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint) {
for (int i = 0; i < angles.length - 1; i++) {
canvas.drawLine(xValues[i], yValues[i], xValues[i + 1], yValues[i + 1], borderPaint);
}
}
}
```
**Класс рисования звезды**
```
public class DrawStar implements DrawFigure {
private float mRadius;
private int[] angles = new int[]{-18, -54, 270, 234, 198, 162, 126, 90, 54, 18, -18};
private float[] xValues = new float[11];
private float[] yValues = new float[11];
@Override
public void draw(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint) {
mRadius = Tools.getRadius(startPoint, finishPoint);
Path starPath = new Path();
for (int i = 0; i < angles.length; i++) {
if (i % 2 == 0) {
xValues[i] = startPoint.x + (float) (mRadius * Math.cos(Math.toRadians(angles[i])));
yValues[i] = startPoint.y + (float) (mRadius * Math.sin(Math.toRadians(angles[i])));
} else {
xValues[i] = startPoint.x + (float) (mRadius / 2 * Math.cos(Math.toRadians(angles[i])));
yValues[i] = startPoint.y + (float) (mRadius / 2 * Math.sin(Math.toRadians(angles[i])));
}
if (i==0){
starPath.moveTo(xValues[i], yValues[i]);
}
else {
starPath.lineTo(xValues[i], yValues[i]);
}
}
starPath.close();
canvas.drawPath(starPath, mPaint);
}
@Override
public void drawWithBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint) {
draw(canvas, startPoint, finishPoint, mPaint);
drawBorder(canvas, startPoint, finishPoint, mPaint, borderPaint);
}
@Override
public void drawBorder(Canvas canvas, PointF startPoint, PointF finishPoint, Paint mPaint, Paint borderPaint) {
for (int i = 0; i < angles.length - 1; i++) {
canvas.drawLine(xValues[i], yValues[i], xValues[i + 1], yValues[i + 1], borderPaint);
}
}
}
```
#### Реализация уровней
После реализации всего игрового процесса, я принялся за реализацию уровней. Всего было создано 60 уровней различной сложности. Сложность уровней зависит от количества фигур, их размеров и расположения. Так же сложность уровней повышалась за счёт возможности рисования пресекающихся фигур.
Для хранения всех уровней была создана база данных, состоящая из двух таблиц со списком. Так как фигуры в базе данных заданы координатами (центр фигуры и точка на её радиусе), то на разных экранах они будут отображаться в разном масштабе или вообще выходить за пределы. Поэтому появилась необходимость в решении проблемы отрисовки уровня в одинаковом масштабе для разных экранов. Для решения этой проблемы были определены координаты фигур при так называемом эталонном разрешении. А отображение в нужном масштабе осуществляется за счет определения коэффициента отношения эталонного разрешения к текущему разрешению и умножения координат всех фигур на рассчитанный коэффициент.
**Структура базы данных**
```
public class LevelsDatabaseHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "levels.sqlite";
private static final int VERSION = 1;
private static final String TABLE_LEVELS = "levels";
private static final String COLUMN_LEVELS_STARS = "stars";
private static final String COLUMN_LEVELS_TIME = "time";
private static final String COLUMN_LEVELS_NUMBER = "number";
private static final String TABLE_FIGURE = "figure";
private static final String COLUMN_FIGURE_TYPE = "type";
private static final String COLUMN_FIGURE_NUMBER = "number";
private static final String COLUMN_FIGURE_CENTER_X = "center_x";
private static final String COLUMN_FIGURE_CENTER_Y = "center_y";
private static final String COLUMN_FIGURE_FINISH_X = "finish_x";
private static final String COLUMN_FIGURE_FINISH_Y = "finish_y";
private static final String COLUMN_FIGURE_COLOR = "color";
private static final String COLUMN_FIGURE_LAYER_INDEX = "layer_index";
private Context mContext;
private SQLiteDatabase mDataBase;
public LevelsDatabaseHelper(Context context) {
super(context, DB_NAME, null, 2);
}
@Override
public void onCreate(SQLiteDatabase db) {
mDataBase = db;
db.execSQL("create table " + TABLE_LEVELS + " (_id integer primary key autoincrement, " +
COLUMN_LEVELS_NUMBER + " integer, " + COLUMN_LEVELS_STARS + " integer, " + " string, " + COLUMN_LEVELS_TIME + " integer)");
db.execSQL("create table " + TABLE_FIGURE + " (_id integer primary key autoincrement, " + COLUMN_FIGURE_NUMBER +
" integer, " + COLUMN_FIGURE_TYPE + " string, " + COLUMN_FIGURE_CENTER_X + " real, "
+ COLUMN_FIGURE_CENTER_Y + " real, " + COLUMN_FIGURE_FINISH_X + " real, " + COLUMN_FIGURE_FINISH_Y
+ " real, " + COLUMN_FIGURE_COLOR + " integer, " + COLUMN_FIGURE_LAYER_INDEX + " string)");
}
}
```
#### Жульничество
При тестировании уровней был найдена лазейка при прохождении уровней, в которых есть пересекающиеся фигуры. Лазейка заключалась в том, что при проверке уровня не учитывается слой, на котором находится фигура. В итоге можно нарисовать сначала верхнюю фигуру, а затем нижнюю и уровень всё равно считался бы пройденным. Для устранения этой лазейки в класс фигуры был добавлена переменная, определяющая номер слоя, на котором она расположена. Так же были учтены следующие условия:
* Фигура не пересекается с другими, т.е. уровень слоя ей не важен, в этом случае введенная переменная принимает значение «-1»;
* На одном слое расположено больше одной фигуры, в этом случае переменная принимает номера слоев через «/», на котором она может быть расположена («2/3/4»).
**Более наглядно решение проблемы представлено на изображении:**
При проверке уровня сначала выполнялась проверка фигур, независящих от слоя, а после сравнивались номера слоёв оставшихся фигур в порядке, в котором их отрисовали.
#### Custom View
Учитывая нетривиальный дизайн, большинство View пришлось реализовывать самостоятельно, например прогресс бар в окне результата пройденного уровня. Прогресс бар имеет нестандартный внешний вид, два заголовка слева (имя параметра, по которому производится оценка) и справа (полученный результат по данному параметру). Так же одним из условий, было возможность поддержки анимированного заполнения.
**Внешний вид Progress Bar**
**Код ProgressBarSuccessView**
```
public class ProgressBarSuccessView extends View {
float mPercentValue = 0;
String mLeftTitleText = "title";
int mWidth, mHeight;
final float mLeftTitleSize = 0.3f, mProgressBarSize = 0.5f, mRightTitleSize = 0.2f;
float mBorderMargin, mProgressMargin;
RectF mProgressBarBorder = new RectF(), mProgressBarRectangle = new RectF();
int mLeftTitleX, mLeftTitleY, mRightTitleX, mRightTitleY;
Paint mTitlePaint, mProgressPaint, mBorderProgressBarPaint;
private Rect mTitleTextBounds = new Rect();
public ProgressBarSuccessView(Context context) {
super(context);
init(null);
}
public ProgressBarSuccessView(Context context, AttributeSet attrs) {
super(context, attrs);
init(attrs);
}
public ProgressBarSuccessView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(attrs);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidth = w;
mHeight = h;
mTitlePaint.getTextBounds(mLeftTitleText, 0, mLeftTitleText.length(), mTitleTextBounds);
mLeftTitleX = (int) ((w * mLeftTitleSize - mTitleTextBounds.width()) / 2 - mTitleTextBounds.left);
mLeftTitleY = (h - mTitleTextBounds.height()) / 2 - mTitleTextBounds.top;
mProgressBarBorder.set(w * mLeftTitleSize, 0 + mBorderMargin, w * (mLeftTitleSize + mProgressBarSize), h - mBorderMargin);
}
private void init(AttributeSet attrs) {
TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.ProgressBarTitle);
mLeftTitleText = a.getString(R.styleable.ProgressBarTitle_progress_bar_title);
mBorderMargin = getResources().getDimension(R.dimen.border_progress_bar_margin);
mProgressMargin = getResources().getDimension(R.dimen.progress_bar_margin);
mTitlePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mTitlePaint.setColor(getResources().getColor(R.color.title_level_success_view));
mTitlePaint.setStyle(Paint.Style.STROKE);
mTitlePaint.setTextSize(getResources().getDimension(R.dimen.progress_bar_title_text_size));
mTitlePaint.setTypeface(FontManager.BEBAS_REGULAR);
mBorderProgressBarPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mBorderProgressBarPaint.setColor(getResources().getColor(R.color.title_level_success_view));
mBorderProgressBarPaint.setStyle(Paint.Style.STROKE);
mBorderProgressBarPaint.setStrokeWidth(2);
mProgressPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mProgressPaint.setColor(getResources().getColor(R.color.progress_bar_level_success_view));
mProgressPaint.setStyle(Paint.Style.FILL);
setWillNotDraw(false);
}
public void setPercent(float percent) {
mPercentValue = Math.round(percent * 100f) / 100f;
invalidate();
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
float left, top, right, bottom;
left = mWidth * mLeftTitleSize + mProgressMargin - mBorderMargin;
top = 0 + mProgressMargin;
right = mPercentValue > 0 ? left + mWidth * mProgressBarSize * mPercentValue - mProgressMargin - mBorderMargin : left;
bottom = mHeight - mProgressMargin;
mProgressBarRectangle.set(left, top, right, bottom);
canvas.drawText(mLeftTitleText, mLeftTitleX, mLeftTitleY, mTitlePaint);
canvas.drawRect(mProgressBarBorder, mBorderProgressBarPaint);
canvas.drawRect(mProgressBarRectangle, mProgressPaint);
mTitlePaint.getTextBounds(String.valueOf((int) (mPercentValue * 100)), 0, String.valueOf((int) (mPercentValue * 100)).length(), mTitleTextBounds);
mRightTitleX = (int) (mWidth - mTitleTextBounds.width() / 2 - mWidth * mRightTitleSize / 2);
mRightTitleY = (mHeight - mTitleTextBounds.height()) / 2 - mTitleTextBounds.top;
canvas.drawText(String.valueOf((int) (mPercentValue * 100)), mRightTitleX, mRightTitleY, mTitlePaint);
}
}
```
**Анимация заполнения прогресс бара**
```
public static AnimatorSet createProgressAnimationSet(ArrayList views, float[] percentValues)
{
AnimatorSet animatorSet = new AnimatorSet();
List animatorList = new ArrayList<>(views.size());
for (int i = 0; i < views.size(); i++){
float value = percentValues[i];
View view = views.get(i);
animatorList.add(createProgressAnimation(view, value));
}
animatorSet.playTogether(animatorList);
return animatorSet;
}
private static ObjectAnimator createProgressAnimation(View view, float progressValue){
ObjectAnimator shapeProgressAnimator = ObjectAnimator.ofFloat(view, "percent", 0, progressValue);
shapeProgressAnimator.setDuration((long) (1000 \* progressValue));
shapeProgressAnimator.setInterpolator(new DecelerateInterpolator());
return shapeProgressAnimator;
}
```
**Подсказки**
Чтобы облегчить жизнь игроку, были добавлены подсказки, которые можно получить за очки. Очки, в свою очередь, начисляются за прохождение уровней, количество очков зависит звезд полученных за уровень. Полученные очки игрок может потратить на любую из 3 доступных подсказок: показать фигуру, её центр или окружность радиуса фигуры.
**Результаты работы**
#### Итог
Выводы о популярности приложения делать ещё рано, поскольку оно было выложено совсем недавно. По некоторым причинам мне некогда было вплотную заняться продвижением игры. Единственное, что было сделано – опубликованы ссылок на игру в соц. сетях.
На освоение Java я потратил совсем мало времени. А на чтение литературы лучше не растрачиваться, т.к. новых книг нет, а в существующих книгах часто приводятся реализации, которые уже не имеют актуальности в современной разработке мобильных приложений.
Неизвестно, станет ли эта игра хитом или окажется провалом. Сделав эту игру, я получил хороший опыт разработки приложений для Android-устройств, который пригодится мне в будущем, а так же наконец-то занялся тем, чем давно хотел. В настоящее время я разрабатываю свое следующее приложения, подходя к процессу более основательно с учётом своих предыдущих ошибок. Кроме того у меня еще много идей мобильных приложений, которые в скором времени увидит мир. | https://habr.com/ru/post/274277/ | null | ru | null |
# Использование платформы Intel Edison для создания видеоровера
[](http://geektimes.ru/company/intel/blog/268648/)
[Intel Edison](http://www.intel.com/content/www/us/en/do-it-yourself/edison.html) — это умная вычислительная платформа, которая используется для создания различных устройств, в том числе носимых. В мире набирает популярность движение мейкеров, увеличивается число продуктов и решений, которые можно построить с использованием платформы Intel Edison. В этой статье вы вам покажем, как построить видеоровер (вездеход с камерой) с использованием платформы Intel Edison и конструктора [Makeblock](http://www.makeblock.cc).
Раз это видеоровер, то он должен иметь камеру. Видео, которое она выдаёт, мы сможем смотреть на компьютере, мобильном телефоне или планшете. Дополнительно мы сможем использовать эти устройства для управления самим вездеходом и камерой.
Приготовление
=============
Вот что нам понадобится, чтобы построить видеоровер:
* Плата Intel Edison.
* Главная плата [Makeblock](http://www.makeblock.cc/).
* Набор [Makeblock Starter Kit](http://www.makeblock.cc/starter-robot-kit/).
* Винты M4, нейлоновые шпильки M4.
* Винты M2.5, нейлоновые шпильки M2.5.
* Адаптер Makeblock Me RJ25.
* Сервоприводы и уголки для них.
* USB-камера с поддержкой MJPEG и UVC.
* Провода (DuPont).
* Батарея на 7.4 В.
* Напечатанная на 3D-принтере рамка.
* USB-кабель.
Установка механических и электронных модулей
============================================
1. Присоедините последовательный порт платы Intel Edison к главной плате Makeblock при помощи проводов.
2. Соедините плату Intel Edison и Makeblock, используя шпильки и напечатанную на 3D-принтере рамку.
3. Соедините камеру и сервопривод.
4. Установите главную плату и сервопривод на шасси из набора Makeblock Starter Kit — Track car.
5. Блок питания, который надо использовать с платой Makeblock, должен выдавать, как минимум 7 В. Соедините последовательный порт на плате Intel Edison и сервопривод через адаптер Me RJ25. (Вам надо соединить адаптер Makeblock Me RJ25 через порты 4 и 5 платы Makeblock, а порт 6 присоедините к серводвигателю).
6. Присоедините камеру к хост-порту USB на плате Intel Edison и затем подключите блок питания (7.4 В) к плате Makeblock.
Установка программ
==================
**Шаг 1.** Чтобы приготовить систему для платы Intel Edison следуйте [руководству](https://software.intel.com/en-us/iot/library/edison-getting-started).
**Шаг 2.** Подключите edi-cam [github.com/xeecos/edi-cam](https://github.com/xeecos/edi-cam) для стриминга видео.
1. Присоедините плату Intel Edison через последовательный порт или по Wi-Fi. Убедитесь, что плата и ваш компьютер находятся в одной локальной сети. Введите:
```
$ ssh root@myedison.local
root@myedison.local's password:root@myedison:~#
```
Замените myedison именем вашей платы Intel Edison. Когда будет запрошен пароль, используйте тот, который вы задали при конфигурировании платы.
2. Чтобы сконфигурировать репозиторий, добавьте следующие строки к файлу `/etc/opkg/base-feeds.conf`:
```
src/gz all http://repo.opkg.net/edison/repo/allsrc/gz edison
http://repo.opkg.net/edison/repo/edison
src/gz core2-32 http://repo.opkg.net/edison/repo/core2-32
```
3. Для обновления opkg, введите:
```
opkg update
```
4. Для установки Git, введите:
```
opkg install git
```
5. UVC-драйвер:
Убедитесь, что у вас установлена последняя версия образа Yocto, в которую уже входят UVC-драйвера. Старая версия Yocto их не содержит.
6. Для установки ffmpeg перейдите в папку bin. Чтобы запустить скрипт, введите:
```
./install_ffmpeg.sh
```
7.Установите пакет Node.js
Перейдите в web/robotjs. Установите пакет Node.js, напечатав:
```
npm install
```
**Шаг 3.** Запустите приложение.
1. Обновите адрес вебсервиса. Измените значение переменной wsUrl в файле `web/robotjs/client/index.html`:
```
// CHANGE THIS TO THE APPROPRIATE WS ADDRESS
var wsUrl = 'ws://myedison.local:8084/';
```
2. Запустите node.js
Перейдите в `web/robotjs` и затем запустите команду
```
node server.js
```
Вы увидите вывод в терминале:
```
WebSocket server listening on port 8084
HTTP server listening on port 8080
Listening for video stream on port 8082
Stream Connected: 127.0.0.1:52995 size: 640x480
Viewing the video stream
```
3. Откройте в браузере `myedison.local:8080`. Вы увидите видео и страницу управления.
Заключение
==========
В этой статье мы показали вам, как использовать плату Intel Edison, механические и электронные модули Makeblock для постройки управляемого видеоровера. Плата Intel Edison исполняет роль сервера и обеспечивает поддержку сети. Но фактически мощность платы Intel Edison используется не полностью. Попробуйте использовать её для более сложной работы, создавая более удивительные устройства. | https://habr.com/ru/post/371559/ | null | ru | null |
# Time Travel Debugging в новом WinDbg
Возможно, вы уже слышали о том, что Microsoft выпустила обновлённую версию своего известного отладчика WinDbg, который и раньше был хорош, но слишком уж отстал по интерфейсу от современных тенденций. Новая версия WinDbg, к счастью, не пошла настолько далеко, чтобы получить новомодный UWP-интерфейс, но вот классические риббон-бары в стиле Microsoft Office — ей очень идут. Приложение распространяется только через Microsoft Store и работают на Win10 как минимум с Anniversary Update. Microsoft говорит, что это сделано для удобства установки и обновления, но я как-то не помню, чтобы с классическим WinDbg были какие-то проблемы с установкой. Скорее это выглядит как ещё один способ приучения разработчиков и пользователей к привычке пользоваться только самой последней версией Windows. Ну ок, пусть так.
WinDbg выглядит симпатично:
И вся его мощь в виде команд, отладки драйверов, удалённой отладки, скриптов и прочего — осталась при нём. Более того, 25 сентября было выпущено обновление, добавляющее в новый WinDbg важную фичу — отладку с возможностью двигаться по ходу работы программы в обратном направлении (Time Travel Debugging). Возможность интересная, поскольку попав в некоторое невалидное состояние программист часто задаётся вопросом «А как же так вышло?». Ранее получить на него ответ можно было либо проигрывая в уме команды в обратном порядке, либо перезапуская отладку снова и снова с добавлением логов и новых контрольных точек. Всё это занимало время. Давайте посмотрим, как это работает сейчас.
[Устанавливаем WinDbg](https://www.microsoft.com/en-us/store/p/windbg/9pgjgd53tn86)
Пишем каку-нибудь небольшую программу и компилируем её. Я взял первую попавшуюся в Интернете реализацию пузырьковой сортировки (да, потому, что я лентяй).
**Пузырьковая сортировка**
```
#include "stdafx.h"
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
// An optimized version of Bubble Sort
void bubbleSort(int arr[], int n)
{
int i, j;
bool swapped;
for (i = 0; i < n - 1; i++)
{
swapped = false;
for (j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
swap(&arr[j], &arr[j + 1]);
swapped = true;
}
}
// IF no two elements were swapped by inner loop, then break
if (swapped == false)
break;
}
}
/* Function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
}
// Driver program to test above functions
int main()
{
int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
```
Теперь у нас есть скомпилированный бинарник, символьный файл к нему и файл с исходником. Это всё понадобится для WinDbg.
Запускаем WinDbg с привилигиями администратора (это важно!). Выбираем File → Start debugging → Launch executable (advanced):
Задаём путь к отлаживаемому бинарнику, ставим галку «Record process with Time Travel Debugging», задаём путь для сохранения записанного трейса выполнения.
Жмём ок, программа запускается, отрабатывает и закрывается. WinDbg сохраняет записанный трейс выполнения в указанную папку и сразу же загружает его (это экономит время отладки).
Теперь открываем в WinDbg файл с кодом, ставим пару брейкпоинтов, запускаем отладку. На первый взгляд всё выглядит знакомо.
Но вот оно — главное отличие:
Нам доступен блок реверсивного управления направлением выполнения кода. Мы можем просто ступить на строку назад.
Мы можем поставить новый брейкпоинт где-нибудь выше и нажать «Go back», чтобы обратное выполнение программы дошло до него.
Обратите внимание — мы прыгнули назад во времени до входа программы в циклы for — и вот внизу в окне Locals мы уже видим, что переменные i и j в этот момент ещё имеют неопределённые значения.
Мы можем ходить вперёд и назад сколько угодно, перезапускать отладку с самого начала. Можно коннектится к уже запущенным процессам для записи выполнения только определённых блоков кода. Очень удобно ловить баги, которые воспроизводятся только иногда или только в определённом окружении, а потом прокручивать их снова и снова.
В общем, фича мне нравится.
Материалы по теме:
1. [Анонс фичи в блоге WinDbg](https://blogs.msdn.microsoft.com/windbg/2017/09/25/time-travel-debugging-in-windbg-preview/)
2. [Документация](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/time-travel-debugging-overview)
3. [Установить WinDbg](https://www.microsoft.com/en-us/store/p/windbg/9pgjgd53tn86) | https://habr.com/ru/post/340744/ | null | ru | null |
# Core Data + Swift для самых маленьких: необходимый минимум (часть 2)
Это вторая часть трилогии о Core Data, первая доступна здесь: [Core Data + Swift для самых маленьких: необходимый минимум (часть 1)](https://habrahabr.ru/post/303512/).
В первой части мы познакомились с общими сведениями о Core Data, основными компонентами (NSManagedObjectModel, NSPersistentStoreCoordinator, NSManagedObjectContext), Редактором модели данных и создали нашу модель данных.
В этой части мы будем работать с объектами, познакомимся с NSEntityDescription и NSManagedObject, автогенерацией классов, а также напишем вспомогательный класс, существенно повышающий удобство работы с Core Data.
#### NSEntityDescription и NSManagedObject
Начнем с **NSEntityDescription** — как можно догадаться из названия, это объект, который содержит описание нашей сущности. Все то, что мы нафантазировали с сущностью в Редакторе модели данных (атрибуты, взаимосвязи, правила удаления и прочее), содержится в этом объекте. Единственное, что мы будем делать с ним — получать его и передавать куда-то в качестве параметра, больше ничего.
**NSManagedObject** — это сам управляемый объект, экземпляр сущности. Продолжая аналогию с СУБД (начатую в прошлой статье), можно сказать, что NSManagedObject — запись (строка) в таблице базы данных.
Чтобы понять, как с этим работать, давайте создадим нового Заказчика. Так как у нас еще нет готовой интерфейсной части (мы займемся этим в следующей статье), то давайте немного попрограммируем прямо в модуле делегата приложения (`**AppDelegate.swift**`). Не беспокойтесь, это только демонстрация, которая важна для понимания, чуть позже мы все перенесем отсюда в другое место. Я воспользуюсь для демонстрации работы следующей функцией:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Здесь я буду размещать примеры
// …
return true
}
```
Создание управляемого объекта (в данном случае Заказчика) выполняется следующим образом:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Описание сущности
let entityDescription = NSEntityDescription.entityForName("Customer", inManagedObjectContext: self.managedObjectContext)
// Создание нового объекта
let managedObject = NSManagedObject(entity: entityDescription!, insertIntoManagedObjectContext: self.managedObjectContext)
return true
}
```
Сначала мы получаем описание сущности (**entityDescription**), передав в соответствующий конструктор строку с именем нужной нам сущности и ссылку на контекст. Как это работает: контекст управляемого объекта, как мы помним из первой части, связан с координатором постоянного хранилища, а координатор, в свою очередь, связан с объектной моделью данных, где и будет произведен поиск сущности по указанному имени. Обратите внимание, что данная функция возвращает опциональное значение.
Затем, на основании полученного описания сущности, мы создаем сам управляемый объект (**managedObject**). Вторым параметром мы передаем контекст, в котором этот объект должен быть создан (в общем случае, как вы помните, может быть несколько контекстов).
Хорошо, мы создали объект, как теперь установить значения его атрибутов? Для это используется кодирование по типу **Key-Value**, суть которого в том, что есть два универсальных метода, один который устанавливает указанное значение по указанному имени, а второй извлекает значение по указанному имени. Звучит гораздо сложнее, чем выглядит.
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Описание сущности
let entityDescription = NSEntityDescription.entityForName("Customer", inManagedObjectContext: self.managedObjectContext)
// Создание нового объекта
let managedObject = NSManagedObject(entity: entityDescription!, insertIntoManagedObjectContext: self.managedObjectContext)
// Установка значения атрибута
managedObject.setValue("ООО «Ромашка»", forKey: "name")
// Извлечение значения атрибута
let name = managedObject.valueForKey("name")
print("name = \(name)")
return true
}
```
Вывод консоли:
```
name = Optional(ООО «Ромашка»)
```
Как видите, все довольно просто. Идем дальше. Теперь надо сохранить этот объект в нашей базе данных. Разве то, что мы создали объект — недостаточно? Нет, любой объект «живет» в конкретном определенном контексте и только там. Вы можете его там создавать, модифицировать и даже удалять, но это все будет происходить внутри определенного контекста. До тех пор, пока вы **явно** не сохраните все изменения контекста, вы не измените реальных данных. Можно провести аналогию с файлом на диске, который вы открываете для редактирования — пока вы не нажали кнопку «Сохранить» никакие изменения не записаны. На самом деле это очень удобно и здорово оптимизирует весь процесс работы с данными.
Сохранение изменений контекста выполняется элементарно:
```
managedObjectContext.save()
```
У нас даже есть в модуле делегата готовая функция для более «умного» сохранения (мы говорили о ней вскользь в прошлой статье), запись происходит только в том случае, если данные действительно изменены:
```
func saveContext () {
if managedObjectContext.hasChanges {
do {
try managedObjectContext.save()
} catch {
let nserror = error as NSError
NSLog("Unresolved error \(nserror), \(nserror.userInfo)")
abort()
}
}
}
```
Таким образом, весь код создания и записи объекта будет выглядеть следующим образом:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Описание сущности
let entityDescription = NSEntityDescription.entityForName("Customer", inManagedObjectContext: self.managedObjectContext)
// Создание нового объекта
let managedObject = NSManagedObject(entity: entityDescription!, insertIntoManagedObjectContext: self.managedObjectContext)
// Установка значения атрибута
managedObject.setValue("ООО «Ромашка»", forKey: "name")
// Извлечение значения атрибута
let name = managedObject.valueForKey("name")
print("name = \(name)")
// Запись объекта
self.saveContext()
return true
}
```
Мы создали объект и записали его в нашу базу данных. Как нам теперь его получить обратно? Это не намного сложнее. Давайте взглянем на код.
```
let fetchRequest = NSFetchRequest(entityName: "Customer")
do {
let results = try self.managedObjectContext.executeFetchRequest(fetchRequest)
} catch {
print(error)
}
```
Здесь мы создаем объект-запрос **NSFetchRequest**, передав в конструктор в качестве параметра название сущности данные которой мы хотим получить. Затем вызываем метод контекста, передав этот запрос в качестве параметра. Это максимально простой вариант извлечение записей, вообще NSFetchRequest очень гибок и предоставляет обширные возможности извлечение данных по определенным условиям. Пример фильтрации и сортировки данных с его помощью мы рассмотрим в следующей части статьи.
Важное замечание: функция **managedObjectContext.executeFetchRequest** всегда возвращает **массив** объектов, даже если объект всего один — возвращен будет массив, если объектов нет вообще — пустой массив.
С учетом вышесказанного, у нас будет следующий текст функции:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Описание сущности
let entityDescription = NSEntityDescription.entityForName("Customer", inManagedObjectContext: self.managedObjectContext)
// Создание нового объекта
let managedObject = NSManagedObject(entity: entityDescription!, insertIntoManagedObjectContext: self.managedObjectContext)
// Установка значения атрибута
managedObject.setValue("ООО «Василек»", forKey: "name")
// Извлечение значения атрибута
let name = managedObject.valueForKey("name")
print("name = \(name)")
// Запись объекта
self.saveContext()
// Извление записей
let fetchRequest = NSFetchRequest(entityName: "Customer")
do {
let results = try self.managedObjectContext.executeFetchRequest(fetchRequest)
for result in results as! [NSManagedObject] {
print("name - \(result.valueForKey("name")!)")
}
} catch {
print(error)
}
return true
}
```
Вывод консоли:
```
name = Optional(ООО «Василек»)
name - ООО «Василек»
name - ООО «Ромашка»
```
Как только вы получили объект, в вышеприведенном листинге это переменная **result** внутри цикла, то вы можете его произвольным образом редактировать (здесь нет никаких отличий от установки атрибутов для нового объекта), либо удалить. Удаление осуществляется вызовом соответствующего метода переменной контекста, которому в качестве параметра и передается удаляемый объект:
```
self.managedObjectContext.deleteObject(result)
```
После удаления также необходимо принудительно вызвать сохранение контекста, не забывайте об этом.
**Небольшое факультативное дополнение**Если вы хотите «пощупать» Core Data поближе, на уровне таблиц, то это проще чем может показаться. Если вы используете Симулятор, то файл базы данных лежит где-то здесь:
```
/Users//Library/Developer/CoreSimulator/Devices//data/Containers/Data/Application//Documents/.sqlite
```
Не торопитесь искать этот файл вручную, гадая какой-же ID у вашего приложения. Есть замечательная утилита, делающая это все за вас — [**SimSim**](https://github.com/dsmelov/simsim) (Пользуясь случаем, хочу сказать спасибо авторам).
После запуска она висит в строке меню и выглядит вот так (значок летучей мышки):
Собственно, назначение очевидно: утилита показывает список хранилищ установленных на симуляторе приложений и позволяет сразу к ним перейти:
Для просмотра самого файла SQLite можно воспользоваться любым бесплатным просмоторщиком, например [Datum Free](https://itunes.apple.com/ru/app/datum-free/id901631046?mt=12)
#### Автогенерация классов Core Data
Метод Key-Value, хорош тем, что он прост, универсален и работает «из коробки». Но есть два момента, которые портят впечатление: во-первых, кода больше, чем хотелось бы, а во-вторых, передавая имя реквизита каждый раз в виде строки, легко ошибиться (автодополнения здесь нет). И как нам быть, если захочется немного больше функциональности от управляемых объектов, например, вычисляемые поля или свои конструкторы? У Core Data есть решение! Мы легко можем создать свой класс (даже больше — Core Data сделает это за нас), унаследовав его от **NSManagedObject** и дополнив всем необходимым. В результате, мы сможем работать с управляемым объектов как с обычным объектом ООП, создавая его путем вызова своего конструктора и обращаясь к его полям «через точку» используя автодополнение (то есть вся мощь ООП в ваших руках).
Откройте Редактор модели данных и выделите любую сущность. Выберете в меню (оно контекстно-зависимое, поэтому надо выделить какую-нибудь сущность) **Editor \ Create NSManagedObject Subclass…**
Откроется окно выбора модели данных; да, в общем случае, может быть несколько независимых моделей данных, но у нас она одна, поэтому выбор очевиден.
В следующем окне нам предлагают выбрать сущности, для которых необходимо сгенерировать классы, давайте выберем сразу все.
Следующее стандартное окно вам должно быть знакомо, единственное что здесь может насторожить, это опция **«Use scalar properties for primitive data types»**. В чем смысл этой опции: если эту опцию не выбирать, то вместо примитивных типов данных (Float, Double, Int и прочее) будет использоваться своеобразная «обертка», содержащая значение внутри себя. Это скорее актуально для **Objective-C**, так как там нет такого понятия как **Optional**. Но мы используем **Swift**, так что я не вижу причин не выбирать эту опцию (возможно, более опытные коллеги в комментариях меня поправят).
В итоге, Core Data создаст для нас несколько файлов, давайте посмотрим, что это за файлы.
Каждая сущность представлена парой файлов, например:
* `**Customer.swift**` — этот файл для вас, вы можете добавить туда любую необходимую вам функциональность, что мы сейчас и сделаем.
* `**Customer+CoreDataProperties.swift**` — это файл Core Data, его лучше не трогать и вот почему: в этом файле содержится описание атрибутов и взаимосвязей вашей сущности, то есть, если вы внесете изменения в эту часть, то у вас сущность и ее представляющий класс не будут согласованы.
Также, если вы по каким-то причинам решите изменить модель данных, то вы можете пересоздать эти сгенерированные классы. В этом случае, первый файл (`**Customer.swift**`) останется не тронутым, а второй (`**Customer+CoreDataProperties.swift**`) будет полностью замещен новым.
Хорошо, мы создали классы для наших сущностей, теперь мы можем обращаться к полям класса «через точку», давайте придадим нашему примеру более привычный вид.
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Описание сущности
let entityDescription = NSEntityDescription.entityForName("Customer", inManagedObjectContext: self.managedObjectContext)
// Создание нового объекта
let managedObject = Customer(entity: entityDescription!, insertIntoManagedObjectContext: self.managedObjectContext)
// Установка значения атрибута
managedObject.name = "ООО «Василек»"
// Извлечение значения атрибута
let name = managedObject.name
print("name = \(name)")
// Запись объекта
self.saveContext()
// Извление записей
let fetchRequest = NSFetchRequest(entityName: "Customer")
do {
let results = try self.managedObjectContext.executeFetchRequest(fetchRequest)
for result in results as! [Customer] {
print("name - \(result.name!)")
}
} catch {
print(error)
}
return true
}
```
Так гораздо лучше. Но создание объекта выглядит несколько тяжеловесно. Можно было бы спрятать все это в конструктор, но для этого нам нужна ссылка на управляемый контекст в котором должен быть создан объект. Кстати, мы до сих пор пишем код в модуле делегата, так как именно здесь у нас определен Core Data Stack. Может можно придумать что-нибудь получше?
#### Core Data Manager
Наиболее распространенной практикой при работе с Core Data является использование паттерна **Singleton** на базе Core Data Stack. Напомню, если кто не знает или забыл, что Singleton гарантирует наличие только одного экземпляра класса с глобальной точкой доступа. То есть, у класса всегда существует один и только один объект, независимо от того, кто, когда и откуда к нему обращается. Этот подход мы сейчас и реализуем, у нас будет Singleton для глобального доступа и управления Core Data Stack.
Создайте новый пустой файл с именем **CoreDataManager.swift**
Для начала давайте добавим директиву импорта Core Data и создадим сам Singleton.
```
import CoreData
import Foundation
class CoreDataManager {
// Singleton
static let instance = CoreDataManager()
private init() {}
}
```
Теперь давайте переместим из модуля делегата приложения все функции и определения, связанные с Core Data.
```
import CoreData
import Foundation
class CoreDataManager {
// Singleton
static let instance = CoreDataManager()
private init() {}
// MARK: - Core Data stack
lazy var applicationDocumentsDirectory: NSURL = {
let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
return urls[urls.count-1]
}()
lazy var managedObjectModel: NSManagedObjectModel = {
let modelURL = NSBundle.mainBundle().URLForResource("core_data_habrahabr_swift", withExtension: "momd")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")
var failureReason = "There was an error creating or loading the application's saved data."
do {
try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
} catch {
var dict = [String: AnyObject]()
dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
dict[NSLocalizedFailureReasonErrorKey] = failureReason
dict[NSUnderlyingErrorKey] = error as NSError
let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
abort()
}
return coordinator
}()
lazy var managedObjectContext: NSManagedObjectContext = {
let coordinator = self.persistentStoreCoordinator
var managedObjectContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
managedObjectContext.persistentStoreCoordinator = coordinator
return managedObjectContext
}()
// MARK: - Core Data Saving support
func saveContext () {
if managedObjectContext.hasChanges {
do {
try managedObjectContext.save()
} catch {
let nserror = error as NSError
NSLog("Unresolved error \(nserror), \(nserror.userInfo)")
abort()
}
}
}
}
```
Теперь у нас есть Singleton и мы можем обращаться к Core Data Stack из любой точки нашего приложения. Например, обращение к управляемому контексту будет выглядеть так:
```
CoreDataManager.instance.managedObjectContext
```
Давайте теперь перенесем все необходимое для создания управляемого объекта в его конструктор.
```
// Customer.swift
// core-data-habrahabr-swift
import Foundation
import CoreData
class Customer: NSManagedObject {
convenience init() {
// Описание сущности
let entity = NSEntityDescription.entityForName("Customer", inManagedObjectContext: CoreDataManager.instance.managedObjectContext)
// Создание нового объекта
self.init(entity: entity!, insertIntoManagedObjectContext: CoreDataManager.instance.managedObjectContext)
}
}
```
Снова вернемся в модуль делегата приложения и внесем несколько изменений. Во-первых, создание управляемого объекта у нас упрощается до одной строки (вызов нового конструктора нашего класса), а во-вторых, такую ссылку на управляемый контекст
```
self.managedObjectContext
```
надо заменить следующей
```
CoreDataManager.instance.managedObjectContext
```
Теперь код будет выглядеть совсем знакомым, а работа с управляемыми объектами будет мало отличаться от обычных объектов ООП.
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Создание нового объекта
let managedObject = Customer()
// Установка значения атрибута
managedObject.name = "ООО «Колокольчик»"
// Извлечение значения атрибута
let name = managedObject.name
print("name = \(name)")
// Запись объекта
CoreDataManager.instance.saveContext()
// Извление записей
let fetchRequest = NSFetchRequest(entityName: "Customer")
do {
let results = try CoreDataManager.instance.managedObjectContext.executeFetchRequest(fetchRequest)
for result in results as! [Customer] {
print("name - \(result.name!)")
}
} catch {
print(error)
}
return true
}
```
Неплохо, не правда ли? Все что нам остается сделать, это создать аналогичные конструкторы для остальных наших сущностей. Но прежде давайте сделаем еще одно улучшение, чтобы сократить количество кода — вынесем функцию, возвращающую описание сущности, в **`CoreDataManager`**.
Давайте вернемся в модуль **`CoreDataManager.swift`** и добавим функцию **`entityForName`**.
```
import CoreData
import Foundation
class CoreDataManager {
// Singleton
static let instance = CoreDataManager()
private init() {}
// Entity for Name
func entityForName(entityName: String) -> NSEntityDescription {
return NSEntityDescription.entityForName(entityName, inManagedObjectContext: self.managedObjectContext)!
}
```
Теперь вернемся в модуль **`Customer.swift`** и изменим код следующий образом.
```
import Foundation
import CoreData
class Customer: NSManagedObject {
convenience init() {
self.init(entity: CoreDataManager.instance.entityForName("Customer"), insertIntoManagedObjectContext: CoreDataManager.instance.managedObjectContext)
}
}
```
Вот теперь точно все, дублирование кода сведено к минимуму. Давайте создадим аналогичные конструкторы для остальных сущностей. Я приведу только один для примера, это просто и не должно вызвать никаких затруднений (абсолютно все то же самое, за исключением имени сущности).
```
// Order.swift
// core-data-habrahabr-swift
import Foundation
import CoreData
class Order: NSManagedObject {
convenience init() {
self.init(entity: CoreDataManager.instance.entityForName("Order"), insertIntoManagedObjectContext: CoreDataManager.instance.managedObjectContext)
}
}
```
#### Вместо заключения
Обратите внимание, что **CoreDataManager**, который мы создали, довольно универсален, в том смысле, что его можно использовать в любом приложении, основанном на Core Data. Единственное, что его связывает именно с нашим проектом, — это имя файла модели данных. Больше ничего. То есть, написав этот модуль один раз, вы можете им пользоваться постоянно в разных проектах.
В [следующей, заключительной части](https://habrahabr.ru/post/304586/), мы будем много работать со **`Storyboard`** и **`UITableViewController`**, познакомимся с **`NSFetchedResultsController`** и еще раз вспомним **`NSFetchRequest`**.
[Этот проект на GitHub](https://github.com/angryscorp/core-data-habrahabr-swift/archive/master.zip) | https://habr.com/ru/post/303798/ | null | ru | null |
# Мои маленькие реле: Тройной Brainfuck, или что такое безумие
*Рис.1: Релейный компьютер BrainfuckPC на фоне его автора*
Продолжая славную традицию ежегодного дайджеста моих самых безумных компьютерных проектов, представляю вам третью и **заключительную** статью о проекте релейного компьютера BrainfuckPC.
В прошлых сериях:
* [2017: Мои маленькие реле: Brainfuck компьютер это магия](https://habr.com/ru/post/402629/)
* [2018: Мои маленькие реле: Brainfuck компьютер это реальность](https://habr.com/ru/post/411145/)
После десяти лет мечтаний и раздумий, два с лишним года неспешной работы и сборки, могу с уверенностью сказать, что проект релейного компьютера состоялся. Несмотря на то, что компьютер бесполезен с практической точки зрения, к тому же еще и регулярно сбоит, он стал отправной точкой для следующих, не менее безумных кибер-проектов.
Под катом звенящие релейные блоки, самые быстрые в мире вычисления на реле, монтаж накруткой, вакуумные индикаторы, и многое другое.
Язык программирования brainfuck
-------------------------------
[Язык программирования brainfuck](https://ru.wikipedia.org/wiki/Brainfuck) — пожалуй, самый популярный в мире эзотерический язык программирования. А заодно самая настоящая [Тьюринг-полная трясина](https://ru.wikipedia.org/wiki/%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D0%BE%D0%B2%D1%81%D0%BA%D0%B0%D1%8F_%D1%82%D1%80%D1%8F%D1%81%D0%B8%D0%BD%D0%B0). Всего лишь 8 инструкций, на которых можно написать все что угодно, но очень долго.
К примеру, у меня ушло три дня на то, чтобы написать и отладить программу деления 355/113, которая печатает в терминал 6 знаков после запятой.
*Рис.2: Инструкции языка brainfuck*
Весь синтаксис языка строится вокруг ОЗУ на 30 тысяч ячеек памяти, с разрядностью 8 бит.
* Двумя инструкциями **+** и **-** мы изменяем значение в текущей ячейке данных на единицу вверх или вниз.
* Двумя инструкциями **<** и **>** мы изменяем на единицу указатель на текущую ячейку данных, тем самым перемещаясь по памяти влево или вправо.
* Еще две инструкции **[** и **]** — позволяют нам организовать циклы. Все что внутри скобок является телом цикла. Вложенные циклы допускаются. Логика инструкции проста — если значение текущей ячейки данных не равно нулю — мы выполним одну итерацию цикла, если равно — то выходим из цикла.
* Последние две инструкции **.** и **,** — позволяют вывести значение текущей ячейки в консоль, или ввести его ОЗУ. Тем самым достигается интерактивность.
Да, этого более чем достаточно для написания любой программы. Существование компиляторов из языка [C в brainfuck](https://github.com/arthaud/c2bf) как бы намекает об этом. Но плотность кода — никакущая. Для выполнения простейших операций, например сложения значений двух ячеек памяти, требуется исполнить сотни инструкций brainfuck.
### brainfuck++
Попробуем хоть немного, но повысить плотность кода. Изучая программы, написанные на этом языке, можно обратить внимание, что в большинстве своем они состоят из последовательностей одних и тех же инструкций **+ — < >**. Это наводит многих на мысль свернуть последовательность таких инструкций в одну и получить небольшой прирост производительности, который от программы к программе может составлять как десятки процентов, так давать и многократный прирост скорости. Например, 10 операций инкремента мы заменяем на операцию +10. 20 операций сдвига указателя вправо на операцию >20 и так далее.
*Рис.3: Инструкции языка brainfuck++*
### От теории к практике
Как вы понимаете, нельзя просто так взять и написать на языке brainfuck операцию Rb = Ra+Rb, где Ra, и Rb — ячейки памяти. Все что мы можем — это изменять на константу содержимое некоторой ячейки и проверять не нуль ли она. В итоге, чтобы сложить два числа, все что нам остается, так это делать +1 для ячейки Rb и -1 для ячейки Ra, до тех пор, пока содержимое ячейки Ra не станет равным нулю. Напишем сие в виде кода на С:
```
/*(mem+RbPos) += *mem
*/
void addMov(Memory &mem, uint16_t RbPos)
{
while (*mem)
{
mem += RbPos;
(*mem)++;
mem -= RbPos;
(*mem)--;
}
}
```
Как результат — в ячейке RbPos окажется старое значение плюс то, что было по исходному адресу. класс Memory — контейнер с 65к целочисленных ячеек. Главное его свойство — переполнение значения указателя вернет его в начало массива. Как в моем реальном железе.
Недостаток описанной функции — потеря исходного значения — оно обнулится. Добавим еще одну переменную Rc, чтобы сохранить его:
```
/*
*(mem+RcPos) = *mem
*(mem+RbPos) += *mem
*/
void addCpy(Memory &mem, uint16_t RbPos, uint16_t RcPos)
{
while (*mem)
{
mem += RbPos;
(*mem)++;
mem -= RbPos;
(*mem)--;
mem += RcPos;
(*mem)++;
mem -= RcPos;
}
}
```
В результате в ячейке RcPos будет лежать скопированное слагаемое. Ну, в том случае если раньше там был нуль.
Поскольку использованная мной нотация очень сильно напоминает brainfuck++ — просто перепишем нашу функцию в символах bfpp, приняв для примера RbPos за 4 и RcPos за 5:
`[
>>>>
+
<<<<
-
>>>>>
+
<<<<<
]`
Описав все примитивы, можно начать комбинировать их в более сложные конструкции и получать программу необходимого функционала. В итоге, можно получить программу, которая делит 355 на 113 (или любые другие числа друг на друга в пределах 16 бит)
**Программа деления с плавающей точкой**
```
class Memory {
public:
Memory()
{
memset(m_mem, 0, sizeof(m_mem));
memPtr = 0;
}
Memory& operator += (uint16_t ptr)
{
memPtr += ptr;
return *this;
}
Memory& operator -= (uint16_t ptr)
{
memPtr -= ptr;
return *this;
}
uint16_t& operator [] (uint16_t ptr)
{
return this->m_mem[ptr];
}
Memory& operator = (uint16_t ptr)
{
memPtr = ptr;
return *this;
}
uint16_t & operator * ()
{
return m_mem[memPtr];
}
Memory& operator ++ ()
{
memPtr++;
return *this;
}
Memory& operator -- ()
{
memPtr--;
return *this;
}
private:
uint16_t memPtr;
uint16_t m_mem[65536];
};
void calcPi()
{
Memory mem;
*mem = 22;
mem += 1;
*mem = 7;
while (*mem)
{
mem += 1;
(*mem)++;
mem -= 1;
(*mem)--;
mem += 2;
(*mem)++;
mem -= 2;
}//correct -909
while (*mem)
{
(*mem)--;
}
mem -= 1;
while (*mem)
{
mem += 2;
while (*mem)
{
mem += 4;
(*mem)++;
mem -= 4;
(*mem)--;
}
mem += 4;
while (*mem)
{
(*mem)--;
mem -= 4;
(*mem)++;
mem -= 2;
(*mem)--;
if (!*mem)
{
//JZ out
goto out;
}
mem += 6;
}
mem -= 6;
out:
mem += 6;
if (*mem)
{
while (*mem)
{
mem -= 6;
(*mem)++;
mem += 6;
(*mem)--;
}
mem -= 6;
if (*mem)
goto out1;
}
mem -= 5;
(*mem)++;
mem -= 1;
}
out1:
mem += 10;
*mem += 0x50;//P
putc(*mem, stderr);
*mem += 0x19;//i
putc(*mem, stderr);
*mem -= 0x2C;//=
putc(*mem, stderr);
mem -= 9;
*mem += 0x30;
putc(*mem, stderr);
mem += 9;
*mem -= 0xf;
putc(*mem, stderr);
mem -= 10;
*mem += 6;
while (*mem)
{
(*mem)--;
mem += 1;//mem == 1
//nullCell(mem);
while (*mem)
{
(*mem)--;
}
mem += 1;
//mulConst(mem, 1, 10);
while (*mem)
{
(*mem)--;
mem -= 1;
(*mem) += 10;
mem += 1;
}
mem += 1;
//addCpy(mem, 1, 2);
while (*mem)
{
mem += 1;
(*mem)++;
mem -= 1;
(*mem)--;
mem += 2;
(*mem)++;
mem -= 2;
}
mem += 3;
//nullCell(mem);
while (*mem)
{
(*mem)--;
}
mem -= 5;
while (*mem)
{
mem += 4;
while (*mem)
{
mem += 6;
(*mem)++;
mem -= 6;
(*mem)--;
}
mem += 6;
while (*mem)
{
(*mem)--;
mem -= 6;
(*mem)++;
mem -= 4;
(*mem)--;
if (!*mem)//Да, грязный хак, доступный только для моего компьютера
{
goto out2;
}
mem += 10;
}
mem -= 10;
out2:
mem += 10;
if (*mem)
{
//addMov(mem, -(6+ 4));
while (*mem)
{
mem -= 10;
(*mem)++;
mem += 10;
(*mem)--;
}
mem -= 10;
if (*mem)
goto out3;
}
mem -= 5;
(*mem)++;
mem -= 5;
}
out3:
mem += 4;
while (*mem)
{
mem -= 3;
(*mem)++;
mem += 3;
(*mem)--;
}
mem += 1;//mem == 6
*mem += 0x30;
putc(*mem, stderr);
mem += 1;//mem == 7
while (*mem)
{
(*mem)--;
}
mem -= 3;
while (*mem)
{
mem -= 1;
(*mem)++;
mem += 1;
(*mem)--;
}
mem -= 4;// mem == 0
}
*mem += 0x0a;
putc(*mem, stderr);
*mem += 3;
putc(*mem, stderr);
}
```
Архитектура релейного компьютера
--------------------------------
Центральным элементом релейного процессора является 16-разрядный полный сумматор с параллельным переносом. К нему на вход подключены два регистра. TMP — временный регистр, в который помещается старое значение, и CMD — командный регистр, в котором хранится инструкция и константа, на которую будет изменяться старое значение.
Посему я могу исполнять операции оптимизированного brainfuck++, а заодно получить полноценные условные переходы — Jump If Zero и Jump If Not Zero в любую сторону программы.
Результат операции суммирования может быть выгружен либо в один из контектных регистров — AP — с номером текущей ячейки данных, или IP — с номером текущей инструкции. Кроме того, результат может быть выгружен в текущую ячейку ОЗУ, если речь идет об инструкциях **+** и **-**
*Рис.4: Архитектура релейного компьютера в работе. Стадия загрузки новой инструкции сменяется стадией ее исполнения.*
Первым делом, нам необходимо вычислить номер следующей инструкции — т.е. выполнить операцию IP++. Для этого, к старому значению IP-регистра прибавляется единица, результат записывается обратно в IP-регистр, и по этому новому адресу, в CMD-регистр, загружается очередная инструкция.
Вторым этапом начинается исполнение только что загруженной инструкции. Если она работает с сумматором, то процесс ее выполнения выглядит примерно так же как и процесс загрузки новой инструкции — старое значение во временный регистр, прибавляем лежающую в младших битах CMD-регистра константу, результат записываем обратно в регистр или текущую ячейку данных.
Таким образом, инструкция исполняется за один тик тактового генератора. По спадающему фронту загружаем очередную инструкцию, по нарастающему — исполняем ее.
**не баг, а фича**
И вот тут вскрылась одна особенность. После включения компьютера первый фронт тактового генератора будет нарастающим, а следовательно — мы должны будем исполнить текущую инструкцию, которую еще никто в CMD-регистр не загрузил — там нули.
Выполнили пустую инструкцию и… делаем IP++!
В итоге, нулевая ячейка памяти программы содержит нуль и никогда не будет исполнена. Первой загруженной из памяти инструкцией станет инструкция по адресу 0x0001.
#### Набор инструкций
*Рис.5: Набор инструкций релейного компьютера*
Инструкции — 16-разрядные, где 4 старших бита отвечают за тип инструкции и 12 младших бит — полезная нагрузка. В большинстве случаев это константа.
* Инструкция NOP — игнорируется.
* Инструкция CTRLIO — особая инструкция, поведение которой кодируется битовой маской полезной нагрузки. В первую очередь она реализует команды записи в консоль и чтения из консоли (в синхронном или асинхронном режимах). Во-вторых, она позволяет выставить 16-разрядный или 8-разрядный режим работы машины. Ну и в-третьих, с помощью инструкции CTRLIO.HALT можно остановить работу машины. Самое смешное, что биты маски
неблокирующие. Можно выставить их хоть все сразу, но поведение машины будет неопределено.
* Инструкция ADD — операция работы с ячейкой данных. Изменяет значение в ячейке на величину константы. При этом, бит.12 — знаковый бит и копируется в биты 13-15. Поэтому инструкция 0x2ffe превращается в операцию \*AP += 0x0ffe, а инструкция 0x3ffe — в \*AP += 0xfffe. Операция вычитания заменяется сложением с отрицательным числом.
* Инструкция ADA — реализует операцию AP+=const и позволяет перемещаться по памяти.
* Инструкции JZ и JNZ — условные. В зависимости от Z-флага позволяют либо совершить прыжок на несколько инструкций вперед или назад, либо остаться на месте. В зависимости от режима работы машины — 16 или 8 бит, состояние Z-флага определяется либо младшим байтом данных либо словом целиком.
Технические характеристики
--------------------------
**BrainfuckPC** — это 16-разрядный компьютер с процессором на базе герконовых реле, с архитектурой Фон-Неймана и набором инструкций Brainfuck++
* Общее число реле: 578 штук
* Общее число логических элементов: 157 штук
* Разрядность шины адреса: 16 бит
* Адресация: пословная
* ОЗУ: 128Кбайт (64 Кслов)
* Разрядность шины данных: 16бит/8бит
* Тактовая частота (текущая/максимальная): 25Гц/40Гц
* Потребляемая мощность: 70Вт
* Габаритные размеры: 110х650х140мм
* Масса: 15кг
Изначально предполагалось, что компьютер будет работать на частотах до 100Гц… А это — на минуточку — 4 пианинные октавы. К сожалению первые тесты показали, что 40Гц — это потолок, но и этого для релейной схемы безумно много. тем более что при внешнем тактировании необходимо подать два импульса на такт — из-за особенностей работы схемы синхронизации с внешним сигналом. 80Гц для музыки — уже что-то.
### Состав компьютера
*Рис.6: Основные узлы релейного компьютера.*
Рассмотрим компьютер поближе. Практически весь объем машины занимают блоки релейного процессора. В настоящий момент все уместилось в пять блоков, однако место есть для шести — так что если очень хочется, то впоследствии функционал процессора можно будет расширить.
Каждый такой блок содержит 32 модуля, в каждом модуле 3 или 4 герконовых реле РЭС55 и РЭС64. Питание каждого блока 5В, 3А.
*Рис.7: Комплект блоков и модулей релейного процессора, готовый к установе на раму.*
Каждый модуль — унифицирован. 60х44мм, разъем на 16 выводов. При сборке блоков логики я вставлял требуемый модуль в свободный разъем и прошивал соединения.
*Рис.8: Модули D-триггеров проверяются на работоспособность.*
Центральный ряд — блоки сумматора и регистровые блоки. Над ними и под ними — 16-разрядные защелки на базе РЭС43, комутирующие поток данных между блоками. Все данные крутятся именно тут.
Нижний ряд — ряд блоков логики процессора. Сейчас частично заполнены два блока, но если очень захочется — то модификация и расширение функционала за счет свободного места более чем возможна.
*Рис.9: Рама собрана из листового 2мм алюминия, из-под лазерной резки. На фото — уже сваренная и загрунтованная рама, готовая к покраске.*
Верхняя часть — индикаторная. Слева — блок состояния машины — индикаторы на базе ИВ-6 отображают номер текущей ячейки памяти и ночер текущей инструкции, непосредственно саму исполняемую инструкцию, а также общий счетчик исполненных инструкций. Последнее очень кстати, ибо если эмулятор, например, говорит, что до первого символа в консоли надо выполнить 30 тысяч инструкций, счетчик наглядно покажет где машина сейчас и когда закончит считать.
*Рис.10: Итоговый вид индикаторной области. В процессе изготовления.*
Справа — располагается плата памяти — самый спорный элемент машины. Хоть я и считаю, что компьютер таки релейный, однозначно 100% релейным является именно процессор. Периферия более современная. В частности — ОЗУ — это статические микросхемы памяти. Но так делают практически все современные создатели релейных компьютеров.
*Рис.11: Программатор. 16 линий адреса, 16 линий данных, питание, земля и линии чтения записи. Итого 36 контактов.*
Поскольку память программ и данных — общая, то кто-то или что-то, каждый раз при включеннии компьютера, должен загружать программу в ОЗУ. Эта задача и возложена на программатор. В настоящий момент программатор располагается на самой плате памяти. Сейчас у него ровно две задачи.
1. Загрузить программу в ОЗУ, ибо каждый раз при включении питания делать это вручную с помощью тумблеров банально лень, хотя и такая возможность присутствует.
2. Следить за состоянием некоторого региона памяти и отображать его на светодиодной матрице 32х16.
На работу процессора это никак не влияет, а видеть в реальном времени что происходит в ОЗУ — очень полезно при дебаге. Впоследствии, когда программатор будет внешним, светодиодную панель будет обслуживать один из индикаторных модулей. Адрес он уже знает, останется подать ему на вход данные.
*Рис.12: Структурная схема периферии процессора.*
Так в ближайшем будущем будет выглядеть схемотехника периферии процессора. На плате памяти останутся только сами микросхемы памяти и цепи согласования сигналов с релейной схемой.
Через 36-контактный разъем программирования можно будет подключить программатор и загрузить прошивку в компьютер. Кроме программатора, имея необходимый преобразователь интерфейса, можно будет воспользоваться любым другим устройством. Хоть считывателем перфолент (у меня, кстати, имеется один, в комплекте с перфоратором перфолент и даже одной катушкой ленты), хоть панелью с тумблерами.
В итоге, релейная логика обеспечивает некий интерфейс, а преобразователь интерфейса может быть любым. К слову, параллельный разъем интерфейса будет совместим с LPT…
### Демонстрация работы и текущий статус
В первую очередь, на компьютере была исполнена программа Hello World из статьи в википедии.
Исходный код выглядит следующим образом:
`++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.`
Благодаря светодиодной панели наглядно видно как изменяются данные:
Хотя и на частоте 25Гц сложно уследить за тем, что происходит в ОЗУ.
Более полезной и практической задачей является расчет знаков числа Pi после запятой. Понятно что современные компьютеры решили эту задачу [вплоть до 31,4 трлн знаков](https://nplus1.ru/news/2019/03/14/longest-pi). Но сам факт того, что BrainfuckPC способен выполнять эту операцию, говорит о том, что релейный компьютер бесполезен не на 100%, а всего лишь на 99.9.
В первую очередь я нашел уже готовый [некий алгоритм расчета написанный на brainfuck](https://github.com/radiolok/bfutils/blob/master/common/pi.bfk).
`> ++++ (4 digits)
[<+>>>>>>>>++++++++++<<<<<<<-]>+++++[<+++++++++>-]+>>>>>>+[<<+++[>>[-<]<[>]<-]>>
[>+>]<[<]>]>[[->>>>+<<<<]>>>+++>-]<[<<<<]<<<<<<<<+[->>>>>>>>>>>>[<+[->>>>+<<<<]>
>>>>]<<<<[>>>>>[<<<<+>>>>-]<<<<<-[<<++++++++++>>-]>>>[<<[<+<<+>>>-]<[>+<-]<++<<+
>>>>>>-]<<[-]<<-<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+<<<-[>>+<<-]<]<<<<+>>>>>>>
>[-]>[<<<+>>>-]<<++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+>[<<+<+>>>-]<<<
<+<+>>[-[-[-[-[-[-[-[-[-<->[-<+<->>]]]]]]]]]]<[+++++[<<<++++++++<++++++++>>>>-]<
<<<+<->>>>[>+<<<+++++++++<->>>-]<<<<<[>>+<<-]+<[->-<]>[>>.<<<<[+.[-]]>>-]>[>>.<<
-]>[-]>[-]>>>[>>[<<<<<<<<+>>>>>>>>-]<<-]]>>[-]<<<[-]<<<<<<<<]++++++++++.`
Одна проблема — хоть и говорится, что эта программа намного быстрее какой-то другой программы, все равно вычисляет очередной знак она крайне медленно.
*Рис.13: Время, затрачиваемое на вывод N знаков числа Pi после запятой.*
4 знака после запятой придется ждать почти полтора часа…
*Рис.14: — Пи=3! — Как грубо!*
Впрочем, даже два знака толком вывести не удалось, вместо них компьютер заявил что Пи равен 4 и завершил работу.
*Рис.15: Он явно знает про ту шутку, что в условии военного положения пи может доходить до четырех.*
Я решил пойти другим путем и написал программу вычисления дроби
. Точность — 6 знаков числа пи после запятой! Это самый точный результат для дробей с числами адекватного размера.
Спустя три бессонные ночи я таки написал программу на brainfuck, способную поделить два числа друг на друга и выводить полученный результат с плавающей точкой в терминал. Вердикт эмулятора следующий — потребуется исполнить 60 тысяч инструкций. В следнем по 10 тысяч на знак:
*Рис.16: Время, затрачиваемое на вывод очередного знако после запятой при вычислении дроби.*
Как быстро будут появляться очередные значения. Надо сказать весьма быстро по сравнению с прошлой программой!
Но счастье было недолгим — компьютер начал сбоить в 16-разрядном режиме. Диагностирование показало, что дурит плата памяти — постоянно выставляет 13-й бит. Сделаю новую плату памяти и все пройдет, а пока ограничусь дробью  двумя знаками после запятой и 8 разрядным режимом работы. Самое главное — она требует выполнить всего лишь 1600 инструкций! На частоте в 25Гц это — чуть более одной минуты.
Неоднократно и со свистом компьютер справляется с поставленной задачей.
### To be continued...
Сейчас на компьютере можно исполнять программы, которые не требуют ввода данных пользователем. Я банально до сих пор не накрутил инструкцию CTRLIO.CIN :) И не собираюсь делать это в ближайшее время. В настоящий момент компьютер завершен на 98%. И после двух лет работы накопилось множество проектов, которые ждут момента, когда я ими займусь.
**Поэтому я переключаюсь на другие проекты**
В первую очередь это ламповый компьютер на базе коммутаторных декатронов. У меня уже есть и перфоратор перфолент и сами декатроны (правда в основном А101 — на них компьютер выйдет еще медленнее чем релейный — нужны А103). Даже 700 вакуумных ламп уже имеется и много всего…
У меня и память для него заготовлена -[16 штук интегральных кубов памяти](http://www.155la3.ru/memory_cube_kp128.htm) на 128 16-разрядных слов каждый. Внутри — многоотверстные ферритовые пластины, эдакое ответвление от памяти на ферритовых кольцах.
[Про пневмонику я тоже не забываю](https://habr.com/ru/post/374309/) — мой товарищ Антон занимается натур. экспериментами, но об этом — в следующий раз.
… оставляя следующие недоделки. Часть задачу решу к фестивалю в конце мая, часть — нет:
* Новая плата памяти, на которой установлены только микросхемы ОЗУ и обвязка к ним. Схема платы памяти есть, печатная плата — еще не разведена. В домашних условиях ее будет лень делать (довольно плотная двухсторонка), посему включу эту плату в заказ, когда буду заказывать платы для пары других проектов — механических часов на реле и пневмоскопа.
* Вместе с новой платой памяти придут стрелочные индикаторы, нормальный крепеж терминального дисплея и самостоятельная логика обновления светодиодной панели.
* Программатор, вернее, разработка прошивки для него. Вообще, при наличии старой платы памяти он избыточен, но так как разъем программирования в наличии — уже можно загружать программу и им.
* Логика тактирования. Тут я совсем ленивая жопа, ибо там буквально обвязать 3 логических модуля. Это обязательно сделаю к фестивалю в конце мая.
* Инструкция чтения из консоли. Она завязана на логику тактирования (в синхронном режиме работы компьютер должен останавливать работу и ждать прихода данных).
* Отправить заявку в книгу рекордов Гиннеса… Как на самый быстрый релейный процессор и одновременно самый медленно-считающий. 16 миллиФлопс это вам не «Шубу в трусы заправлять» (из комментариев на youtube).
Вся документация по релейному компьютеру есть в [репозитории на GitHub](https://github.com/radiolok/RelayComputer2), а следить за его статусом можно в любой соцсети по ссылкам у меня в профиле.
UPD: От участия в фестивале я отказался.
~~И еще — 25–26 мая в Москве, на территории «Хлебозавода», пройдет первый фестиваль крафтовых производств и DIY-культуры [Antifactory](https://antifactory.ru/). Я там буду присутствовать с релейным компьютером и [релейный контроллер автополива](https://habr.com/ru/post/260643/) тоже привезу. Вход на мероприятие свободный, так что будете в эти дни в Москве — не упустите шанс увидеть моего релейного монстра вживую. Если довезу в целости и сохранности — обязательно продемонстрирую в работе.~~ | https://habr.com/ru/post/442732/ | null | ru | null |
# Рост хоккеистов: анализируем данные всех чемпионатов мира в текущем веке
[](http://image.spreadshirtmedia.com/image-server/v1/designs/13069879,width=280,height=280?mediaType=png)
На днях завершился очередной чемпионат мира по хоккею.
За просмотром матчей родилась идея. Когда в перерывах телевизионная камера показывает уходящих в раздевалку игроков, трудно не заметить, насколько они огромные. На фоне тренеров, функционеров команд, сотрудников ледовой арены, журналистов или просто фанатов они, как правило, выглядят очень внушительно.
**Вот, к примеру, восходящие звезды финского хоккея, Патрик Лайне и Александр Барков, вместе с преданными поклонниками**
[Источник](https://www.instagram.com/p/BFjNdn7zORh/?taken-by=jvgfi)
И я задался вопросами. Действительно ли хоккеисты выше обычных людей? Как изменяется рост хоккеистов со временем в сравнении с обычными людьми? Есть ли устойчивые межстрановые различия?
### Данные
IIHF, организация, проводящая чемпионаты мира по хоккею, каждый год публикует составы участвующих команд с информацией о росте и весе каждого игрока. Архив этих данных [тут](http://www.iihf.com/iihf-home/history/past-tournaments/).
Я собрал вместе данные всех чемпионатов мира с 2001 по 2016 годы. От года к году формат предоставления данных слегка меняется, что требует некоторых усилий по их очистке. Не представляя, как грамотно автоматизировать процесс, все данные копировал вручную, что заняло чуть больше 3 часов. Объединенный датасет [выложил в открытый доступ](https://dx.doi.org/10.6084/m9.figshare.3394735.v2).
**R code. Подготовка к работе, загрузка данных**
```
# load required packages
require(dplyr) # data manipulation
require(lubridate) # easy manipulations with dates
require(ggplot2) # visualization
require(ggthemes) # themes for ggplot2
require(cowplot) # nice alignment of the ggplots
require(RColorBrewer) # generate color palettes
require(texreg) # easy export of regression tables
require(xtable) # export a data frame into an html table
# download the IIHF data set; if there are some problems, you can download manually
# using the stable URL (https://dx.doi.org/10.6084/m9.figshare.3394735.v2)
df <- read.csv('https://ndownloader.figshare.com/files/5303173')
# color palette
brbg11 <- brewer.pal(11,'BrBG')
```
### Растут ли хоккеисты? Грубое (периодное) сравнение
Для начала сравним средний рост игроков на всех 16 чемпионатах мира.
**R code. Рисунок 1. Изменение среднего роста хоккеистов на чемпионатах мира, 2001-2016 гг.**
```
# mean height by championship
df_per <- df %>% group_by(year) %>%
summarise(height=mean(height))
gg_period_mean <- ggplot(df_per, aes(x=year,y=height))+
geom_point(size=3,color=brbg11[9])+
stat_smooth(method='lm',size=1,color=brbg11[11])+
ylab('height, cm')+
xlab('year of competition')+
scale_x_continuous(breaks=seq(2005,2015,5),labels=seq(2005,2015,5))+
theme_few(base_size = 15)+
theme(panel.grid=element_line(colour = 'grey75',size=.25))
gg_period_jitter <- ggplot(df, aes(x=year,y=height))+
geom_jitter(size=2,color=brbg11[9],alpha=.25,width = .75)+
stat_smooth(method='lm',size=1,se=F,color=brbg11[11])+
ylab('height, cm')+
xlab('year of competition')+
scale_x_continuous(breaks=seq(2005,2015,5),labels=seq(2005,2015,5))+
theme_few(base_size = 15)+
theme(panel.grid=element_line(colour = 'grey75',size=.25))
gg_period <- plot_grid(gg_period_mean,gg_period_jitter)
```
Положительный тренд очевиден. За полтора десятилетия средний рост хоккеиста на чемпионате мира увеличился почти на 2 сантиметра (левая панель). Как будто бы незначительный прирост на фоне довольно большой вариации (правая панель). Много это или мало? Чтобы ответить на вопрос, надо корректно сравнить с населением (но об этом ближе к концу статьи).
### Когортный анализ
Более корректный способ изучения изменения в росте подразумевает сравнение по когортам рождения. Тут мы сталкиваемся с любопытным нюансом — некоторые хоккеисты участвовали не в одном чемпионате мира. Вопрос: вычищать ли повторные записи для одних и тех же людей? Если нам интересен средний рост хоккеиста на чемпионате (как на картинке выше), пожалуй, не имеет смысла зачищать. Но если мы хотим проследить изменение роста хоккеистов как таковое, на мой взгляд, было бы неправильно присваивать больший вес тем игрокам, которые регулярнее попадали на чемпионаты мира. Поэтому для дальнейшего анализа я очистил данные от повторных записей одних и тех же игроков.
**R code. Подготовка данных к когортному анализу**
```
# remove double counts
dfu_h <- df %>% select(year,name,country,position,birth,cohort,height) %>%
spread(year,height)
dfu_h$av.height <- apply(dfu_h[,6:21],1,mean,na.rm=T)
dfu_h$times_participated <- apply(!is.na(dfu_h[,6:21]),1,sum)
dfu_w <- df %>% select(year,name,country,position,birth,cohort,weight) %>%
spread(year,weight)
dfu_w$av.weight <- apply(dfu_w[,6:21],1,mean,na.rm=T)
dfu <- left_join(dfu_h %>% select(name,country,position,birth,cohort,av.height,times_participated),
dfu_w %>% select(name,country,position,birth,cohort,av.weight),
by = c('name','country','position','birth','cohort')) %>%
mutate(bmi = av.weight/(av.height/100)^2)
```
Общее количество наблюдений сократилось с 6292 до 3333. Если хоккеист участвовал более чем в одном чемпионате мира, данные о росте и весе я усреднял, поскольку рост и (в особенности) вес отдельно взятого хоккеиста мог меняться со временем. Сколько же раз хоккеисты удостаиваются чести сыграть за национальные сборные на чемпионатах мира? В среднем чуть менее 2 раз.
**R code. Рисунок 2. Гистограмма распределения хоккеистов по количеству участий в ЧМ**
```
# frequencies of participation in world championships
mean(dfu$times_participated)
df_part <- as.data.frame(table(dfu$times_participated))
gg_times_part <- ggplot(df_part,aes(y=Freq,x=Var1))+
geom_bar(stat='identity',fill=brbg11[9])+
ylab('# of players')+
xlab('times participated (out of 16 possible)')+
theme_few(base_size = 15)
```
Но есть и уникумы. Посмотрим, кто из игроков принял участие как минимум в 10 чемпионатах мира. Таких игроков оказалось 14.
**R code. Таблица 1. Лидеры участия в чемпионатах мира**
```
# the leaders of participation in world championships
# save the table to html
leaders <- dfu %>% filter(times_participated > 9)
View(leaders)
print(xtable(leaders), type="html", file="table_leaders.html")
```
| | name | country | position | birth | cohort | av.height | times\_participated | av.weight | bmi |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | ovechkin alexander | RUS | F | 1985-09-17 | 1985 | 188.45 | 11 | 98.36 | 27.70 |
| 2 | nielsen daniel | DEN | D | 1980-10-31 | 1980 | 182.27 | 11 | 79.73 | 24.00 |
| 3 | staal kim | DEN | F | 1978-03-10 | 1978 | 182.00 | 10 | 87.80 | 26.51 |
| 4 | green morten | DEN | F | 1981-03-19 | 1981 | 183.00 | 12 | 85.83 | 25.63 |
| 5 | masalskis edgars | LAT | G | 1980-03-31 | 1980 | 176.00 | 12 | 79.17 | 25.56 |
| 6 | ambuhl andres | SUI | F | 1983-09-14 | 1983 | 176.80 | 10 | 83.70 | 26.78 |
| 7 | granak dominik | SVK | D | 1983-06-11 | 1983 | 182.00 | 10 | 79.50 | 24.00 |
| 8 | madsen morten | DEN | F | 1987-01-16 | 1987 | 189.82 | 11 | 86.00 | 23.87 |
| 9 | redlihs mikelis | LAT | F | 1984-07-01 | 1984 | 180.00 | 10 | 80.40 | 24.81 |
| 10 | cipulis martins | LAT | F | 1980-11-29 | 1980 | 180.70 | 10 | 82.10 | 25.14 |
| 11 | holos jonas | NOR | D | 1987-08-27 | 1987 | 180.18 | 11 | 91.36 | 28.14 |
| 12 | bastiansen anders | NOR | F | 1980-10-31 | 1980 | 190.00 | 11 | 93.64 | 25.94 |
| 13 | ask morten | NOR | F | 1980-05-14 | 1980 | 185.00 | 10 | 88.30 | 25.80 |
| 14 | forsberg kristian | NOR | F | 1986-05-05 | 1986 | 184.50 | 10 | 87.50 | 25.70 |
Александр Овечкин, 11 раз! Но тут надо отметить, что не для всех хоккеистов в принципе возможно было поучаствовать во всех 16 чемпионатах: зависит когорты рождения (насколько игровая карьера пересеклась именно с этим периодом наблюдения), от того, участвовала ли сборная игрока во всех чемпионатах мира (см. рисунок 3) и попадал ли игрок стабильно в сборную; наконец есть еще НХЛ, стабильно отвлекающий лучших из лучших от участия в чемпионатах мира.
**R code. Рисунок 3. Участие сборных в чемпионатах мира по хоккею в 2001-2016 гг.**
```
# countries times participated
df_cnt_part <- df %>% select(year,country,no) %>%
mutate(country=factor(paste(country))) %>%
group_by(country,year) %>%
summarise(value=sum(as.numeric(no))) %>%
mutate(value=1) %>%
ungroup() %>%
mutate(country=factor(country, levels = rev(levels(country))),
year=factor(year))
d_cnt_n <- df_cnt_part %>% group_by(country) %>%
summarise(n=sum(value))
gg_cnt_part <- ggplot(data = df_cnt_part, aes(x=year,y=country))+
geom_point(color=brbg11[11],size=7)+
geom_text(data=d_cnt_n,aes(y=country,x=17.5,label=n,color=n),size=7,fontface=2)+
geom_text(data=d_cnt_n,aes(y=country,x=18.5,label=' '),size=7)+
scale_color_gradientn(colours = brbg11[7:11])+
xlab(NULL)+
ylab(NULL)+
theme_bw(base_size = 25)+
theme(legend.position='none',
axis.text.x = element_text(angle = 90, hjust = 1,vjust=0.5))
```
### Растут ли хоккеисты? Регрессионный анализ
Регрессионный анализ позволяет более корректно ответить на вопрос об изменении роста игроков. В данном случаем с помощью мультиноминальной линейной регрессии предсказыватся рост хоккеиста в зависимость от когорты рождения. Включая в спецификацию регресиионной модели различные дополнительные (контрольные) переменные, мы получаем значение наиболее интересующего нас коэффициента "при прочих равных". Например, добавляя к объясняющим переменным помимо когорты рождения позицию игрока на поле, мы получаем взаимосвязь роста и когорты, очищенную от эффекта различий в зависимости от позиции; добавляя в контрольны переменные страны, получаем результат, очищенный от межстрановых различий. Разумеется, если контрольные переменные сами оказываются значимыми, на это тоже стоит обратить внимание.
Регрессионные модели (особенно линейные регрессии) очень чувствительны к выбросам (см., например, [эту статью](https://habrahabr.ru/post/251225/)). Не вдаваясь глубоко в эту обширную тему, я лишь убрал из анализа когорты, для которых мы имеем слишком небольшое количество представителей.
**R code. Убираем маленькие когорты**
```
# remove small cohorts
table(dfu$cohort)
dfuc <- dfu %>% filter(cohort<1997,cohort>1963)
```
Не желая резать данные сильно, я убрал только когорты 1963, 1997 и 1998 годов рождения, для которых у нас есть менее 10 игроков.
Итак, результаты рагрессионного анализа. В каждой следующей модели я добавляю одну переменную.
**Зависимая переменная**: рост хоккеиста.
**Объясняющие перемеенные**: 1) когорта рождения; 2) + позиция на поле (сравнение с защитниками); 3) + страна (сравнение с Россией).
**R code. Таблица 2. Результаты регрессионного анализа**
```
# relevel counrty variable to compare with Russia
dfuc$country <- relevel(dfuc$country,ref = 'RUS')
# regression models
m1 <- lm(data = dfuc,av.height~cohort)
m2 <- lm(data = dfuc,av.height~cohort+position)
m3 <- lm(data = dfuc,av.height~cohort+position+country)
# export the models to html
htmlreg(list(m1,m2,m3),file = 'models_height.html',single.row = T)
```
Statistical models| | **Model 1** | **Model 2** | **Model 3** |
| (Intercept) | -10.17 (27.67) | -18.64 (27.01) | 32.59 (27.00) |
| cohort | 0.10 (0.01)\*\*\* | 0.10 (0.01)\*\*\* | 0.08 (0.01)\*\*\* |
| positionF | | -2.59 (0.20)\*\*\* | -2.59 (0.20)\*\*\* |
| positionG | | -1.96 (0.31)\*\*\* | -1.93 (0.30)\*\*\* |
| countryAUT | | | -0.94 (0.55) |
| countryBLR | | | -0.95 (0.53) |
| countryCAN | | | 1.13 (0.46)\* |
| countryCZE | | | 0.56 (0.49) |
| countryDEN | | | -0.10 (0.56) |
| countryFIN | | | 0.20 (0.50) |
| countryFRA | | | -2.19 (0.69)\*\* |
| countryGER | | | -0.61 (0.51) |
| countryHUN | | | -0.61 (0.86) |
| countryITA | | | -3.58 (0.61)\*\*\* |
| countryJPN | | | -5.24 (0.71)\*\*\* |
| countryKAZ | | | -1.16 (0.57)\* |
| countryLAT | | | -1.38 (0.55)\* |
| countryNOR | | | -1.61 (0.62)\*\* |
| countryPOL | | | 0.06 (1.12) |
| countrySLO | | | -1.55 (0.58)\*\* |
| countrySUI | | | -1.80 (0.53)\*\*\* |
| countrySVK | | | 1.44 (0.50)\*\* |
| countrySWE | | | 1.18 (0.48)\* |
| countryUKR | | | -1.82 (0.59)\*\* |
| countryUSA | | | 0.54 (0.45) |
| R2 | 0.01 | 0.06 | 0.13 |
| Adj. R2 | 0.01 | 0.06 | 0.12 |
| Num. obs. | 3319 | 3319 | 3319 |
| RMSE | 5.40 | 5.27 | 5.10 |
| \*\*\*p < 0.001, \*\*p < 0.01, \*p < 0.05 |
#### Интерпретация моделей
**Модель 1**. Увеличение когорты на один год соответсвует увеличению роста хоккеистов на 0.1 см. Коэффициент статистически значим, но при этом модель объясняет лишь 1% вариации зависимой переменной. В принципе это не проблема, поскольку моделирование носит объясняющий характер, задача предсказания не ставится. Тем не менее, низкий коэффициент детерминации показывает, что должны быть другие переменные, гораздо лучше объясняющие различия между хоккеистами в росте.
**Модель 2**. Защитники — самые высокие игроки в хоккее. Вратари ниже на 2 см, нападающие — на 2.6 см. Все коэффициенты статистически значимы. Объясненная вариация зависимой переменной возрастает до 6%. При этом коэффициент при переменной *когорта рождения* не изменяется.
**Модель 3**. Добавление контрольных переменных для стран любопытно по двум причинам. Во-первых, некоторые различия статистически значимы и интересны сами по себе. Так, например, шведы, словаки и канадцы статистически значимо выше наших игроков. Большинство же наций значительно ниже нас, японцы аж на 5.2 см, итальянцы — на 3.6 см, французы — на 2.2 см (см. также рисунок 4). Во-вторых, введение контрольных переменных для стран значительно уменьшает коэффициент при переменной *когорта рождения* — до 0.08. Это значит, что межстрановые различия объясняют часть различий по когортам рождения. Коэффициент детерминации модели возрастает до 13%.
**R code. Рисунок 4. Рост хоккеистов по странам**
```
# players' height by country
gg_av.h_country <- ggplot(dfuc ,aes(x=factor(cohort),y=av.height))+
geom_point(color='grey50',alpha=.25)+
stat_summary(aes(group=country),geom='line',fun.y = mean,size=.5,color='grey50')+
stat_smooth(aes(group=country,color=country),geom='line',size=1)+
#geom_hline(yintercept = mean(height),color='red',size=.5)+
facet_wrap(~country,ncol=4)+
coord_cartesian(ylim = c(170,195))+
scale_x_discrete(labels=paste(seq(1965,1995,10)),breaks=paste(seq(1965,1995,10)))+
theme_few(base_size = 15)+
theme(legend.position='none',
panel.grid=element_line(colour = 'grey75',size=.25))
```
Наиболее полная модель показывает, что увеличение роста хоккеистов происходит со скоростью 0.08 см в год. Это означает прирост 0.8 см за десятилетие или на 2.56 см за 32 года с 1964 по 1996. Обратите внимание, что при учете контрольных переменных скорость увеличения роста хоккеистов оказывается примерно в полтора раза ниже, чем при более грубом анализе средних значений (рисунок 1): 0.8 см за десятилетие против примерно 1.2 см.
Прежде чем мы, наконец, постараемся понять, насколько значительным оказывается увеличение роста, хочу обратить внимание еще на один любопытный момент. Введение контрольных переменных подразумевает фиксацию различий между категориями при едином наклоне регрессионной линии (единый коэффициент при главной объясняющей переменной). Это не всегда хорошо и может замаскировать значительные различия в тесноте связи между исследуемыми переменными в подвыборках. Так, например, раздельное моделирование зависимости роста игроков от амплуа (рисунок 5) показывает, что взаимосвязь наиболее ярко выражена для вратарей и наименее заметна для защитников.
**R code. Рисунок 5. Корреляция между ростом и когортой раздельно для защитников, форвардов и вратарей**
```
dfuc_pos <- dfuc
levels(dfuc_pos$position) <- c('Defenders','Forwards','Goalkeeprs')
gg_pos <- ggplot(dfuc_pos ,aes(x=cohort,y=av.height))+
geom_jitter(aes(color=position),alpha=.5)+
stat_smooth(method = 'lm', se = T,color=brbg11[11],size=1)+
scale_x_continuous(labels=seq(1965,1995,5),breaks=seq(1965,1995,5))+
scale_color_manual(values = brbg11[c(8,4,10)])+
facet_wrap(~position,ncol=3)+
xlab('birth cohort')+
ylab('height, cm')+
theme_few(base_size = 20)+
theme(legend.position='none',
panel.grid=element_line(colour = 'grey75',size=.25))
```
**R code. Таблица 3. Модель 3 раздельно для подвыборок защитников, форвардов и вратарей**
```
# separate models for positions
m3d <- lm(data = dfuc %>% filter(position=='D'),av.height~cohort+country)
m3f <- lm(data = dfuc %>% filter(position=='F'),av.height~cohort+country)
m3g <- lm(data = dfuc %>% filter(position=='G'),av.height~cohort+country)
htmlreg(list(m3d,m3f,m3g),file = '2016/160500 Hockey players/models_height_pos.html',single.row = T,
custom.model.names = c('Model 3 D','Model 3 F','Model 3 G'))
```
Statistical models| | **Model 3 D** | **Model 3 F** | **Model 3 G** |
| (Intercept) | 108.45 (46.46)\* | 49.32 (36.73) | -295.76 (74.61)\*\*\* |
| cohort | 0.04 (0.02) | 0.07 (0.02)\*\*\* | 0.24 (0.04)\*\*\* |
| countryAUT | 0.14 (0.96) | -2.01 (0.75)\*\* | 0.47 (1.47) |
| countryBLR | 0.30 (0.87) | -1.53 (0.73)\* | -2.73 (1.55) |
| countryCAN | 1.55 (0.78)\* | 0.39 (0.62) | 3.45 (1.26)\*\* |
| countryCZE | 0.87 (0.84) | 0.30 (0.67) | 0.63 (1.36) |
| countryDEN | -0.60 (0.95) | 0.10 (0.75) | -0.19 (1.62) |
| countryFIN | -0.55 (0.89) | -0.04 (0.67) | 2.40 (1.32) |
| countryFRA | -3.34 (1.15)\*\* | -2.06 (0.93)\* | 1.39 (2.07) |
| countryGER | 0.48 (0.85) | -1.40 (0.72) | -0.65 (1.33) |
| countryHUN | -1.32 (1.47) | -0.70 (1.16) | 0.65 (2.39) |
| countryITA | -2.08 (1.08) | -4.78 (0.82)\*\*\* | -2.02 (1.62) |
| countryJPN | -4.13 (1.26)\*\* | -6.52 (0.94)\*\*\* | -2.27 (1.98) |
| countryKAZ | -1.23 (0.95) | -1.82 (0.79)\* | 1.79 (1.58) |
| countryLAT | -0.73 (0.95) | -1.39 (0.75) | -3.42 (1.49)\* |
| countryNOR | -3.25 (1.07)\*\* | -1.06 (0.85) | -0.10 (1.66) |
| countryPOL | 0.82 (1.89) | -0.58 (1.55) | 0.37 (2.97) |
| countrySLO | -1.57 (0.99) | -1.54 (0.79) | -2.25 (1.66) |
| countrySUI | -1.98 (0.91)\* | -2.36 (0.71)\*\*\* | 1.12 (1.47) |
| countrySVK | 2.94 (0.87)\*\*\* | 0.81 (0.67) | -0.70 (1.50) |
| countrySWE | 0.75 (0.81) | 1.24 (0.65) | 1.37 (1.33) |
| countryUKR | -1.37 (1.01) | -1.77 (0.80)\* | -3.71 (1.66)\* |
| countryUSA | 0.76 (0.78) | -0.08 (0.62) | 2.58 (1.26)\* |
| R2 | 0.09 | 0.10 | 0.24 |
| Adj. R2 | 0.07 | 0.09 | 0.20 |
| Num. obs. | 1094 | 1824 | 401 |
| RMSE | 5.08 | 5.08 | 4.87 |
| \*\*\*p < 0.001, \*\*p < 0.01, \*p < 0.05 |
Раздельное моделирование показывает, что в когортах 1964-1996 годов рождения, средний рост хоккеистов, участвовавших в чемпионатах мира в 2001-2016 годах, увеличивался со скоростью 0.4 см за десятиление для защитников, 0.7 см — для нападающих и (!) 2.4 см — для вратарей. За три десятиления средний рост вратарей увеличился на 7 см!
Пришло время сравнить эти изменения со средними значениями для населения.
### Сравнение с населением
Результаты регрессионного анализа фиксируют значительные межстрановые различия. Поэтому сравнивать имеет смысл по странам: хоккеистов определенной страны с мужским населением этой же страны.
Для сравнения роста хоккеистов со средними показателями мужского населения я использовал данные из [релевантной научной статьи](https://dx.doi.org/10.1016/j.ehb.2010.03.001) ([PDF](http://www.sciencedirect.com.sci-hub.cc/science/article/pii/S1570677X10000225)). Данные я скопировал из статьи (использовав замечательную программку [tabula](http://tabula.technology/)) и тоже [разместил в открытом доступе](http://doi.org/10.1016/j.ehb.2010.03.001).
**R code. Загрузка данных Hatton, T. J., & Bray, B. E. (2010) и подготовка к анализу**
```
# download the data from Hatton, T. J., & Bray, B. E. (2010).
# Long run trends in the heights of European men, 19th–20th centuries.
# Economics & Human Biology, 8(3), 405–413.
# http://doi.org/10.1016/j.ehb.2010.03.001
# stable URL, copied data (https://dx.doi.org/10.6084/m9.figshare.3394795.v1)
df_hb <- read.csv('https://ndownloader.figshare.com/files/5303878')
df_hb <- df_hb %>%
gather('country','h_pop',2:16) %>%
mutate(period=paste(period)) %>%
separate(period,c('t1','t2'),sep = '/')%>%
transmute(cohort=(as.numeric(t1)+as.numeric(t2))/2,country,h_pop)
# calculate hockey players' cohort height averages for each country
df_hoc <- dfu %>% group_by(country,cohort) %>%
summarise(h_hp=mean(av.height)) %>%
ungroup()
```
К сожалению, данные о динамике роста населения пересекаются лишь с 8 странами из моего хоккейного датасета: Австрия, Дания, Финляндия, Франция, Германия, Италия, Норвегия, Швеция.
**R code. Пересекающиеся данные**
```
# countries in both data sets
both_cnt <- levels(factor(df_hb$country))[which(levels(factor(df_hb$country)) %in% levels(df_hoc$country))]
both_cnt
```
**R code. Рисунок 6. Сравнение динамики увеличения роста мужского населения и хоккеистов. Примечание: зеленый цвет - мужское население; коричневый цвет - хоккеисты.**
```
gg_hoc_vs_pop <- ggplot()+
geom_path(data = df_hb %>% filter(country %in% both_cnt), aes(x=cohort,y=h_pop),
color=brbg11[9],size=1)+
geom_point(data = df_hb %>% filter(country %in% both_cnt), aes(x=cohort,y=h_pop),
color=brbg11[9],size=2)+
geom_point(data = df_hb %>% filter(country %in% both_cnt), aes(x=cohort,y=h_pop),
color='white',size=1.5)+
geom_point(data = df_hoc %>% filter(country %in% both_cnt), aes(x=cohort,y=h_hp),
color=brbg11[3],size=2,pch=18)+
stat_smooth(data = df_hoc %>% filter(country %in% both_cnt), aes(x=cohort,y=h_hp),
method='lm',se=F,color=brbg11[1],size=1)+
facet_wrap(~country,ncol=2)+
ylab('height, cm')+
xlab('birth cohort')+
theme_few(base_size = 15)+
theme(panel.grid=element_line(colour = 'grey75',size=.25))
```
Во всех проанализировнных странах хоккеисты выше стеднестатистических мужчин на 2-5 см. Но это не удивительно — в спорте значительная селекция.
Примечательно другое. В развитых странах мира особенно бурное увеличение роста мужского населения происходило в первой середине 20 века. В когортах примерно 1960-х годов рождения рост мужчин приблизился к плато и пеерстал бурно увеличиваться. Тренд среднего роста хоккеистов во всех странах (кроме почему-то Дании) как будто бы продолжил приостановившийся многолетний тренд всего мужского населения.
Для когорт европейцев, родившихся в первой половине 20 века, темпы увеличения среднего роста варьировались от 1.18 до 1.74 см за десятилетие в зависимости от страны (рисунок 7). Начиная с 1960-х годов этот показатель опустился до уровня 0.15-0.80 за 10 лет.
**R code. Рисунок 7. Средняя динамика роста мужского населения**
```
# growth in population
df_hb_w <- df_hb %>% spread(cohort,h_pop)
names(df_hb_w)[2:26] <- paste('y',names(df_hb_w)[2:26])
diffs <- df_hb_w[,3:26]-df_hb_w[,2:25]
df_hb_gr<- df_hb_w %>%
transmute(country,
gr_1961_1980 = unname(apply(diffs[,22:24],1,mean,na.rm=T))*2,
gr_1901_1960 = unname(apply(diffs[,9:21],1,mean,na.rm=T))*2,
gr_1856_1900 = unname(apply(diffs[,1:8],1,mean,na.rm=T))*2) %>%
gather('period','average_growth',2:4) %>%
filter(country %in% both_cnt) %>%
mutate(country=factor(country,levels = rev(levels(factor(country)))),
period=factor(period,labels = c('1856-1900','1901-1960','1961-1980')))
gg_hb_growth <- ggplot(df_hb_gr, aes(x=average_growth,y=country))+
geom_point(aes(color=period),size=3)+
scale_color_manual(values = brbg11[c(8,3,10)])+
scale_x_continuous(limits=c(0,2))+
facet_wrap(~period)+
theme_few()+
xlab("average growth in men's height over 10 years, cm")+
ylab(NULL)+
theme_few(base_size = 20)+
theme(legend.position='none',
panel.grid=element_line(colour = 'grey75',size=.25))
```
На фоне стагнирующего тренда в населении увеличение роста хоккеистов выглядит весьма внушительным. А акселерация среди вратарей вообще беспрецедентна.
Не стоит забывать и про селекцию. Расхождение трендов в населении и среди хоккеистов, вероятно, свидетельствует об усиливающейся селекции — хоккей требует все большего роста для успешной карьеры.
### Селекция в спорте
Проглядывая научную литературу по теме я наткнулся на [примечательный результат](https://dx.doi.org/10.1080/02640410600908001). Оказывается, в профессиональном спорте преобладают люди, рожденные в первой половине года. Объясняется это тем, что спортивные секции, как правило, формируют детские команды по когортам рождения. Таким образом, рожденные в начале года, всегда имеют чуть больше прожитого времени за плечами, что зачастую прямо выражается в физическом превосходстве над сверстниками, рожденными под конец года. Нетрудно проверить этот результат на нашем датасете.
**R code. Рисунок 8. Распределение хоккеистов по месяцам рождения**
```
# check if there are more players born in earlier months
df_month <- df %>% mutate(month=month(birth)) %>%
mutate(month=factor(month,levels = rev(levels(factor(month)))))
gg_month <- ggplot(df_month,aes(x=factor(month)))+
geom_bar(stat='count',fill=brbg11[8])+
scale_x_discrete(breaks=1:12,labels=month.name)+
xlab('month of birth')+
coord_flip()+
theme_few(base_size = 20)+
theme(legend.position='none',
panel.grid=element_line(colour = 'grey75',size=.25))
```
Действительно, респределение довольно сильно смещено в сторону ранних месяцев. Если разбить данные по декадам рождения, то невооруженным глазом видно, что эффект усиливается со временем (рисунок 9). Косвенно это свидетельствует о том, что селекция в хоккее становится жестче.
**R code. Рисунок 9. Распределение хоккеистов по месяцам рождения, раздельно по декадам рождения**
```
# facet by decades
df_month_dec <- df_month %>%
mutate(dec=factor(substr(paste(cohort),3,3),labels = paste('born in',c('1960s','1970s','1980s','1990s'))))
gg_month_dec <- ggplot(df_month_dec,aes(x=factor(month)))+
geom_bar(stat='count',fill=brbg11[8])+
scale_x_discrete(breaks=1:12,labels=month.abb)+
xlab('month of birth')+
facet_wrap(~dec,ncol=2,scales = 'free')+
theme_few(base_size = 20)+
theme(legend.position='none',
panel.grid=element_line(colour = 'grey75',size=.25))
```
### На будущее
Любопытно будет посмотреть, влияют ли физические данные на игровую статистику хоккеистов. Наткнулся на занимательную статью, [опубликованную](https://dx.doi.org/10.1098/rspb.2008.0873) в очень приличном научном журнале, в которой авторы нашли корреляцию между соотношением пропорций лица хоккеиста и средним количеством штрафных минут за игру.
**График из указанной статьи**
[Источник](http://rspb.royalsocietypublishing.org/content/275/1651/2651)
### Reproducibility
Полный R скрипт, воспроизводящий результаты моей статьи, [тут](https://dx.doi.org/10.6084/m9.figshare.3395983.v1).
Использована версия R-3.2.4
Все пакеты по состоянию на 2016-03-14. В случае пакетных несовместимостей, данный код будет гарантированно воспроизведен при использовании пакета [checkpoint](https://cran.r-project.org/web/packages/checkpoint/index.html) с указанием соответствующей даты. | https://habr.com/ru/post/301340/ | null | ru | null |
# Hashing
It is an efficient searching technique. Searching is a widespread operation on any data structure. Hashing is used to search specific records from a large domain of records. If we can efficiently search a record out of many records, we easily perform different operations on that data. Hashing is storing and retrieving data from the database in the order of O(1) time. We can also call it the mapping technique because we try to map smaller values into larger values by using hashing.
Following are the significant terminologies related to hashing
**Search Key**
In the database, we usually perform searching with the help of some keys. These keys are called search keys. If we take the student data, then we search by some registration number. This registration number is a search key. We have to put the search keys in hash tables.
**Hash Table**
It is a data structure that provides us the methodology to store data properly. A hash table is shown below. It is similar to an array. And we have indexes in it also like an array.
**Hash Function**
When we perform searching, inserting, or deleting some data from it, we don’t need to scan the whole table. With the help of a hash function, we will perform it with the order of O(1) time. There are different hash functions such as:
* K mod 10
* K mod n
* Mid Square
* Folding Method
‘K mod 10’ and ‘K mod n’ are the most widely used methods.
Suppose we have a number 24 and hash function ‘K mod 10’.With the help of the hash function, we will map 24 in the hash table. For this purpose, we can put K is equal to 24 so:
*24 mod 10 = 4*
So we can place 24 at index 4 in the hash table. Then for 52 number
*52 mod 10 = 2*
52 will go to index 2 location. Next for number 91
*91 mod 10 = 1*
So, 91 will be placed at index 1 in the table. Then finally for 67
*67 mod 10 = 7*
A hash table uses two components:
* Hash function
* Bucket Array
For an element key pair, the hash function calculates some value based on a key. A hash function is a function with a key as an input parameter. A hash function will give us two parts:
**Hash Codes**
In this, we assign an integer to the key. It is going to map the key to some integer.
**Compression Map**
It will convert the integer, or rather it will map the integer which we have received from the hash code to an integer in the range 0 to n-1. Once we have the hash function of the key, we would first receive an integer, and then map that integer to 0 to n-1. So the outcome of the hash code or the outcome of the hash function will be an integer in the range 0 to the n-1. This integer depends on the key of the input element.
In the bucket array, we are going to store the element in an array of hash functions of the key. So once we will receive an integer in the range 0 to n minus 1.So, we will store the element in an array of not just the key but the array of hash function of the key. So, once we do this, the keys no longer have to be integers. Also, we don’t need to know the range of keys because we are going to map it into a range which is provided by us.
**Hash Code**
Hash code is a function that converts a key to an integer. So it's going to convert a key of any type to an integer.
Following are some properties of a good hash code:
* It will minimize collisions. It means that if we are given two keys that are different, their hash codes should also be different. So if two keys say ‘K1’ does not equal ‘K2’.
*K1 ≠K2*
It implies that the hash code of key 1 should also not equal to the hash code of key 2.If two keys are a map to the same hash code, then we say a collision has occurred. We don’t want this. We want different hash codes for different keys. So we want to minimize collisions.
* A good hashcode should be uniform. If we have a key ‘K1’ and that is equal to key ‘K2’.
*K1 = K2*
Then we don’t need different answers for hash code. Because for the same value of the key, if we run our hash code, then we should always get the same value of the hash code. So if both keys are equal, then the hash code of Key 1 has to equal the hash code of Key 2.
*hash(K1) = hash(K2)*
**Hash Code Map Example**
***Memory Address***
In this, we are going to interpret the memory address of the key as the hash code. So we are going to take the memory address of the key as the hash code of the key.
Let's take an example of it. We have a key 1, and this is at a memory address of 5000. Then we have key 2, and this is at memory address 5010.
 *Hash(K1) = 5000*
*Hash(K2) = 5010*
It can be seen that the key, whatever the data type it may be, has arrived at an integer that maps to that data.
*Disadvantage*
The disadvantage of this hash code is that this is not uniform.
***Integer Cast***
It is a method of mapping to an integer. In this, whatever the data type of the key may be, typecast it to an integer. So if we have a string and we typecast a character of that string, it is going to return an ASCII value to us. And thereby, we will get an integer.
*Disadvantage*
Its disadvantage is that for data types like double or float, we encounter a loss of data. And a lot of collisions will occur in this method.
***Component Sum***
It is a type of hash code in which the partition bits of the key into fixed-length components. Suppose we have a float or a double that’s going to be 64 bits for us. We will partition them into a fixed bit component. So we will partition these 64 bits into two 32 bits. Then we will add these two 32 bits to get a 32-bit hash code after ignoring overflow.
Suppose we use a string case. And We have a key that is equal to the string ‘NAME’. So, in this case, we will not directly typecast this to an integer. We will divide this into four 32 bit segments. Then we will add these values. For each of these values, we take ASCII values of each of these characters. Then we will get the final hash code by adding each of these values.
*Key = ‘NAME’*
*ASC(N) + ASC(A) + ASC(M) + ASC(E)*
*Hash Code (Key) = X*
Disadvantage
Its disadvantage is that a lot of collisions can occur with different arrangements of various segments.
***Polynomial Accumulation***
In this, firstly, we divide a key into different segments like component sum. But in polynomial accumulation, we just take some variables or integers or some non-zero constant.
Suppose we have a key that is equal to a string ‘CODE’. We will divide this key into 32-bit segments. Then we will take the ASCII value of each of the string characters. Then we will take the sum of ASCII of each character into non-zero constant ( a ).
*Key = ‘CODE’*
*( ASC(C) x a0 )+( ASC(O) x a1) + (ASC(D) x a2) + (ASC(E) x a3)*
*Hash Code (Key, a)*
In this, if we change the arrangement of letters, the hash code is also going to change. For the same keys, we will get the same hash code. For the different keys, we will get different hash codes. Now let's take a look at the program of hash code. Let's say that key is going to be an array. Elements of this array will contain 32-bit segments which we have divided our key into. At position 0, we will have ASCII of ‘C’. At position 1,2, and 3, we will have ASCII of ‘O’,’D’, and ‘E’. Now program to calculate the hash code is:
```
for(i= n-1 ; i > = 0 ; i--){
sum = ( sum * a ) + arr[i];
}
arr[ C , O , D , E ]
i = 3 , sum = E ;
i = 2 , sum = Ea + D ;
i = 1 , sum = Ea2+ Da + O;
i = 0 , sum = Ea3+ Da2+ Oa + C;
```
**Hashing Techniques to Resolve Collision**
When we calculate some hash function or location or address for keys and use that same hash function. That hash function will give the same index, but we cannot store two values at the same place in the hash table. This process is called a collision. To resolve these collisions, we have some techniques:
***Separate Chaining***
In this type, if two keys hash to the same hash value, then in the bucket array for that particular hash value index, we will create a linked list.
Let's consider we have keys 100,105,200, and 205. Hash function is equal to K times mod of 10.
*Keys = 100 ,105,200,205*
*H(K) = K mod 10*
Since the range of this function is 10, we have a bucket array of elements ranging from 0 to 9. For the first key-value, which is 100, 100 mod 10 is equal to 0. So it will be filled at index 0. At index 0, we will start a linked list with the key of 100. Now for key 105,
*105 mod 10 = 5*
So now start a linked list with a key of 105 at index 5.Then, for key 200,
*200 mod 10 = 0*
So we will go to the index 0 and add it to the end of the linked list after 100. Now for the key 205,
*205 mod 10 = 5*
We will go to index 5 and add it to the end of the linked list after 105. This is how to separate chaining works.
So we always need two functions for a hash table in it. The first insert operation and the second is the search operation. Let's look at the algorithm of each function.
***Insert***
This algorithm is fairly simple. If we say insert and we have an algorithm ‘insert item' . And we have a (key, element) pair which we want to insert. So, we will go to the index, which is equal to the key. Then at that index, we will have a linked list. This is going to be an array of linked list.So to this linked list, we will insert at the end the key-element pair.
***Search***
If we want to search for a key-element pair, the linked list we search for the element will be equal to the linked present in the array of the index key. So call this linked as C and store the array of a key in it. Now C is a linked list in which we want to search.
***Linear Probing***
In this, when a collision occurs, that is two distinct keys are mapped to the same hash value. In such a case, the colliding element will be positioned in the later circularly available table cell.
To understand the working of linear probing, let's consider that our hash function is:
*H(x) = x mod 10*
And keys are:
*Keys = (18,41,22,32,44,59,79)*
Now hash values will be:
*Hash Values = ( 8, 1,2,2,4,9,9)*
As the range is 10, the bucket array will have indexes from 0 to 9. We will place each key in the index, which is equal to their hash value. For the key value 32, its index value is the same as key-value 22. Index 2 has been already filled with key 22, so I will check its next index. As next index 3 is empty or free, so key 32 will be placed here. The index for key 79 is 9, but it has already been filled with key 59 because its index is also 9. So, we will go to the next circularly available table cell, which is 0. As index 0 is free, so we will place key 79 here:
Now let's see the pseudocode for inserting an element. Firstly we will calculate the hash code or hash value of the key and store that value in variable ‘H’. The key could be either placed at index H or could be placed at an index somewhere different from H provided that H is not empty. So let's keep the incrementing variable i equal to 0.
***Quadratic Probing***
In linear probing, a lot of elements start clustering. That is, elements will start to be stored in groups or in a group of consecutive filled cells. This is not good because when we want to add an element to a cluster , we have to probe through many indexes to finally add that element. So it is not very time efficient. The solution to this problem is quadratic probing. In quadratic probing, we have to check which indexes to check when we want to add an element. We iteratively check the index of the hash value of the key plus square of i mod N.The expression for quadratic probing is:
Suppose we have a hash function:
*H(x) = x mod 10*
And keys are:
*Keys = ( 2, 12 , 22 )*
Hash value will be:
*Hash = ( 2,2,2 )*
Now we will create an array having indexes 0 to 9.Firstly, key 2 will be placed at index value 2 in the array. Key 12 has index value 2, but index 2 has already filled with key 2.So to place key 12, the index value will be:
Now key 22 has index value 2, but it has been already filled, so we will find their index values as:
***Double Hashing***
In double hashing, we check iteratively indexes of the hash value of K plus j into the hash value of 2K.
*Double Hashing = Hash1(K) + j Hash 2(K)*
We have two hash functions in double hashing. In the above expression, ‘j’ is the iterative element starting at 0.
The values of both hash functions will be:
Now we will create a bucket array from 0 to 12 index value because the maximum range of N is 13. Now we will insert these hash values into the bucket array.
For adding key value 18:
*5 + (0\*3) = 5*
So 18 will go to the index value 5.
For key value 41:
*2+ (0\*1)=2*
Similarly for keys 22 and 44:
*9+ (0\*6) = 9*
*5+(0\*5) = 5*
Keys 22 will go to index value 9 but key 44 has index value 5 which is not empty. So now we will take:
*5+(1\*5) = 10*
So the index value for key 44 will be 10.
 | https://habr.com/ru/post/563664/ | null | en | null |
# Обновляемые смарт-контракты Ethereum
Почти перед каждым программистом, который пишет смарт-контракты Ethereum встают вопросы: «Что делать, если нужно будет расширить функционал контрактов? Как быть, если в контракте найдется баг, который повлечет за собой потерю средств? Что делать, если обнаружится уязвимость в компиляторе solidity (что бывало уже не раз)?» Ведь, контракты, которые мы загружаем в сеть, не могут быть изменены. Поначалу довольно сложно осознать: как это код нельзя обновить? Почему? Но в этом отчасти и сила смарт-контрактов Ethereum — пользователи, возможно, меньше бы стали доверять контрактам, которые можно менять.
Постараемся разобрать несколько подходов, которые все же позволяют менять смарт-контракты.
Эта статья рассчитана на тех, кто обладает хотя бы базовыми навыками программирования на языке solidity и понимает основные принципы работы сети Ethereum.
#### Разделить смарт-контракт на несколько связанных контрактов
При этом можно сохранить адреса активных в данный момент контрактов в storage какого-либо из контрактов. Нередко выделяют какой-то один контракт, который отвечает за хранение и изменение ссылок на части всей системы.
Как пример можно привести контракт распродажи токенов, в котором четко не прописаны правила вычисления количества токенов, которые нужно отправить на кошелек с которого пришли Этеры. Вычислением количества может заниматься отдельный контракт, который мы сможем подменять в случае надобности. Не будем долго останавливаться на этом варианте, потому что подобный подход часто используется не только в solidity.
Одним из главных минусов такого подхода является то, что никак нельзя изменить интерфейс какого-то контракта, который является внешним для всей системы. Нельзя добавить или удалить функцию.
#### Использовать delegatecall для проксирования вызова в другой контракт
В [EIP-7](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-7.md) была предложена и реализована инструкция, которая позволяет вызывать код из другого контракта, но контекст вызова остается тем же самым, что и у текущего контракта. То есть, вызываемый контракт будет писать в storage вызывающего контракта, msg.sender и msg.value остаются такими же, как изначально.
В сети можно найти несколько примеров реализации данного механизма. Все они включают использование solidity assembly. Без assembly невозможно добиться возвращения какого-либо значения из delegatecall.
Основная идея всех методов, которые используют delegatecall для проксирования — реализация fallback функции. В ней необходимо прочесть calldata и передать дальше через delegatecall.
Поближе посмотрим на несколько примеров реализации:
1. [Upgradeable](https://gist.github.com/Arachnid/4ca9da48d51e23e5cfe0f0e14dd6318f) хранит размеры возвращаемых значений в mapping.
Вот реализация fallback функции отсюда:
````
bytes4 sig;
assembly { sig := calldataload(0) }
var len = _sizes[sig];
var target = _dest;
assembly {
// return _dest.delegatecall(msg.data)
calldatacopy(0x0, 0x0, calldatasize)
delegatecall(sub(gas, 10000), target, 0x0, calldatasize, 0, len)
return(0, len)
}
````
При этом размер возвращаемого значения (в байтах) хранится в mapping \_sizes. Это поле в storage необходимо заполнять при обновлении контракта.
Минусом данного подхода является то, что размер возвращаемого значения жестко привязан к сигнатуре вызываемой функции, то есть вернуть строку произвольного размера или массив байтов не получится.
Кроме того, обращение к storage довольно дорого стоит. А в данном случае у нас будет аж два обращения к storage: когда мы обращаемся к полю \_dest и когда мы обращаемся к полю \_size.
2. [EVM assembly tricks](http://martin.swende.se/blog/EVM-Assembly-trick.html): всегда использовать размер ответа, равный 32 байтам.
Код очень похож на предыдущий пример, но всегда используется размер ответа, равный 32 байтам. Это довольно взвешенное решение. Во-первых, большинство типов в solidity умещаются именно в 32 байта, во-вторых, не обращаясь лишний раз к storage, мы экономим довольно приличное количество газа. Позже оценим, сколько примерно газа тратится в разных вариантах реализации
3. [Использование новых инструкций](https://github.com/0v1se/contracts-upgradeable/blob/master/contracts/Dispatcher.sol) resultdatasize и resultdatacopy
Эти инструкции появились в основной сети Ethereum только после последнего хардфорка (Byzantium — 17 октября 2017 года).
Инструкции позволяют получить размер ответа, который возвращен из call/delegatecall, а также скопировать сам ответ в память. То есть, мы получили возможность реализовать полноценный прокси для любых размеров returndata.
Вот итоговый assembly код:
````
assembly {
let _target := sload(0)
calldatacopy(0x0, 0x0, calldatasize)
let retval := delegatecall(gas, _target, 0x0, calldatasize, 0x0, 0)
let returnsize := returndatasize
returndatacopy(0x0, 0x0, returnsize)
switch retval case 0 {revert(0, 0)} default {return (0, returnsize)}
}
````
Рассмотрим вопрос использования газа. Проведенное тестировние показывает, что все 3 приведенных метода увеличивают использование газа на значение от 1000 до 1500. Много это или мало? Это примерно 2% от более-менее средней стоимости транзакции, которая будет изменять storage.
#### Сложности в использовании
К сожалению, использование данных методик ограничено. Во-первых, чтобы такое обновление контрактов работало, нельзя менять структуру хранения данных в контракте (нельзя переставлять местами поля, удалять поля). В новые версии контракта поля можно добавлять.
Также необходимо очень аккуратно разграничивать доступ к функции, которая меняет адрес активного контракта.
Немаловажным фактом является то, что доверие пользователей к контракту будет меньше, чем к такому же неизменяемому. С другой стороны можно предусмотреть тестовый период времени, в течение которого новую версию контракта можно откатить, а после которого версия контракта будет зафиксирована и меняться больше не сможет.
#### Примеры реализации обновлений
Несколько контрактов, которые помогут сделать обновление проще и надежнее.
[Upgradeable](https://github.com/0v1se/contracts-upgradeable/blob/master/contracts/Upgradeable.sol) — в этом контракте реализована проверка на то, что поле target (адрес активной версии контракта) хранится в том же самом слоте, что и в текущей версии.
Аналогично можно реализовать проверки и на другие поля storage (пример можно посмотреть в [Target.sol](https://github.com/0v1se/contracts-upgradeable/blob/master/test/contracts/Target.sol))
Если вы планируете реализовать Upgradeable контракты, то обязательно посмотрите на [тесты](https://github.com/0v1se/contracts-upgradeable/blob/master/test/upgradeable.js) для контракта Upgradeable.
Перед деплоем подобных контрактов в сеть, нужно обязательно тестировать все варианты. Иначе после очередного обновления можно остаться без функционирующего контракта и без возможности обновления. | https://habr.com/ru/post/342200/ | null | ru | null |
# Rust новости #3 (ноябрь 2018)
Предлагаю вашему вниманию субъективную подборку ржавых новостей за ноябрь. В этой подборке: Rust 2018, RustRush, видео с конференций, Amazon Lambda и Firecracker, квизы, переход exonum на actix-web, 10 причин использовать Rust.
[Результаты Rust опроса 2018](https://blog.rust-lang.org/2018/11/27/Rust-survey-2018.html)
------------------------------------------------------------------------------------------
Опубликованы [результаты ежегодного Rust-опроса](https://blog.rust-lang.org/2018/11/27/Rust-survey-2018.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a0wuac/rust_survey_2018_results)), который шел [с августа](https://blog.rust-lang.org/2018/08/08/survey.html).
Там довольно много всякой интересной информации, особенно, если рассматривать в динамике по сравнению с прошлыми годами, но отдельно радует рост количества профессионально использующих язык: если в прошлом году 21% опрошенных использовали Rust на работе, то в этом году — уже 30%.
Rust 2018
---------
Уже на днях будет выпущен Rust 1.31 — первая стабильная версия с поддержкой новой редакции языка: Rust 2018. ([что за "редакции"?](https://rust-lang-nursery.github.io/edition-guide/editions/index.html))
К выходу новой редакции языка приурочили редизайн официальной страницы языка — [beta.rust-lang.org](http://beta.rust-lang.org) — который вызвал поляризованные отзывы о формулировках и шрифтах-цветах (например: [1](https://www.reddit.com/r/rust/comments/a1jjuf/a_new_look_for_rustlangorg), [2](https://users.rust-lang.org/t/the-beta-rust-lang-org-pr-debacle/22778));
Firecracker от AWS (Amazon Web Services)
----------------------------------------
["В AWS представили Firecracker — «микровиртуализацию» для Linux"](https://habr.com/company/flant/blog/431192):
> На [AWS re:Invent 2018](https://reinvent.awsevents.com), что проходит в эти дни в Лас-Вегасе, состоялся анонс [Firecracker](https://github.com/firecracker-microvm/firecracker) — новой технологии виртуализации с открытым кодом, основанной на Linux KVM. Авторы обещают, что с ней «в доли секунды можно запускать легковесные микровиртуальные машины (microVMs) в невиртуализированной среде, получив преимущества и традиционных ВМ — в виде безопасности и изоляции рабочих нагрузок, и контейнеров — в виде эффективного использования ресурсов».
>
>
>
> Основу проекту положила Open Source-разработка от Google — crosvm из Chromium OS, что написана на Rust и отвечает за запуск операционных систем с виртуализацией устройств (но без эмуляции реального аппаратного обеспечения). Посему код Firecracker тоже написан на языке Rust, и его авторы обещают возвращать свои исправления в кодовую базу родительского проекта, хотя сами проекты со временем сильно разошлись в своём предназначении.
Так же:
* [/r/rust: "AWS firecracker microvm is all rust"](https://www.reddit.com/r/rust/comments/a0rph0/aws_firecracker_microvm_is_all_rust);
* [/r/rust: "Rust support has been added to AWS Lambda"](https://www.reddit.com/r/rust/comments/a1jkof/rust_support_has_been_added_to_aws_lambda);
[Видео докладов с RustFest 2018 Rome](https://media.ccc.de/c/rustfest18rome)
----------------------------------------------------------------------------
* ["Declarative programming in Rust"](https://media.ccc.de/v/rustfest-rome-5-declarative-programming-in-rust);
* ["Sequoia: A New OpenPGP Implementation in Rust"](https://media.ccc.de/v/rustfest-rome-6-sequoia);
* ["Oh Boy! Creating a Game Boy Emulator in Rust"](https://media.ccc.de/v/rustfest-rome-3-gameboy-emulator);
* ["One Thousand Ways to Die in Rust FFI"](https://media.ccc.de/v/rustfest-rome-9-one-thousand-ways-to-die-in-rust-ffi);
* ["Rust, For Science!"](https://media.ccc.de/v/rustfest-rome-4-rust-for-science);
* ["Behind The Scenes Of Producing An Executable"](https://media.ccc.de/v/rustfest-rome-8-behind-the-scenes-of-producing-an-executable);
* ["Simple CRDT in Rust"](https://media.ccc.de/v/rustfest-rome-10-simple-crdt-in-rust);
* ["Grappling with growth, and other good problems to have"](https://media.ccc.de/v/rustfest-rome-1-keynote);
* ["Caging the SpiderMonkey — Ensuring safe JS bindings in Servo"](https://media.ccc.de/v/rustfest-rome-2-caging-the-spidermonkey);
* ["Fun with Rusty Robots"](https://media.ccc.de/v/rustfest-rome-7-fun-with-rusty-robots);
* ["Increasing Rust's Reach Project Highlight"](https://media.ccc.de/v/rustfest-rome-11-project-highlight);
[Видео докладов с Rust Belt Rust 2018](https://www.youtube.com/playlist?list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW)
----------------------------------------------------------------------------------------------------------------
Все с растфеста посмотрели? Тогда вот еще добавка с [Rust Belt Rust 2018](https://www.rust-belt-rust.com):
* ["Core Team Talk" — Ashley Williams and Niko Matsakis](https://www.youtube.com/watch?v=C4jQbc1RJPY&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=2);
* ["Monotron — a 1980s style home computer written in Rust" — Jonathan Pallant](https://www.youtube.com/watch?v=xBRFtlT5Pfs&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=3);
* ["Syntax conveniences afforded by the compiler" — Tshepang Lekhonkhobe](https://www.youtube.com/watch?v=Xk5IZOtLUmE&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=4);
* ["Actix and Actors in Rust" — Nathan Hawkins](https://www.youtube.com/watch?v=W-hvnVeRJzs&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=5);
* ["Lightning Talks: Rust Quiz" — Alex Crichton and David Tolnay](https://www.youtube.com/watch?v=QtDj9R6vtA8&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=6);
* ["Lightning Talks: Rustbots" — Robots powered by Rust — Rahul Thakoor](https://www.youtube.com/watch?v=HoD-PrkaGUU&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=7);
* ["Lightning Talks: Personal Wiki" — James Sacksteder](https://www.youtube.com/watch?v=3i3gdxD_opM&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=8);
* ["Lightning Talks: Rust's Family Tree" — Jenny Manning](https://www.youtube.com/watch?v=u3vZia0NB1I&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=9);
* ["Lightning Talks: Announcing the Ann Arbor Meetup" — Esty Thomas](https://www.youtube.com/watch?v=qtxvwermthE&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=10);
* ["Lightning Talks: Rust In Space" — myrrlyn](https://www.youtube.com/watch?v=xYDKcoS26ZM&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=11);
* ["Percy: Isomorphic Web Apps with Rust + WebAssembly" — Chinedu Francis Nwafili](https://www.youtube.com/watch?v=M6RLvGqQU10&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=12);
* ["Evolving API design in Rust" — Simon Nicholas Heath](https://www.youtube.com/watch?v=Xt1JOVeQ5hw&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=13);
* ["Maintaining the Rust Community" — Arshia Mufti](https://www.youtube.com/watch?v=1YR3TbrC3r4&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=14);
* ["Move fast and don't break things: High-performance networking in Rust" — Joshua Liebow-Feeser](https://www.youtube.com/watch?v=UfMOOxOGCmA&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=15);
* ["State of the crates.io" — Sean Griffin](https://www.youtube.com/watch?v=QjQPNZPSlqA&t=0s&list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW&index=16);
[Весь плейлист](https://www.youtube.com/playlist?list=PLgC1L0fKd7UlpVTHVfLYVtudVx8CzbSxW).
И закину сюда же до кучи двухчасовую [запись Rust Bay Area Meetup](https://www.youtube.com/watch?v=-F7whGjquHI).
[RustRush 2018](https://rustrush.ru): конференция 15-16 декабря в Москве
------------------------------------------------------------------------
RustRush 2018 — конференция для разработчиков на Rust, посвящённая вебу, блокчейну, высокой производительности и системному программированию.
Осталось меньше двух недель! CfP закончен, выложена [окончательная программа докладов](https://rustrush.ru/program).
[cheats.rs](https://cheats.rs)
------------------------------
[cheats.rs](https://cheats.rs) ([репозиторий](https://github.com/ralfbiedert/cheats.rs), [обсуждение](https://www.reddit.com/r/rust/comments/a0z1ln/rust_language_cheat_sheet_cheatsrs)) — памятка по Rust + подборка ссылок на другие подобные памятки. Может дико пригодиться при погружении в язык.
Сайт, кстати, сделан с использованием [Zola](https://www.getzola.org) (см. ниже в секции новых и обновленных пакетов).
[Как мы переводили Exonum с Iron на actix-web](https://habr.com/company/bitfury/blog/429450)
--------------------------------------------------------------------------------------------
Статья о практическом опыте работы с относительно хитрым обобщенным кодом от [Gorthauer87](https://habr.com/users/gorthauer87/). Код кишок местами сложновато устроен, зато итоговый результат для пользователя удобен и красив.
[10 неочевидных преимуществ использования Rust](https://habr.com/post/430294)
-----------------------------------------------------------------------------
[freecoder\_xx](https://habr.com/users/freecoder_xx/) написал обзорную статью о менее продвигаемых достоинствах Rust.
> В данной статье собран десяток неочевидных и особо не рекламируемых преимуществ использования Rust, которые, я надеюсь, помогут вам определиться с выбором этого языка для ваших проектов.
[Rust Quiz](https://dtolnay.github.io/rust-quiz)
------------------------------------------------
Из [доклада Алекса](https://www.youtube.com/watch?v=QtDj9R6vtA8) вырос сайт со средне и очень сложными вопросами по крайним случаям и "бородавкам" Ржавчины ([обсуждение](https://www.reddit.com/r/rust/comments/a1846o/rust_quiz_26_medium_to_hard_rust_questions_with)). По нажатию кнопки "reveal" ("сдаюсь") показывается развернутое объяснение что за чертовщина происходит в примере кода.
Исходный код всего этого дела живет [тут](https://github.com/dtolnay/rust-quiz). Туда можно делать PRы, если вы знаете еще клевые вопросы подобного формата.
[Embedded](https://github.com/rust-embedded/wg)
-----------------------------------------------
* [OxidizeConf](https://ferrous-systems.com/blog/oxidize-the-embedded-rust-conference) ([обсуждение](https://www.reddit.com/r/rust/comments/a0ujpc/oxidizeconf_a_conference_about_embedded_systems)) — объявлена конференция об embedded/IoT на Rust;
* ["This Year in Embedded Rust"](https://rust-embedded.github.io/blog/2018-11-14-this-year-in-embedded-rust) — подведение итогов прогресса рабочей группы программирования под встраиваемые системы за год:
+ Организовалось активное подсообщество;
+ Стало возможно вести разработку без ночников;
+ Сильно расширился список поддерживаемого железа;
+ Понизился порог вхождения за счет разработки дополнительного [инструментария](https://github.com/rust-embedded/cargo-binutils) и [готовых шаблонов проектов](https://github.com/rust-embedded/cortex-m-quickstart);
+ Улучшилась документация, в частности были начаты:
+ [The Embedded Rust book](https://docs.rust-embedded.org/book) — основная книга;
+ [The Discovery book](https://docs.rust-embedded.org/discovery) — введение в предметную область;
+ [The Embedonomicon](https://docs.rust-embedded.org/embedonomicon) — для хардкора;
+ [Awesome Embedded Rust](https://github.com/rust-embedded/awesome-embedded-rust) — список интересных проектов;
* [Bootstrapping My Embedded Rust Development Environment](https://josh.robsonchase.com/embedded-bootstrapping) ([обсуждение](https://www.reddit.com/r/rust/comments/a0fl57/bootstrapping_my_embedded_rust_development)) — обзор рабочего процесса и инструментов встроенщика;
* [embedded-sdmmc-rs](https://github.com/thejpster/embedded-sdmmc-rs) ([обсуждение](https://www.reddit.com/r/rust/comments/a07k6e/wip_a_no_std_rust_crate_for_reading_sdmmc_cards)) — позволяет читать SD/MMC карты, поддерживает [no\_std](https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib);
* [drone](https://github.com/martindeegan/drone) ([обсуждение](https://www.reddit.com/r/rust/comments/9zktb4/quadcopter_in_rust)) — ПО и контроллер для квадракоптеров;
[WebAssembly](https://rustwasm.github.io)
-----------------------------------------
* ["Programming WebAssembly with Rust"](https://pragprog.com/book/khrust/programming-webassembly-with-rust) ([обсуждение](https://www.reddit.com/r/rust/comments/a16u31/programming_webassembly_with_rust_book_is_in_beta)) — открыт платный доступ к бета версии книги;
* [typed-html](https://github.com/bodil/typed-html) ([обсуждение](https://www.reddit.com/r/rust/comments/9ydtvx/typedhtml_type_checked_jsx_for_rust)) — реализует макрос `html!`, позволяющий создавать HTML документы из Rust кода при помощи [JSX](https://reactjs.org/docs/introducing-jsx.html)-совместимого синтаксиса (БОНУС: [отлично работает и в WASM'е!](https://twitter.com/bodil/status/1062123547542388742));
* [HOWTO: Setting up WebAssembly on stable rust without rustup](https://www.reddit.com/r/rust/comments/9t95fd/howto_setting_up_webassembly_on_stable_rust);
* [Terrarium](https://wasm.fastlylabs.com) ([обсуждение](https://www.reddit.com/r/rust/comments/9yvg45/terrarium_fastly_labs)) — площадка для экспериментов с WASM от [Fastly](https://www.fastly.com);
* [php-ext-wasm](https://github.com/Hywan/php-ext-wasm) ([обсуждение](https://www.reddit.com/r/rust/comments/9y7wl6/run_wasm_in_php_natively_php_extension_written_in)) — проект по прямому запуску WASM из PHP, основан на [paritytech/wasmi](https://github.com/paritytech/wasmi);
* [Wasmer](https://wasmer.io) ([обсуждение](https://www.reddit.com/r/rust/comments/9z741o/wasmer_highperformance_jitting_webassembly), [код](https://github.com/wasmerio/wasmer)) — оптимизирующий JIT компилятор WASM, основанный на [Cranelift](https://github.com/CraneStation/cranelift);
* [Bringing Elm's architecture to Rust and Webassembly](https://sindrejohansen.no/blog/willow/rust/elm/2018/11/16/willow-elm-in-rust.html) ([обсуждение](https://www.reddit.com/r/rust/comments/9xovoq/bringing_elms_architecture_to_rust_and_webassembly)) — про [willow](https://github.com/sindreij/willow), попытку переноса ["архитектуры Elm"](https://guide.elm-lang.org/architecture) на Rust;
Игрострой
---------
* Я завел [twitter.com/rust\_gamedev](https://twitter.com/rust_gamedev) (по аналогии с [rustwasm](https://twitter.com/rustwasm), [rustembedded](https://twitter.com/rustembedded) и т.п.), странно что этого никто раньше не сделал;
* Новая студия [Embark](https://www.embark-studios.com), основанная выходцами из DICE/EA, [заявила о намерении использовать Rust как основной язык](https://twitter.com/repi/status/1060469377500274689) ([обсуждение](https://www.reddit.com/r/rust/comments/9viryw/embark_a_newly_found_game_studio_will_build_their));
* [Видео "Modulator crate and Play app (Rust coding series)"](https://www.youtube.com/watch?v=n-txrCMvdms) ([обсуждение](https://www.reddit.com/r/rust/comments/9zem4v/modulator_andrea_pessino_on_twitter)) — Andrea Pessino (CTO Ready at Dawn) записал пафосное видео-презентацию библиотеки [Modulator](https://github.com/apessino/modulator); 
* [Rusted Ruins](https://github.com/garkimasera/rusted-ruins) ([обсуждение](https://www.reddit.com/r/rust/comments/9vrikb/extensible_open_world_rouge_like_game_written_in)) — расширяемый [рогалик](https://ru.wikipedia.org/wiki/Roguelike);
* [Alexandru Ene: Rust And Game Development](https://alexene.github.io/2018/11/15/Rust-and-game-development.html) ([обсуждение](https://www.reddit.com/r/rust/comments/9xctdd/rust_and_game_development_post_by_alexene)) — мысли о текущем состоянии ржавого игростроя и в каких направлениях ему стоит развиваться;
* [Vulkano 0.11 released](https://www.patreon.com/posts/22587417) ([обсуждение](https://www.reddit.com/r/rust/comments/9v7uh8/vulkano_011_released)) — улучшена документация и работа с шейдерами, Tomaka отстранился от разработки (и вообще разработки игр);
* [grr](https://github.com/msiglreith/grr) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a0a5u0/grr_030_release_a_modern_opengl_45_wrapper)) — еще одна обертка над OpenGL (в reddit обсуждении есть сравнение с [glium](https://github.com/glium/glium)), идет сразу с [PBR примером](https://github.com/msiglreith/grr/tree/b5f09a86b/examples/pbr) ([картинка](https://raw.githubusercontent.com/msiglreith/grr/master/info/examples/pbr.png));
* [glsl-0.13 and its visitor pattern](https://phaazon.net/blog/glsl-0.13-visitor) — улучшен модуль glsl::syntax и "AST visitors";
* [/r/rust: "Rust in AAA game engine"](https://www.reddit.com/r/rust/comments/9zuk09/rust_in_aaa_game_engine) — очень толковое обсуждение перспектив использования Rust в больших игровых движках;
* [This month in rustsim #2 (November 2018)](https://www.rustsim.org/blog/2018/12/01/this-month-in-rustsim):
+ [улучшены деформируемые объекты](https://www.youtube.com/watch?v=Qd1sxFG-2p0);
+ множество мелких улучшений в коде и документации [nalgebra](https://nalgebra.org)/[ncollide](https://ncollide.org);
+ начата работа над новым пакетом ["space"](https://github.com/vadixidav/space) с пространственными структурами данных;
Экосистема движка [Аметист](https://www.amethyst.rs/blog):
* [Основан Фонд Аметиста — Amethyst Foundation](https://www.amethyst.rs/blog/non-profit-announce) ([обсуждение](https://www.reddit.com/r/rust/comments/a01hcn/amethyst_foundation_has_been_formed)) — в основном, для приема пожертвований ([F.A.Q.](https://community.amethyst-engine.org/t/amethyst-foundation-faq/108));
* Появился [отдельный форум аметиста](https://community.amethyst-engine.org), в котором, например, есть [вики-тема со списком игр на движке](https://community.amethyst-engine.org/t/games-made-with-amethyst/134);
* [Сменился логотип](https://github.com/amethyst/amethyst/blob/77969cf6d/book/src/images/amethyst_emblem.png);
* [Laminar 0.1](https://github.com/amethyst/laminar) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/9wlbbm/amethyst_laminar_networking_crate_010_released)) — сетевая библиотека для игр, работающая поверх UDP ([список возможностей](https://github.com/amethyst/laminar#features)), [интегрирован](https://github.com/amethyst/amethyst/pull/1137) в Аметист;
* [Видео "Everpuzzle — using the Amethyst Engine with Rust for Games"](https://www.youtube.com/watch?v=P_9A7P0uNpY) — презентация о процессе разработки головоломки [Everpuzzle](https://github.com/Skytrias/everpuzzle);
* [Where The Fun Begins](https://azriel.im/will/2018/11/23/where-the-fun-begins) — Azriel рассказывает о реализации столкновений разных зон 2д персонажей;
* [LemRunner](https://cs2dsb.itch.io/lemrunner) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a1jp6x/my_github_game_jam_2018_entry_developed_in), [код](https://github.com/cs2dsb/github-game-jam-2018)) — смесь Леммингов и раннера для [Game Off 2018](https://itch.io/jam/game-off-2018); 
Одной строкой
-------------
* [IntelliJ-Rust](https://intellij-rust.github.io) продолжает развиваться: [#86](https://intellij-rust.github.io/2018/11/07/changelog-86.html), [#87](https://intellij-rust.github.io/2018/11/26/changelog-87.html) — в частности, улучшена работа со стандартыми макросами, улучшена интеграция с LLDB, добавлена команда группировки импортов ([GIF](https://intellij-rust.github.io/assets/posts/changelog-86/nest-use-statements.gif)) и поддержка сворачиваемых регионов ([GIF](https://intellij-rust.github.io/assets/posts/changelog-87/custom-folding-regions.gif));
* [С марта 2019 для публикации чего-то на crates.io будет требоваться подтвержденный почтовый адрес](https://users.rust-lang.org/t/a-verified-email-address-will-be-required-to-publish-to-crates-io-starting-on-2019-02-28/22425) ([обсуждение](https://www.reddit.com/r/rust/comments/9yjsmr/a_verified_email_address_will_be_required_to));
* [Доля Rust-кода в Firefox постепенно растет](https://twitter.com/eroc/status/1061049330574884864) ([обсуждение](https://www.reddit.com/r/rust/comments/9vsbhi/rust_in_firefox_usage_numbers)) — уже что-то порядка 6% кодовой базы;
* [How to speed up the Rust compiler in 2018: NLL edition](https://blog.mozilla.org/nnethercote/2018/11/06/how-to-speed-up-the-rust-compiler-in-2018-nll-edition) ([обсуждение](https://www.reddit.com/r/rust/comments/9uj7hu/how_to_speed_up_the_rust_compiler_in_2018_nll)) — героическое ускорение компилятора раста;
* [Getting started with nightly async/await support](https://jsdw.me/posts/rust-asyncawait-preview) ([обсуждение](https://www.reddit.com/r/rust/comments/a0jvo4/getting_started_with_nightly_asyncawait_support)) — async-синтаксис еще не скоро стабилизируют, но с ним уже можно начинать знакомиться;
* [How Rust helps keep Kentik's performance on high](https://www.kentik.com/blog/under-the-hood-how-rust-helps-keep-kentik's-performance-on-high) — [Kentik](https://www.kentik.com) рассказывают о роли Rust в их бэкенде;
* [A hammer you can only hold by the handle](https://blog.systems.ethz.ch/blog/2018/a-hammer-you-can-only-hold-by-the-handle.html) ([обсуждение](https://www.reddit.com/r/rust/comments/9uccla/a_hammer_you_can_only_hold_by_the_handle)) — наглядная демонстрация выгоды от правильного использования системы типов;
* [Build Your Own Shell using Rust](https://www.joshmcguigan.com/blog/build-your-own-shell-rust) ([обсуждение](https://www.reddit.com/r/rust/comments/9xwkh5/build_your_own_shell_using_rust)) — каждый программист должен написать хотя бы один шелл, да? :) ;
* [Things Rust doesn’t let you do](https://medium.com/@GolDDranks/things-rust-doesnt-let-you-do-draft-f596a3c740a5) ([обсуждение](https://www.reddit.com/r/rust/comments/9w9ldx/things_rust_doesnt_let_you_do)) — перечисление основных ограничений, которые Rust накладывает на код, зачем они нужны и как их при необходимости можно обходить;
* [After NLL: Moving from borrowed data and the sentinel pattern](http://smallcultfollowing.com/babysteps/blog/2018/11/10/after-nll-moving-from-borrowed-data-and-the-sentinel-pattern) ([обсуждение](https://www.reddit.com/r/rust/comments/9vxxgg/after_nll_moving_from_borrowed_data_and_the)) — Нико продолжает свою серию об NLL и планах на будущее;
* [Stacked Borrows Implemented: An Aliasing Model for Rust](https://www.ralfj.de/blog/2018/11/16/stacked-borrows-implementation.html) ([обсуждение](https://www.reddit.com/r/rust/comments/9xnxw6/stacked_borrows_implemented_an_aliasing_model_for)) — Ральф продолжает докапываться до семантики Ржавчины;
* [Implementing Rust’s std::sync::Mutex in D](https://atilanevesoncode.wordpress.com/2018/11/06/implementing-rusts-stdsyncmutex-in-d) ([обсуждение](https://www.reddit.com/r/rust/comments/9urp6k/implementing_rusts_stdsyncmutex_in_d)) — хоть статья и не нацелена на Rust программистов, она дает хороший ликбез чем хорош стандартный ржавый мьютекс;
* [/r/rust: What are the main challenges when switching to Rust?](https://www.reddit.com/r/rust/comments/9zs6ra/what_are_the_main_challenges_when_switching_to) — обсуждение сложностей перехода на Ржавчину;
* [/r/rust: "When should a library panic vs. return 'Result'?"](https://www.reddit.com/r/rust/comments/9x17hn/when_should_a_library_panic_vs_return_result)) — очень хорошее обсуждение нюансов "паники vs result";
* Альтернативный бекенд компилятора Rust [Cranelift](https://github.com/CraneStation/cranelift) продолжает развиваться: он уже может выдавать код с немного лучшей производительностью чем LLVM с `--opt-level=0` и дает это на 30% быстрее ([обсуждение](https://www.reddit.com/r/rust/comments/9xobgz/the_cranelift_backend_for_rustc_now_produces_code));
Новые и обновленные пакеты
--------------------------
Некоторые свежие пакеты за месяц или существенные обновления старых:
* [tr](https://github.com/woboq/tr) ([обсуждение](https://www.reddit.com/r/rust/comments/a09b0n/tr_a_crate_for_internationalizationof_rust_code)) — макросы для локализации приложений, вдохновленные ['tr' из Qt](https://wiki.qt.io/QtInternationalization#What_is_tr.28.29.3F);
* [cargo nono](https://github.com/hobofan/cargo-nono) ([обсуждение](https://www.reddit.com/r/rust/comments/9wbv0v/cargo_nono_detect_possible_no_std_compatibility)) — расширение cargo, которое по внешним эвристикам пытается найти зависимости, ломающие no\_std;
* [immense](https://crates.io/crates/immense) ([обсуждение](https://www.reddit.com/r/rust/comments/9y1efh/generate_3d_meshes_in_rust)) — пакет для генерации трехмерных сеток;
* [Logos](https://github.com/maciejhirsz/logos) ([обсуждение](https://www.reddit.com/r/rust/comments/9z87z7/logos_create_ridiculously_fast_lexers)) — позволяет писать "невероятно быстрые" лексические анализаторы;
* [fluid](https://gitlab.com/Boiethios/fluid-rs/wikis/home) ([обсуждение](https://www.reddit.com/r/rust/comments/9zyisj/fluid_a_crate_that_makes_your_unit_tests_easier)) — фреймворк для написания тестов, вдохновленный [XUnit](https://xunit.github.io);
* [guerrilla](https://crates.io/crates/guerrilla) ([обсуждение](https://www.reddit.com/r/rust/comments/9vngqn/guerrilla_patching_in_rust_for_unsafe_fun_and)) — эксперимент по реализации "monkey patching" для Rust (кстати, про название пакета: я никогда не задумывался над [этимологией термина "monkey patch"](https://en.wikipedia.org/wiki/Monkey_patch#Etymology));
* [serde\_postgres](https://github.com/1aim/serde_postgres) — простой способ десериализовать строки из postgres в произвольные структуры (обратная сериализация не поддерживается);
* [pgxr](https://github.com/clia/pgxr) — позволяет писать ржавые функции расширения для PostgreSQL;
* [MutGuard](https://github.com/geal/mutguard) ([обсуждение](https://www.reddit.com/r/rust/comments/9wcujb/mutguard_run_code_every_time_data_is_mutably)) — позволяет запускать произвольный код при каждом взятии изменяющей ссылки на хранимые данные (например, для проверки инвариантов);
* [Zola 0.5](https://www.vincentprouillet.com/blog/releasing-zola-0-5-0) ([обсуждение](https://www.reddit.com/r/rust/comments/9xyoq3/gutenberg_is_out_zola_050_is_in)) — генератор статических сайтов Gutenberg сменил название на Zola и обзавелся подгрузкой данных из CSV/TOML/JSON, шаблонами страниц, ["прозрачными секциями"](https://github.com/getzola/zola/issues/408);
* [rand 0.6](https://crates.io/crates/rand/0.6.0) ([обсуждение](https://www.reddit.com/r/rust/comments/9wzck6/rand_lib_version_06_release_now_with_a_book)) — библиотека для генерации случайных чисел, помимо теперь обзавелась [своей собственной книгой](https://rust-random.github.io/book);
* [lifeguard 0.6](https://github.com/zslayton/lifeguard) ([обсуждение](https://www.reddit.com/r/rust/comments/9wvtoj/lifeguard_v060_an_object_pool_manager_in_rust)) — позволяет создавать пулы переиспользуемых объектов; Новая версия улучшает производительность, разрешает создавать рекурсивные указатели и добавляет служебные типажи для удобства;
* [Pijul 0.11](https://pijul.org/posts/2018-11-20-pijul-0.11) ([обсуждение](https://www.reddit.com/r/rust/comments/9z2pkl/pijul_011), [код](https://nest.pijul.com/pijul_org/pijul)) — система контроля версий, [основанная на теории патчей](https://jneem.github.io/pijul), переехала на новый [Tokio](https://tokio.rs), обзавелась неполным клонированием, получила поддержку SSH прокси и конфигурационных файлов;
RFC
---
По RFC (Request for Comments) довольно удобно наблюдать, в какую сторону движется язык, так что вот некоторые интересные. В заголовке PRов есть ссылка "Rendered", по которой RFC доступен в удобочитаемой форме.
В этом месяце были приняты:
* [RFC #2561 Future possibilities](https://github.com/rust-lang/rfcs/pull/2561) — в новых RFC появится секция с перспективами развития предложенной идеи (мета-RFC);
* [RFC #2591 Stabilise exhaustive integer pattern matching](https://github.com/rust-lang/rfcs/pull/2591) — стабилизация исчерпывающих числовых сопоставлений, т.е., например, если в сопоставлении `u8` переменной перечислены все 255 значений, то `_` ветка будет не нужна;
RFC в рассмотрении:
* [RFC #2592 Stabilize 'std::task' and 'std::future::Future'](https://github.com/rust-lang/rfcs/pull/2592) — предлагает стабилизировать футуры (это отдельный от [async/await](https://github.com/rust-lang/rfcs/pull/2394) синтаксиса RFC);
* [RFC #2593 Enum variant types](https://github.com/rust-lang/rfcs/pull/2593) — предлагает расширить возможности использования вариантов перечислений, сделав их ближе к обычным структурам;
* [RFC #2584 Structural Records](https://github.com/rust-lang/rfcs/pull/2584) — предлагает добавить анонимные структуры (или их можно назвать кортежами с именованными полями);
* [RFC #2602 #[attribute]s galore](https://github.com/rust-lang/rfcs/pull/2602) — предлагает разрешить навешивание атрибутов на ВЖ, типы, ограничители (bounds) и еще кучу всего;
* [RFC #2603 Symbol Mangling v2](https://github.com/rust-lang/rfcs/pull/2603) — предлагает причесать [схему декорирования символов](https://en.wikipedia.org/wiki/Name_mangling);
* [RFC #2500 Needle API](https://github.com/rust-lang/rfcs/pull/2500) предлагает добавить `std::needle` с абстракциями над `&str`, `&mut str`, `&[T]`, `&mut [T]`, `Vec` и `&OsStr`;
Pre-RFC:
* [Pre-RFC for Anonymous Variant Types, a minimal anonymous sum type proposal](https://www.reddit.com/r/rust/comments/9tk7jw/prerfc_for_anonymous_variant_types_a_minimal) — предлагает добавить ~~задницы `(_|_)`~~ анонимные перечисления с типами вроде `(NoneError|ParseIntError)`;
* [Pre-RFC: sum-enums](https://internals.rust-lang.org/t/pre-rfc-sum-enums/8782) — предлагает ввести новый вид перечислений с синтаксисом `enum(A, B, C, ..)` и `enum Foo(A, B, C, ..)`;
* [Rust traits and their (lack of) privacy](https://phaazon.net/blog/rust-traits-privacy) — phaazon предлагает добавить типажам возможность иметь приватные методы (*тут я как-то прямо очень скептичен*);
Был отклонен [RFC #2328 officially adopting Ferris](https://github.com/rust-lang/rfcs/pull/2328) — решили, что [Ферриса](http://www.rustacean.net) нет особого смысла делать официальным талисманом;
---
Это все, спасибо за внимание!
Если я не добавил какую-то важную ссылку или событие, смело закидывайте в комментарии. :)
*КДПВ взята [отсюда](https://github.com/rust-lang/rfcs/pull/2328), остальные картинки из сайтов соответствующих проектов.* | https://habr.com/ru/post/432250/ | null | ru | null |
# Менеджер пакетов для XCode
Сегодня обнаружил достойный внимания всех разработчиков, пишущих под iOS/Mac OS и использующих XCode, проект – менеджер плагинов для XCode. Имя этому проекту – [Alcatraz](http://bit.ly/ZNRgJM). Увидев это чудо, я незамедлительно захотел его протестировать, благо установка выполняется тремя действиями:
1. Запустить терминал
2. Вставить следующий код в окно терминала:
```
mkdir -p ~/Library/Application\ Support/Developer/Shared/Xcode/Plug-ins;
curl -L http://goo.gl/xfmmt | tar xv -C ~/Library/Application\ Support/Developer/Shared/Xcode/Plug-ins -
```
3. Нажать Enter.
Перезапускаем XCode и в меню Window видим новый пункт открывающий окно менджера пакетов, также доступное по сочетанию горячих клавиш Shift-Cmd-9
Окно менеджера пакетов выглядит вот так:
В верхней части расположены кнопки фильтров по типам плагинов. В основной части окна отображается список доступных плагинов. Установка и удаление осуществляется простым кликом по галочке напротив плагина. Если при установке плагина что-то пошло не так, в строке статуса, в нижней части окна вы увидите сообщение об ошибке. В случае успешной установки там же появится рекомендация перезапустить среду. Сходу мне не удалось поставить только цветовые темы XCode, но я особо и не стремился.
Сейчас [список плагинов](https://github.com/mneorr/alcatraz-packages/blob/master/packages.json) не велик, но его можно дополнять, сделав форк репозитория на github, внеся свои правки и отправив pull-request. Я смог найти в этом списке 90% плагинов о которых когда-либо слышал.
Сам менеджер пакетов находится в alpha версии и возможны падения и прочие трудности. Но такому, на мой взгляд замечательному, проекту можно это простить.
Этому продукту суждено было появиться и я очень рад его увидеть. Он займет достойное место в моей повседневной деятельности наряду с Cocoapods. Надеюсь, вам он тоже понравится. | https://habr.com/ru/post/177775/ | null | ru | null |
# Введение в детерминированные сборки на С/С++. Часть 1
*Перевод статьи подготовлен специально для студентов курса [«Разработчик С++»](https://otus.pw/6G2d/).*
---
### Что такое детерминированная сборка?
Детерминированная сборка — это процесс сборки одного и того же исходного кода с одной и той же средой и инструкциями сборки, при котором создаются одни и те же двоичные файлы в любом случае, даже если они сделаны на разных машинах, в разных каталогах и с разными именами. Такие сборки также иногда называют воспроизводимыми или герметичными сборками, если гарантируется, что они будут создавать одни и те же двоичные файлы даже при компиляции из разных папок.
Детерминированные сборки не являются чем-то, что происходит само собой. Они не создаются в обычных проектах, и причины, по которым этого не происходит, могут быть разными для каждой операционной системы или компилятора.
Детерминированные сборки должны быть гарантированы для заданной *среды сборки*. Это означает, что некоторые переменные, такие как *операционная система, версии системы сборки и целевая архитектура*, предположительно остаются одинаковыми в разных сборках.
В последние годы различные организации, такие как [Chromium](https://www.chromium.org/developers/testing/isolated-testing/deterministic-builds), [Reproducible builds](https://reproducible-builds.org/) или [Yocto](https://wiki.yoctoproject.org/wiki/Reproducible_Builds), предпринимали много усилий для достижения детерминированных сборок.
### Важность детерминированных сборок
Существуют две основные причины, почему детерминированные сборки так важны:
* **Безопасность**. Изменение двоичных файлов вместо исходного кода может сделать изменения невидимыми для оригинальных авторов. Это может быть фатальным в критических для безопасности условиях, таких как медицина, авиация и космос. Потенциально идентичные результаты для данных материалов позволяют третьим сторонам прийти к консенсусу относительно правильного результата.
* **Отслеживаемость и двоичное управление**. Если вы хотите иметь репозиторий для хранения ваших двоичных файлов, то скорее всего вы не хотите создавать двоичные файлы со случайными контрольными суммами из источников в одной и той же ревизии. Это может привести к тому, что система репозитория будет хранить разные двоичные файлы как разные версии, когда они должны быть одинаковыми. Например, если вы работаете в Windows или MacOS, в библиотеке есть поля со временем создания/модификации входящих в нее объектных файлов, что приведет к различиям в бинарных файлах.
### Двоичные файлы, участвующие в процессе сборки в C/C++
Существуют различные типы двоичных файлов, которые создаются в процессе сборки в C/C++ в зависимости от операционной системы.
**Microsoft Windows**. Наиболее важными являются файлы с расширениями `.obj`, `.lib`, .`dll` и `.exe`. Все они соответствуют спецификации формата переносимых исполняемых файлов (Portable Executable, PE). Эти файлы могут быть проанализированы с помощью таких инструментов, как [dumpbin](https://docs.microsoft.com/en-us/cpp/build/reference/dumpbin-reference?view=vs-2019).
**Linux**. Файлы с расширениями `.o`, `.a`, `.so` и без расширений (для исполняемых двоичных файлов) соответствуют формату исполнимых и компонуемых файлов (Executable and Linkable Format, ELF). Содержимое ELF-файлов можно проанализировать с помощью [readelf](https://sourceware.org/binutils/docs/binutils/readelf.html).
**Mac OS**. Файлы с расширениями `.o`, `.a`, `.dylib` и без расширений (для исполняемых двоичных файлов) соответствуют спецификации формата Mach-O. Эти файлы можно проверить с помощью приложения [otool](https://opensource.apple.com/source/cctools/cctools-921/otool/), которое является частью набора инструментов XCode в MacOS.
### Источники вариаций
Много разных факторов могут сделать ваши сборки *недетерминированными*. Факторы будут различаться для разных операционных систем и компиляторов. Каждый компилятор имеет определенные параметры для исправления источников вариаций. На сегодняшний день `gcc` и `clang` — это те компиляторы, которые содержат больше опций для исправления. Для `msvc` есть несколько недокументированных опций, которые вы можете попробовать, но, в конце концов, вам, вероятно, придется исправлять двоичные файлы, чтобы получить детерминированные сборки.
#### Временные метки, добавленные компилятором/компоновщиком
Есть две основные причины, из-за которых наши двоичные файлы могут содержать информацию о времени, которая сделает их невоспроизводимыми:
* Использование макросов `__DATE__` или `__TIME__` в исходниках.
* Когда формат файла заставляет хранить информацию о времени в объектных файлах. Это случай формата Portable Executable в Windows и Mach-O в MacOS. В Linux ELF-файлы не кодируют какие-либо временные метки.
Давайте рассмотрим пример, где эта информация заканчивается компиляцией статической библиотеки базового проекта hello world в MacOS.
```
.
├── CMakeLists.txt
├── hello_world.cpp
├── hello_world.hpp
├── main.cpp
└── run_build.sh
```
Библиотека выводит сообщение в терминале:
```
#include "hello_world.hpp"
#include
void HelloWorld::PrintMessage(const std::string & message)
{
std::cout << message << std::endl;
}
```
А приложение будет использовать это, чтобы вывести сообщение «Hello World!»:
```
#include
#include "hello\_world.hpp"
int main(int argc, char\*\* argv)
{
HelloWorld hello;
hello.PrintMessage("Hello World!");
return 0;
}
```
Мы будем использовать CMake для сборки проекта:
```
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_library(HelloLibA hello_world.cpp)
add_library(HelloLibB hello_world.cpp)
add_executable(helloA main.cpp)
add_executable(helloB main.cpp)
target_link_libraries(helloA HelloLibA)
target_link_libraries(helloB HelloLibB)
```
Мы создадим две разные библиотеки с одинаковыми исходными кодами, а также два двоичных файла с одинаковыми источниками. Соберем проект и выполним `md5sum`, чтобы посмотреть контрольные суммы всех двоичных файлов:
```
mkdir build && cd build
cmake ..
make
md5sum helloA
md5sum helloB
md5sum CMakeFiles/HelloLibA.dir/hello_world.cpp.o
md5sum CMakeFiles/HelloLibB.dir/hello_world.cpp.o
md5sum libHelloLibA.a
md5sum libHelloLibB.a
```
Получаем вывод, наподобие этого:
```
b5dce09c593658ee348fd0f7fae22c94 helloA
b5dce09c593658ee348fd0f7fae22c94 helloB
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibA.dir/hello_world.cpp.o
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibB.dir/hello_world.cpp.o
adb80234a61bb66bdc5a3b4b7191eac7 libHelloLibA.a
5ac3c70d28d9fdd9c6571e077131545e libHelloLibB.a
```
Это интересно, поскольку исполняемые файлы `helloA` и `helloB` имеют одинаковые контрольные суммы, также как и промежуточные объектные файлы Mach-O `hello_world.cpp.o`, но этого нельзя сказать про файлы с расширением `.a`. Это потому, что они хранят информацию о промежуточных объектных файлах в архивном формате. Заголовок этого формата включает поле с именем `st_time`, устанавливаемое системным вызовом `stat`. Проверим `libHelloLibA.a` и `libHelloLibB.a`, используя `otool`, чтобы показать заголовки:
```
> otool -a libHelloLibA.a
Archive : libHelloLibA.a
0100644 503/20 612 1566927276 #1/20
0100644 503/20 13036 1566927271 #1/28
> otool -a libHelloLibB.a
Archive : libHelloLibB.a
0100644 503/20 612 1566927277 #1/20
0100644 503/20 13036 1566927272 #1/28
```
Мы видим, что файл содержит несколько временных полей, которые делают нашу сборку недетерминированной. Отметим, что эти поля не распространяются на конечный исполняемый файл, поскольку они имеют одинаковую контрольную сумму. Эта проблема также может возникнуть при сборке в Windows с Visual Studio, но с PE файлом вместо Mach-O.
На этом этапе мы можем попытаться сделать все еще хуже и заставить наши двоичные файлы быть также недетерминированными. Изменим файл `main.cpp`, таким образом, чтобы он включал макрос `__TIME__`:
```
#include
#include "hello\_world.hpp"
int main(int argc, char\*\* argv)
{
HelloWorld hello;
hello.PrintMessage("Hello World!");
std::cout << "At time: " << \_\_TIME\_\_ << std::endl;
return 0;
}
```
Проверяем контрольные суммы файлов еще раз:
```
625ecc7296e15d41e292f67b57b04f15 helloA
20f92d2771a7d2f9866c002de918c4da helloB
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibA.dir/hello_world.cpp.o
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibB.dir/hello_world.cpp.o
b7801c60d3bc4f83640cadc1183f43b3 libHelloLibA.a
4ef6cae3657f2a13ed77830953b0aee8 libHelloLibB.a
```
Мы видим, что теперь у нас есть разные двоичные файлы. Мы могли бы проанализировать исполняемый файл с помощью такого инструмента, как [diffoscope](https://diffoscope.org/), который показывает разницу между двумя двоичными файлами:
```
> diffoscope helloA helloB
--- helloA
+++ helloB
├── otool -arch x86_64 -tdvV {}
│┄ Code for architecture x86_64
│ @@ -16,15 +16,15 @@
│ 00000001000018da jmp 0x1000018df
│ 00000001000018df leaq -0x30(%rbp), %rdi
│ 00000001000018e3 callq 0x100002d54 ## symbol stub for: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev
│ 00000001000018e8 movq 0x1721(%rip), %rdi ## literal pool symbol address: __ZNSt3__14coutE
│ 00000001000018ef leaq 0x162f(%rip), %rsi ## literal pool for: "At time: "
│ 00000001000018f6 callq 0x100002d8a ## symbol stub for: __ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc
│ 00000001000018fb movq %rax, %rdi
│ -00000001000018fe leaq 0x162a(%rip), %rsi ## literal pool for: "19:40:47"
│ +00000001000018fe leaq 0x162a(%rip), %rsi ## literal pool for: "19:40:48"
│ 0000000100001905 callq 0x100002d8a ## symbol stub for: __ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc
│ 000000010000190a movq %rax, %rdi
│ 000000010000190d leaq __ZNSt3__1L4endlIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_(%rip), %rsi #
```
Он показывает, что информация `__TIME__` была вставлена в двоичный файл, что делает его недетерминированным. Давайте посмотрим, что можно сделать, чтобы избежать этого.
#### Возможные решения для Microsoft Visual Studio
Microsoft Visual Studio имеет флаг компоновщика /Brepro который не документирован Microsoft. Этот флаг устанавливает временные метки из формата Portable Executable в значение -1, как видно на рисунке ниже.
Чтобы активировать этот флаг с помощью CMake, мы должны добавить следующие строки при создании `.exe`:
```
add_link_options("/Brepro")
```
или эти строки для `.lib`
```
set_target_properties(
TARGET
PROPERTIES STATIC_LIBRARY_OPTIONS "/Brepro"
)
```
Проблема в том, что этот флаг делает двоичные файлы воспроизводимыми (относительно временных меток в формате файла) в нашем конечном двоичном файле .exe, но не удаляет все временные метки из .lib (та же проблема, что и с объектными файлами Mach-O, о которой мы говорили выше). Поле TimeDateStamp из [заголовочного файла COFF](https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#file-headers) для файлов `.lib` останется. Единственный способ удалить эту информацию из двоичного файла `.lib` — это исправить `.lib`, заменив байты, соответствующие полю TimeDateStamp, на любое известное значение.
#### Возможные решения для GCC и CLANG
* gcc обнаруживает существование переменной среды SOURCE\_DATE\_EPOCH. Если эта переменная установлена, ее значение указывает метку времени UNIX, которая будет использоваться для замены текущей даты и времени в макросах `__DATE__` и `__TIME__`, чтобы встроенные метки времени стали воспроизводимыми. Значение может быть установлено на известную временную метку, такую как время последнего изменения исходных файлов или пакета.
* clang использует `ZERO_AR_DATE`, который, если установлен, сбрасывает метку времени, представленную в архивных файлах, устанавливая ее на 0. Учтите, что это не исправит макросы `__DATE__` или `__TIME__`. Если мы хотим исправить эффект этого макроса, мы должны либо исправить двоичные файлы, либо подделать системное время.
Давайте продолжим с нашим примером проекта для MacOS и посмотрим, каковы будут результаты при установке переменной среды `ZERO_AR_DATE`.
```
export ZERO_AR_DATE=1
```
Теперь, если мы соберем наш исполняемый файл и библиотеки (убирая макрос `__DATE__` в исходниках), мы получим:
```
b5dce09c593658ee348fd0f7fae22c94 helloA
b5dce09c593658ee348fd0f7fae22c94 helloB
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibA.dir/hello_world.cpp.o
0a4a0de3df8cc7f053f2fcb6d8b75e6d CMakeFiles/HelloLibB.dir/hello_world.cpp.o
9f9a9af4bb3e220e7a22fb58d708e1e5 libHelloLibA.a
9f9a9af4bb3e220e7a22fb58d708e1e5 libHelloLibB.a
```
Все контрольные суммы теперь одинаковы. Проанализируем заголовки файлов с расширением `.a`:
```
> otool -a libHelloLibA.a
Archive : libHelloLibA.a
0100644 503/20 612 0 #1/20
0100644 503/20 13036 0 #1/28
> otool -a libHelloLibB.a
Archive : libHelloLibB.a
0100644 503/20 612 0 #1/20
0100644 503/20 13036 0 #1/28
```
Мы можем увидеть, что поле `timestamp` заголовка библиотеки было установлено равным нулю.
*Мы плавно подошли к концу первой части статьи. Продолжение материала можно [прочитать тут](https://habr.com/ru/company/otus/blog/468555/).* | https://habr.com/ru/post/467741/ | null | ru | null |
# Отучаем Chrome кушать винчестеры
Нравится мне Chrome, но надоело мне что он скрипит винчестером так как будто они не ломаются. Решил я его отучить это делать. Получилось, теперь делюсь рецептурой.
Зачем? Во-первых, винчестер — не железный, в смысле — железный, конечно, но ломаться умеет и чем больше его долбят — тем быстрее ломается (как я понял на собственном опыте, когда потерял все данные); во-вторых, Хром очень много всякого барахла хранит в базах данных, которые почти не используют память компа, в результате через месяц использования даже набор адреса становится пыткой — винчестер скрипит, буквы по секунде набираются. Все эти проблемы убираются.
Warning-warning! Сразу предупрежу — топик для продвинутых пользователей, много подводных камней! Но если Вы беспокоитесь за свои данные и винчестер — добро пожаловать в наши ряды.
Итак, затея простая. Сделать RAMDisk (виртуальный «диск» в памяти компьютера) и заставить Хром хранить там свои дела. Звучит просто, подводных камней хватает и неудобства некоторые будут, но зато винчестер живым выйдет и летать Хром будет. Так что не спешите делать, прочитайте.
1. Качаем RAM Disk: ссылка была взята [тут (+объяснения)](http://www.mydigitallife.info/2007/05/27/free-ramdisk-for-windows-vista-xp-2000-and-2003-server/) и вела она на [скачаивание](http://depositfiles.com/ru/files/916161) (по-моему даже [вот это](http://support.microsoft.com/kb/257405) то же самое).
Скачав, запускаем, там, в общем-то, все очевидно. Я создал RamDisk на 128MB (меньше не рекомендую) под названием R:.
По идее он будет автоматом пересоздаваться при загрузке. (У меня создается)
2. Качаем Iron Portable (это модифицированный Хром, который не шлет в Гугл всяко лишнее о Вас — хотите паранойи? Попробуйте внести 127.0.0.1 google.com в hosts — Google Chrome даже не сможет работать — настолько ему папа Гугл нужен. По крайней мере так было пару месяцев назад.) Ссылка на [скачивание](http://www.srware.net/downloads/IronPortable.zip). Если устареет — ищите Portable версию на [этой странице](http://www.srware.net/en/software_srware_iron_download.php).
Почему именно Portable? Мы же хотим, чтобы Chrome хранил все базы данных на RAMDisk'е (то есть в памяти, которая в 100 раз быстрее, чем винчестер и не так чувствительна к перезаписи — проще говоря: не сломается).
А вот Гугл Хром хранит все Ваши данные в мистической директории Application Data / ...., а не там куда Вы установили. По идее можно запускать Хром с параметром, который должен изменить эту директорию на другую, но на практике этот ключик чисто медитативный (для успокоения), но толком ничего не меняет. Так что заставить не модифицированную версию Хрома хранить базы на RAMDisk мне не удалось. Portable версия с другой стороны хранит данные именно там где она установлена. В остальном ничем почти не отличается.
3. Распаковываем Portable версию в R:\, переименовываем название папки в Iron. Проверка правильности: должен существовать файл R:\Iron\IronPortable.exe
4. Копируем эту директорию куда-нибудь себе на жесткий диск (бэкап, потому что RAMDrive после перезагрузки очистится).
5. Создаем ярлык для Portable версии, указываем:
Объект: R:\Iron\IronPortable.exe
Рабочая папка: R:\Iron\
Рабочую папку указывать обязательно! Иначе у Вас будет профиль создан там где Вы создали ярлык (на рабочем столе, например).
6. Отключаем нафиг защиты от фишинга — это гигантские файлы, тормозящие работу. Если уж мучает паранойя — поставьте [OpenDNSы](http://opendns.com) в качестве DNS серверов — и работать быстрее будет и фишеров недолюбливать будет. Если зарегистрироваться и отключить показ рекламы для своего ip на несуществующих сайтах — вообще отлично работает и кушать не просит.
7. (по желанию, проблемы!) Запустив этот ярлык мы получаем почти бесшумный Chrome. Остается еще одна проблемка — Chrome имеет привычку создавать файлы etilqs (sqlite задом наперед) в TMP папке (c:\Windows\Temp) — это создает тоже нагрузку. Идем менять Temp папку на тот же RamDrive. («Windows Key+Break» — «Свойства системы» — «Дополнительно» — «Переменные среды» — в нижнем окне ищем TMP, ставим R:\tmp
#### Проблемы
1. Проблема пункта 7 в том, что многие программы, например, WinRAR или инсталляторы будут в R:\TMP распаковывать временные файлы и если этот файл больше чем свободного места (а это около 70MB при установленном Iron Portable) то инсталляция не дойдет до конца, а архив не распакуется.
2. Еще проблемы возникают с тем, что иногда у Вас будет вылетать Хром внезапно — это значит что место на R:\ закончилось. Закрываем Хром, идем в r:\Iron\Profile\Default\Cache\, удаляем там все без сожалений.
3. Еще нюанс[\*]: YouTube и прочие ролики Chrome имеет желание кэшировать, так что большие ролики, не помещающиеся на RAMDisk будут показываться только кусками. Может быть, правда, это решается если не делать пункта 7 (не проверял).
[\*] Дорогие Хабравчане, не пишите, пожалуйста, больше "[ньюанс](http://gramota.ru/slovari/dic/?word=%ED%FC%FE%E0%ED%F1&all=x)" — я не грамотей, конечно, но уж очень глаза режет и [часто встречается](http://www.google.ru/search?hl=ru&newwindow=1&q=%2Bньюанс+site:habrahabr.ru&btnG=Поиск&lr=&aq=f&oq=). (Иногда хочется тэг [spoiler][/spoiler])
4. Последнее — если Вы нажмете «Сделать Iron браузером по умолчанию» десктоп-ярлыки со ссылками вида http://… будут создавать профили там где этот ярлык открылся, так что там надо поискать в реестре (regedit.exe) обработчик http:// (я их несколько нашел, по-моему HKEY\_CURRENT\_USER\Software\Classes\http\shell\open\command) — заменить там Iron.exe на *«c:\ram\_iron.bat» — "%1"* и создать c:\ram\_iron.bat с таким содержимым:
`r:
cd \iron\
IronPortable.exe %1 %2 %3 %4`
5. Некоторые файлы .html, например, из папок имеющих пробелы в названии не будут открываться (мой баг, но как его поправить через .bat файл без использования какого-нибудь языка программирования — пока не знаю). Смысл в том, что в каждом аргументе пробелы надо на %20 заменить, а как это сделать в .bat — кто его знает.
#### Стоит ли это того?
Для меня — да. Мне здоровье винчестера и скорость браузинга очень важны.
Лично я использую Хром (точнее, Iron) только таким образом, в противном случае идеология SQLite («мы никогда не потеряем данные, поэтому пишем каждый байт на винчестер, нам не нужны гигабайты оперативки, мы хотим надежности») какой бы правильной ни была (по идее), но по винчестеру сильно бьет. Неудобства есть, но они — мизерные (сохранять состояние перед перезагрузкой, восстанавливать при включении — конечно — не для начинающего пользователя), да периодически кэш чистить приходится (но этого можно избежать заняв больше памяти под RAMDisk).
Йои Хаджи,
[вид с Хабра](http://yoihj.habrahabr.ru/blog/) | https://habr.com/ru/post/61616/ | null | ru | null |
# Лазерное шоу своими руками. Часть 2
Теперь, когда вы прочитали(или не прочитали) всю эту скучную теорию из [первой части](http://habrahabr.ru/post/176527/) – займёмся практическими экспериментами. Если у вас в хозяйстве завалялся аналоговый осциллограф, то вы сможете не прилагая почти никаких усилий вывести на него видео.
Структурную схему простенького лазерного проектора вы можете видеть ниже:
Она достаточно примитивна и не содержит системы термостабилизации лазеров, защитного затвора и прочих радостей настоящего проекторостроителя.
Работает эта система следующим образом: В компьютер или в графический контроллер загружаются файлы с векторными картинками/видео в специальном формате. Управляющая программа преобразует эти файлы в поток точек, каждая из которых характеризуется углом отклонения зеркал гальванометров по вертикали и горизонтали, а также мощностью излучения лазеров. ЦАП формирует из этого потока аналоговые сигналы для управления лазерным проектором по стандарту ILDA. Все выходы ЦАП — дифпары, с размахом ±10В для управления гальванометрами и ±5В для драйверов лазеров. Схема управления гальванометрами, получив новые значения углов поворотов от ЦАП моментально изменяет положение зеркал и стабилизирует их на новом месте(гальванометры имеют обратную связь по положению зеркала и шустренький ПИД регулятор). Драйвера обеспечивают на выходе лазерных диодов интенсивность луча, пропорциональную входному напряжению. Лазерные лучи смешиваясь на специальной зеркальной системе попадают на зеркала гальванометров, и на выходе мы имеем рисующий(сканирующий) лазерный луч того цвета и яркости, который только будет нам угоден.
#### Простейший ЦАП для лазерного проектора
Для сборки и любования этим чудо-агрегатом вам понадобятся:
* Компьютер с ОС Windows и звуковой картой;
* Кусок провода с разъёмом Jack 3.5 от китайских наушников;
* Аналоговый осциллоскоп с возможностью работы в режиме развёртки X/Y;
* Скачать программу [sourceforge.net: LFI Player 3D Laser Display Software](http://sourceforge.net/projects/lfiplayer3d/files/latest/download?source=files);
* Файл с лазерным видео: [Анимация дельфина](http://ibh.tenko.org/habr/ani.ild) [Кусочек Bad Apple](http://ibh.tenko.org/habr/p1501_3000.ild).
1. Распакуйте LFI Player, и отредактируйте в её директории файл EzAudDac.ini под свою систему:
```
; Пример моей конфигурации, для компьютера с одной звуковой картой
[Sound Card Selection]
UseCardNumber=1
LowLatencyBuffering=no
SampleRate=48000
RepeatFrameWhenOut=no
[Channel Invert]
X=no
Y=no
R=yes
G=yes
B=yes
I=yes
[Channel Selection]
X=1
Y=2
R=0
G=0
B=0
I=0
AL=0
AR=0
```
Параметром UseCardNumber выбираем номер звуковой карты, с которой будем работать.
2. Подключите щупы осциллоскопа к выходам левого и правого канала звуковой карты при помощи аудиоразъёма с проводом, переключите осциллоскоп в режим развёртки X/Y
3. Запустите LFI\_Player\_V1\_1\_6\_EzAudDAC.exe, откройте в ней файл ILD, и нажмите Play. На осциллографе вы сможете наблюдать векторную анимацию.
Должно получиться что-то вроде этого:
Картинка слегка искажена из-за наличия разделительных конденсаторов на выходе ЦАП звуковой карты, которые не пропускают постоянную составляющую. Если их убрать, и добавить простейший усилитель на ОУ(слегка изменённый выходной каскад из схемы ниже), вы получите полноценный ЦАП для лазерной графики. Единственный его недостаток — небольшие частоты дискретизации, которые не позволят вам рисовать сложные многоэлементные картины или растр.
#### Высокоскоростной ЦАП
Более серьёзный ЦАП, лишённый этих недостатков можно собрать по схемам, приведённым ниже.
Плата ЦАП:
[Увеличить](http://ibh.tenko.org/habr/lfdac_p1.jpg)
Переходник на стандартный разъём ILDA:
[Увеличить](http://ibh.tenko.org/habr/lfdac_p2.jpg)
Микроконтроллер DD1 [CY7C68013A](http://www.cypress.com/?mpn=CY7C68013A-56PVXCT) обеспечивает связь по USB 2.0 и содержит в себе буферы FIFO для эндпоинтов USB. Встроенный в контроллер логический автомат GPIF настраивается так, чтобы не задействуя сам контроллер, по тактовому сигналу мгновенно загружать данные из буфера эндпоинтов в соответствующие ЦАП. Получилось что-то вроде скоростной звуковой карты, с дискретизацией до нескольких мегагерц. Все ЦАПы и источник опорного напряжения были заказаны у [Texas Instruments](http://www.ti.com/) как семплы.
Вот так это выглядит в собранном виде:
Прошивка будет, но чуть позже.
В следующей серии я расскажу вам, как собрать лазерный драйвер с аналоговым управлением. | https://habr.com/ru/post/176539/ | null | ru | null |
# Внешняя сортировка с O(1) дополнительной памяти
Прочитав [эту статью](http://habrahabr.ru/post/266557/), я вспомнил, как писал внешнюю сортировку, которая использовала O(1) внешней памяти. Функция получала бинарый файл и максимальный размер памяти, которую она могла выделить под массив:
```
void ext_sort(const std::string filename, const size_t memory)
```
Я использовал алгоритм из [Effective Performance of External Sorting with No Additional Disk Space](https://scholar.google.co.il/scholar?cluster=7995905689817415486&hl=ru&as_sdt=0,5):
1. Разделим файл на блоки, которые помещаются в доступную память. Обозначим эти блоки Block\_1, Block\_2, …, Block\_(S-1), Block\_S. Установим P = 1.
2. Читаем Block\_P в память.
3. Отсортируем данные в памяти и запишем назад в Block\_P. Установим P = P + 1, и если P ≤ S, то читаем Block\_P в память и повторяем этот шаг. Другими словами, отсортируем каждый блок файла.
4. Разделим каждый блок на меньшие блоки B\_1 и B\_2. Каждый из таких блоков занимает половину доступной памяти.
5. Читаем блок B\_1 блока Block\_1 в первую половину доступной памяти. Установим Q = 2.
6. Читаем блок B\_1 блока Block\_Q во вторую половину доступной памяти.
7. Объеденим массивы в памяти с помощью in-place слияния, запишем вторую половину памяти в блок B\_1 блока Block\_Q и установим Q = Q + 1, если Q ≤ S, читаем блок B\_1 блока Block\_Q во вторую половину доступной памяти и повторяем этот шаг.
8. Записываем первую половину доступной памяти в блок B\_1 блока Block\_1. Так как мы всегда оставляли в памяти меньшую половину элементов и провели слияние со всеми блоками, то в этой части памяти хранятся M минимальных элементы всего файла.
9. Читаем блок B\_2 блока Block\_S во вторую половину доступной памяти. Установим Q = S −1.
10. Читаем блок B\_2 блока Block\_Q в первую половину доступной памяти.
11. Объеденим массивы в памяти с помощью in-place слияния, запишем первую половину доступной памяти в блок B\_2 блока Block\_Q и установим Q = Q −1. Если Q ≥ 1 читаем блок B\_2 блока Block\_Q в первую половину доступной памяти и повторяем этот шаг.
12. Записываем вторую половину доступной памяти в блок B\_2 блока Block\_S. Аналогично шагу 8, тут хранятся максимальные элементы всего файла.
13. Начиная от блока B\_2 блока Block\_1 и до блока B\_1 блока Block\_S, определим новые блоки в файле и снова пронумеруем их Block\_1 to Block\_S. Разделим каждый блок на блоки B\_1 и B\_2. Установим P = 1.
14. Читаем B\_1 и B\_2 блока Block\_P в память. Объеденим массивы в памяти. запишем отсортированный массив назад в Block\_P и установим P = P +1. Если P ≤ S, повторяем этот шаг.
15. Если S > 1, возвращаемся к шагу 5. Каждый раз мы выделяем M минимальных и максимальных элементов, записываем их в начало и конец файла соответственно, а потом делаем то же самое с оставшимися элементами, пока не дойдем до середины файла.
Преимущество такого алгоритма, кроме отсутствия буфера на диске, это то, что с диска мы читаем данные относительно большими порциями, что ускоряет алгоритм.
Реализуем алгоритм на C++.
Для начала определим количество блоков и размер блока в байтах и в элементах и выделим память:
```
const size_t type_size = sizeof(T);
const uint64_t filesize = file_size(filename);
std::fstream data(filename, std::ios::in | std::ios::out | std::ios::binary);
const uint64_t chunk_number = filesize / memory;
const size_t chunk_size = memory / type_size - (memory / type_size) % 2, chunk_byte_size =
chunk_size * type_size, half_chunk_byte_size = chunk_byte_size / 2, half_chunk_size = chunk_size / 2;
std::vector \*chunk = new std::vector(chunk\_size);
```
Теперь пункты 2-3 — сортируем каждый блок:
```
for (uint64_t i = 0; i < chunk_number; ++i) {
data.seekg(chunk_byte_size * i);
data.read((char *) chunk->data(), chunk_byte_size);
flat_quick_sort(chunk->begin(), chunk->end());
data.seekp(chunk_byte_size * i);
data.write((char *) chunk->data(), chunk_byte_size);
}
```
Саму сортировку мы напишем чуть позднее.
Приступим к слияниям. Нижняя половина:
```
int64_t s = chunk_number, start = 0;
while (s > 0) {
data.seekp(half_chunk_byte_size * start);
data.read((char *) chunk->data(), half_chunk_byte_size);
for (int64_t q = 1; q < s; ++q) {
data.seekg(half_chunk_byte_size * start + chunk_byte_size * q);
data.read((char *) (chunk->data() + half_chunk_size), half_chunk_byte_size);
in_place_merge(chunk->begin(), chunk->begin() + half_chunk_size - 1, chunk->begin() + chunk_size);
data.seekp(half_chunk_byte_size * start + chunk_byte_size * q);
data.write((char *) (chunk->data() + half_chunk_size), half_chunk_byte_size);
}
data.seekp(half_chunk_byte_size * start);
data.write((char *) chunk->data(), half_chunk_byte_size);
```
И аналогично верхняя:
```
data.seekp(half_chunk_byte_size * start + chunk_byte_size * s - half_chunk_byte_size);
data.read((char *) (chunk->data() + half_chunk_size), half_chunk_byte_size);
for (int64_t q = s - 2; q >= 0; --q) {
data.seekg(half_chunk_byte_size * (start + 1) + chunk_byte_size * q);
data.read((char *) chunk->data(), half_chunk_byte_size);
in_place_merge(chunk->begin(), chunk->begin() + half_chunk_size - 1, chunk->begin() + chunk_size);
data.seekp(half_chunk_byte_size * (start + 1) + chunk_byte_size * q);
data.write((char *) chunk->data(), half_chunk_byte_size);
}
data.seekg(half_chunk_byte_size * start + chunk_byte_size * s - half_chunk_byte_size);
data.write((char *) (chunk->data() + half_chunk_size), half_chunk_byte_size);
```
Перераспределяем блоки, завершаем цикл и не забываем освободить память:
```
--s;
++start;
for (int64_t p = 0; p < s; ++p) {
data.seekp(half_chunk_byte_size * start + chunk_byte_size * p);
data.read((char *) chunk->data(), chunk_byte_size);
in_place_merge(chunk->begin(), chunk->begin() + half_chunk_size - 1, chunk->begin() + chunk_size);
data.seekg(half_chunk_byte_size * start + chunk_byte_size * p);
data.write((char *) chunk->data(), chunk_byte_size);
}
}
delete chunk;
}
```
**Функция полностью**
```
template
void ext\_sort(const std::string filename, const size\_t memory) {
const size\_t type\_size = sizeof(T);
const uint64\_t filesize = file\_size(filename);
std::fstream data(filename, std::ios::in | std::ios::out | std::ios::binary);
const uint64\_t chunk\_number = filesize / memory;
const size\_t chunk\_size = memory / type\_size - (memory / type\_size) % 2, chunk\_byte\_size =
chunk\_size \* type\_size, half\_chunk\_byte\_size = chunk\_byte\_size / 2, half\_chunk\_size = chunk\_size / 2;
std::vector \*chunk = new std::vector(chunk\_size);
for (uint64\_t i = 0; i < chunk\_number; ++i) {
data.seekg(chunk\_byte\_size \* i);
data.read((char \*) chunk->data(), chunk\_byte\_size);
flat\_quick\_sort(chunk->begin(), chunk->end());
data.seekp(chunk\_byte\_size \* i);
data.write((char \*) chunk->data(), chunk\_byte\_size);
}
int64\_t s = chunk\_number, start = 0;
while (s > 0) {
data.seekp(half\_chunk\_byte\_size \* start);
data.read((char \*) chunk->data(), half\_chunk\_byte\_size);
for (int64\_t q = 1; q < s; ++q) {
data.seekg(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* q);
data.read((char \*) (chunk->data() + half\_chunk\_size), half\_chunk\_byte\_size);
in\_place\_merge(chunk->begin(), chunk->begin() + half\_chunk\_size - 1, chunk->begin() + chunk\_size);
data.seekp(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* q);
data.write((char \*) (chunk->data() + half\_chunk\_size), half\_chunk\_byte\_size);
}
data.seekp(half\_chunk\_byte\_size \* start);
data.write((char \*) chunk->data(), half\_chunk\_byte\_size);
data.seekp(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* s - half\_chunk\_byte\_size);
data.read((char \*) (chunk->data() + half\_chunk\_size), half\_chunk\_byte\_size);
for (int64\_t q = s - 2; q >= 0; --q) {
data.seekg(half\_chunk\_byte\_size \* (start + 1) + chunk\_byte\_size \* q);
data.read((char \*) chunk->data(), half\_chunk\_byte\_size);
in\_place\_merge(chunk->begin(), chunk->begin() + half\_chunk\_size - 1, chunk->begin() + chunk\_size);
data.seekp(half\_chunk\_byte\_size \* (start + 1) + chunk\_byte\_size \* q);
data.write((char \*) chunk->data(), half\_chunk\_byte\_size);
}
data.seekg(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* s - half\_chunk\_byte\_size);
data.write((char \*) (chunk->data() + half\_chunk\_size), half\_chunk\_byte\_size);
--s;
++start;
for (int64\_t p = 0; p < s; ++p) {
data.seekp(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* p);
data.read((char \*) chunk->data(), chunk\_byte\_size);
in\_place\_merge(chunk->begin(), chunk->begin() + half\_chunk\_size - 1, chunk->begin() + chunk\_size);
data.seekg(half\_chunk\_byte\_size \* start + chunk\_byte\_size \* p);
data.write((char \*) chunk->data(), chunk\_byte\_size);
}
}
delete chunk;
}
```
Осталось реализовать функции flat\_quick\_sort и in\_place\_merge. Идею (и большую часть реализации) flat quick sort я взял в [статье](http://habrahabr.ru/post/247053/) хабраюзера [ripatti](http://habrahabr.ru/users/ripatti/). Я только заменил median of medians (посчитал это оверкиллом в среднем случае) на median-of-nine и добавил сортировку вставками для маленьких частей массива.
**flat\_quicksort.h**
```
#ifndef EXTERNAL_SORT_FLAT_QUICKSORT_H
#define EXTERNAL_SORT_FLAT_QUICKSORT_H
template
void insertion\_sort(ForwIt be, ForwIt en) {
for (ForwIt ii = be + 1; ii != en; ii++) {
ForwIt jj = ii - 1;
auto val = \*ii;
while (jj >= be and \*jj > val) {
\*(jj + 1) = \*jj;
--jj;
}
\*(jj + 1) = val;
}
}
template
ForwIt median\_of\_3(ForwIt it1, ForwIt it2, ForwIt it3) {
return (\*it1 > \*it2) ?
(\*it3 > \*it2) ? (\*it1 > \*it3) ? it3 : it1 : it2 :
(\*it3 > \*it1) ? (\*it2 > \*it3) ? it3 : it2 : it1;
}
template
ForwIt choose\_pivot(ForwIt be, ForwIt en) {
ptrdiff\_t s = (en - be) / 8;
ForwIt mid = be + (en - be) / 2;
ForwIt best1 = median\_of\_3(be, be + s, be + 2 \* s), best2 = median\_of\_3(mid - s, mid, mid + s), best3 = median\_of\_3(
en - 2 \* s, en - s, en);
return median\_of\_3(best1, best2, best3);
}
// search for the end of the current block
template
ForwIt block\_range(ForwIt be, ForwIt en) {
ForwIt it = be;
while (it != en) {
if (\*be < \*it)
return it;
++it;
}
return it;
}
// warning: after the partition outer pivot may point to random element
template
std::pair partition\_range(ForwIt be, ForwIt en, ForwIt pivot) {
std::pair re;
ForwIt j = be;
for (ForwIt i = be; i != en; ++i)
if (\*i < \*pivot) {
if (pivot == i) pivot = j; else if (pivot == j) pivot = i;
std::swap(\*j, \*i);
++j;
}
re.first = j;
for (ForwIt i = j; i != en; ++i)
if (\*pivot == \*i) {
if (pivot == i) pivot = j; else if (pivot == j) pivot = i;
std::swap(\*j, \*i);
++j;
}
re.second = j;
return re;
}
// makes largest element the first
template
void blockify(ForwIt be, ForwIt en) {
for (ForwIt it = be; it != en; ++it)
if (\*be < \*it)
std::swap(\*be, \*it);
}
template
void flat\_quick\_sort(ForwIt be, ForwIt en) {
ForwIt tmp = en; // the current end of block
while (be != en) {
if (std::is\_sorted(be, tmp)) {
be = tmp;
tmp = block\_range(be, en);
continue;
}
if (tmp - be < 32)
insertion\_sort(be, tmp);
else {
ForwIt pivot = choose\_pivot(be, tmp);
std::pair range = partition\_range(be, tmp, pivot);
blockify(range.second, tmp);
tmp = range.first;
}
}
}
#endif //EXTERNAL\_SORT\_FLAT\_QUICKSORT\_H
```
Со слиянием было сложнее. Сначала я использовал заглушку, использующую O(n) памяти:
```
template
void merge(std::vector &chunk, size\_t s, size\_t q, size\_t r) {
std::vector \*chunk2 = new std::vector(q - s + 1);
auto it2 = chunk2->begin(), it1 = chunk.begin() + q + 1, it = chunk.begin() + s;
std::copy(it, it1, it2);
while (it2 != chunk2->end() && it1 != chunk.begin() + r + 1) {
if (\*it1 > \*it2) {
\*it = \*it2;
++it2;
} else {
\*it = \*it1;
++it1;
}
++it;
}
if (it1 == chunk.begin() + r + 1)
std::copy(it2, chunk2->end(), it);
else
std::copy(it1, chunk.begin() + r + 1, it);
delete chunk2;
}
```
Когда я захотел заменить заглушку in-place версией, оказалось, что быстрые алгоритмы in-place слияния в большинстве своем достаточно запутанные (посмотрите, например, [On optimal and efficient in place merging](https://scholar.google.com/scholar?cluster=15596289922936727341&hl=ru&as_sdt=0,5)). Мне надо было что-то попроще, и я выбрал алгоритм из статьи [A simple algorithm for in-place merging](https://scholar.google.co.il/scholar?cluster=8489305296842245618&hl=ru):
**in-place merge**
```
template
void merge\_B\_and\_Y(Iter z, Iter y, Iter yn) {
for (; z < y && y < yn; ++z) {
Iter j = std::min\_element(z, y);
if (\*j <= \*y)
std::swap(\*z, \*j);
else {
std::swap(\*z, \*y);
++y;
}
}
if (z < y)
flat\_quick\_sort(z, yn);
}
template
Iter find\_next\_X\_block(Iter x0, Iter z, Iter y, size\_t k, size\_t f, Iter b1,
Iter b2, auto max) {
auto min1 = max, min2 = max;
Iter m = x0 + (ptrdiff\_t) floor((z - x0 - f) / k) \* k + f, x = x0;
if (m <= z)
m += k;
for (auto i = m; i + k <= y; i += k) {
if (i != b1 && i != b2) {
Iter j = (i < b1 && b1 < i + k) ? m - 1 : i + k - 1;
if (\*i <= min1 && \*j <= min2) {
x = i;
min1 = \*i;
min2 = \*j;
}
}
}
return x;
}
template
void in\_place\_merge(Iter x0, Iter y0, Iter yn, int64\_t k, bool rec) {
if (k == -1)
k = (int64\_t) sqrt(yn - x0);
size\_t f = (y0 - x0) % k;
Iter x = (f == 0) ? y0 - 2 \* k : y0 - k - f;
auto t = \*x, max = \*std::max\_element(x0, yn);
\*x = \*x0;
Iter z = x0, y = y0, b1 = x + 1, b2 = y0 - k;
int i = 0;
while (y - z > 2 \* k) {
++i;
if (\*x <= \*y || y >= yn) {
\*z = \*x;
\*x = \*b1;
++x;
if ((x - x0) % k == f) if (z < x - k)
b2 = x - k;
x = find\_next\_X\_block(x0, z, y, k, f, b1, b2, max);
} else {
\*z = \*y;
\*y = \*b1;
++y;
if ((y - y0) % k == 0)
b2 = y - k;
}
++z;
\*b1 = \*z;
if (z == x)
x = b1;
if (z == b2)
b2 = yn + 1;
++b1;
if ((b1 - x0) % k == f)
b1 = (b2 == yn + 1) ? b1 - k : b2;
}
\*z = t;
if (rec)
merge\_B\_and\_Y(z, y, yn);
else {
flat\_quick\_sort(z, y);
in\_place\_merge(z,y,yn,(int64\_t)sqrt(k),true);
}
}
```
Но на моем компьютере замена merge на in-place merge замедляла алгоритм почти на порядок. Возможно я ошибся в реализации или просто выбрал медленный алгоритм в погоне за простотой. Времени разбираться, как всегда, не было, к тому же gprof почему-то падал. И тут меня осенило. Если мы выделям M байт динамической памяти, то не важно, как мы её используем, мы все равно получаем O(1). Тогда просто выделим 2/3 под данные, а треть — под буфер слияния. Замедление будет гораздо меньше. И правда:
| Алгоритм | Время (75MB int64 в 7,5MB памяти) | Скорость (75MB int64 в 7,5MB памяти) | Время (7,5MB int64 в 75KB памяти) | Скорость (7,5MB int64 в 75KB памяти) | Время (750MB int64 в 75MB памяти) | Скорость (750MB int64 в 75MB памяти) |
| --- | --- | --- | --- | --- | --- | --- |
| In-place merge | 6.04329 s | 1 241 045 B/s | 24.2993 s | 3 086 508 B/s | - | - |
| Merge | 0.932663 s | 8 041 489 B/s | 2.73895 s | 27 382 756 B/s | 47.7946 s | 15 691 689 B/s |
| Алгоритм [SLY\_G](http://habrahabr.ru/users/sly_g/) | 1.79629 s | 4175272 B/s | 3.84775 s | 19 491 910 B/s | 39.77 s | 18 858 436 B/s |
К сожалению, на больших объемах алгоритм замедляется, что ожидаемо, ведь мы не используем никакого буфера вообще. Тем не менее, скорость алгоритма достаточно адекватная, и, я уверен, может быть улучшена.
Все исходники лежат [здесь](https://github.com/Randl/CS/tree/master/External%20sort). | https://habr.com/ru/post/268535/ | null | ru | null |
# Автоматизация поддержания соответствия между названиями слоев в редакторе и коде с помощью CodeDom
При работе с [Unity](https://unity3d.com/ru/) очень часто приходится обращаться к сущностям Unity (слоям коллизий, сортировочным слоям, тэгам, осям ввода, сценам) по их названиям. Если какую-то из них, например, переименовать в редакторе, то нужно не забыть, соответственно, подправить название в коде, иначе нас ждет ошибка. И ошибка эта возникнет не при компиляции, а во время выполнения, непосредественно в момент обращения по имени. Немного автоматизации спасет от таких неприятных сюрпризов.
На первый взгляд, для решения этой проблемы логично использовать [шаблоны T4,](http://www.google.ru/search?q=t4+template) но они мне показались неудобными (по крайней мере, при использовании именно в Unity-проекте), поэтому я выбрал другой подход. Использование [CodeDom](http://www.google.ru/search?q=codedom) для решения такой мелкой проблемы может показаться оверинжинирингом, но личный опыт доказал состоятельность этого подхода: я написал свой незамысловатый генератор кода больше года назад, и с тех пор, не внося в него изменения, успешно пользовался им, что сэкономило мне немало нервов и порядочно секунд времени.
В данной статье мы рассмотрим написание аскетичного генератора кода с [константами](https://msdn.microsoft.com/ru-ru/library/ms173119.aspx), содержащими названия [слоев](https://docs.unity3d.com/Manual/Layers.html) [коллизий](https://docs.unity3d.com/Manual/LayerBasedCollision.html). Работа с названиями других сущностей делается аналогично.
Общий план действий таков:
* Получить список названий слоев коллизий, имеющихся в проекте.
* Сгенерировать сам код, содержащий класс с нужными константами.
* Записать этот код в файл.
* Побудить Unity немедленно скомпилировать добавленный/измененный файл.
### Получаем список названий слоев коллизий
Тут все просто, если не бояться лезть в места, названные внутренними. Конкретнее, список имен слоев коллизий хранится как поле «внутреннего» класса.
```
private static IEnumerable GetAllLayers()
{
return InternalEditorUtility.layers;
}
```
### Генерируем сам код
У CodeGen слегка своя терминология (сравните, например, с терминологией в [Roslyn](https://github.com/dotnet/roslyn/wiki/Roslyn%20Overview)), но, в целом, все соответствует синтаксическому дереву, присущему коду на C#. В порядке от корня к листьям, мы будем использовать следующее:
1. CodeCompilationUnit — это сам генератор кода, который мы здесь, так сказать, конфигурируем.
2. CodeNamespace — это пространство имен, в котором будет сидеть наш класс. Мы не будем оборачивать класс в явное пространство имен, но создать экземпляр CodeNamespace, все равно, придется.
3. CodeTypeDeclaration — это сам класс.
4. CodeMemberField — это член класса (в данном случае, объявление константы).
5. CodePrimitiveExpression — это выражение с литералом (в данном случае, строка, который будет присваиваться константе).
Генерируем публичную строковую константу, у которой имя и значение совпадают с именем слоя коллизий.
```
private static CodeMemberField GenerateConstant(string name)
{
name = name.Replace(" ", "");
var @const = new CodeMemberField(
typeof(string),
name);
@const.Attributes &= ~MemberAttributes.AccessMask;
@const.Attributes &= ~MemberAttributes.ScopeMask;
@const.Attributes |= MemberAttributes.Public;
@const.Attributes |= MemberAttributes.Const;
@const.InitExpression = new CodePrimitiveExpression(name);
return @const;
}
```
Есть у CodeGen одно мелкое неудобство: он не умеет создавать статические классы. Связано это с тем, что он создавался на заре языка C#, когда в него еще не «завезли» статические классы. Будем выкручиваться: сымитируем статический класс запечатанным классом с приватным конструктором. Так поступали некоторые ранние пользователи C#, а использующие язык Java вынуждены и сейчас прибегать к этому.
```
private static void ImitateStaticClass(CodeTypeDeclaration type)
{
@type.TypeAttributes |= TypeAttributes.Sealed;
@type.Members.Add(new CodeConstructor {
Attributes = MemberAttributes.Private | MemberAttributes.Final
});
}
```
Наконец-то, соберем сам класс, с приватным конструктором и константами:
```
private static CodeCompileUnit GenerateClassWithConstants(
string name,
IEnumerable constants)
{
var compileUnit = new CodeCompileUnit();
var @namespace = new CodeNamespace();
var @class = new CodeTypeDeclaration(name);
ImitateStaticClass(@class);
foreach (var constantName in constants)
{
var @const = GenerateConstant(constantName);
@class.Members.Add(@const);
}
@namespace.Types.Add(@class);
compileUnit.Namespaces.Add(@namespace);
return compileUnit;
}
```
### Записываем код в файл
```
private static void WriteIntoFile(string fullPath, CodeCompileUnit code)
{
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (var stream = new StreamWriter(fullPath, append: false))
{
var writer = new IndentedTextWriter(stream);
using (var codeProvider = new CSharpCodeProvider())
{
codeProvider.GenerateCodeFromCompileUnit(code, writer, new CodeGeneratorOptions());
}
}
}
```
### Заставляем Unity немедленно «осознать» изменения
Это последний шаг, и он не требует существенного количества кода, поэтому пусть этим занимается та функция, которая будет реагировать на ввод пользователя.
```
[MenuItem("Habr/Generate layers constants")]
private static void GenerateAndForceImport()
{
const string path = @"Auto/Layers.cs";
var fullPath = Path.Combine(Application.dataPath, path);
var className = Path.GetFileNameWithoutExtension(fullPath);
var code = GenerateClassWithConstants(className, GetAllLayers());
WriteIntoFile(fullPath, code);
AssetDatabase.ImportAsset("Assets/" + path, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
```
### Результат
Собираем все воедино:
**Итоговый код генератора**
```
namespace Habr
{
using Microsoft.CSharp;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using UnityEditor;
using UnityEditorInternal;
using UnityEngine;
internal static class HabrCodeGen
{
[MenuItem("Habr/Generate layers constants")]
private static void GenerateAndForceImport()
{
const string path = @"Auto/Layers.cs";
var fullPath = Path.Combine(Application.dataPath, path);
var className = Path.GetFileNameWithoutExtension(fullPath);
var code = GenerateClassWithConstants(className, GetAllLayers());
WriteIntoFile(fullPath, code);
AssetDatabase.ImportAsset("Assets/" + path, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
private static CodeCompileUnit GenerateClassWithConstants(
string name,
IEnumerable constants)
{
var compileUnit = new CodeCompileUnit();
var @namespace = new CodeNamespace();
var @class = new CodeTypeDeclaration(name);
ImitateStaticClass(@class);
foreach (var constantName in constants)
{
var @const = GenerateConstant(constantName);
@class.Members.Add(@const);
}
@namespace.Types.Add(@class);
compileUnit.Namespaces.Add(@namespace);
return compileUnit;
}
private static CodeMemberField GenerateConstant(string name)
{
name = name.Replace(" ", "");
var @const = new CodeMemberField(
typeof(string),
name);
@const.Attributes &= ~MemberAttributes.AccessMask;
@const.Attributes &= ~MemberAttributes.ScopeMask;
@const.Attributes |= MemberAttributes.Public;
@const.Attributes |= MemberAttributes.Const;
@const.InitExpression = new CodePrimitiveExpression(name);
return @const;
}
private static IEnumerable GetAllLayers()
{
return InternalEditorUtility.layers;
}
private static void ImitateStaticClass(CodeTypeDeclaration type)
{
@type.TypeAttributes |= TypeAttributes.Sealed;
@type.Members.Add(new CodeConstructor {
Attributes = MemberAttributes.Private | MemberAttributes.Final
});
}
private static void WriteIntoFile(string fullPath, CodeCompileUnit code)
{
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (var stream = new StreamWriter(fullPath, append: false))
{
var tw = new IndentedTextWriter(stream);
using (var codeProvider = new CSharpCodeProvider())
{
codeProvider.GenerateCodeFromCompileUnit(code, tw, new CodeGeneratorOptions());
}
}
}
}
}
```
Кладем нашу утилиту в папку Editor, нажимаем Habr → Generate layers constants, получаем в проекте файл со следующим содержанием:
```
// ------------------------------------------------------------------------------
//
// This code was generated by a tool.
// Mono Runtime Version: 2.0.50727.1433
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// ------------------------------------------------------------------------------
public sealed class Layers {
public const string Default = "Default";
public const string TransparentFX = "TransparentFX";
public const string IgnoreRaycast = "IgnoreRaycast";
public const string Water = "Water";
public const string UI = "UI";
public const string Habr = "Habr";
private Layers() {
}
}
```
### Дальнейшие действия
Полученной утилите не хватает следующих вещей:
* Чуть более удобного интерфейса с чуть более гибкими настройками.
* Устойчивости к невалидным в C# названиям.
* Генерации аналогичным образом констант для названий сортировочных слоев, сцен, тэгов и осей ввода.
Чтобы не тратить время на написание своего «велосипеда», вы также можете воспользоваться [моим «велосипедом»](https://gist.github.com/dogfuntom/00faf9f3598d845b1a5c). | https://habr.com/ru/post/309128/ | null | ru | null |
# «И швец и жнец» или обзор полезных расширений для XWiki
Вот уже второй год, как мы используем XWiki вместо Confluence.
За это время я к ней привык и даже в некотором роде полюбил. Поэтому не могу пройти мимо такого важного события как выход новой LTS версии 4.10.X.
Если вы не знакомы с релизным циклом XWiki, то вас может удивить, что LTS версия выходит в конце года и в течение следующего года получает обновления. Иногда бывает так, что обновления версии XWiki, что-то правит и одновременно что-то ломает, но в целом как обновление того стоит. Например, в 14 версии неплохо улучшили работу с вложениями, экспортом PDF и диалогом вставки изображений в редакторе.
Сегодня я не буду вдаваться в технические подробности, а просто сделаю беглый обзор функционала, рассчитанный в первую очередь на людей только что узнавших об XWiki. Обозревать мы будем самую последнюю на текущий момент версию 14.10.2 со Standard Flavor, установленную через Docker образ.
Для начала оставлю ссылки на другие статьи цикла:
* [Может ли Xwiki заменить Confluence](https://habr.com/ru/post/541184/)
* [Работа с меню и боковыми панелями](https://habr.com/ru/post/551772/)
* [Изменяем профиль пользователя, добавляем новые поля](https://habr.com/ru/post/573626/)
* [Немного моих полезных рецептов](https://habr.com/ru/post/649157/)
* [Клонируем репозиторий GitLab прямо внутрь XWiki](https://habr.com/ru/post/667166/)
* [Создаем свое приложение App within minutes на примере интеграции с Telecom API](https://habr.com/ru/company/mtt/blog/680308/)
Теперь оглавление:
* [Введение](#a1)
* [Расширения из пакета Demo flavor](#a2)
* [Еще несколько интересных расширений](#a3)
* [Заключение](#a4)
Введение
--------
Если вы прочитали мою [самую первую статью про XWiki](https://habr.com/ru/post/541184/), то уже знаете, что я при установке обычно рекомендовал выбрать [Demo Flavor](https://extensions.xwiki.org/xwiki/bin/view/Extension/Demo%20Flavor/), Данный пакет подтягивал набор расширений, которые переносили пользователя вики “в мир роскоши и комфорта”. Фактически мы могли сделать простенький портал для управления проектом или проектной командой.
К сожалению, не так давно Demo Flavor перестал поддерживаться, а значит новые пользователи могут никогда не узнать о том, как из XWiki сделать блог, форум или даже таск-менеджер.
Но это не беда! Ведь сегодня мы посмотрим на несколько интересных расширений для XWiki, которые вы сможете легко установить в любой момент после завершения инсталляции. Просто введите название расширения в строку поиска менеджера расширений. Если ничего не нашлось, нажмите на кнопку “Все совместимые расширения”.
Расширения из пакета Demo flavor
--------------------------------
### Добавляем Markdown
Расширение: [**CommonMark Markdown Syntax 1.2**](https://extensions.xwiki.org/xwiki/bin/view/Extension/MarkdownSyntax/Markdown%20Syntax%201.2)
На текущий момент, XWiki не совсем полноценно работает с Markdown (например, реализован не весь функционал таблиц), но в целом очень полезно иметь возможность работы с markdown, особенно если вы копируете тексты из других систем документирования.
### Таск-менеджер
Прежде чем перейти непосредственно к расширению Task Manager Application, стоит сказать, что в Demo Flavor были пакеты для интеграцией с Jira:
[JIRA Macro](https://yandex.ru/clck/jsredir?from=yandex.ru%3Bsearch%2F%3Bweb%3B%3B&text=&etext=2202.5DHm1dYWQcVob6OkMiUWt-YhDJ4wLOCnJBJ1PpozXJNrYmthbGtza256d3Bkd3Zr.0d8ef05225f777292bf03fe6e1f034f3ca76ed40&uuid=&state=jLT9ScZ_wbo,&&cst=AiuY0DBWFJ5fN_r-AEszk2GSp6cqwAQ02omw_5r6JVqqoI8Az3p_zIWIA8icHNKMbgV1iS0s5wFfEUMWDIle7TEMEIZWS8gD3DMwr10EZtqpcEh1569AYsv_oDZKHCftPEfgnHvpoUBq5QNy6S641u5Fur6j5uHp3T86f0HlZqGCdYUhjG1TvYUdjrQOuOIrFFtfek4XvXVkyNWPOQrbqrgZ_OyWIU2sVV9NFfBwKNJynBCmqkUeVDDsjbrL_j-GhNi6hnmJ45ipcsk_2_ile7XJuO3AWg4rT7A5O-EPDqu6XgGVf8i3PYP6pwpD_kQR_g3tnUu-1FoYzssE9z0Vhx4_DCLuV8-mdOD8xzCR7xkscJpHXvFdtmLrDdWI-iJWfAGqVWhWxHXk4wuA0XgyMFlsvc8R-PfMOZvy5NW8xxQzhd7da-PMV4uqCJWuvRfH84yOabxjs7QfjF_C3LRhrlYcazXIRliIMRSSB6jLpf3qcMMgsIUxqAG5ZLsSXou4DS1TNjl2CX1IZLSrz_wz_YeSLJFYnWy4msjHCYpvK4E4RqNlHbFAcTqQT2Y860R6pxUn84pSJw47ZgjkLUNLsH8HlacKTbXsKVeEfuA3TOtzSUtWQU3eZezFanjuoSC9qmW_OPjri14sl-YpLpMfv8blgHad0Nqp4wAKfW1xeNHQm3qpEs2U2IYyREoBJK7MO7SKSfE-NFOFLwUY88B1Cc91uFRqcc5vWss7TQtCJfIPNbyUnZ7kJcV854WPQpkECT8JO8fmi6FFZ947ejVUQL1mbUls4b9g3zM4NzfOdEY1qysZAahrx5kUA7jZ_ZMvQzeSK-pAQ1qS_3D9jlsyoT58cPMIKYnG4IKrLOLhPcn91jaCq4wmF1xrGhKsQhjcrha_NxI6YvLRAJK2sougFczOfOu_XocrPnZEG-JkCF9YNhTgU4F6LDBk_gR0Hgrhvs3YiMatlg6uTktJGsaKnRQagK-DUn0bi42Y_fEkNx76TIcGl5WCjmOL83NKm5lLtgDOWcPlD4cUnlzcPUlHoa3f9Uh4xjMJ7vYDtkfS5f_VkznMGnvTMuk2eUvZNytAxjbyPxcdPIpxIa9ucJ7dOg5-OFl3XldnsveooBQXeiqciSC1CWD09TB0hBHFL0fE07IoNXWopIScNICvuu6FzssS4TLNQtxQPYlEt-5seB2SdUztSCtw7kDvjl6FhQZD&data=UlNrNmk5WktYejY4cHFySjRXSWhXQ1NZNW5TZlJMUXhUZHhjbDY2cW0yQ19UOF9SdDNZVG13d1IzZnpYdkJtRWRQZVhSRWJ0ZzB6N2hhaDJPakxFY2JZd3I4Tm91b1JkT1FUR2NFYnlianZyMTJnaDU1RG95UE14MkNzTlg0a3poVXltcjFLSXJtV3NETmEzdERIQkg5VFgydXdIcDdqSEtnSnN5LWRXZHFnLA,,&sign=296a9060c449b1a8ef4d1ee43a23f4e6&keyno=0&b64e=2&ref=orjY4mGPRjk5boDnW0uvlrrd71vZw9kpzUV_GDU1tL9f73Ah0JyrMwDWm_bXNhOa_MJfUWFahbU,&l10n=ru&cts=1672482750182%40%40events%3D%5B%7B%22event%22%3A%22click%22%2C%22id%22%3A%221_1j4aw00-01%22%2C%22cts%22%3A1672482750182%2C%22fast%22%3A%7B%22organic%22%3A1%7D%2C%22service%22%3A%22web%22%2C%22event-id%22%3A%22lcbt1p7qs3%22%7D%5D&mc=1.584962500721156&hdtime=1127.7) + [JIRA Admin Application](https://extensions.xwiki.org/xwiki/bin/view/Extension/JIRA%20Administration/), с помощью которых можно подключиться к Jira и посмотреть последние обновления в проектах.
Но я ими почти не пользовался, поэтому перейдем к полноценному такс-менеджеру.
Расширение: [**Task Manager Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/Task%20Manager%20Application)
Если вы очень не прихотливы в вопросах управления проекта или у вас небольшая команда, то возможно вам вполне хватит функционала этого расширения.
Можно создать проект, настроить статусы и приоритеты.
А потом завести и посмотреть задачи.
С помощью макроса, любую страницу можно превратить в Kanban доску
`{{kanbanboard space="TaskManager" /}}`
Само собой решения от крупных производителей выглядят интереснее, но поскольку это open source вы всегда сможете допилить базовое расширение под свои нужды.
### Файловый менеджер
Расширение: [**File Manager Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/File%20Manager%20Application)
Не то чтобы самое полезное приложение, но вдруг вам понадобится превратить Xwiki в хранилище файлов и папок.
### Подсветка кода
Расширение: [**Syntax Highlighting Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/EditorTools/Syntax%20Highlighting%20Application)
Повышает читаемость кода редактируемого в XWiki. Если вдруг не установится со Standard Flavor, то рекомендую поставить.
### Блог
Расширение: [**Blog Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/Blog%20Application)
Можно превратить вики в блог команды разработки или отдать на откуп отделу персонала, чтобы писали мотивирующие публикации.
### Совещания и календарь
Для календаря и совещаний в Demo Flavor устанавливаются [Meeting Manager Application](https://extensions.xwiki.org/xwiki/bin/view/Extension/Meeting%20Manager%20Application) (но оно слегка устарело) и [Mocca Calendar Application.](https://extensions.xwiki.org/xwiki/bin/view/Extension/MoccaCalendar)
Вы можете попробовать и другие приложения например, [Meeting Application](https://extensions.xwiki.org/xwiki/bin/view/Extension/Meeting%20Application)
### Форум
Расширение: [**Forum Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/ForumApplication)
Если вы с начала нулевых ждали, 2023 чтобы стать админов на форуме и упиваться властью баня неугодных, то самое время взглянуть на Forum Application.
### Обсуждение идей
Расширение: [**Ideas Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/Ideas)
Расширение для сбора идей, с возможностью проголосовать. Сейчас такое можно сделать в любом чате, но вдруг вы захотите, чтобы все процессы были только в XWiki.
P.S. На момент написания статьи у меня не работали кнопки голосования, может что-то криво встало.
### Опросы
Расширение: [**XPoll Application**](https://extensions.xwiki.org/xwiki/bin/view/Extension/XPoll%20Application)
Расширение похоже на предыдущее, можем опросить пользователей вики.
### Часто задаваемые вопросы
Расширение: [FAQ Application](https://extensions.xwiki.org/xwiki/bin/view/Extension/FAQ%20Application)
В принципе функционал можно реализовать с помощью обычных страниц, но и такое решение имеет право на жизнь.
Еще несколько интересных расширений
-----------------------------------
Если вы планируете использовать XWiki как портал для документации, то следующие приложения тоже могут быть полезны.
### Диаграммы
Расширение: [Diagram Application](https://extensions.xwiki.org/xwiki/bin/view/Extension/Diagram%20Application#HDependencies)
Очень сильно устаревшая версия интеграции с [draw.io](http://draw.io). Тем не менее базовый функционал есть. Вы можете купить или изучить PRO версию приложения, она регулярно обновляется.
### UML
Расширения: [PlantUML Macro](https://extensions.xwiki.org/xwiki/bin/view/Extension/PlantUML%20Macro) и [PlantUML Administration](https://extensions.xwiki.org/xwiki/bin/view/Extension/PlantUML%20Administration/)
Первое расширение позволяет вставить plantUML код в страницу, а второе позволяет выбрать сервер для рендеринга.
### Программирование
Расширение: [**PHP Macro**](https://extensions.xwiki.org/xwiki/bin/view/Extension/PHP%20Macro/)и[**Python Macro**](https://extensions.xwiki.org/xwiki/bin/view/Extension/Python%20Macro)
Позволяет обрабатывать PHP и Python код внутри страниц XWiki.
### Формулы
Расширение: [**MathJax Macro**](https://extensions.xwiki.org/xwiki/bin/view/Extension/MathJaxMacro/)
Рендеринг формул.
Заключение
----------
Это далеко не полный список, расширений для XWiki. Еще можно найти много интересного функционала от построения графиков, до рендеринга гитарных аккордов.
А еще если приложить руки, то всегда можно написать свое приложение или модифицировать существующее.
Благодаря огромным возможностям по расширению функционала, на базе XWiki можно не только организовать сайт технической документацией, но и полноценный корпоративный портал для небольшой и непритязательной команды разработки. | https://habr.com/ru/post/708792/ | null | ru | null |
# Чистая архитектура в Python: пошаговая демонстрация. Часть 2
**Содержание*** [Часть 1](https://habrahabr.ru/post/319126/)
* *Часть 2*
* [Часть 3](https://habrahabr.ru/post/319898/)
* [Часть 4](https://habrahabr.ru/post/320662/)
* [Часть 5](https://habrahabr.ru/post/320928/)
### Доменные модели
**Git tag:** [Step02](http://github.com/lgiordani/rentomatic/tree/step02)
Начнем с простого определения модели `StorageRoom`. Как было сказано ранее, модели в чистой архитектуре очень легкие, по крайней мере, легче, чем их ORM-аналоги в фреймворках.
Раз мы следуем методологии TDD, то первое, что мы напишем, это тесты. Создадим файл `tests/domain/test\_storageroom.py` и поместим внутри него этот код:
```
import uuid
from rentomatic.domain.storageroom import StorageRoom
def test_storageroom_model_init():
code = uuid.uuid4()
storageroom = StorageRoom(code, size=200, price=10,
longitude='-0.09998975',
latitude='51.75436293')
assert storageroom.code == code
assert storageroom.size == 200
assert storageroom.price == 10
assert storageroom.longitude == -0.09998975
assert storageroom.latitude == 51.75436293
def test_storageroom_model_from_dict():
code = uuid.uuid4()
storageroom = StorageRoom.from_dict(
{
'code': code,
'size': 200,
'price': 10,
'longitude': '-0.09998975',
'latitude': '51.75436293'
}
)
assert storageroom.code == code
assert storageroom.size == 200
assert storageroom.price == 10
assert storageroom.longitude == -0.09998975
assert storageroom.latitude == 51.75436293
```
Эти два теста гарантируют, что наша модель может быть инициализированы с корректными переданными ей значениями или при помощи словаря. В первом случае требуется указать все параметры модели. Позже можно будет сделать некоторые из них опциональными, предварительно написав необходимые тесты.
Пока же давайте напишем класс `StorageRoom`, разместив его в файле `rentomatic/domain/storageroom.py`. Не забываем создать файл `\_\_init\_\_.py`в каждом подкаталоге проекта, которые Python должен воспринимать как модули.
```
from rentomatic.shared.domain_model import DomainModel
class StorageRoom(object):
def __init__(self, code, size, price, latitude, longitude):
self.code = code
self.size = size
self.price = price
self.latitude = float(latitude)
self.longitude = float(longitude)
@classmethod
def from_dict(cls, adict):
room = StorageRoom(
code=adict['code'],
size=adict['size'],
price=adict['price'],
latitude=adict['latitude'],
longitude=adict['longitude'],
)
return room
DomainModel.register(StorageRoom)
```
Модель очень проста и не требует пояснений. Одним из преимуществ чистой архитектуры является то, что каждый слой содержит небольшие кусочки кода, которые, будучи изолированы, должны выполнять простые задачи. В нашем случае, модель предоставляет API для инициализации и сохранения информации внутри класса.
Метод `from\_dict` полезен при создании модели из данных, поступающих из другого слоя (такого как слой базы данных или из строки запроса в REST слое).
Может возникнуть соблазн попытаться упростить функцию `from\_dict`, абстрагируя и предоставляя ее как метод класса *Model*. И учитывая, что определенный уровень абстракции и обобщения возможен и нужен, а инициализация моделей может взаимодействовать с различными иными сценариями, лучше реализовать её непосредственно в самом классе.
*Абстрактный базовый класс* `DomainModel` — это простой способ классифицировать модель для будущих сценариев, таких как проверка на принадлежности класса к модели в системе. Для получения дополнительной информации об использовании *Абстрактных Базовых Классов* в Python советую почитать [этот пост](http://blog.thedigitalcatonline.com/blog/2016/04/03/abstract-base-classes-in-python/).
### Сериализаторы
**Git tag:** [Step03](http://github.com/lgiordani/rentomatic/tree/step03)
Если мы хотим вернуть нашу модель как результат вызова API, то её нужно будет сериализовать. Типичный формат сериализации это JSON, так как это широко распространённый стандарт, используемый для веб-API. Сериализатор не является частью модели. Это внешний специальный класс, который получает экземпляр модели и переводит её структуру и значения в некоторое представление.
Для тестирования JSON-сериализации нашего класса `StorageRoom` поместите в файл `tests/serializers/test\_storageroom\_serializer.py` следующий код
```
import datetime
import pytest
import json
from rentomatic.serializers import storageroom_serializer as srs
from rentomatic.domain.storageroom import StorageRoom
def test_serialize_domain_storageroom():
room = StorageRoom('f853578c-fc0f-4e65-81b8-566c5dffa35a',
size=200,
price=10,
longitude='-0.09998975',
latitude='51.75436293')
expected_json = """
{
"code": "f853578c-fc0f-4e65-81b8-566c5dffa35a",
"size": 200,
"price": 10,
"longitude": -0.09998975,
"latitude": 51.75436293
}
"""
assert json.loads(json.dumps(room, cls=srs.StorageRoomEncoder)) == json.loads(expected_json)
def test_serialize_domain_storageruum_wrong_type():
with pytest.raises(TypeError):
json.dumps(datetime.datetime.now(), cls=srs.StorageRoomEncoder)
```
Поместите в файл `rentomatic/serializers/storageroom\_serializer.py` код, который проходит тест:
```
import json
class StorageRoomEncoder(json.JSONEncoder):
def default(self, o):
try:
to_serialize = {
'code': o.code,
'size': o.size,
'price': o.price,
"latitude": o.latitude,
"longitude": o.longitude,
}
return to_serialize
except AttributeError:
return super().default(o)
```
Предоставляя класс, унаследованный от `JSON.JSONEncoder`, используем `json.dumps(room, cls = StorageRoomEncoder)` для сериализации модели.
Мы можем заметить некоторое повторение в коде. Это минус чистой архитектуры, который раздражает. Поскольку мы хотим максимально изолировать слои и создать облегченные классы, мы, в конечном итоге, повторяем некоторые действия. Например, код сериализации, который присваивает атрибуты от `StorageRoom` на атрибуты JSON, схож с тем, что мы используем для создания объекта из словаря. Не одно и тоже, но сходство этих двух функций имеется.
### Сценарии (часть 1)
**Git tag:** [Step04](http://github.com/lgiordani/rentomatic/tree/step04)
Пришло время реализовать реальную бизнес-логику нашего приложения, которая будет доступна снаружи. Сценарии — это то место, где мы реализуем классы, которые запрашивают хранилище, применяют бизнес-правила, логику, трансформируют данные как нашей душе угодно, и возвращают результат.
С учетом этих требований, давайте начнем последовательно строить *сценарий*. Наипростейший *сценарий*, который мы можем создать, это тот, что извлекает все складские помещения из хранилища и возвращает их. Обратите внимание, что мы пока не реализовали слой хранилища, поэтому в наши тестах мы будем его мокать (подменять фикцией).
Вот основа для простого теста *сценария*, который выводит список всех складских помещений. Поместите этот код в файл `tests/use\_cases/test\_storageroom\_list\_use\_case.py`
```
import pytest
from unittest import mock
from rentomatic.domain.storageroom import StorageRoom
from rentomatic.use_cases import storageroom_use_cases as uc
@pytest.fixture
def domain_storagerooms():
storageroom_1 = StorageRoom(
code='f853578c-fc0f-4e65-81b8-566c5dffa35a',
size=215,
price=39,
longitude='-0.09998975',
latitude='51.75436293',
)
storageroom_2 = StorageRoom(
code='fe2c3195-aeff-487a-a08f-e0bdc0ec6e9a',
size=405,
price=66,
longitude='0.18228006',
latitude='51.74640997',
)
storageroom_3 = StorageRoom(
code='913694c6-435a-4366-ba0d-da5334a611b2',
size=56,
price=60,
longitude='0.27891577',
latitude='51.45994069',
)
storageroom_4 = StorageRoom(
code='eed76e77-55c1-41ce-985d-ca49bf6c0585',
size=93,
price=48,
longitude='0.33894476',
latitude='51.39916678',
)
return [storageroom_1, storageroom_2, storageroom_3, storageroom_4]
def test_storageroom_list_without_parameters(domain_storagerooms):
repo = mock.Mock()
repo.list.return_value = domain_storagerooms
storageroom_list_use_case = uc.StorageRoomListUseCase(repo)
result = storageroom_list_use_case.execute()
repo.list.assert_called_with()
assert result == domain_storagerooms
```
Тест прост. Сначала мы подменили хранилище так, чтобы он предоставлял метод `list()`, возвращающий список заранее созданных выше моделей. Затем мы инициализируем *сценарий* с хранилищем и выполняем его, запоминая результат. Первое, что мы проверяем, это что метод хранилища был вызван без какого-либо параметра, а второе, это правильность результата.
А вот реализация *сценария*, которая проходит тест. Поместите код в файл `rentomatic/use\_cases/storageroom\_use\_case.py`
```
class StorageRoomListUseCase(object):
def __init__(self, repo):
self.repo = repo
def execute(self):
return self.repo.list()
```
Однако, при такой реализации *сценария* мы вскоре столкнёмся с проблемой. Во-первых, у нас нет стандартного способа передачи параметров вызова, а это значит, что у нас нет стандартного способа для проверки их корректности. Следующая проблема состоит в том, что мы упускаем стандартный способ возвращения результатов вызова, и, следовательно, мы не можем узнать, был ли вызов успешен или нет, и если нет, то по какой причине. Та же проблема и с неверными параметрами, рассмотренными в предыдущем пункте.
Таким образом, мы хотим, чтобы были введены некоторые структуры для оборачивания входных и выходных данных наших *сценариев*. Эти структуры называются *объектами запроса и ответа*.
### Запросы и ответы
**Git tag:** [Step05](http://github.com/lgiordani/rentomatic/tree/step05)
Запросы и ответы — это важная часть чистой архитектуры. Они перемещают параметры вызова, входные данные и результаты вызова между слоем *сценариев* и внешним окружением.
*Запросы* создаются на основе входящих вызовов API, так что им предстоит столкнуться с такими штуками, как неправильные значения, пропущенные параметры, неверный формат и т.д. *Ответы*, с другой стороны, должны содержать результаты вызовов API, в том числе должны представлять ошибки и давать подробную информацию о том, что произошло.
Вы вправе использовать любую реализацию *запросов и ответов*, чистая архитектура ничего не говорит об этом. Решение о том, как упаковать и представить данные, полностью лежит на вас.
Ну а пока нам просто необходим `StorageRoomListRequestObject`, который может быть инициализирован без параметров, так что, давайте создадим файл `tests/use\_cases/test\_storageroom\_list\_request\_objects.py` и поместим в него тест для этого объекта.
```
from rentomatic.use_cases import request_objects as ro
def test_build_storageroom_list_request_object_without_parameters():
req = ro.StorageRoomListRequestObject()
assert bool(req) is True
def test_build_file_list_request_object_from_empty_dict():
req = ro.StorageRoomListRequestObject.from_dict({})
assert bool(req) is True
```
На данный момент *объект запроса* пуст, но он нам пригодится сразу, как только у нас появятся параметры для *сценария*, выдающего список объектов. Код для класса `StorageRoomListRequestObject` находится в файле `rentomatic/use\_cases/request\_objects.py` и имеет следующий вид:
```
class StorageRoomListRequestObject(object):
@classmethod
def from_dict(cls, adict):
return StorageRoomListRequestObject()
def __nonzero__(self):
return True
```
*Запрос* так же довольно прост, так как на данный момент нам необходим только успешный ответ. В отличие от *запроса*, *ответ* не связан с каким-либо конкретным *сценарием*, так что файл теста можно назвать `tests/shared/test\_response\_object.py`
```
from rentomatic.shared import response_object as ro
def test_response_success_is_true():
assert bool(ro.ResponseSuccess()) is True
```
и фактический *объект ответа* находится в файле `rentomatic/shared/response\_object.py`
```
class ResponseSuccess(object):
def __init__(self, value=None):
self.value = value
def __nonzero__(self):
return True
__bool__ = __nonzero__
```
Продолжение следует в [Части 3](https://habrahabr.ru/post/319898/). | https://habr.com/ru/post/319202/ | null | ru | null |
# Самые простые фракталы на JavaScript
Представляю сообществу страничку на JavaScript, которая позволяет строить, рисовать, создавать простые фрактальные фигуры, основанные на самоподобии. На самом деле это мой первый опыт использования HTML/CSS/JS. При обширном опыте программирования, я до сих пор пропускал веб-разработку. А поскольку, по моим представлениям, самый удобный способ научиться программировать — это сделать какой-нибудь проект, вот он [мой фрактальный HelloWorld](http://rawgithub.com/nordwinder/frac-js/master/frac.html).
Общая идея проста. Берется какая-нибудь линия, состоящая из отрезков, то есть кусочно-линейная. Назовем ее базовой линией. Затем каждый из отрезков заменяется на копию базовой линии соответствующим образом масштабированную и повернутую. Далее заменяется каждый из сегментов получившейся линии, и процесс продолжается пока не надоест. Проиллюстрирую на картинках. Пример базовой линии:
Первая итерация:
Вторая:
Программка позволяет создавать и изменять базовую линию: добавлять и удалять вершины, двигать их, сразу же смотреть что из этого получается. Кроме того, производить замену сегмента на копию базовой линии можно по-разному. Можно, например, перед заменой отразить базовую линию относительно одной из осей (той, которая соединяет начальную и конечную точки). Конечно, можно было бы отразить и относительно перпендикулярной оси, но я реализовал только первый вариант. Будет или нет отражение показывается цветом базовой линии:
**А вот способы управления и контроля.*** *Shift + левая кнопка мыши на базовой линии* — добавление новой вершины;
* *Ctrl + ЛКМ на вершине* — удаление вершины;
* *ЛКМ на вершине* — перемещение;
* *ЛКМ на сегменте* — использование отражения на данном сегменте;
* *ЛКМ на пустом месте* — передвижение всей фигуры целиком.
И несколько картинок:
Напоследок несколько слов о коде. Конечно, после C++/Matlab/Python я был весьма удивлен представлению объектов в JS. И отсутствию классов, и глобальным переменным. В конце концов, я заключил весь код в две функции. Первая создавала объект фрактала и выполнена по следующей схеме с использованием замыкания:
```
function fracObject() {
// объект для приватных данных
var own = {};
// и для публичных
var that = {};
// ... здесь они заполняются ...
// а возвращается только публичный
return that;
}
```
Пока не знаю как к этому добавить наследование, как корректно использовать this. Но это в будущем, для этого проекта наследование было бы уже лишним. Вторая функция загружается после body.onload и реализует взаимодействие с пользователем.
Ссылка на проект в GitHub: <https://github.com/nordwinder/frac-js>
А тем, кто дочитал до конца, пожелаю красивых фракталов.
**UPD:** Заменил рекурсивный вызов на обычную, хотя и более сложную функцию. Сдается мне, стало быстрее работать. Кроме того, теперь за один раз рисуется не более 10 тысяч отрезков. Затем следует небольшая пауза — браузеру обработать события, посмотреть не ушел ли пользователь. Добавил прогресс бар и кнопку отмены. Теперь вешать браузер не должно даже на самых сложных и запутанных линиях. | https://habr.com/ru/post/187780/ | null | ru | null |
# Вышел FindBugs 3.0.1
Новая версия FindBugs [доступна для скачивания](https://sourceforge.net/projects/findbugs/) на официальном сайте. Несмотря на то что поменялась только третья цифра в номере версии, вас ждёт множество новых интересных детекторов, а также улучшение старых. Если основная фича 3.0.0 заключалась в поддержке Java 8 и новых детекторов практически не было, то в 3.0.1 упор был сделан на функционал. Здесь я хочу вкратце осветить некоторые новые детекторы, разработанные лично мной.
В этой статье ограничимся детекторами бесполезного кода. Мне нравится разрабатывать такие детекторы: они не просто ищут конкретный шаблон (например, вызов метода с заведомо некорректным параметром), а доказывают бесполезность определённых фрагментов кода. Порой таким образом можно найти весьма неожиданные ошибки.
### UC\_USELESS\_CONDITION
Про этот детектор я писал [отдельно](http://habrahabr.ru/post/240121/), но со времени той статьи он был значительно доработан. Теперь полноценно обрабатываются изменяемые переменные, переиспользование регистра, переброс значений из одной переменной в другую, вызовы String.length(), unboxing, проверки длин массивов. Также частично поддерживаются поля. Доработаны приоритеты. Этот детектор позволяет найти очень интересные баги из серии «как получилось, что мы годами этого не замечали?» Например, такой код [нашёлся](http://grepcode.com/file/repo1.maven.org/maven2/net.sourceforge.pmd/pmd-java/5.2.3/net/sourceforge/pmd/lang/java/rule/basic/AvoidUsingHardCodedIPRule.java#86) в PMD 5.2.3 (это тоже инструмент для проверки качества кода!):
```
protected boolean isHexCharacter(char c) {
return isLatinDigit(c) || ('A' <= c || c <= 'F') || ('a' <= c || c <= 'f');
}
```
Из-за ошибочного использования || вместо && условие истинно для любых символов (метод всегда вернёт true). Баг существует как минимум с версии 5.0.0 (дальше не копал) — почти три года.
Замечу, кстати, что такие ошибки некоторые не видят, даже если смотрят прямо на них. Вот [тут](https://sourceforge.net/p/findbugs/bugs/1360/) другой разработчик FindBugs подумал, что на условии `c != '\n' || c != '\r'` произошло ложное срабатывание и даже придумал хитрую теорию про совпадение кода символа и номера регистра с переменной. А на самом деле срабатывание не ложное, код действительно с ошибкой.
Иногда находится ошибочная копипаста. Например, [такое](http://grepcode.com/file/repo1.maven.org/maven2/org.apache.lucene/lucene-core/4.10.3/org/apache/lucene/codecs/compressing/CompressingStoredFieldsReader.java#283) нашлось в Lucene 4.10.3:
```
final int bitsPerStoredFields = fieldsStream.readVInt();
if (bitsPerStoredFields == 0) { ... }
else if (bitsPerStoredFields > 31) {
throw new CorruptIndexException("bitsPerStoredFields=" + bitsPerStoredFields + " (resource=" + fieldsStream + ")");
} else { ... }
final int bitsPerLength = fieldsStream.readVInt();
if (bitsPerLength == 0) { ... }
else if (bitsPerStoredFields > 31) { // Здесь UC_USELESS_CONDITION
throw new CorruptIndexException("bitsPerLength=" + bitsPerLength + " (resource=" + fieldsStream + ")");
} else { ... }
```
FindBugs теперь видит, что при bitsPerStoredFields > 31 мы уже должны были вывалиться с исключением, поэтому второй раз такая проверка бессмысленна. Видимо, авторы скопировали кусок кода и забыли исправить на bitsPerLength.
### UC\_USELESS\_OBJECT
Это сообщение выводится, если в методе создаётся объект или массив и с ним производятся некоторые манипуляции, которые не дают никаких побочных эффектов, кроме изменения состояния этого объекта. Подобный детектор есть в стороннем плагине [FB-contrib](http://fb-contrib.sourceforge.net/bugdescriptions.html) (WOC\_WRITE\_ONLY\_COLLECTION\_LOCAL) — он находит коллекции, в которые производится только запись. Наш детектор может находить более хитрые ситуации и обрабатывать некоторые пользовательские объекты. Обычно находится ненужный код, который остался после рефакторинга и может быть попросту удалён. Но иногда срабатывание детектора сигнализирует о каких-то глубоких проблемах в алгоритме. Простой пример с [массивами](http://grepcode.com/file/repository.grepcode.com/java/ext/com.jetbrains/intellij-idea/13.0.0/com/intellij/uiDesigner/designSurface/DesignDropTargetListener.java#282) из IDEA:
```
final int[] dx = new int[componentCount];
final int[] dy = new int[componentCount];
for (int i = 0; i < componentCount; i++) {
final RadComponent component = myDraggedComponentsCopy.get(i);
dx[i] = component.getX() - dropX;
dy[i] = component.getY() - dropY;
}
```
Массивы dx и dy заполняются, но нигде дальше не используются (вероятно, использовались раньше). Весь этот цикл не нужен, и его можно удалить.
А вот [тут](http://grepcode.com/file/repository.grepcode.com/java/eclipse.org/4.4.1/org.eclipse.jdt/ui/3.10.1/org/eclipse/jdt/internal/ui/javadocexport/RecentSettingsStore.java#145) в Eclipse уже скорее алгоритмическая ошибка:
```
public void setProjectSettings(IJavaProject project, String destination, String antpath, String[] hrefs) {
ProjectData data= fPerProjectSettings.get(project);
if (data == null) {
data= new ProjectData(); // UC_USELESS_OBJECT
}
data.setDestination(destination);
data.setAntpath(antpath);
StringBuffer refs= new StringBuffer();
...
data.setHRefs(refs.toString());
}
```
ProjectData — POJO-класс, и FindBugs в состоянии увидеть, что его сеттеры не меняют глобального состояния системы, модифицируя только сам объект. Стандартный путь выполнения (без захода в if) вопросов не вызывает. Но если мы зашли в if, то дальнейшая часть метода не имеет смысла, так как новый объект никуда не сохраняется. Видимо, предполагалось после создания сохранить его в Map fPerProjectSettings.
### RV\_RETURN\_VALUE\_IGNORED\_NO\_SIDE\_EFFECT
Третья из моих серьёзных разработок в этом релизе. Возможно, когда-нибудь про неё напишу отдельно. Предупреждение выдаётся, когда вызывается метод, который не имеет побочных эффектов и его результат не используется. Здесь возможны ложные срабатывания, хотя они довольно редки и не снижают общую ценность предупреждения.
Вот [пример](http://grepcode.com/file/repository.grepcode.com/java/ext/com.jetbrains/intellij-idea/13.0.0/com/intellij/lang/ant/dom/AntDomDirSet.java#64) из IDEA:
```
protected List getFiles(@Nullable AntDomPattern pattern, Set processed) {
...
if (singleFile != null && singleFile.isDirectory()) {
Collections.singletonList(singleFile); // RV\_RETURN\_VALUE\_IGNORED\_NO\_SIDE\_EFFECT
}
return Collections.emptyList();
}
```
Очевидно, внутри условия забыли написать return. Если возвращаемый тип вызванного метода совместим с возвращаемым типом текущего, приоритет предупреждения увеличивается.
Ещё [пример](http://grepcode.com/file/repository.grepcode.com/java/ext/com.jetbrains/intellij-idea/13.0.0/org/jetbrains/idea/maven/navigator/SelectMavenProjectDialog.java#56) из IDEA (не потому что там много ошибок, а потому что сотрудники JetBrains читают этот пост):
```
protected void doOKAction() {
SimpleNode node = getSelectedNode();
if (node instanceof NullNode) node = null;
if (node != null) {
if (!(node instanceof MavenProjectsStructure.ProjectNode)) {
// RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT
((MavenProjectsStructure.MavenSimpleNode)node).findParent(MavenProjectsStructure.ProjectNode.class);
}
}
myResult = node != null ? ((MavenProjectsStructure.ProjectNode)node).getMavenProject() : null;
super.doOKAction();
}
```
Кажется, хотели подписать `node =` слева.
Забытый return или присваивание, пожалуй, самые частые причины этого сообщения. Ещё бывает, что программист вызывает метод, думая, что он что-то меняет, а он ничего не меняет. Например, в Apache POI [вызывают](http://grepcode.com/file/repo1.maven.org/maven2/org.apache.poi/poi/3.11/org/apache/poi/hssf/record/common/FeatFormulaErr2.java#97) метод setBoolean, разумно предполагая, что он что-то устанавливает. А он просто вычисляет новое значение и возвращает его (и кто только так метод назвал!).
Случается, что программист вызвал не тот метод, который хотел. Так в самом FindBugs мы нашли и исправили [ошибочное использование](https://code.google.com/p/findbugs/source/browse/findbugs/src/java/edu/umd/cs/findbugs/ba/npe/DerefFinder.java?r=11189b911ff3edc66cea0263d278cf56d6531c6d#155) BitSet.intersects() (проверяет, пересекаются ли два множества) вместо BitSet.and() (пересекает два множества, изменяя первое).
### UC\_USELESS\_VOID\_METHOD
Это следствие из предыдущего детектора: так как мы научились неплохо определять, есть ли у метода побочный эффект, мы можем сообщить о непустых void-методах, которые таких эффектов не имеют. Чаще всего это какой-нибудь недописанный код с TODO посередине, но удаётся найти и поистине странные вещи. Вот, к примеру, [бесполезный](http://grepcode.com/file/repository.grepcode.com/java/eclipse.org/4.4.1/org.eclipse.ui/cheatsheets/3.4.200/org/eclipse/ui/internal/cheatsheets/registry/CheatSheetRegistryReader.java#537) метод из Eclipse:
```
private void pruneEmptyCategories(CheatSheetCollectionElement parent) {
Object[] children = parent.getChildren();
for (int nX = 0; nX < children.length; nX++) {
CheatSheetCollectionElement child = (CheatSheetCollectionElement) children[nX];
pruneEmptyCategories(child);
}
}
```
Выполняется рекурсивный обход древовидной структуры и больше ничего.
А вот ещё метод [merge](http://grepcode.com/file/repository.grepcode.com/java/eclipse.org/4.4.1/org.eclipse.ant/ui/3.5.500/org/eclipse/ant/internal/ui/dtd/util/SortedSet.java?av=f#184) класса SortedSet в Eclipse:
**public void merge(SortedSet other)**
```
public void merge(SortedSet other) {
Object[] array = fKeyHolder.getKeys();
Object[] otherarray = other.fKeyHolder.getKeys();
if (otherarray == null)
return;
if (array == null) {
array = otherarray;
return;
}
int ithis = 0, iother = 0, i = 0;
int mthis = array.length, mother = otherarray.length;
Object[] tmp = new Object[mthis + mother];
while (ithis < mthis && iother < mother) {
int comp = fComp.compare(array[ithis], otherarray[iother]);
if (comp <= 0) {
tmp[i++] = array[ithis++];
} else {
tmp[i++] = otherarray[iother++];
}
}
while (ithis < mthis) {
tmp[i++] = array[ithis++];
}
while (iother < mother) {
tmp[i++] = otherarray[iother++];
}
}
```
Можете ли вы заметить, что этот метод из 26 строк с тремя циклами и тремя if'ами на самом деле не несёт никакой пользы? FindBugs теперь может.
### Заключение
Обновляйте FindBugs, и вы, возможно, найдёте в своих проектах проблемы, о которых раньше не подозревали. Плагин для Eclipse [доступен](http://findbugs.sourceforge.net/downloads.html) у нас на сайте. [Плагин для IDEA](https://plugins.jetbrains.com/plugin/3847?pr=idea) тоже обновлён. Не забывайте [сообщать](https://sourceforge.net/p/findbugs/bugs/) нам о ложных срабатываниях и других найденных проблемах.
**Disclaimer**Нет, я не сообщил обо всех этих ошибках разработчикам. В процессе разработки FindBugs я тестирую около 50 открытых проектов и нахожу в них суммарно тысячи новых багов (по сравнению с предыдущей версией FindBugs). Время, которое я мог бы потратить на формирование баг-репортов, я лучше потрачу на улучшение FindBugs. В некоторых из рассматриваемых проектов FindBugs точно используется, поэтому разработчики сами увидят новые баги, когда обновятся. Если вы желаете помочь сообществу, вы всегда можете сами проверить любой открытый проект с помощью FindBugs и сообщить разработчикам проекта о найденных багах. | https://habr.com/ru/post/251749/ | null | ru | null |
# npm для простых смертных
Эта статья предназначена для тех, кто не очень дружит с Node.js, но хочет использовать приложения вроде Grunt, Gulp и тому подобные. Процесс работы с этими приложениями подразумевает редактирование файла package.json и использование команд npm, так что понимание принципов работы npm поможет вам справиться с трудностями.
Node.js за 5 минут
------------------
Понимание того, что такое Node.js поможет вам лучше разобраться с npm. В двух словах — Node.js это интерпретатор языка JavaScript. Сам по себе Node.js является C++ приложением, которое получает на входе JavaScript-код и выполняет его.
Давайте создадим простую программу. Создайте файл **helloworld.js** и поместите в него следующий код:
```
console.log("Hello World");
```
Теперь откройте терминал, зайдите в папку с вашей программой и выполните команду `node helloworld.js`. Вместо helloworld.js может быть любой другой файл с JavaScript-кодом. [Убедитесь, что у вас установлен Node.js](http://nodejs.org/download). Результат выполнения программы будет выглядеть примерно так:
Программа просто выведет строку «Hello World» в терминал.
Пакеты в Node.js
----------------
Вкратце, пакетом в Node.js называется один или несколько JavaScript-файлов, представляющих собой какую-то библиотеку или инструмент.
npm (аббр. node package manager) — это стандартный менеджер пакетов, автоматически устанавливающийся вместе с Node.js. Он используется для скачивания пакетов из облачного сервера npm, либо для загрузки пакетов на эти сервера.
### Файл package.json
Файл package.json содержит в себе информацию о вашем приложении: название, версия, зависимости и тому подобное. Любая директория, в которой есть этот файл, интерпретируется как Node.js-пакет, даже если вы не собираетесь публиковать его.
Способ использования файла package.json зависит от того, собираетесь ли вы скачивать пакет или публиковать его.
### Скачивание пакетов
Если вы хотите скачать пакет вручную, вам необязательно использовать для этого package.json. Вы можете выполнить в терминале команду **npm** с названием нужного пакета в качестве аргумента команды, и пакет будет автоматически скачан в текущую директорию. Например:
```
$ npm install canvas-chart
```
Также для скачивания пакетов вы можете использовать package.json. Создайте в директории вашего проекта файл package.json, и добавьте в него следующий код (мы не указываем название нашего пакета и версию, т. к. мы не собираемся его публиковать; мы указываем название и версию пакетов для загрузки):
```
{
"devDependencies": {
"canvas-chart": "~1.3.0"
}
}
```
Затем сохраните файл и выполните в терминале команду `npm install`.
Если вы хотите использовать в своём проекте множество пакетов, то лучше указать их package.json вместо того, чтобы каждый раз скачивать их через терминал.
Если вы используете package.json для скачивания пакетов, то получается, что вы создаёте пакет для скачивания пакетов. Я знаю, что это странно, но это работает.
Если какой-либо пакет имеет зависимости, то npm найдёт их через package.json загружаемого пакета и скачает их. В нашем случае у пакета **canvas-chart** тоже есть файл package.json с прописанными в нём зависимостями.
### Публикация пакета
Чтобы опубликовать пакет, вам потребуется собрать все исходные коды и файл package.json в одной директории. В package.json должны быть указаны название, версия и зависимости пакета. Например:
```
{
"name": "canvas-project",
"version": "0.1.0",
"devDependencies": {
"canvas-chart": "~1.3.0"
}
}
```
Посмотрев на этот код, мы можем сказать, что пакет «canvas-project» зависит от пакета «canvas-chart». Опубликовать пакет можно с помощью комадны `npm publish`.
### Использование пакета в качестве исполняемого файла
Когда npm скачивает пакет, он ищет свойство «bin» в файле package.json. Если он находит это свойство, то он конвертирует этот пакет в исполняемый файл и размещает его в указанной директории.
Например, команда ниже загружает *grunt-cli* в текущую директорию и конвертирует исходники в исполняемый файл, который затем помещается в папку со всеми исполняемыми файлами. Вследствие этого мы сможем вызвать команду *grunt-cli*.
```
$ npm install grunt-cli
```
Теперь вы знаете, что такое пакет и как он может зависеть от других пакетов. Также вы узнали, как npm работает с пакетами. Давайте перейдём от теории к практике и установим Grunt.
Установка Grunt с помощью npm
-----------------------------
Grunt это таск-раннер, позволяющий автоматизировать многие повседневные задачи вроде сжатия изображений и минификации css-файлов.
Выполните следующие шаги, чтобы установить Grunt и начать работу с ним.
* Создайте директорию для вашего проекта. С точки зрения сервера эта директория будет корневой.
* Откройте эту директорию через терминал.
* Теперь скачайте и установите Grunt. Аргумент `-g` указывает npm на то, что пакет следует скачивать в основную папку для хранения пакетов, а не в текущую директорию.
```
$ npm install -g grunt-cli
```
* Для каждой задачи, выполняемой grunt’ом, есть отдельный пакет. Например, можно найти пакеты для минификации JavaScript, склеивания файлов и так далее. Также вы можете создавать собственные пакеты для выполнения каких-либо задач; такие пакеты будут называться Grunt-плагинами. Давайте установим нужные нам пакеты в директирии нашего проекта. Для этого нам понадобится создать файл package.json и поместить в него код ниже. Затем выполните команду `npm install`. Она загрузит нужные пакеты. Помните о том, что директория, содержащая package.json, сама является пакетом.
```
{
"devDependencies": {
"grunt-contrib-concat": "~0.3.0"
}
}
```
* Мы установили пакет для склеивания файлов. Теперь нам надо описать задачу для Grunt. Это делается с помощью файла *Gruntfile.js*. Когда вы выполняете команду `grunt` в директории проекта, Grunt будет искать Gruntfile.js, чтобы загрузить и выполнить задачи. Давайте подключим наш плагин для склеивания файлов и опишем простую задачу.
```
module.exports = function(grunt) {
// 1. Общая конфигурация
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
concat: {
// 2. Настройки для склеивания файлов
dist: {
src: [
'js/libs/*.js', // Все js-файлы в директории libs
'js/global.js' // Отдельный файл
],
dest: 'js/build/production.js',
}
}
});
// 3. Сообщаем, какие плагины мы собираемся использовать
grunt.loadNpmTasks('grunt-contrib-concat');
// 4. Определяем задачу по умолчанию, которая будет выполняться при запуске команды grunt в терминале.
grunt.registerTask('default', ['concat']);
};
```
* По этому принципу вы можете сами скачать и подключить нужные плагины.
* Теперь вы можете запустить команду `grunt` в директории вашего проекта, чтобы склеить js-файлы.
Итог
----
В этой статье я попробовал объяснить то, как работает npm для новичков в Node.js. Теперь вы должны быть способны устанавливать и использовать различные Node.js-приложения. Спасибо за чтение! | https://habr.com/ru/post/243335/ | null | ru | null |
# Natas Web. Прохождение CTF площадки, направленной на эксплуатацию Web-уязвимостей
В данной статье мы разберемся с эксплуатацией некоторых WEB-узвимостей на примере прохождения варгейма [Natas](http://overthewire.org/wargames/natas/). Каждый уровень имеет доступ к паролю следующего уровня. Все пароли также хранятся в файлах /etc/natas\_webpass/. Например, пароль для natas5 хранится в файле /etc/natas\_webpass/natas5 и доступен для чтения только для пользователей natas4 и natas5.
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
level 0
-------
Просматриваем исходный код страницы и проверяем комментарии.
Находим пароль.
> Очень часто при разработке сайтов разработчики комментируют для себя различную вспомогательную информацию, в том числе и данные для авторизации.
level 1
-------
Снова просматриваем исходный код страницы, но на нажатие правой клавиши мыши назначено javascript событие, которые не позволяет сызвать контекстное меню.
Для просмотра страницы можно ипользоватть горячие клавиши браузера, тогда событие нажатия правой клавиши мыши не сработает.
Находим пароль.
> Как вариант(иногда приоритетней), можно просто скачать всю страницу и просмотреть код.
>
>
> ```
> wget --http-user=natas1 --http-password=gtVrDuiDfck831PqWsLEZy5gyDz1clto http://natas1.natas.labs.overthewire.org
> ```
>
>
> 
level 2
-------
Снова просматриваем исходный код страницы, замечаем, что на страницу загружается картинка.
Зайдем в дирректорию, откуда происходит загрузка картинки. Наблюдаем, что эта дирректоря непроиндексирована и доступна пользователям.
Забираем пароль.
> Для того, чтобы избежать просмотр файлов в дирректории, в настройках сервера (в данном случае /etc/apche2/httpd.conf) должен стоять запрет на индескирование файлов. Или в данной дирректории должен находиться файл index.html.
level 3
-------
Снова просматриваем исходный код страницы, там нет ничего интересного. Вторым пунктом после просмотра исходного кода, является сканирование файлов и дирректорий. В качестве параметеров утилиты dirb укажем пользователя и пароль для http-аутентификации.
Файл robots.txt содержит список дирректорий и файлов, который запрещены для просмотра роботам-поисковикам (например google и yandex).
Зайдем в скрытую дирректурию на сайте, найдем файл и заберем пароль.
> Как аналог, можно использовать утилиты dirsearch, или burpsuite.
level 4
-------
Сервер сообщает, с какой страницы перешли и говорит с какой нужно перейти. Эти данные он может проверить только в заголовке протокола HTTP.
В браузере выбирем панель инутрументов → сеть → прошлый запрос и «изменить и отправить». Следует изменить поле Referer – именно оно показывает откуда мы перешли.
Осталось забрать пароль.
> Данное действие burpsuite.
>
>
>
> Необходмо постоянно просматривать, какие HTTP поля просматривает Web-Сервер. Это самые редко- фильтруемые пользовательские данные.
level 5
-------
Сервис сообщает, что мы не залогинины. То есть он хранит данные нашей авторизации. Единственное место где Это можно передавать: сессия cookies.
Посмотрим кукисы (для удобства лучше установить расширения в браузере), и изменим значение параметра loggedin на 1.
Перезагрузим страницу и заберем пароль.
> Данный вид уязвимости относится к категории Broken Authentication and Session Management.
level 6
-------
Данный сервис предоставляет нам исходный код для анализа.
Секрет, который мы должны ввести, инклудится (подключается из файла).
Переходим по адресу этого файла на сервере и получаем
секрет. Так как данные файлы содержат код php, то они
отображаются, только если их скачивать.
Отправляем секрет, получаем пароль.
level 7
-------
Перейдя по обеим ссылкам, замечаем какион образом они загружаются. Название файла на сервере передаётся в GET параметре pages.
Попробуем указать в качестве параметра путь к файлу /etc/passwd.
И нам говорят, где забрать пароль.
> Данная уязвимость относится к категории LFI.
level 8
-------
Предоставлен исходный код сервиса. Хранится закодированная строка и способ кодирования.
Необходимо раскодировать в обратном порядке:
1. перевести из hex-вида в бинарное представление;
2. перевернуть строку;
3. декодировать base64.
```
php
$secret = "3d3d516343746d4d6d6c315669563362";
echo base64_decode(strrev(hex2bin($secret)))."\n";
?
```
Отправляем секрет и получаем пароль.
level 9
-------
Из разбора исходного кода становится ясно, что пользовательские данные передаются в командную строку для поиска данных в файле.
Так как данные не фильтруются, то можно собрать конвейер и выполнить иные команды ОС. Если передать в запрос строку, к примеру: « || ls # », то полный запрос станет таким «grep -i || ls # dictionary.txt». Все, что после || – выполнится с ошибкой, а после # – будет закомментировано, т. е. мы получаем только вывод команды ls.
Таким образом читаем файл: «|| cat /etc/natas\_webpass/natas10 #».
> Данная уязвимость относится к категории OS Command Injection.
level 10
--------
Из разбора исходного кода становится ясно, что пользовательские данные передаются в командную строку для поиска данных в файле.
Задача такая же, как и на уровне 9, только теперь присутствует фильтр. Т.о. из запроса исчезнут знаки: «;»,«|»,«&». Можно лигитимно прочитать файл! Предположим, что в нашем пароле есть символ «z»: « z /etc/natas\_webpass/natas11 # ».
Продолжение следует. Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). | https://habr.com/ru/post/464111/ | null | ru | null |
# Насколько крепка дружба между Java и С внутри Dalvik VM?
 В данной статье попытался очень подробно описать свои шаги при исследовании кода андроида и его выполнения в Dalvik VM. Мне было очень интересно узнать ответы, на вопросы:
* Как выглядит код, генерируемый С? (с позиции ARM)
* Как выглядит код, генерируемый Java?
* Как и где происходит выполнение кода?
Поэтому данная статья разбита на 3 части.
Мне кажется ставить перед собой такие вопросы и изучить их — важный момент при последующем написании кода, ведь андроид уже наступил на пятки и не знать его также, как и один из своих любимых инструментов (например С) уже будет не правильно.
Я до этого практически не производил анализ виртуальных машин, а сейчас меня заинтересовал Dalvik VM. Поэтому всё описание будет относится к этой VM и вы можете наблюдать за моим повествованием, ход которого несколько раз изменяется.
#### Вступление
Для того, чтобы понять эту статью, вам нужно обладать начальными знаниями об ассемблере под архитектуру ARM. В статье дано мало информации, чтобы это понять, но делается акцент, на то, что читатель этого не знает. Поэтому есть много пояснений «своими словами», но не больше.
Также необходимо, чтобы вы обладали навыками создания андроид приложения с нуля (знали структуру директорий и основные файлы).
Вы также можете посмотреть на итоги к каждой статье и понять, стоит ли вам её читать.
Все 3 части очень сильно отличаются нагрузкой, примерно в равной силе. Например, когда перейдете к 3й части, вам может показаться, что она настолько же сложнее 2й, как 2я по отношению к первой. Так что прошу будьте внимательны, если не владеете предметом, в конце нагрузка может быть большая.
##### Кому будет интересна статья
Только искателям приключений.
Хороший разработчик, если этого не знает, легко узнает (надеюсь моё понимание хорошего разработчика не сильно завышено), а вот тот кто хочет что-то начать и попробовать, а не знает как, ему будет очень трудно.
Я хотел показать, что поставить себе вопросы и найти на них ответы в таком дремучем лесу как Dalvik VM, более чем реально и мне хочется показать этот путь тому, кто решится на такой же дерзкий поступок.
##### Первоначальная цель
Моя основная задача сравнить код на С:
```
int sum(int a, int b) {
return a + b;
}
```
C таким же кодом на Java:
```
public class Summator {
int sum(int a, int b) {
return a + b;
}
static int staticSum(int a, int b) {
return a + b;
}
}
```
```
public class NativeSummator {
native int sum(int a, int b);
static native int staticSum(int a, int b);
}
```
Свои предположения есть, но очень хочется посмотреть как действительно оно происходит.
##### Подготовительные знания
Я здесь напомню, как примерно выглядит интеграция С кода в Java, через JNI.
Для того, чтобы использовать внешнюю (нативную) функцию в коде Java, используется ключевое слово native:
```
package com.m039.study;
public class Summator {
native int sum(int a, int b);
}
```
При этом код на С должен выглядеть:
```
int
Java_com_m039_study_Summator_sum(JNIEnv* env, jobject thiz, int a, int b) {
return a + b;
}
```
Для того, чтобы Java увидела функцию она должна быть составлена по определенным правилам (дано по памяти):
* название начинается с Java
* содержит путь к: модулю + название класса + имя функции
* в функцую передаются два дополнительных аргумента: указатель на окружение и структура на объект или на класс (если метод static)
Для компиляции используется команда `ndk-build`. Эта команда ожидает, что файлы на С (или С++) находятся в каталоге ./jni. В каталоге обязан находится файл Android.mk и может быть Application.mk.
После компиляции будет создана библиотека libNAME.so в директории ./libs/armebi, где armebi может отличаться.
Вам придется обратиться к другому документу, если вам нужно более детальные шаги. Можете посмотреть в каталог [документации](http://android.git.kernel.org/?p=platform/ndk.git;a=tree;f=docs;h=529dcbea56edf85028aed8c46ce6e03a0ba1718e;hb=HEAD) и примеров, прилагаемых к [NDK](http://developer.android.com/sdk/ndk/overview.html).
#### Часть I. Как выглядит код, генерируемый С?
Вопрос: Что именно делает код на С?
В принципе, это понятно, но как это выглядит с точки зрения архитектуры ARM, т.к. почти все мобильные устройства сейчас используют именно эту архитектуру?
Чтобы разобраться в этом необходимо понять как код на С выглядит в ассемблерном(сыром) виде.
##### Дизассемблируем
Основной вопрос это взаимодействие С и Java, исходя из этого выбрал 5 примеров:
1. Стандартный:
```
int sum(int a, int b) {
return a + b;
}
```
2. Биндинг через JNI (не static):
```
int
Java_com_m039_study_Summator_sum(JNIEnv* env,
jobject thiz,
int a,
int b) {
return a + b;
}
```
3. Биндинг через JNI (static):
```
int
Java_com_m039_study_StaticSummator_sum(JNIEnv* env,
jclass thiz,
int a,
int b) {
return a + b;
}
```
4. Биндинг через JNI (не static, через функцию):
```
int
Java_com_m039_study_Summator_sum(JNIEnv* env,
jobject thiz,
int a,
int b) {
return sum(a, b);
}
```
5. Биндинг через JNI (staic, через функцию):
```
int
Java_com_m039_study_StaticSummator_sum(JNIEnv* env,
jclass thiz,
int a,
int b) {
return sum(a, b);
}
```
Немного подумаем. Как мне кажется 4 и 5 почти похожи, если не сказать полностью. А 1-3 должны отличаться передаваемыми параметрами. Вот это и хотелось бы проверить.
###### Система сборки
Система сборки андроид приложений крайне упрощена, а для таких целей, как проверка компилируемого кода для андроида необходимо знать флаги компиляции. В особенности флаг оптимизации.
В файле Application.mk можно изменить переменную `APP_OPTIM` и присвоить ей одно из двух значений: release или debug.
Т.к. цель данной статьи сравнить интеграцию двух языков, а не разобраться хорошо в одном, то для простоты рассуждений буду использовать значение 'debug'. Это возможно даст лучшее понимание и меньше шансов на ошибку (что даст больше шансов написать эту статью), но всё равно, потом необходимо посмотреть насколько код в режими 'release' отличается.
Теперь немного поподробнее.
Файл [APPLICATION-MK.html](http://android.git.kernel.org/?p=platform/ndk.git;a=blob;f=docs/APPLICATION-MK.html;h=e569716e1ef7b530b4c6d8fddafc890fedeca2ae;hb=HEAD#l61) описывает, что значит флаг `APP_OPTIM`, там также указано, что можно изменить в таге [application](http://developer.android.com/guide/topics/manifest/application-element.html#debug) аттрибут на `android:debuggable="true"` и переменной `APP_OPTIM` присвоится значение 'debug'. Если аттрибуту присвоить значение «false», то `APP_OPTIM` присвоится 'release'.
Поэтому в дальнейшем предполагается что в AndroidManifest.xml установлен аттрибут в `android:debuggable` в «true».
И нельзя упустить тот момент, какие значения будут переданы компилятору, при использовании переменной `APP_OPTIM`, это можно посмотреть ниже, в том же [файле](http://android.git.kernel.org/?p=platform/ndk.git;a=blob;f=build/core/add-application.mk;h=70c133e40a3084afb6696c42ebd687eb21245324;hb=HEAD#l190):
```
ifeq ($(APP_OPTIM),debug)
APP_CFLAGS := -O0 -g $(APP_CFLAGS)
else
APP_CFLAGS := -O2 -DNDEBUG -g $(APP_CFLAGS)
endif
```
Теперь приступ к рассмотру всех 5 вариантов.
##### В режиме 'debug'
*Примечание*: все листинги были получены командой `arm-linux-androideabi-objdump -d "путь к файлу"`
###### Вариант 1
```
00000804 :
804: b082 sub sp, #8
806: 9001 str r0, [sp, #4]
808: 9100 str r1, [sp, #0]
80a: 9a01 ldr r2, [sp, #4]
80c: 9b00 ldr r3, [sp, #0]
80e: 18d3 adds r3, r2, r3
810: 1c18 adds r0, r3, #0
812: b002 add sp, #8
814: 4770 bx lr
816: 46c0 nop (mov r8, r8)
```
В данном листинге много лишнего, а всё из-за соглашения вызова, а конкретнее [ARM calling convention](http://en.wikipedia.org/wiki/Calling_convention#ARM).
Перевожу на данный пример:
— 04: резервирует память под 2 локальные переменные.
— 06-08: сохраняет аргументы, переданные в функцию.
— 0a-0c: эти же аргументы передаются в другие регистры r2 и r3, соответсвенно.
— 0e: равносильно r3 = r2 + r3
— 10: сохранения результата в регистр r0
— 12: возвращаем указатель стека в начальное состояние
— 14: возвращает туда, откуда пришли
— 16: выравнивание функции в файле с помощью комманды nop
*Дополнение*: мне было не понятно 2 момента: суффикс s и комманда bx. Первое означает, что при выполнении также будут обновлен флаг состояния. Второе является thumb коммандой, которая равносильна комманде bl.
После того, как код был разжеван, то стало понятно, что много и много лишнего. Конечно, если использовать оптимизацию, ничего подобного и не было.
В этом листинге надо отметить только 2 момента, как передаются аргументы в функцию и как выполняется основная часть.
Аргументы передаются через регистры, основная часть содержить всего лишь одну команду. Отсюда можно было сделать вывов, что код `adds r0, r1, r2; bx lr` имеет право на существование.
Но повторюсь, нельзя утверждать, что такой код будет в готовом приложении (если только, кто-то не надумает выпускать 'debug' версию на рынок). И пока есть предположение, что в Java всё еще хуже и его хочется проверить. Поэтому надо быстренько пройтись по оставшимся листингам.
###### Вариант 2
```
000007ec :
7ec: b084 sub sp, #16
7ee: 9003 str r0, [sp, #12]
7f0: 9102 str r1, [sp, #8]
7f2: 9201 str r2, [sp, #4]
7f4: 9300 str r3, [sp, #0]
7f6: 9a01 ldr r2, [sp, #4]
7f8: 9b00 ldr r3, [sp, #0]
7fa: 18d3 adds r3, r2, r3
7fc: 1c18 adds r0, r3, #0
7fe: b004 add sp, #16
800: 4770 bx lr
802: 46c0 nop (mov r8, r8)
```
Да-да, тоже самое и как предполагалось, только увеличилось количество аргументов и только. А сколько лишних операций, ужас. Но при этом желание посмотреть оптимизированную версию становится куда больше.
*Примечание*: пока подтверждается предположение, что использовать много JNI функций (которым передаются лишние аргументы), хуже чем использовать простые функции (которым просто передаются меньше аргументов). (Сейчас, когда переписываю эту статью, это утверждение звучит очень наивно)
###### Вариант 3
```
00000850 :
850: b084 sub sp, #16
852: 9003 str r0, [sp, #12]
854: 9102 str r1, [sp, #8]
856: 9201 str r2, [sp, #4]
858: 9300 str r3, [sp, #0]
85a: 9a01 ldr r2, [sp, #4]
85c: 9b00 ldr r3, [sp, #0]
85e: 18d3 adds r3, r2, r3
860: 1c18 adds r0, r3, #0
862: b004 add sp, #16
864: 4770 bx lr
866: 46c0 nop (mov r8, r8)
```
Предположение оправдалось, код идентичен 2 варианту.
###### Вариант 4
```
000008e0 :
8e0: b500 push {lr}
8e2: b085 sub sp, #20
8e4: 9003 str r0, [sp, #12]
8e6: 9102 str r1, [sp, #8]
8e8: 9201 str r2, [sp, #4]
8ea: 9300 str r3, [sp, #0]
8ec: 9a01 ldr r2, [sp, #4]
8ee: 9b00 ldr r3, [sp, #0]
8f0: 1c10 adds r0, r2, #0
8f2: 1c19 adds r1, r3, #0
8f4: f7ff ffde bl 8b4
8f8: 1c03 adds r3, r0, #0
8fa: 1c18 adds r0, r3, #0
8fc: b005 add sp, #20
8fe: bd00 pop {pc}
```
Зачем всё-таки нужно рассматривать этот вариант? На тот случай, если показалось, что писать лучше всё в JNI функциях. Тогда как на самом деле, лучше использовать JNI как обертку для более сложных конструкций. А уж в маленьких С функций можно делать всё, что захочется. (*Замечание*: после написания этой статьи мне это утверждения уже кажется очевидным)
Данный код немного сложнее:
— e0: сохраняет адрес возврата
— e2: резервирует память под локальные переменые
— e4-ea: сохраняет аргументы в локальные переменные
— ec-ee: берет значение локальный переменных
— f0-f2: подготавливает значение регистров к вызову функции
— f4: сам вызов функции
— f8-fa: сохраняет результат в регистр, а потом его записывает в регистр для возвращающего значения
— fc: возвращает указатель стека в начальное положение
— fe: переходит туда, откуда вызвали
Строчка 'e0', используется для сохранения адреса возврата с учетом того, что регистр lr будут переписан через инструкцию bl.
Как можно заметить, оочень много лишнего кода. Предположу, что такой код имеет право на существование:
```
push {lr}
sub sp, #20
adds r0, r2, #0
adds r1, r3, #0
bl 8b4
add sp, #20
pop {pc}
```
###### Вариант 5
Думаю его рассматривать не стоит.
##### В режиме 'release'
Очень хочется проверить свои догадки по поводу того какой код будет в оптимизированном варианте.
###### Вариант 1
```
0000894 :
894: 1808 adds r0, r1, r0
896: 4770 bx lr
```
###### Вариант 2
```
00000890 :
890: 1898 adds r0, r3, r2
892: 4770 bx lr
```
###### Вариант 3
```
00000898 :
898: 1898 adds r0, r3, r2
89a: 4770 bx lr
```
###### Вариант 4
```
0000089c :
89c: b510 push {r4, lr}
89e: 1c10 adds r0, r2, #0
8a0: 1c19 adds r1, r3, #0
8a2: f7ff fff7 bl 894
8a6: bd10 pop {r4, pc}
```
###### Впечатление
Я немного удивлен и нет. Всё, что до этого предполагалось совпало. Оптимизированный код хорош, очень близок к тому, который попытался выше написать сам.
##### Часть I. Итог
Эта часть возможно познакомит вас с ассемблером под ARM. Возможно вы захотите проанализировать другие конструкции языка и понять их. Может быть будете также удивлены своим догадкам.
Но самое главное, если вы андроид разработчик, то вам теперь стало понятно как используются настройки компиляции по умолчанию и куда смотреть при потребности.
Мне вначале было интересно узнать, насколько код на С будет лучше кода на Java. Я сначало написал статью, а вот этот итог пишу после. Могу сказать, что пока можете обратить внимание насколько элегантно получается решить задачу на языке С и насколько компактно получилось это в дизассемблерном виде. В опкодах Java это также можно заметить, но уже меньше. А в 3й статье, где опкоды смешиваются с С, этого практически нету.
А сейчас, как раз, немного об опкодах Java.
#### Часть II. Как выглядит код, генерируемый Java?
Для начала необходимо понять, как работает JVM, а точнее Dalvik VM. Для этого необходимо дизассемблировать файл \*.dex, который является файлом байткодов для Dalvik VM.
Как будет выглядеть класс Summator (см. первоначальная цель)? Для этого натравим программу `dexdump -d classes.dex`. То, что выдала комманда:
```
#5 : (in Lcom/m039/study/Summator;)
name : 'sum'
type : '(II)I'
access : 0x0000 ()
code -
registers : 4
ins : 3
outs : 0
insns size : 3 16-bit code units
00226c: |[00226c] com.m039.study.Summator.sum:(II)I
00227c: 9000 0203 |0000: add-int v0, v2, v3
002280: 0f00 |0002: return v0
catches : (none)
positions :
0x0000 line=73
locals :
0x0000 - 0x0003 reg=1 this com/m039/study/Summator;
0x0000 - 0x0003 reg=2 a I
0x0000 - 0x0003 reg=3 b I
```
```
name : 'staticSum'
type : '(II)I'
access : 0x0008 (STATIC)
code -
registers : 3
ins : 2
outs : 0
insns size : 3 16-bit code units
002100: |[002100] com.m039.study.Summator.staticSum:(II)I
002110: 9000 0102 |0000: add-int v0, v1, v2
002114: 0f00 |0002: return v0
catches : (none)
positions :
0x0000 line=77
locals :
0x0000 - 0x0003 reg=1 a I
0x0000 - 0x0003 reg=2 b I
```
Здесь необходимо разглядеть `add-int v0, v1, v2` и значение опкода '9000 0102'. Теперь можно перейти к тому, как выглядят эти опкоды изнутри.
##### Какие опкоды смотреть?
Меня больше интересует архитектура ARM и т.к. эта архитектура используется по умолчанию, то и опкоды будут соответствующие. Но ARM-ов достаточно много, какой используется по-умолчанию?
Для этого необходимо обратиться к документу Application.mk, а конкретнее к описанию переменной [APP\_ABI](http://android.git.kernel.org/?p=platform/ndk.git;a=blob;f=docs/APPLICATION-MK.html;h=e569716e1ef7b530b4c6d8fddafc890fedeca2ae;hb=HEAD#l134). Там указано, что по-умолчанию используется armv5te. Вот его и будем исследовать!
##### Где начать смотреть?
Сами опкоды находятся в директории [armv5te](http://android.git.kernel.org/?p=platform/dalvik.git;a=tree;f=vm/mterp/armv5te;hb=HEAD). Правильно было бы рассмотреть файлы, находящиеся в этой директории, но мне захотелось сделать не совсем правильным способом, но он тоже работает — рассмотреть уже сгенерированные файлы. А точнее файл [InterpAsm-armv5te.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD). Мне кажется так интереснее и практичнее.
##### Документация
Вся основная документация расположена в каталоге [docs](http://android.git.kernel.org/?p=platform/dalvik.git;a=tree;f=docs;h=7045c2e00b823918a8387187ca171d4c68936080;hb=HEAD), но по необходимости буду давать ссылки на более читабельный формат, чем сырой html.
##### Исследуем опкод сложения (0x90)
Рассмотрим опкод [0x90](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l4180), его код:
```
.L_OP_ADD_INT: /* 0x90 */
/* File: armv5te/OP_ADD_INT.S */
/* File: armv5te/binop.S */
/*
* Generic 32-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = r0 op r1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register other than r0, you can override "result".)
*
* If "chkzero" is set to 1, we perform a divide-by-zero check on
* vCC (r1). Useful for integer division and modulus. Note that we
* *don't* check for (INT_MIN / -1) here, because the ARM math lib
* handles it correctly.
*
* For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
* xor-int, shl-int, shr-int, ushr-int, add-float, sub-float,
* mul-float, div-float, rem-float
*/
/* binop vAA, vBB, vCC */
FETCH(r0, 1) @ r0<- CCBB
mov r9, rINST, lsr #8 @ r9<- AA
mov r3, r0, lsr #8 @ r3<- CC
and r2, r0, #255 @ r2<- BB
GET_VREG(r1, r3) @ r1<- vCC
GET_VREG(r0, r2) @ r0<- vBB
.if 0
cmp r1, #0 @ is second operand zero?
beq common_errDivideByZero
.endif
FETCH_ADVANCE_INST(2) @ advance rPC, load rINST
@ optional op; may set condition codes
add r0, r0, r1 @ r0<- op, r0-r3 changed
GET_INST_OPCODE(ip) @ extract opcode from rINST
SET_VREG(r0, r9) @ vAA<- r0
GOTO_OPCODE(ip) @ jump to next instruction
/* 11-14 instructions */
```
Если посмотреть на комментарии, то всё становится ясно, но мне бы хотелось эти комментарии самому разглядеть в коде. Поэтому дальше идет разбор куска этого кода.
Опкод [0x90](http://www.netmite.com/android/mydroid/dalvik/docs/dalvik-bytecode.html) соответсвует инструкции сложения, её формат [23x](http://www.netmite.com/android/mydroid/dalvik/docs/instruction-formats.html). Это значит, что размер инструкции 2 байта и использует 3 регистра, 'x' означает, что больше, кроме этого, ничего нету.
Следовательно код данного опкода должен извлечь эти 3 регистра, которые передаются в формате 23x и использовать их для сложения. Но тут оказывается, что всё не так просто. Приставка 'v' к регистру, например, 'vCC' — означает virtual. И получается так, что опкод передает номера регистров, а потом инструкция извлекает значение содержащееся в указанном регистре. (*Замечание*: не всегда у регистров есть приставка 'v')
Это выглядит примерно так:
— Имеем опкод: 00|90 02|01 (AA|op CC|BB)\*
— 90 означает опкод сложения
— Извлекаем номера регистров r9 = 0, r2 = 1, r3 = 2
— Извлекаем содержание регистров r1 = REG(r3), r0 = REG(r2)\*\*
— Выполняем инструкцию 'add r0, r0, r1'
— Сохраняем возвращающее значение REG(r9) = r0
\* для простоты восприятия добавил |, аналогично документации
\*\* REG — является псевдокодом
В данном опкоде также содержаться команды необходимые для перехода к другому опкоду. Сейчас на них не стоит обращать внимания, так как их разбиру чуток ниже.
И теперь как это всё выглядит в ассемблере или более суровое объяснение:
1. [FETCH](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l154)(r0, 1). В данном опкоде (0x90) используются два регистра [rPC](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l76) и rINST (там же), которые соответствуют r4 и r5. Если посмотреть немного ниже, то можно заметить, что rINST ([FETCH\_INST](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l113)) это значение лежащее по адресу rPC. Следовательно можно сказать, что rINST равен значению команды FETCH(rINST, 0).
2. Извлекаются номера регистров, стандартным методом. (см. картинку)
3. [GET\_VREG](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l185)(r1, r3). Появляется новый регистр rFP. Этот регистр указывает на область памяти для локальных переменных и аргументов. Т.е. через него можно как извлечь значения аргументов, так и записать возвращающее значение. Его можно представить как указатель на внутренние регистры VM.
4. .if 0… .endif непонятен, а всё потому, что исследовать начал с файла InterpAsm-armv5te.S! Если посмотреть в файл [binop.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/armv5te/binop.S;h=d169ed649e6880e5f27ba788abf75191e3a98941;hb=HEAD), то станет понятно, что проверка второго аргумента но ноль в данном опкоде отключена.
5. FETCH\_ADVANCE\_INST(2) рассмотрена далее
6. Выполняется сложение
7. GET\_INST\_OPCODE(ip) рассмотрена далее
8. [SET\_VREG](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l186)(r0, r9) записывает возвращающее значение в соответствующий регистр, номер которого указан в r0.
9. GOTO\_OPCODE(ip) рассмотрена далее
Нарисовал наглядную (надеюсь) картинку:
[](http://imageshack.us/photo/my-images/546/opcodes.png/)
Можно сделать вывод, что опкод похож на тот же самый код ассемблера ('adds r0, r1, r0'), только c 2 дополнениями: обработкой виртуальных регистров и переходом к следующему опкоду.
###### Не рассмотренная часть
Была рассмотрена обработка виртуальных регистров. Теперь также надо понять, что делают остальные команды в опкоде, надеюсь они не уведут слишком далеко. Например туда, где инициализируются значения таких регистров как rFP и rPC. Хотя это не менее интересно, но сильное ответвление от цели.
Теперь рассмотрим остальные команды:
1. [FETCH\_ADVANCE\_INST](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l127)(2) в регистр rINST записывается следующий опкод
2. [GET\_INST\_OPCODE](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l167)(ip) в регистр ip заноситя номер опкода (уже следующего)
3. [GOTO\_OPCODE](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l178)(ip) переходим на код следующего опкода
В этих 3х командах появляется регистр rIBASE. Надо проверить, является ли он опкодом с номером 0х00? Кажется, как будто должен. Да, так оно и есть. В коде встречается часто строчка:
```
adr rIBASE, dvmAsmInstructionStart @ set rIBASE
```
А значение [dvmAsmInstructionStart](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l420), равно .L\_OP\_NOP. А код OP\_NOP? Он и вправду равен [0х00](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/out/InterpAsm-armv5te.S;h=e6abac5023343f04630f73c5ce76becd433403af;hb=HEAD#l425).
###### Чего не рассмотрели, а хотелось бы
В данном разделе не было рассмотрено только то, какое у остальных (rPC, rFP) регистров начальное значение. Возможно, их рассмотрим дальше. Почему «возможно», потому что большую ценность для статьи, пока представляет rFP, а не rPC.
##### Исследуем опкод сложения (правильная версия)
Мне показалось, что тот способ, как был исследован опкод не совсем правильный, но так мне показалось приятнее. Но теперь рассмотрим как это можно сделать лучше, а именно как составлены файлы в папке arm5vte?
Для этого необходимо обратиться к документу [README.txt](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=vm/mterp/README.txt;hb=HEAD).
Я немного удивлен, но тот способ, который использовал для исследования, был правильный, с точки зрения файла README.txt. Вот цитата:
*«The best way to become familiar with the interpreter is to look at the generated files in the „out“ directory, such as out/InterpC-portstd.c, rather than trying to look at the various component pieces in (say) armv5te.»*
Теперь, что касается нашего примера, рассмотрим файл OP\_ADD\_INS.S:
```
%verify "executed"
%include "armv5te/binop.S" {"instr":"add r0, r0, r1"}
```
Это код означает, что этот файл будет, условно, заменен файлом binop.S, в котором значения $instr будет `add r0, r0, r1`.
Осталось рассмотреть файл [binop.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/armv5te/binop.S;h=d169ed649e6880e5f27ba788abf75191e3a98941;hb=HEAD):
```
%default {"preinstr":"", "result":"r0", "chkzero":"0"}
/*
* Generic 32-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = r0 op r1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register other than r0, you can override "result".)
*
* If "chkzero" is set to 1, we perform a divide-by-zero check on
* vCC (r1). Useful for integer division and modulus. Note that we
* *don't* check for (INT_MIN / -1) here, because the ARM math lib
* handles it correctly.
*
* For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
* xor-int, shl-int, shr-int, ushr-int, add-float, sub-float,
* mul-float, div-float, rem-float
*/
/* binop vAA, vBB, vCC */
FETCH(r0, 1) @ r0<- CCBB
mov r9, rINST, lsr #8 @ r9<- AA
mov r3, r0, lsr #8 @ r3<- CC
and r2, r0, #255 @ r2<- BB
GET_VREG(r1, r3) @ r1<- vCC
GET_VREG(r0, r2) @ r0<- vBB
.if $chkzero
cmp r1, #0 @ is second operand zero?
beq common_errDivideByZero
.endif
FETCH_ADVANCE_INST(2) @ advance rPC, load rINST
$preinstr @ optional op; may set condition codes
$instr @ $result<- op, r0-r3 changed
GET_INST_OPCODE(ip) @ extract opcode from rINST
SET_VREG($result, r9) @ vAA<- $result
GOTO_OPCODE(ip) @ jump to next instruction
```
Как видно код очень и очень похож, на то что было раньше. Только теперь не осталось никаких не понятных моментов. Например был комментарий "@optional op..", а почему, не понятно. Теперь ясно.
Разбирать этот опкод не вижу смысла, в нём всё уже было рассмотрено. Теперь необходимо поскорее перейти к самому главному вопросу — как заполняются аргументы у native и не native функций?
##### Часть II. Итог
Это было уже другой уровень чем в первой части, надо было многое узнать и вспомнить, но зато теперь структура опкода понятна! Этому можно радоваться. Да, большего смысла в этом нету, чем просто радоваться. Но при этом вы уже сможете написать свой опкод.
Из этой части вы могли почерпнуть какая архитектура используется для генерации файлов. Где и как найти соответствующий опкод.
Также у вас может быть появилось много вопросов и советую вам посмотреть [презентацию](http://sites.google.com/site/io/dalvik-vm-internals) разработчика Dalvik VM. В этой презентации очень хорошо показано как именно используются такие команды как GOTO\_OPCODE или как организована очередь байткодов.
Не пытаюсь сразу делать выводы по достижению цели, все выводы будут в самом конце статьи. А теперь предлагаю погрузиться во внутрь Dalvik VM и понять где же исполняется этот код, но предупреждаю дальше уровень еще выше, но кода вставлять буду меньше.
#### Часть III. Как и где происходит выполнение кода?
В 3й части будет рассмотрен процесс извлечения функции в Dalvik VM. Предыдущие знания очень сильно помогут, но боюсь предположить, что скачек будет такой же как и между первой и второй частью. Приступим!
*Замечание*: мне кажется, что вам лучше сразу не ходить по ссылкам, а сначала почитать, так будет материал постепенно появляться и меньше шансов запутаться.
##### Дизассемблируем
Нужно понять как заполняется опкод, для этого посмотрим вот такой вот код в разрезе:
```
public class Summator {
void test() {
sum(44, 43);
staticSum(42, 41);
nSum(44, 43);
nStaticSum(42, 41);
}
int sum(int a, int b) {
return a + b;
}
static int staticSum(int a, int b) {
return a + b;
}
native int nSum(int a, int b);
native static int nStaticSum(int a, int b);
}
```
```
name : 'test'
type : '()V'
access : 0x0000 ()
code -
registers : 5
ins : 1
outs : 3
insns size : 21 16-bit code units
outs : 3
insns size : 21 16-bit code units
0022a8: |[0022a8] com.m039.study.Summator.test:()V
0022b8: 1303 2c00 |0000: const/16 v3, #int 44 // #2c
0022bc: 1302 2b00 |0002: const/16 v2, #int 43 // #2b
0022c0: 1301 2a00 |0004: const/16 v1, #int 42 // #2a
0022c4: 1300 2900 |0006: const/16 v0, #int 41 // #29
0022c8: 6e30 2e00 3402|0008: invoke-virtual {v4, v3, v2}, Lcom/m039/study/Summator;.sum:(II)I // method@002e
0022ce: 7120 2d00 0100|000b: invoke-static {v1, v0}, Lcom/m039/study/Summator;.staticSum:(II)I // method@002d
0022d4: 6e30 2600 3402|000e: invoke-virtual {v4, v3, v2}, Lcom/m039/study/Summator;.nSum:(II)I // method@0026
0022da: 7120 2500 0100|0011: invoke-static {v1, v0}, Lcom/m039/study/Summator;.nStaticSum:(II)I // method@0025
0022e0: 0e00 |0014: return-void
catches : (none)
positions :
0x0008 line=29
0x000b line=30
0x000e line=31
0x0011 line=32
0x0014 line=33
locals :
0x0000 - 0x0015 reg=4 this Lcom/m039/study/Summator;
```
Очень сильно не хочется разбирать (и копировать в статью) каждый файл в директории armv5te. Поэтому попытаюсь дать ссылки и выдержки из этих файлов.
В листинге выше можно заметить, что метод native ничем не отличается от другого. Как же так? Вообще то так и должно быть, но всё равно, в листинге нету никакого намека на то, как же извлекается native метод.
Но сначала, почему бы не рассмотреть сам вызов (invoke-virtual) и сразу предположу, что там код не маленький. Поэтому сформирую заранее то, что хотелось бы там найти:
— отличие virtual от static
— само извлечение функции
— и сколько и, возможно, какие операции следуют до извлечения
Остальное пока не интересует и не должно отвлекать от исследования.
##### Выполнение метода
Начнем рассматривать листинг с верху вниз.
Часть кода, которая заполняет и извлекает метод sum:
```
0022b8: 1303 2c00 |0000: const/16 v3, #int 44 // #2c
0022bc: 1302 2b00 |0002: const/16 v2, #int 43 // #2b
0022c8: 6e30 2e00 3402 |0008: invoke-virtual {v4, v3, v2}, Lcom/m039/study/Summator;.sum:(II)I // method@002e
```
На первый взгляд всё очень просто. Заполняются соответствующие регистры и извлекается метод.
Попробую предположить, как будет выглядеть этот метод изнутри.
`const/16` — наверно заносит значение 44 в виртуальный регистр по номеру 0, а потом значение 43. (*Замечание*: а если предположить, что v1 это обозначение виртуального регистра, то сомнений нет)
`invoke-vritual` — заносит значение this в v4 и вызывает функцию.
###### const/16
```
%verify "executed"
/* const/16 vAA, #+BBBB */
FETCH_S(r0, 1) @ r0<- ssssBBBB (sign-extended)
mov r3, rINST, lsr #8 @ r3<- AA
FETCH_ADVANCE_INST(2) @ advance rPC, load rINST
SET_VREG(r0, r3) @ vAA<- r0
GET_INST_OPCODE(ip) @ extract opcode from rINST
GOTO_OPCODE(ip) @ jump to next instruction
```
Данный код считывает значение переданное во втором байте и записывает значение в виртуальный регистр. Можно отметить (опять), что всё выглядит также как и генерируемом коде на С (оптимизированный вариант) только с 2мя дополнениями: на каждую запись/чтение используется промежуточный виртуальный регистр и каждый раз загружается новый опкод и совершается переход. В остальном всё очень и очень прозрачно.
###### invoke-*kind*
2 виртуальных регистра заполнены, теперь переходим к файлу OP\_INVOKE\_VIRTUAL.S. И там глубокий ужас. Поэтому сразу попробуем понять, в чем разница между virtual (файл [OP\_INVOKE\_VIRTUAL.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S;hb=HEAD)) и static ([OP\_INVOKE\_STATIC.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=vm/mterp/armv5te/OP_INVOKE_STATIC.S;hb=HEAD)).
По коду отличие в двух местах. Значение передаваемое в функцию dvmResolveMethod и не у static метода имеется дополнительный довесок ".L${opcode}\_continue:".
Рассмотрим, что делает функция dvmResolveMethod.
Перед вызовом этой функции регистры заполнены следующим образом. (выдержка из комментариев):
— r0 < — method->clazz
— r1 < — CCCC \*
— r2 < — METHOD\_VIRTUAL или METHOD\_STATIC (method type)
— r3 < — glue->method
\* по документу [instructions-format](http://www.netmite.com/android/mydroid/dalvik/docs/instruction-formats.html) CCCC, хотя в комментариях написано BBBB
Теперь обратимся к коду функции [dvmResolveMethod](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/oo/Resolve.c;h=c4bda8baa87a3b1d86183b02f4dad01c420faa23;hb=HEAD#l176). Если посмотреть на объявление функции, то станет понятно, что 4й аргумент (см. выше) лишний:
```
Method* dvmResolveMethod(const ClassObject* referrer,
u4 methodIdx,
MethodType methodType)
```
Это функция возвращает указатель на структуру [Method](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/oo/Object.h;h=903450f69e86905ebce987a263f1e08bc137c615;hb=HEAD#l527), большего знать об этой функции и не нужно. Взглянем на эту структуру.
Очень много интересных и полезных полей, но есть одно замечательно поле, которое предоставляет особый интерес — `nativeFunc`. Следовательно это структура также содержит указатель на native функцию.
Теперь неплохо бы узнать, где эта структура или этот метод «выполняется».
И в файле OP\_INVOKE\_STATIC.S и в OP\_INVOKE\_VIRTUAL.S в конце вызывается функция `bl common_invokeMethod${routine}`. Скорее всего это и есть главный обработчик структуры Method и код его можно найти в файле [footer.S](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/armv5te/footer.S;h=b69aef8006111f6079ac810ff778c48fed9e5325;hb=HEAD#l565). Приставка «NoRange» появилась из-за первой строчки в файле — `%default { ... , "routine" : "NoRange" }`
Но прежде чем смотреть в footer.S, можно посмотреть, что значит тип `DalvikBridgeFunc` у поля `nativeMethod`? Если пробежаться по коду VM, то можно найти, что полю `nativeMethod` присваивается функция [dvmResolveNativeMethod](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/Native.c;h=1ebef2eedf15ff50a1de36b596b9367aac4431b3;hb=HEAD#l70)
По комментарию этой функции становится ясно — она используется для того, чтобы найти native метод (в библиотеке libNAME.so) и главное выполнить его. Ну что же, поверим ей на слово, тот случай единственный случай, когда лучше поверить.
Одним вопросом меньше, теперь стало ясно, кто и где выполняет native метод. Но всё равно, не до конца понятно где. Ведь файл footer.S так и не был рассмотрен.
Возвращаясь к функции [common\_invokeMethodNoRange](http://android.git.kernel.org/?p=platform/dalvik.git;a=blob;f=vm/mterp/armv5te/footer.S;h=b69aef8006111f6079ac810ff778c48fed9e5325;hb=HEAD#l565). Можно обратить внимание на то, что она очень страшная и в ней есть ответы на то, что было не понятно в прошлой части, а именно кто заполняет такие регистры как rFP и rPC. Как можно заметить эта функция их и заполняет.
Только немного терпения и там можно понять, например, чем заполняется rINST, rPC, r2? Указателем на поле method->inst, т.е. инструкциями (байткодом). И таких моментов очень много, поэтому рассмотрение их опущу.
А вот интерес представляет native, а там еще всё проще. Если наш метод является native (проверяются соответствующие флаги), то выполняется та самая функция nativeFunc, с которой уже имели дело.
В остальном, common\_invokeMethodNoRange очень похож на стандартный опкод, которые раньше рассматривали, только много дополнительных проверок.
А как быть со static или не static методами? footer.S к ним отношения, по видимому не имеет, всё что можно было про них сказать, уже было сказано в соответствующих файлах опкодов (invoke-virtual и invoke-static).
На этом можно сказать, кто где и что сделал понятным. А если нет, то дальше разобраться не составит труда. Моя задача была показать, что поставить себе вопросы (см. первоначальная цель) и хорошо разобраться в этом более чем реально.
##### Часть III. Итог
В этой части была найдена функция, отвечающая за извлечение native метода. Также проследили за тем, где эта функция извлекается и где она хранится. С этими знаниями можно рассмотреть другие части языка Java и понаблюдать за ними в коде Dalvik VM.
После этой части становится ясно, что байткод представляет из себя много опкодов и каждый между собой взаимодействует. И в этой части было рассмотрена только маленькая часть этого взаимодействия.
Если вас заинтересовала данная тема, то в дальнейшем можно рассмотреть стандартные структуры языка Java в дизассемблерном виде и понять, почему разработчик Dalvik VM в своей презентации показывал примеры как следует делать или не следует делать при программировании на языке Java для андроида.
#### Итог
Я здесь постараюсь сделать выдержки из того, что как мне кажется можно узнать в этой статье.
Но сначала хочу подчеркнуть пару особенностей, как составлена статья.
Вы могли встретить в тексте слово «Замечание», оно было добавлено после написание всей статьи в черновик. А потом мне показалось, что стоит эти замечания добавить.
Моя цель данной статьи показать мышление, которые необходимо для исследования непонятного кода на практике. Выбрал для этого очень простые вопросы и интересующий меня объект. Поэтому можете встретить много ответвлений и заметить как меняется отношение к предмету.
А теперь немного о том, что мне кажется интересным и является результатом исследований. Они могут показаться вам банальными, многие вещи написаны в спецификации языка Java, но после данной статьи гораздо проще разобраться в этих структурах как есть.
Вот основные моменты:
1. Вызов метода, какой бы он ни был static, virtual (есть также с приставкой quick), он вызов метода и по себе очень сложный, если сравнивать с простым С (и даже С++). Вот, например, допустим у вас есть wraper для Box2D. Если каждый раз (в бесконечном цикле) вызывать метод из этой обертки, для того, чтобы проверить пересекаются ли объекты, то возникает соответствующий вопрос — зачем? Это лучше и нужно сделать на С, а вот создать мир и проинициализровать объекты можно и в Java.
2. Опкоды, очень близки по своему функционалу к ассемблерным вставкам, дабы они так и реализованы с помощью ассемблера. Естественно, они лучше чем вызов сторонней функции через JNI, но хуже чем просто это сделать на С.
Хуже они по двум критериям:
1) Используют для своих вызов обертку через виртуальные регистры, что очень сильно похоже на то, как С компилятор выдает в debug режиме. Можно даже сказать, что опкод по скорости очень похож на не оптимизированную версию на С.
2) В каждом опкоде есть код извлечения следующего опкода, но он не большой. После извлечения происходит переход на следующий, что уже похоже на простую инструкцию `bl`.
Я утолил свой интерес и узнал, что хотел и мои догадки большей частью оправдались. Мне очень приятно, если вам это понравилось и вы прошли со мной этот путь. Надеюсь у вас появились интерсные мысли и главное интерес к тому как всё работает.
Я часто замечаю, что разработчики оочень часто пользуются стереотипами (по поводу языков Java и С/C++) и не проявляют ни малейшего действия для того, чтобы их разрушать, а без этого никуда.
Если вам интересен дополнительный материал то можете посмотреть в папку docs на файл [jni-tips.html](http://www.netmite.com/android/mydroid/dalvik/docs/jni-tips.html) и [презентацию](http://sites.google.com/site/io/dalvik-vm-internals) 2008 года разработчика Davik VM. Также есть интересный проект [smali](http://code.google.com/p/smali/), но у меня руки до него не добрались.
P.S. Сразу извиняюсь, если допустил какую-то ошибку, пожалуйста, поправьте меня и тогда сразу же внесу изменения. | https://habr.com/ru/post/126356/ | null | ru | null |
# 14 вещей, которые я хотел бы знать перед началом работы с MongoDB
***Перевод статьи подготовлен в преддверии старта курса [«Нереляционные базы данных»](https://otus.pw/ZRL1/).***
---
Основные моменты:
* Крайне важно разработать схему несмотря на то, что в MongoDB она необязательна.
* Аналогично, индексы должны соответствовать вашей схеме и шаблонами доступа.
* Избегайте использования больших объектов и больших массивов.
* Будьте осторожны с настройками MongoDB, особенно если речь идет о безопасности и надежности.
* В MongoDB нет оптимизатора запросов, поэтому вы должны быть осторожны при выполнении операций запроса.
Я очень давно работаю с базами данных, но только недавно открыл для себя MongoDB. Есть несколько вещей, которые я хотел бы знать перед началом работы с ней. Когда у человека уже есть опыт в определенной сфере, у него существуют предвзятые представления о том, что такое базы данных и что они делают. В надежде облегчить задачу понимания другим людям, представляю список распространенных ошибок.
### Создание сервера MongoDB без аутентификации
К сожалению, MongoDB по умолчанию ставится без аутентификации. Для рабочей станции, доступ к которой устанавливается локально, такая практика нормальна. Но поскольку MongoDB – это многопользовательская система, которая любит использовать большие объемы памяти, будет лучше, если вы поставите ее на сервер с максимально возможным в ваших условиях количеством оперативной памяти, даже если собираетесь использовать ее только для разработки. Установка на сервер через порт по умолчанию может оказаться проблемной, особенно, если в запросе можно выполнить любой код на javascript (например, `$where` в качестве идеи для [инъекции](https://lockmedown.com/securing-node-js-mongodb-security-injection-attacks/)).
Есть несколько методов аутентификации, но проще всего установить для пользователя ID/пароль. Воспользуйтесь этой идеей, пока будете думать над причудливой аутентификацией на основе [LDAP](https://docs.mongodb.com/manual/core/security-ldap-external/). Если говорить о безопасности, то MongoDB должна постоянно обновляться, а логи всегда следует проверять на наличие несанкционированного доступа. Мне, например, нравится выбирать другой порт в качестве порта по умолчанию.
### Не забудьте привязать поверхность атаки к MongoDB
[Чек-лист обеспечения безопасности MongoDB](https://docs.mongodb.com/manual/administration/security-checklist/) содержит хорошие советы для снижения риска проникновения в сеть и утечки данных. Легко отмахнуться и сказать, что сервер для разработки не нуждается в высоком уровне безопасности. Однако все не так просто и это относится ко всем серверам MongoDB. В частности, если нет веской причины использовать `[mapReduce](https://docs.mongodb.com/manual/reference/command/mapReduce/#dbcmd.mapReduce)`, `[group](https://docs.mongodb.com/manual/reference/command/group/#dbcmd.group)` или [$where](https://docs.mongodb.com/manual/reference/operator/query/where/#op._S_where), нужно отключить использование произвольного кода на JavaScript, написав в файле конфигурации `[javascriptEnabled:false](https://lockmedown.com/securing-node-js-mongodb-security-injection-attacks/)`. Поскольку в стандартной MongoDB файлы данных не зашифрованы, разумно запускать MongoDB с [Dedicated User](https://docs.mongodb.com/manual/administration/security-checklist/#run-mongodb-with-a-dedicated-user), у которого есть полный доступ к файлам, с ограниченным доступом только для него и возможностью использовать собственные средства управления доступом к файлам операционной системы.
### Ошибка при разработке схемы
MongoDB не использует схему. Но это не значит, что схема не нужна. Если вы хотите просто хранить документы без какой-либо согласованной схемы, сохранять их можно быстро и просто, но извлечь их потом может быть [чертовски сложно](https://www.compose.com/articles/mongodb-with-and-without-schemas/).
Классическая статья «*[6 эмпирических правил для проектирования схем MongoDB»](https://www.mongodb.com/blog/post/6-rules-of-thumb-for-mongodb-schema-design-part-1)* стоит того, чтобы ее прочитать, а такие функции, как [Schema Explorer](https://studio3t.com/knowledge-base/articles/schema-explorer/) в стороннем инструменте Studio 3T, стоит использовать для регулярных проверок схем.
### Не забудьте о порядке сортировки
Забыв о порядке сортировки можно сильнее всего разочароваться и потерять больше времени, чем при использовании любой другой неправильной конфигурации. По умолчанию MongoBD использует [бинарную сортировку](https://jira.mongodb.org/browse/SERVER-1920). Но вряд ли она будет кому-то полезна. Чувствительные к регистру, ударению, бинарные сортировки считались любопытными анахронизмами наряду с бусами, кафтанами и завивающимися усами еще в 80-х годах прошлого века. Теперь же их использование непростительно. В реальной жизни «мотоцикл» – это то же самое, что и «Мотоцикл». А «Британия» и «британия» – одно и то же место. Строчная буква – это просто прописной эквивалент большой буквы. И не заставляйте меня говорить о сортировке диакритических знаков. При создании базы данных в MongoDB используйте параметры сортировки без учета ударения и [регистра](https://weblogs.sqlteam.com/dang/archive/2009/07/26/Collation-Hell-Part-1.aspx), которые соответствуют языку и [культуре пользователей системы](https://derickrethans.nl/mongodb-collation-revised.html). Так вы значительно упростите поиск по строковым данным.
### Создание коллекций с большими документами
MongoDB рада разместить большие документы размером до 16 МБ в коллекциях, а [GridFS](https://docs.mongodb.com/manual/core/gridfs/#gridfs) предназначена для больших документов размером больше 16 МБ. Но только потому, что большие документы там можно разместить, хранить их там не лучшая идея. Лучше всего MongoDB будет работать, если вы будете сохранять отдельные документы размером в несколько килобайт, рассматривая их больше, как строки в широкой SQL-таблице. Большие документы будут источником проблем с [производительностью](https://www.reddit.com/r/mongodb/comments/573fqr/question_mongodb_terrible_performance_for_a/).
### Создание документов с большими массивами
Документы могут содержать массивы. Лучше всего, если количество элементов в массиве далеко от четырехзначного числа. Если элементы к массиву добавляются часто, он перерастет содержащий его документ, и его нужно будет [переместить](http://docs.mongodb.org/manual/core/data-model-operations/#document-growth), значит, нужно будет [обновить и индексы](http://docs.mongodb.org/manual/core/write-performance/#document-growth). При повторной индексации документа с большим массивом, индексы часто будут перезаписываться, поскольку под каждый элемент существует [запись](http://docs.mongodb.org/manual/core/index-multikey/), хранящая его индекс. Такая переиндексация также происходит, когда документ вставляется или удаляется.
В MongoDB есть так называемый [«коэффициент заполнения»](https://docs.mongodb.com/manual/core/mmapv1/#record-allocation-strategies), который предоставляет пространство для роста документов, чтобы свести эту проблему к минимуму.
Вы можете подумать, что обойтись можно без индексации массивов. К сожалению, из-за отсутствия индексов у вас могут появиться другие проблемы. Поскольку документы просматриваются от начала до конца, поиск элементов в конце массива будет занимать больше времени, да и большинство операций, связанных с таким документом, будут [медленными](http://grokbase.com/t/gg/mongodb-user/128r0h5gzw/inserting-into-300-000-size-embedded-array-is-slow-even-w-o-indexes).
### Не забудьте, что порядок стадий в агрегации имеет значение
В системе базы данных с оптимизатором запросов, запросы, которые вы пишете, являются объяснениями того, что вы хотите получить, а не того, как это получить. Работает такой механизм по аналогии с заказом в ресторане: обычно вы просто заказываете блюдо, а не даете подробные инструкции повару.
В MongoDB вы инструктируете повара. Например, нужно убедиться, что данные проходят через `reduce` как можно раньше в пайплайне с помощью `$match` и `$project`, а сортировка происходит только после `reduce`, и что поиск происходит ровно в том порядке, в котором вам нужно. Наличие оптимизатора запросов, который избавляет от лишней работы, оптимально упорядочивает этапы и выбирает тип соединения, может вас избаловать. В MongoDB у вас появляется больше контроля ценой удобства.
Такие инструменты как [Studio 3T](https://studio3t.com/) упростят построение запросов агрегации в [MongoDB](https://studio3t.com/knowledge-base/articles/build-mongodb-aggregation-queries/). Функция Aggregation Editor позволит вам применять операторы пайплайна по одному этапу за раз, а также проверять входные и выходные данные на каждом этапе для упрощения дебага.
### Использование быстрой записи
Никогда не устанавливайте в MongoDB параметры записи с высокой скоростью, но низкой надежностью. Этот режим *«file-and-forget»* кажется быстрым, поскольку команда возвращается до того, как осуществляется запись. Если система упадет до того, как данные будут записаны на диск, они потеряются и окажутся в несогласованном состоянии. К счастью, в 64-битном MongoDB включено журналирование.
Движки для хранения MMAPv1 и WiredTiger используют логирование для предотвращения этого, хотя WiredTiger может восстановиться до последней согласованной [контрольной точки](https://docs.mongodb.com/manual/core/wiredtiger/#storage-wiredtiger-checkpoints), если журналирование отключено.
Журналирование гарантирует, что база данных находится в согласованном состоянии после восстановления и хранит все данные до момента записи в журнале. Периодичность записей настраивается с помощью параметра `[commitIntervalMs](https://docs.mongodb.com/manual/reference/configuration-options/#storage.journal.commitIntervalMs)`.
Чтобы быть уверенным в записях, убедитесь, что в файле конфигурации журналирование включено `[(storage.journal.enabled](https://docs.mongodb.com/manual/reference/configuration-options/#configuration-file))`, а периодичность записей соответствует тому объему информации, который вы можете позволить себе потерять.
### Сортировка без индекса
При поиске и агрегировании часто возникает необходимость в сортировке данных. Будем надеяться, что это делается на одном из заключительных этапов, после фильтрации результата с целью уменьшения объема сортируемых данных. И даже в таком случае для сортировки вам понадобится [индекс](https://studio3t.com/knowledge-base/articles/mongodb-index-strategy/). Можно воспользоваться одиночным или составным индексом.
Если подходящего индекса нет, MongoDB обойдется без него. Существует ограничение памяти в 32 Мб на общий размер всех документов в [операции сортировки](https://docs.mongodb.org/manual/reference/limits/#Sort-Operations), и если MongoDB достигнет этого предела, то она либо выдаст ошибку, либо вернет [пустой набор записей](https://www.sitepoint.com/7-simple-speed-solutions-mongodb/).
### Поиск без поддержки индексов
Поисковые запросы выполняют функцию аналогичную операции JOIN в SQL. Для лучшей работы им нужен индекс значения ключа, используемого в качестве внешнего ключа. Это неочевидно, поскольку использование не отражено в `explain()`. Такие индексы являются дополнением к индексу, записанному в `explain()`, который в свою очередь используется операторами пайплайна `$match` и `$sort`, когда те встречаются в начале пайплайна. Индексы теперь могут охватывать любую стадию [пайплайна агрегации](https://docs.mongodb.com/manual/core/aggregation-pipeline/#aggregation-pipeline-operators-and-performance).
### Отказ от использования мультиобновлений
Метод `[db.collection.update()](https://docs.mongodb.com/manual/reference/method/db.collection.update/)` используется для изменения части существующего документа или целого документа, вплоть до полной замены в зависимости от заданного вами параметра `[update](https://docs.mongodb.com/manual/reference/method/db.collection.update/#update-parameter)`. Не так очевидно, что он не обработает все документы в коллекции, пока вы не установите параметр `[multi](https://docs.mongodb.com/manual/reference/method/db.collection.update/#multi-parameter)` для обновления всех документов, отвечающих критериям запроса.
### Не забудьте о важности порядка ключей в хэш-таблице
В JSON объект состоит из неупорядоченной коллекции размером ноль или более пар имя/значение, где имя – это строка, а значение – это строка, число, логическое значение, ноль, объект или массив.
К сожалению, BSON придает большое значение порядку при поиске. В MongoDB порядок ключей внутри встроенных объектов [имеет значение](http://devblog.me/wtf-mongo), т.е. `{ firstname: "Phil", surname: "factor" }` – это не то же самое, что `{ { surname: "factor", firstname: "Phil" }`. То есть вы должны хранить в документах порядок пар имя/значение, если хотите быть уверены в том, что найдете их.
### Не путайте *«null»* и *«undefined»*
Значение *«undefined»* никогда не было допустимым в JSON, согласно [официальному стандарту](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf) JSON (ECMA-404, Раздел 5), несмотря на то, что оно используется в JavaScript. Более того, для BSON оно устарело и преобразовывается в `$null`, что не всегда является хорошим решением. [Избегайте использования *«undefined»* в MongoDB](https://github.com/meteor/meteor/issues/1646#issuecomment-29682964).
### Использование `$limit()` без `$sort()`
Очень часто, когда вы ведете разработку в MongoDB, полезно просто увидеть образец результата, который вернется из запроса или агрегации. Для этой задачи вам пригодится `$limit()`, но его никогда не должно быть в финальной версии кода, если только перед ним вы не используете `$sort`. Эта механика нужна, поскольку иначе вы не можете гарантировать порядок результата, и не сможете надежно просматривать данные. В верхней части результата вы будете получать разные записи в зависимости от сортировки. Для надежной работы запросы и агрегации должны быть детерминированными, то есть выдавать одинаковые результаты при каждом выполнении. Код, в котором есть `$limit()`, но нет `$sort`, не будет являться детерминированным и впоследствии может вызвать ошибки, которые будет трудно отследить.
### Заключение
Единственный способ разочароваться в MongoDB – это сравнивать ее непосредственно с другим типом баз данных, таким как СУБД, или прийти к ее использованию, исходя из каких-то определенных ожиданий. Это все равно что сравнивать апельсин с вилкой. Системы баз данных преследуют определенные цели. Лучше всего просто понять и оценить для себя эти различия. Было бы стыдно давить на разработчиков MongoDB из-за пути, который вынудил их идти по пути СУБД. Мне хочется видеть новые и интересные способы решения старых проблем, таких как обеспечение целостности данных и создание систем данных, устойчивых к сбоям и атакам злоумышленников.
Внедрение в MongoDB в версии 4.0 ACID transactionality — хороший пример внедрения важных улучшений инновационным путем. Мультидокументальные и мультиоператорные транзакции теперь атомарные. Также появилась возможность регулировать время, необходимое для получения блокировок, и заканчивать зависшие транзакции, а также изменять уровень изоляции.
[](https://otus.pw/ZRL1/)
### Читать ещё:
* [Как загрузить данные в Google BigQuery](https://habr.com/ru/company/otus/blog/519340/) | https://habr.com/ru/post/520412/ | null | ru | null |
# Calltracking в Minecraft или как быстро сделать трехмерный UI
Пару месяцев назад назад я показал детям Minecraft, а чуть позже — купил им [книгу](https://habrahabr.ru/company/piter/blog/269757/) по программированию в MineCraft. Правда, детям купил, чес-слово. Ну сам взял полистить, ну написал пару скриптов…
На этом история и закочнилась бы, но на днях мне довелось поучаствовать в хакатоне одного calltracking сервиса. Для тех, кто не в курсе, [calltracking](https://ru.wikipedia.org/wiki/Call_tracking) — эта такая штука, которая предоставляет статистику звонков. И что важно для нашей истории — эта статистика доступна по API.
В этот момент отдельные части сложились в цельную картину и я подумал — о! статистика звонков в Minecraft.
Ну что ж, формат хакатона располагает к безумным идеям, а эта идея показалась мне достаточно безумной, чтобы быть реализованной.
А если серьезно — то кто сказал что интерфейсы должны быть двумерными?
И кто сказал что трехмерный интерфейс это долго и сложно?
Вся затея у меня заняла 3 часа (57 строк на питоне), учитывая, что первые полчаса я разбирался как на python парсить джейсон.
Под катом — вся история целиком, видео с результатом и бонус для дочитавших до конца — все 3 часа разработки в 3 минутном time-lapse видео.
Чтобы это все заработало мне понадобилось 3 простых шага:
1. Поднимаем сервер Minecraft который позволяет взаимодействовать с миром Minecraft по API на Python
2. Берем статистику звонков по calltracking API
3. Создаем кубики в Minecraft.
Ок, поехали!
### 1. Сервер Minecraft
Сервер майнкрафта с красивым названием [bukkit](https://bukkit.org) у меня уже был готов (скачать его можно с [сайта книги](http://eu.wiley.com/WileyCDA/Section/id-823690.html) вместе с очень подробными видеоинструкциями).
Версия игры — 1.6.4, скрипты будем писать на Python, т.к. этот сервер их понимает.
### 2. Берем статистику звонков по API
Тут тоже все просто, пару строк на питоне и все готово:
```
import json, requests
data = requests.get("https://istat24.com.ua/api/{your_api_key}/calls.json?counter_start_date=2016-02-01&counter_end_date=2016-02-05")
json = json.loads(data.content)
```
Пару слов про сам API.
Я использую API Calltracking сервиса [iStat24](http://iStat24.com) (в отделе разработки которого и происходил этот самый хакатон), он возвращает журнал звонков в JSON, а чтобы получить данные для определенного аккаунта нужно в этом самом аккаунте сгенерировать API\_key, который у меня к хакатону был заготовлен заранее.
Пример звонка из JSON:
```
{
call_id: 5555555,
numberA: "380555555555",
numberB: "380555555555",
start: "2016-02-05 15:11:13",
duration: "00:03:57",
wait_duration: "00:00:07",
speak_duration: "00:03:50",
record: "http://url_to_the_audio_record.mp3",
accepted: 1,
direction: "incoming",
reklama_name: "Google organic",
reklama_id: 729
}
```
Из этого всего нас интересует:
**wait\_duration** — время ожидания звонка (гудки, короче говоря)
**speak\_duration** — время разговора
**accepted** — значение 1/0 определяет был звонок принят или пропущен.
Итого, имеем массив звонков. Теперь осталось их только представить визуально.
### 3. Создаем кубики в Minecraft
До этого все было просто, да? даже не просто — тривиально.
Вы наверное думаете что с этого места начнется какая-то магия? А вот и нет.
Дело в том, что все написано до нас.
Есть расчудесная библиотека на питоне — **minecraftstuff**, которая умеет делать все основные вещи в Minecraft.
Нам осталось только описать где и какого типа кубик мы хотим создать.
Подключаем и инициализируем библиотеку:
```
import mcpi.minecraft as minecraft
import mcpi.block as block
import mcpi.minecraftstuff as minecraftstuff
mc = minecraft.Minecraft.create()
mcdrawing = minecraftstuff.MinecraftDrawing(mc)
```
Теперь координаты. Minecraft — мир трехмерный, поэтому очевидно что нам нужны x,y и z.
Можно брать текущие координаты персонажа командой mc.player.getTilePos(), но я решил захардкодить определенное место в мире Minecrft (просто потому, что после каждой итерации мне нужно было очищать все пространство с предыдущей попыткой «строительства».) Для дебага удобнее, в общем.
Кубик рисуется командой mc.setBlock(x, y, z, blockType).
А как удалить кубик? Как оказалось — воздух в Minecraft — это тоже кубик. Поэтому вместо удаления кубиков — нужно просто нарисовать кубики с воздухом. Можно делать это поштучно при помощи это же команды mc.setBlock(x, y, z, block.AIR.id) — указывая тип блока «block.AIR.id». А можно использовать команду mc.setBlocks() которая забивает прямоугольную область кубиками нужного типа. В книжке написано что это быстрее, чем рисовать кубики поштучно.
В итоге у меня получился вот такой код для очистки пространства:
```
mc.postToChat("START")
startX=146; startY=0; startZ=-30 // хардкод начальных координат
# Clean up
mc.setBlocks(startX-2, startY-20, startZ+5, startX+2, startY+200, startZ-250, 8)
time.sleep(2)
mc.setBlocks(startX-3, startY-1, startZ+6, startX+3, startY+210, startZ-551, block.AIR.id)
time.sleep(2)
# cleanUp(pos.x, pos.y, pos.z, 40) # Clean up self
mc.postToChat("Clean up is done")
```
Лайвхак. Здесь я сначала забиваю пространство кубиками с ID=8 а потом забиваю это же пространство воздухом.
Это делается исключительно для дебага, чтобы было видно какой же именно участок через 2 секунды будет очищен. Иначе это совершенно не очевидно и занимает кучу времени подгадать нужные координаты.
Вообще, весь этот участок кода можно заменить на всего одну команду: mc.setBlocks(startX-3, startY-1, startZ+6, startX+3, startY+210, startZ-551, block.AIR.id), все остальное исключительно для дебага.
Чтобы было красивее, я решил что каждый звонок будет представлен в виде башни шириной (и толщиной) в 2 кубика — а длительность звонка будет представлена высотой башни (1 секунда = 1 кубик). Поэтому простенькая процедурка которая рисует башню заданной высоты:
```
def drawCall(x, y, z, length, blockType):
length = (length, 200)[length>200]
for i in range(y, y+length):
mc.setBlock(x, i, z, blockType)
mc.setBlock(x+1, i, z, blockType)
mc.setBlock(x+1, i, z+1, blockType)
mc.setBlock(x, i, z+1, blockType)
```
Обратите внимание, что в нее встроен дисторшн — потому что высота мира в Minecraft, как оказалось, 255 кубиков, поэтому если звонок был длиннее 255 секунд (а таких конечно же много) — они уходят выше «крыши мира» и продолжаются с «дна мира», что конечно же не эстетично.
Теперь у нас готово все, чтобы нарисовать звонки.
Просто пробегаемся по массиву звонков полученному из API и рисуем башни (используя кубики разных типов, чтобы визуально представить время ожидания звонка, время разговора и пропущенные звонки — красным цветом).
```
for call in json:
offset+=3
duration = get_sec(call['duration'])
wait_duration = get_sec(call['wait_duration'])
speak_duration = get_sec(call['speak_duration'])
if call['accepted'] == 1:
drawCall(startX, startY, startZ-offset, wait_duration, 41) # wait_duration
drawCall(startX, startY+wait_duration, startZ-offset, speak_duration, 133) #speak_duration
else:
drawCall(startX, startY, startZ-offset, duration, 152) # duration
```
На этом все, заходим в майнкрафт и любуемся трехмерной статистикой звонков.
Кстати, одно видео я записал сам, а второе — записал ребенок. Угадаете какое где?
Желтые кубики — время ожидания(гудки), зеленые — время разговора, красные — пропущенный звонок.
[ [Исходник скрипта на Python](https://github.com/n0quarter/minecraft_calltracking/blob/master/iStat24.py) ]
И обещанное в начале поста видео 3 часов разработки сжатое до 3 минут:
И напоследок вопрос, какие процессы/данные, по вашему, смотрелись бы лучше в трехмерном виде?
Навскидку:
— дашборд для отображения продакшн-серверов, в случае падения какого-либо из них — скрипт автоматически добавляет кубик-динамит и взрывает его :) если Minecraft вывести на офисный монитор и настроить звук погромче — должно впечатлять.
Еще идеи? | https://habr.com/ru/post/278995/ | null | ru | null |
# CS Cart или через терни к черной дыре костылей и оптимизаций
Совсем недавно, я стал разработчиком модулей для CS Cart. Случилось это по воле случая: меня взяли на работу в Петербургскую сеть интернет магазинов, торгующих вейпами и всякими интересными штуками для удовлетворения потребностей физического характера страждущих пар и одиночек (кто не понял - еще не дорос ). Оба интернет магазина развернуты на двух витринах с разными доменами, но одной админкой и общей базой данных. Что же с ней не так? Думаю о CMS написано много, но я добавлю свою ложку дегтя в бочку с дегтем .
Путешествие в модуль через лес директорий
-----------------------------------------
В процессе разработки первого модуля для этой платформы, я столкнулся со множеством проблем, которых, как я полагал, имея опыт работы с ООП, а также с CMS MODX Revo, быть не должно. Первое, что бросилось в глаза - это очень сложная и запутанная структура модуля:
```
root/
├─ app/
│ └ addons/ <- Модули и расширения
│ └ [id_модуля]/ <- Папка модуля
│ ├─ controllers/ <- Расширение контроллеров
│ │ ├─ backend/ <- Панель администратора
│ │ │ ├─ [ваш_контроллер].php <- Новый контроллер
│ │ │ ├─ [контроллер].pre.php <- Расширение перед контроллером
│ │ │ └─ [контроллер].post.php <- Расширение после контроллером
│ │ ├─ common/ <- Общие контроллеры
│ │ │ ├─ [ваш_контроллер].php
│ │ │ ├─ [контроллер].pre.php
│ │ │ └─ [контроллер].post.php
│ │ └─ frontend/ <- Контроллеры витрины
│ │ ├─ [ваш_контроллер].php
│ │ ├─ [контроллер].pre.php
│ │ └─ [контроллер].post.php
│ ├─ database/ <- MySQL файлы
│ ├─ schemas/ <- Расширение PHP схем
│ │ └─ [папка_схем]/ <- Папка схемы (тип схемы)
│ │ └─ [название_схемы].post.php <- Расширение после схемы
│ ├─ Tygh/ <- Классы
│ │ ├─ Shippings/ <- Доставки
│ │ │ └─ Services/ <- Службы доставки
│ │ │ └─ [СлужбаДоставки].php <- Ваша служба доставки
│ │ └─ [ВашКласс].php <- Любой новый класс
│ ├─ addon.xml <- Главный файл модуля
│ ├─ config.php <- Константы
│ ├─ func.php <- Функции и расширения хуков
│ └─ init.php <- Подключение хуков
├─ design/
│ ├ backend/ <- Шаблоны панели администратора
│ │ ├ css/ <- Стили панели администратора
│ │ │ └ addons/
│ │ │ └ [id_модуля]/ <- Ваш модуль
│ │ │ ├ styles.css <- Ваши стили
│ │ │ └ styles.less
│ │ ├ mail/ <- Email и шаблоны счетов
│ │ │ └ templates/
│ │ │ └ addons/ <- Модули и аддоны
│ │ │ └ [id_модуля]/ <- Папка модуля
│ │ │ ├ hooks/ <- Подключение к хукам
│ │ │ │ └ [тип_хука]/ <- Папка хука
│ │ │ │ ├ [название_хука].pre.tpl <- Код перед хуком
│ │ │ │ ├ [название_хука].post.tpl <- Код после хука
│ │ │ │ └ [название_хука].override.tpl <- Переписать хук
│ │ │ ├ [шаблон_письма]_subj.tpl/
│ │ │ └ [шаблон_письма].tpl/
│ │ ├ media/ <- Статические данные
│ │ │ └ images/
│ │ │ └ addons/
│ │ │ └ [id_модуля]/ <- Изображения вашего модуля
│ │ │ ├ изображение_1.jpg/
│ │ │ └ изображение_2.png/
│ │ └ templates/ <- Шаблоны
│ │ └ addons/
│ │ └ [id_модуля]/
│ │ ├ hooks/ <- Подключение к хукам
│ │ │ ├ index/ <- Папка хука
│ │ │ │ ├ scripts.post.tpl <- Хук подключения вашего скрипта
│ │ │ │ └ styles.post.tpl <- Хук подключения вашего стиля
│ │ │ └ [тип_хука]/
│ │ │ ├ [название_хука].pre.tpl <- Ваш код перед хуком
│ │ │ ├ [название_хука].post.tpl <- Ваш код после хука
│ │ │ └ [название_хука].override.tpl <- Ваш код перепишет хук
│ │ ├ views/ <- Собственная страница
│ │ │ └ [ваш_контроллер]/ <- Контроллер
│ │ │ └ [режим_контроллера].tpl <- Режим (mode) контроллера
│ │ └ overrides/ <- Переписать любой шаблон
│ │ └ ... <- Создайте нужную структуру
│ │
│ └ themes/ <- Дизайн витрины — темы
│ └ [название_темы]/ <- Название темы
│ ├ css/ <- Стили
│ │ └ addons/
│ │ └ [id_модуля]/
│ │ ├ styles.css <- Ваш стиль CSS
│ │ └ styles.less <- Ваш стиль LESS
│ ├ mail/ <- Шаблоны писем и счетов
│ │ └ templates/
│ │ └ addons/
│ │ └ [id_модуля]/
│ │ ├ hooks/ <- Раширение через хуки
│ │ │ └ [тип_хука]/
│ │ │ ├ [название_хука].pre.tpl
│ │ │ ├ [название_хука].post.tpl
│ │ │ └ [название_хука].override.tpl
│ │ ├ [шаблон_письма]_subj.tpl/ <- Шаблон темы письма
│ │ └ [шаблон_письма].tpl/ <- Шаблон письма
│ ├ media/ <- Статические данные
│ │ └ images/
│ │ └ addons/ <- Изображения модуля
│ │ └ [id_модуля]/
│ │ ├ изображение_1.jpg/
│ │ └ изображение_2.png/
│ └ templates/ <- Шаблоны
│ └ addons/
│ └ [id_модуля]/ <- Ваш модуль
│ ├ hooks/ <- Расширение хуков
│ │ ├ index/ <- Папка хука
│ │ │ ├ scripts.post.tpl <- Хук подключения вашего скрипта
│ │ │ └ styles.post.tpl <- Хук подключения вашего стиля
│ │ └ [тип_хука]/ <- Папка хука
│ │ ├ [название_хука].pre.tpl <- Ваш код перед хуком
│ │ ├ [название_хука].post.tpl <- Ваш код после хука
│ │ └ [название_хука].override.tpl <- Перезаписать хук целиком
│ ├ views/ <- Новая страница
│ │ └ [ваш_контроллер]/ <- Папка вашего контроллера
│ │ └ [режим_контроллера].tpl <- Шаблон для режима контроллера
│ └ overrides/ <- Переписать любой шаблон темы
│ └ ... <- Файл который нужно переписать
│
├ js/ <- Скрипты модуля
│ └ addons/
│ └ [id_модуля]/
│ └ func.js/
└ var/ <- Хранилище шаблонов модуля
└ themes_repository/ <- Используется при установке
└ [название_темы]/
└ ...
```
Может показаться, что модуль имеет логичную иерархию внутри своей структуры, но, иногда, следуя по документации, случаются баги, которые не должны были появиться. Например: был у меня кейс, когда обращаясь к контроллеру через AJAX функцию, встроенную в класс CMS JS упорно не хотела работать с моим контроллером, хотя сделано всё было четко по документации. Поискав информацию и обратившись к комьюнити, состоящем, в основном из 3-4 активных завсегдатаев-разработчиков, я понял, что даже сами разработчики этой платформы не могут ответить на вопрос о том, почему их функция ведет себя некорректно.
Модуль в результате был закончен, но в обход документации, что я считаю своим упущением и продолжаю искать пути решения данной проблемы, с надеждой выпустить апдейт в соответствии с документацией.
То что мертво - труп, но потыкать палкой нужно
----------------------------------------------
Второй задачей, которую поставило руководство, являлась оптимизация сайтов этого магазина. Я взялся за нее без энтузиазма, понимая, что это мертворожденное существо, и мы с коллегой путем мучений и отключения всего того зоопарка модулей, что были установлены до моего появления со словами: "А че бы нет?!" - добились улучшенных показателей Google и в LightHouse, но прироста, в 20 единиц на одном сайте и 10 на другом, было не достаточно. Тогда я полез смотреть БД более детально. Поняв, что БД у данной CMS - набор несвязанных друг с другом таблиц, я понял, что все взаимодействия с базой и связки данных проходят через PHP, что, как я считаю, неправильно. Почему сделано именно так? - всё просто: CMS создавалась в 2003-2004 годах, и в качестве движка для СУБД использовался MyISAM.
MyISAM - сам по себе, довольно медленный движок и он не рассчитан на 50 000 (!) товаров (о количестве поговорим позже). Более того связывание таблиц этом движке реализовано не так хорошо как, скажем, в том же InnoDB. Из-за этого сервер начинает очень страдать при одновременном обращении 500 - 1000 пользователей.
Теперь поговорим о количестве товаров. Откуда 50 000 спросите вы? "Потому что" - отвечу я. Дело в том, что одну из витрин отдали на SEO какому то подозрительному фрилансеру из Беларуси. Странность его суждений заключается в разнообразных уловках и ухищрениях. Например: для улучшения видимости сайта он просил коллегу создать несуществующую номенклатуру и каждый день подгружать несуществующий товар. Аргументировал он это тем, что пользователи будут искать товары из этого несуществующего списка и попадать к нам на сайт, на этот товар. Понятно, что пользователь уйдет сразу же после этого, так как товара в наличии нет и никогда не было и не будет. Сайт ни капельки не продвигается, а руководство с упорством продолжает считать мнение данного "спеца" авторитетней мнения штатного программиста и контент-менеджера.
Такое количество номенклатуры - аномально и это, в свою очередь, также подвергает оба сайта зависаниям, лагам и другим неприятным вещам.
Нужна скрепка? Плати 100 баксов
-------------------------------
Последняя проблема, которую я освещу в данной статье - это плата за любое мелкое допиливание этого "зомби". Хочешь стандартный функционал cron в панеле админа - плати. Подключить метрику не через утиную гуску, а так, чтобы она не нагружала клиент - плати. И другие малозначимые, но иногда важные изменения - стоят денег. Ценник, как правило, начинается от 100$ за модуль. Да, разработчикам, как и мне, хочется кушац, но у меня сложилось впечатление, что CMS и её стандартные модули специально не доведены до нормального состояния. А так как структуру всех классов и методов знают только создатели данной CMS, то они и являются, по сути, монополистами на рынке, так как любой фрилансер или штатный проггер, не сможет нормально сделать модуль с первого раза, используя недописанную и костыльную документацию, что предлагается на данный момент.
Заключение
----------
Я не верю, что ситуация с данной CMS когда нибудь изменится и мне, действительно, жаль тех, кто имея огромную номенклатурную базу сидит на ней и платит за все доделки баснословные деньги. Но хочется верить, что, хотя бы в моем магазине, я сумею побороть некоторые её недостатки.
Надеюсь, статья Вам была интересна. Я буду писать еще о своих изысканиях в этой CMS или о разработке модулей для неё. | https://habr.com/ru/post/558778/ | null | ru | null |
# Russian AI Cup 2017 — история второго места
Привет! В этой статье я хотела бы рассказать вам о своем участии в соревновании по написанию игровых ботов [Russian AI Cup](http://russianaicup.ru/) CodeWars, на котором мне удалось занять 2 место, и что и как для этого было сделано.
### Анонс и первые впечатления
Должна признаться, что опубликованный [анонс](https://habrahabr.ru/company/mailru/blog/340540/) соревнования меня не очень порадовал. Ограничение на количество действий, выделение рамкой, автоматическая стрельба юнитов… Все выглядело так, что не будет ни поиска путей, ни прицельной стрельбы и уж точно никакого микроконтроля. А ведь микроконтроль — это то, что так восхищало меня в играх топов соревнования прошлого года. Сама я тогда больших успехов в этой области не достигла, но надеялась наверстать в этом году. Но пропускать такое интересное соревнование, конечно же, было нельзя.
Положительным моментом раннего анонса было то, что другие участники подобрали и выложили в общий доступ [набор](https://github.com/core2duo/RHC-AI) тематических статей о разработке стратегий для RTS. Ну и уже можно было обдумывать принципы управления группами войск.
### Начало работы
Итак, изначально нам были доступны 5 видов войск по 100 единиц: танки — мощный, но медленный юнит, БМП – более мобильный юнит, подходящий для уничтожения авиации, БРЭМ – ремонтные машины, беззащитные к атакам врага, вертолеты – мощное оружие против танков, но крайне уязвимые перед истребителями и истребители – быстрые, но опасные только для вертолетов. Среди доступных действий было выделение, снятие выделения, добавление в группу и исключение из нее, а также вращения и сжатие. Для стратегии было доступно лишь 12 действий в 60 тиков.
После открытия соревнования я несколько дней не могла приступить к разработке стратегии, так как не очень было понятно, с какой стороны к ней подступиться.
Чтобы хоть как-то начать, я слегка модифицировала быстрый старт (Smart guy), предоставленный организаторами. Стартовая стратегия представляла собой следующее: раз в 300 тиков для каждого вида техники получали центр формации по усредненным координатам всех юнитов, выбирался один предпочитаемый тип техники-цели, группа выделялась и получала вектор направления в сторону цели. БРЭМ направлялись просто в центр карты.
Я расширила список целей для каждого вида техники; при отсутствии целей добавила убегание от формации опасного типа. Выглядела эта первая версия очень уныло. Группы растягивались, сталкивались друг с другом, застревали, части групп отрывались и уходили куда-то к горизонту. Вражеские группы тоже иногда разрывались и мои юниты пытались атаковать пустое пространство между ними. Однако стоило лишь попробовать начать улучшать стратегию, как стали появляться новые идеи ее развития.
К этому моменту в песочнице были [популярны](https://habrahabr.ru/users/sat2707/posts/) стратегии вида «торнадо» — техника всех видов стягивалась к одному центру и закручивалась для уплотнения. А затем появилась более совершенная техника, которую участники окрестили «бутербродом» — войска уже смешивались не абы как, а чередующимися ровными рядами. В результате получался очень мощный строй, так как разнородная техника прикрывала друг друга, а БРЭМ устраняла повреждения. Такие «бутерброды» в считанные тики поглощали «торнадо», не говоря уж о моих бестолковых однородных отрядах. Такой поворот меня весьма огорчил. Сражаться с «бутербродами» отдельными отрядами казалось было бесполезно, а играть в «пятнашки» со стартовым случайным расположением отрядов и хардкодить формирование «бутерброда» мне совсем не хотелось. В результате я снова на пару дней забросила стратегию.
И тут пришли хорошие новости — так как организаторов тоже не устраивало засилье «бутербродов», они добавили возможность ядерного удара, которым можно было поразить сразу большое количество юнитов, находясь при этом на относительно безопасном расстоянии. Это меня вдохновило, и «зачатки» бутерброда были с облегчением удалены. Ирония, правда, состоит в том, что тактический ядерный удар в конечном итоге оказался скорее на руку «бутербродам», а не их противникам, но понятно это стало не сразу.
Так как я планировала управлять группами войск, необходимо было качественно их обнаруживать, для чего применялась [кластеризация](http://scikit-learn.org/stable/modules/clustering.html). Наиболее подходящим мне показался [DBSCAN](http://scikit-learn.org/stable/modules/clustering.html#dbscan), так как он распознает произвольное количество кластеров любой формы. Разбивка на группы проводилась для каждого рода техники отдельно следующим образом:
* Кластеризация с параметрами eps=17 и minPts=5 (минимальное расстояние на котором точки считаются соседями и минимальное количество соседей для точки, при котором точка может быть включена в кластер).
* В результате работы кластеризации получался набор кластеров, а также шум — точки, которые не получилось включить в кластер по заданным параметрам. Шум кластеризировался еще раз, но с minPts=2 для обнаружения мелких групп.
* После второго прохода также оставался шум — единичные юниты. Их я уже просто добавляла каждого в свой кластер.
* Найденные кластеры помещались в группы — объекты, которые по мере добавления единиц техники вычисляли собственный центр массы, а также координаты прямоугольника, в который была вписана группа для ее выделения.
Сразу отмечу, что я никогда не пользовалась назначением групп, только выделением рамкой.
Каждый расчетный тик менеджер групп сравнивал полученные после кластеризации группы с группами, полученными на предыдущих шагах и на основе положения и хотя бы частичного совпадения техники в группах, устанавливал соответствие между старой и новой версией, что позволяло отслеживать «историю» группы.
*Кластеры, раскрашенные в разные цвета*
На мой взгляд, управление группами получилось довольно удачным. Группы могли сколько угодно рваться или объединяться — новые формации тут же получали управление без каких-либо дополнительных усилий с моей стороны. Даже коллизии разнородных групп через какое-то время успешно разрешались самостоятельно.
Теперь можно было прикрутить группы к стартовой стратегии. Изначально управление техникой выглядело так:
```
delayedMoves.add(move -> {
move.setAction(ActionType.CLEAR_AND_SELECT);
move.setRight(world.getWidth());
move.setBottom(world.getHeight());
move.setVehicleType(vehicleType);
});
delayedMoves.add(move -> {
move.setAction(ActionType.MOVE);
move.setX(targetX - x);
move.setY(targetY - y);
});
```
Было это не очень удобно, поэтому пришлось разработать систему работы с действиями. Создание команды на движение у меня получилось [таким](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/Action.java#L62):
```
Action.moveTo(group, targetX, targetY);
```
где объект Action содержал в себе сгруппированные действия, которых на тот момент для всех случаев было ровно два (выделение и собственно само действие). При этом в качестве параметров использовались уже обычные координаты на карте вместо вектора движения.
Работой с действиями занимался [ActionManager](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/ActionManager.java). На раннем этапе он представлял собой очередь с приоритетом, куда каждый тик, с доступным действием помещались команды для каждой из групп. Менеджер удалял команды исчезнувших групп, заменял старые цели в очереди на более актуальные. Также для каждой группы хранилось последнее выполненное действие и, если вновь поступающее действие имело схожий угол направления и близкую цель со старым действием, новое действие в очередь не добавлялось. Предполагалось, что это поможет сэкономить доступные ходы. Этот менеджер вышел довольно примитивным; сложные цепочки команд или отложенные действия он выполнять не умел. Поэтому в дальнейшем более сложные действия приходилось обрабатывать на более высоком уровне.
Итак, у меня было 1100 строк кода, кластеризация, группы, удобное управление, менеджеры и… логика Smart guy и совершенное непонимание, что со всем этим делать.
### Потенциальные поля
Изначально я предполагала, что действия моих групп я буду определять как векторы влияний — например для определения конечного направления движения понадобилось бы сложить вектор к группе, которую планируется уничтожить и векторы «отталкивания» от своих групп и опасных вражеских групп. Но мне это показалось слишком сложным и я решила попробовать модные потенциальные поля (ПП).
Для расчета зарядов потенциальных полей нужно было понимать, какие группы опасны, а на какие стоит напасть. Например, пяти вертолетам стоит бояться трех истребителей, но при этом 25 вертолетов, уничтожат один истребитель, получив минимальный ущерб. Исход битвы можно было бы симулировать, но мне хотелось для начала сделать какой-то простой расчет. Исписав несколько листов и успев отчаяться, я наконец решила пересмотреть прочитанную ранее литературу.
Нужная информация нашлась в [этой диссертации](http://nova.wolfwork.com/papers/Uriarte-phdthesis.pdf). В этой работе в числе прочего рассматриваются различные модели предсказания результатов исхода битв в RTS. В эксперименте авторов лучшие результаты показала Target-Selection Lanchester’s Square Law Model, давшая 94.45%± 0.34 верных предсказаний. Такой результат меня вполне устраивал, к тому же расчеты примерно совпадали с моей «бумажной» симуляцией. По сравнению с реальной игровой ситуацией модель была упрощением, так как не учитывала плотности формации, дальности стрельбы, кулдаунов и т. п., но я посчитала, что на начальном этапе этим можно пренебречь. На самом же деле этот [расчет](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/TSLanchester.java#L9) так остался основным и неизменным до конца соревнования. Думаю, что эта удачная находка является одним из ключевых элементов моей стратегии.
Информации о потенциальных полях в сети не очень много, еще меньше было мною прочитано, так что у меня получилась какое-то свое исполнение полей, о котором я попробую рассказать поподробнее.
В статьях о потенциальных полях обычно изображаются поля, рассчитанные на все игровое поле. Похожие скриншоты демонстрировали и некоторые участники соревнования. Но, так как на карте практически не было статических объектов (погоду и местность я не учитывала), которые можно было бы рассчитывать заранее, а ситуация на карте была довольно динамичной, я посчитала, что имеет смысл рассчитывать поле для движения в самой ближайшей перспективе, то есть в непосредственной близости от расчетной группы. Расчет влияния на все поле использовался только для визуализации при отладке.
*расчетное поле истребителей, притягиваемых вражескими вертолетами справа (красный сильнее желтого)*
Для расчета наилучшего направления движения группы использовалась сетка размерностью 16х16. Насколько близко просчитывать влияние? С одной стороны, для экономии действий хотелось, чтобы выбиралось как можно более дальняя точка назначения, но с другой, если выбирать клетку с наибольшим потенциалом на относительно дальнем расстоянии, то возрастает вероятность того, что путь к лучшей клетке будет проходить через вредные для нас клетки. Я решила рассчитывать значения зарядов на [три клетки](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L80) в каждую сторону от центра группы. Заряд для вражеской группы задавался расчетной разностью убитых юнитов, так что группа, при сражении с которой потери моих войск рассчитывались большими, чем у противника, генерировала отрицательный заряд.
Убывание заряда считалось по закону:
где *score* — рассчитанная разность очков; *dist* — расстояние в размерности сетки. При этом, положительный заряд оказывал влияние на любой дистанции, а отрицательный заряд имел ограниченное дистанцией атаки и радиусом групп влияние. Отрицательные поля ограниченного влияния также генерировали края карты и собственные группы для избежания коллизий. Изначально значения зарядов из всех источников суммировались.
Эта версия имела массу недостатков — группы слипались (из-за чего я отказалась от деления групп на 4 части, как я думала временно), размазывались по стенам (границам игрового мира) или наоборот так боялись стен, что не могли добить одиночных вражеских юнитов. Но, наконец-то, за 4 дня до начала первого раунда, у меня получилась стратегия, которая стабильно побеждала Smart guy!
### Ядерный удар
За оставшееся до раунда время нужно было добавить бомбу, которая выглядела достаточно эффективным и эффектным оружием.
[Удар](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/Bombing.java#L73) первоначально был сделан довольно просто: вражеские группы сортировались по размеру (для этого пришлось сделать еще одну кластеризацию, без различия типов), и для каждой группы, размер которой был не менее четверти от самой крупной группы, искалась моя группа, способная нанести удар в центр вражеской группы так, чтобы в зону удара попадало только минимальное количество моих юнитов. Ударная группа останавливалась и до момента удара бомбы контролировалось, чтобы группа не получала никаких других команд и оставалась неподвижной.
Для [уклонения](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/Evasion.java#L14) от вражеского удара выделялись все юниты, попадающие в зону удара и для них делался SCALE, то есть все юниты направлялись в сторону от центра удара. Так как это действие выполнялось вне групп и было не очень понятно какие группы будут затронуты, и как расширение будет влиять на их состав, на время уклонения никакие другие действия ни для кого не выполнялись. Длительность «распрыга» подсчитывалась с учетом кулдауна и после удара выполнялось стягивание с той же продолжительностью.
Работало не идеально так как довольно часто мешал кулдаун на действия, а также многочисленные баги, которые периодически приходилось править почти до конца соревнования.
За 40 минут до начала первого раунда я обнаружила неприятный баг: к моменту, когда очередь подходила к действию выделения, сохраненные координаты группы уже были неактуальными, что приводило к разрывам группы. Пришлось экстренно исправлять и в панике отправлять последнюю посылку за 3 минуты до начала раунда.
Не смотря на то, что к началу 1 раунда бот показывал стабильный рост в песочнице, я была не очень в нем уверена и серьезно опасалась, что во второй раунд мне не пройти. Тем не менее, в раунде бот показал себя хорошо, получив 92.9% побед и заняв 35 место. Не последнюю роль тут сыграл рандом, так как топовых соперников почти не было, но все же я уверилась, что двигаюсь в правильном направлении.
**gif — типичная игра первого раунда**
*группы атакуют «торнадо»*
### Подготовка ко 2 раунду
Из-за различий скоростей на местности группы при движении растягивались и разрывались. Чтобы это исправить, я, как и многие, добавила периодическое [сжатие](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/MyStrategy.java#L182). Также поправила неприятное поведение — один единственный оторвавшийся от группы юнит начинал её сильно отталкивать, сбивая с нужного пути. Решив, что так как от единичных юнитов мало пользы, то лучше для групп одного типа вместо отталкивания сделать притягивание для случая, если одна из групп меньше 10 юнитов либо же в два раза меньше другой. Заряд был равен численности большей группы. Теперь потеряшки быстро приклеивались к основной группе.
Расчет зарядов от центров групп работал не очень хорошо, так как группы могли быть очень разных форм, а мне хотелось получить большую точность, чтобы лучше искать слабые места в «торнадо» и «бутербродах». Для того, чтобы привести поле к форме отряда, группа дополнительно разбивалась на [ячейки](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/Group.java#L87) 16х16. Теперь заряд [рассчитывался](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L94) не от центра, а от ближайшей ячейки группы.
Испробовала также идею генерировать заряды от каждой ячейки вражеской комбинированной группы, рассчитывая итог боя относительно части юнитов моей группы, находящихся в соразмерной ячейке, но решение оказалось совершенно нежизнеспособным и я к нему больше не возвращалась.
Заметила, что иногда в борьбе с «бутербродами» группы оценивают ситуацию слишком оптимистично. Например, вертолеты привлекала легкая и богатая добыча в виде БРЭМ и танков, которая перевешивала негативное влияние от замешанных там же БМП. В итоге довольно часто мои группы бесстрашно бросались прямо в центр «бутерброда», существенно увеличивая счет соперника. Предположу, что обычно такие проблемы решаются балансом коэффициентов, но я сделала проще: если ячейка испытывала только положительные влияния от групп противника, то учитывалось только максимальное из них, а при наличии отрицательного влияния всегда брался минимум. В результате мои группы перестали «сгорать», но это не слишком помогло, так как теперь они кружили вокруг плотного «бутерброда», не находя в нем слабых мест, пока он методично бомбил мои отряды. В отличие от «бутерброда» они не имели возможности лечиться, так как мои БРЭМ не участвовали в боях, а обычно отсиживались в углу. «Бутерброду» же бомбы не причиняли много вреда, так как, во-первых, он мог вылечиться, а во-вторых, мой удар всегда бил в центр группы так, что за пару ударов он прожигал в ней дыру и продолжал бить в ту же точку, не нанося противнику повреждений. Пришлось срочно дорабатывать удар для поиска точки с максимальным повреждением, снова используя учет распределения юнитов в группе по ячейкам. Но борьбе с хорошо сделанными «бутербродами» это не сильно помогло. Я пробовала держать войска дальше, чтобы уберечь от бомб, пробовала подводить ближе, для более агрессивных атак, но все равно игроки с плотными формациями такие как [azt-yur](http://russianaicup.ru/profile/azt-yur) и [Savidiy](http://russianaicup.ru/profile/Savidiy) меня в основном побеждали. В конце-концов, посмотрев, что даже уже ставший к тому моменту лидером, [GreenTea](http://russianaicup.ru/profile/GreenTea) иногда проигрывает игры без зданий плотным формациям, я решила бросить борьбу с «бутербродами» и заняться играми по правилам второго раунда.
*Картина рассчитанных потенциалов для группы танков (слева вверху). Негативные поля (синие) перекрывают позитивные (красные)*
Для захвата зданий я просто добавила в расчет полей притяжение к зданиям. Сразу стало ясно, что заряды привязанные к очкам себя не оправдывают, так как гораздо выгоднее получить 100 очков, просто немного постояв на здании, чем гоняться по всей карте за группой противника, рискуя потерять свои войска. Поэтому фабрике назначался заряд 250, а контрольному центру — 150 очков. Также, чтобы сделать здания еще более привлекательными, затухание поля было сделано более мягким — points \* (Math.pow(0.9, dist)). Распределение зданий между группами было сделано самым примитивным образом — если в некотором радиусе здания находилась дружественная группа, более близкая к цели, то это здание исключалось из целей текущей группы. Но уже такой простой захват зданий даже без строительства давал отличный перевес по очкам в играх с «бутербродами» которые были медлительны и неповоротливы и не могли быстро захватывать здания.
Постепенно я отказывалась от сложения зарядов от разных источников. Благодаря этому легко удалось разрешить такие проблемы как коллизии групп, отталкивающие поля которых поглощались сильным полем фабрики, попадание под атаку опасных групп при попытке захвата фабрик; зависания в центре ничего, где просто «удачно» сложились поля и т.п. Вместо суммы зарядов у меня выбирался наибольший (или наименьший, если клетка испытывала влияние отрицательного заряда).
Для первых экспериментов строительства новой техники, я запустила строительство БМП группами по 50 на всех фабриках. Результаты первых тестов меня настолько впечатлили, что я сразу же выложила эту недоделку в песочницу. Помните, я писала про притяжение к своим? Так вот, благодаря ему, группы начинали сливаться, и чем больше становилась группа, тем сильнее она притягивала. В результате у меня вырастал какой-то адский краб из БМП, уничтожающий все на своем пути.
Но конечно гигантские крабы мне были не нужны, а нужны были мобильные группы, поэтому притяжение «для своих» я все же подрезала. Строительство тоже должно было быть более разумным, учитывающим ситуацию на поле.
Строительство было реализовано следующей логикой:
В начале каждого хода формировался «[список заказов](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/FacilityManager.java#L49)» — типы техники, которые требовалось построить. Например:
* строить истребители, если их осталось меньше 10;
* если у соперника заметно больше танков, то строить либо вертолеты, если у противника нет истребителей, либо тоже танки;
* в любых непонятных случаях строить БМП;
Далее каждая из фабрик получая этот список заказов «[решала](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/FacilityManager.java#L129)», готова ли она принять заказ, проверяя завершенность текущего строительства и наличие опасностей вокруг. Также менеджер строительства [следил](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/FacilityManager.java#L29) за строящимися группами и помечал их таким образом, чтобы они не пытались покинуть фабрику раньше, чем группа достигнет заданного размера.
С этими изменениями бот уже уверенно держался в топ-10, так что можно было даже передохнуть пару дней перед раундом. Во втором раунде бот показал хороший результат, не проиграв ни одного боя из 59.
### Подготовка к финалу и финал
В играх финального типа добавилось новое условие — туман войны. Что с ним делать было не очень ясно, поэтому я сосредоточилась на исправлении давно известных проблем. Например, мне хотелось сделать уклонение от бомбы, а также ядерный удар более эффективными, не зависящими от лимита действий. Для этого я сделала подсчет использованных действий и, если за 60 тиков до возможного удара лимит действий был меньше, чем нужное количество для текущего действия плюс действия на ядерный удар (уклонение от удара), действие откладывалась.
После этой доработки бот стал падать по таймауту. Кластеризация у меня выполнялась только при наличии доступных ходов, а теперь ходы были доступны гораздо чаще. Мелкими оптимизациями достичь ускорения почти не удалось, а делать кластеризацию реже мне не хотелось (по правде сказать, мне хотелось делать ее чаще). Решение оказалось очень простым. Так как группы формируются и расформировываются не так уж часто, то кластеризацию я оставила раз в 5 тиков, а в остальное время заменила ее простым [обновлением](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/GroupManager.java#L26) списка транспорта.
В процессе этих доработок я заметила, что действия по группам выполняются гораздо чаще, чем по идее должны были. Оказалось, что экономия действий не работала наверное со времен добавления ПП. После исправлений танки стали получать действия раз в 250 тиков и более. Заодно для экономии расчетное поле ПП было увеличено с 3 до 4 клеток.
Только на финишной прямой у меня дошли руки работы с авиацией. Все это время вертолеты у меня гибли в самом начале боя, что было очень плохо, так как сохраненные вертолеты иногда могли решить исход всей игры. Чтобы спасти вертолеты на поле добавлялся сильный [заряд](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L386), находящийся в точке за ближайшей к вертолетам группой БМП. Благодаря этому вертолеты успешно прятались за БМП от противника «бегая» вокруг них. В дополнение к этому [сделала](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L422), чтобы приоритетной целью для вертолетов были танки (а не БРЭМ), а для истребителей — вертолеты (а не истребители). Так как на старте игр в тумане авиация не имела ударных целей, истребители направлялись сопровождать танки, а вертолеты — БМП.
**gif — вертолеты прячутся от истребителей за группой БМП**
*Вертолеты — группа сверху; БМП — желтая группа в центре; синие вражеские истребители внизу*
Также дорабатывалась работа с фабриками. Например, при захвате теперь [учитывалось](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L327), может ли группа-захватчик справиться с вражескими группами поблизости; [добавила](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/PotentialFields.java#L372) притяжения своим фабрикам, частично захваченными врагом. Сделала размер строящихся групп меньше, а также [зависящим](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/FacilityManager.java#L131) от ситуации на поле. Строительство воздушных юнитов теперь могло [прекращаться](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/FacilityManager.java#L154) досрочно, если фабрике грозила опасность.
За два дня до финала я обнаружила ужасную и глупую ошибку — оказывается, при ограничении действий, я перепутала кулдаун на бросок бомбы с общим кулдауном на действия. Из-за этого вместо разрешенных 12 действий у меня всегда использовалось только 7. Как мне кажется, после исправления этой ошибки игра бота заметно улучшилась.
В последнюю очередь перед финалом я добавила [подсчет](https://github.com/Oreshnik/CodeWars/blob/master/src/main/java/VehiclesCounter.java) вражеской техники, информация о которой из-за тумана теперь была недоступна.
Учитывать новые юниты было довольно просто — надо было всего лишь следить за типом и прогрессом строительства на фабрике. А вот учитывать погибших юнитов было гораздо сложнее. Проблема заключалась в том, что и для убитых, и для ушедших в туман юнитов приходила совершенно одинаковая информация с durability = 0. Для того, чтобы понять, мог ли юнит погибнуть, я проверяла, были ли в некотором радиусе способные нанести урон группы, и были ли в этих группах юниты, находящиеся в примерном радиусе удара. Также, если на прошлом тике был выполнен ядерный удар, проверялось, был ли потенциальный погибший в его радиусе. В результате вышел довольно неплохой учет, например, в одной из игр на тике 10000 рассчитанное и реальное количество были такими:
ARRV: 20 FIGHTER: 32 HELICOPTER: 3 IFV: 346 TANK: 99
ARRV: 19 FIGHTER: 32 HELICOPTER: 1 IFV: 327 TANK: 99
Некоторое расхождение возможно объясняется тем, что часть юнитов уходили в туман и гибли от бомбы уже там. Благодаря подсчету удалось использовать все адаптивные настройки строительства, сделанные ранее.
Накануне финала бот вошел в первую тройку в песочнице. При этом сильно проигрывал [GreenTea](http://russianaicup.ru/profile/GreenTea), [Leos](http://russianaicup.ru/profile/Leos), [mixei4](http://russianaicup.ru/profile/mixei4), нестабильно играл с [tyamgin](http://russianaicup.ru/profile/tyamgin), [Adler](http://russianaicup.ru/profile/Adler) и [Milanin](http://russianaicup.ru/profile/Milanin). Поэтому, хотя очевидно, бот и претендовал на место в 10, на сильно большее я не рассчитывала. Однако, после первой половины финала бот занял 4 место, так что появился некоторый стимул по его улучшению в перерыве. Некоторое время я сомневалась, ведь при равенстве очков преимущество имеет тот, кто отправил стратегию раньше, а очки ботов на местах 2-6 были очень близкими. Но, так как при просмотре игр были обнаружены явные ошибки и неоптимальности, решено было изменения все же внести.
Помимо исправления мелких багов было сделано следующее:
* истребители были выведены вперед танков, а вертолеты — за БМП, так как иначе первые ядерные удары получали обе группы
* так как я заметила, что мои группы часто бросали фабрики беззащитными перед приближающимся к фабрике противником, заряд для вражеских групп, угрожающих моим зданиям, был увеличен в 10 раз. Это заставило мои группы оборонять свои здания чаще.
* увеличила необходимое количество наземной техники, в случае отсутствия которой строительство авиации было запрещено со 100 до 200
* повысила приоритет строительству танков — если раньше они начинали строиться при 20% превышении их количества у соперника, то теперь достаточно было любого превышения
* кроме этого стало ясно, что увеличение размера поля было ошибкой — из-за этого группы чаще стали страдать от коллизий, поэтому для наземных юнитов поле было снова уменьшено до 3.
Еще мне очень хотелось сделать захват фабрик более оптимальным, так как в некоторых играх на этом я очевидно теряла преимущество. Но делать я это пыталась уже в глубокой ночи и внятного решения получить не удалось.
Возможно благодаря сделанным правкам, а может быть игры были для меня более удачными, но во второй части финала мой бот, хоть и с небольшим отрывом, но вышел на второе место.
Не смотря на большой объем времени, затраченный на написание бота, не все задуманное удалось реализовать в коде. Так, мне бы хотелось сделать захват фабрик более разумным, уметь нападать двумя группами на одну цель одновременно, угадывать местоположение отрядов, скрытых в тумане и т. д.
Спасибо, что дочитали до конца. Как видите, история моего бота показывает, что даже относительно простые подходы могут быть довольно эффективными. До встречи на Russian AI Cup в 2018 году! Приходите, будет интересно! | https://habr.com/ru/post/345858/ | null | ru | null |
# Я создал принтер чеков для issues в GitHub
У меня есть много [хобби-проектов](https://github.com/aschmelyun?tab=repositories) в GitHub. Некоторые из них довольно популярны, поэтому к ним время от времени постят issues. Проблема в том, что они теряются в куче моих электронных писем или я забываю пройтись по своим репозиториям и добавить новые пункты в список дел.
Иногда я записывал новые issues на стикеры, когда видел уведомления, но всегда хотел найти предлог, чтобы упростить этот процесс. Однажды в кафе я увидел, как принтер чеков выплёвывает заказы, и задался вопросом, можно ли использовать его для печати тикетов каждый раз, когда в один из моих репозиториев добавляют issue.
Спойлер: у меня получилось!
>
>
> Вот зачем я купил принтер чеков: каждый раз, когда в одном из моих репозиториев GitHub появляется новый issue, физический тикет печатается у меня на столе. [pic.twitter.com/g6uYtGP9J7](https://t.co/g6uYtGP9J7) — Andrew Schmelyun (@aschmelyun) [24 марта 2022 года](https://twitter.com/aschmelyun/status/1506960015063625733?ref_src=twsrc%5Etfw)
Давайте разберёмся, что же я использовал для этого и как настроил систему!
Список оборудования
-------------------
Чтобы приступить к работе, мне нужен был термопринтер чеков и способ передачи данных в него. В конечном итоге я использовал следующие комплектующие:
* Epson TM-T88IV;
* Raspberry Pi Zero W;
* Адаптер Micro USB — USB;
* Кабель USB Type-B.
Термопринтер Epson я выбрал потому, что в нём используется набор команд ESC/POS, для которого есть [надёжные библиотеки](https://github.com/search?q=esc%2Fpos) на множестве языков программирования. Плюс эти принтеры довольно часто продают с рук, и мне за вполне умеренную цену удалось найти его на Ebay с набором бумаги для чеков.
Также мне нужно было какое-то оборудование для подключения между Интернетом и принтером, упрощающее передачу данных. Можно было бы подключить принтер к моему PC, но мне хотелось, чтобы это была полностью автономная система, которую можно было бы просто поставить в углу. У меня завалялась старая неиспользуемая [Raspberry Pi Zero W](https://www.raspberrypi.com/products/raspberry-pi-zero-w/), поэтому я выбрал её.
Так как у RPi Zero есть лишь один разъём micro USB, для подключения к принтеру чеков я использую адаптер и кабель USB Type-B.
Передача данных в принтер
-------------------------
Итак, мы подключили принтер, Raspberry Pi готова к работе, но нам нужно как-то передавать данные *в* принтер *из* Raspberry Pi. Это легко можно сделать с помощью Node или Python, но поскольку я PHP-разработчик и мне нравится преодолевать ограничения языка, выберем его. К счастью, существует [довольно качественная библиотека](https://github.com/mike42/escpos-php) для работы с командами ESC/POS на PHP.
Однако прежде чем писать код, мне нужно убедиться, что принтер доступен для создаваемой мной программы. Так как я использую Ubuntu в Raspberry Pi, доступ можно получить через `/dev/usb/lp0` (или другой lp#). Но для начала, возможно, придётся немного подготовиться.
Сначала я открою терминал в устройстве, к которому подключён принтер (в нашем случае это Raspberry Pi). Выполню команду `lsusb` чтобы получить *Product ID* и *Vendor ID* от соединения с принтером. Она вернёт нечто подобное:
```
Bus 002 Device 001: ID 04b2:0202 Epson TM-T888IV Device Details
```
Далее я создам правило udev, позволяющее пользователям, принадлежащим к группе **dialout**, пользоваться принтером. Создаю файл `/etc/udev/rules.d/99-escpos.rules` и добавляю в него следующее:
```
SUBSYSTEM=="usb", ATTRS{idVendor}=="04b2", ATTRS{idProduct}=="0202", MODE="0664", GROUP="dialout"
```
Не забудем заменить шестнадцатеричные значения на vendor ID и product ID, возвращённые из `lsusb`.
Если пользователи не относятся к группе *dialout*, попытаемся их туда добавить:
```
sudo usermod -a -G dialout pi && sudo usermod -a -G dialout root
```
А в конце нужно перезапустить udev:
```
sudo service udev restart
```
Подключение готово и теперь можно начинать писать код, чтобы его тестировать. Для начала я запрошу нужную библиотеку с помощью Composer:
```
composer require mike42/escpos-php
```
После её установки мне нужно написать код для отправки данных в принтер. Создаём файл `index.php` и добавляем в него следующее:
```
php
require __DIR__ . '/vendor/autoload.php';
use Mike42\Escpos\PrintConnectors\FilePrintConnector;
use Mike42\Escpos\Printer;
$connector = new FilePrintConnector('/dev/usb/lp0');
$printer = new Printer($connector);
$printer-text('Hello, world!');
$printer->feed(2);
$printer->cut();
```
Чтобы запустить его, мне достаточно выполнить скрипт при помощи PHP и root-доступа:
```
sudo php index.php
```
Если всё получилось, то на чеке распечатается **Hello, world!** с двумя пропущенными строками, после чего чек будет отрезан. Всё это работает довольно просто.
Создан connector печати для «файла» `/dev/usb/lp0`, который является USB-адаптером, к которому подключен принтер. Последующие команды принтера (`text()`, `feed()`, `cut()`) потоково передают по этому соединению сырые команды, связанные с соответствующими действиями принтера.
> **Примечание**: если вы получаете ошибку о допуске при отправке на `/dev/usb/lp0` или что-то подобное, то попробуйте выполнить `sudo chmod +777 /dev/usb/lp0`, и проверьте, устранило ли это проблему.
Теперь можно подключиться к GitHub и заполнить чеки реальными данными.
Подключение к GitHub
--------------------
В GitHub можно легко прослушивать события в репозиториях при помощи [webhooks](https://docs.github.com/en/developers/webhooks-and-events/webhooks/about-webhooks). Зайдя на страницу параметров одного из моих репозиториев и перейдя в раздел webhooks, я могу создать хук, который будет выполнять POST на определённый URL при выбранном действии. В данном случае я хочу печатать тикет при создании нового issue, поэтому выбрал раздел «Issues». В качестве типа данных я выбрал JSON, потому что мне нравится с ним работать.
Но прежде чем двигаться дальше, мне нужен URL, на который GitHub мог бы *отправить POST-запрос*. Сначала я подключусь к Raspberry Pi по ssh и запущу локальный PHP-сервер, использовав флаг -S в папке с моим проектом:
```
sudo php -S 127.0.0.1:8000
```
После запуска сервера мне нужен способ получить доступ к этому порту на Raspberry Pi, когда она находится в локальной сети. Я не хочу раскрывать мой домашний IP-адрес или создавать pass-through через роутер. Поэтому я просто воспользовался [ngrok](https://ngrok.com/) для создания туннеля через открытый порт.
```
ngrok http 8000
```
После загрузки я копирую выданный URL https и вставляю его в поле URL для webhook в GitHub, а потом сохраняю webhook. Сразу после сохранения должен отправиться тестовый запрос, ngrok принимает запрос, передаёт его по туннелю на локальный PHP-сервер, и на принтере печатается ещё один **Hello, world!**.
Теперь можно использовать входящий запрос от GitHub для создания тикета.
Готовый код
-----------
Теперь внесём изменения в приведённый выше код. Сначала мне нужно отвергать всё, что не является POST-запросом. Поэтому перед инициализацией FilePrintConnection я добавляю такие строки:
```
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
return 'Error: Expecting POST request';
}
```
А после инициализации FilePrintConnection и Printer я декодирую весь JSON-запрос от GitHub как ассоциативный массив:
```
$data = json_decode(file_get_contents('php://input'), true);
```
Теперь можно использовать предыдущие методы принтера и массив данных с GitHub для создания нужного мне чека! При работе с библиотекой Escpos для форматирования текста требуется **куча** повторяющегося кода. Например, вот как выглядит заголовок issue жирным подчёркнутым текстом вместе с телом, написанным обычным текстом:
```
$printer->setUnderline(true); // start underlined text
$printer->setEmphasis(true); // start bolded text
$printer->text($data['issue']['title']);
$printer->setEmphasis(false); // stop bolded text
$printer->setUnderline(false); // stop underlined text
$printer->text($data['issue']['body']);
```
> Полный код, который я использовал для форматирования тикета в показанном выше твите, можно посмотреть в [репозитории GitHub](https://github.com/aschmelyun/github-receipts).
Теперь чтобы протестировать код, мне достаточно перейти в репозиторий, для которого я настроил webhook, создать новый issue и подождать, пока принтер выдаст тикет.
Завершение и дальнейшие шаги
----------------------------
Итак, что же можно ещё сделать с этой системой? Пока она определённо является лишь доказательством работоспособности идеи, но мы можем **расширить её** в разных направлениях.
Например, в сам тикет можно добавить QR-код с ссылкой на issue в GitHub. Также можно добавить больше подробностей об issue, например, метки и степень опасности.
Кроме того, можно использовать эту концепцию для обработки практически любых данных, поступающих от webhook или через запрос API. Например, для печати тикетов из приложений наподобие Jira и Bugsnag, исключений, выброшенных приложениями в продакшене, или даже повседневных пунктов todo и списков покупок! | https://habr.com/ru/post/675874/ | null | ru | null |
# Хватит делать сайты с бесконечной прокруткойǃ
TL;DR. Хотя бесконечная прокрутка подходит для некоторых случаев, но она может создать проблемы.
Бесконечная прокрутка может быть дезориентирующей, неконтролируемой и вызывать стресс у пользователей.
В этой статье мы объясним, почему нужно прекратить создание сайтов с бесконечной прокруткой. Но для начала рассмотрим краткую историю вопроса.
Краткая история скроллинга
==========================
Чтобы понять, что такое скроллинг, посмотрим на происхождение [слова](https://www.etymonline.com/search?q=scroll).
***scroll (свиток)** (n.): c. 1400, “рулон пергамента или бумаги”*
Свитки первоначально использовали тогда, когда документ становился слишком длинным (например, религиозного содержания). С таким большим количеством контента стало трудно управляться, его трудно читать и переписывать.
Когда в нашу жизнь вошли компьютеры, по-прежнему требовался способ перемещаться по большим фрагментам контента.
Эволюция свитков в компьютерах
==============================
#### 1. Строки (и столбцы)
После появления веба дизайнеры изобрели/изучили множество способов пагинации/прокрутки контента. До интернета мы прокручивали строки на экране.
Горизонтальная прокрутка сделала скроллинг инструментом не только для чтения контента, но и для навигации по экрану.
#### 2. Окна (не операционная система)
Наличие прокрутки подтолкнуло людей к созданию оконного интерфейса. С помощью окон можно одновременно просматривать несколько фрагментов содержимого.
*В Диспетчере программ Windows 3.1 несколько «свитков»*
#### 3. Веб-страницы
Прокрутка решает самую *фундаментальную* проблему при просмотре веб-страниц. Однако она может вызвать много проблем для пользователей и может помешать им. Посмотрим внимательнее.
Варианты навигации по веб-страницам
===================================
Попытаюсь определить, как разработчики и дизайнеры создавали интерфейс для навигации по веб-страницам.
Начнём с некоторых серверных систем пагинации.
Разбивка страниц на основе смещения
-----------------------------------
Cамая известная система пагинации. В этой технике сначала нужно найти, сколько элементов нужно разбить на страницы:
```
-- All posts count
SELECT COUNT(*) AS total FROM posts
```
После этого нужно подсчитать страницы. Предположим, мы показываем `10` элементов на странице:
```
-- First page items
SELECT * FROM posts LIMIT 10
```
И если мы хотим перейти на страницу `3`, то нужно пропустить первые `30` элементов, используя смещение (`OFFSET`):
```
-- Third page items
SELECT * FROM posts LIMIT 10 OFFSET 30
```
Клиенту отправляется информация следующим образом:
```
{
"pagination": {
"items_count": 100,
"current": 3,
"total_pages": 10
},
"items": [...]
}
```
Плюсы и минусы пагинации на основе смещения:
--------------------------------------------
* Хорошо: легко перейти на любую страницу
* Хорошо: более свободный вариант для пользователя
* Плохо: проблемы с производительностью
* Плохо: при изменении данных могут отображаться повторяющиеся элементы
Пагинация по указателю
----------------------
Большие данные затрудняют расчёт таблиц, так как данные постоянно прибывают (подумайте о Twitter). Таким образом, разработчики придумали новые методы разбиения данных на страницы: **по указателям** (cursor).
Каждой строке присваивается уникальный указатель. Не нужно обсчитывать всю таблицу и знать точное число страниц:
```
-- Get extra 1 item to get its cursor.
SELECT * FROM posts ORDER BY id DESC LIMIT 11
```
Предположим, что у каждого сообщения уникальный указатель (ID в данном примере) для разбиения на страницы. Клиент получит следующую информацию:
```
{
"pagination": {
"next": 1234 // extra item's ID (cursor), null if end of data.
},
"items": [...]
}
```
И вы можете запросить следующую страницу с помощью указателя:
```
-- Offsetting records using 1234 cursor
SELECT * FROM posts WHERE id >= 1234 ORDER BY id LIMIT 11
```
Плюсы и минусы пагинации по указателям:
---------------------------------------
* Хорошо: более производительная, нет обсчёта таблицы
* Хорошо: отображение повторяющихся элементов невозможно, если кто-то вставит строку в центр таблицы
* Плохо: невозможно перейти на любую страницу
* Плохо: ограничения для клиента, неизвестно общее количество страниц и номер текущей страницы
Рассмотрим некоторые методы навигации.
Следующий и предыдущий
----------------------
**Действие**: на основе кликов
**Техника**: на основе смещения или по указателям
Она в основном используется для навигации по блогам. Это самая старая версия бесконечной прокрутки. При таком подходе пользователь может не знать, где заканчивается контент.
*Пагинация WordPress*
Нумерация страниц
-----------------
**Действие**: на основе кликов
**Техника**: на основе смещения
По-моему, это наиболее удобный тип навигации. Он использует пагинацию на основе смещения, которая позволяет перейти на нужную страницу, а также одним кликом перейти к концу или началу.
*Примеры нумерации*
Google использует такую навигацию в результатах поиска:
Загрузить ещё
-------------
**Действие**: триггер
**Техника**: на основе указателей, *хотя можно реализовать на основе смещения, но это будет неудобно*
Это один из новейших методов разбиения на страницы, он также использует предыдущую версию бесконечной прокрутки.
*Кнопка «Загрузить ещё»*
В приведённом выше примере пользователь нажимает кнопку «Загрузить ещё» (Load More), чтобы увидеть больше контента.
Бесконечная прокрутка
---------------------
**Действие**: на основе прокрутки
**Техника**: на основе указателей, *хотя можно реализовать на основе смещения, но это будет ОЧЕНЬ неудобно*
Бесконечная прокрутка — новейшая техника пагинации на основе указателей.
> Хью Уильямс утверждает, что [изобрёл бесконечную прокрутку в 2005 году для Microsoft](https://hughewilliams.com/2012/03/06/ideas-and-invention-and-the-story-of-bings-image-search/).
> [Metafizzy](https://github.com/metafizzy/infinite-scroll) разработала open source инструмент, помогающий разработчикам реализовать бесконечную прокрутку.
*Бесконечная прокрутка позволяет прокручивать страницу до бесконечности*
Хватит делать сайты с бесконечной прокруткой!
=============================================
До сих пор мы рассматривали, как сюда попасть. Теперь поговорим, почему здесь так хреново.
Поиск футера
------------
Нижний колонтитул — базовая единица анатомии веб-страницы, как и заголовок. Сайты указывают там подробные сведения и ссылки: номера телефонов, адреса, ссылки на разделы справки и поддержки. Если пользователи ищут эту информацию, они обычно прокручивают страницу вниз до футера.
С бесконечной прокруткой пользователям трудно найти футер, потому что невозможно увидеть конец страницы. Невозможность достичь футера может напрягать пользователя (что не здорово).
Сайты с бесконечной прокруткой (например, Twitter) решают проблему, размещая необходимую информацию и ссылки в боковую панель. Боковая панель — это решение проблемы, но не очень хорошее. Футер должен оставаться футером.
*Футер Twitter на правой боковой панели*
Не используйте бесконечную прокрутку, если у вас нет таймлайна или ленты
------------------------------------------------------------------------
Приложения социальных сетей работают с таймлайном. Пользователи стремятся ориентироваться во времени, работать с прошлым. В этом случае бесконечная прокрутка упрощает навигацию. Здесь она хороша для производительности, особенно в мобильных устройствах.
Но если у вас интернет-магазин, новостной сайт, журнал или блог, то стремление пользователей — перемещаться по элементам или статьям, и тогда бесконечная прокрутка становится для них кошмаром. В списке с таймлайном люди в основном не ищут дату или уникальный элемент. В списках на основе элементов пользователь хочет именно найти конкретный элемент. Бесконечная прокрутка делает это практически невозможным.
Дайте пользователям больше контроля
-----------------------------------
Пользователи, как правило, не любят UI, который не могут контролировать.
Событие прокрутки не ведёт явно к намерению что-то делать. Люди перемещаются по странице, а если хотят совершить действие, то обычно делают клик или прикасаются к экрану (это и есть триггеры). Они информируют UI о своем решении. Но бесконечная прокрутка срабатывает без какого-либо решения.
Бесконечная прокрутка делает страницы менее управляемыми. Пользователи также могут столкнуться с глюками прыжков.
Вместо бесконечной прокрутки поставьте кнопку «Загрузить ещё», которая является триггером. Это даст пользователю контроль. (Я бы предпочел старый стиль нумерации страниц, но мы предполагаем, что сейчас используем пагинацию по указателям).
Разрешите пользователям идти куда они хотят
-------------------------------------------
Люди перемещаются по страницам, сохраняют некоторые в закладки, делятся с друзьями и т.д.
Однако бесконечная прокрутка не может сохранить состояние по своей сути. Пользователи не могут делиться текущим состоянием. Это также означает, что вы не можете отслеживать действия пользователей с помощью инструментов аналитики.
Если ваш метод внутренней пагинации основан на указателях, почти невозможно разрешить пользователям произвольную навигацию. Если у вас сайт электронной коммерции, то дайте пользователям возможность переходить к нужным продуктам.
Кроме того, если в списке есть функция «Сортировать по», необходимо показать пользователю нумерацию страниц. Если список в алфавитном порядке, нельзя заставлять людей прокручивать список до буквы K, иначе они сойдут с ума.
Нужно показывать пользователю, где он находится. Когда он обновляет страницу с бесконечной прокруткой, то будет отброшен в самое начало, и ему придётся снова прокручивать вниз до того места, где он был раньше.
Вывод
=====
Бесконечная прокрутка хороша в некоторых случаях, но как правило, она создаёт больше проблем, чем решает. Дизайнеры не должны рассматривать бесконечную прокрутку как серебряную пулю, которая решает все проблемы с разбиением на страницы. Хватит делать сайты с бесконечной прокруткой! | https://habr.com/ru/post/427615/ | null | ru | null |
# Получение root доступа к смарт-телевизорам LG на ОС webOS
**Обновление поста от 04.11.2022 г.**
LG заблокировала данный способ получения рута, новый вариант доступен [тут](http://webos-forums.ru/post158462.html#p158462).
Наверное, многие слышали про получение рут доступа к девайсам на Android. Благодаря ему вы можете существенно расширить возможности мобильных устройств на этой ОС. А вот про рут доступ к телевизорам LG мало кто слышал. Так вот, на днях энтузиасты выложили инструкцию по получению рут доступа к телевизорам LG на операционной системе webOS версий 1.0-3.0. Сама инструкция под катом, а для начала хочу напомнить, что мобильная ОС webOS была разработана еще компанией Palm (если кто помнит такую:) для своих смартфонов и планшетов и базируется на ядре Linux с «самописной» графической оболочкой.
**Предостережения**
Хочу предупредить, что в случае возникновения проблем с телевизором, в сервисном центре вам могут отказать в гарантийном обслуживании. Можно нанести вред устройству или сделать его неработоспособным. Если вы не продвинутый пользователь и толком не знаете зачем вам нужны Root-права, настоятельно рекомендуется их не получать, т.к. всегда есть шанс получить «кирпич», либо изменить настройки, которые повлекут проблемы в работе.
Для получения рута вам нужно будет загрузить на телевизор специальный скрипт. Аудит работы скрипта и инструкции можно почитать [тут](http://forums.webosnation.com/lg-webos-tv/331754-pivotce-seems-webos-tv-has-been-rooted.html#post3450911) (англ.).
*Если вы имели дело с Linux-системами, ничего сложного в процедуре получении рута в webOS нет. Для его получения понадобятся: телевизор с webOS, подключенный к сети, компьютер (подключенный к этой же сети), учетная запись разработчика на сервере LG.*
1. Первым делом создайте учетную запись разработчика (если отсутствует) на сервере [developer.lge.com](http://developer.lge.com/) ([инструкция](http://webostv.developer.lge.com/develop/app-test/#preparingAccount) /англ./).
2. Установите в телевизоре из каталога приложений LG Store приложение Developer Mode. Запустите его, введите логин/пароль из предыдущего пункта, включите переключатели Dev Mode Status и Key Server. Телевизор перезагрузится и будет готов к дальнейшим манипуляциям ([инструкция](http://webostv.developer.lge.com/develop/app-test/#installDevModeApp) /англ./).
3. Установите на компьютер webOS SDK (только компонент SDK-CLI) отсюда <http://webostv.developer.lge.com/sdk/download/download-sdk/>, проще всего с помощью интернет-установщика (файл «Ваша\_ОС\_Installer»).
Запустите **webOS TV CLI**.
В открывшемся окне наберите **ares-setup-device** и нажмите «ввод». Выберите add.
```
ares-setup-device
name deviceinfo connection profile
-------- ------------------------ ---------- -------
emulator developer@127.0.0.1:6622 ssh tv
** You can modify the device info in the above list, or add new device.
? Select: (Use arrow keys)
> add
modify
remove
```
Введите информацию о ТВ по следующему образцу (10.123.45.67 — укажите IP-адрес вашего ТВ):
```
** You can modify the device info in the above list, or add new device.
? Select: add
? Enter Device Name: tv2
? Enter Device IP address: 10.123.45.67
? Enter Device Port: 9922
? Enter ssh user: prisoner
? Enter description: new device
? Select authentification: password
? Enter password:
? Save ? Yes
name deviceinfo connection profile
-------- -------------------------- ---------- -------
tv2 prisoner@10.123.45.67:9922 ssh tv
emulator developer@127.0.0.1:6622 ssh tv
```
После добавления ТВ проверьте результат, выполнив следующую команду:
```
ares-setup-device -list
```
Получите файл ключа с ТВ с помощью следующей команды:
```
ares-novacom --device tv2 --getkey
```
При запросе Passphrase нужно ввести 6-символьный пароль (регистр важен!), который отображается в приложении Developer Mode на ТВ.
```
input passphrase [default: webos]:
```
Проверьте соединение ПК с ТВ следующей командой:
```
ares-install --device tv2 --list
```
4. Скачайте файл [zalil.su/6937580](http://zalil.su/6937580), переименуйте его в root.
5. С помощью puttygen.exe сделайте import key ранее полученного с ТВ ключа, затем save private key. Установите WinSCP отсюда [winscp.net/eng/download.php](https://winscp.net/eng/download.php), запустите и вводите IP адрес вашего ТВ, порт 9922, далее укажите ключ тут «Еще -> SSH -> Аутентификация -> Файл закрытого ключа». Далее «Соединение -> Открыть терминал (Ctrl+T)». В правом окошке откроется содержимое ТВ, скопируйте туда из левого окна файл root. Все, WinSCP больше не понадобится, можно его закрыть.
6. Теперь для соединения с ТВ нам понадобится Linux-приложение ssh. Если на ПК установлен не Linux, а Windows XP,7,8 — скачайте и установите [Сygwin](https://cygwin.com/install.html) (UNIX-подобная среда и интерфейс командной строки для Microsoft Windows), не забыв про компонент openssh.
Если на ПК стоит Win10, то проще всего использовать [подсистему Linux в Windows 10](https://habrahabr.ru/company/eset/blog/281418/)
7. Запустите Cygwin64 Terminal и выполните следующую команду:
```
ssh -i tv_webos_key prisoner@192.168.x.x -p 9922
```
где tv\_webos\_key — имя файла ключа, 192.168.x.x — IP-адрес ТВ
8. Выполните команды:
```
chmod +x root
./root
```
Скрипт начнет выполнять свои действия, ждем пока не появится надпись:
```
try install any app from market
```
9. Возьмите пульт и попробуйте установить любое приложение из магазина приложений на ТВ — выдаст ошибку. А скрипт в свою очередь должен написать
```
third stage ok.
try get root - input password 1111
Password:
```
10. Введите пароль 1111.
Всё, рут получен!
11. Проверить можно набрав id — выдаст:
```
uid=0(root) gid=0(root)........
```
Такой рут — временный — до перезагрузки. Для получения постоянного рута выполните эту [инструкцию](http://webos-forums.ru/post56978.html#p56978).
12. Чтобы попасть в главную rootfs набираем —
```
busybox chroot /proc/1/root
```
И можно почитать следующий пост:
[webos-forums.ru/post54464.html#p54464](http://webos-forums.ru/post54464.html#p54464)
**Полезные советы:**
1. vim лучше через ssh не использовать. Есть проблемы с битностью передачи сигналов некоторых клавиш, по крайней мере в Windows и на webOS 1.4.
2. Лучше всего перекладывать нужные файлы для редактирования в /tmp/
```
cp somefile /tmp/somefile
```
3. Если выдает ошибку при скачке через WinSCP, то поменять права на файл
```
chmod 607 /tmp/somefile
```
4. Далее локально на своем ПК редактировать, обратно положить файл в /tmp/и перезаписать старый
```
cp /tmp/somefile somefile
```
5. В конце команды
```
ssh -i tv_webos_key prisoner@192.168.x.x -p 9922
```
добавить опцию
```
"/bin/sh -i"
```
(с ковычками), чтобы была интерактивная сессия.
6. Всё, что кладётся в **/tmp/**, после выключения ТВ удаляется.
Всем бобра!
Собственно, сам оригинал [инструкции](http://webos-forums.ru/topic4650.html) от автора.
С помощью данных Root-прав можно, например, автоматически запускать нужное вам приложение при включении телевизора. | https://habr.com/ru/post/335504/ | null | ru | null |
# Креативное использование веб-шрифтов
С помощью CSS-магии мы можем создавать красивые типографические эффекты и забыть о использовании изображений, в большинстве случаев. В этой статье мы создадим ряд симпатичных примеров веб-типографики, используя плагин jQuery — lettering.js, а также различные приемы CSS. В некоторых примерах мы также добавим переходы при наведении курсора мыши, чтобы сделать их немного более интерактивным.
*Пожалуйста, обратите внимание: примеры будут работать только в браузерах, которые поддерживают соответствующие свойства CSS.*
Также мы не будем включать префиксы браузеров в примеры кода в статье, но вы можете найти их в исходниках. В большинстве случаев мы будем использовать плагин lettering.js.
Итак, перейдем к примерам, их всего будет восемь.
##### [Пример 1](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index.html)
Идея первого примера в том, чтобы разделить или разрезать слово при наведении курсора и при этом показать второе слово, которое скрыто. Для этого нам понадобится следующая html-разметка:
```
Облако
Солнце
Облако
------------------------
```
Слово, которое будет отображаться вначале, будет дублироваться. (Заметим, что все эти примеры предназначены скорее для декоративных целей).
Мы применим плагин lettering.js для слов, т.е. у нас будет еще один тег span вокруг первого и последнего слова (дубликатов):
```
$(".cs-text-cut").lettering('words');
```
Теперь давайте взглянем на стили. Прежде всего, мы зададим фиксированную ширину для блока с текстом:
```
.cs-text {
width: 645px;
margin: 120px auto 30px;
cursor: default;
}
```
Теги span первого уровня будут выводиться как блочные элементы:
```
.cs-text > span {
display: block;
}
```
Два span-a с классом ".cs-text-cut" будут иметь высоту 90px и мы установим overflow: hidden. Идея состоит в том, чтобы высота этого span-а была вдвое меньше его реальной высоты, таким образом мы разрежем текст на половину. Также добавим переход для этих элементов:
```
.cs-text-cut {
width: 100%;
height: 90px;
overflow: hidden;
transition: all 0.4s ease-in-out;
}
```
Теперь добавим границы сверху и снизу:
```
.cs-text-cut:first-child {
border-top: 1px solid rgba(255,255,255,0.5);
}
.cs-text-cut:last-child {
border-bottom: 1px solid rgba(255,255,255,0.5);
}
```
Затем установим размер шрифта и высоту строки внутреннего тега span равную 180px, которая является ровно в два раза больше высоты его родителя, также добавим некоторые стили для текста:
```
.cs-text-cut span {
display: block;
line-height: 180px;
color: rgba(255,255,255,1);
font-size: 180px;
font-weight: 400;
text-transform: uppercase;
text-align: center;
margin-top: 6px;
font-family: 'Sancreek', cursive;
text-shadow: 7px 2px 0 rgba(255,255,255,0.3);
}
```
Второе дублирующее слово, которое является последним дочерним элементом в нашей структуре будет немного «поднято». Таким образом нам будет видно только нижняя часть слова:
```
.cs-text-cut:last-child span {
margin-top: -84px;
}
```
Текст в середине, который мы хотим, чтобы появлялся при наведении курсора мыши, будет позиционироваться абсолютно, и мы установим прозрачность для него равную 0. Он также будет уменьшен вдвое:
```
.cs-text-mid {
font-family: 'Raleway', sans-serif;
font-weight: 100;
text-transform: uppercase;
font-size: 50px;
letter-spacing: 50px;
line-height: 50px;
text-indent: 20px;
position: absolute;
top: 50%;
margin-top: -25px;
color: rgba(255,255,255,0.3);
text-shadow: 0 0 0 rgba(255,255,255,0.9);
opacity: 0;
transform: scale(0.5);
transition: all 0.4s ease-in-out 0s;
}
```
Когда мы наводим мышь на слово, мы хотим, чтобы верхняя половина перемещалась вверх, поэтому мы будем перемещать её по Y-оси и уменьшим её прозрачность:
```
.cs-text:hover .cs-text-cut:first-child {
transform: translateY(-25px);
opacity: 0.5;
}
```
А нижняя половина будет перемещена вниз:
```
.cs-text:hover .cs-text-cut:last-child {
transform: translateY(25px);
opacity: 0.5;
}
```
И, наконец, мы изменим прозрачность для среднего текста и увеличим его. Обратите внимание, что мы добавили переход с задержкой в 0,3 секунды. Это даст нам время, чтобы сначала переместить половинки исходного слова вверх и вниз:
```
.cs-text:hover .cs-text-mid {
transition-delay: 0.3s;
opacity: 1;
transform: scale(1);
}
```
Итак с первым примером мы закончили. Давайте перейдем ко второму.
##### [Пример 2](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index2.html)
Во втором примере мы поиграем немного с трансформацией и создадим полупрозрачные панели с буквами.
```
Капля
-----
```
Мы применим lettering, чтобы обернуть каждую букву в span:
```
$("#cs-text").lettering();
```
Затем зададим основной оболочке фиксированную ширину и добавим [clearfix hack от Nicolas Gallagher](http://nicolasgallagher.com/micro-clearfix-hack/), потому что наши теги span будут плавающими (float: left):
```
.cs-text {
width: 600px;
margin: 70px auto 30px;
}
/* Micro clearfix hack by Nicolas Gallagher http://nicolasgallagher.com/micro-clearfix-hack/ */
.cs-text:before,
.cs-text:after {
content: " ";
display: table;
}
.cs-text:after {
clear: both;
}
/* end clearfix hack */
```
Каждый span будет иметь обтекание слева и мы также добавим полупрозрачный фон и свойство box-shadow, которое создаст широкую границу. Затем мы «наклоним» элемент (transform: skewY(8deg)) и добавим переход:
```
.cs-text span {
float: left;
width: 120px;
font-size: 120px;
line-height: 230px;
font-weight: 400;
text-transform: uppercase;
text-align: center;
cursor: default;
font-family: 'Medula One', cursive;
display: block;
z-index: 1;
position: relative;
color: rgba(255,255,255,0.7);
text-shadow: 5px 5px 2px rgba(0,0,0,0.5);
background: rgba(0,0,0,0.05) url(../images/scratch-texture.png);
box-shadow:
-6px 2px 10px rgba(0,0,0,0.5),
inset 0 0 0 20px rgba(255, 255, 255, 0.4);
border-radius: 5px;
transform: skewY(8deg);
transition: all 0.5s ease-in-out;
}
```
Мы будем использовать псевдо-класс :before для того, чтобы создать эффект внутренней тени. Есть и другие способы сделать это, но давайте немножко пофантазируем :)
```
.cs-text span:before {
content: '';
position: absolute;
left: 20px;
right: 20px;
top: 20px;
bottom: 20px;
box-shadow:
1px 1px 1px rgba(255,255,255,0.4),
inset 1px 1px 1px rgba(0,0,0,0.1);
}
```
С помощью псевдо-класса :after добавим маленькую точку в верхней части элемента:
```
.cs-text span:after {
content: '';
position: absolute;
left: 50%;
top: 5px;
margin-left: -5px;
width: 10px;
height: 10px;
border-radius: 50%;
box-shadow: inset 1px 1px rgba(0, 0, 0, 0.4);
background: rgba(255, 255, 255, 0.2);
}
```
И, наконец, при наведении курсора мыши, мы повернем элемент и немного его увеличим, также изменим тени и повысим значение прозрачности:
```
.cs-text span:hover {
transform: translateY(-10px) scale(1.1);
color: rgba(255,255,255,1);
text-shadow: 2px 2px 2px rgba(0,0,0,0.2);
}
```
##### [Пример 3](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index3.html)
Третий пример полностью основан на [уроке о создании поцарапанной плитки в Photoshop](http://textuts.com/scrabble-tiles-text-effect/) от textuts.com. И мы постараемся создать точно такой же эффект с помощью CSS.
```
Я вас любил: ♥любовь еще, быть может, В душе моей угасла не совсем, Но пусть она вас больше не тревожит, Я не хочу печалить вас ничем.
--------------------------------------------------------------------------------------------------------------------------------------
### АС Пушкин
```
Мы опять применим lettering.js к словам и буквам:
```
$(".cs-text").lettering('words').children('span').lettering()
```
Это позволит нам обернуть каждое слово в тег span с классом, начинающимся со слова «word», и каждую букву в слове в span с классом, начинающимся со слова «char».
Отцентрируем текст:
```
.cs-text {
text-align: center;
margin-top: 70px;
}
```
Слова будут выводиться как inline-блоки и мы зададим им боковые отступы:
```
.cs-text span[class^="word"] {
display: inline-block;
margin: 0 15px;
}
```
Для каждого символа мы определим цвет фона, ширину и высоту. Текст тени создаст эффект врезанных букв, а несколько теней box-shadow добавит объем плитке:
```
.cs-text span[class^="char"] {
width: 90px;
height: 100px;
display: inline-block;
background: #e4d095;
color: #2a1f1b;
border-radius: 4px;
font-size: 60px;
font-weight: 400;
line-height: 100px;
margin: 10px 3px;
text-align: center;
cursor: default;
font-family: "Spinnaker", Arial, sans-serif;
text-shadow:
1px 1px 1px rgba(255, 255, 255, 0.9),
0 -1px 1px rgba(255,255,255,0.2);
text-transform: uppercase;
box-shadow:
1px 7px 15px rgba(0,0,0,0.8),
inset 3px 0 2px rgba(255,255,255,0.4),
inset 0 3px 0px rgba(255,255,255,0.5),
inset -2px -3px 0px rgba(143,128,82,0.6);
}
```
Теперь добавим немного «рандомности», незначительно поворачивая каждую нечетную и каждую третью плитку:
```
.cs-text span[class^="char"]:nth-child(odd) {
transform: rotate(2deg);
}
.cs-text span[class^="char"]:nth-child(3n) {
transform: rotate(-3deg);
}
```
Пятое слово и последний заголовок будут иметь красные буквы, а также заголовок будет немного меньше, чем остальной текст:
```
.cs-text > span:nth-child(5) span,
h3.cs-text span[class^="char"] {
color: #a62a19;
}
h3.cs-text span[class^="char"] {
font-size: 40px;
width: 50px;
height: 60px;
line-height: 60px;
}
```
Все готово!
##### [Пример 4](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index4.html)
В четвертом примере используем текст как фон с типографическим эффектом. Мы сделаем буквы большими и полупрозрачными, добавим тени для текста и повернем некоторые буквы «случайным» образом.
```
Не завидуй
тому, кто силен и богат.
За рассветом всегда
наступает закат.
С этой жизнью короткою,
равною вздоху,
Обращайся как с
данной тебе напрокат.
-----------------------------------------------------------------------------------------------------------------------------------------------------------
```
Мы обернем каждую букву в тег span, при помощи всё того же lettering.js:
```
$("#cs-text").lettering();
```
Выровним текст по центру и зададим ему ширину 100%:
```
.cs-text {
width: 100%;
text-align: center;
margin-top: 80px;
}
```
Буквы будут полупрозрачными, для этого определим цвет RGBA с низким значением прозрачности. Мы также добавим тень для текста с большим смещением:
```
.cs-text span {
font-family: 'Cantata One', 'Trebuchet MS', sans-serif;
font-size: 180px;
line-height: 150px;
font-weight: 400;
color: rgba(255,255,255,0.3);
display: inline-block;
text-transform: uppercase;
text-shadow: 15px 15px 0 rgba(0,0,0,0.2);
cursor: default;
pointer-events: none;
}
```
Поскольку мы хотим использовать это как фон, добавим свойство pointer-events: none. Это позволит избежать выделения текста мышью.
Теперь, давайте рандомно повернем и изменим некоторые буквы. Для этого мы будем использовать селектор :nth-child:
```
.cs-text span:nth-child(2n) {
transform: rotate(-6deg);
color: rgba(255,255,255,0.4); ;
}
.cs-text span:nth-child(3n) {
transform: translateY(20px);
}
.cs-text span:nth-child(4n) {
color: rgba(255,255,255,0.2);
}
.cs-text span:nth-child(3n+3) {
transform: scale(1.4) rotate(5deg);
}
.cs-text span:nth-child(7n) {
font-size: 110px;
}
.cs-text span:nth-child(12n) {
font-size: 200px;
}
```
Вот и все, очень простой, но впечатляющий текстовый эффект.
##### [Пример 5](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index5.html)
В пример 5 создадим эффект 3D.
```
Гармошка
--------
```
Здесь мы хотим, чтобы каждая буква была обернута двумя тегами span, поэтому мы сначала применим lettering.js, а затем обернем созданые теги span в еще один:
```
$("#cs-text").lettering().children('span').wrap('');
```
Определим ширину/высоту и отступы для основного контейнера:
```
.cs-text {
position: relative;
width: 960px;
height: 100px;
margin: 100px auto;
cursor: default;
}
```
Первый слой тегов span будет иметь свойства perspective и float:
```
.cs-text > span {
perspective: 200px;
float: left;
position: relative;
}
```
Так как мы будем вращать и перемещать внутренние теги span, нам нужно в определенном порядке расположить контейнеры (от центра к краям):
```
.cs-text > span:first-child,
.cs-text > span:last-child {
z-index: 1;
}
.cs-text > span:nth-child(2),
.cs-text > span:nth-child(7){
z-index: 2;
}
.cs-text > span:nth-child(3),
.cs-text > span:nth-child(6){
z-index: 3;
}
.cs-text > span:nth-child(4) {
z-index: 5;
}
.cs-text > span:nth-child(5){
z-index: 4;
}
```
Внутренние span-ы будут иметь множественный фон: градиент и полупрозрачные текстуры. Мы также применим box-shadow, что даст некоторую глубину элементам:
```
.cs-text span span {
display: block;
background: url(../images/scratch-texture.png), linear-gradient(to right, #00b7ea 0%,#009ec3 100%);
box-shadow:
-1px 0 2px rgba(255,255,255,0.4),
-2px 0 0 #00adda,
-2px 7px 9px rgba(0, 0, 0, 0.5);
color: #fff;
text-shadow: -1px -1px 2px rgba(0,0,0,0.6);
width: 120px;
height: 150px;
font-weight: 700;
line-height: 150px;
font-size: 140px;
text-align: center;
text-transform: uppercase;
}
```
Последние четыре буквы будут иметь обратный градиент, box-shadow и text-shadow:
```
.cs-text > span:nth-child(n+5) span {
background: url(../images/scratch-texture.png), linear-gradient(to right, #009ec3 0%,#00b7ea 100%);
box-shadow:
1px 0 2px rgba(255,255,255,0.4),
2px 0 0 #00adda,
-2px 7px 9px rgba(0, 0, 0, 0.5);
text-shadow: 1px 1px 2px rgba(0,0,0,0.6);
}
```
Теперь мы переместим внутренние span-ы по Z-индексу и будем вращать их, чтобы создать нужный эффект. Каждый из них будет иметь различные значения, поэтому мы будем использовать селектор :nth-child:
```
.cs-text > span:nth-child(4) span{
transform: translateZ(40px) rotateY(40deg);
}
.cs-text > span:nth-child(5) span{
transform: translateZ(40px) rotateY(-40deg);
}
.cs-text > span:nth-child(3) span{
transform: translateZ(30px) rotateY(30deg);
}
.cs-text > span:nth-child(6) span{
transform: translateZ(30px) rotateY(-30deg);
}
.cs-text > span:nth-child(2) span{
transform: translateZ(20px) rotateY(20deg);
}
.cs-text > span:nth-child(7) span{
transform: translateZ(20px) rotateY(-20deg);
}
.cs-text > span:first-child span{
transform: translateZ(10px) rotateY(10deg);
}
.cs-text > span:last-child span{
transform: translateZ(10px) rotateY(-10deg);
}
```
Также переместим span-ы немного по оси Х:
```
.cs-text > span:nth-child(-n+4) {
transform: translateX(14px);
}
.cs-text > span:nth-child(n+5) {
transform: translateX(-14px);
}
```
Готово, теперь у нас есть аккуратный 3D текст!
##### [Пример 6](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index6.html)
На этот пример меня вдохновил Оригами. Для каждой буквы у нас будет несколько полупрозрачных span-ов, которые мы будем вращать и «наклонять». При наведении мыши все преобразования будут удалены.
```
Роза
----
```
Нам нужно каждую букву обернуть тегом span, перед которым будет три пустых тега span, и все это будет обернуто еще одним тегом span (да-да, можно мозг сломать):
```
$("#cs-text").lettering().children('span').wrap('').parent().prepend('');
```
Добавим ширину и некоторые отступы для основного контейнера:
```
.cs-text {
width: 600px;
margin: 70px auto 30px;
}
/* Micro clearfix hack by Nicolas Gallagher http://nicolasgallagher.com/micro-clearfix-hack/ */
.cs-text:before,
.cs-text:after {
content: " ";
display: table;
}
.cs-text:after {
clear: both;
}
/* end clearfix hack */
```
Все теги span будут блочными элементами:
```
.cs-text span{
cursor: default;
display: block;
position: relative;
}
```
Первый слой span-ов будет иметь высоту и ширину 130 пикселей и некоторые отступы:
```
.cs-text > span {
float: left;
width: 130px;
height: 130px;
margin: 10px;
}
```
Все внутренние span-ы будут иметь фон RGBA, который сделает их полупрозрачными. Мы также добавим переход для них:
```
.cs-text span span {
position: absolute;
width: 100%;
height: 100%;
top: 0;
left: 0;
background: rgba(255,255,255,0.3);
box-shadow: 1px 1px 2px rgba(0,0,0,0.2);
transition: all 0.3s ease-in-out;
}
```
Последний дочерний внутренний span содержит букву, укажем для неё размер и добавим несколько цветных теней для текста. Он также будет иметь фоновый градиент, который будет имитировать тонкий изгиб:
```
.cs-text span span:last-child{
font-size: 70px;
line-height: 130px;
font-weight: 400;
text-transform: uppercase;
text-align: center;
color: rgba(255,255,255,0.8);
font-family: 'Michroma', sans-serif;
text-shadow:
1px 1px 1px rgba(0,0,0,0.1),
-1px -1px 1px rgba(0,0,0,0.1),
5px 5px 0 rgba(216,65,40,0.6),
-5px -5px 0 rgba(37,166,164,0.6);
background:
linear-gradient(
45deg,
rgba(249,249,249,0.08) 0%,
rgba(234,234,234,0.5) 49%,
rgba(255,255,255,0.51) 50%,
rgba(244,244,244,0.94) 100%
);
}
```
Теперь добавим некоторые произвольные повороты и наклоны для span-ов:
```
.cs-text > span:nth-child(odd) span:first-child {
transform: rotate(5deg) skewY(-14deg);
}
.cs-text > span:nth-child(even) span:first-child {
transform: rotate(-35deg) skewY(-5deg);
}
.cs-text > span:nth-child(odd) span:nth-child(2) {
transform: rotate(45deg) skewY(-10deg);
}
.cs-text > span:nth-child(even) span:nth-child(2) {
transform: rotate(27deg) skewY(-12deg);
}
.cs-text > span:nth-child(odd) span:nth-child(3) {
transform: rotate(45deg);
}
.cs-text > span:nth-child(even) span:nth-child(3) {
transform: rotate(30deg);
}
```
При наведении мыши мы будем убирать все преобразования для блоков:
```
#cs-text > span:hover span {
transform: rotate(0deg) skewY(0deg);
text-shadow:
1px 1px 0 rgba(216,65,40,0.1),
-1px -1px 0 rgba(37,166,164,0.1);
}
```
Шестой пример готов! Есть еще множество вариантов данного примера, просто попробуйте поиграться с преобразованиями для создания интересных эффектов.
##### [Пример 7](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index7.html)
В этом примере мы изначально покажем логотип, а затем, при наведении мыши, покажем все остальные буквы. Мы не будем использовать здесь плагин lettering, мы просто создадим следующую структуру:
```
C
o
d
r
o
p
s
---------------------
```
Сначала определим некоторые свойства текста:
```
.cs-text {
font-size: 50px;
text-transform: uppercase;
margin: 80px auto 0 auto;
width: 580px;
height: 100px;
padding-left: 20px;
font-family: 'McLaren', Arial;
font-weight: 400;
position: relative;
}
/* Micro clearfix hack by Nicolas Gallagher http://nicolasgallagher.com/micro-clearfix-hack/ */
.cs-text:before,
.cs-text:after {
content: " ";
display: table;
}
.cs-text:after {
clear: both;
}
/* end clearfix hack */
```
Теги span будут иметь свойство float: left, и мы сделаем их круглыми. Мы также добавим переход.
```
.cs-text span {
cursor: default;
display: block;
float: left;
border-radius: 50%;
width: 100px;
height: 100px;
line-height: 100px;
text-align: center;
margin: 0 0 0 -20px;
color: rgba(255,255,255,0.95);
text-shadow: 0 -1px 1px rgba(0,0,0,0.1);
transition: all 0.4s ease-in-out;
}
```
Для четных и нечетных тегов span будет разный цвет фона и мы добавим тонкую текстуру для них:
```
.cs-text span:nth-child(odd) {
background: rgba(118,176,204, 0.8) url(../images/noise.png);
}
.cs-text span:nth-child(even) {
background: rgba(58,126,162, 0.8) url(../images/noise.png);
}
```
Все span-ы будут перемещены в центр. Мы применим трансформацию дважды: первый раз в процентах, например, первый span нужно переместить на 3 позиции, т.е. на 300%, а второе преобразование для компенсации отступов:
```
.cs-text span:nth-child(1) {
transform: translate(300%) translate(-60px);
}
.cs-text span:nth-child(2) {
transform: translate(200%) translate(-40px);
}
.cs-text span:nth-child(3) {
transform: translate(100%) translate(-20px);
}
.cs-text span:nth-child(5) {
transform: translate(-100%) translate(20px);
}
.cs-text span:nth-child(6) {
transform: translate(-200%) translate(40px);
}
.cs-text span:nth-child(7) {
transform: translate(-300%) translate(60px);
}
```
Все span-ы, кроме последнего, будут иметь прозрачность равную 0:
```
.cs-text span:not(:last-child) {
opacity: 0;
pointer-events: none;
}
```
Последний span будет содержать логотип. Мы зададим ему другой фон и расположим его по центру основного контейнера:
```
.cs-text span:last-child{
position: absolute;
top: 0;
left: 50%;
margin-left: -50px;
z-index: 100;
background: url(../images/codrops_logo.jpg) no-repeat center center;
}
```
При наведении мыши все span-ы вернутся в свое естественное положение, и мы увеличим значение прозрачности до 1:
```
.cs-text:hover span:not(:last-child){
transform: translate(0%);
opacity: 1;
}
```
Логотип будет немного увеличен, а затем исчезнет:
```
.cs-text:hover span:last-child {
opacity: 0;
transform: scale(1.4);
}
```
##### [Пример 8](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index8.html)
В последнем примере мы просто немного поиграем с несколькими тенями для текста.
```
Время для кофе
---------------
```
Мы опять используем lettering.js, чтобы обернуть все слова в теги span:
```
$(".cs-text").lettering('words');
```
Добавим ширину для основного заголовка и отцентрируем его. Мы также наклоним его немного:
```
.cs-text {
width: 660px;
margin: 120px auto 30px;
cursor: default;
transform: skewY(-12deg);
text-align: center;
}
```
Теги span сделаем блочными элементами, и добавим верхнее поле:
```
.cs-text span {
display: block;
color: #fff;
font-weight: 400;
text-transform: uppercase;
margin-top: 6px;
font-family: 'Stint Ultra Expanded', cursive;
}
```
Первое слово будет иметь размер шрифта равный 100 пикселям, и большое расстояние между буквами:
```
.cs-text span:first-child {
font-size: 100px;
letter-spacing: 96px;
text-shadow: 6px 6px 0px rgba(255,255,255,0.3);
}
```
Второе слово будет курсивным шрифтом с засечками, и мы зададим ему в темный цвет:
```
.cs-text span:nth-child(2) {
font-family: Georgia, serif;
font-weight: 400;
text-transform: none;
font-style: italic;
line-height: 60px;
font-size: 67px;
color: #392f2c;
text-shadow: 1px 1px 1px rgba(255,255,255,0.3);
position: relative;
}
```
Мы используем псевдо-классы :before и :after для создания двух линий слева и справа:
```
.cs-text span:nth-child(2):before,
.cs-text span:nth-child(2):after {
content: '';
width: 240px;
height: 2px;
background: #392f2c;
position: absolute;
top: 50%;
margin-top: -1px;
box-shadow: 0 1px 0 rgba(255,255,255,0.2);
}
.cs-text span:nth-child(2):before {
left: 0px;
}
.cs-text span:nth-child(2):after {
right: 0px;
}
```
Последнее слово будет иметь несколько теней для текста, чтобы создать эффект стопки букв. Хитрость заключается в чередовании цвета текста и цвета фона, который в нашем случае является темно-коричневым:
```
.cs-text span:nth-child(3) {
font-size: 130px;
text-shadow:
2px 2px 0 #645f59,
4px 4px 0 #fff,
6px 6px 0 #645f59,
8px 8px 0 #fff,
10px 10px 0 #645f59,
12px 12px 0 #fff,
14px 14px 0 #645f59,
16px 16px 0 #fff,
18px 18px 0 #645f59,
20px 20px 0 #fff,
22px 22px 0 #645f59,
24px 24px 0 #fff;
}
```
И вот и все! Надеюсь, вам понравилось эти примеры и Вы найдете их полезными! С ними можно очень много экспериментировать, так что пробуйте!
[Демонстрация](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/index.html)
[Скачать исходные файлы](http://www.webmasters.by/images/articles/css/creative-web-typography-styles/TypographyStyles.zip) | https://habr.com/ru/post/151453/ | null | ru | null |
# Не CDN единым
В последнее время стало модно говорить о доступности при разработке сайтов, писать rel, alt, делать версию для слабовидящих и так далее, однако почему бы сначала не подумать о нормальных пользователях. Подключая jQuery из CDN:
```
```
… многие забывают очень важную деталь.
Конечно же, нужно не забывать проверить, подгрузилась ли библиотека, и если нет, то подгрузить с собственного сайта. Для этого можно просто добавить:
```
window.jQuery || document.write('<script src="js/vendor/jquery-1.11.2.min.js"><\/script>')
```
Это настолько просто, однако, многие крупные сайты грешат тем, что забывают про это. Реальный пример – крупный ресурс, завязанный на работу с клиентами из Китая, забыв про эту проверку, сделал невозможной работу этих клиентов с их сайтом, если клиент не использовал vpn. Причина проста: подгружали с CDN гугла, а в Китае почти все гугловское заблокировано (被和谐了).
Разработчики, пожалуйста, не забывайте об этом!
Ну а тех, кто не хочет замарачиваться с vpn, и при этом хочет чтоб скрипты с ajax.googleapis.com подгружались, можно порекомендовать следующий совет:
В файле hosts пропишите следующую строку
```
127.0.0.1 ajax.googleapis.com
```
Затем установить python, если он ещё не установлен в системе, и запустить скрипт:
```
#-*- coding: utf-8 -*-
import SocketServer
import SimpleHTTPServer
import urllib
import os
PORT = 80
class Proxy(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
if '/ajax/libs/' in self.path:
self.path = self.path.replace('/ajax/libs/','http://yastatic.net/')
self.copyfile(urllib.urlopen(self.path), self.wfile)
if os.name == 'posix':
httpd = SocketServer.ForkingTCPServer(('', PORT), Proxy)
else:
httpd = SocketServer.ThreadingTCPServer(('', PORT), Proxy)
print "serving at port", PORT
httpd.serve_forever()
```
При этом, естественно, нужно убедиться в том, что скрипты с [yastatic.net](http://yastatic.net/) у вас грузятся. | https://habr.com/ru/post/250663/ | null | ru | null |
# Новости из мира OpenStreetMap № 483 (15.10.2019-21.10.2019)
[Картографируют каждый божий день](https://osmstats.neis-one.org/?item=boards) [1](#wn483_21154) | [altogetherlost.com](http://altogetherlost.com/) & Pascal Neis ([neis-one.org](http://neis-one.org/))
Картографирование
-----------------
* На сайте regio-osm.de [появился](https://twitter.com/regio_osm/status/1185936023949316096) валидатор [номеров домов](https://regio-osm.de/hausnummerauswertung/anzeige_dynamisch.html?zoom=9&lat=42.45465&lon=21.76186&layers=B0000TTTFF) в Косово.
* Флориан Лохофф [написал](https://f.zz.de/posts/201910152010.access_private_on_driveways/) в своем блоге о проблемах, возникающих при использовании тега `access=private` (доступ только для своих) на дорогах, отмеченных тегом `highway=service`. Если указать такой уровень доступа, навигаторы не будут прокладывать по такой дороге путь. Однако не всегда такие дороги являются закрытыми. Поэтому он предлагает быть внимательными и выбирать более точные теги.
* Адам Франко записал два видеоролика о работе с мультиполигонами в редакторе JOSM. [В первом](https://www.openstreetmap.org/user/Adam%20Franco/diary/390981) он рассказывает о том, как создать мультиполигон для двух объектов, имеющих общие границы. Пожалуйста, обратите внимание, такой способ картографирования не желателен в OSM. [Во втором](https://www.openstreetmap.org/user/Adam%20Franco/diary/390982) — как находить и исправлять ошибки, связанные с мультиполигонами.
* Голосование за [предложение](https://wiki.openstreetmap.org/wiki/Discussions/tagging/contact:phone_or_phone) Вэрома Нарама — не использовать больше тег `contact:phone=`, а вместо него применять `phone=` — продлиться до 5 ноября.
* Также до 5 ноября продлится голосование за [предложение](https://wiki.openstreetmap.org/wiki/Proposed_features/sunbathing) Вадима, который считает, что нужно отмечать отдельными тегом места для принятия солнечных ванн (загорать).
* OSM-Хорватия [развернула](https://osm-hr.org/2019/10/16/openstreetmap-hrvatska-je-dobila-tasking-manager/) на своем сервере свой собственный Task Manager от HOT с целью координации различных картоакций. Например, сейчас они отрисовывают заливы на побережье по карте Хорватии TOPO 1:25000, которая не так давно стала свободной для использования.
Сообщество
----------
* [1] Паскаль Нейс обновил свой сервис статистики [OSMstats](https://osmstats.neis-one.org/?item=boards) и [добавил](https://twitter.com/pascal_n/status/1185933156794404867?s=20) еще несколько функций. Например, в разделе «Activity» вы можете увидеть пользователей, которые картографировали почти каждый день, 19 из них — каждый. Обязательно ознакомьтесь и с [другими](http://resultmaps.neis-one.org/) новыми разделами: «Map changes», «Discussions», «Traces» и «Notes».
* Хизер Лесон просит всех, кто принимает участие в жизни того или иного свободного или открытого проекта (она это назвала акронимом FLO — Free/Libre/Open), пройти [опрос](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-October/006263.html), касающийся «выгорания» членов таких сообществ.
* RebeccaF [опубликовала](https://www.openstreetmap.org/user/RebeccaF/diary/390973) в своем дневнике перечень того, что можно сделать, чтобы в OSM, HOT и на конференции «State of the Map» было еще больше людей. Эти мысли были озвучены во время обсуждения на SoTM в Гейдельберге (Германия).
* OSM лежит в [основе](https://resiliencymaps.org/open_building_map_osm) проекта по созданию динамической модели расчета сейсмической опасности, которая обновляет данные из OSM каждую минуту.
Импорты
-------
* Данные эстонского кадастра [импортируются](https://wiki.openstreetmap.org/wiki/Maa-amet) в OSM с 2013 года. Пользователь SviMik разработал для этого удобный и простой [инструмент](http://osm.svimik.com/btrace_verify.php). Но ему все равно необходима помощь сообщества. Помимо этого, он также сделал [валидатор](http://osm.svimik.com/noroad.php), который подсказывает, где еще нужно нарисовать дороги в Эстонии. Статистика и обзор всех инструментов доступны на его личном [сайте](http://osm.svimik.com/).
События
-------
* Пользователь Betaslb [написал](https://www.openstreetmap.org/user/Betaslb/diary/391013) в дневниках OSM о своих впечатлениях о конференции SotM-2019. Они интересны, потому что это взгляд новичка, а не эксперта в OSM.
* Началась регистрация на конференцию "[SotM-2019 Азия](https://stateofthemap.asia)", которая пройдет 1-2 ноября 2019 года в столице Бангладеша Дакке.
Гуманитарный OSM
----------------
* Райли Шампань, графический редактор National Geographic, [опубликовал](https://twitter.com/rileydchampine/status/1185260459521277952) в Твиттере ссылку на свою презентацию «Картографирование территорий с беженцами с использованием открытых данных», с которой он выступил на конференции NAICS 2019. В качестве бонуса — ссылка на электронную таблицу Google, содержащую запросовы, которые он использовал в Overpass Turbo.
Обучение
--------
* Российский пользователь Павел Гаврилов [написал](https://medium.com/@pavgavrilov/%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%BE-%D0%BA%D0%B0%D1%80%D1%82%D1%8B-openstreetmap-a9e0ae6f508c) обучающую статью об OSM, которая может быть полезна новичкам. В ней он рассказывает об основах проекта.
Карты
-----
* Российский пользователь Николай Петров запустил онлайн-проект [OpenRecycleMap](https://openrecyclemap.org). Это карта, с помощью которой можно найти контейнер для раздельного сбора мусора. Также сервис позволяет добавлять новые точки приема отходов. Данные берутся и добавляются в OSM.
* Сервис maptiler.com [сообщает](https://www.maptiler.com/blog/2019/10/openstreetmap-in-wgs84-on-maptiler-cloud.html) в своем блоге, что теперь их карты на базе OSM доступны в новых проекциях: WGS84, французской Lambert и голландской Rijksdriehoekstelsel. В статье также есть краткий обзор картографических проекций и ссылки на их интересное [сравнение](https://map-projections.net/imglist.php), сделанное Тобиасом Юнгом.
* «Геоинформационная [система](https://www.gisip.ru/#!en/) индустриальных парков, технопарков и кластеров Российской Федерации», разработанная Министерством промышленности и торговли РФ, в качестве подложки использует OSM.
Переходим OSM
-------------
* Российский портал Е1 [опубликовал](https://www.e1.ru/news/spool/news_id-66242083-section_id-294.html) новость о том, что в Екатеринбурге в ноябре 2019 года заработают «умные» светофоры, которые будут отдавать приоритет общественному транспорту. Но одной из фотографий, иллюстрирующих материал, можно [увидеть](https://static.ngs.ru/news/99/preview/da07f3157210dcf48cf35dbc17b58f2b21bd3c9e1_709.jpg), что в системе управления дорожным движением в качестве карты используется OSM.
Открытые данные
---------------
* Австрийский портал открытых данных data.gv.at [рекламировал](https://twitter.com/datagvat/status/1184742319133790208) свои новые наклейки в Твиттере, которые будут распространяться на мероприятиях, связаных с открытыми данными. Например, их можно будет получить на [@gov20campAT](https://barcamptools.eu/govcamp-vienna-2019/), которое состоится 29 ноября 2019 года.
* Первая Шотландская [неконференция](https://ti.to/code-the-city/SODU2020/) по открытым данным [состоится](https://lists.openstreetmap.org/pipermail/talk-gb/2019-October/023669.html) в городе Абердин 14-15 марта 2020 года.
* Администрация Перми [разрешила](https://wiki.openstreetmap.org/wiki/RU:%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D1%8F/%D0%98%D0%A1%D0%9E%D0%93%D0%94_%D0%9F%D0%B5%D1%80%D0%BC%D0%B8) использовать данные, размещенные на "[Публичном портале ИСОГД г. Перми](https://isogd.gorodperm.ru/)", в OSM.
Лицензии
--------
* Дискуссия вокруг того, что Facebook не указывает должным образом атрибуцию OSM, [продолжается](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-October/006243.html) до сих пор. С одной стороны Кристоф отмечает, что обсуждение и разработка нового руководства по атрибуции OSM проходит в закрытом режиме. С другой стороны, Нуно Кальдейра подробно и с примерами рассказывает, как именно Facebook нарушил требования лицензии.
Программное обеспечение
-----------------------
* Джоди Гарнетт [спросил](https://twitter.com/jodygarnett/status/1184277842135154688) в Твиттере: готовы ли члены fossgis\_eV поддержать GeoServer путем его по переаттестации в OGC.
Программирование
----------------
* Шэй Стронг из EagleView [написал](https://www.kdnuggets.com/2019/09/openstreetmap-data-ml-training-labels-object-detection.html) на сайте KD Nuggets материал об одном из методов использования машинного обучения для нахождения зданий, которые не нарисованы в OSM. Его модель работает с уже отмеченными зданиями в OSM.
* Йохен Топф [поделился](https://blog.jochentopf.com/2019-10-20-osmdata-on-cloud-servers.html) своим опытом работы с облачным-сервисом Hetzner, куда не так давно он перенес сайт osmdata.openstreetmap.de (ранее openstreetmapdata.com).
* Энди Аллан [написал](https://blog.gravitystorm.co.uk/2019/10/17/smoother-api-upgrades-for-openstreetmap/) в своем блоге о том, как у него идет работа по рефакторингу основного кода OpenStreetMap, чтобы он мог поддерживать сразу несколько версий API одновременно.
Релизы
------
* Вышла [новая](http://www.postgis.net/2019/10/20/postgis-3.0.0) версия PostGIS v. 3.0.0.
* [Вышла](https://vk.com/wall-168028574_212) новая версия мобильного приложения [Sight Safari](https://play.google.com/store/apps/details?id=city.sightsafari.android&hl=en) v. 2.2.0. Теперь можно делиться маршрутами с другими пользователями прямо из приложения.
Знаете ли вы …
--------------
* … про [сайт](https://osm.amdmi3.ru/) российского пользователя AMDmi3, где собраны различные рендеры OSM?
Другие «гео» события
--------------------
* В The Guardian вышла [забавная статья](https://www.theguardian.com/technology/2019/oct/19/do-you-wind-it-up-teens-tackle-old-tech-rotary-phones), в которой журналист знакомит современных подростков с технологиями 1980-х годов: телефон с поворотным диском, плеер Sony Walkman и транзисторное радио. Одним из примеров — бумажный атлас улиц Лондона («A-Z»).
* На прошлой неделе мы сообщали о том, что австралийское государственное агенство «Geoscience Australia» больше не будет печатать и продавать бумажные топографические карты. The Guardian глубоко [размышляет](https://www.theguardian.com/travel/2019/oct/20/the-perfect-combination-of-art-and-science-mourning-the-end-of-paper-maps) над этим событием.
* Йенс Яковски из Швеции [делится](https://forbattrakartan.lantmateriet.se/): «Шведское землемерное управление просит граждан принимать участие в улучшении официальных шведских карты и, например, сообщить о туристических тропах, которые не отмечены на карте». Мы им отвечаем: «Тогда нам лучше прямо сейчас начать править OpenStreetMap.»
* Jane Macfarlane [считает](https://spectrum.ieee.org/computing/hardware/your-navigation-app-is-making-traffic-unmanageable), что распространение навигационных приложений вроде Waze, Apple Maps и Google Maps умножает хаос и затрудняет управление дорожным движением.
* В статье на futurezone.at [рассказывается](https://futurezone.at/digital-life/google-maps-fehler-supermarkt-bekommt-kokain-statt-bananen/400650647), что ошибки на карте не всегда должны восприниматься негативно. Из-за ошибки в Google Maps была поймана банда наркоманов.
* Издание El Pais [пишет](https://elpais.com/cultura/2019/10/19/actualidad/1571509125_159564.html), что военные карты Испании, составленные во время Второй мировой войны американцами и британцами, наконец-то, рассекречены.
* Google [объявил](https://www.blog.google/products/maps/new-ways-report-driving-incidents-google-maps/), что в скором времени на Google Maps можно будет сообщать о дорожно-транспортных происшествиях. Появление этих функций на Google Maps ставит вопрос о будущем сервиса Waze, который был [куплен](https://techcrunch.com/2013/06/11/its-official-google-buys-waze-giving-a-social-data-boost-to-its-location-and-mapping-business/?guccounter=1&guce_referrer_us=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&guce_referrer_cs=FIg4tbodXs7f-r-C_65Lmg) Google 6 лет назад.
* В [статье](https://onlinelibrary.wiley.com/doi/10.1111/ecog.04532), опубликованной в издании «Ecography», показывается, как текстовый анализ научных статей может быть использован для [создания карт](https://twitter.com/EcographyJourna/status/1183722784498864128) тех мест, где проводились исследования различных насекомых-опылителей (как правило, пчел).
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [482](https://habr.com/ru/post/473512/), [481](https://habr.com/ru/post/471852/), [480](https://habr.com/ru/post/471122/), [479](https://habr.com/ru/post/470359/), [478](https://habr.com/ru/post/469161/) | https://habr.com/ru/post/473888/ | null | ru | null |
# Задача о 8-ми ферзях. Свежий взгляд. Шаг первый. Сокращаем количество шагов перебора в три раза
Казалось бы, что можно добавить на тему о популярной задачке о расстановке ферзей на шахматной доске стандартной размерности 8x8 клеток? Но как оказалось и тут можно внести свою толику программистской мысли.
Классически задача решается последовательным перебором ферзей на заданной линии и бонусом предлагается анализировать диагонали которые покрываются установкой ферзя в нужную клетку. Но те реализации алгоритмов, что я видел, установкой или снятием ферзя с маркировкой диагоналей, едва ли перекрывают по быстродействию расстановку ферзей по-принципу ладьи.
Как оказывается в алгоритм можно привнести существенные улучшения отказавшись от линейного обхода/перебора клеток и внеся понятие анализа состояния атак шахматной доски.
Я добавил два улучшающих принципа в алгоритм, которые позволяют снизить общее кол-во переборов в три раза.
---
Двигаемся по столбцам (A-H). В столбцах перебираем строки (1-8)
* Установить ферзя, означает - промаркировать все атаки (горизонтальную и диагональные) и пометить столбец с ферзём, как занятый.
* Снять ферзя, означает снять маркировку атак и пометить столбец, который он занимал, как свободный.
1. Проверить поставлены ли все ферзи во всех столбцах. Если да, то выдать удачный результат.
Вернуться на шаг назад в переборе (снять последнего установленного ферзя).
Рекурсивно переходим к пункту №1.
2. Проверить, есть ли такой свободный столбец, в который нельзя поставить ферзя?. Если такой столбец имеется - шаг назад в рекурсивном обходе, дальнейшие ходы - бессмысленны.
Вернуться на шаг назад в переборе (снять последнего установленного ферзя).
Рекурсивно переходим к пункту №1.
3. Проверить, есть ли такой свободный столбец в который можно поставить только одного ферзя? Если такой такой имеется, разумеется туда и ставим ферзя, жертвуя линейностью обхода. Рекурсивно переходим к пункту №1.
4. Находим ближайший к началу доски свободный столбец, выполняем в нем перебор всех не атакованных позиций. Устанавливаем ферзя в не атакованную позицию.
Рекурсивно переходим к пункту №1
---
Для реализации алгоритма я выбрал 64-х битную математику в арифметических и логических операциях. [ + - AND NOT XOR OR << >>].
Шахматная доска 8x8 в 64 клетки отлично ложится в 64-х битовую переменную.
Чтобы не использовать внутренние циклы для маркировки состояний по диагонали, я инициализирую их заранее. Есть три раздельных слоя для маркировки атак ферзя. Два диагональных слоя и один горизонтальный. В один слой все три атаки сливать нельзя, так как это не позволит восстановить предыдущее состояние шахматной доски.
Для демонстрации своего алгоритма я выбрал язык C#, как наиболее легкий и понятный. JS не содержит поддержки целочисленной 64-х битной арифметики, и чтобы не усугублять демо-пример кластеризацией на 32-х битную арифметику - я от него отказался.
Язык СИ несколько тяжелей, по тексту, но содержит поддержку нужных для ускорения работы алгоритма инструкций процессора - POPCNT и BSF в виде "intrinsics"-функций.
С JVM на момент написания этой статьи существуют некоторые неопределённости, о которых не будем распространяться.
В итоге выбран C# с дополнительным классом битовой логики, который пытливый программист сам может переложить на процессорную аппаратную поддержку.
**Итак приступим!**
Размещаем шахматную доску в 64-битную переменную следующим образом
Первого ферзя в алгоритме ставим на [A1] (x = 0, y = 0). Базовое движение делаем по X-оси (по столбцам), на каждой оси перебираем позицию Y (строки). Как видно из иллюстрации, каждый столбец представляет из себя байт (8-мь бит).
Теперь промаркируем диагонали:
Диагональ LR (LEFT+BOTTOM : RIGHT+TOP)
Номер LR-диагонали считается по формуле: N = X+Y
Так например, для позиций (xy): 3:2 (26), 4:1 (33), 1:4 (12) - Номером диагонали будет - 5;
для позиций (xy): 7:4 (60), 5:6 (46), 4:7 (39) - Номером диагонали будет - 11;
Диагональ LR: (LEFT+BOTTOM : RIGHT+TOP)
Диагональ RL (RIGHT+BOTTOM : LEFT+TOP)Номер RL-диагонали считается по формуле: N = 7 - X+Y
Ну а дальше - дело техники:
* Вводим массивы:
ulong diag\_LR[15]
ulong diag\_RL[15]
Массивы содержат шахматную доску где биты установленные в 1 означают атаку по диагонали. Предварительно инициализируем их. Данные массивы нужны для того, чтобы не вводить в основной цикл внутренние циклы для маркировки атак. Массив для горизонтальной атаки не нужен, поскольку легко накладывается 64-битным числом
* Вводим переменную "ulong markers". Каждый байт markers содержит либо 0x00, либо 0xFF, чтобы обозначать доступен ли X-столбец для установки ферзя.
0xFF - доступен
0x00 - занят
* Вводим три переменные (ulong): attacks\_HZ, attacks\_LR, attacks\_RL, чтобы держать состояния атак по горизонтали и вертикалям. Чтобы получить полное состояние всех атак клетки, надо слить их по операции OR: attacks\_HZ | attacks\_LR | attacks\_RL.
Для понимания работы алгоритма надо также понимать, что часть операций над 64-х разрядными числами можно совершать параллельно над байтами числа, если числа хранимые в байтах не вызывают арифметического переполнения относительно друг-друга. Например число 0x0303\_0303\_0303\_0303 - можно рассматривать, как вектор из 8-ми байтов установленных в 3-и. Тогда операцией инкрементации вектора будет прибавление к числу - значения 0x0101\_0101\_0101\_0101. Результатом будет - 0x0404\_0404\_0404\_0404.
Ответом на вопрос - "В байт векторе присутствуют байты со значениями в диапазоне от 0 до 8. Есть ли в байт-векторе, хотя бы одно число 8?" - будет наложение на вектор маски - 0x0808\_0808\_0808\_0808 операцией AND. Ненулевое значение означает, что байт-векторе есть такие числа.
0x0108\_0304\_0708\_0506
AND
0x0808\_0808\_0808\_0808 =
-----------------------------------
0x0800\_0000\_0008\_0000 - ЕСТЬ (ненулевой результат)
0x0106\_0304\_0700\_0506
AND
0x0808\_0808\_0808\_0808 =
-----------------------------------
0x0000\_0000\_0000\_0000 - НЕТ (нулевой результат)
Код прототипа:
1. Выражения предельно упрощены, для понимания логики происходящего, и для трассировки алгоритма в отладочном режиме
2. Алгоритм оптимизирован под инструкцию процессора BSF (Bit Scan Forward), которая в прототипе дана, как функция "BitOp.bsf64()". Также может применяться инструкция процессора `BLSR(BMI1).`
```
using System;
namespace Queen_8x8
{
delegate void Solution(int[] queens);
class Program
{
static void Main(string[] args)
{
print("Hello Queens!");
print(":");
Queen_8x8 task = new Queen_8x8();
task.smart_check = true;
task.init(print_solution);
task.run();
print("solution_count = " + task.solution_count);
print("solve_count = " + task.solve_count);
print("reverse_count = " + task.reverse_count);
}
static void print(String s)
{
Console.WriteLine(s);
}
static void print_solution(int[] queens)
{
String s = "";
s += "[ ";
for (int i = 0; i < queens.Length; i++)
{
s += Char.ConvertFromUtf32(i + 65) + (queens[i] + 1).ToString();
if (i < (queens.Length - 1)) s += ", ";
}
s += " ]";
print(s);
}
}
class Queen_8x8
{
protected Solution solution;
public const int queens_count = 8;
public const int diag_count = queens_count * 2 - 1;
public ulong markers = 0xFFFF_FFFF_FFFF_FFFF;
public int[] queens = new int[queens_count];
ulong[] diag_LR = new ulong[diag_count];
ulong[] diag_RL = new ulong[diag_count];
ulong attacks_HZ = 0; // атака по горизонтали
ulong attacks_LR = 0; // атака по диагонали BL-TR [\]
ulong attacks_RL = 0; // атака по диагонали BR-TL [/]
public bool smart_check = true;
// Statisticks
public int solution_count = 0;
public int solve_count = 0;
public int reverse_count = 0;
private int get_LR(int x, int y) { return x + y; }
private int get_RL(int x, int y) { return (queens_count - 1 - x) + y; }
public void init(Solution solution)
{
this.solution = solution;
solution_count = 0;
solve_count = 0;
reverse_count = 0;
markers = 0xFFFF_FFFF_FFFF_FFFF;
for (int i = 0; i < queens.Length; i++)
{
queens[i] = -1;
}
for (int i = 0; i < diag_count; i++)
{
diag_LR[i] = 0;
diag_RL[i] = 0;
}
for (int x = 0; x < queens_count; x++)
{
for (int y = 0; y < queens_count; y++)
{
ulong mask = 1UL << ((x << 3) + y);
diag_LR[get_LR(x, y)] |= mask;
diag_RL[get_RL(x, y)] |= mask;
}
}
}
public void run()
{
solve();
}
protected void step(int qx, int qy)
{
ulong q_CM = 0xFFUL << (qx << 3);
ulong a_HZ = 0x0101_0101_0101_0101UL << qy;
ulong a_LR = diag_LR[get_LR(qx, qy)];
ulong a_RL = diag_RL[get_RL(qx, qy)];
// Set Queeen
queens[qx] = qy;
markers &= ~q_CM;
attacks_HZ |= a_HZ;
attacks_LR |= a_LR;
attacks_RL |= a_RL;
// Recurse
solve();
// Remove Queeen
attacks_HZ &= ~a_HZ;
attacks_LR &= ~a_LR;
attacks_RL &= ~a_RL;
markers |= q_CM;
queens[qx] = -1;
}
protected void solve()
{
if (markers == 0)
{
solution_count++;
solution(queens);
return;
}
ulong attacks = attacks_HZ | attacks_LR | attacks_RL;
// Получаем в каждом байте 64-разрядного числа -
// сумму занятых мест по столбцам
// Каждый байт обозначает столбец таблицы и содержит число
// в интервале от 0 до 8
ulong sum_vec_8 = BitOp.popcnt64_bv(attacks);
// Проверка, что остались незаполненные столбцы
// Определяем что в каком либо столбце присуствует число 8
// Если в каком-либо столбце присутствует число 8, то общее значение теста
// станет ненулевым
ulong test = sum_vec_8 & 0x0808_0808_0808_0808UL;
test &= markers; // Отбрасывем столбцы (columns), где уже установлены ферзи
if (smart_check && test != 0)
{
return; // Есть столбец не занятый ферзем, но поставить в этот столбец ферзя - невозможно
}
// Проверка, на то что есть столбцы, только с одим возможным ходом
// Поскольку мы отбросили вариант, что в столбцах присутствует число 8
// прибавляем к каждому столбцу единицу и опять проверяем все столбцы на наличие числа 8
// Если изначально в каком-либо столбце присутствовало число 7, то общее значение теста
// станет ненулевым
test = sum_vec_8 + 0x0101_0101_0101_0101UL;
test &= 0x0808_0808_0808_0808UL;
test &= markers; // Отбрасывем столбцы (columns), где уже установлены ферзи
int qx;
int qy;
ulong column;
if (smart_check && test != 0)
{
reverse_count++;
qx = BitOp.bsf64((test >> 3)) >> 3;
column = (~attacks >> (qx << 3)) & 0xFFUL;
qy = BitOp.bsf64(column);
step(qx, qy);
return;
}
// Делаем перебор по столбцу
qx = BitOp.bsf64(markers) >> 3;
column = (~attacks >> (qx << 3)) & 0xFFUL;
while (column != 0)
{
solve_count++;
qy = BitOp.bsf64(column);
column &= column - 1; // BLSR BMI1!!! column &= ~(1UL << qy); // Сбросить самый младший единичный бит
step(qx, qy);
}
return;
}
}
class BitOp
{
// Просумировать все биты в байтах 64-разрядного числа
public static ulong popcnt64_bv(ulong value)
{
ulong result = value;
result = result - ((result >> 1) & 0x5555_5555_5555_5555UL); // Результат сумм по 2-а бита
result = (result & 0x3333_3333_3333_3333UL) + ((result >> 2) & 0x3333_3333_3333_3333UL); // Результат сумм по 4-е бита
result = (result + (result >> 4)) & 0x0F0F_0F0F_0F0F_0F0F; // Результат сумм по 8-ь бит
return result;
}
public static byte add64_bv(ulong value)
{
ulong result = value;
result += result >> 8; // Результат сумм по 16-ь бит
result += result >> 16; // Результат сумм по 32-ь бит
result += result >> 32; // Результат
return (byte)(result);
}
/*
* Подсчитать кол-во битов установленных в 1 в 64-разрядном числе
* Полностью эквивалентна машинной инструкции Intel x86/x64 - POPCNT
*/
public static byte popcnt64(ulong value)
{
ulong result = value;
result = result - ((result >> 1) & 0x5555_5555_5555_5555UL); // Результат сумм по 2-а бита
result = (result & 0x3333_3333_3333_3333UL) + ((result >> 2) & 0x3333_3333_3333_3333UL); // Результат сумм по 4-е бита
result = (result + (result >> 4)) & 0x0F0F_0F0F_0F0F_0F0F; // Результат сумм по 8-ь бит
result += result >> 8; // Результат сумм по 16-ь бит
result += result >> 16; // Результат сумм по 32-ь бит
result += result >> 32; // Результат
return (byte)(result);
}
public static byte popcnt8(byte value)
{
ulong result = value;
result = result - ((result >> 1) & 0x55); // Результат сумм по 2-а бита
result = (result & 0x33) + ((result >> 2) & 0x33); // Результат сумм по 4-е бита
result = (result + (result >> 4)) & 0x0F; // Результат сумм по 8-ь бит
return (byte)(result);
}
public static int bsf64(ulong value)
{
if (value == 0) return -1;
int bitpos = 0;
ulong mask = 0xFFFF_FFFF_FFFF_FFFFUL;
int step = 64;
while ((step >>= 1) > 0)
{
if ((value & (mask >>= step)) == 0)
{
value >>= step;
bitpos |= step;
}
}
return bitpos;
}
}
}
```
Результат программы:
Оптимизированный вывод алгоритма
В консоли видно эталонное число найденных комбинаций равное 92, и количество переборов равное 672.
В прототипе присутствует флажок-переменная "smart\_check". Установка его в FALSE приведет к отключению моей оптимизации. Тогда вывод в консоль станет классическим.
Стандартный вывод алгоритма2056 ./ 672 = 3,05
Оптимизация на количестве переборов выше в 3-и раза.
P.S. Продолжение возможно последует...
UPDATE!!! 27/07/2022
P.P.S. Уже появилась уточненная версия алгоритма (1а), где дополнительно анализируются не только колонки, но и строки, на возможность поставить в них ферзя или поставить единственно возможного ферзя. На данный момент вывод результата выглядит, так:
Версия алгоритма 1аУпало количество ходов перебора (-80) и реверс-шагов (-140). | https://habr.com/ru/post/679200/ | null | ru | null |
# Tips and Tricks по программированию на Android
Летом друг подкинул пару заказов по разработке для Android. Первое это streaming проигрыватель видео для одного французского телевидения, второе — простенькая игрушка.
Во время разработки (мой первый опыт разработки на Android и на Java), я уяснил несколько правил, которые нужно соблюдать для корректной и устойчивой работы программ, которыми хочу поделится…
Возможно для профессионалов статья будет не интересной, но для новичков, которые впервые столкнулись с разработкой под мобильные устройства, информация будет полезной.
#### Примеры
Для наглядности я создал небольшой проект, в котором приведено несколько примеров к правилам ниже.
Исходники: [fileshare.in.ua/3050399](http://fileshare.in.ua/3050399)
APK: [fileshare.in.ua/3050402](http://fileshare.in.ua/3050402)
#### Правило 1. Не выполняйте сложные операции в UI потоке
Выполнение каких-либо сложных операция в UI потоке приведет к тому что UI будет недоступен пользователю (т. е. будет «висеть»). При этом любые действия пользователя, во время таких «подвисаний», могут привести к появлению сообщения о том что приложение зависло, с предложением закрыть его.
Поэтому все сложные вычисления стоит выносить в отдельный поток.
**На примере:**
Посмотреть как не нужно делать, и к чему это приводит можно нажав кнопку «Do all on UI thread». В момент нажатия, происходит создание дочернего Activity у которого в методе onCreate() стоит псевдо-сложная операция, которая занимает 20 секунд. После нажатия, при попытке нажать кнопку Back телефона, выскакивает сообщение о том что приложение «подвисло».
При нажатии кнопки «Do hard operation with separate thread» основного окна, произойдет создание Activity и потока для выполнения сложной операции.
#### Правило 2.Используйте адаптеры правильно
При работе с нестандартными списками, создание строк происходит по средствам скрытого вызова метода getView() адаптера, установленного для данного списка.
В getView() адаптера, разработчику предоставляется возможность создать строку любого вида. Например:
**Пример:**
*Как не надо делать:*
> `@Override
>
> public View getView(int position, View convertView, ViewGroup parent) {
>
> final View view = mInflater.inflate(R.layout.row, null);
>
>
>
> TextView tv\_programm = (TextView) view.findViewById(R.id.channel\_proramm);
>
> TextView tv\_starttime = (TextView) view.findViewById(R.id.time\_start);
>
> TextView tv\_endtime = (TextView) view.findViewById(R.id.time\_end);
>
> ImageView ib\_logo = (ImageView) view.findViewById(R.id.channel\_logo);
>
> ProgressBar pb\_progress = (ProgressBar) view.findViewById(R.id.programm\_progress);
>
>
>
> tv\_programm.setFocusable(false);
>
> tv\_starttime.setFocusable(false);
>
> tv\_endtime.setFocusable(false);
>
> ib\_logo.setFocusable(false);
>
> pb\_progress.setFocusable(false);
>
>
>
> ib\_logo.setClickable(false);
>
>
>
> final String name = mNames[position];
>
> if ( name != null ) {
>
> tv\_programm.setText(name);
>
> }
>
> return view;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут для каждой строки списка вызывается создание нового объекта View. В результате, при перелистывании списка, мы получим засорение памяти объектами которые не отображаются. И следовательно Garbage Collector будет вызываться чаще (см. правило 3).
*Как правильно делать:*
> `private class ViewHolder {
>
> TextView tv\_programm;
>
> TextView tv\_starttime;
>
> TextView tv\_endtime;
>
> ImageView ib\_logo;
>
> ProgressBar pb\_progress;
>
> }
>
>
>
> @Override
>
> public View getView(int position, View convertView, ViewGroup parent) {
>
> ViewHolder holder = null;
>
> if ( convertView == null ) {
>
> convertView = mInflater.inflate(R.layout.row, null);
>
>
>
> holder = new ViewHolder();
>
> holder.tv\_programm = (TextView) convertView.findViewById(R.id.channel\_proramm);
>
> holder.tv\_starttime = (TextView) convertView.findViewById(R.id.time\_start);
>
> holder.tv\_endtime = (TextView) convertView.findViewById(R.id.time\_end);
>
> holder.ib\_logo = (ImageView) convertView.findViewById(R.id.channel\_logo);
>
> holder.pb\_progress = (ProgressBar) convertView.findViewById(R.id.programm\_progress);
>
>
>
> holder.tv\_programm.setFocusable(false);
>
> holder.tv\_starttime.setFocusable(false);
>
> holder.tv\_endtime.setFocusable(false);
>
> holder.ib\_logo.setFocusable(false);
>
> holder.pb\_progress.setFocusable(false);
>
>
>
> holder.ib\_logo.setClickable(false);
>
>
>
> convertView.setTag(holder);
>
> } else {
>
> holder = (ViewHolder) convertView.getTag();
>
> }
>
>
>
> final String name = mNames[position];
>
> if ( name != null ) {
>
> holder.tv\_programm.setText(name);
>
> }
>
> return convertView;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В этом примере будет создано только то количество объектов, которое помещается на экране. И для прорисовки новых строк списка, будут использоваться объекты не отображенные в данный момент. Т. е. объекты будут переиспользоваться, без создания новых.
**В чем выигрыш?**
В примере к правилу 2 (кнопки «Use incorrect list adapter» и «Use correct list adapter»), создается список из 1000 строк.
При запуске, приложения использует 3% общей памяти устройства.
При перелистывании списка с неправильным использованием адаптера, необходимо дополнительно 14% памяти устройства, что бы пролистать список до последнего элемента. При этом прорисовка происходит дерганно.
Если использовать адаптер правильно, дополнительно используется <=1% и перелистывание проходит плавно.
#### Правило 3. Поменьше выделений памяти (Java и Garbage Collector)
Это правило наверное знакомо каждому разработчику Java. Но т. к. я раньше программировал на C++, Garbage Collector (aka GC) был для меня в новинку.
Чем чаще происходит создание и удаление объектов, тем чаще вызывается GC. А каждый вызов GC занимает 100-200мс. При этом все потоки на время выполнения GC останавливаются. При этом прорисовка кадров может быть заметна (порой <10 fps).
#### Заключение:
Это только малая часть того что мне удалось почерпнуть, пока работал с Android, и если тема кому-то будет интересна, буду писать следующую порцию советов и трюков.
#### Полезные ссылки:
[android-developers.blogspot.com](http://android-developers.blogspot.com/) — блог разработчиков Android
[developer.android.com/videos/index.html](http://developer.android.com/videos/index.html) — видео о разработке под Android
Особенно советую посмотреть:
Google I/O 2009 — Make your Android UI Fast and Efficient. — Правило 2 взято отсюда.
Google I/O 2009 — Writing Real-Time Games for Android. — Правило 3.
**UPD:** спасибо за карму, перенес в Android
**UPD2:** спасибо хабрапользователю [i\_home](https://geektimes.ru/users/i_home/) за еще одну полезную ссылку [small-coding.blogspot.com](http://small-coding.blogspot.com/) в [комментариях](http://habrahabr.ru/blogs/android/78570/#comment_2298428) | https://habr.com/ru/post/78570/ | null | ru | null |
# Свой tor2web-сервис при помощи Nginx и Lua
Обсудим, как сделать шлюз из Интернета в скрытые сайты Tor.
Сеть [Tor](https://www.torproject.org) — это система прокси-серверов, позволяющая устанавливать анонимное сетевое соединение. С помощью Tor можно анонимно подключаться к обычным серверам и хостить непрослушиваемые серверы в самой сети Tor. В последнем случае создается скрытый сервер в зоне onion. Имя сервера включает 16 букв и цифр (фингерпринт).
Как можно заходить на скрытые серверы:
1. установить Tor и направить через него трафик браузера. [Tor-браузер](https://www.torproject.org/projects/torbrowser.html.en) — это portable-приложения, которое включает всё необходимое;
2. однако не все люди устанавливают Tor-браузер, поэтому нужен способ показать содержимое скрытого сервера обычному пользователю сети. На помощь приходят сервисы tor2web, предоставляющие прямой доступ к скрытым сайтам.
Сайт Hidden Wiki ([kpvzxxbbraaigawj.onion](http://kpvzxxbbraaigawj.onion)) можно открыть в обычном браузере ([kpvzxxbbraaigawj.tor2web.fi](http://kpvzxxbbraaigawj.tor2web.fi)). Если пользователь подключается к сайту через tor2web, то он теряет анонимность в обмен на доступ к скрытому сайту без установки Tor. Приведу список подобных сервисов, некоторые из которых закрылись.
* \*.Tor2web.org (3 сервера)
* \*.Tor2web.fi
* \*.Tor2web.blutmagie.de
* \*.onion.sh (отключен)
* \*.onion.to (отключен)
* \*.onion.lu (отключен)
* \*.t2w.pw (отключен)
* \*.tor2web.ae.org (отключен)
Рассмотрим существующие способы запустить tor2web-сервис, после чего я поделюсь своим собственным.
Проект Tor2web-3.0?
-------------------
[Tor2web-3.0](https://github.com/globaleaks/Tor2web-3.0) — важная часть проекта [GlobaLeaks](https://en.wikipedia.org/wiki/GlobaLeaks), которая облегчает доступ пользователей сети к скрытым серверам.
Пример сайта: [kpvzxxbbraaigawj.tor2web.org](https://kpvzxxbbraaigawj.tor2web.org)
К проекту Tor2web-3.0 подключено 3 сервера. Можно установить Tor2web на свой сервер и примкнуть к их сети. Отключенные серверы .lu и .to [принадлежат](https://www.whonix.org/forum/index.php?topic=295.0) тем же людям.
Tor2web-3.0 устанавливается как отдельная служба. Код написан на Python. К Tor2web-3.0 практически нет нареканий, но мне хотелось избежать дополнительного участника (пользователь — Nginx — Tor2web-3.0 — Tor — целевой сайт). Кроме того, мне не по душе сетевой софт, написанный на Python.
Polipo?
-------
[Polipo](http://www.pps.univ-paris-diderot.fr/~jch/software/polipo/) — HTTP-сервер, который умеет перенаправлять подключения в SOCK5-сервер. Раньше Polipo использовался для этой цели в составе Tor-браузера.
Можно было бы выстроить цепочку: Nginx — Polipo — Tor. Как и в случае с Tor2web-3.0, возникает лишний участник, так как Nginx не умеет проксировать трафик через SOCK5-сервер. Кроме того, для нормального отображения сайтов хочется заменять в ответе сервера onion-ссылки ссылками на шлюз: s/.onion/.onion.xx/
Патчим Nginx?
-------------
Существует [патч](http://mailman.nginx.org/pipermail/nginx-devel/2013-January/003302.html) для Nginx, который добавляет возможность проксировать трафик через SOCK5-сервер. На самом деле, [протокол SOCKS5](https://tools.ietf.org/html/rfc1928) очень простой, поэтому странно, что до сих пор нет официального модуля. Это решение выглядит заманчивым, но оно не доведено до ума: пришлось бы патчить Nginx при каждом обновлении. Хочется иметь решение, которое бы работало на обычном Nginx из ~~коробки~~ Debian Wheezy. Кроме того, нет возможности заменять ссылки в ответе сервера.
Пишем модуль для Nginx на Lua
-----------------------------
Nginx давно поддерживает [возможность](http://wiki.nginx.org/HttpLuaModule) встраивать сценарии на Lua. Коду на Lua предоставляется широкий круг возможностей, в том числе манипуляции с сокетами прямого доступа. К сожалению, модуль для подключения к SOCKS5-серверу я не нашел, поэтому написал [свой](https://github.com/starius/lua-resty-socks5). Для каждого запроса устанавливается соединение с программой Tor через порт 9050, проходит рукопожатие SOCKS5 и передаётся адрес целевого сайта. После этого сокет используется, как если бы это был прямой сокет к целевому сайту. Запрос пользователя считывается в память, редактируется и передаётся серверу. Ответ сервера считывается, редактируется (замена ссылок) и передается пользователю. Все операции неблокирующие. Эту часть я оформил как отдельный модуль [onion2web](https://github.com/starius/onion2web).
При первом подключении к сайту пользователь видит заглушку с формой подтверждения захода на сайт. Это нужно, чтобы нельзя было включать картинки со скрытых сервисов в страницы обычных сайтов.
Модуль socks5 содержит функции, с помощью которых сокет пробрасывается через SOCK5-сервер. Функции описаны на [страничке модуля](https://github.com/starius/lua-resty-socks5). Модуль onion2web содержит одну функцию handle\_onion2web, которая обслуживает tor2web-шлюз. Пример использования см. ниже. Есть возможность задать адрес и порт тора и отключить форму подтверждения захода на сайт.
Недоработки:
* реализован очень простой HTTP-клиент версии 1.0, в котором отключены keep-alive и сжатие передаваемых данных.
* Запрос и ответ читаются целиком в память, после чего передаются получателю. Это увеличивает расход памяти и замедляет передачу информации, особенно в направлении от сайта к пользователю. Подозреваю, что с SOCKS5-сервером нужно общаться в отдельной [сопрограмме](http://wiki.nginx.org/HttpLuaModule#ngx.thread.spawn). Возникнут сложности с подменой адресов в ответе сервера (граница блоков данных может прийтись на заменяемый адрес).
* Форма загрушки не содержит защиты от CSRF и всегда перенаправляет на главную страницу (лучше перенаправлять на путь, который был открыт изначально).
* Ответ сервера надо редактировать более аккуратно: заменять ссылки только в HTML и только в атрибутах.
На этом варианте я и остановился и использовал его для своего [tor2web-шлюза](http://onion.gq). К недостаткам самого сайта можно отнести отсутствие SSL. Думаю, есть и другие недостатки. И вообще пока решение скорее костыльное.
Как поднять свой tor2web-шлюз
-----------------------------
Нужны домен, сервер и [wildcard SSL-сертификат](https://en.wikipedia.org/wiki/Wildcard_certificate) на этот домен.
В домене нужно прописать всем поддоменам IP-адрес нашего сервера:
На сервере потребуется Tor, Nginx со свежим ngx\_lua и мой модуль onion2web для подключения к SOCKS5-серверу из Nginx. В Debian Wheezy есть пакет nginx-extras, который содержит слишком старый ngx\_lua. (Этой старый ngx\_lua не поддерживает некоторых используемых методов, например, ngx.req.raw\_header.) Версия nginx-extras из wheezy-backports содержит достаточно свежий ngx\_lua. Модуль onion2web можно установить через luarocks (это автоматически установит модуль socks5 как зависимость).
Установка для Debian Wheezy:
```
# echo deb http://ftp.us.debian.org/debian/ wheezy-backports main > /etc/apt/sources.list.d/wheezy-backports.list
# apt-get update
# apt-get install tor luarocks nginx-extras/wheezy-backports
# luarocks install onion2web
```
В Nginx создаем такой сайт:
```
server {
listen 80;
server_name *.onion.gq;
location / {
default_type text/html;
content_by_lua '
require("onion2web").handle_onion2web(".onion.gq");
';
}
}
```
Домен фигурирует в конфиге в двух местах: server\_name и внутри Lua-кода.
Сайт готов: [kpvzxxbbraaigawj.onion.gq](http://kpvzxxbbraaigawj.onion.gq/)
Исходники модуля socks5: [github.com/starius/lua-resty-socks5](https://github.com/starius/lua-resty-socks5)
Исходники модуля onion2web: [github.com/starius/onion2web](https://github.com/starius/onion2web) | https://habr.com/ru/post/243055/ | null | ru | null |
# Новый алгоритм трассировки пути для оптимизации работы GPU: Wavefront Path Tracing
В этой статье мы исследуем важную концепцию, используемую в недавно выпущенной платформе Lighthouse 2. [Wavefront path tracing](https://research.nvidia.com/publication/megakernels-considered-harmful-wavefront-path-tracing-gpus), как её называют Лейн, Каррас и Аила из NVIDIA, или streaming path tracing, как она изначально называлась в [магистерской диссертации](http://resolver.tudelft.nl/uuid:4a5be464-dc52-4bd0-9ede-faefdaff8be6) ван Антверпена, играет важнейшую роль в разработке эффективных трассировщиков пути на GPU, а потенциально и трассировщиков пути на CPU. Однако она довольно контринтуитивна, поэтому для её понимания необходимо переосмыслить алгоритмы трассировки лучей.
Occupancy
---------
Алгоритм трассировки пути на удивление прост и его можно описать всего в нескольких строках псевдокода:
```
vec3 Trace( vec3 O, vec3 D )
IntersectionData i = Scene::Intersect( O, D )
if (i == NoHit) return vec3( 0 ) // ray left the scene
if (i == Light) return i.material.color // lights do not reflect
vec3 R, pdf = RandomDirectionOnHemisphere( i.normal ), 1 / 2PI
return Trace( i.position, R ) * i.BRDF * dot( i.normal, R ) / pdf
```
Входящими данными является *первичный луч*, проходящий из камеры через пиксель экрана. Для этого луча мы определяем ближайшее пересечение с примитивом сцены. Если пересечений нет, то луч исчезает в пустоте. В противном случае, если луч дойдёт до источника света, то мы нашли путь прохождения света между источником и камерой. Если мы найдём что-то другое, то выполняем отражение и рекурсию, надеясь, что отражённый луч всё-таки найдёт источник освещения. Заметьте, что этот процесс напоминает (обратный) путь фотона, отражающегося от поверхностей сцены.
GPU предназначены для выполнения этой задачи в многопоточном режиме. Поначалу может показаться, что трассировка лучей идеально подходит для этого. Итак, мы используем OpenCL или CUDA для создания потока для пикселя, каждый поток выполняет алгоритм, который и в самом деле работает, как задумано, и при этом довольно быстр: достаточно взглянуть на несколько примеров с ShaderToy, чтобы понять [насколько](https://www.shadertoy.com/view/4sfGDB) [быстрой](https://www.shadertoy.com/view/4sXGDs) [может](https://www.shadertoy.com/view/4ljGRd) [быть](https://www.shadertoy.com/view/XdB3Dw) [трассировка](https://www.shadertoy.com/view/llXSWr) [лучей](https://www.shadertoy.com/view/4lB3D1) на GPU. Но как бы то ни было, вопрос в другом: действительно ли эти трассировщики лучей *максимально быстры*?
У этого алгоритма есть проблема. Первичный луч может найти источник света сразу же, или после одного случайного отражения, или спустя пятьдесят отражений. Программист для CPU заметит здесь потенциальное переполнение стека; программист для GPU должен увидеть *проблему занятости (occupancy)*. Проблема вызвана условной хвостовой рекурсией: путь может завершиться на источнике света или продолжаться дальше. Перенесём это на множество потоков: часть потоков прекратится, а другая часть продолжит работу. Через несколько отражений у нас останется несколько потоков, которым нужно продолжать вычисления, а большинство потоков будет ждать завершения работы этих последних потоков. Понятие *«занятость»* — это мера части потоков GPU, выполняющих полезную работу.
Проблема занятости относится и к модели выполнения SIMT устройств GPU. Потоки упорядочены в группы, например в GPU Pascal (оборудование NVidia класса 10xx) 32 потока объединяются в *warp*. Потоки в warp имеют общий счётчик программы: они выполняются с фиксированным шагом, поэтому каждая инструкция программы выполняется 32 потоками одновременно. SIMT расшифровывается как *single instruction multiple thread («одна инструкция, много потоков»)*, что хорошо описывает концепцию. Для процессора SIMT код с условиями представляет сложности. Это наглядно показано в официальной документации Volta:
*Выполнение кода с условиями в SIMT.*
Когда некое условие истинно для некоторых потоков в warp, ветви оператора *if*-сериализуются. Альтернативой подходу «все потоки выполняют одно и то же» является «некоторые потоки отключены». В блоке if-then-else средняя занятость warp будет равна 50%, если только у всех потоков не будет согласованности относительно условия.
К сожалению, код с условиями в трассировщике лучей встречается не так редко. Лучи теней испускаются, только если источник освещения не находится за точкой затенения, разные пути могут сталкиваться с разными материалами, интегрирование методом «русской рулетки» может уничтожить или оставить путь в живых, и так далее. Выясняется, что occupancy становится основным источником неэффективности, и без чрезвычайных мер её предотвратить не так уж просто.
Streaming Path Tracing
----------------------
Алгоритм streaming path tracing (потоковой трассировки пути) разработан для устранения корневой причины проблемы занятости. Streaming path tracing разделяет алгоритм трассировки пути на четыре этапа:
1. **Сгенерировать**
2. **Продлить**
3. **Затенить**
4. **Соединить**
Каждый этап реализуется как отдельная программа. Поэтому вместо выполнения полного трассировщика пути как одной программы GPU («ядра», kernel) нам придётся работать с *четырьмя* ядрами. Кроме того, как мы скоро увидим, они выполняются в цикле.
**Этап 1 («Сгенерировать»)** отвечает за генерацию первичных лучей. Это простое ядро, создающее начальные точки и направления лучей в количестве, равном количеству пикселей. Выходными данными этого этапа являются большой буфер лучей и счётчик, сообщающий следующему этапу количество лучей, которое нужно обработать. Для первичных лучей эта величина равна *ширине экрана*, умноженной на *высоту экрана*.
**Этап 2 («Продлить»)** — это второе ядро. Оно выполняется только после того, как этап 1 будет завершён для всех пикселей. Ядро считывает буфер, сгенерированный на этапе 1, и пересекает каждый луч со сценой. Выходными данными этого этапа становится результат пересечения для каждого луча, сохраняемый в буфере.
**Этап 3 («Затенить»)** выполняется после полного завершения этапа 2. Он получает результат пересечения с этапа 2 и вычисляет модель затенения для каждого пути. Эта операция может генерировать новые лучи или не создавать их, в зависимости от того, завершился ли путь. Пути, порождающие новый луч (путь «продлевается») записывает новый луч («отрезок пути») в буфер. Пути, непосредственно сэмплирующие источники освещения («явное сэмплирование освещения» или «вычисление следующего события») записывают луч тени во второй буфер.
**Этап 4 («Соединить»)** трассирует лучи тени, сгенерированные на этапе 3. Это похоже на этап 2, но с важным отличием: лучам тени достаточно найти *любое* пересечение, в то время как продлевающим лучам нужно было найти ближайшее пересечение. Поэтому для этого создано отдельное ядро.
После завершения этапа 4 у нас получится буфер, содержащий лучи, продлевающие путь. Взяв эти лучи, мы переходим к этапу 2. Продолжаем делать это, пока не останется продлевающих лучей или пока не достигнем максимального количества итераций.
Источники неэффективности
-------------------------
Озабоченный производительностью программист увидит в такой схеме алгоритмов streaming path tracing множество опасных моментов:
* Вместо единственного вызова ядра у нас теперь есть *по три вызова на итерацию*, плюс ядро генерации. Вызовы ядер означают определённое повышение нагрузки, поэтому это плохо.
* Каждой ядро считывает огромный буфер и записывает огромный буфер.
* CPU должен знать, сколько потоков нужно порождать для каждого ядра, поэтому GPU должен сообщать CPU, сколько лучей было сгенерировано на этапе 3. Перемещение информации из GPU в CPU — это плохая идея, а оно требуется как минимум один раз на итерацию.
* Как этап 3 записывает лучи в буфер, не создавая при этом повсюду пробелы? Он ведь не использует для этого атомарный счётчик?
* Количество активных путей всё равно снижается, так как же эта схема вообще может помочь?
Начнём с последнего вопроса: если мы передадим в GPU миллион задач, он не породит миллион потоков. Истинное количество выполняемых одновременно потоков зависит от оборудования, но в общем случае выполняются десятки тысяч потоков. Только при падении нагрузки ниже этого числа мы заметим проблемы занятости, вызванные малым количеством задач.
Также беспокойство вызывает масштабный ввод-вывод буферов. Это и в самом деле сложность, но не такая серьёзная, как можно ожидать: доступ к данным сильно предсказуем, особенно при записи в буферы, поэтому задержка не вызывает проблем. На самом деле, для такого типа обработки данных и были в первую очередь разработаны GPU.
Ещё один аспект, с которым GPU очень хорошо справляются — это атомарные счётчики, что довольно неожиданно для программистов, работающих в мире CPU. Для z-буфера требуется быстрый доступ, и поэтому реализация атомарных счётчиков в современных GPU чрезвычайно эффективна. На практике атомарная операция записи столь же затратна, как некэшированная запись в глобальную память. Во многих случаях задержка будет замаскирована масштабным параллельным выполнением в GPU.
Остаются два вопроса: вызовы ядер и двухсторонняя передача данных для счётчиков. Последний и в самом деле представляет собой проблему, поэтому нам необходимо ещё одно архитектурное изменение: *постоянные потоки (persistent threads)*.
Последствия
-----------
Прежде чем углубляться в подробности, мы рассмотрим последствия использования алгоритма wavefront path tracing. Во-первых, скажем про буферы. Нам нужен буфер для вывода данных этапа 1, т.е. первичных лучей. Для каждого луча нам необходимы:
* Точка начала луча (ray origin): три значения float, то есть 12 байт
* Направление луча (ray direction): три значения float, то есть 12 байт
На практике лучше увеличить размер буфера. Если хранить по 16 байт для начала и направления луча, то GPU сможет считывать их за одну 128-битную операцию считывания. Альтернативой является 64-битная операция считывания с последующей 32-битной операцией для получения float3, что почти в два раза медленнее. То есть для экрана 1920×1080 мы получаем: 1920x1080x32=~64 МБ. Также нам понадобится буфер для результатов пересечения, созданных ядром «Продлить». Это ещё по 128 бит на элемент, то есть 32 МБ. Далее, ядро «Затенить» может создать до 1920×1080 продлений пути (верхний предел), и мы не можем записывать их в буфер, из которого считываем. То есть ещё 64 МБ. И, наконец, если наш трассировщик пути испускает лучи тени, то это ещё один буфер на 64 МБ. Просуммировав всё, мы получаем 224 МБ данных, и это только для алгоритма фронта волны. Или около 1 ГБ при разрешении 4K.
Здесь нам нужно привыкнуть к ещё одной особенности: памяти у нас в избытке. Может показаться. что 1 ГБ — это много, и существуют способы снижения этого числа, но если подойти к этому реалистично, то к тому времени, когда нам действительно понадобится трассировать пути в 4K, использование 1 ГБ на GPU с 8 ГБ будет меньшей из наших проблем.
Более серьёзной, чем требования к памяти, проблемой станут последствия для алгоритма рендеринга. Пока я предполагал, что нам нужно генерировать один продлевающий луч и, возможно, по одному лучу тени для каждого потока в ядре «Затенить». Но что если мы хотим выполнить Ambient Occlusion, использовав 16 лучей на пиксель? 16 лучей AO нужно хранить в буфере, но, что ещё хуже, они появятся только в следующей итерации. Похожая проблема возникает при трассировке лучей в стиле Уиттеда: испускание луча тени для нескольких источников освещения или разделение луча при столкновении со стеклом реализовать почти невозможно.
С другой стороны, wavefront path tracing решает проблемы, которые мы перечислили в разделе «Occupancy»:
* На этапе 1 все потоки без условий создают первичные лучи и записывают их в буфер.
* На этапе 2 все потоки без условий пересекают лучи со сценой и записывают результаты пересечения в буфер.
* На этапе 3 мы начинаем вычисление результатов пересечений с занятостью 100%.
* На этапе 4 мы обрабатываем непрерывный список лучей тени без пробелов.
Ко времени, когда мы вернёмся на этап 2 с оставшимися в живых лучами с длиной в 2 отрезка, у нас снова получился компактный буфер лучей, гарантирующий при запуске ядра полную занятость.
Кроме того, имеется и дополнительное преимущество, которое не стоит недооценивать. Код в четырёх отдельных этапах изолирован. Каждое ядро может использовать все доступные ресурсы GPU (кэш, общую память, регистры) без учёта других ядер. Это может позволить GPU выполнять код пересечения со сценой в большем количестве потоков, потому что этот код не требует такого большого количества регистров, как код затенения. Чем больше потоков, тем лучше можно спрятать задержки.
Полная занятость, улучшенная маскировка задержек, потоковая запись: все эти преимущества непосредственно связаны с возникновением и природой платформы GPU. Для GPU алгоритм wavefront path tracing очень естественен.
Стоит ли оно того?
------------------
Разумеется, у нас возникает вопрос: оправдывает ли оптимизированная занятость ввод-вывод из буферов и затраты на вызов дополнительных ядер?
Ответ положительный, однако доказать это не так легко.
Если мы на секунду вернёмся к трассировщикам пути с ShaderToy, то увидим, что в большинстве из них используется простая и жёстко заданная сцена. Замена её на полномасштабную сцену — нетривиальная задача: для миллионов примитивов пересечение луча и сцены становится сложной проблемой, решение которой часто оставляют для NVidia ([Optix](https://developer.nvidia.com/optix)), AMD( [Radeon-Rays](https://gpuopen.com/gaming-product/radeon-rays/)) или Intel ([Embree](https://www.embree.org/)). Ни один из этих вариантов не сможет легко заменить жёстко прописанную сцену в искусственном трассировщике лучей CUDA. В CUDA ближайший аналог (Optix) требует контроля над выполнением программы. Embree в CPU позволяет трассировать отдельные лучи из вашего собственного кода, но ценой этого становятся значительные затраты производительности: он предпочитает трассировать вместо отдельных лучей большие группы лучей.
*Экран из «It's About Time», отрендеренного с помощью Brigade 1.*
Будет ли wavefront path tracing быстрее своей альтернативы («мегаядра» (megakernel), как его называют Лейн с коллегами), зависит от времени, проводимого в ядрах (большие сцены и затратные шейдеры снижают относительное превышение затрат алгоритмом фронта волны), от максимального длины пути, занятости мегаядра и разницы в нагрузке на регистры на четырёх этапах. В ранней версии оригинального [трассировщика пути Brigade](https://www.researchgate.net/publication/258395638_The_Brigade_Renderer_A_Path_Tracer_for_Real-Time_Games) мы обнаружили, что даже простая сцена со смешением отражающих и ламбертовых поверхностей, запущенная на GTX480, выигрывала от использования wavefront.
Streaming Path Tracing в Lighthouse 2
-------------------------------------
В платформе Lighthouse 2 есть два трассировщика пути wavefront path tracing. Первый использует для реализации этапов 2 и 4 Optix Prime (этапы пересечения лучей и сцены); во второй для реализации той функциональности используется непосредственно Optix.
Optix Prime — это упрощённая версия Optix, которая только занимается пересечением набора лучей со сценой, состоящей из треугольников. В отличие от полной библиотеки Optix, она не поддерживает пользовательского кода пересечений, и пересекает только треугольники. Однако для wavefront path tracer именно это и требуется.
Wavefront path tracer на основе Optix Prime реализован в `rendercore.cpp` проекта `rendercore_optixprime_b`. Инициализация Optix Prime начинается в функции `Init` и использует `rtpContextCreate`. Сцена создаётся с помощью `rtpModelCreate`. Различные буферы лучей создаются в функции `SetTarget` при помощи `rtpBufferDescCreate`. Заметьте, чтобы для этих буферов мы предоставляем обычные указатели устройств: это значит, что их можно использовать и в Optix, и в обычных ядрах CUDA.
Рендеринг начинается в методе `Render`. Для заполнения буфера первичных лучей используется ядро CUDA под названием `generateEyeRays`. После заполнения буфера при помощи `rtpQueryExecute` вызывается Optix Prime. С его помощью результаты пересечений записываются в `extensionHitBuffer`. Заметьте, что все буферы остаются в GPU: за исключением вызовов ядер трафик между CPU и GPU отсутствует. Этап «Затенить» реализован в обычном ядре CUDA `shade`. Его реализация находится в `pathtracer.cu`.
Некоторые подробности реализации `optixprime_b` стоят упоминания. Во-первых, лучи тени трассируются вне цикла фронта волны. Это правильно: луч тени влияет на пиксель, только если он не перекрыт, но во всех остальных случаях его результат больше нигде не нужен. То есть луч тени является *одноразовым*, его можно трассировать в любой момент и в любом порядке. В нашем случае мы используем это, группируя лучи тени, чтобы окончательно трассируемый батч был как можно бОльшим. У этого есть одно неприятное последствие: при *N* итерациях алгоритма фронта волны и *X* первичных лучах верхняя граница количества лучей тени равна *XN*.
Ещё одна деталь — это обработка различных счётчиков. Этапы «Продлить» и «Затенить» должны знать, сколько путей активно. Счётчики для этого обновляются в GPU (атомарно), а значит и используются в GPU, даже без возврата в CPU. К сожалению, в одном из случаев это невозможно: библиотеке Optix Prime необходимо знать количество трассируемых лучей. Для этого нам раз в итерацию нужно возвращать информацию счётчиков.
Заключение
----------
В этой статье объясняется, что такое wavefront path tracing, и почему она необходима для эффективного выполнения трассировки пути на GPU. Её практическая реализация представлена в платформе Lighthouse 2, имеющей открытые исходники и [доступной на Github](https://github.com/jbikker/lighthouse2/blob/master/README.md). | https://habr.com/ru/post/461017/ | null | ru | null |
# Google Earth Engine (GEE) как общедоступный суперкомпьютер
Сервис [Google Earth Engine](https://code.earthengine.google.com) предоставляет возможность бесплатно работать с огромными массивами пространственной информации. К примеру, в считанные минуты можно получить композитную мозаику (сборное изображение) по миллиону космоснимков. Считая, что каждая сцена (набор спектральных каналов) Landsat 8 занимает в сжатом виде 1 ГБ, при таком запросе обрабатывается объем информации порядка 1 ПБ. И все это доступно бесплатно, быстро, и в любое время. Но есть такое мнение (неправильное), что GEE на бесплатных аккаунтах позволяет обработать и экспортировать лишь небольшие наборы данных. На самом деле, такое впечатление вызвано лишь тем, что программировать на GEE можно начать, даже не читая документации сервиса, а вот извлечь много данных, все еще не читая документации, уже не получится. Далее мы рассмотрим три разных решения задачи векторизации растров и двумя разными способами напишем серверную GEE функцию для вычисления геохэша.
Введение
--------
А вы любите работать на суперкомпьютерах (это университетские кластеры, к примеру)? Я — нет! Несмотря на всю их мощь, на практике зачастую полезность таких монстров совсем не очевидна. Вы можете меня упрекнуть в пристрастности (и это правда — для меня линукс дебиан, конечно, лучший, и убунта как его непутевый потомок тоже на что-то годится), но работать на околодесятилетней давности линуксе центос это совсем перебор (он и свежий-то всегда второй свежести, если глянуть на версии пакетов в нем). Впрочем, это еще цветочки. Чтобы зря не тратить драгоценные ресурсы суперкомпьютеров, на них обычно установлен коммерческий компилятор интел, притом очень мохнатого года (может быть старше самого центоса, который, видимо, когда-то уже обновляли). Но и это еще не беда, в конце концов. Планировщики ресурсов на таких системах часто вызывают оторопь, и есть с чего — при попытке запустить задание, скажем, на 128 ядрах, ничего не происходит, ни запуска задания, ни выдачи какой-либо ошибки от утилиты запуска. В процессе оказывается, что число доступных нам ядер равно двум (всегда удивляюсь, почему так мало по умолчанию дают ресурсов), увеличение квоты требует административной работы (зачастую, уже на этом этапе проще переключиться на какой-нибудь Amazon AWS). Но самое худшее начинается позже. С завидным постоянством бинарные модули того самого вышеупомянутого проприетарного компилятора оказываются установлены в домашней директории давно сгинувшего вместе со своей домашней директорией пользователя, а без них компилятор, естественно, ничего не компилирует. Конечно, другого компилятора в системе нет, ведь его код был бы не столь оптимален… Таким образом, ситуация проясняется — нам нужно найти подходящий центос, установить его где-то локально или в облаке, портировать на него нужный софт, сделать статические сборки (поскольку на целевой системе часть системных пакетов может быть заменена непонятно чем и откуда) и тогда, возможно, мы сможем все это запустить на доступных нам двух ядрах кластера (будет ли когда-нибудь доступно большее их количество — предугадать невозможно, по разным причинам). Я мог бы еще многое добавить, но вы уже понимаете, почему лично я не люблю суперкомпьютеры.
Теперь поговорим про другой суперкомпьютер — облачный и общедоступный сервис [Google Earth Engine](https://code.earthengine.google.com). Все, что нам потребуется для начала работы — открыть ссылку в браузере и можно начинать писать код на javascript и скачивать данные (кстати, можно туда загрузить еще и свои данные, а еще можно использовать API сервиса для доступа из других сред разработки и языков). При этом сразу же доступно огромное количество данных и вычислительных ресурсов. На мой взгляд, все это вполне заслуживает того, чтобы почитать-таки документацию и научиться работать в сервисе достаточно эффективно. Впрочем, обработка и получение растров достаточно очевидны и так, тем более, что ко всем предоставляемым в сервисе наборам данных есть и примеры их визуализации, а для их скачивания на Google Drive (к примеру) в растровом формате (обычно, GeoTIFF) достаточно функции Export.image.toDrive. А вот работа с векторными данными, тем более, преобразование растров в вектор далеко не так очевидны и в интернет зачастую можно встретить жалобы, что не удается выгрузить несколько сот тысяч записей. Вот специально сейчас проверил — за 21 минуту мне удалось выгрузить 10 миллионов записей на Google Drive в формате GeoJSON, получив файл размером 2Гб. И это далеко не предел для бесплатного аккаунта (не говоря уж о том, что можно выгружать данные по частям).
Преобразование растровых данных сервиса в точечные
--------------------------------------------------
Рассмотрим три подхода:
1. Простейший способ заключается в создании геометрии, включающей в себя требуемые точки, и получении для них атрибутов растра:
```
var points_with_attributes = Image.reduceRegion({
reducer: ee.Reducer.toList(Image.bandNames().size()),
geometry: points
})
```
Способ пригоден, в основном, при работе с векторными данными, которые мы хотим дополнить информацией с растров. Здесь мы априори знаем координаты всех точек и получаем для них атрибуты растра.
1. Способ поинтереснее предполагает преобразование в список всех пикселов растра, попадающих в указанную область. Извлечем сначала только атрибуты пикселов растра:
```
var attributes = Image.reduceRegion({
reducer: ee.Reducer.toList(Image.bandNames().size()),
geometry: some_area
})
```
Метод рабочий, но с подвохом и ресурсоемкий. В чем же подвох? Дело в том, что в некоторых точках растра атрибутивные данные могут быть пропущены и такие точки исключаются в данном методе. То есть метод возвращает от нуля до полного набора точек, которые попадают в заданную область. И как только мы захотим получить и координаты возвращаемых точек, метод может перестать работать (если в данных есть пропуски, как отмечено выше). Посмотрим код примера:
```
var latlon = ee.Image.pixelLonLat()
var points_with_attributes = image
.addBands(latlon)
.reduceRegion({
reducer: ee.Reducer.toList(),
geometry: some_area
});
```
Функция ee.Image.pixelLonLat() создает растр с координатами каждой точки, который мы добавляем к рабочему растру. Этот код прекрасно работает, но только пока в растровых данных нет пропусков и длины списков координат и атрибутов совпадают (по возможности, все операции сервисом GEE выполняются параллельно и, в результате, список по каждому каналу формируется независимо). Кроме того, необходимо добавить перепроецирование данных, но эта операция ресурсозатратная и сильно ограничивает наши возможности обработки данных на бесплатном аккаунте:
```
var latlon = ee.Image.pixelLonLat().reproject(image.projection())
var points_with_attributes = image
.addBands(latlon)
.reduceRegion({
reducer: ee.Reducer.toList(),
geometry: some_area
});
```
К счастью, возможно разом решить обе проблемы:
```
var latlon = ee.Image.pixelLonLat()
var points_with_attributes = image
.addBands(latlon)
.add(image.select(0).add(0))
.reduceRegion({
reducer: ee.Reducer.toList(),
geometry: some_area
});
```
Здесь мы принудительно выполняем бесполезное вычисление на данных (предполагается, что первый канал растра содержит числовые данные), чтобы унифицировать длину списков атрибутов и списков координат, а заодно и выполнить перепроецирование растра координат. В итоге, все координаты, для которых не определены атрибуты, будут удалены (это может во много раз уменьшить количество полученных точек), растр координат окажется спроецирован на растр атрибутов и данные будут корректно обработаны. Такой вот трюк, основанный на парадигме отложенных (ленивых) вычислений сервиса.
1. И, наконец, самый простой и быстрый способ, который позволит обработать много данных:
```
var latlon = ee.Image.pixelLonLat()
var points_with_attributes = image
.sample({
region: some_area,
geometries: true
});
```
В коде выше флаг "geometries" указывает, нужны ли нам координаты точек или только их атрибуты.
Создание собственных серверных функций
--------------------------------------
Обычно, кроме извлечения данных "как есть", мы еще хотим как-то их обработать. Это можно сделать локально, выгрузив данные, или непосредственно в сервисе GEE. Во втором случае, мы получаем огромные вычислительные ресурсы, но нужно написать специальный код для серверной обработки. Следует помнить, что в окне облачного редактора мы можем писать смесь клиентского и серверного кода (что часто приводит к различным ошибкам). Когда вы только начинаете писать серверные функции GEE, нужны рабочие примеры, но найти их сложно. Для примера напишем функцию вычисления [геохэша](https://en.wikipedia.org/wiki/Geohash), или хэша заметающей кривой (z-curve). Кстати, найти готовую реализацию такой функции мне не удалось, что еще раз подтверждает, как сложно начинающим найти примеры по серверным функциям GEE. Чем полезна такая функция? Кроме прочего, геохэш позволяет сделать пространственное объединение данных очень просто и без операций с геометрическими объектами — достаточно лишь сократить количество символов геохэша. Кодирование и декодирование геохэшей поддерживается в PostgreSQL/PostGIS, Google BigQuery и многих других системах. Итак, посмотрим простую реализацию функции в стиле С-кода:
```
var geohash_accumulate = function(obj, list) {
// define common variables
var base32 = ee.String('0123456789bcdefghjkmnpqrstuvwxyz'); // (geohash-specific) Base32 map
// get previous state variables
var prev = ee.Dictionary(ee.List(list).get(-1));
var lat = ee.Number(prev.get('lat',0));
var lon = ee.Number(prev.get('lon',0));
var idx = ee.Number(prev.get('idx',0));
var bit = ee.Number(prev.get('bit',0));
var evenBit = ee.Number(prev.get('evenBit',1));
var geohash = ee.String(prev.get('geohash',''));
var latMin = ee.Number(prev.get('latMin',-90));
var latMax = ee.Number(prev.get('latMax',90));
var lonMin = ee.Number(prev.get('lonMin',-180));
var lonMax = ee.Number(prev.get('lonMax',180));
// calculate substep bit step idx
// bisect E-W longitude
var lonMid = ee.Number(ee.Algorithms.If(evenBit.gt(0), lonMin.add(lonMax).divide(2), 0) );
idx = ee.Number(ee.Algorithms.If(evenBit.gt(0).and(lon.gte(lonMid)), idx.multiply(2).add(1), idx) );
lonMin = ee.Number(ee.Algorithms.If(evenBit.gt(0).and(lon.gte(lonMid)), lonMid, lonMin) );
idx = ee.Number(ee.Algorithms.If(evenBit.gt(0).and(lon.lt(lonMid)), idx.multiply(2), idx) );
lonMax = ee.Number(ee.Algorithms.If(evenBit.gt(0).and(lon.lt(lonMid)), lonMid, lonMax) );
// bisect N-S latitude
var latMid= ee.Number(ee.Algorithms.If(evenBit.eq(0), latMin.add(latMax).divide(2), 0) );
idx = ee.Number(ee.Algorithms.If(evenBit.eq(0).and(lat.gte(latMid)), idx.multiply(2).add(1), idx) );
latMin = ee.Number(ee.Algorithms.If(evenBit.eq(0).and(lat.gte(latMid)), latMid, latMin) );
idx = ee.Number(ee.Algorithms.If(evenBit.eq(0).and(lat.lt(latMid)), idx.multiply(2), idx) );
latMax = ee.Number(ee.Algorithms.If(evenBit.eq(0).and(lat.lt(latMid)), latMid, latMax) );
// check position
evenBit = evenBit.not();
bit = bit.add(1);
geohash = ee.String(ee.Algorithms.If(bit.eq(5), geohash.cat(base32.slice(idx,ee.Number(idx).add(1))), geohash));
idx = ee.Number(ee.Algorithms.If(bit.eq(5), ee.Number(0), idx));
bit = ee.Number(ee.Algorithms.If(bit.eq(5), ee.Number(0), bit));
// return state
var curr = prev
.set('idx', idx )
.set('bit', bit )
.set('evenBit', evenBit)
.set('geohash', geohash)
.set('latMin', latMin )
.set('latMax', latMax )
.set('lonMin', lonMin )
.set('lonMax', lonMax );
return ee.List([curr]);
};
function geohash_encode(lat, lon, precision) {
var init = ee.Dictionary({lat: lat, lon: lon})
var state = ee.List.sequence(1,precision*5).iterate(geohash_accumulate, ee.List([init]))
return ee.String(ee.Dictionary(ee.List(state).get(-1)).get('geohash'))
}
```
Сделаем также простую проверку полученных геохэшей
```
// PostGIS check from https://postgis.net/docs/ST_GeoHash.html
print (ee.Algorithms.If(geohash_encode(48, -126, 20).compareTo('c0w3hf1s70w3hf1s70w3'),'Error','OK'));
// Google BigQuery check from https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geohash
print (ee.Algorithms.If(geohash_encode(47.62, -122.35, 10).compareTo('c22yzugqw7'),'Error','OK'));
```
Вместо использования вложенных циклов в функции geohash\_encode() мы создаем функцию geohash\_accumulate() и вызываем ее 5 раз для вычисления каждого символа геохэша. С учетом того, что GEE лимитирует количество вызовов функций, это не слишком масштабируемое решение. Как можно улучшить функцию? Проще всего продублировать пятикратно участок кода под комментарием "calculate substep bit step idx" и вызывать полученную функцию geohash\_accumulate() лишь единожды для каждого вычисляемого символа (при желании, можно также сократить количество передаваемых между вызовами переменных). А можно и переписать код внутренней функции в функциональном стиле. Я, в общем-то, и не собирался этого делать, но пока я писал текст статьи, мне стало интересно попробовать и вот что получилось:
```
var geohash_accumulate = function(obj, list) {
// define common variables
var range4 = ee.List.sequence(0,4).map(function(val){return ee.Number(val).multiply(1/4)});
var range8 = ee.List.sequence(0,8).map(function(val){return ee.Number(val).multiply(1/8)});
// get previous state
var prev = ee.Dictionary(ee.List(list).get(-1))
var lat = ee.Number(prev.get('lat',0))
var lon = ee.Number(prev.get('lon',0))
var n = ee.Number(prev.get('n',0)).add(1)
var geohash = ee.String(prev.get('geohash',''))
var latMin = ee.Number(prev.get('latMin',-90))
var latMax = ee.Number(prev.get('latMax',90))
var lonMin = ee.Number(prev.get('lonMin',-180))
var lonMax = ee.Number(prev.get('lonMax',180))
// calculate step n
var base32 = ee.String(ee.Algorithms.If(n.mod(2).eq(1), '028b139c46df57eghksujmtvnqwyprxz', '0145hjnp2367kmqr89destwxbcfguvyz'));
var latRange = ee.List(ee.Number(ee.Algorithms.If(n.mod(2).eq(1), range4, range8)));
latRange = latRange.map(function(item){return ee.Number(item).multiply(latMax.subtract(latMin)).add(latMin)});
var lonRange = ee.List(ee.Number(ee.Algorithms.If(n.mod(2).eq(1), range8, range4)));
lonRange = lonRange.map(function(item){return ee.Number(item).multiply(lonMax.subtract(lonMin)).add(lonMin)});
var latIdx = latRange.indexOf(latRange.filter(ee.Filter.lte('item', lat)).get(-1));
latIdx = ee.Number(ee.Algorithms.If(latIdx.gte(latRange.size().add(-1)), latIdx.add(-1), latIdx));
var lonIdx = lonRange.indexOf(lonRange.filter(ee.Filter.lte('item', lon)).get(-1));
lonIdx = ee.Number(ee.Algorithms.If(lonIdx.gte(lonRange.size().add(-1)), lonIdx.add(-1), lonIdx));
var idx = lonIdx.multiply(latRange.size().add(-1)).add(latIdx);
// reset bounds
latMin = latRange.get(latIdx)
latMax = latRange.get(latIdx.add(1))
lonMin = lonRange.get(lonIdx)
lonMax= lonRange.get(lonIdx.add(1))
// define geohash symbol
var geohash = geohash.cat(base32.slice(idx,ee.Number(idx).add(1)));
// return state
var curr = prev
.set('n', n )
.set('geohash', geohash )
.set('latMin', latMin )
.set('latMax', latMax )
.set('lonMin', lonMin )
.set('lonMax', lonMax );
return ee.List([curr]);
};
function geohash_encode(lat, lon, precision) {
var init = ee.Dictionary({lat: lat, lon: lon})
var state = ee.List.sequence(1,precision).iterate(geohash_accumulate, ee.List([init]))
return ee.String(ee.Dictionary(ee.List(state).get(-1)).get('geohash'))
}
```
Да, это та же самая функция, только уже в Javascript-стиле, и требует в пять раз меньше вызовов внутренней функции, что позволит нам обработать примерно впятеро раз больше данных на бесплатном аккаунте.
Заключение
----------
Сегодня мы рассмотрели еще кусочек мозаики из мира пространственной обработки данных. Как обычно, я рассказал о том, что бесплатно доступно каждому и легко может быть повторено, поскольку весь код перед вами. Конечно, и этот код будет доступен на моем GitHub (смотрите репозиторий [GIS Snippets](https://github.com/mobigroup/gis-snippets/tree/master/) в поддиректории GEE). Сразу не выложил, поскольку там надо сначала порядок навести — оказывается, чего у меня только не накопилось за два десятилетия работы с пространственными данными и программирования вообще. | https://habr.com/ru/post/548292/ | null | ru | null |
# Поточная конвертация баз Firebird 2.5 в формат ODS12 (Firebird 3.0)
У каждой версии Firebird есть собственная версия формата дисковых структур базы данных – O(n)D(isk)S(tructure). До версии 2.5 включительно, движок Firebird мог работать с ODS предыдущих версий, то есть базы от старых версий открывались новой версией и работали в режиме совместимости, но движок Firebird 3.0 работает только с БД в собственной ODS версии 12.0.
Чтобы перейти на 3.0, базу данных от 2.5 необходимо преобразовывать в новый формат через backup/restore. Разумеется, мы предполагаем, что БД была предварительно подготовлена для конвертации — т.е. метаданные и запросы были проверены на совместимость с Firebird 3.0.
Если следовать стандартному подходу, это означает, что нужно произвести бэкап на версии 2.5, затем установить 3.0 и сделать рестор. Такая процедура приемлема, если есть достаточно времени, но при миграции больших баз данных, или при одновременной миграции нескольких десятков БД, когда время поджимает, можно воспользоваться поточной конвертацией, которая на 30-40% быстрее. Как именно это сделать (под Windows и под Linux), читайте под катом.
Общая идея состоит в том, что для ускорения мы воспользуемся конвейером:
```
gbak -b … база25 stdout | gbak -c … stdin база30
```
Gbak от 2.5 генерирует бэкап в линейном формате и направляет его в stdout, который тут же через stdin подхватывает gbak от 3.0 и создает новую БД.
Организовывать такой конвейер нужно обязательно локальным (файловым) методом доступа, поскольку сетевой доступ (даже через localhost) существенно замедлит процесс.
Ниже мы рассматриваем детали для Windows и Linux.
**Windows**
В случае Windows проще всего сделать полностью автономную сборку Firebird. Для этого берём [embed-архив Firebird 2.5](https://github.com/FirebirdSQL/firebird/releases/download/R2_5_8/Firebird-2.5.8.27089-0_x64_embed.zip), переименовываем fbemded.dll в fbclient.dll, добавляем из архива «обычного» 2.5 утилиты gbak.exe и (необязательно) – isql.exe.
Firebird 3.0 использует [единую сборку](https://firebirdsql.org/en/firebird-3-0/) и не требует никакой доработки.
Самый минимальный вариант (не требующий установки рантайм-библиотек VS2008/VS2010 на целевой системе) содержит следующие файлы:
```
25/gbak.exe
25/fbclient.dll
25/firebird.conf
25/firebird.log
25/firebird.msg
25/ib_util.dll
25/icudt30.dll
25/icuin30.dll
25/icuuc30.dll
25/Microsoft.VC80.CRT.manifest
25/msvcp80.dll
25/msvcr80.dll
30/fbclient.dll
30/firebird.conf
30/firebird.msg
30/gbak.exe
30/ib_util.dll
30/icudt52.dll
30/icudt52l.dat
30/icuin52.dll
30/icuuc52.dll
30/msvcp100.dll
30/msvcr100.dll
30/intl/fbintl.conf
30/intl/fbintl.dll
30/plugins/engine12.dll
```
Опытный администратор может заметить, что в 2.5 не включены файлы intl/fbintl.dll и intl/fbintl.conf. Это действительно так, поскольку gbak не использует чарсет коннекта и не конвертирует данные между чарсетами, но на «приемной» стороне Firebird 3.0 эти файлы необходимы при создании индексов.
В firebird.conf Firebird 3.0 рекомендуется добавить:
```
MaxUnflushedWrites = -1
MaxUnflushedWriteTime = -1
```
Также, желательно установить и разные значение IpcName для 2.5 и 3.0.
При выборе значений других параметров firebird.conf исходим из простого соображения: на этапе переливки данных в одном процессе gbak работает 2.5, а в другом – 3.0, затем 2.5 завершает работу, а 3.0 начинает построение индексов.
Чтобы ускорить этап построения индексов в 3.0, рекомендуется увеличить размер параметра TempCacheLimit до ~40% RAM (если это выделенный сервер, конечно).
Например, если на сервере 16 Гб RAM, то можно поставить
```
TempCacheLimit=6G
```
*Разумеется, такое значение можно ставить только у 64битного Firebird 3, поскольку любой 32-битный процесс не сможет аллокировать больше 2х гигабайт памяти.*
У 2.5 этот параметр менять не нужно – он и так не может быть больше 2х гигабайт, да и при бэкапе на скорость не влияет.
Перед выполнением операции требуется проверить, что страничный кэш в заголовке базы данных установлен в 0 (команда `gstat -h databasename`, смотреть строку Page buffers).
Если кэш задан явно в хидере БД, то он переопределяет значения из firebird.conf (и databases.conf в 3.0), и в случае неадекватно больших значений может привести к излишнему потреблению памяти и уходу в своп.
Далее, копируем файлы на целевую систему.
Конвертация проводится после остановки «системной» службы Firebird 2.5, в командной строке с повышением прав до локального администратора (пример):
```
set ISC_USER=владелец
"25/gbak" -z -b -g -v -st t -y 25.log база25 stdout|^
"30/gbak" -z -c -v -st t -y 30.log stdin база30
```
В этом примере используется «прямая косая» в кавычках (допустимый «unix-style»), а «шляпка» (символ «^») экранирует символ перевода строки, что удобно при наборе длинных команд. Опция -st(atus) появилась в Firebird 2.5.8 и позволяет записать в протокол данные о времени работы процесса gbak (подробности – в документации).
**Linux**
На Linux Firebird 3 зависит от библиотеки tommath. В CentOS (RHEL) эта библиотека находится в epel-репозитории, в Ubuntu (Debian) в – системном.
Для CentOS требуется сначала подключить epel-репозиторий и только потом делать
```
yum install libtommath
```
Ubuntu не нужно подключать дополнительные репозитории, но в Ubuntu 16 и в Ubuntu 18 устанавливаются разные версии пакетов – libtommath0 и libtommath1, соответственно.
Firebird 3.0 ищет tommath.so.0 и для Ubuntu 18 дополнительно требуется создать ссылку (symlink) c tommath.so.0 на tommath.so.1. Для этого сначала надо найти tommath.so.1.
Искомый путь в Ubuntu – `/usr/lib/x86_64-linux-gnu/`, но в других Debian-based дистрибутивах может быть иначе.
Вторая проблема связана с тем, что до Firebird 3.0.1, включительно, не было простого способа установить две разные версии сервера. Вариант «компилируем из исходников с нужным префиксом» мы не рассматриваем из-за его относительной трудоемкости.
Для Firebird 3.0.2 и выше реализована [сборка с –enable-binreloc](http://tracker.firebirdsql.org/browse/CORE-5204) и отдельная опция установщика (-path путь).
Предполагая, что библиотека tommath и, при необходимости, симлинк для tommath.so.0 добавлены в систему, можно доустановить актуальный (на момент написания этой статьи) дистрибутив Firebird 3.0.4 в, например, /opt/fb3:
```
./install.sh -path /opt/fb3
```
После этого можно останавливать системный сервис Firebird и запускать поточную конвертацию.
*При остановке Firebird надо учитывать, что процессы Firebid 2.5 в режиме Classic обычно запускает xinetd – поэтому требуется или запретить сервис firebird для xinetd или остановить xinetd полностью.*
В firebird.conf для 3.0 на Linux не нужно задавать MaxUnflushed-параметры (они работают только на Windows) и менять настройки Firebird 2.5.
В линуксе локальный (файловый) доступ Firebird 2.5 не эквивалентен embeded-варианту под Windows – сервер 2.5 будет работать в процессе gbak (без сетевой части), но права доступа будут проверяться по базе пользователей, а значит, потребуется не только логин, но и пароль:
```
export ISC_USER=username ISC_PASSWORD=password
/opt/firebird/bin/gbak -b … база25 stdout\
|/opt/fb3/bin/gbak -c … stdin база30
```
После успешной конвертации надо удалить сначала «дополнительный» Firebird 3.0, затем «основной» Firebird 2.5 и уже после этого выполнить чистую установку Firebird 3.0 — причем лучше всего из штатного установщика tar.gz, а не через репозитории, т.к. версия в репозиториях может отставать.
Также, после рестора БД на Linux и переустановки надо проверить, чтобы новая БД имела владельцем пользователя firebird.
Если это не так, то надо будет исправить
```
chown firebird.firebird database
```
**Итог**
Кроме экономии времени и места на диске у поточной конвертации есть ещё одно важное преимущество – преобразование базы делается без удаления существующего Firebird 2.5, что заметно упрощает откат при неудачной конвертации (чаще всего — из-за недостатка места или неожиданной перезагрузки во время процесса миграции).
Экономия времени связана с тем, что «классическая» конвертация это «время бэкапа» плюс «время восстановления». Восстановление состоит из двух частей: чтение данных из файла бэкапа и построение индекса.
При поточной конвертации суммарное время получается как «время бэкапа плюс пять-десять процентов» и «время построения индексов».
Конкретные результаты зависят от структуры базы, но в среднем время восстановления примерно равно двойному времени бэкапа. Поэтому, если брать за единицу время бэкапа, то «классическая конвертация» — три единицы времени, поточная — две единицы времени. Дополнительно сократить время помогает увеличение TempCacheLimit.
В целом, поточная конвертация на практике позволяет сэкономить 30-40% процентов от времени поочередного бэкапа и рестора.
**Вопросы?**
Пожалуйста, все вопросы пишите в комментариях, или направляйте автору методики и соавтору данной статьи — Василию Сидорову, ведущему системному инженеру компании «iBase», по адресу bs at ibase ru. | https://habr.com/ru/post/445204/ | null | ru | null |
# Операция «B.A.T.M.A.N.»: добавление модулей ядра в Yocto на Intel Edison
Недавно меня спросили о том, как добавить поддержку batman-adv в Yocto. В результате завязалась переписка, которая стала основой для этого поста. Итак, как же это сделать? Давайте разбираться вместе.
[](http://habrahabr.ru/company/intel/blog/267817/)
Способ первый: не надо изобретать велосипед
-------------------------------------------
Прежде чем что-то делать самому, не помешает проверить, не сделал ли уже то же самое кто-то ещё. Стоит пройтись по существующим репозиториям, например, заглянуть [сюда](http://repo.opkg.net/edison/repo/core2-32/). Мне удалось найти [здесь](http://repo.opkg.net/edison/repo/core2-32/) необходимый libnl, но не B.A.T.M.A.N. (сейчас, правда, он уже там есть, но мне, всё же, хочется продолжить рассказ). В такой ситуации вполне можно обратиться с вежливой просьбой к тому, кто занимается репозиторием, например, в нашем случае, к пользователю с ником [AlexT](https://communities.intel.com/thread/55692?start=0&tstart=0). Суть просьбы заключается в добавлении пакетов «kernel-module-batman-adv» и «batctl» в [репозиторий opkg](http://repo.opkg.net/edison/repo/core2-32/). Если удача будет на вашей стороне, то AlexT это сделает, но нужно учесть, что он занимается данным репозиторием на добровольной основе в свободное время. Пакеты можно устанавливать командой вида «opkg install ».
Способ второй: компиляция на целевом устройстве
-----------------------------------------------
Этот подход немного сложнее, он требует достаточно свободного места в rootfs Intel Edison. При его применении нужно загрузить и скомпилировать необходимый код уровня ядра на целевом устройстве.
Способ третий: сборка в среде Yocto
-----------------------------------
Для того чтобы этим способом воспользоваться, вам понадобится:
* Главный компьютер, на котором установлена Linux x64. Например – Ubuntu 12.04 (мне доводилось слышать о проблемах с Yocto в Ubuntu 14.04, возможно, сейчас они уже решены), Fedora 20 и так далее.
* Как минимум 50 Гб свободного места на диске (это если вы хотите скомпилировать полный образ Yocto).
### Настройка Yocto
Загрузите «Yocto complete image» [отсюда](https://software.intel.com/en-us/iot/hardware/edison/downloads). После загрузки выполните такие команды:
* tar xvf edison-src\*.tgz
* cd edison-src
* device-software/setup.sh
* source poky/oe-init-build-env
### Сборка kernel-modules-batman-adv
Здесь путь к успеху лежит через следующие шаги:
* Выполните команду bitbake -c menuconfig virtual/kernel. Она откроет новое окно, в котором будет запущено средство конфигурирование ядра для Edison.
* Настройте B.A.T.M.A.N. Для этого, в сессии menuconfig, установите параметры B.A.T.M.A.N., которые вы хотели бы видеть в категории Networking Support > Networking Options > BATMAN.
* cp build/tmp/work/edison-poky-linux/linux-yocto//linux-edison-standard-build/.config device-software/meta-edison/recipes-kernel/linux/files/defconfig
* bitbake -c compile\_kernelmodules virtual/kernel
* Если вам нужны полные модули tarball, тогда нужна команда bitbake -c deploy virtual/kernel. Tarball можно будет найти по адресу build/tmp/deploy/images/edison
* В противном случае нужна следующая команда на целевом устройстве: opkg install build/tmp/deploy/ipk/edison/kernel-module-batman-adv\_.ipk
Я изменил следующие параметры конфигурации:
```
< # CONFIG_BATMAN_ADV не установлен
---
> CONFIG_BATMAN_ADV=m
> CONFIG_BATMAN_ADV_BLA=y
> CONFIG_BATMAN_ADV_DAT=y
> CONFIG_BATMAN_ADV_NC=y
> # CONFIG_BATMAN_ADV_DEBUG не установлен
```
### Установка batctl
Для того чтобы использовать B.A.T.M.A.N., нужно установить и batctl. Подходящие рецепты для системы сборки BitBake можно найти в Интернете. Например, я использовал [этот](https://github.com/openembedded/openembedded/blob/master/recipes/batctl/batctl.inc), внеся в него некоторые изменения. Вот как выглядит то, что я делал:
```
mkdir -p device-software/meta-edison-distro/recipes-support/batman/
cat > device-software/meta-edison-distro/recipes-support/batman/batctl_2014.4.0.bb <
```
Так как libnl изменил входящий в него путь установки, мне нужно пропатчить Makefile batctl. Делается это так:
```
mkdir -p device-software/meta-edison-distro/recipes-support/batman/files
cat > device-software/meta-edison-distro/recipes-support/batman/files/patch.patch <
```
После всех этих манипуляций для сборки batctl с помощью bitbake нужна такая команда:
```
bitbake batctl
```
После завершения сборки готовый пакет можно найти по адресу build/tmp/deploy/ipk/core2-32/batctl\_2014.4.0-r0\_core2-32.ipk. Его можно установить при помощи «opkg install» на Intel Edison с установленным Yocto Linux
### Тестирование на Intel Edison после установки
```
root@edison:~/ # modprobe batman-adv
```
Если вы хотите, чтобы модуль загружался автоматически, вероятно, вам стоит включить его в /etc/modules-load.d/
```
root@edison:~/ # modinfo batman-adv
filename: /lib/modules/3.10.17-poky-edison+/kernel/net/batman-adv/batman-adv.ko
version: 2013.2.0
description: B.A.T.M.A.N. advanced
author: Marek Lindner , Simon Wunderlich
license: GPL
srcversion: 66711903985B5CAAE0DAF30
depends:
intree: Y
vermagic: 3.10.17-poky-edison+ SMP preempt mod\_unload ATOM
```
С использованием USB Ethernet-адаптера:
```
root@edison:~/ # batctl if add enp0s17u1
root@edison:~/ # batctl if
enp0s17u1: active
root@edison:~/ # batctl s
tx: 6
tx_bytes: 468
tx_dropped: 0
rx: 1
rx_bytes: 42
forward: 0
forward_bytes: 0
mgmt_tx: 60
mgmt_tx_bytes: 2428
mgmt_rx: 0
mgmt_rx_bytes: 0
tt_request_tx: 0
tt_request_rx: 0
tt_response_tx: 0
tt_response_rx: 0
tt_roam_adv_tx: 0
tt_roam_adv_rx: 0
dat_get_tx: 0
dat_get_rx: 0
dat_put_tx: 0
dat_put_rx: 0
dat_cached_reply_tx: 0
nc_code: 0
nc_code_bytes: 0
nc_recode: 0
nc_recode_bytes: 0
nc_buffer: 0
nc_decode: 0
nc_decode_bytes: 0
nc_decode_failed: 0
nc_sniffed: 0
# ifconfig bat0
bat0 Link encap:Ethernet HWaddr 52:78:97:51:ba:9d
inet6 addr: fe80::5078:97ff:fe51:ba9d/64 Scope:Link
UP BROADCAST RUNNING MULTICAST DYNAMIC MTU:1500 Metric:1
RX packets:1 errors:0 dropped:0 overruns:0 frame:0
TX packets:6 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:42 (42.0 B) TX bytes:468 (468.0 B)
```
Итоги
-----
Рассмотренный подход позволяет встраивать модули в ядро Yocto Linux на Intel Edison. Используя его, вы можете включить в ядро то, что вам нужно, и не зависеть от репозиториев. Если же ваша цель – именно B.A.T.M.A.N. Advanced, значит, ваш Intel Edison готов к работе в MESH-сети. | https://habr.com/ru/post/267817/ | null | ru | null |
# Агрегаты, мои агрегаты, как приятно о вас думать
В Domain-Driven Design выделяют стратегические и тактические паттерны. Например, первые — это Единый язык, а вторые — Агрегаты. Я много раз слышал от коллег, что со стратегией всё понятно, но когда дело доходит до перехода на тактический уровень (до кода) — всё в тумане. Это приводит к некорректным техническим решениям, которые не могут компенсировать даже правильный настрой и близость к бизнесу. Для успеха проекта крайне важно освоить тактические паттерны, особенно Агрегаты. Всё потому, что Агрегаты инкапсулируют в себя почти всю бизнес-логику, это основа вашего приложения. В этой статье я и расскажу про Агрегаты, как они могут помочь и почему важно их освоить. Но...
Антипаттерны
------------
Удачные решения закрепляется как паттерны. Неудачные решения, которые разработчики используют вновь и вновь, закрепляются как антипаттерны.
#### Анемичная модель
Это [**первый антипаттерн**](https://martinfowler.com/bliki/AnemicDomainModel.html), с которым я постоянно сталкиваюсь. Типичная анемичная модель выглядит как набор классов, достаточно точно передающих состояние объектов реального мира. Но у этих классов нет поведения, если не считать поведением пачку геттеров и сеттеров. Заполнение полей в такой модели происходит в слое доменных сервисов. По факту, сами модели не владеют своими полями.
```
//типичная анемичная модель
public class Order
{
public UUId Id {get; set;}
public Product[] Items {get; set;}
public decimal TotalPrice {get; set;}
public Tax[] Taxes {get; set;}
public Address DeliveryAddress {get; set;}
public string Phone {get; set;}
}
```
**Недостатки модели.**
**У класса нет инвариантов**. Объект обычно создается беспараметрическим конструктором, необязательно в консистентном состоянии. В течение жизни поля экземпляра могут меняться в различных местах и нельзя гарантировать осмысленное состояние. Например, можно забыть установить корректное значение `TotalPrice` при пересчете налогов, изменении адреса или продуктов.
**Жонглирование**. Обычно слой доменных сервисов представлен несколькими сервисами и экземпляр класса перебрасывается между сервисами. Каждый сервис меняет часть состояния объекта. Например, есть `Order` и `OrderService` создает экземпляр в каком-то виде, потом `CalculationService` заполняет цены-скидки-налоги, а какой-нибудь `DeliveryService` фиксирует информацию о доставке. Часть сервисов может обновлять поля объекта, часть только читать. Но все равно мы получаем высокую связанность сервисов через такие объекты и низкую кохезию (к этим терминам мы еще вернемся).
**Как исправить?**
> Если на проекте много анемичных моделей — начните с «чистки»: уберите публичные сеттеры; уберите беспараметрические конструкторы. Отмечу, что не получится перейти одним махом. Это длительный процесс рефакторинга, не стоит переводить анемичную модель на агрегаты в духе Big Bang.
>
>
Прежде чем вносить новую логику на уровне сервиса, подумайте о причинах — можно ли эту логику разместить внутрь класса. Есть отличный пример перехода от анемичной модели к богатой доменной от [Kamil Grzybek](https://github.com/kgrzybek/refactoring-from-anemic-to-rich-domain-model-example).
Переход от анемичной модели к доменной.
> Использование Анемичных моделей для DTO абсолютно нормально.
>
>
### Универсальная модель
Второй антипаттерн появляется от избыточного переиспользования классов и модулей и попытки построить универсальные классы, которые опишут всевозможные аспекты объектов реального мира. Например, вернемся к нашему `Order`.
Когда система развивается, объект получает поля, чтобы отвечать любым новым требованиям. В таком объекте собраны все кейсы какие только могут произойти с Заказом в нашей системе. Получается такая «лестница Эшера»: вроде каждая часть нормальна и полезна, но всё вместе уже с трудом поддается восприятию.
Лего-относительность.**Недостатки антипаттерна.**
**Каждый раз используется только часть модели**. Объект большой, наши сервисы и репозитории заполняют только часть полей, а остальные могут остаться неинициализированными, а объект может оказаться в несоглассованном состоянии.
**Непонятно где ждать** `Null Reference Exception`. (`NullPointerException`, `AttributeError: 'NoneType' object has no attribute` и т.п.). Из предыдущего пункта следует, что легко можно встретиться с `null`. Без просмотра кода сервисов и репозиториев вы не можете сказать какие поля в данном флоу заполняются, а какие нет. Хуже всего, что позже кто-то может чуть «оптимизировать» приложение и перестать заполнять часть полей. Статический поиск использований становится бесполезным инструментом, так как надо проходить прямо по коду.
**Много лишних данные в объектах**. Например, вы получаете историю заказов для пользователя, и каждый элемент этого массива будет полноценным экземпляром с налогами, продуктами и ингредиентами. Лишние поля могут требовать значительных дополнительных затрат по памяти, трафику, ЦПУ, если такой объект интенсивно используется в нагруженном сервисе.
**Нет границ и контракта**. Самое плохое, что границы таких моделей начинают плыть. Из-за переизбытка деталей разработчику сложно принять хорошие решения об уместности нового поля в объекте, о подходящем именовании.
**Как исправить?**
> Не пытайтесь строить универсальные модели.
>
>
В DDD используется подход с разбиением моделей по Ограниченным контекстам (Bounded Contexts). Несколько лаконичных моделей Order не нарушают принципа DRY. Вы не должны повторять себя именно в поведении, и не бойтесь повторять себя в данных.
Перейдем к Агрегатам.
Агрегат
-------
При использовании DDD принято делить наши доменные классы на Сущности (Entities) и Объекты-значения (Value objects). Они существенно отличаются друг от друга, например, сущности имеют историю, а у Объектов-значений нулевой жизненный цикл. Самое важное отличие между ними — **правила идентичности**. Более подробно можно почитать в статье [@vkhorikov](/users/vkhorikov)«[Entity vs Value Object: полный список отличий](https://habr.com/ru/post/275599/)».
> Агрегат – кластер Сущностей и Объектов-значений, который воспринимается снаружи как единое целое.
>
>
Все эти сущности доступны только через Корень агрегата (Aggregate Root). Звучит просто, но непонятно. Покажу на примере — возьмем наш Заказ, у которого помимо других полей есть Налоги и Продукты.
**Что мы можем делать:**
* Как-то получать весь кластер по Id корня Агрегата, или другому набору атрибутов, определяющим идентичность.
* Использовать публичные методы корня Агрегата для изменения состояния, в том числе внутренних сущностей.
**Избегайте:**
* Получать экземпляры Tax/Product напрямую, в обход сущности Order.
* Выставлять наружу структуру агрегата. Лучше просто выставить набор методов, а внутреннее устройство оставить неизвестным.
```
//Иногда необходимо выставить часть агрегата, в таком случае можно выставить как readonly-поля
private readonly List \_orderItems;
public IReadOnlyCollection OrderItems => \_orderItems;
```
Таким образом, внешние потребители не знают ничего об устройстве нашего агрегата (массив у нас под капотом или словарь — неважно!). Такой объект нельзя привести в несогласованное состояние. В случае анемичной модели мы в любой момент можем забыть поменять взаимосвязанные поля синхронно, например, `Items` и `TotalPrice`. Используя агрегаты мы пишем бизнес-логику в одном месте, можем выставить явные инварианты класса, написать тест.
**Примечание**: о проектировании по контракту можно почитать в статье[«Программирование по контракту в .NET Framework 4»](https://habr.com/post/67813/) и [«Программирование согласно контракту на JVM»](https://habr.com/post/352672/).
```
// простой пример агрегата Заказ
public class Order
{
public UUId Id { get; }
private List \_items;
private decimal \_totalPrice;
private List \_taxes;
public Order(UUId id)
{
Id = id;
\_items = new List();
\_totalPrice = 0;
\_taxes = new List();
}
public void AddProduct(Product product)
{
// Агрегат сам может определить можно ли добавить такой продукт
if (!CanAddProduct(product))
{
return;
}
\_items.Add(product);
// пересчитываем налоги и общую стоимость
RecalculateTaxesAndTotalPrice();
}
public decimal GetTaxesAmount()
{
return \_taxes.Sum(x => x.Amount);
}
private void RecalculateTaxesAndTotalPrice()
{
\_taxes = ...
\_totalPrice = \_items.Sum(x => x.Price) + \_taxes.Sum(x=>x.Amount);
}
private bool CanAddProduct(Product product)
{
//some checks
return true;
}
}
```
Нормотворчество
---------------
Казалось бы — пиши код и не обращай ни на кого внимание. Но и у нас есть свои законы. Они, конечно же, не такие обязательные как закон сохранения энергии, но лучше их знать.
#### Law of Demeter
Закон Деметры или «Не разговаривай с незнакомцами». На вики этот закон поясняют так:
> Таким образом, код `a.b.Method()`нарушает Закон Деметры, а код `a.Method()` корректный.
>
>
Постойте! Но наши агрегаты как раз и требуют такого написания кода. Правильный агрегат не выставляет наружу поведение своих частей, только своё. Незнакомцы не пройдут! Например, получение суммы налогов будет сделано через метод корня.
```
private Tax[] _taxes;
public Money GetTaxesAmount()
{
return _taxes.Sum(x=>x.Amount);
}
```
Чем меньше вы выставили наружу, тем проще рефакторить и развивать. Ведь не надо переделывать потребителей. Так мы снижаем Coupling нашего кода.
#### Constantine's Law
> A structure is stable if cohesion is strong and coupling is low.
>
>
Что такое Coupling? Как это связано с Cohesion? Русские переводы очень плохи, особенно когда переводят термины как Связность и Связанность. Я каждый раз воспроизвожу контекст и пытаюсь перевести на английский. Есть ещё вариант перевода: Сцепленность — Coupling и Кохезия — Cohesion. Но он тоже не очень. Буду использовать англоязычные термины.
**Coupling** — мера взаимозависимости различных классов и модулей друг с другом. При использовании универсальных анемичных моделей и слоя сервисов часто получаем широкое использование доменных классов внутри Сервисов. Что в свою очередь приводит к повышению Coupling.
Доменные классы доступны всем и полностью.При использовании агрегатов мы сокращаем пятно контакта (выставляем минимальный контракт наружу) и переносим всю логику внутрь агрегата. У нас пропадает необходимость передавать наш объект между сервисами — Coupling снижается.
**Cohesion** — мера того, насколько задачи одного программного модуля требуют использования других модулей. Один из плюсов сильной Cohesion — локализация изменений для новой фичи. В случае агрегата вся бизнес-логика обычно локализована в самом агрегате, так мы получаем Strong Cohesion.
Как видим, использование агрегатов позволяет получить Low Coupling и Strong Cohesion.
Заключение
----------
> Агрегат – важнейший паттерн в обойме DDD.
>
>
При его использовании вы получаете множество преимуществ:
* Low Coupling.
* Strong Cohesion.
* Отличную тестируемость: вы пишите тесты на состояние практически без моков.
* Понятный контракт и инварианты класса.
Тема агрегатов, конечно же, не исчерпывается этой статьей. В следующих статьях я расскажу о темах сложнее: как выбирать Агрегат, как они взаимодействуют и затрону транзакционные границы.
По теме агрегатов рекомендую почитать:
* Блог Владимира Хорикова, особенно статью [Domain model purity vs. domain model completeness](https://enterprisecraftsmanship.com/posts/domain-model-purity-completeness/).
* Опыт рефакторинга описывается в упомянутом примере от [Kamil Grzybek](https://github.com/kgrzybek/refactoring-from-anemic-to-rich-domain-model-example), в статье [Refactoring from anemic model to DDD](https://blog.pragmatists.com/refactoring-from-anemic-model-to-ddd-880d3dd3d45f). Также есть курс Владимира Хорикова на Pluralsight и [исходники к курсу](https://github.com/vkhorikov/AnemicDomainModel).
Эта статья написана по следам воркшопа на конференции [Archdays-2020](https://2020.archdays.ru/program/). Запись доступна на YouTube. Для этого воркшопа я подготовил [репозиторий](https://github.com/GraDea/aggregates) с кодом и ссылками.
> Если интересно узнать что такое DDD, как использовать или хотите обсудить статью — присоединяйтесь к [чату](https://t.me/iDDDqd) и каналу [DDDevotion](https://t.me/dddevotion). 23 декабря пройдет предновогодний онлайн-митап: будет много кода, общения и веселья. Приходите! Регистрация по [ссылке](https://dddevotion.timepad.ru/event/1509640/).
>
> | https://habr.com/ru/post/532628/ | null | ru | null |
# Postgresso 8-9 (45-46)
*По некоторым причинам этот номер сдвоенный, дальше Postgresso продолжит выходить в обычном, ежемесячном режиме.*
---
### Релизы Postgres
#### PostgreSQL 15 — Beta 3-4, RC 1-2 и, теперь GA
Свершилось! Главное событие — конечно, это выход уже официальной, общедоступной (general availability) 15-й версии:
**[PostgreSQL 15 Released!](https://www.postgresql.org/about/news/postgresql-15-released-2526/)**
Среди главных новшеств называют:* поддержка SQL-команды [MERGE](https://www.postgresql.org/docs/15/sql-merge.html);
* избирательная публикация содержания таблиц благодаря возможности определить список столбцов и условия в фильтрах;
* больше опций при сжатии, в том числе сжатие Zstandard ([zstd](https://www.postgresql.org/docs/15/runtime-config-wal.html#GUC-WAL-COMPRESSION)); в том числе поддержка сжатия на стороне сервера в процессе [pg\_basebackup](https://www.postgresql.org/docs/15/runtime-config-wal.html#GUC-WAL-COMPRESSION);
* поддержка структурированного вывода логов в JSON-формате;
* увеличение производительности, особенно при сортировке в памяти и на диске
Об этом много написано, сейчас мы на этом останавливаться не будем (но можно глянуть, например, краткий комментарий **[PostgreSQL 15 – New Features to Be Excited About](https://www.percona.com/blog/postgresql-15-new-features-to-be-excited-about/)** от *Умара Шахида*, Umair Shahid, Percona) и пару ссылок ниже по поводу схемы public.
Можно, однако, сказать, что на самом деле главное событие произошло не сейчас, а ещё в фазе **[PostgreSQL 15 Beta 4](https://www.postgresql.org/about/news/postgresql-15-beta-4-released-2507/)**. Тогда откатили большую серию патчей, связанных с SQL/JSON.
**[Патчи отложили на PostgreSQL 16](https://postgrespro.ru/list/thread-id/2614934?ysclid=l7wfbtt4i5786115363)** (можно смотреть [всю ветку](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=2f2b18bd3f554e96a8cc885b177211be12288e4a), дискуссия [здесь](https://www.postgresql.org/message-id/flat/abd9b83b-aa66-f230-3d6d-734817f0995d%40postgresql.org). Чтобы корректно откатить SQL/JSON, пришлось изменить 60 (!) файлов. Среди того, что откатили:
* [SQL/JSON constructors](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=f4fb45d15);
* [IS JSON predicate](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=33a377608);
* [SQL/JSON query functions](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=1a36bc9db);
* [SQL JSON functions](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=606948b05);
* [JSON\_TABLE](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=4e34747c8).
*Депеш* (Hubert depesz Lubaczewski) [пишет](https://www.depesz.com/2022/09/02/sql-json-is-postponed/): *я сам в марте и апреле писал о грядущих великих возможностях (great feature) полной реализации SQL/JSON. Увы, всё пришлось откатить (удалить из исходников) не только из PostgreSQL 16, но и из «почти готовой» PostgreSQL 15.*
Наш коллега *Егор Рогов* (автор [PostgreSQL изнутри](https://postgrespro.ru/education/books/internals)) не унывает:
*Мне в этой истории нравится, что, во-первых, много людей до самого последнего помогали* Никите [Глухову] *с патчами, во-вторых, что он сам не бросал задачу, и, в-третьих, что сообщество не пошло на то, чтобы оставить недоведенный до ума код или нарушить релизный цикл. Надеюсь, что счастливый конец все-таки случится, но теперь уже через год.*
Чтобы узнать о новом в 15-й версии, имеет смысл послушать/посмотреть [доклад на PGConf.Russia 2022](https://www.youtube.com/watch?v=9RDS-DQDY0A) руководителя отдела образовательных программ Postgres Professional *Павла Лузанова*. Там, соответственно тем временам, много посвящено SQL/JSON, но это не пропадёт: не в PG 15, так в PG 16, опять же.
Немного о мелочах, случившихся до выхода официальной PostgreSQL 15: некоторые изменения были и в **[PostgreSQL 15 RC 1](https://www.postgresql.org/about/news/postgresql-15-rc-1-released-2516/)**
(Release Candidate 1) относительно Beta 4:* Синтаксис публикации схемы при логической репликации поменялся на CREATE PUBLICATION… FOR TABLES IN SCHEMA ...;
* публикации при логической репликации теперь могут публиковать таблицы внутри схемы, если определены и схема, и таблица;
* запрещена публикация схемы, если определена таблица со списком столбцов, подлежащих репликации;
* запрещено создание новой базы данных, если её ICU-локаль не поддерживается.
Ну а в RC 2 опять произошёл откат назад: отказались от [optimized order of GROUP BY keys](https://commitfest.postgresql.org/30/1651/).
**[Postgres 15 Configuration Changes](https://blog.rustprooflabs.com/2022/10/postgres-15-config-changes)**
Появились 6 новых конфигурационных настроек в `postgresql.conf`:* `recovery_prefetch` (по умолчанию `try`),
* `wal_decode_buffer_size` (по умолчанию 512kB),
* `archive_library` (''),
* `recursive_worktable_factor` (по умолчанию 10),
* `log_startup_progress_interval` (по умолчанию 10 сек.),
* `stats_fetch_consistency` (по умолчанию `cache`),
В трёх — изменения:* `log_checkpoints` (по умолчанию `on` вместо `off`),
* `log_autovacuum_min_duration` (по умолчанию 10 мин. -1),
* `hash_mem_multiplier` (по умолчанию 2.0 вместо 1.0).
И один параметр отменили: `stats_temp_directory`.
Что это за параметры и с чем их едят, смотрите в [этой короткой заметке](https://blog.rustprooflabs.com/2022/10/postgres-15-config-changes) от RustProof Labs и в [документации](https://www.postgresql.org/docs/15/index.html). А [список изменений](https://pgconfig.rustprooflabs.com/param/change/14/15) здесь же на RustProof.
**[Be Ready! Public schema changes in Postgres 15](https://www.crunchydata.com/blog/be-ready-public-schema-changes-in-postgres-15)**
Об этом предупреждает *Пол Рэмзи* (Paul Ramsey, Crunchy Data). Его вывод: хотя в PostgreSQL 15 больше нет глобальной привилегии на запись в схеме public, несложно организовать совместную работу пользователей на том же уровне, используя пользовательские схемы и роли.
**[A 'public' Schema Change in Postgres 15](https://andreas.scherbaum.la/blog/archives/1120-Changes-to-the-public-schema-in-PostgreSQL-15-and-how-to-handle-upgrades.html)**
В блоге *Андреаса Шербаума* (Andreas Scherbaum), который называется [Ads' Corner](https://andreas.scherbaum.la/blog/), Андреас объясняет, почему привилегия CREATE больше не даётся по умолчанию на схему public, и как с этим быть, переходя с PostgreSQL 14 на 15. Подытоживая, он пишет: *а лучше всего вообще не полагаться на то, что можно писать в схему public.*
Образование
===========
Как-то так сложилось, что в этом выпуске много образования.
#### PostgreSQL Internals
Вышла 3-я часть английской версии книги *Егора Рогова*: **[PostgreSQL 14. Part III.](https://postgrespro.com/blog/pgsql/5969741)**
Part III. Locks. Relation-Level Locks · Row-Level Locks · Miscellaneous Locks · Locks in Memory.
PDF можно скачать по той же ссылке [отсюда](https://edu.postgrespro.com/postgresql_internals-14_parts1-3_en.pdf). Каждая новая переводная глава будет и дальше добавляться в этот PDF. Постоянная страница, посвященная книге, [здесь](https://postgrespro.com/community/books/internals).
**[Learning PostgreSQL Internals](http://blog.cleverelephant.ca/2022/10/postgresql-links.html)**
Ещё Internals — от *Пола Рэмзи*. Это обзор источников по Postgres, куда вошли другие Internals, например **[The Internals of PostgreSQL](https://www.interdb.jp/pg/)** *Хиронобу Сузуки* (Hironobu Suzuki). В целом обзор Пола ориентирован прежде всего на классиков-разработчиков Postgres, поэтому в нём упомянут *Олег Бартунов*, но нет ссылки на книгу Егора. Не убудет: английская версия (не говоря о русской) щедро упоминается в англоязычном Postgres-интернете.
#### Майкл Стоунбрейкер
**[Architecture of a Database System](https://dsf.berkeley.edu/papers/fntdb07-architecture.pdf)**
Эта большая работа, в которой великий Майкл Стоунбрейкер (Michael Stonebraker, MIT) и его соавторы — *Джозеф Хеллерстайн* (Joseph M. Hellerstein, Калифорнийский Университет в Беркли) и *Джеймс Хамильтон* (James Hamilton, Microsoft Research) сформулировали (в данном случае в 2007-м году) базовые принципы построения СУБД.
Впрочем, Рэмзи ссылается на другую работу Стоунбрейкера:
**[The Design Of Postgres](https://dsf.berkeley.edu/papers/ERL-M85-95.pdf)** в соавторстве с *Лоуренсом Роу* (Lawrence A. Rowe).
#### Курсы CMU Database Group
Аббревиатура CMU — это Университет Карнеги Меллон. Там, прежде всего, очень активно преподаёт известный нашим читателям профессор *Энди Павло* (Andy Pavlo).
Вот планы на осень этого года: **[CMU 2022](https://15445.courses.cs.cmu.edu/fall2022/)**. А вот PDF-файл с концепциями СУБД: **[Database System Concepts](https://github.com/Sorosliu1029/Database-Systems/blob/master/Database-System-Concepts-7th-Edition.pdf)**, авторы *Абраам Зильбершац* (Abraham Silberschatz, Yale University), *Хенри Корт* (Henry F. Korth, Lehigh University) и *С. Сударшан* (S. Sudarshan, Indian Institute of Technology, Bombay — нигде не нашёл полного имени, везде просто S). На этой книге основаны лекции Энди.
А это **[плейлисты CMU Group](https://www.youtube.com/c/CMUDatabaseGroup/playlists)** с многочисленными лекциями. [Расписание лекций](https://15721.courses.cs.cmu.edu/spring2017/schedule.html) (старое, но там ссылки на файлы).
Вот один из примеров лекций, говорящий о глубине проникновения в тему: **[06 — Memory Management + Buffer Cache (CMU Intro to Database Systems / Fall 2022)](https://www.youtube.com/watch?v=Y9H2HaRKOIw)**
#### Основы и тенденции
Советуем обратить внимание на эту серию: **[Foundations and Trends in Databases](https://www.nowpublishers.com/DBS?vol=1)**.
Вышло 12 томов. Главред серии *Джозеф Хеллерстайн* (Joseph M. Hellerstein, University of California, Berkeley) и *Сураджит Чаудхури* (Surajit Chaudhuri, Microsoft Research, Redmond)
#### Pagila 3.0 и Sakila
**[Pagila](https://github.com/devrimgunduz/pagila/)** начиналась как опенсорсный вариант демонстрационной базы [Sakila](https://dev.mysql.com/doc/sakila/en/). Поэтому сначала 2 слова о Sakila.
Это хорошо нормализованная база как бы некоторого магазина, раздающего в аренду DVD, в ней фильмы, актёры, отношения фильм-актёр и главная таблица, связывающая фильмы, магазины, аренду, сотрудников, платежи — всего 15 таблиц. Её создавали как демонстрационную для MySQL, но позже просто отдали по BSD License. Ниже описана ссылка на [статью](https://blog.jooq.org/how-to-plot-an-ascii-bar-chart-with-sql/), где её данные используются для демонстрации «графических» возможностей SQL.
Но Pagila развивается параллельно Sakila, и наращивая возможности. В новой версии:* демонстрационные данные JSONB (основаны на пакетах из [apt.postgresql.org](http://apt.postgresql.org) и [yum.postgresql.org](http://yum.postgresql.org);
* поддержка docker compose;
* теперь можно создавать базу Pagila в докере по шагам;
* даты в данных обновлены до 2022-го года.
Готовы RPM-ы, лежат в репозиториях YUM и zypp. Тарбол [выложил](https://github.com/devrimgunduz/pagila/releases) *Деврим Гюндюз* (Devrim Gündüz). Сообщение об этом [здесь](https://people.planetpostgresql.org/devrim/index.php?/archives/120-Pagila-3.0.0-is-out-with-shiny-new-features-and-bugfixes.html).
В персональном [блоге Деврима](https://people.planetpostgresql.org/devrim/index.php?/authors/1-Devrim-Gunduz) на [Планете Постгрес](https://planet.postgresql.org/) много небольших статей, в которых он обычно пишет об установке PostgreSQL и сопутствующего софта на RHEL или Rocky Linux. Например, он выложил пакеты consul и haproxy в репозиторий PostgreSQL RPM для поддержки [patroni](https://github.com/zalando/patroni), чтобы можно было использовать последние версии этих пакетов. Но оказалось, что эти пакеты могут поломать уже существующие инсталляции, такие как HAProxy 1.8.4 RPM на RHEL 8. Поэтому, чтобы не ломать чужое окружение, выложил новые pgdg-rhel9-extras, pgdg-rhel8-extras и pgdg-rhel7-extras — для RHEL 9/8/7 соответственно — см. **[New repo: Extra packages for PostgreSQL RPM repo](https://people.planetpostgresql.org/devrim/index.php?/archives/116-New-repo-Extra-packages-for-PostgreSQL-RPM-repo.html#extended)**.
#### Sakila и картинки из ASCII-символов
**[How to Plot an ASCII Bar Chart with SQL](https://blog.jooq.org/how-to-plot-an-ascii-bar-chart-with-sql/)** — полезное развлечение в ностальгическом духе: как построить диаграммы-столбики исключительно средствами SQL? Это можно сделать, хотя выйдет и не так эффектно, как популярные на заре ЭВМ портреты ASCII-символами.
Скрипты лежат [здесь](https://github.com/jOOQ/sql-scripts/blob/main/PostgreSQL/bar-charts.sql). Для примера использовали упомянутую выше учебную базу [Sakila](https://dev.mysql.com/doc/sakila/en/). Автор — [*Лукас Эдер*](https://github.com/lukaseder) (Lukas Eder), вообще-то, специалист по [JOOQ](https://en.wikipedia.org/wiki/JOOQ_Object_Oriented_Querying) (Java-библиотеке для объектно-ориентированных запросов на базе SQL).
Кстати, об ASCII: *Лука Феррари* (Luca Ferrari, опенсорс-«адвокат» и человеческое существо, хотя [на фото](https://fluca1978.github.io/about/) кот) напоминает в **[PostgreSQL ASCII numeric operators](https://fluca1978.github.io/2022/10/10/PostgreSQLNumericOperators.html)** о том, что популярные операторы с числами можно представить ASCII-символами:* `|/` это `sqrt`;
* `||/` это `cbrt`;
* `@` это `abs`.
#### Игровые площадки Postgres
**[Learn Postgres at the Playground](https://www.crunchydata.com/blog/learn-postgres-at-the-playground)** — *Крейг Керстинс* (Craig Kerstiens, Crunchy Data) обнародовал серию интерактивных обучающих материалов по Postgres. К ним — свежие советы.
#### PostgresPro EDU
Появился новый телеграм-канал [PostgresPro EDU](https://t.me/PostgresProEdu). В нём уже целая серия полезных сообщений. Первое сообщение канала: [Postgres Professional](https://postgrespro.ru) совместно с [ГАИШ МГУ](http://www.sai.msu.ru/?ysclid=l9etwikxjl213083112) запустили онлайн-курс «Язык SQL» для студентов по изучению системы управления базами данных PostgreSQL. Он построен на основе учебного пособия Евгения Павловича Моргунова **[PostgreSQL. Основы языка SQL](https://postgrespro.ru/education/books/sqlprimer)**.
С 21 сентября 2022 года [открыт доступ](https://openedu.ru/course/msu/SQL/) к первым видеоурокам на платформе «Открытое образование» для тех, кто уже успел записаться ранее, и для будущих слушателей.
Всего запланировано 9 тематических разделов:* элементы теории баз данных;
* введение в язык SQL;
* типы данных СУБД PostgreSQL;
* основы языка определения данных;
* запросы;
* изменение данных;
* индексы;
* транзакции;
* повышение производительности.
Есть информация о грядущих мероприятиях Postgres Professional:
23 октября 2022 приглашаются **студенты новосибирских вузов**. Встреча в главном корпусе НГУ (ул. Пирогова 1, этаж 3, аудитория 3107). Начало встречи в 14-00. Бесплатно. А 24-го октября состоится [PGConf.Сибирь](https://pgconf.ru/202210).
На 26 октября 2022 запланирован **PGMeetup.Барнаул** для студентов, преподавателей, IT-специалистов и всех, кто интересуется Postgres. Есть [программа](https://pgconf.ru/20221026/talks)). Алтайский государственный университет (пр-т Социалистический, д. 68, аудитория 1С). Начало в 18-00. Тоже бесплатно.
К слову, мероприятие из этой серии прошло в Нижнем Новгороде — **PGMeetup.NN**. Ещё один митап — **в Москве**, там обсуждались типичные ошибки разработчиков приложений при работе с СУБД Postgres, способы сжатия данных в PostgreSQL и шардирование данных.
#### Интересный автор: Михаил Цымблер
Хочу обратить ваше внимание на специалиста по СУБД из университетской среды: [*Михаил Цымблер*](https://mzym.susu.ru/) (в латинице Mikhail Zymbler) работает в ЮУрГУ (Челябинск). Ни разу не встречал его на конференциях по базам данных, зато много раз на конференциях по параллельным вычислениям. Михаил занимается разными вещами, в том числе ИИ для медицины. Его работы по параллельным базам данных базируются на PostgreSQL. Их можно найти на таких ресурсах как [academia.edu](https://academia.edu) (нужен эккаунт). Вот презентация о «Приручении слонов»: **[Embed Parallelism into PostgreSQL](https://www.yumpu.com/en/document/read/53838240/embed-parallelism-into-postgresql)**. Вот его страничка с **[курсами](https://mzym.susu.ru/courses/)**.
#### Электронные книжки от pganalyze
* [Advanced Database Programming with Rails and Postgres](https://pganalyze.com/ebooks/advanced-database-programming-rails-postgres);
* [Best Practices for Optimizing Postgres Query Performance](https://pganalyze.com/ebooks/optimizing-postgres-query-performance);
* [Effective Indexing in Postgres](https://pganalyze.com/ebooks/postgres-indexing);
* [Finding the root cause of slow Postgres queries using EXPLAIN](https://pganalyze.com/ebooks/explain-slow-postgres-queries);
* [Efficient Search in Rails with Postgres](https://pganalyze.com/ebooks/efficient-search-in-rails-with-postgres);
* [The Most Important Events to Monitor in Your Postgres Logs](https://pganalyze.com/ebooks/monitoring-postgres-logs).
Страница публикаций [здесь](https://pganalyze.com/resources/ebooks).
#### книга: Mastering PostGIS and OpenStreetMap
Эту [книгу](https://blog.rustprooflabs.com/2022/10/announce-mastering-postgis-openstreemap) написал сотрудник RustProof Labs *Райан Ламберт* (Ryan Lambert). Он же дал ссылку на [одну из главок](https://book.postgis-osm.com/ch_pgosm/denver-area-extract.html) в открытом доступе. А так сама книга [стоит 100 баксов](https://postgis-osm.com/buy).
### PG(SQL)-пятнецы
Так мы [в своё время](https://habr.com/ru/company/postgrespro/blog/504504/?ysclid=l97966qiq5193332914) перевели Phridays. Недавно родился любопытный проект, который придумал *Райан Буз* (Ryan Booz, CTO EnergyCAP), названный им **[PGSQL Phriday](https://www.softwareandbooz.com/pgsql-phriday-001-invite/)**: раз в месяц представители Postgres-сообщества пишут в блог. Но не абы что. Пока предлагается написать 2 справедливые заметки и одну фейковую.
Райан признаётся, что вдохновение для топика первой пятнецы он черпал из доклада *Ильи Космодемьянского* на PGConf NYC: *PostgreSQL Worst Practices* (но мы даём ссылку на русскоязычную версию [на Highload++](https://www.youtube.com/watch?v=HxwLCyCY8ec), а сам Илья, возможно, вдохновлялся [Вредными советами Григория Остера](https://www.youtube.com/watch?v=5QZtkOg_wk0)). Короче, в этой игре Райана один из трёх советов должен быть вредным.
По поводу нейминга: Райан не знал, что *Пятнецы* до него уже придумал *Шон Томас* (Shaun Thomas). Шон не обиделся. Пятнецы Шона назывались чуть по-другому: PG Phridays, и какое-то время проходили каждую пятницу, а не раз в месяц, как у Райана. И [начинал](https://bonesmoses.org/tags/pg-phriday/page/5/) Шон пятнецы летом 2015-го (и тоже с вредных советов: **[10 Ways to Ruin Performance: In The Loop](https://bonesmoses.org/2015/pg-phriday-10-ways-to-ruin-performance-in-the-loop/)**), и только через пару лет этот блог [перекочевал](https://www.2ndquadrant.com/en/blog/author/shaun-thomas/page/3/) под крышу 2ndQuadrant (EDB).
Тем, затронутых Шоном, не перечислить. [Мы ссылались](https://habr.com/ru/company/postgrespro/blog/504504/?ysclid=l97966qiq5193332914), например, на такие:* [проблемы с ID транзакций](https://www.2ndquadrant.com/en/blog/10-things-postgres-could-improve-part-1/);
* [неприятные сюрпризы репликации](https://www.2ndquadrant.com/en/blog/pg-phriday-10-things-postgres-could-improve-part-2/);
* [MVCC и почему надо быть внимательным с хранением](https://www.2ndquadrant.com/en/blog/pg-phriday-10-things-postgres-could-improve-part-3/).
А [позже](https://habr.com/ru/company/postgrespro/blog/658783/?ysclid=l97962iy86375854509) — на **[Tidying Up With VACUUM](https://www.enterprisedb.com/blog/pg-phriday-tidying-vacuum)**
Открытия/Закрытия
-----------------
**[Distributed Postgres goes full open source with Citus: why, what & how](https://www.citusdata.com/blog/2022/09/12/distributed-postgres-goes-full-open-source-with-citus/)**
Citus открыли теперь уже все фичи своего Enterprise в Citus 11. *Джелте Феннема* (Jelte Fennema) объясняет:
*Это связано с изменением бизнес-модели. Citus начинался как форк PostgreSQL в 2011, тогда бизнес-модель была построена на продаже Enterprise-лицензий и контрактов по поддержке. В 2016 мы отказались от идеи форка (un-forked) и открыли основную массу кода. После этого мы отделяли Enterprise с его лицензиями от открытой версии, включая туда дополнительные Enterprise-фичи.
Но со временем бизнес-модель стала меняться в сторону от продажи Enterprise-лицензий. Сейчас наша бизнес-модель построена вокруг управляемых услуг (managed service): [Azure Database for PostgreSQL — Hyperscale (Citus)](https://azure.microsoft.com/en-us/pricing/details/postgresql/hyperscale-citus/). Как вы догадываетесь, мы добавляем к опенсорсному Citus фичи для управления.*
Полный список открытых энтерпрайзных фич [здесь](https://www.citusdata.com/updates/v11-0/#enterprise-opensource). Среди них, например, неблокирующий ребалансировщих шардов ([non-blocking shard rebalancer](https://docs.citusdata.com/en/stable/admin_guide/cluster_management.html?highlight=rebalance&_gl=1*19fulmu*_ga*OTI1MDc5MDAwLjE2NTE3Nzg4Njc.*_ga_DS5S1RKEB7*MTY2NjAwMTE0NS4xNi4xLjE2NjYwMDE4NjkuMC4wLjA.#rebalance-shards-without-downtime) — до этого ребалансировщик был открыт, но non-blocking не был там доступен). Можно почитать блог о **[Citus 11.1](https://www.citusdata.com/updates/v11-1/)**, гитхаб [здесь](https://github.com/citusdata/citus).
**[Cloudflare Open Sources Its PgBouncer Fork](https://blog.cloudflare.com/open-sourcing-our-fork-of-pgbouncer/)**
**CF PgBouncer**
Cloudflare поддерживала внутренний форк PgBouncer, в который добавляла багфиксы аутентификации и новшества, связанные с изоляцией пользователей (использование CPU и памяти, дисковые операции ввода-вывода). Теперь, пишет *Джастин Кван* (Justin Kwan, Cloudflare), код открыт.
А вот руководство **Heroku** сделало движение в противоположном направлении: **[Removal of Heroku free product plans](https://news.ycombinator.com/item?id=32594533)**. Они даже назвали это красиво **Новая глава**: **[Heroku’s Next Chapter](https://blog.heroku.com/next-chapter)**
Опубликована [Heroku Roadmap](https://github.com/orgs/heroku/projects/130). Мудрый *Боб Уайз* (Bob Wise, Heroku General Manager и исполнительный вице-президент Salesforce, владеющей сейчас Heroku) говорил о важности этого шага для надёжный поддержки тех больших и малых клиентов, которые сделали ставку на Heroku, о фокусировке на *mission critical* и о том, что бесплатные планы и неактивные эккаунты будут ликвидированы. Но продолжится вклад в открытый код [Cloud Native Buildpacks](https://buildpacks.io/).
Анонимайзеры
------------
Сразу несколько читателей наших выпусков интересовались этим классом ПО. Набросаем некоторые ссылки с краткими комментариями.
**[PostgreSQL Anonymizer 1.1](https://www.postgresql.org/about/news/postgresql-anonymizer-11-privacy-by-default-for-postgres-2253/)**
Мы не раз писали об этом расширении Dalibo (в `shred_preload_libraries` в `postgresql.conf` просто `anon`, разработчик Дамьян Клошар, Damien Clochard), следили за его взрослением. PostgreSQL Anonymizer прячет или заменяет персональные данные (personally identifiable information — PII), или коммерческие данные в базах PostgreSQL. Поддерживает 3 стратегии анонимизации:* динамическое маскирование ([dynamic masking](https://postgresql-anonymizer.readthedocs.io/en/latest/dynamic_masking/)),
* статическое маскирование ([static masking](https://postgresql-anonymizer.readthedocs.io/en/latest/static_masking/)) и
* [anonymous dumps](https://postgresql-anonymizer.readthedocs.io/en/latest/anonymous_dumps/) (просто экспорт маскированных данных в SQL-файл).
Расширение предлагает набор [функций маскирования](https://postgresql-anonymizer.readthedocs.io/en/latest/masking_functions/), таких как:
Substitution, Randomization, Faking, Pseudonymization, Partial Scrambling, Shuffling, Noise Addition and Generalization. Названия их говорят за себя, на этой [страничке документации](https://postgresql-anonymizer.readthedocs.io/en/latest/masking_functions/) есть ссылки.
В версии 1.1 появилась [защита данных по умолчанию](https://postgresql-anonymizer.readthedocs.io/en/latest/privacy_by_default/). Это значит, что все столбцы по умолчанию (без объявления правил маскирования) маскируются. Но эта возможность пока в бета, а станет готовой для промышленной эксплуатации только в 2.0.
Другое изменение — в **[Anonymous Dumps (pg\_dump\_anon)](https://postgresql-anonymizer.readthedocs.io/en/latest/anonymous_dumps/)**. `pg_dump_anon` было bash-криптом. Его полностью переписали на Go. Старый скрипт переименовали в `pg_dump_anon.sh` и сохранили для обратной совместимости. Но в версии 2.0 его уже не будет.
Можно почитать об этом, например, в блоге Alibaba Cloud **[How to Mask Sensitive Information on PostgreSQL Using Anon Plug-in](https://www.alibabacloud.com/blog/how-to-mask-sensitive-information-on-postgresql-using-anon-plug-in_597716)**. Там есть примеры разных типов маскирования.
**[Data Masking For PostgreSQL](https://www.cybertec-postgresql.com/en/products/data-masking-for-postgresql/)**
В статье говорится о расширении **pg\_datamask**, разработанном в Cybertec. Интересно, что можно выбрать один из двух путей: простой — generic masking: есть библиотека, в которой есть всё (утверждают в статье) для эффективного маскирования. Почти всегда этого достаточно. Если нет, то можно самому написать нужные функции для маскирования данных.
**[Open Diffix (pg\_diffix)](https://github.com/diffix/pg_diffix)**
**pg\_diffix** — расширение PostgreSQL для сильной динамической анонимизации. Оно гарантирует, что результаты простых SQL-запросов будут анонимизированы. Его можно бесплатно [скачать](https://www.open-diffix.org/en/download/), а можно [попробовать онлайн-демо](https://www.open-diffix.org/en/demo/). На их гитхабе есть много учебных материалов по diffix:
[обучалка для админа](https://github.com/diffix/pg_diffix/blob/master/docs/admin_tutorial.md),
[руководство админа](https://github.com/diffix/pg_diffix/blob/master/docs/admin_guide.md),
[книжка банкира](https://github.com/diffix/pg_diffix/blob/master/docs/banking.ipynb) (с правдоподобными данными) и
[руководство для аналитика](https://github.com/diffix/pg_diffix/blob/master/docs/analyst_guide.md).
**[sepgsql](https://www.postgresql.org/docs/15/sepgsql.html)**
Это известный загружаемый модуль для мандатного доступа. В нём есть возможности маскирования.
### PLV8
Мне доводилось собирать plv8. Это, как минимум, требует времени и усилий. А язык важный, он, хоть и не входит в 4 языка «из коробки» для PostgreSQL (кстати, почитайте статью *Ивана Панченко* **[PostgreSQL: Серверное программирование на «человеческом» языке: PL/Perl, PL/Python, PL/v8](https://habr.com/ru/company/postgrespro/blog/502254/)**), но он мощный и удобный, и пользуются им часто.
После изрядного перерыва в августе вышли 2 версии [PL/v8 (расширения plv8)](https://github.com/plv8/plv8):
**[plv 8 3.1.4](https://github.com/plv8/plv8/releases/tag/v3.1.4)**
и
**[plv 8 3.1.3](https://github.com/plv8/plv8/releases/tag/v3.1.3)**
А на днях *Алексей Фадеев*, старший разработчик .NET компании sibedge (Томск), сообщил, что они собрали докер-образы plv8 с PostgreSQL 15. Недавно у них появилась поддержка arm64, так как новые MacBook на процессорах M1 и M2 очень популяризировали архитектуру arm64 и увеличили спрос образы с такой архитектурой. Образы от sibedge собраны на основе [официальных образов](https://hub.docker.com/_/postgres) Postgres. Как и официальные, они собраны под два дистрибутива: стабильная версия Debian и [alpine](https://ru.wikipedia.org/wiki/Alpine_Linux) (размер alpine-образов почти вдвое меньше).
Интересно, что образы в двух репозиториях:
sibedge/postgres-plv8 (сборка по умолчанию) и
sibedge/postgres-plv8-bigint (сборка с поддержкой сериализации BigInt) — sibedge рекомендует к использованию образ sibedge/postgres-plv8-bigint, поскольку при работе с версией по умолчанию все значения BigInt конвертируются в строки (это не только значения колонок типа bigint, но и результаты агрегатных функций, например count или sum).
Подробности, доступные платформы [здесь](https://hub.docker.com/r/sibedge/postgres-plv8). А [здесь история вопроса](https://sibedge.com/blog/sibedge-s-contribution-to-the-development-of-postgres-a-simple-installation-of-plv8-by-alexey-fadeev/).
О своей работе и о выборе технологий Алексей рассказывал на [PGConf.Russia 2022](https://pgconf.ru/2022):
**[Сборка plv8: от архива с бинарниками до компактного докер-образа](https://pgconf.ru/2022/316603)**.
### Мониторинг и тюнинг
**[check\_pgactivity 2.6](https://github.com/OPMDG/check_pgactivity/releases/tag/REL2_6)**
check\_pgactivity — PostgreSQL-плагин для мониторинга под [Nagios](https://www.nagios.org/). Он призван упростить работу с метриками производительности. В новой версии:* совместимость с PostgreSQL 14;
* новый сервис `session_stats` для сбора сессионных данных;
* сервис `autovacuum` теперь не показывает `max_workers` для версий 8.2 и ниже.
**[Tuning Linux kernel for PostgreSQL](https://vettabase.com/blog/tuning-linux-kernel-for-postgresql/)**
*Майкл Абоуджи* (Michael Aboagye, Vettabase) [создал роль](https://github.com/Vettabase/ansible-role-linux-for-postgresql) в [Ansible](https://www.ansible.com/) для тонкой настройки ядра Linux. В статье он говорит о параметрах:
`kernel.shmmax`,
`kernel.shmall`,
`vm.swappiness`,
`vm.overcommit_memory`,
`vm.overcommit_ratio`,
`HugePages`,
`vm.dirty_background_ratio`,
`vm.dirty_ratio`.
Маркетинговый смысл этой статьи в том, что в конце автор предлагает обратить внимание на продукт компании, в которой работает: [PostgreSQL Health Check](https://vettabase.com/blog/services/health-checks/postgresql/)
**[Harnessing Shared Buffers (and Reaping the Performance Benefits) — Part 1](https://www.enterprisedb.com/blog/harnessing-shared-buffers-and-reaping-performance-benefits-part-1)**
*Шон Томас* (Shaun Thomas, EDB — о его PG-Пятнецах выше в обзоре) демонстрирует на бенчмарках («старая добрая pgbench», [HammerDB](https://www.hammerdb.com/) TPROC-C и TPROC-H).
В перовой части пока выводы такие: склады данных большого объёма лучше работают с небольшими объёмами памяти, выделенной в Shared Buffers, так как большинство страниц используются только 1 раз. Поддерживать такие страницы в буфере дороже, чем отдать их в распоряжение ОС. При OLTP-нагрузках картина совсем другая.
Но в первой части тесты крутились на системам с жёсткими дисками. Во второй будут результаты с NVM и большими RAM. Обещаны сюрпризы.
**[Using BUFFERS for query optimization](https://www.pgmustard.com/blog/using-postgres-buffers-for-query-optimization)**
*Майкл Кристофайдес* (Michael Christofides, pgMustard) объясняет, что такое *shared, temp, local, hit, read, dirtied* и *written*. Конечно, он рекомендует использовать pgMustard, иллюстрируя примеры симпатичными скриншотами. И агитирует за их [патч](https://commitfest.postgresql.org/38/3409/): включение BUFFERS в EXPLAIN по умолчанию. Соавтор патча — соведущий подкастов **[Postgres.FM](https://postgres.fm/episodes)** *Николай Самохвалов*, вот его статья **[EXPLAIN (ANALYZE) needs BUFFERS to improve the Postgres query optimization process](https://postgres.ai/blog/20220106-explain-analyze-needs-buffers-to-improve-the-postgres-query-optimization-process)** на эту тему.
**[Postgres memory allocation and OS memory allocation](https://dev.to/yugabyte/postgres-memory-allocation-and-os-memory-allocation-30f1)**
*Фриц Хоогланд* (Frits Hoogland) опубликовал даже не совсем статью. Скорее, приглашение обсудить некоторые найденные им странности при алокации памяти под безымянные блоки PL/pgSQL. Исследования средствами **gdb** и линуксовой командой **smem** дают радикально разную информацию об освобождении памяти. На момент написания нашего обзора никто не откликнулся на его зов о помощи.
**[PostgreSQL – how to detect and solve memory availability issues](https://awide.io/postgresql-how-to-detect-and-solve-memory-availability-issues/)**
Речь идёт об [Awide](https://awide.io/product/) — решении для управления и мониторинга, о том, как его использовать. Там есть окошко, напоминающее монитор в Windows, но каждая строчка это SQL-запрос. Увидев прожорливый запрос, можно глянуть подробней. Есть профайлер запросов, который рисует кривую потребления памяти во времени.
Память считается доступной, если фоновый процесс postgres может алоцировать память без свапирования. Потребление и остаток рассчитываются по-разному для разных платформ, и собирается из нескольких величин. Когда свободная память опускается ниже пороговой величины, приходит предупреждение. Разработчик — тель-авивская фирма Awide Labs.
Не на ту же, но на родственную тему: [Параллелизм в PostgreSQL: не сферический, не конь, не в вакууме](https://habr.com/ru/company/postgrespro/blog/423685/) (её [англоязычный вариант](https://habr.com/ru/company/postgrespro/blog/500442/))
### Ещё статьи
**[5 years in PostgreSQL major versions performance — anything surprising?](https://kmoppel.github.io/2022-09-05-5-years-in-postgresql-major-versions-performance-anything-surprising/)**
*Каарел Моппел* (Kaarel Moppel, Cybertec) решил количественно сравнить производительность PostgreSQL версий 10 и 15 на небольшом наборе запросов, используя **pgbench**. Спойлер: 15-й победил по сумме. Но не то, чтобы очень убедительно. Каарел даже пожалел, что вполне работоспособного старика скоро выпроваживают на незаслуженную [EOL](https://itisgood.ru/2019/09/11/chto-takoe-end-of-life-eol-v-vychislitelnoj-tehnike/?ysclid=l7uzh71ddb632659464). В статье есть о JIT, о (не)надёжности тестирования в облачной среде. Выявлены две не очень впечатляющие аномалии в производительности PostgrSQL 15 Beta 2.
**[A New Approach to Sharding for Distributed PostgreSQL](https://postgrespro.com/blog/pgsql/5969681)**
*Дмитрий Урсегов*, разработчик Postgres Professional, специалист по шардингу, обозревает нынешнее состояние postgres fdw, на базе которого и делается шардинговое решение Postgres Pro. Рассказывает об узких местах при планировании шардинговых запросов. После теоретической части делится результатами TPC-C своего решения и сравнивает с другими шардинговыми решениями.
Кстати, Дмитрий помог и некоторыми интересными ссылками, которые вошли в этот выпуск — спасибо. Спасибо *Николаю Попову* и *Михаилу Жилину* — за то же. *Егор Рогов* и *Павел Лузанов* помогают всегда, это даже не буду дальше оговаривать.
**[Future Proofing SQL with Carefully Placed Errors](https://hakibenita.com/future-proof-sql)**
Интересная тема. Прямая совместимость кода SQL. Её в нашей литературе ещё называют **восходящей**. С обратной проще: код известен, данные и API тоже. А вот предвидеть будущие данные и API, которые, возможно, придётся поддерживать — это намного сложней.
Автор, *Хаки Бенита* (Haki Benita), хорошо известный в Postgres-сообществе, считает, что с проблемой прямой совместимости, в общем, справляются, но вот в мире SQL с этим плохо. Статья его не теоретическая: он сразу начинает со своего демонстрационного кода: системы платежей. Он делает ошибку, которая проскакивает незамеченной. Это не дело. Чтобы такого не происходило в будущем, он пишет простенькую функцию с RAISE EXCEPTION.
Для этой же цели можно использовать появившуюся недавно Python-функцию [assert\_never](https://docs.python.org/3.11/library/typing.html#typing.assert_never). Но есть забавный хак, позволяющий вообще обойтись без функции, вызывающей ошибку. Можно просто написать ELSE 1/0 в блоке CASE. Ещё один хак — ELSE с приведением типа.
**[Ускоряем работу с графами в 20000 раз](https://habr.com/ru/post/650007/)**
Автор, *Никита Ляпин* ака [Spinifex](https://habr.com/ru/users/spinifex/) хранит большие графы (65536 узлов и каждый из них связан с каждым, 4294967296 связей) в PostgreSQL и обходит их рекурсивными SQL-запросами. Он использует некоторый алгоритм сжатия графов, который действительно может давать такой выигрыш. Потом он тестирует и на реальных графовых данных, это тоже работает, хотя и не так эффектно. Специализированные графовые базы данных и языки запросов упоминаются, но не рассматриваются и не тестируются. Интересные обсуждения в комментариях.
**[Как реляционная СУБД делает JOIN?](https://habr.com/ru/post/560834/)**
Тот же автор. Теперь он реализует JOIN на C#, на SQL, тестирует на PostgrSQL и строит графики.
*Разработчики на C# или других ООП языках часто воспринимают СУБД как всего лишь хранилище*, — говорит он, — *они считают, что бизнес-правила в SQL — это плохо. В противовес им создаются библиотеки вроде [Linq2Db](https://github.com/linq2db/linq2db): весь код пишется на C#, но затем этот **код транслируется на SQL** и выполняется на стороне СУБД.*
На C# в явном виде, естественно, Никита реализует **Nested Loop, Merge Join** и **Hash Join**. Графики производительности причудливо переплетаются. Затем, он возвращается к идеологии СУБД (между прочим, ссылаясь как на авторитет на книгу *Хиронобу Сузуки*, о которой мы говорили выше) и PostgreSQL в частности. И в некоторых случаях СУБД обгоняет C#.
*Для получения данных СУБД динамически выбирает алгоритм, наиболее эффективный в данном случае. В C# аналогичных библиотек или реализаций просто нет*.
И не надо — автор отдаёт себе отчёт, что каждому своё. Заодно напоминаем об увлекательной статье коллеги *Павла Толмачёва* о причудливом поведении планировщика: **[Как работает оптимизатор PostgreSQL при большом количестве таблиц в запросе](https://habr.com/ru/users/ptolmachev/posts/)**
**[Как ускорить работу PostgreSQL с помощью конфигурации базы и оптимизации запросов](https://habr.com/ru/company/southbridge/blog/684826/)**
Администратор баз данных в Southbridge и ведущий инженер компании Data Driven Lab *Иван Чувашов*. Эта статья — конспект бесплатного вебинара об оптимизации PostgreSQL от «Слёрма». Некоторые тезисы статьи вызвали полемику в комментариях.
**[Where Did the Stats Collector Go in Postgres 15?](https://www.percona.com/blog/postgresql-15-stats-collector-gone-whats-new/)**
PostgreSQL отслеживает деятельность каждого процесса, чтобы дальше агрегировать статистику: например, сколько раз сканировалась таблица или индекс; когда был последний (авто)VACUUM, сколько раз он проходился по таблице. Всю эту информацию можно посмотреть через представления `pg_stat_*`.
*Джобин Аугустин* (Jobin Augustine, Percona) объясняет, какие проблемы были в версиях до PostgreSQL 15 со [stats collector](https://postgrespro.ru/docs/postgresql/14/monitoring-stats?lang=ru). В любом случае этот механизм очень плохо масштабировался. Теперь этих проблем нет, так как и самого собирателя статистики нет. Не надо хранить временные файлы, статистика лежит в разделяемой памяти.
Соответственно, параметр `stats_temp_directory` исчез. Директория `pg_stat_tmp` тоже не нужна, но её оставили, чтобы работали расширения вроде [pg\_stat\_statements](https://postgrespro.ru/docs/postgresql/14/pgstatstatements?lang=ru).
Ещё некоторые релизы
--------------------
**[FerretDB 0.5.4](https://github.com/FerretDB/FerretDB/releases/tag/v0.5.4)**
[FerretDB](https://github.com/FerretDB/FerretDB) (бывшая MangoDB — через *a*!) создавалась как де-факто опенсорсная замена MongoDB. Это прокси, конвертирующая запросы протокола MongoDB 5.0+ в SQL, используя PostgreSQL как движок базы данных. Технический директор — *Алексей Палажченко*, организатор конференции по Go [GopherCon Russia](https://www.gophercon-russia.ru/). Самая свежая версия — 0.5.4. Технические детали [по ссылке](https://github.com/FerretDB/FerretDB).
**[WAL-G 2.0.1](https://github.com/wal-g/wal-g/releases/tag/v2.0.1)**
Новое по всем СУБД: поддержка arm(aarch64) сборки пакетов под Ubuntu 20.04.
PostgreSQL: поддержка PostgreSQL 15.
Postgres-зверушки
-----------------
[Здесь](https://postgresql.pet/) собралась уже целая коллекция биографий зверушек, помогавших разрабатывать Postgres. Недавние:
**[Холли (курица)](https://postgresql.pet/post/holly_the_hen/)**
**[Эмба (пёс)](https://postgresql.pet/post/emba/)**
**[Milo (котик)](https://postgresql.pet/post/milo/)**
Статистически наибольший вклад в Postgres внесли собаки.
Конференции — взрослые и детские
--------------------------------
**[Saint Highload++](https://highload.ru/spb/2022)**
Прошёл 22-23 сентября в СПб.
Там были довольно неожиданные доклады. Например, [Могут ли данные управлять аппаратной конфигурацией дата-центра?](https://highload.ru/spb/2022/abstracts/9375) *Антон Катенев* и *Павел Лавренко* представители РСК — суперкомпьютерной фирмы. Они рассказывали об универсальной платформе, позволяющей соединить управление аппаратной конфигурацией, создание систем хранения «по запросу», управления данными и задачами обработки. Применили её для построения платформы обработки данных с Большого Адронного Коллайдера (LHC) в Объединённый Институт Ядерных Исследований в г. Дубна.
Одновременно в другом зале *Олег Бартунов* и *Иван Панченко* (руководство Postgres Professional) читали доклад совсем неожиданный: [Postgres от начала веков и до наших дней](https://highload.ru/spb/2022/abstracts/9415). От начала веков — не метафора. Действительно речь в начале шла о *самых дальних предпосылках: чтобы правильно проследить, как человечество дошло до концепции СУБД вообще и Постгреса в частности, как развивался и какими технологиями питался Постгрес*.
В [программе](https://highload.ru/spb/2022/abstracts) конференции были даже Fail-секция и Fail-митап.
**[SmartData 2022](https://smartdataconf.ru/)**
Фокус, конечно, на больших данных. Но и на ней есть доклады, имеющие отношения к Postgres. Прошла онлайн 17-18 октября и должна пройти в СПб (тоже с онлайновой частью) 29-го октября.
Можно обратить внимание на такие доклады:
[Организация потоковой обработки данных для Big Data](https://smartdataconf.ru/schedule/video?v=MTAwMTQwwooyMDAwMTE0MsKKMA) [с применением PostgreSQL] *Евгений Ненахов*, МТC Digital;
[Интервью с Александром Ермаковым](https://smartdataconf.ru/schedule/video?v=MTAwMTQwwooyMDAwMTE1MMKKMA) [Arenadata];
[Data Vault на Greenplum c помощью DBT](https://smartdataconf.ru/schedule/video?v=MTAwMTQwwooyMDAwMDU5MMKKMA) *Марк Порошин*, Smart Prediction Technologies.
Кстати, у нас есть в планах обзор по DBT — наши читатели интересуются.
**[Daycare for Children at PostgreSQL Conference Europe](https://www.postgresql.eu/events/pgconfeu2022/news/pgconfeu-2022-daycare-for-children-at-postgresql-conference-europe-62/)**
На [этой всеевропейской Postgres-конференции](https://2022.pgconf.eu/), что пройдёт в Берлине 25–28 октября, будет специальная программа для детей. Родители, пришедшие говорить или слушать, смогут доверить своих деток от 3 до 15 лет профессиональной организации, специализирующейся на присмотре за детьми — Märchenkinder (буквально: Сказочные Дети). Среди развлечений числится, например, раскрашивание лиц и ногтей.
---
*На сегодня всё.* | https://habr.com/ru/post/683810/ | null | ru | null |
# MPCMeter — индикация прогресса просмотра видео. Arduino + JavaScript
#### **Вместо введения**
Спасибо моему анонимному хабрадедуморозу за [подарочек](http://habrahabr.ru/post/249843/#comment_8278907) (*pro mini*). Долго колебался, что с ней делать. Махнул рукой и заказал в дополнение китайскую посылочку…
Спустя месяцок настало и моё время “помигать светодиодом” ;).
#### **Идея**
Пока ехала посылка, думал что бы такого сделать. В итоге принято решение сделать что-нибудь чуть больше, чем помигать светодиодом.
Идея заключается в следующем — отобразить прогресс просмотра видео, используя какой-нибудь индикатор.
#### **Задача**
1. вытащить статистику по запущенному фильму;
2. обработать и передать в arduino данные;
3. отобразить прогресс на индикаторе.
#### **Для нетерпеливых сразу результат**
#### **Реализация**
##### **1. MPC**
Сколько себя помню, на ПК у меня всегда установлен [Media PLayer Classic](https://mpc-hc.org/). Оказывается MPC умеет отдавать статистику по, скажем так, текущей сессии в виде html-странички со следующим содержанием:
**HTML**
```
MPC-HC WebServer - Variables
D:%5cFILMS%5cIts.Always.Sunny.in.Philadelphia.S10E10.720p.WEB.rus.LostFilm.TV.mp4
D:\FILMS\Its.Always.Sunny.in.Philadelphia.S10E10.720p.WEB.rus.LostFilm.TV.mp4
D:%5cFILMS
D:\FILMS
1
Пауза
1069384
00:17:49
1255210
00:20:55
75
0
1
0
```
Что бы добиться от него такого функционала, нужно проставить галочку "**Слушать порт**" в настройках
**Настройки**
Всё самое важное содержится в тегах
```
значение
```
Остаётся только разобрать их и выбрать нужное.
##### **2. NodeJS**
Разбирать страничку будем при помощи NodeJS. Кстати, страница доступна по адресу [localhost](http://localhost):13580/variables.html (порт из настроек).
Всю логику можно разделить на 3 блока:
* модуль работы с MPC web-сервером;
* модуль обработки данных;
* модуль работы с arduino.
Далее основные моменты. Весь проект вместе с кодом можно глянуть на [github](https://github.com/andreevich/MPCMeter)
**Немного js**При помощи родного http.get и обещаний обращаюсь к нашей странице
```
main.prototype.get = function(){
var that = this
return new Promise(function(done){
http.get(that.mpc_uri, function(res) {
res.on('data', function (chunk) {
that.mpc_obj.parse(chunk)
done(that.mpc_obj.get());
});
}).on('error', function(e) {
done(e.message);
});
})
}
```
Методом parse объекта mpc\_obj разбираю полученные данные
```
MPC_obj.prototype.parse = function(data){
var obj = {}
data.toString().split('\n').forEach(function(line){
// отбираем параграфы, так как параметры только в них
if (match=/\')+1,line.lastIndexOf('<'))
}
})
this.settings=obj;
}
```
На выходе имеем вот такой объект
```
{ filepatharg: 'D:%5cmbrr555.avi',
filepath: 'D:\\mbrr555.avi',
filedirarg: 'D:%5c',
filedir: 'D:\\',
state: '1',
statestring: 'Пауза',
position: '1023',
positionstring: '00:00:01',
duration: '114906',
durationstring: '00:01:54',
volumelevel: '77',
muted: '0',
playbackrate: '1',
reloadtime: '0' }
```
Подготавливаем данные для arduino
```
// Возвращает прогресс просмотренного
MPC_obj.prototype.getProgress = function(){
return (this.settings["position"]/this.settings["duration"]).toFixed(5)
}
// Возвращает прогресс для ШИМ (PWM) 1,0 -> 255
MPC_obj.prototype.PWM = function(){
return (this.getProgress()*255).toFixed(0)
}
```
Общение с arduino происходит путём обмена данными на com-порту. Для работы с com выбрал библиотеку [node-serialport](https://github.com/voodootikigod/node-serialport)
Подключаемся с её помощью к порту com5 и устанавливаем скорость
```
var SerialPort = require('serialport').SerialPort;
var serialPort = new SerialPort("COM5", {
baudrate: 57600
}, false);
```
Открываем порт и посылаем в ответ arduino наш прогресс каждый раз, когда она попросит
```
serialPort.open(function (error) {
if ( error ) {
console.log('failed to open: '+error);
} else {
console.log('open');
//получил данные от arduino
serialPort.on('data', function(data) {
main.init(function(a){
//послал в ответ прогресс фильма
serialPort.write(a);
});
});
}
});
```
##### **3. Arduino**
Теперь железо. Данные для arduino мы подготовили, теперь определимся с той самой индикацией. Для отображения прогресса я выбрал вот такой очень дешёвый модуль вольтметра и немного его «подкрасил»
**Чуть подробней**Оказывается, крышка держалась на… липкой ленте и легко снималась
Ну а далее размеры и пара новых панелек
В arduino мы посылаем данные о прогрессе фильма и пропорционально изменяем напряжение на одной из ног микроконтроллера. Принципиальная схема (наличие светодиода для того, что бы им помигать в конце сеанса ;))
Теперь запрограммируем наш микроконтроллер.
В переменную inByte будем считывать данные, полученные по com-порту. Вешаем на 3й пин светодиод, а на 9й — вольтметр. Устанавливаем точно такую же скорость как и раньше. loop — наш бесконечный цикл. Каждые 100мс отправляем в порт абстрактные данные Serial.print('A'). Ждём наличие ответа Serial.available() > 0. Если на ПК запущен MPC и nodeJS-приложение, которое возвращает прогресс, то чуть подсветим светодиод на 3м пине analogWrite(3, 5) и передадим на 9й пин вольтметра значение прогресса analogWrite(9, inByte). Функция analogWrite передаёт значения от 0 до 255, что в нашем случае соответствует от 0В до 5В. Тут нужно почитать про [ШИМ (PWM)](http://arduino.ru/Tutorial/PWM) — это всё благодаря ему.
Когда мы просмотрели половину фильма, в этот момент на 9й пин будет передано 255/2 = analogWrite(9, 127), что соответствует 2,5В на вольтметре. Как только фильм закончен — бодренько мигаем светодиодом ;)
```
int inByte = 0;
void setup() {
pinMode(9, OUTPUT);
pinMode(3, OUTPUT);
analogWrite(3, 0);
analogWrite(9, 0);
Serial.begin(57600);
}
void loop() {
Serial.print('A');
delay(100);
if (Serial.available() > 0) {
analogWrite(3, 5);
inByte = Serial.parseInt();
analogWrite(9, inByte);
if (inByte==255)
analogWrite(3, 255);
}
}
```
Вот так это всё выглядит в живую на макетке
да ещё и на видео ;)
Кстати в этом проекте использован как раз [подарочек](http://habrahabr.ru/post/249843/#comment_8278907) от того самого хабрадедамороза.
PS.
Рядом лежит Attiny13, как время будет — попробую перенести всё на неё.
Ссылки:
* [подарочек от хабрадедамороза](http://habrahabr.ru/post/249843/#comment_8278907);
* [Media PLayer Classic](https://mpc-hc.org/);
* [Весь проект на github](https://github.com/andreevich/MPCMeter);
* [модуль для работы с com-портом node-serialport](https://github.com/voodootikigod/node-serialport);
* [про ШИМ (PWM)](http://arduino.ru/Tutorial/PWM) ;
* [свеженький NodeJS](https://nodejs.org);
* [Arduino IDE](http://arduino.cc/en/Main/Software).
Если где-то написал полную ерунду или ошибся — подсказывайте, подправлю ;). Спасибо за внимание. | https://habr.com/ru/post/254911/ | null | ru | null |
# Оптимизация сайта для GooglePage Speed (учтены все особенности после его обновления) Часть 1
Эта статья будет интересна, кто столкнулся с разного рода проблемами после обновления Google PageSpeed и претензиям со стороны заказчиков или начальника, почему упал бал или возникло такое количество замечаний. А так же тем, кто производит оптимизацию сайтов.
В первую очередь стоит упомянуть, что вот [в этой статье](https://habr.com/post/429668/), на мой взгляд, всё очень грамотно и доступно расписано.
Я же от себя добавлю больше *практических* советов, а так же будет интересно послушать вашу точку зрения и увидеть ваши наработки.
Перечислю о чём я буду говорить в этой статье:
1. CSS и JS
* подключение файлов
* загрузка библиотек
* трюки
2. Fonts
* подключение шрифтов
* отображение шрифтов во время загрузки страницы
3. Изображения
* разные форматы (jpg, png, webp, base64)
* sprite
И если ты остался на этой статье до этого момента, то тебе скорее всего интересно (или у тебя заглючила кнопка «назад») Ниже подробнее о каждом пункте.
### CSS и JS
**JS**
1. Обязательным будет свойство **async** для подключаемых скриптов (кроме jQuery). Это точно избавит вас от замечания в GPSpeed по поводу асинхронной загрузки скриптов.
2. Совет банальный, но он очень толковый — старайтесь использовать сложные и массивные библиотеки по минимуму.
3. Свои настройки js библиотек (slick, fancybox) или небольшие фрагменты кода, которые выполняют разные задачи лучше заливать на сервер одним файлом. В моём случае, и скрипт для отправки почты, и маска для input и анимация и всё-всё находится в одном файле build.js ( которому я так же задаю **async**.
4. Этот совет ситуативный, то есть под ситуацию смотрите. Если у вас сразу после открытия страницы на её первом экране выполняется какой-то скрипт, то его будет правильнее подключить отдельно и не давать ему **async**
**CSS**
1. Тут немного посложнее. К тегу **link** вам необходимо будет добавить такое свойство
Именно в таком виде ваши css файлы будут подключаться лишь после дерева DOM. Грубо говоря, это тот же **async** только для .css
2. Очень важный и действенный совет! Он добавляет от 5 до 10 баллов гарантированно. Нужно **разделить ваш main.css на два файла**. В первом будут только те стили, которые подгружаются для того контента, который виден сразу после открытия страницы. Это top bar, header, первая картинка, первая form и тд. В общем то, что вы поместили на «лицо» вашего сайта. Во втором уже всё остальное.
### Шрифты
Я обнаружил новое для себя css свойство для шрифтов
```
font-display
```
А конкретно, его параметр **swap**, который не дожидаясь подгрузки вашего красивого и тяжёлого шрифта показывает текст в браузере используя встроенный в этот же браузер шрифт (например sans-serif). Это сразу же убирает одну из ошибок в GPSpeed.
Выглядеть это будет так
```
@font-face {
font-family: 'FontName';
src: local('FontName'), url('FontName.woff') format('woff');
font-weight: normal;
font-style: normal;
font-display: swap;
}
```
Так же есть такой скрипт (для его работы нужно подключить fontfaceobserver.js):
```
var html = document.documentElement;
if (sessionStorage.fontsLoaded) {
html.classList.add("fonts-loaded");
} else {
var script = document.createElement("script");
script.src = "../js/fontfaceobserver.js";
script.async = true;
script.onload = function() {
var regular = new FontFaceObserver("FontName");
var bold = new FontFaceObserver("FontName", {
weight: "bold"
});
var light = new FontFaceObserver("FontName", {
weight: "300"
});
Promise.all([
regular.load(),
bold.load(),
light.load()
]).then(function() {
html.classList.add("fonts-loaded");
sessionStorage.fontsLoaded = true;
});
};
document.head.appendChild(script);
}
```
Лично мне не очень помог, но вы попробуйте, может вы лучше с ним совладаете. Ведь я нашёл его на просторах, и люди говорили, что действительно помогает.
### Подключение шрифтов
1. В основном встречаются два вида подключения — с помощью ссылки (например на google fonts, или же локально, на сервере. Так вот, по поводу второго способа, его так же можно поделить на 2: отдельным css файлом (с помощью link подключаем fonts.css) и напрямую через код (через ваш style.css).
И поскольку сейчас мы ведём речь именно об оптимизации сайта для GPSpeed, то я убедился в том, что лучше подключаться шрифты через ваш главный файл css.
2. И ещё один совет, который помогает — положите файлы со шрифтами (woff, ttf и тд) рядом с вашим файлом css, который его запрашивает. Раньше у меня была отдельная папка на сервере для шрифтов, но потом я переместил их скорость загрузки шрифтов увеличилась в 2 раза. (по данным GPSpeed на подключение шрифта Muller раньше у меня уходило 180ms, сейчас 70-90ms)
### Изображения, картинки и т.д.
За следующие 2 совету ручаюсь, помогли не только мне, а всему офису и даже друзьям отдалённо работающим.
1. Загружайте абсолютно все картинки **> с помощью lazyloading. Выглядеть это будет так
```
![Описание]()
```
И не забудьте подключить **lazyload.min.js**
2. Если у вас на странице много **sv**g элементов, то их лучше добавлять **чистым кодом**, без лишнего обращения к тегу img. Кроме того, svg необходимо ужимать, например, с помощью этого сайта [jakearchibald.github.io/svgomg](https://jakearchibald.github.io/svgomg/) (не реклама).
3. Банально, но не забывайте ужимать ВСЕ картинки на сайте. Даже те, которые весят 5кб. Хоть эти 3 кб которые вы выиграйте никак не повлияют на скорость загрузки, вы избавитесь от ошибки на GPSpeed, и добавите себе до 10 баллов.
**!**Теперь проблемный момент — форматы изображений. А именно нас волнует *webp, JPEG 2000, JPEG XR*. Ведь сейчас это один из рекомендуемых GPSpeed-ом расширений. Как известно, они до сих пор не поддерживается некоторыми браузерами, среди которых достаточно популярный Mozila Firefox. Хоть они и объявили, что **в марте будет полная поддержка** этого формата, нам всё-равно ещё год ждать, пока все юзеры этого браузера обновятся до последней версии… Я перерыл кучу сайтов, кучу скриптов, но толкового ничего не нашёл. По этому теперь настало моё время задать вопрос вам: используете ли вы формат webp или любые другие новые форматы изображений? И как вы это делаете?** | https://habr.com/ru/post/436966/ | null | ru | null |
# Новые источники данных для Teiid, часть 1: используем DDL
Те, кто сталкивались с необходимостью объединения нескольких источников данных, наверное, уже знают о [JBoss Teiid](http://www.jboss.org/teiid "JBoss Teiid"), вводная статья о нём есть даже на [хабре](http://habrahabr.ru/post/142580/). Коротко говоря, эта система предназначена для для представления нескольких физических источников данных (например, СУБД) в виде одной виртуальной базы данных (virtual database, VDB) с доступом по SQL.
Штатно Teiid поддерживает многие источники данных, например, *Oracle*, *DB2*, *M$ SQL Server*, *MySQL*, *PostgreSQL*, *[SalesForce](http://www.salesforce.com/)*, но, вместе с тем, предоставляет также и удобные инструменты для работы с web-сервисами, XML, JSON. На базе этого инструментария можно легко построить доступ к несложному источнику данных (например, делать запросы в twitter, в поставке Teiid есть готовый пример), и обойтись при этом только [DDL](http://ru.wikipedia.org/wiki/Data_Definition_Language)-описанием. Но для чего-либо посложнее уже требуется писать код.
[Вторая часть](http://habrahabr.ru/post/150878/ "Новые источники данных для Teiid, часть 2: пишем транслятор") статьи.
В этой части мы рассмотрим способ описания с помощью DDL, в следующей будем писать транслятор.
В общем случае для организации доступа к источнику требуются две составных части: коннектор (connector) и транслятор (translator). Коннектор отвечает за непосредственно соединение, тогда как транслятор агрегирует исходные данные (запрос), отправляет их через соединение, предоставленное коннектором, получает ответ и преобразует его в понятную для Teeid форму.
Традиционно для иллюстрации описываемого в постах на хабре авторы используют что-нибудь, имеющее отношение к хабру. Почему бы и нет? В качестве источника данных мы возьмём хабр-апи: <http://habrahabr.ru/api/profile/%name%>.
Среди прочих коннекторов, поставляемых с Teiid, есть универсальный WS connector, подходящий для любого сервиса, предоставляющего доступ по http/https. Им мы и воспользуемся для доступа к web-сервису хабра.
Базовые настройки
-----------------
Для начала необходимо прописать источник данных. Для JBoss 7 в файл *%JBOSS\_HOME%/standalone/configuration/standalone.xml* (или *...domain...*) нужно добавить такое:
>
> ```
>
> [...]
>
>
> teiid-connector-ws.rar
> NoTransaction
>
>
> http://habrahabr.ru/api/profile/
>
>
>
>
> [...]
> ```
>
Тут есть 2 важных момента: в строке с отметкой [1] мы задаем JNDI-имя нашего data source (это имя мы будем использовать в дальнейшем), а в строке с отметкой [2] — end point — URL нашего сервиса.
Пишем DDL
---------
Я уже упоминал выше о примере реализации запросов в twitter, который поставляется с Teiid. Для того, чтобы получить доступ к хабр-апи таким же способом, достаточно написать правильный DDL в VDB-файле.
Итак, *habr-vdb.xml*:
>
> ```
> xml version="1.0" encoding="UTF-8" standalone="yes"?
>
>
>
>
>
>
> CREATE VIRTUAL PROCEDURE getHabr(name varchar) RETURNS (login varchar(128), karma float, rating float,
> ratingposition long) AS
> select ha.\* from
> (call habr.invokeHTTP(action => 'GET', endpoint =>querystring(name))) w,
> XMLTABLE('habrauser' passing XMLPARSE(document w.result) columns
> login varchar(128) PATH 'login',
> karma float PATH 'karma',
> rating float PATH 'rating',
> ratingposition long PATH 'ratingPosition') ha;
> CREATE VIEW Habr AS select \* FROM habrview.getHabr;
>
>
>
>
>
>
>
> ```
>
По сути, это — уже готовая реализация нашего источника данных, т.к. написанного достаточно, чтобы получить информацию о любом юзере через хабр-апи.
Разбираем код подробнее
-----------------------
`/>` — способ описание нового транслятора через наследование (type — имя родительского транслятора, name — имя создаваемого транслятора). Предназначен этот способ для того, чтобы можно было задавать значение свойств (properties), отличных от значений по умолчанию. Т.к. значение по умолчанию свойства `DefaultBinding = SOAP12`, то мы не можем напрямую использовать транслятор ws.
Штатный WS connector реализует процедуру invokeHTTP(), через которую и работает весь его функционал. `/>` служит для подключения нашего источника данных *habrDS* (мы описывали его выше, в *standalone.xml*) и вновь созданного транслятора '*rest*'. Таким образом, при вызове `habr.invokeHTTP()` мы вызываем транслятор с конкретными параметрами и заданным URL web-сервиса.
Для непосредственной обработки данных мы должны создать дополнительную модель — `/>`: дело в том, что описывать сущности БД через DDL мы можем только в моделях, имеющих `type="VIRTUAL"`, с другой стороны, указывать источники данных и трансляторы мы можем только в не-виртуальных моделях, а нам необходимо и то, и другое.
Здесь всё просто: создаём виртуальную процедуру `getHabr`, для которой описываем входной параметр и результаты, и которая реализуется через SELECT-запрос, который, в свою очередь, вызывает `habr.invokeHTTP()` для выполнения GET-запроса к web-сервису (с назначением результату алиаса `w`). Здесь параметр `name` передаётся из виртуальной процедуры в реальную. `habr.invokeHTTP()` возвращает полученные данные в параметре result, который далее передаётся во встроенную функцию `XMLPARSE(document w.result)`, где `document` означает, что это well-formed XML, а не фрагмент. Эта функция парсит полученные данные и уже в виде XML-дерева передаёт дальше, в функцию `XMLTABLE`, для которой мы так же, как и для виртуальной процедуры, задаём список колонок с указанием типов, а кроме типов указываем ещё и пути, по которым значения будут доставаться из XML-документа. `'habrauser'` означает базовый путь.
И последний шаг: создаём view, которое реализуется, как вызов виртуальной процедуры и, соответственно, заимствует список её выходных параметров в качестве своей структуры.
Всё. Осталость только сделать запрос:
```
select * from habrview.habr where name='elfuegobiz'
``` | https://habr.com/ru/post/150765/ | null | ru | null |
# Введение в HDInsight
HDInsight Services for Windows Azure — это сервис, позволяющий работать с кластером Apache Hadoop в Облаке, предоставляющий программную среду для операций управления, анализа и отчетности по Большим Данным.
Я не буду подробно останавливаться на возможностях Hadoop. Он был впервые представлен в 2005 г. в составе проекта Apache Software Foundation и представляет собой программную платформу распределенной обработки значительных объемов данных. Скажем, петабайтный размер не является для нее препятствием. Платформа Hadoop основана на распределенной файловой системе HDFS (Hadoop Distributed File System), реализованной на кластере Hadoop. В состав кластера входят узлы, хранящие фрагменты файлов (DataNode). Теоретически могут быть сотни и тысячи таких узлов, основанных на недорогих вычислительных платформах (commodity hardware). Для обеспечения высокой надежности поддерживается избыточность путем создания копий фрагментов между узлами. Знаниями о том, на каком узле данных какая реплика лежит, обладает NameNode. Со стороны клиента это выглядит, как обычная древовидная файловая система. Сам NameNode не выполняет основные операции ввода-вывода. Он лишь снабжает клиента метаданными о местоположении первичной реплики фрагмента. Репликация фрагментов осуществляется автоматически. В случае выхода из строя первичной реплики фрагмента одна из его вторичных реплик назначается первичной и на дополнительном узле также автоматически создается еще одна копия. Масштабируемость на значительные объемы данных достигается за счет параллельной обработки фрагментов. Исторически в разработке Google Labs проект Hadoop был ориентирован на задачи поиска и классификации Интернет-контента. Например, функция Map получает на вход набор данных и преобразует его в список пар ключ/значение. Функция Reduce выполняет обратную операцию, сворачивая список путем группировки его по ключам. В целях распараллеливания может быть создано множество экземпляров таких функций, каждый обрабатывающий свой фрагмент. Узлы, на которых хранятся входные фрагменты файлов и запускаются обрабатывающие их экземпляры MapReduce, носят название TaskTracker, а координирующий экземпляры узел – JobTracker. Количество экземпляров определяется количеством и местоположением фрагментов. Помимо поисковых, под данный шаблон попадает множество иных типов задач обработки данных. Существуют построенные поверх HDFS и MapReduce проекты Pig, Hive, Mahout, Pegasus и др., предоставляющие более высокий уровень абстракции и позволяющие решать задачи управления потоками данных, запросные, аналитические задачи, а также задачи отыскания скрытых закономерностей (data mining), характерные для хранилищ (data warehouses), которые традиционно строятся на серверах управления базами данных, реляционной модели и того или иного диалекта языка запросов SQL. Взаимодействие не менее традиционно осуществляется при помощи ODBC-драйверов.
Осенью прошлого года на конференции Pass Summit 2011 в Сиэтле было объявлено о выпуске Hadoop Connector для Microsoft SQL Server, облегчающего обмен данными между двумя системами. Кроме того, в партнерстве с компанией HortonWorks в настоящее время предоставляется предварительная ознакомительная версия Windows Azure HDInsight Service и Microsoft HDInsight Server for Windows,[100%-совместимая](http://www.microsoft.com/sqlserver/en/us/solutions-technologies/business-intelligence/big-data.aspx) с открытыми стандартами Apache Hadoop. Скачать HDInsight Server под Windows можно [здесь](http://www.microsoft.com/web/gallery/install.aspx?appid=HDINSIGHT-PREVIEW). Чтобы попробовать HDInsight Service в Облаке, нужно зарегистрироваться на тестирование [здесь](https://connect.microsoft.com/SQLServer/Survey/Survey.aspx?SurveyID=13697).
В качестве пререквизитов необходимо иметь облачную учетную запись Microsoft. Эккаунты в рамках программ MSDN, BizSpark, DreamSpark работают. В рамках предварительной версии доступно создать кластер Hadoop из 3-х узлов с общим объемом дискового пространства 1.5 ТБ. Кластер будет жить 5 суток с момента создания. После этого вся конфигурация и содержимое будут потеряны, придется создавать заново. Из начальных данных требуется указать DNS-имя (оно, понятно, должно быть уникальным) и административный логин/пароль. Использование Windows Azure SQL Database для хранения метаданных нам на первых порах не понадобится, но на всякий случай обратите внимание, что такая возможность есть и база (в том случае, если вы захотите ей воспользоваться) должна быть создана заранее. Жмем на кнопку Request Cluster в правой нижней части экрана:
Рис.1
Проходит несколько минут, и Cluster Status = Deploying изменяется на Running, после чего его можно использовать.
Рис.2
Жмем на ссылку Go to Cluster. Из Web-интерфейса можно перейти в интерактивная консоль выполнения JavaScript и Hive-команд, сессию удаленного доступа, сконфигурировать порты для взаимодействия по ODBC, создать задание, посмотреть историю выполнения заданий, ознакомиться с типовыми примерами использования Hadoop. По кнопке Downloads в настоящее время имеется возможность установить на локальную машину x86 или х64 HiveODBC-драйверы. Кнопка Manage Cluster позволяет контролировать размер использованного дискового пространства, а также задать папки в Windows Azure BLOB Service, которые можно рассматривать как сторидж (Azure Storage Vault), альтернативный дисковому пространству кластера для нативных процессов Hadoop. Например, в качестве входного и выходного местоположения для MapReduce. Если что-то фатально напортачили, кластер можно пересоздать, зайдя на [www.hadooponazure.com](https://www.hadooponazure.com/) и нажав кнопку Release Cluster.
Рис.3
Установим соединение через Remote Desktop, кликнув на соответствующую плитку в экране портала. Для авторизации используется учетная запись, заданная на Рис.1.
Рис.4
Можно видеть, что в качестве базовой операционной системы используется 64-битная редакция Windows Server 2008R2 Enterprise SP1. Она установлена на партиции D:. Для открытия командного окна Hadoop запустим Start -> Run ->
`D:\Windows\system32\cmd.exe /k pushd "c:\apps\dist\hadoop-1.1.0-SNAPSHOT" && "c:\apps\dist\hadoop-1.1.0-SNAPSHOT\bin\hadoop.cmd"`
Создадим в HDFS каталог для будущих экспериментов и подкаталог, куда будут размещены входные данные:
`hadoop fs -mkdir Sample1/input`
Для получения интерактивной справки java FsShell следует набрать hadoop fs -help.
Перенесем в подкаталог input файл Sample.log, который понадобится для дальнейшей иллюстрации работы Hadoop. Этот файл представляет собой некоторый абстрактный журнал слабоструктурированного формата, содержащий строки с признаками TRACE, DEBUG, INFO, FATAL и т.д. Его можно взять из примеров HortonWorks по адресу [gettingstarted.hadooponazure.com/hw/sample.log](http://gettingstarted.hadooponazure.com/hw/sample.log). Это не терабайтный лог, он имеет скромный размер ~100 КБ, но для иллюстрации, скажем, MapReduce сгодится. Для простоты скачаем его начально в директорию Windows на кластере HDInsight, скажем, d:\Temp. Интернет на Windows-машине, с которой установлено удаленное подключение, имеется. Сразу будет предложено обновить Internet Explorer, но для наших последующих задач это несущественно. Загрузим Sample.log в HDFS. Для копирования из локальной файловой системы используется свитч -put:
`hadoop fs -put d:\Temp\Sample.log Sample1/input/`
Убеждаемся, что он загрузился:
`hadoop fs -ls Sample1/input/`
Рис.5
Далее будут рассмотрены базовые возможности MapReduce на примере анализа Sample.log. | https://habr.com/ru/post/165185/ | null | ru | null |
# Пишем кроссбраузерный UserJS. Пример №2: переопределяем alert()
Начало: [Пример №1: меняем логотип Яндексу](http://habrahabr.ru/blogs/GreaseMonkey/73901/)
Прошлый раз меня спросили: "[А из UserJS есть доступ к переменным страницы?](http://habrahabr.ru/blogs/GreaseMonkey/73901/#comment_2129699)".
Ответ: да.
Я покажу пример с функцией alert(). alert — переменная страницы, метод window. Заместо alert может быть любая другая переменная.
### Opera и Safari GreaseKit
```
window.alert = function(){ ... }
```
### Firefox
`window.wrappedJSObject.alert = function(){ ... }`
Помните window.wrappedJSObject из прошлой статьи? Нет? Тогда goto "[Пример №1: меняем логотип Яндексу](http://habrahabr.ru/blogs/GreaseMonkey/73901/)".
Вариант работающий в Опере, Файрфокс и Safari GreaseKit:
```
var w = window.wrappedJSObject || window;
w.alert = function(){ ... }
```
[Nice alert](http://habrahabr.ru/blogs/GreaseMonkey/70850/), скрипт, который я делал, использует именно этот код.
### Google Chrome
В Google Chrome 3 можно было обратиться к window страницы через contentWindow. [В Chrome 4 это убрали из соображений безопасности](http://groups.google.com/group/chromium-extensions/browse_thread/thread/a4ff886cfecf80ca). Говорят, пишите так:
```
location.href = "javascript:window.alert=function(){ ... }
```
*Примечание:* Я вообще не вижу смысла писать UserJS для Хрома. Нужно писать [.CRX расширения](http://code.google.com/chrome/extensions/getstarted.html), они обновляться умеют. Это тот же UserJS, но в архиве (плюс мелочь типа manifest.json). Поэтому, про Хром писать я пока не буду.
Продолжение: [Пример №3: TwitPic thumbnails](http://habrahabr.ru/blogs/GreaseMonkey/74012/) | https://habr.com/ru/post/73928/ | null | ru | null |
# Новая система nooLite-F с обратной связью и шифрованием
На днях в лабораторию Hi-Lab.ru поступили модули новой системы **nooLite-F** компании [Ноотехника](http://www.noo.com.by/) для тестирования и интеграции с [Arduino Mega Server](https://hi-lab.ru/arduino-mega-server) и я предлагаю вашему вниманию небольшое резюме по новой системе, своё мнение о ней и простые примеры кода Arduino для управления новыми устройствами.
Эта статья — одна из первых ласточек по этой системе и я думаю, что скоро вы увидите много других отчётов о ней, а пока самая горячая и актуальная информация из первых рук.
Что такое nooLite?
------------------
Для тех кто не знал или забыл, напомню, что nooLite это беспроводная система управления электрооборудованием, таким, как освещение в вашем доме или электроприборы, которые можно включать и выключать при помощи беспроводных пультов управления. Пульты имеют много вариантов исполнения, но в основном они выглядят как обычные выключатели освещения. Управляющие блоки, которые принимают команды, представляют собой небольшие коробочки с несколькими проводами, часть из которых подключается к питающему напряжению, а часть — к нагрузке.
Просто и понятно. Благодаря этой простоте система nooLite завоевала популярность и продаётся в большом количестве сетевых и оффлайновых магазинов. Но есть одно «но». Всем хороша система nooLite, но она имеет один (и даже два) существенных недостатка. Первый — это отсутствие серьёзного шифрования передаваемых команд и данных. Для большинства бытовых применений это не очень критично, но для многих людей это неприемлемо с точки зрения безопасности — существует хоть небольшая, но не нулевая вероятность того, что вам не повезёт и кто-то из хулиганских или криминальных соображений решит вскрыть ваше соединение и поуправлять вашим оборудованием.
Второй недостаток — это отсутствие в системе обратной связи (есть правда псевдо-обратная связь при помощи специальных блоков, но это не очень серьёзно). Что это значит? Это значит, что вы, отдав команду на включение чего-либо, не можете быть уверены, что эта команда реально выполнена, а не ушла бесследно в мировой эфир.
Вот как раз с этими двумя недостатками и призвана бороться новая версия системы под названием nooLite-F. Разговоры необходимости выпуска новой версии шли уже давно и вот наконец в продаже появились первые приборы новой серии.
Немного технических подробностей
--------------------------------
С технической точки зрения система nooLite представляет собой приёмно-передающие устройства, работающие на частоте 433 МГц и использующие амплитудную модуляцию передаваемого сигнала. Выбор амплитудной модуляции обусловлен тем, что по мнению производителя системы, это простой и слабо восприимчивый к помехам способ передачи команд на небольшое расстояние. В системе используются PIC контроллеры (12, 16, 18). Энергопотребление устройств невелико и пульты и сенсоры системы работают на батарейках.
В новой системе nooLite-F частота работы осталась прежней, 433 МГц, и что ещё более важно — сохранилась совместимость со старой версией оборудования. То есть вы можете при помощи управляющих модулей nooLite-F работать с обычными приборами nooLite.
В новой системе модуляция сменилась на частотную, но, как это ни удивительно, это не мешает новым устройствам работать со старыми, использующими амплитудную модуляцию. Как это возможно? Инженерам компании, пришлось немного модифицировать трансивер новых модулей для работы одновременно с обоими типами модуляции.
Новые трансиверы имеют лучшую чувствительность и, как следствие, примерно на 30% большую дальность связи.
Безопасность и шифрование
-------------------------
В системе nooLite-F используется серьёзное шифрование по стандарту AES, что должно надёжно обезопасить работу и использование этого оборудования. В свою очередь работа с шифрованием потребовала повышения вычислительной мощности и заставило перейти на использование контроллеров PIC 32. Но это по прежнему энергоэффективное решение и блоки и модули системы могут длительное время работать от батареек.
Доступное оборудование
----------------------
На данный момент для покупки доступны три устройства новой системы:
* Адаптер MTRF-64-USB для управления через USB интерфейс с компьютера
* Модуль MTRF-64 для управления при помощи контроллеров с UART интерфейсом
* Беспроводной силовой блок SLF-1-300
Мы будем проводить свои эксперименты с силовым блоком SLF-1-300 и модулем MTRF-64.
Всего три изделия это временное явление — в планах компании выпуск целой линейки оборудования системы nooLite-F, в том числе устройств на DIN-рейку.
Силовой блок SLF-1-300
----------------------
Внешне силовые блоки новой системы ничем не отличаются от привычных блоков nooLite. Тот же аккуратный корпус и те же несколько проводов для подключения питания и нагрузки.
Несколько интересней выглядит содержимое блока. Слева на картинке видны две микросхемы — одна (поменьше) это микросхема трансивера, точная маркировка:
**MRF49XA
1637
RG3**
и вторая микросхема контроллера, управляющего блоком, точная маркировка
**STI E4 7B572
32F030F4P6
PHL 648 A**
Всё очень компактно и аккуратно. Это и есть долгожданный nooLite с шифрованием и обратной связью.
Обратная сторона платы практически полностью закрыта радиатором.
Что находится под радиатором можно увидеть, посмотрев на плату силового блока сбоку: несколько объёмных деталей не уместившихся на обратной стороне платы. Вот и вся схемотехника.
Модуль MTRF-64
--------------
Как я уже сказал, мы будем рассматривать модуль MTRF-64 с UART интерфейсом, его собрата с USB подключением мы трогать не будем, они практически идентичны, за исключением нескольких деталей о которых будет сказано чуть ниже. Фото управляющего модуля:
Как вы видите, он очень похож на силовой блок, те же микросхемы, кварц и ещё несколько деталей. Вот точная маркировка микросхем, установленных на плате. Трансивер:
**MRF49XA
1636
M5H**
Микроконтроллер:
**STI E4 7B573
32F042F6P6
PHL 648 A**
Пустующее место для недостающей микросхемы — это место для установки FTDI переходника USB-UART. Тут же видно место для установки USB разъёма — очевидно, что для обоих устройств используется одна и та же печатная плата.
Теперь немного о подключении модуля к микроконтроллерам вообще и к Arduino в частности: для работы модуля достаточно подключить всего четыре провода — RX, TX, VCC, GND. Проще, как говориться, некуда.
Для тех, кто не только читает статьи, но что-то делает своими руками замечу, что модуль питается строго от 3,3 вольт и его выводы не толерантны к 5-вольтовым сигналам, так что имейте это в виду и будьте внимательны при подключении модуля.
Немного о функционале модуля. Он имеет четыре основных режима работы:
* Передатчик для «старых» устройств системы nooLite. Это аналог функционала модуля nooLite [MT1132](https://geektimes.ru/post/269100/)
* Приёмник для «старых» устройств системы nooLite. Аналог модуля nooLite [MR1132](https://geektimes.ru/post/274520/)
* Передатчик для нового оборудования nooLite-F
* Приёмник для нового оборудования nooLite-F
То есть этот модуль является универсальным решением для взаимодействия микроконтроллеров с системой nooLite. Плюс, в отличие от своих аналогов, имеет возможность работать с 64-я каналами, вместо 32-х.
Arduino и nooLite-F
-------------------
Теперь давайте разберём простой пример, который даст вам представление о работе с этим модулем в среде Arduino. По аналогии вы сможете организовать работу с этим модулем с любой другой системой.
Модуль взаимодействует с управляющим контроллером по последовательному интерфейсу (Serial) на скорости 9600 б/с. Поскольку MTRF-64 работает только с напряжением 3,3 В, то мы отложим в сторону нашу любимую Arduino Mega и возьмём с полки Arduino Due и подключим модуль к ней. Четыре проводка и всё готово. Для связи с модулем будем использовать Serial3.
* Вывод RX модуля подключаем к TX3 (14) Arduino Due.
* Вывод TX модуля подключаем к RX3 (15) Arduino Due.
Теперь можно написать тестовый демонстрационный скетч. Начнём с функции setup().
```
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println(F("NooLite-F test"));
Serial3.begin(9600);
delay(1);
bootOut();
// Commands:
// 0 - Off
// 2 - On
// 4 - Switch
// 9 - Unbind
//15 - Bind
setCommand(0);
setChannel(0);
setChecksum();
Serial.print(F("CH: ")); Serial.println(TO_MTRF[4]);
Serial.print(F("CMD: ")); Serial.println(TO_MTRF[5]);
Serial.print(F("CHECKSUM: ")); Serial.println(TO_MTRF[15]);
mtrfSend();
delay(100);
}
```
Запускаем Serial для вывода отладочных сообщений и Serial3 для работы с модулем MTRF-64. При старте модуль входит в режим обновления ПО на 12 секунд и для прерывания этого режима мы включаем функцию
```
void bootOut() {
for (byte i = 0; i <= 16; i++) {
Serial3.write(BOOT_OUT[i]);
}
}
```
Которая отправляет магические данные модулю, выводящие его из режима обновления ПО.
Далее формируем команду:
```
// Commands:
// 0 - Off
// 2 - On
// 4 - Switch
// 9 - Unbind
//15 - Bind
```
На самом деле команд гораздо больше, с полным описанием протокола и работы модуля вы можете ознакомиться в [документе](http://www.noo.com.by/assets/files/PDF/MTRF-64.pdf) на сайте производителя.
Далее выводим тестовые сообщения о канале, команде и контрольной сумме посылки. На этом начальная процедура setup() закончена и скетч входит в бесконечный цикл loop().
```
void loop() {
//setBind();
//setUnbind();
//setOn();
//setOff();
setSwitch();
delay(1000);
}
```
Здесь находятся пять строк, которые инициируют посылку той или иной команды модулю MTRF-64. Вы должны выбрать какую-либо одну команду и запустить скетч (остальные команды должны быть закомментированы). Начинать нужно с команды привязки силового блока к модулю setBind().
Процедура привязки:
* Нажимаете кнопку на силовом блоке — на нём начинает мигать светодиод
* Запускаете скетч с раскомментированной строкой setBind()
* Подтверждаете привязку, нажав ещё раз кнопку на силовом блоке
Всё, теперь комментируете строку setBind() и раскомментируете, например, строку setSwitch(), запускаете скетч и тестовая лампа, подключённая к силовому блоку, начинает мигать раз в секунду. Это только тестовый пример и на основе этого скетча вы можете создать любую, сколь угодно сложную систему управления приборами nooLite.
Ещё немного о работе скетча. В коде формируется содержимое массива TO\_MTRF в соответствии с документацией на MTRF-64, ссылку на которую я дал чуть выше. Далее содержимое этого массива посылается по последовательному интерфейсу непосредственно модулю.
После этого ожидается ответ модуля и пришедшими данными заполняется массив FROM\_MTRF, далее этот массив анализируется и принимаются заранее запрограммированные решения.
Вот назначение прочих функций тестового скетча:
**setChannel(byte ch)** — устанавливает требуемый номер канала (0 – 63).
**setCommand(byte cmd)** — устанавливает нужную команду.
**setChecksum()** — вычисляет контрольную сумму посылки.
**mtrfSend()** — отсылка данных.
**mtrfReceive()** — приём и парсинг ответов модуля.
Таким образом вы можете привязывать и отвязывать устройства на любом канале, включать, выключать и переключать свет при помощи Ардуино и MTRF-64. Ещё раз напомню, что это только демонстрация работы и пример для дальнейшей разработки.
**Полный код тестового скетча управления MTRF-64 при помощи Arduino**
```
/*
* NooLite-F
* MTRF-64 test Sketch
*/
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
byte BOOT_OUT[17] = {171, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,175,172};
byte TO_MTRF[17] = {171, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,172};
byte FROM_MTRF[17];
// Передача адаптеру посылки для выхода из режима обновления ПО
void bootOut() {
for (byte i = 0; i <= 16; i++) {
Serial3.write(BOOT_OUT[i]);
}
}
void setChannel(byte ch) {
TO_MTRF[4] = ch;
}
void setCommand(byte cmd) {
TO_MTRF[5] = cmd;
}
void setChecksum() {
TO_MTRF[15] = 0; // младший байт
for (byte i = 0; i <= 14; i++) {
TO_MTRF[15] += TO_MTRF[i];
}
}
void mtrfSend() {
for (byte i = 0; i <= 16; i++) {
Serial3.write(TO_MTRF[i]);
}
delay(50);
mtrfReceive();
}
void setOff() {
setCommand(0);
setChecksum();
mtrfSend();
}
void setOn() {
setCommand(2);
setChecksum();
mtrfSend();
}
void setSwitch() {
setCommand(4);
setChecksum();
mtrfSend();
}
void setBind() {
setCommand(15);
setChecksum();
mtrfSend();
}
void setUnbind() {
setCommand(9);
setChecksum();
mtrfSend();
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println(F("NooLite-F test"));
Serial3.begin(9600);
delay(1);
bootOut();
// Commands:
// 0 - Off
// 2 - On
// 4 - Switch
// 9 - Unbind
//15 - Bind
setCommand(0);
setChannel(0);
setChecksum();
Serial.print(F("CH: ")); Serial.println(TO_MTRF[4]);
Serial.print(F("CMD: ")); Serial.println(TO_MTRF[5]);
Serial.print(F("CHECKSUM: ")); Serial.println(TO_MTRF[15]);
mtrfSend();
delay(100);
}
void loop() {
//setBind();
//setUnbind();
//setOn();
//setOff();
setSwitch();
delay(1000);
}
void printFromMTRF() {
Serial.println();
for(byte i = 0; i < 17; i++) {
Serial.print(FROM_MTRF[i]); Serial.print(" ");
}
Serial.println();
}
void mtrfReceive() {
if (Serial3.available() > 0) {
Serial3.readBytes(FROM_MTRF, 17);
if (FROM_MTRF[0] == 173 && FROM_MTRF[1] == 2 && FROM_MTRF[16] == 174) {
//printFromMTRF();
Serial.print(F("Receive: "));
if (FROM_MTRF[10] != 0 && FROM_MTRF[2] == 0) {Serial.println(F("On!"));}
if (FROM_MTRF[10] == 0 && FROM_MTRF[2] == 0) {Serial.println(F("Off!"));}
if (FROM_MTRF[2] == 1) {Serial.println(F("Error!"));}
} else {
Serial.println(F("Receive error or bind"));
printFromMTRF();
}
}
}
```
Заключение
----------
В этот краткий обзор не вошёл рассказ о многих функциях новой системы, например о прошивке по воздуху, дистанционной привязке и многих других возможностях — всё невозможно объять в рамках одной обзорной статьи, но я уверен, что скоро появятся другие статьи про nooLite-F от множества любителей и энтузиастов автоматизации.
Теперь моё мнение о новой системе nooLite-F. Однозначно, это большой шаг вперёд для компании Ноотехника. Разница между старой системой и новой большая — шифрование делает её безопасной, а обратная связь позволяет быть уверенным в выполнении отданных команд. А всё вместе это выводит nooLite на новый уровень и позволяет строить на этой системе серьёзные проекты автоматизации. | https://habr.com/ru/post/370383/ | null | ru | null |
# Импортозамещение на практике. Часть 6. Пользовательские рабочие места
Эта статья довольно долго не могла увидеть свет, по ряду причин, от проблем со здоровьем после COVID (я отупел), до отсутствия времени. Время шло, импортозамещение набирало обороты, пилоты становились продакш-средами, и все ~~катилось под откос~~ шло к светлому будущему.
Какое-то время назад мы с командой тоже приступили к пилотированию миграции на «отечественное» ПО. И вот, что из этого вышло.
Началось все с разговоров. А куда без них?
С чего начинается миграция? С выбора ПО? Нет, с планирования и анализа.
*- Чего мы хотим достичь?*
*- Заместить импортные программные продукты отечественными аналогами.*
*- Полностью?*
*- Да.*
*- А если аналогов нет?*
*- Тогда в максимально возможном объеме.*
И тут у нас встала дилемма. Потому что сотрудники Компании в работе помимо прочего используют CAD и PLM софт, который просто не умеет работать на Linux. Вернее, умеет, но через костыли wine’а, что вызывает недовольство пользователей в плане быстродействия. Так же мы используем VDI Horizon, который умеет работать только с AD. А аналогов у Horizon нет. И не говорите про всякие там надстройки для ProxMox и вот это вот все. Ни одна из других существующих VDI-систем не умеет работать с Instant Clones. Максимум, что предлагает OpenSource (и импортозамещение, которое построено на OpenSource) - это Linked Clones. А у нас на IC построены как Windows пулы, так и Linux. И администрировать VDI-рабочие столы как полноценные машины — это смерти подобно, и стоимость владения вырастает за счет необходимости держать огромный штат техподдержки. Поэтому мы не сможем полностью уйти от Windows, как бы нам этого ни хотелось. И из этого вытекает следующее:
* **Мы не сможем уйти от домена на базе Windows**.
* Для обеспечения работоспособности инфраструктуры нужны также сервисы DNS, DHCP, WSUS, CA and etc, которые нет смысла (или невозможно) переносить на Linux.
А раз мы не сможем полностью импортозаместиться, то и проект не имеет особого смысла. На этом можно было бы и закончить, но мы решили, что раз уж инфраструктуру импортозаместить не выйдет — займемся хотя бы пользовательской средой. А со стороны инфры сделаем все, что сможем. Zabbix перевезем на отечественную ОСь.. еще чего-нибудь.. Потому что проблема, например, почтового сервера заключается в том, что Exchange у нас есть, и он работает.. А чтобы его заменить на условный Communigate Pro нам нужно потратить кучу денег. А кто же любит тратить деньги, если и так все работает?.. И так с большинством развернутых в проде систем.
На том и порешали.
0. Ansible
----------
Как поднять Ansible я писать не буду, информации об этом в интернетах более, чем достаточно, не вижу смысла загромождать статью лишней информацией. Главное, что там нужно сделать — это сформировать ssh-ключ, с которым Ansible будет ходить к клиентам, и продумать доставку этого ключа на клиентов.
И еще один нюанс – динамическое inventory. Клиентские ПК – дело непостоянное: кто-то уволился, кто-то пришел, какие-то ПК выключены, какие-то больше не существуют. И как это поддерживать в актуальном состоянии – целая задача. Особенно, когда речь идет не о десятках, и даже не о сотнях, а о тысячах машин. Мы пошли по более-менее простому пути – использование плагина [nmap](https://docs.ansible.com/ansible/latest/collections/community/general/nmap_inventory.html) в связке с плагином [constructed](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/constructed_inventory.html) для Ansible. При запуске он опрашивает указанные подсети и формирует список хостов для применения плейбуков или ролей, а потом делает свои грязные делишки на отобранные по правилам хосты.
### 0.1. Муки выбора дистрибутива
Из представленных на рынке «отечественных» ОС по факту выбор-то и не велик, благо, 99% наших рабочих мест не нужно закрывать сертифицированными ОСями. DEB или RPM, Gentoo-подобные поделки для централизованного администрирования даже не рассматривались, спасибо. Астра\Альт\РедОС\ROSA. Проблема в том, что все они платные. Но. У Альта есть форк - [Simply Linux](https://www.basealt.ru/simplylinux), который [бесплатен для коммерческого использования](https://www.basealt.ru/about/news/archive/view/rossiiskaja-os-simply-linux-besplatno-vsem-postradavshim-ot-sankcii). Думаю, дальше не стоит объяснять, почему мы выбрали Simply Linux.
Ниже есть глава про преобразование ISO-образа.
1. Локальный репозиторий
------------------------
В нашем случае все даже проще, чем обычно. БазАльт сделал веб-интерфейс, который в пару кликов позволяет настроить репликацию их репозитория (выбранных веток).
Выглядит вот так:
Чтобы попасть на эту страничку, нужно доустановить пакеты [ahttpd](https://www.altlinux.org/Alterator-ahttpd-server), alterator-fbi и [alterator-mirror](https://www.altlinux.org/Alterator-mirror), и запустить-активировать ahttpd:
```
systemctl start ahttpd
systemctl enable ahttpd
```
В целом в этой админке довольно много функций помимо зеркалирования репозитория, доступ к которым открывается с доустановкой нужных пакетов альтератора.
Дальше мы столкнулись с тем, что нельзя выбрать, куда будут зеркалироваться пакеты. В Вике Альта пишут про то, что надо лезть в `fstab`, и там монтировать желаемое расположение к `/srv/public/mirror`\*. Но нам это показалось странным. В итоге нашли файлик `/usr/lib/alterator/backend3/mirror`, в котором указаны пути для alterato-mirror. Поменяли `dest_dir=/repos/alt_main-repo` и все поехало.
\*(Статью в Вике Альта правил я по результатам наших изысканий)
Дальше мы подумали о том, что нам нужен будет кастомный репозиторий, в который мы будем сваливать пакеты того же Каспера и 1С.. да и прочие, которых нет в репозах Альта (Simply). Список доп.софта у нас получился примерно такой:
* 1С толстый и тонкий клиент
* Google Chrome
* Касперский агент и клиент
* OnlyOffice (ну не Libre же офисным работникам отдавать..)
* VNC-Viewer
* VMWare Horizon Client (про него отдельная история, как Windows-админ (я) пытался RPM собрать)
Чтобы создать кастомный репозиторий, нужно прочитать [это](https://www.altlinux.org/APT_%D0%B2_ALT_Linux/CreateRepository) и [это](https://www.altlinux.org/APT_%D0%B2_ALT_Linux/OwnRepo), создать нужную структуру каталогов, наполнить нужное место RPM-пакетами, создать gpg-ключ, создать и подписать индексы, подключить репозиторий клиентам, и можно радоваться.
В целом – ничего сложного, если не накосячить с деревом каталогов, как я по началу.
После заполнения каталога с RPM-пакетами, в моем случае это `/repos/alt_custom-repo/x86_64/RPMS.alt_custom_repo/`, нужно создать и подписать индексы:
```
genbasedir --create --progress --sign --default-key=[gpg-key без скобок] --topdir=/repos/alt_custom-repo x86_64 alt_custom_repo
```
\*`genbasedir` является командой из пакета `apt-utils`.
Основные сложности у меня вызвали 2 пакета – OnlyOffice и VMWare Horizon Client. Первый не может удовлетворить зависимости, второй просто не существует.
### 1.3. Пакеты
Тут я вынужден сделать лирическое отступление - я и моя команда - чистый SRE, парни, которые про эти ваши CI\CD и DevOps практики знают только из интернетов и разговоров с коллегами. Это я к тому, что пересобрать RPM-пакет для сисадмина - это тёмный лес. Но мы не отступаем перед сложностями. Самое сложное было разобраться в скриплетах и найти инфу о том, в какой последовательности они применяются при обновлении пакета. И тут мне помогла [вот эта дока](https://docs.fedoraproject.org/en-US/packaging-guidelines/).
#### 1.3.1. OnlyOffice
Тут все просто – пересобрать RPM без отсутствующих зависимостей. Но стоит сразу уточнить, что Альт (Simply) по дефолту не даст руту собрать RPM-пакет, для этого предлагается использовать непривилегированного пользователя. Делаем:
```
cd /tmp
wget https://download.onlyoffice.com/install/desktop/editors/linux/onlyoffice-desktopeditors.x86_64.rpm?_ga=2.238710784.1633530263.1666265796-724860256.1666265796
sudo apt-get install wget
wget https://download.onlyoffice.com/install/desktop/editors/linux/onlyoffice-desktopeditors.x86_64.rpm?_ga=2.238710784.1633530263.1666265796-724860256.1666265796
rpmrebuild -enp onlyoffice-desktopeditors.x86_64.rpm\?_ga\=2.238710784.1633530263.1666265796-724860256.1666265796
sudo apt-get install rpmrebuild
rpmrebuild -enp onlyoffice-desktopeditors.x86_64.rpm\?_ga\=2.238710784.1633530263.1666265796-724860256.1666265796
```
=Ъ
И в открывшейся спеке комментируем пакеты, которых нет в репозиториях Р10. Приводим к виду:
```
Requires: /bin/sh
Requires: /bin/sh
Requires: /bin/sh
Requires: /bin/sh
Requires: /bin/sh
Requires: atk
Requires: boost-filesystem
Requires: curl
Requires: fonts-ttf-dejavu
Requires: gtk3
Requires: libX11
Requires: libXScrnSaver
Requires: fonts-ttf-liberation
Requires: fonts-ttf-liberation-narrow
Requires: libstdc++ >= 4.8.0
Requires: libxcb
#Requires: rpmlib(CompressedFileNames) <= 3.0.4-1
#Requires: rpmlib(FileDigests) <= 4.6.0-1
#Requires: rpmlib(PayloadFilesHavePrefix) <= 4.0-1
#Requires: rpmlib(PayloadIsXz) <= 5.2-1
Requires: libxcbutil-image
Requires: libxcbutil-keysyms
Requires: libxcb-render-util
Requires: xdg-utils
```
И сохраняем. На выходе получается RPM-пакет без неудовлетворенных зависимостей. Да, так делать неправильно. Но, на Вике Альта так и написано – [игнорируй зависимости](https://www.altlinux.org/OnlyOffice), и "спина болеть не будет".
Можно сделать то же самое, но в одну команду. Так менее наглядно, но более автоматизированно:
```
rpmrebuild -np --change-spec-requires='sed -e "s/dejavu-sans-fonts/fonts-ttf-dejavu/" \
-e "/dejavu-sans-mono-fonts/d" -e "/dejavu-serif-fonts/d" \
-e "s/xcb-util-image/libxcbutil-image/" -e "s/xcb-util-keysyms/libxcbutil-keysyms/" \
-e "s/xcb-util-renderutil/libxcb-render-util/" -e "/xcb-util-wm/d" \
-e "s/liberation-mono-fonts/fonts-ttf-liberation/" -e "/liberation-sans-fonts/d" \
-e "/liberation-serif-fonts/d" -e "s/liberation-narrow-fonts/fonts-ttf-liberation-narrow/"' \
onlyoffice-desktopeditors.x86_64.rpm
```
Более правильным решением, конечно же, было бы собрать пакет из исходников. Но мы же SRE.. И поэтому это мы записали в планы. На потом.
#### 1.3.2. VMWare Horizon Client
Собрать из исходников проприетарное ПО не получится, даже если вы - не я. Horizon можно скачать в виде tarball-архива с бинарниками, и писать спеку под них. Но я пошел по более простому пути. Я скачал bundle, написал spec-файл для его установки, и запаковал это все в RPM-пакет.
А потом я решил автоматизировать это дело. И написал скриптик, который, получая на вход ссылку на скачивание bundle'а Horizon Client'а, создает структуру каталогов для сборки, меняет в спеке "хххххх" на "версию", и запускает сборку.
Spec-файл [Horizon Agent](https://customerconnect.vmware.com/en/downloads/info/slug/desktop_end_user_computing/vmware_horizon_clients/horizon_8) for Linux выглядит так:
```
Name: vmware-horizon-client
Version: xxxxxx
Release: 1
Summary: custom rpm package vmware-horizon-client
License: GPL
Source0: %{name}-%{version}.tar.gz
Requires: bash
Requires: python3-modules-sqlite3
Requires: python3-modules-curses
Requires: python3-module-pexpect
Requires: python-modules-json
Requires: python-module-pygtk
Requires: python-module-jinja2
Requires: python-module-yaml
Requires: python-module-distutils-extra
%description
VMware Horizon Client for LAB.RU team custom repo
%prep
%setup -q
%install
install -d -m 0755 $RPM_BUILD_ROOT/opt/vdi/
install -m 0755 %{name}-%{version} $RPM_BUILD_ROOT/opt/vdi/%{name}-%{version}
%pretrans
if !([ -z "$(pgrep vmware-view)" ]); then
pkill -f vmware-view
fi
%preun
if !([ -z "$(pgrep vmware-view)" ]); then
pkill -f vmware-view
fi
file=(`ls /opt/vdi/`)
if !([ -z $file ]); then
env VMWARE_KEEP_CONFIG=no /opt/vdi/$file -u vmware-horizon-client --console
rm -f /opt/vdi/$file
fi
if test -f "/etc/skel/Рабочий стол/vmware-view.desktop"; then
rm -f "/etc/skel/Рабочий стол/vmware-view.desktop"
fi
%posttrans
env TERM=dumb VMWARE_EULAS_AGREED=yes /opt/vdi/%{name}-%{version} --console --set-setting vmware-horizon-integrated-printing vmipEnable yes --set-setting vmware-horizon-html5mmr html5mmrEnable yes --set-setting vmware-horizon-usb usbEnable yes --set-setting vmware-horizon-smartcard smartcardEnable yes --set-setting vmware-horizon-rtav rtavEnable yes --set-setting vmware-horizon-tsdr tsdrEnable yes --set-setting vmware-horizon-scannerclient scannerEnable yes --set-setting vmware-horizon-serialportclient serialportEnable yes --set-setting vmware-horizon-mmr mmrEnable yes --set-setting vmware-horizon-media-provider mediaproviderEnable yes --set-setting vmware-horizon-teams-optimization teamsOptimizationEnable no
echo "view.defaultBroker = 'uag.lab.ru'" > /etc/vmware/view-mandatory-config
echo "view.defaultDomain = 'lab'" >> /etc/vmware/view-mandatory-config
echo "view.defaultProtocol = 'BLAST'" >> /etc/vmware/view-mandatory-config
echo "view.autoHideToolbar = 'TRUE'" >> /etc/vmware/view-mandatory-config
echo "view.autoConnectBroker = 'uag.lab.ru'" >> /etc/vmware/view-mandatory-config
echo "view.enableMMR = 'TRUE'" >> /etc/vmware/view-mandatory-config
chmod +x /usr/share/applications/vmware-view.desktop
if !([[ -f "/etc/skel/Рабочий\ стол/vmware-view.desktop" ]]); then
ln -sf /usr/share/applications/vmware-view.desktop /etc/skel/Рабочий\ стол/vmware-view.desktop
chmod 755 /etc/skel/Рабочий\ стол/vmware-view.desktop
fi
if [[ -d /home/LAB.RU/ ]]; then
for dir in $(ls /home/LAB.RU/ | grep -v _); do
if !([[ -f "/home/LAB.RU/$dir/Рабочий\ стол/vmware-view.desktop" ]]); then
ln -sf /usr/share/applications/vmware-view.desktop /home/LAB.RU/$dir/Рабочий\ стол/vmware-view.desktop
chmod 755 /home/LAB.RU/$dir/Рабочий\ стол/vmware-view.desktop
fi
done
fi
%files
/opt/vdi/%{name}-%{version}
%changelog
* August 2022 ANSysoev
-
```
Скрипт для выглядит так:
```
#!/bin/bash
if [ -z "$@" ]; then
echo "run script with link to download Horizon Client as argument at run"
else
cd /home/user/rpmbuild/
rm -rf /home/user/rpmbuild/*
mkdir BUILD BUILDROOT SOURCES SPECS SRPMS
cd /home/user/rpmbuild/SOURCES
wget "$@"
version=$(ls | sed -e "s/VMware-Horizon-Client-//" -e "s/.bundle//" -e "s/-/./g")
name="vmware-horizon-client"
fullname=$(echo $name-$version)
mkdir $fullname
mv $(find /home/user/rpmbuild/SOURCES/ -maxdepth 1 -type f) /home/user/rpmbuild/SOURCES/$fullname/$fullname
tar -czvf $fullname.tar.gz $fullname
cp /home/user/vmware-horizon-client.spec /home/user/rpmbuild/SPECS/vmware-horizon-client.spec
sed -i "s/xxxxxx/$version/" /home/user/rpmbuild/SPECS/vmware-horizon-client.spec
cd /home/user/rpmbuild/
rpmbuild -bb SPECS/vmware-horizon-client.spec
fi
```
Для запуска надо сделать вот такую магию:
```
horizon-client-RPM-1.sh https://download3.vmware.com/software/CART23FQ3_LIN64_2209/VMware-Horizon-Client-2209-8.7.0-20616018.x64.bundle
```
И На выходе получится собранный пакетик:
```
tree
rpmbuild
├── BUILD
│ └── vmware-horizon-client-2209.8.7.0.20616018.x64
│ └── vmware-horizon-client-2209.8.7.0.20616018.x64
├── BUILDROOT
├── RPMS
│ └── x86_64
│ └── vmware-horizon-client-2209.8.7.0.20616018.x64-1.x86_64.rpm
├── SOURCES
│ ├── vmware-horizon-client-2209.8.7.0.20616018.x64
│ │ └── vmware-horizon-client-2209.8.7.0.20616018.x64
│ └── vmware-horizon-client-2209.8.7.0.20616018.x64.tar.gz
├── SPECS
│ └── vmware-horizon-client.spec
└── SRPMS
```
#### 1.3.3. Google Chrome and etc.
Тут вообще проблем нет, просто скачивается RPM-пакет с официального сайта, копируется в каталог, и все. Все пакеты с удовлетворенными зависимостями ставятся так. И это хорошо.
2. Преобразование ISO-образа
----------------------------
Мы выбрали Simply, потому что он бесплатный.
Но. Отдавать офисным работникам Linux с xfce на борту — это парализовать работу офиса на неопределенный срок. Если более-менее привычные к ПК ребята освоятся достаточно быстро, но тоже не сразу, то тётушки-бухгалтеры — скорее никогда, чем быстро. Поэтому что? Правильно, надо поставить KDE! Это тоже не решит все проблемы, но порог вхождения существенно снизится.
Но. Если выпилить xfce и поставить сверху KDE — получится не кошерно. Останутся лишние пакеты от DM и DE, поэтому надо лезть в ISO и понять, как же происходит установка Linux, чтобы вмешаться в этот процесс и вместо одной DE поставить другую.
На самом деле ничего сложного в этом нет (если разобраться), но все по порядку.
Прочитав Вику Альта [Модификация установочного ISO образа](https://www.altlinux.org/%D0%9C%D0%BE%D0%B4%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F_%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BE%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_ISO_%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%B0), [Создание образов устройств](https://www.altlinux.org/%D0%A1%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2_%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2), [Autoinstall](https://www.altlinux.org/Autoinstall#%D0%94%D0%B5%D0%BB%D0%B0%D0%B5%D0%BC_%C2%AB%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%C2%BB_%D0%B4%D0%B8%D1%81%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B8%D0%B2), и ничего в ней не поняв, я решил отвязаться от дистрибутива, и полез в теорию. Хотя последняя ссылка мне помогла во многом.
Что есть дистрибутив Linux? Дистрибутив – это, сильно упрощая, ядро Linux + набор пакетов. Всё. Набор пакетов ПО – суть «встроенный в ISO репозиторий». У Simply пакеты лежат в `\ISOroot\ALTLinux\RPMS.main\`. Чтобы собрать дистрибутив, нужно набрать выбранные пакеты, удовлетворить их зависимости, и положить в ISO, описать «группы ПО», пересчитать и подписать индексы. . В директории `Metadata\pkg-groups.tar\lists\` лежит файл `.base`, содержащий в себе список пакетов, которые накатываются в любом случае, а так же директория `slinux`, содержащая в себе описание этих самых групп ПО (имя и состав пакетов каждой группы).
Для того, чтобы избавиться от xfce и добавить вместо него KDE есть 2 пути: сложный и очень сложный.
Очень сложный предполагает скачивание из репозитория нужных пакетов (KDE и его зависимости). Но мне было лень. Наверное, есть какой-то специальный софт, который умеет считывать зависимости из метадаты указанного пакета, и выкачивать эти зависимости.. Но я такого не нашел, поэтому пошел по сложному пути, а именно — скачал Альт Workstation 10 K (у которого та же пакетная база, что и у Simply, только с KDE искаропке), и подменил пакеты в ISO-репозитории и файл `.base`, собрал, установил… … … … ..ииииии.. получил свежеустановленный Альт 10 K. Удивился. Много думал. В основном о том, что моих теоретических познаний явно недостаточно для реализации поставленной мной же задачи. (Как же сложно и неприятно быть тупым! Проклятый COVID!)
После ~~пролитых слез, покрасневших глаз, вырванных волос и обгрызенных ногтей~~ поиска причин, я понял, что в списке пакетов есть RPM’ки со словом branding в имени, и понял, что именно их установка в целевую систему отвечает за то, какой дистрибутив получится на выходе. Например, один из пакетов правит файлик`/etc/system-release`, другой накидывает нескучные обои и т.д.
Словом, после нехитрых, но скучных и утомительных правок файлика `.base` и закидывания в репозиторий недостающих пакетов (у меня на это ушло примерно 10 попыток установки системы), я получил на выходе Simply Linux 10 K. Потом я решил, что этого недостаточно, и отсобрал еще один ISO уже без DE.. Simply Linux Server. А то на чем мне Ansible и локальный репозиторий разворачивать?
Список команд чуть ниже.
Далее — доставка на свежеустановленную систему ключей Ansible и установка hostname. Если в ОСи будут установлены ключи от Ansible, то дальше можно все сделать через сам Ansible. Тут нам поможет пакет alterator-postinstall и простейший скрипт, который доставит в `/root/.ssh/authorized_keys` нужные ключи. У меня 2 Ansible, 1 в головном офисе, и 1 в филиале, канал с которым, мягко говоря, оставляет желать лучшего. Поэтому 2 ключа. Так же нужно позаботиться об инженерах техподдержки, и закинуть в свежую систему скрипт, который на основе существующих в AD записей для компьютеров, будет подбирать подходящий hostname для нового ПК перед вводом в домен. Эти скрипты тоже нужно будет доставить в целевую систему. Скрипт назовем 87-set-ansbls-keys.sh, и напишем в нем следующее (ну почти так, ключи я вам не покажу =Ъ):
```
#!/bin/sh
. install2-init-functions
echo "ssh-rsa бла-бла-бла-набор-символов root@ansible-filial-hostname" > $destdir/root/.ssh/authorized_keys
echo "ssh-rsa бла-бла-бла-набор-символов root@ansible-hostname" >> $destdir/root/.ssh/authorized_keys
cp /var/ChangeHostName.py $destdir/var/
```
Тут одна тонкость — таргет указывается с преффиксом `$destdir`, иначе установщик, выполняя директиву postinstall, запишет ключи в свой /root, а не в устанавливаемую ОС.
Скрипт поиска подходящего hostname прост, как 5 копеек (которых никто не видел уже черт знает сколько лет). Я создал в AD бесправную учетку, чтобы Python мог сходить в AD и считать уже существующие в определенной OU учетки компьютеров, и выбрать следующий по списку.
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import os
import sys
from getpass import getpass
from ldap3 import Server, Connection, SUBTREE, LEVEL
import time
username="lab.ru\linux_to_domain"
password="Passw0rd!"
server = Server("dc-1.lab.ru", port=389, use_ssl=False, get_info='ALL')
connection = Connection(server, user=username, password=password,
fast_decoder=True, auto_bind=True, auto_referrals=True, check_names=False, read_only=True,
lazy=False, raise_exceptions=False)
hostnamedigit=1
hostname = "ARM-"+'{:0>4}'.format(hostnamedigit)
def get_all_ad_hosts(connection):
results = list()
elements = connection.extend.standard.paged_search(
search_base='OU=LINUX,OU=Computers,dc=lab,dc=ru',
search_filter='(&(objectCategory=computer)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))',
search_scope=SUBTREE,
attributes=['name'],
paged_size=100)
for element in elements:
host = dict()
if 'dn' in element:
host['dn'] = element['dn']
host['name'] = element['attributes'][u'name'][0]
results.append(host)
return(results)
connection.unbind()
def search_for_duplicatename(hostname,list_of_computers):
for computer in list_of_computers:
if computer['name'].casefold() == hostname.casefold():
print(hostname+" already exists")
return 1
return 0
computers = get_all_ad_hosts(connection)
while search_for_duplicatename(hostname, computers) != 0:
hostnamedigit += 1
hostname = "ARM-"+'{:0>4}'.format(hostnamedigit)
print(hostname)
os.system("hostnamectl set-hostname "+hostname)
print("Your system is gonna reboot in 10 seconds....")
time.sleep(10)
os.system("reboot now")
```
Теперь о том, куда же эти скрипты поместить. Целевая директория — архив altinst, находящийся в корне ISO. В архиве скрипт нужно расположить в директории `/usr/share/install2/postinstall.d/` и не забыть сделать его исполняемым, иначе чуда не произойдет. Скрипт подбора hostname я положил в /var, хотя это не играет особой роли.
Но. Прежде, чем все это сделать, нужно смонтировать [скачанный ISO](https://www.basealt.ru/simplylinux/download), скопировать куда-то его содержимое, распаковать архив с помощью squashfs-tools (пакет нужно поставить), скопировать скрипты, поменять файлик `.base`.. Словом, сделать все свои грязные делишки, и потом запаковать архив и собрать ISO. Итого (перед выполнением `genbasedir` нужно скопировать необходимые пакеты, удалить лишние, и привести в порядок файлы, отвечающие за установку групп ПО, как было описано выше):
```
apt-get install apt-utils squashfs-tools
mkdir /home/user/slinux_iso /home/user/altinst
cd /home/user/altinst
sudo mount /home/user/slinux.iso /mnt
cp -r /mnt/* /home/user/slinux_iso/
unsquashfs /home/user/slinux_iso/altinst
cp /path_to_script_ansible_keys.sh /home/user/altinst/squashfs-root/usr/share/install2/postinstall.d/87-set-ansbls-keys.sh
chmod +x /home/user/altinst/squashfs-root/usr/share/install2/postinstall.d/87-set-ansbls-keys.sh
cp /path_to_script_hostname /home/user/altinst/squashfs-root/var/ChangeHostName.py
chmod +x /home/user/altinst/squashfs-root/var/ChangeHostName.py
rm /home/user/slinux_iso/altinst
mksquashfs /home/user/altinst/squashfs-root/ /home/user/slinux_iso/altinst
genbasedir --create --topdir=/home/user/slinux_iso/ ALTLinux main
cd /home/user/slinux_iso
sudo xorriso \
-as mkisofs "/home/user/slinux_iso"\
-joliet \
-partition_cyl_align "off" \
-partition_offset 16 \
-iso-level 3 \
-full-iso9660-filenames \
-sysid "LINUX" \
-volid "Simply Linux 10.1 x86_64" \
-volset "ALT" \
-publisher "BASEALT LTD" \
-appid "SIMPLY LINUX 10.1 X86_64 2022-06-28" \
-copyright "LICENSE_ALL_HTML" \
-eltorito-boot syslinux/isolinux.cfg \
-eltorito-catalog syslinux/boot.cat \
-no-emul-boot \
-boot-load-size 4 \
-boot-info-table \
-isohybrid-mbr syslinux/isohdpfx.bin \
-eltorito-alt-boot \
-e EFI/.efiboot.img \
-no-emul-boot \
-isohybrid-gpt-basdat \
-output ../SimplyLinux10_KDE.iso
```
И ждем.
В целом, можно было заскриптовать и еще какие-то штуки, которые делаются при первом запуске системы, как то – установка доменных сертификатов, прописывание локального репозитория и т.д. Но мы предпочли делать это через Ansible. Так это проще контролировать, и проще что-то изменить, если это потребуется.
3. Ansible playbooks
--------------------
Дальше мы приступили к написанию плейбуков для доставки на клиенты нужных настроек:
* ssh
* sssd
* samba
* kerberos
* pam
* cups
* ввод в домен
* … etc.
Я довольно долго думал о том, нужно ли приводить листинг плейбуков. И, посоветовавшись с командой, мы решили, что не все стоит выкладывать. По ряду причин.
Спойлер*Да, мы знаем, что в нижеследующем можно сделать все иначе. Использовать роли, переменные и т.д. Хранить все в гите, отслеживать там изменения и прочее, прочее, прочее. Мы знаем, спасибо. Но читать это в рамках статьи будет невозможно. Поэтому плейбуки. Поэтому разбито так, как разбито.*
Итак, требования следующие:
1. Доставить внутренние сертификаты, импортировать их
2. Добавить локальные репозитории
3. Установить в систему весь требуемый софт, закинуть конфиги для установленного софта, настроить skel, чтобы при первом входе в систему, пользователь получил нужные линки и каталоги, предусмотреть подключение для пользователей сетевых шар, живущих на Windows-сервере, предусмотреть подключение пользователям списка баз 1С, как это описано [здесь](https://habr.com/ru/post/250287/) (ну это просто удобно)
4. Сформировать конфиги для подключения ПК к домену, предусмотреть запуск логон-скриптов, обойти проблему авторизации на proxy-сервере (в нашем случае это скрипт, который стучится в proxy-сервер с Kerberos-тикетом, посредством curl’а, и получает на проксе тикет на 8 часов). Да, WSA – она такая..
5. Настроить ssh согласно требованиям от ИБ, в том числе ограничить доступ для определенных групп AD
6. Настроить доступ к sudo для определенной группы AD
7. Соблюсти прочие требования ИБ (мне запретили это показывать. ИБ – те еще параноики)
8. Ввести ПК в домен
9. Предусмотреть механизм «брендирования» - обои рабочего стола, загрузчика и прочее (это мне тоже запретили вам показывать)
10. Предусмотреть возможность массового обновления
В плейбуках все понятно по названиям тасков. Поэтому в проде мы вообще не делали комментариев. Для статьи я добавил немного комментов там, где посчитал необходимым.
«Кто в теме и так поймет, кто не в теме – тот все равно листинг читать не будет».
Оговорюсь лишь о том, что для доставки файлов, открытых ключей и прочего, мы опубликовали их рядом с репозиториями. Там все равно web-сервер поднят, почему бы его не использовать?
#### 3.1. Доставить внутренние сертификаты, импортировать их
```
- name: Install local CA certs
gather_facts: false
hosts: simply
tasks:
- name: Execute script
shell: |
mkdir /tmp/certs
cd /tmp/certs
wget --no-check-certificate https://local-repo-srv.lab.ru/alt_custom-repo/certs/root.crt
wget --no-check-certificate https://local-repo-srv.lab.ru/alt_custom-repo/certs/subca.crt
cp ./rootca.crt /etc/pki/ca-trust/source/anchors/
cp ./subca.crt /etc/pki/ca-trust/source/anchors/
chmod a-x /etc/pki/ca-trust/source/anchors/*
update-ca-trust extract
```
#### 3.2. Добавить локальные репозитории
```
- name: add repositories
gather_facts: false
hosts: simply
tasks:
- name: delete all /etc/apt/sources.list.d/
shell: rm -f /etc/apt/sources.list.d/*
- name: create lab.list
copy:
dest: /etc/apt/sources.list.d/lab.list
content: |
rpm [p10] http:// local-repo-srv.lab.ru /alt_main-repo p10/branch/x86_64 classic
rpm [p10] http:// local-repo-srv.lab.ru /alt_main-repo p10/branch/noarch classic
rpm [alt_custom_repo] http:// local-repo-srv.lab.ru /alt_custom-repo x86_64 alt_custom_repo
- name: add custom gpg key
shell: curl http:// local-repo-srv.lab.ru /alt_custom-repo/x86_64/base/custom_repo.pgp >> /etc/apt/custom_repo.pgp && gpg --no-default-keyring --keyring /usr/lib/alt-gpgkeys/pubring.gpg --import /etc/apt/custom_repo.pgp
- name: add /etc/apt/vendors.list.d/lab.list
copy:
dest: /etc/apt/vendors.list.d/lab.list
content: |
simple-key "alt_custom_repo" {
Fingerprint "бла-бла-бла-буквы-и-цЫфры";
Name "Vasily ";
}
- name: apt-get update
shell: |
apt-get update
apt-get dist-upgrade -y
```
#### 3.3. Установить в систему весь требуемый софт, …
```
- name: soft installation
gather_facts: false
hosts: simply
tasks:
- name: update
shell: apt-get update -y
- name: install packages
apt_rpm:
name:
- sudo
- apt-scripts
- openssh
- task-auth-ad-sssd
- sssd-ad
- samba-client
- 1c-preinstall-full
- vmware-view-preinstall
- onlyoffice-desktopeditors
- nano
- firefox
- libinput
- libinput-devel
- xorg-drv-libinput
- xorg-drv-libinput-devel
- x11vnc
- x11vnc-service
- 1c-enterprise-8.3.18.1483-thin-client
- vlc
- google-chrome-stable
- autofs
- vmware-horizon-client
- system-config-printer
- kde5-spectacle
- evolution
- evolution-ews
- conky
- remmina
- remmina-plugins
- cups
state: present
- name: remove Libre, stop cups
shell: |
apt-get remove libreoffice5 -y && apt-get clean -y && apt-get autoremove -y
systemctl stop cups
#для VNC есть еще таска для установки пароля, но я вам ее не покажу.
#Там тривиально
- name: x11vnc config
copy:
dest: /usr/sbin/x11vnc-start-daemon
content: |
#!/bin/bash
AUTH=`ps aux | grep "\-auth " | head -n 1`
AUTH=${AUTH/*\-auth /}
AUTH=${AUTH/ */}
/usr/bin/x11vnc -auth $AUTH -dontdisconnect -usepw -shared -forever -rfbport 5900 -rfbauth /etc/vncpasswd -display :0 -repeat
- name: catalogs and files
file:
path: "{{ item.path }}"
state: "{{ item.state }}"
with_items:
- { path: /etc/skel/Рабочий стол/, state: directory } #каталог для создания ярлыков
- { path: /mnt/share/, state: directory } #каталог для монтирования «сетевых дисков»
- { path: /var/ChangeHostName.py, state: absent } #удаление скрипта подбора hostname
- { path: /opt/1cv8/x86_64/8.3.18.1483/libstdc++.so.6, state: absent } #для работы 1С этот файл надо удалить. Не спрашивайте, это не баг, это фича.
- { path: /etc/skel/.1C/1cestart/, state: directory } #каталог для монтирования шары со списком баз для 1С
- name: create links
file:
src: "{{ item.src }}"
dest: "{{ item.dest }}"
state: "{{ item.state }}"
mode: "{{ item.mode }}"
force: yes
with_items:
- { src: /mnt/share/, dest: /etc/skel/Рабочий стол/Сетевые_Папки, state: link, mode: '755' }
- { src: /usr/share/applications/firefox.desktop, dest: /etc/skel/Рабочий стол/firefox.desktop, state: link, mode: '755' }
- { src: /usr/share/applications/google-chrome.desktop, dest: /etc/skel/Рабочий стол/google-chrome.desktop, state: link, mode: '755' }
- { src: /usr/share/applications/1cestart-8.3.18-1483.desktop, dest: /etc/skel/Рабочий стол/1C.desktop, state: link, mode: '755' }
- { src: /usr/share/kf5/applications/kf5/org.kde.dolphin.desktop, dest: /etc/skel/Рабочий стол/Dolphin.desktop, state: link, mode: '755' }
- { src: /usr/share/applications/onlyoffice-desktopeditors.desktop, dest: /etc/skel/Рабочий стол/onlyoffice-desktopeditors.desktop, state: link, mode: '755' }
- { src: /usr/share/applications/vmware-view.desktop, dest: /etc/skel/Рабочий стол/vmware-view.desktop, state: link, mode: '755' }
- { src: /mnt/.services/1CBases/1cestart_alt.cfg, dest: /etc/skel/.1C/1cestart/1cestart.cfg, state: link, mode: '755' }
- name: copy files
copy:
src: "{{ item.src }}"
dest: "{{ item.dest }}"
owner: "{{ item.owner }}"
group: "{{ item.group }}"
mode: "{{ item.mode }}"
with_items:
#блок копирования настроек cups. Они для всех одинаковы, подключается очередь
#печати на принтер MyQ
- { src: /etc/ansible/playbooks/files/cups/cupsd.conf, dest: /etc/cups/cupsd.conf, owner: root, group: lp, mode: '640' }
- { src: /etc/ansible/playbooks/files/cups/cups-files.conf, dest: /etc/cups/cups-files.conf, owner: root, group: root, mode: '644' }
- { src: /etc/ansible/playbooks/files/cups/printers.conf, dest: /etc/cups/printers.conf, owner: root, group: lp, mode: '600' }
- name: enable services
service:
name: "{{ item }}"
enabled: yes
state: restarted
with_items:
- x11vnc
- cups
- name: firefox set krb enable
copy:
dest: /usr/lib64/firefox/browser/defaults/preferences/myprefs.js
content: |
pref("network.negotiate-auth.trusted-uris",".lab.ru");
pref("network.automatic-ntlm-auth.trusted-uris",".lab.ru");
pref("network.automatic-ntlm-auth.allow-non-fqdn","true");
pref("network.negotiate-auth.allow-non-fqdn","true");
pref("network.negotiate-auth.delegation-uris",".lab.ru");
- name: chrome set krb enable
copy:
dest: /etc/opt/chrome/policies/managed/krb.json
content: |
{
"AuthServerAllowlist": "*.lab.ru",
"AuthNegotiateDelegateAllowlist": "*.lab.ru"
}
- name: apt dedup, enable cups
shell: |
apt-get dedup -y
systemctl start cups
```
#### 3.4. Сформировать конфиги для подключения ПК к домену, ..
```
- name: pre-domain config
gather_facts: false
hosts: simply
tasks:
- name: krb config
copy:
dest: /etc/krb5.conf
content: |
[logging]
# default = FILE:/var/log/krb5libs.log
[libdefaults]
default_realm = LAB.RU
dns_lookup_realm = true
dns_lookup_kdc = true
ticket_lifetime = 24h
renew_lifetime = 7d
rdns = false
forwardable = yes
default_ccache_name = FILE:/tmp/krb5cc_%{uid}
- name: samba config
copy:
dest: /etc/samba/smb.conf
content: |
[global]
security = ads
realm = LAB.RU
workgroup = LAB
netbios name = {{inventory_hostname}}
template shell = /bin/bash
kerberos method = system keytab
wins support = no
idmap config * : range = 10000-20000000
idmap config * : backend = tdb
- name: sssd config
copy:
dest: /etc/sssd/sssd.conf
content: |
[sssd]
config_file_version = 2
user = root
domains = LAB.RU
services = pam,nss,autofs
[nss]
[pam]
[domain/LAB.RU]
id_provider = ad
auth_provider = ad
chpass_provider = ad
default_shell = /bin/bash
fallback_homedir = /home/%d/%u
ad_server = dc-1.lab.ru,dc-2.lab.ru
ad_backup_server = _srv_
cache_credentials = true
debug_level = 2
#монтирование сетевых дисков. Через pam mount ничего не вышло. Он либо багованый,
#либо фича у него такая, но мы перешли на смб, который монтирует шары при
#обращении к ним пользователя
- name: autofs config
copy:
dest: /etc/auto.master
content: |
/mnt/share /etc/auto.samba --ghost
/mnt/.services /etc/auto2.samba --ghost --timeout 60
- name: autofs config 1
copy:
dest: /etc/auto.samba
content: |
disk_1 -fstype=cifs,multiuser,cruid=$UID,sec=krb5,domain=LAB.RU ://dfs-server.lab.ru/Share
disk_2 -fstype=cifs,multiuser,cruid=$UID,sec=krb5,domain=LAB.RU ://file-server.lab.ru/Share2
disk_3 -fstype=cifs,multiuser,cruid=$UID,sec=krb5,domain=LAB.RU ://file-server.lab.ru/Share3
- name: autofs config 2
copy:
dest: /etc/auto2.samba
content: |
1CBases -fstype=cifs,multiuser,cruid=$UID,sec=krb5,domain=LAB.RU ://file-server.lab.ru /1CBases
background -fstype=cifs,multiuser,cruid=$UID,sec=krb5,domain=LAB.RU ://file-server.lab.ru/background
- name: enable autofs
service:
name: autofs
enabled: yes
state: restarted
- name: configure nsswitch and cronyd
lineinfile:
path: "{{ item.path }}"
regexp: "{{ item.regexp }}"
line: "{{ item.line }}"
loop:
- { path: /etc/nsswitch.conf, regexp: '^passwd', line: 'passwd: files sss' }
- { path: /etc/nsswitch.conf, regexp: '^shadow', line: 'shadow: tcb files sss' }
- { path: /etc/nsswitch.conf, regexp: '^group', line: 'group: files sss' }
- { path: /etc/chrony.conf, regexp: '^pool', line: 'pool dc-1.lab.ru iburst' }
- name: set control policy and system-auth
shell: |
control sudo public
control system-auth sss
#Cisco WSA – довольно «интересный» proxy-сервер..
#И так как далеко не все Linux’овые приложения умеют использовать krb-тикеты
#для авторизации на прокси, приходится использовать костыль. Нет, можно было
#заставить пользователя сначала запустить браузер, авторизоваться на проксе,
#и только после этого получить доступ в интернет, скажем, с мессенджера..
#но мы посчитали это издевательством.
- name: proxy auth script
copy:
dest: /var/proxy_auth.sh
content: |
#!/bin/bash
ip=$(echo `ifconfig eth0 2>/dev/null|awk '/inet addr:/ {print $2}'|sed 's/addr://'`)
echo "curl -isL --negotiate -u : https://proxy-server.lab.ru/same_text/$ip/http://lab.ru/ > /dev/null" > /tmp/proxy_auth.sh
/bin/bash /tmp/proxy_auth.sh
rm -f /tmp/proxy_auth.sh
mode: "755"
- name: create logon script fpr proxy auth
copy:
dest: /etc/profile.d/proxy_auth.sh
content: |
#!/bin/bash
/var/proxy_auth.sh
mode: "755"
```
#### 3.5. Настроить ssh согласно требованиям от ИБ, в том числе ограничить доступ для определенных групп AD
```
- name: ssh
gather_facts: false
hosts: simply
tasks:
- name: edit sshd config
lineinfile:
path: /etc/openssh/sshd_config
regex: "^(#)?{{item.key}}"
line: "{{item.key}} {{item.value}}"
state: present
loop:
- { key: "LogLevel", value: "VERBOSE" }
- { key: "PermitRootLogin", value: "prohibit-password" }
- { key: "MaxAuthTries", value: "3" }
- { key: "MaxSessions", value: "2" }
- { key: "PermitEmptyPasswords", value: "no" }
- { key: "UsePAM", value: "yes" }
- { key: "AllowGroups", value: "domain?users root wheel linux-sudoers" }
#да, да, именно в таком формате тут нужно указывать доменные группы с пробелами
#в названиях
notify:
- restart sshd
- enable sshd
handlers:
- name: restart sshd
service:
name: sshd
state: restarted
- name: enable sshd
service:
name: sshd
enabled: yes
```
#### 3.6. Настроить доступ к sudo для определенной группы AD
```
- name: sudoers
gather_facts: false
hosts: simply
tasks:
- name: edit sudoers file
blockinfile:
path: /etc/sudoers
backup: yes
block: |
%Linux-Sudoers ALL=(ALL) ALL
%Linux-Users ALL=/usr/bin/apt-cache
%Linux-Users ALL=/usr/sbin/poweroff
%Linux-Users ALL=/usr/sbin/NetworkManager
validate: /usr/sbin/visudo -cf %s
- name: replace line
lineinfile:
path: /etc/sudoers
regexp: '^@includedir /etc/sudoers.d'
line: '#@includedir /etc/sudoers.d'
validate: /usr/sbin/visudo -cf %s
```
#### 3.8. Ввести ПК в домен
```
#При запуске спрашивает логин и пароль (в «приватном» виде).
#После чего получает керберос-тикет и подключает ОС к домену
- name: domain join
gather_facts: false
hosts: simply
vars_prompt:
- name: "adlogin"
prompt: "Enter AD Login"
private: no
- name: "password"
prompt: "Enter password"
private: yes
tasks:
- name: domain check
shell: timeout 6s net ads testjoin
register: domain_state
failed_when: domain_state.rc == 0
- name: Clear the sssd cache
shell: rm -f /var/lib/sss/db/* /var/lib/sss/mc/*
- name: get krb ticket
shell: echo '{{ password }}'| kinit "{{ adlogin }}"
- name: join domain
command: net ads join -U "{{ adlogin }}"%"{{ password }}" createcomputer="/Computers/Linux"
- name: sssd enable
service:
name: sssd
enabled: yes
state: restarted
- name: reboot
reboot:
reboot_timeout: 120
```
#### 3.10. Предусмотреть возможность массового обновления
Тут пришлось сделать отдельный playbook для обновления, и отдельный playbook для брендирования, так как мы пошли по простому пути – не стали пилить тему для кедов, а просто поменяли интересующие нас картинки. И поэтому при обновлении пакетов картинки затираются. Поэтому сразу после обновления происходит брендирование.
Playbook апдейта:
```
- name: update and upgrade
hosts: simply
gather_facts: false
tasks:
- name: update & upgrade
shell: |
apt-get update -y && apt-get dist-upgrade -y
apt-get dedup -y
```
Брендинг у нас уже был (но я вам его не покажу, мне запретили). И поэтому playbook обновления выглядят так:
```
- import_playbook: update.yml
- import_playbook: branding.yml
```
4. Server-side
--------------
Следующий этап импортозамещения – перенос инфраструктурных сервисов на «отечественные» программные продукты. Об этом мы долго думали, рассматривали варианты, поднимали стенды (но стенд и боевые тесты – это совсем не одно и то же). Словом, перекинуть на Альт или Астру, или какую-то еще ОС, например, Zabbix, dhcp, dns, proxy-сервер – не проблема. Это все есть и работает. Но заменить VMWare Hypervisor просто нечем. OpenNebula? Ну да, ну да. KVM? ProxMox? VDI – отсутствует. Проблема «отечественного» софта осталась той же – это пересобранное OpenSource ПО, которое стоит денег. И как весь OpenSource, его стоимость заключается не в «коробка + 2 инженера», а в «десяток инженеров с зарплатами сильно выше, чем у «коробочного» (в зависимости от размера инфраструктуры).
По итогу мы перекинули на Simply Linux продуктовый Zabbix, и подняли Ansible, jitsi и локальный репозиторий. Дальше по плану перенос Nextcloud, Kaspersky Security Center, Certification Authority. Но все это.. такое.. Фикция и профанация.
5. Выводы
---------
В целом, со слов тестовой группы, работать на Linux «можно». Да, недостает привычных виндовых удобств, типа SSO для Outlook, предпросмотра документов в 1С (над этим работает наш центр компетенций 1С), «адок с банк-клиентами и криптопрой» (с) техподдержка.
«Работать можно». Базовый функционал есть. Да, не искаропке, его приходится допиливать, ибо парадигма Linux такова, что каждый каждый делает «это» так, как хочет. Если вы понимаете, о чем я. А допиливать функционал приходится в основном силами админов и ТП.
В итоге: используя данный инструментарий, сотрудник сможет выполнять свои обязанности.
Но. Шаг влево\шаг вправо вызывает жуткий butthurt как у пользователя, так у техпода, привыкшего к Windows. У нас же как заведено? Логи начинают читать только тогда, когда google ничего не подсказал. И перестроить мышление довольно трудно, потому что «ну там же так работает! И это удобно! Так зачем уходить от удобного и привычного к сложному и непонятному?». Но это уже политика, это на другом ресурсе обсуждается.
«Мыши плакали и кололись..» А, стоп, где-то я это [уже писал](https://habr.com/ru/post/449828/).. | https://habr.com/ru/post/695284/ | null | ru | null |
# Интеграция CI/CD для нескольких сред с Jenkins и Fastlane. Часть 1
> В преддверии старта курса ["iOS Developer. Basic"](https://otus.pw/xhV24/) традиционно подготовили для вас интересный перевод, а также приглашаем записаться на бесплатный вебинар, в рамках которого наши эксперты подробно расскажут о программе курса, а также ответят на интересующие вас вопросы.
>
>
---
Внедрение технологий непрерывной интеграции (Continuous Integration - CI) и непрерывного развертывания (Continuous Delivery - CD) в процесс разработки - бесспорно единственный способ отслеживать актуальность изменений кода и определять ошибки интеграции на самых ранних этапах. Это также еще и путь к отлаженным билдам, практически сразу же доступным для тестирования и готовым к отправке в продакшн даже после значительных изменений кода.
Интегрируя CI/CD в свою повседневную работу, разработчики могут достичь двух важных целей: во-первых, возможность запускать наборы тестов на сервере, который не является рабочим компьютером, чтобы инженер мог продолжать разрабатывать новый функционал без отвлекающих факторов и, во-вторых, возможность отправлять билды своему заказчику или инженеру по обеспечению качества, чтобы продемонстрировать/протестировать/проанализировать новую фичу, даже если они не могут собрать и запустить проект на своих собственных компьютерах.
Но что происходит, когда у нас есть несколько промежуточных сред, и тесты должны выполняться на разных серверах или функции должны тестироваться в разных средах? Вот где на помощь приходят Jenkins и Fastlane - инструменты, которые позволяют автоматизировать процесс под различные конфигурации, и именно на этом фокусируется данная статья.
Существует множество отличных статей и руководств, в которых подробно описывается, как использовать Jenkins и Fastlane для настройки CI для мобильного проекта. Однако я хочу сосредоточиться на том, как мы можем настроить соответствующие скрипты для работы с несколькими средами.
Jenkins и Fastlane
------------------
Чтобы понять, как мы можем интегрировать CI в проект, мы должны понимать, как **Jenkins** и **Fastlane** работают. Вкратце, Jenkins - это сервер непрерывной интеграции с открытым исходным кодом, написанным на Java, и это один из наиболее широко используемых инструментов для управления сборками непрерывной интеграции. Jenkins предоставляет возможность создавать **пайплайны** (**Pipelines**), которые по сути являютсяжизненными циклами процессов, называемых **задачами** (**Jobs**), которые включают сборку, документирование, тестирование, упаковку, стейджинг, развертывание, статический анализ и многое другое. Задачи связаны друг с другом в последовательности, образующей конвейер (пайплайн), и именно здесь в игру вступает Fastlane.
**Fastlane** - это инструмент с открытым исходным кодом, который используется для автоматизации процесса развертывания и распространения мобильных проектов (iOS и Android), предлагающий широкий спектр функций автоматизации в рамках жизненного цикла мобильного приложения, таких как упаковка, подписание кода, распространение сборок и многое другое. Fastlane позволяет создавать задачи, именуемые **Lanes**,которые по сутипредставляют из себя скрипты, то есть серию команд, называемых **Actions**,которые описывают рабочий процесс, который мы хотим автоматизировать.
Наша цель
---------
Итак, то, чего мы здесь хотим достичь, - это автоматизировать процесс распространения нашего iOS-приложения путем автоматизации загрузки нашего приложения в **Testflight**, откуда заинтересованные лица (заказчик, инженер по обеспечению качества, продавец, который хочет продемонстрировать приложение, и в том же духе) могут войти в систему и загрузить его без особых усилий. Более того, мы хотим продвинуться на один шаг дальше и реализовать возможность автоматически загружать билды в Testflight по одному нажатию кнопки:
a) для разных веток под разные фичи
b) для нескольких конфигураций, соответствующих разным средам
Такова будет наша конечная цель ?.
Предварительные требования
--------------------------
В этой статье мы считаем, что Jenkins и Fastlane уже были установлены и настроены. Существует множество руководств, в которых подробно описывается, как нужно выполнять настройку. Кроме того, для Jenkins потребуется установить некоторые плагины, чтобы позволить Jenkins запускаться из веб-хуков Github и запускать задание. Это плагины [Github](https://plugins.jenkins.io/github/), [Xcode](https://plugins.jenkins.io/xcode-plugin/), [SCM](https://plugins.jenkins.io/workflow-scm-step/) (Source Control Management), которые будут использоваться для того, чтобы сделать чекаут нашего проекта с Github, и [Credentials Plugin](https://plugins.jenkins.io/credentials-binding/) для того, чтобы связать учетные данные для переменных окружения.
Начнем
------
Для начала нам нужно создать новый пайплайн в Jenkins. Этот пайплайн будет описан созданным нами скриптом, который выполняет загрузку нашего приложения в Testflight.
В главном меню панели инструментов Jenkins (ниже) мы выбираем первый вариант => *New Item* (Pipeline) и создаем задачу (Job) Jenkins с именем “Upload to Testflight”.
Далее выбираем параметр *Configure* в левом меню и продолжаем, добавляя конфигурацию только что созданного пайплайна. Начнем с добавления небольшого описания.
В поле *Definition* ниже, в разделе Pipeline выбираем параметр «Pipeline Script from SCM». Этот параметр указывает Дженкинсу получить пайплайн из системы управления исходным кодом (SCM), в роли которой будет наш клонированный Git-репозиторий.
Мы добавляем параметр - ветку, которую мы хотим каждый раз билдить и загружать в Testflight, а также добавляем ссылку на репозиторий github, предоставляя также параметры учетных данных github.
Наконец, мы определяем скрипт, который будет описывать весь процесс пайплайна.
Нажимаем кнопку «Save» и вуаля! Нам удалось создать собственную задачу в Jenkins. Теперь мы готовы приступить к написанию нашего скрипта!
В основном мы будем использовать подход [Scripted Pipeline](https://www.jenkins.io/doc/book/pipeline/syntax/). Наш скрипт будет состоять из нескольких этапов, называемых стадиями (stages), которые описывают, что собирается делать наш пайплайн. В конечном итоге мы хотим закончить загрузкой в Testflight, но перед загрузкой мы хотим убедиться, что наши модульные тесты проходятся успешно. Таким образом, различные фазы скрипта автоматизации должны включать следующие стадии:
1. Чекаут репозитория
2. Установка зависимостей
3. Сброс симуляторов
4. Запуск тестов
5. Сборка билда
6. Загрузка в Testflight
7. Очистка
После того, как мы написали наш скрипт, нам нужно выбрать опцию *Build with Parameters* из меню пайплайна, который мы только что создали, и указать ветку, которую мы хотим собрать:
После того, как мы нажмем кнопку *Build*, и конвейер будет успешно запущен, мы увидим следующее в Jenkins Stage view:
что будет означать, что мы успешно загрузили наше приложение в Testflight!
Сбой на одном из этих этапов будет автоматически означать, что вся работа завершится ошибкой, и мы увидим соответствующий этап, подсвеченный красным цветом. В этом случае мы можем перейти в *Console Output* в меню задачи, просмотреть логи и определить причину сбоя и, конечно, повторно запустить задачу после устранения проблемы.
Скрипт
------
В нашем скрипте, который мы назвали MyScript.groovy, мы определим функцию называемую `deploy()`, внутри которой мы намерены реализовать вышеперечисленные стадии следующим образом:
**1. Чекаут репозитория**
Мы делаем чекаут нашего репозитория с помощью команды `checkout` плагина SCM, которая будет запускать проверку проекта с использованием параметров конфигурации, которые мы указали в Jenkins Pipeline.
```
stage('Checkout') {
checkout scm
}
```
**2. Установки зависимостей**
```
stage('Install dependencies') {
sh 'gem install bundler'
sh 'bundle update'
sh 'bundle exec pod repo update'
sh 'bundle exec pod install'
}
```
Наш проект использует в качестве менеджера зависимостей CocoaPods, поэтому нам нужно запустить `pod install`, чтобы загрузить зависимости проекта. Для выполнения этой команды и всех других шелл-команд мы используем Bundler, который представляет собой инструмент для управления гемом приложения Ruby. Выполнив первые 2 команды, нам удается установить Bundler, а затем Bundler загружает все гемы, указанные в Gemfile проекта. Это стадия, на которой мы можем указать набор инструментов, которые могут понадобиться нашему приложению, например Fastlane, который мы будем использовать следующим, или, если нам нужен линтер или [Danger](https://github.com/danger/danger), это место как раз для определения их ruby гемов. Мы продолжаем дальше и запускаем `pod repo update`, чтобы всегда иметь последние версии pod'а, и, наконец, мы запускаем `pod update`, чтобы загрузить зависимости проекта.
**3. Сброс симуляторов**
```
stage('Reset Simulators') {
sh 'bundle exec fastlane snapshot resetsimulators --force'
}
```
Этот шаг не обязателен, но необходим, если мы хотим запускать модульные тесты на следующей стадии, не беспокоясь о потенциально устаревшем состоянии симулятора, которое может привести к сбою при модульном тестировании.
Это первый раз, когда Fastlane появляется в кадре. Как я упоминал ранее, Fastlane использует **Lanes** и уже имеет большое количество заготовленных лейнов, но мы можем создавать и свои собственные настраиваемые лейны внутри файла под именем Fastfile. Здесь мы используем заготовленный лейн, который делает именно то, что нам нужно.
Команда выше удалит и пересоздаст все iOS-симуляторы, что можно счесть чрезмерным, но иногда «отчаянные времена требуют отчаянных мер» .
**4. Запуск тестов**
```
stage('Run Tests') {
sh 'bundle exec fastlane test'
}
```
На этом этапе мы запускаем модульные тесты для нашего проекта. Теперь `test` представляет собой кастомный лейн, который мы реализовали внутри нашего **Fastfile,** и имеет следующую реализацию:
```
lane :test do
scan(
clean: true,
devices: ["iPhone X"],
workspace: "ourproject.xcworkspace",
scheme: "productionscheme",
codecoverage: true,
outputdirectory: "./testoutput",
outputtypes: "html,junit"
)
slather(
coberturaxml: true,
proj: "ourproject.xcodeproj",
workspace: "ourproject.xcworkspace",
outputdirectory: "./testoutput",
scheme: "productionscheme",
jenkins: true,
ignore: [arrayofdocstoignore]
)
end
```
Здесь мы используем два основных экшена Fastlane: [scan](https://docs.fastlane.tools/actions/scan/) и [slather](https://docs.fastlane.tools/actions/slather/).
Scan используется для фактического запуска модульных тестов и может быть настроен с несколькими параметрами, такими как *workspace* (рабочее пространство), *scheme* (схема), codecoverage (покрытие кода) и, что наиболее важно, *devices* (устройства), где можем указать симулятор, в котором мы хотим запускать наши модульные тесты.
Slather используется для сбора покрытия кода при выполнении модульных тестов, а также принимает несколько аргументов, таких как результирующий каталог для отчета о покрытии, а также массив документов, которые следует игнорировать при сборе покрытия кода (*ignore*).
Здесь и происходит Fastlane-магия ✨. Определяя этот лейн всего двумя экшенами, нам удается легко запускать наши модульные тесты внутри Jenkins. Обратите внимание, что все они, очевидно, должны быть успешно пройдены, иначе эта стадия и вся задача закончатся неудачей.
---
*На этом мы завершаем первую часть перевода,* [*вторую часть можно прочитать тут*](https://habr.com/ru/company/otus/blog/527562/)*.*
***А если вас заинтересовал курс, предлагаем записаться на*** [***бесплатный вебинар по ссылке***](https://otus.pw/xhV24/)***.*** | https://habr.com/ru/post/526394/ | null | ru | null |
# Установка и настройка: Nginx + php5-fpm
В данной заметке, будет показано как поставить связку Nginx + php5-fpm (php5.3) на Debian Lenny и настроить безопасную конфигурацию.### Установка и настройка
**Важно:** все команды от root'а.
Добавляем репозитарии и генерируем ключи:
>
> ```
> echo "deb http://backports.debian.org/debian-backports lenny-backports main" >> /etc/apt/sources.list
> echo "deb http://php53.dotdeb.org stable all" >> /etc/apt/sources.list
> gpg --keyserver keys.gnupg.net --recv-key 89DF5277 && gpg -a --export 89DF5277 | apt-key add -
> ```
>
Обновляем:
>
> ```
> aptitude update
> ```
>
Устанавливаем nginx и php5-fpm:
>
> ```
> aptitude install -t lenny-backports "nginx"
> apt-get install php5-cli php5-common php5-suhosin
> apt-get install php5-fpm php5-cgi
> ```
>
Приводим конфиг /etc/nginx/nginx.conf к виду:
>
> ```
> user www-data;
> worker_processes 1; # Ставим число по количеству ядер
>
> timer_resolution 100ms;
> worker_rlimit_nofile 8192;
> worker_priority -5; #Увеличитвваем приоритет
>
> error_log /var/log/nginx/error.log;
> pid /var/run/nginx.pid;
> events {
> worker_connections 1024;
> }
> http {
> include /etc/nginx/mime.types;
> access_log /var/log/nginx/access.log;
>
> sendfile on;
> keepalive_timeout 65;
> tcp_nodelay on;
>
> gzip on;
> gzip_min_length 1100;
> #gzip_disable "msie6"; #Быстрее, но работает только на новых версиях nginx
> gzip_disable "MSIE [1-6]\.(?!.*SV1)";
> gzip_proxied any;
> gzip_comp_level 4;
> gzip_types text/plain text/css application/x-javascript text/xml application/xml application/xml+rss text/javascript;
> gzip_vary on;
>
> include /etc/nginx/conf.d/*.conf;
> include /etc/nginx/sites-enabled/*;
> }
>
> ```
>
Удаляем `/etc/nginx/sites-available/default`
#### Пример конфига
Конфиг для использования с CMS WordPress, с учетом использования chroot`/etc/nginx/sites-enabled/example.ru`:
>
> ```
>
> server {
> listen 80;
> server_name www.example.ru;
> rewrite ^ http://example.ru$request_uri? permanent; #301 redirect
> }
> server {
> listen 80;
> server_name example.ru;
> root /var/www/example.ru;
> index index.php;
>
> location / {
> try_files $uri $uri/ /index.php?q=$uri&$args;
> }
> location ~* ^.+.(js|css|png|jpg|jpeg|gif|ico)$ {
> access_log off;
> expires max;
> }
> location ~ \.php$ {
> # fastcgi_split_path_info ^(.+\.php)(.*)$;
> fastcgi_pass 127.0.0.1:9000;
> fastcgi_index index.php;
>
> fastcgi_param DOCUMENT_ROOT /example.ru;
> fastcgi_param SCRIPT_FILENAME /example.ru$fastcgi_script_name;
> fastcgi_param PATH_TRANSLATED /example.ru$fastcgi_script_name;
>
> include fastcgi_params;
> fastcgi_param QUERY_STRING $query_string;
> fastcgi_param REQUEST_METHOD $request_method;
> fastcgi_param CONTENT_TYPE $content_type;
> fastcgi_param CONTENT_LENGTH $content_length;
> fastcgi_intercept_errors on;
> fastcgi_ignore_client_abort off;
> fastcgi_connect_timeout 60;
> fastcgi_send_timeout 180;
> fastcgi_read_timeout 180;
> fastcgi_buffer_size 128k;
> fastcgi_buffers 4 256k;
> fastcgi_busy_buffers_size 256k;
> fastcgi_temp_file_write_size 256k;
> }
>
> location = /favicon.ico {
> log_not_found off;
> access_log off;
> }
> location = /robots.txt {
> allow all;
> log_not_found off;
> access_log off;
> }
> ## Disable viewing .htaccess & .htpassword
> location ~ /\.ht {
> deny all;
> }
> }
>
> ```
>
Устанавливаем mysql:
>
> ```
> apt-get install mysql-server mysql-client php5-mysql
> mkdir -p /var/www/var/run/mysqld
> mount --bind /var/run/mysqld/ /var/www/var/run/mysqld/
> ```
>
Создадим каталог и файл index.php:
>
> ```
> mkdir -p /var/www/example.ru
> echo "php phpinfo(); ?" >/var/www/example.ru/index.php
> ```
>
Перезапускаем nginx и php5-fpm:
>
> ```
> /etc/init.d/nginx restart
> /etc/init.d/php5-fpm restart
> ```
>
### Безопасность
Проставим правильные права каталогам:
>
> ```
> chown -R www-data /var/www/example.ru && chmod -R 750 /var/www/example.ru
> ```
>
Исправляем [уязвимость](http://forum.antichat.ru/thread222063-php-fpm.html) связанную с
```
location ~ .php$ {
```
, для этого прописываем в /etc/php5/fpm/php.ini
>
> ```
> cgi.fix_pathinfo=0
> ```
>
Включим использование chroot, для ограничения доступа PHP к системе. Для этого редактируем файл /etc/php5/fpm/php5-fpm.conf, прописываем:
>
> ```
>
> chroot = /var/www
> chdir = /
>
> ```
>
Далее мы столкнемся с проблемой что PHP не сможет отрезолвить адрес, исправляем:
>
> ```
>
> mkdir /var/www/{etc,lib};
> cp /etc/hosts /var/www/etc/hosts;
> cp /etc/resolv.conf /var/www/etc/resolv.conf;
> cp /lib/libnss_dns.so.2 /var/www/lib/libnss_dns.so.2 //ваша система 32 битная
> cp /lib64/libnss_dns.so.2 /var/www/lib64/libnss_dns.so.2 //ваша система 64 битная
> ```
>
Перезапускаем php5-fpm:
>
> ```
> /etc/init.d/php5-fpm restart
> ```
>
Заходим на страницу нашего сайта example.ru и любуемся на вовод phpinfo() нашего сайта.
P.S. C настройками мне помог разобраться [inkvizitor68sl](https://habrahabr.ru/users/inkvizitor68sl/) автор блога Debian.pro.
**NEW:**#### Установка Nginx 0.8.54
>
> ```
>
> apt-get update
> apt-get install libxml2-dev libbz2-dev libcurl4-openssl-dev libmcrypt-dev libmhash2 libmhash-dev libpcre3 libpcre3-dev make
>
> wget http://sysoev.ru/nginx/nginx-0.8.54.tar.gz
> tar zxf nginx-0.8.54.tar.gz
> cd nginx-0.8.54
>
> ./configure \
> --conf-path=/etc/nginx/nginx.conf \
> --error-log-path=/var/log/nginx/error.log \
> --http-client-body-temp-path=/var/lib/nginx/body \
> --http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
> --http-log-path=/var/log/nginx/access.log \
> --http-proxy-temp-path=/var/lib/nginx/proxy \
> --lock-path=/var/lock/nginx.lock \
> --pid-path=/var/run/nginx.pid \
> --with-debug --with-http_dav_module \
> --with-http_gzip_static_module \
> --with-http_realip_module \
> --with-http_stub_status_module \
> --with-http_sub_module
>
> make && make install
>
> ```
>
#### Debian «Squeeze»
Для установки пакета php-fpm понадобится:
>
> ```
>
> echo "deb http://packages.dotdeb.org squeeze all" >> /etc/apt/sources.list
> wget http://www.dotdeb.org/dotdeb.gpg && cat dotdeb.gpg | apt-key add - && aptitude update
>
> ```
>
**UPD:** Добавил пару строк в установку mysql, указание в настройках localhost теперь работает. Спасибо [inkvizitor68sl](https://habrahabr.ru/users/inkvizitor68sl/). | https://habr.com/ru/post/113101/ | null | ru | null |
# Заметки о Unix: небольшая странность семейства вызовов exec*()
Я недавно [писал](https://utcc.utoronto.ca/~cks/space/blog/unix/FindExecImplementationShows) об опции `-exec` команды `find` и ненароком упомянул о «семействе системных вызовов `exec()`». Это — странное выражение, обычно о Unix-вызовах так не говорят, так как они, как правило, не объединяются в некие «семейства». Но в данном случае речь идёт о целом наборе схожих механизмов. Перечислим их:
```
execv() execve() execvp() execvpe()
execl() execlp() execle()
```
(Этот список выглядит именно так в Linux и в OpenBSD; подобный список, составленный для FreeBSD, включал бы в себя `execvP()`, а не `execvpe()`. В [POSIX-версии](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html) подобного списка нет вызова `execvpe()`, но есть вызов `fexecve()`, который я не вполне готов включить в семейство вызовов `exec()`.)
[](https://habr.com/ru/company/ruvds/blog/553070/)
Одна из этих команд не похожа на другие. На самом деле, во всём этом списке, включающем в себя, как минимум, шесть `exec()`-функций, лишь `execve()` относится к системным вызовам; остальные `exec*()`-функции — это просто библиотечные функции, в основе которых лежит `execve()`. То, что существуют удобные библиотечные функции, основанные на системном вызове (или на нескольких вызовах), не является чем-то необычным; так, например, устроено всё то, что имеет отношение к `stdio`. Но всё это выглядит несколько странно из-за того, что имена функций весьма близки друг к другу. У меня хорошая память на имена `libc`-функций Unix, но я, вероятно, в большинстве случаев, не смог бы выделить из вышеприведённого списка настоящий системный вызов `exec()`.
(Сейчас-то я, конечно, хорошо помню о том, что `execve()` — это системный вызов, который, в большинстве Unix-дистрибутивов, лежит в основе `exec*()`-функций.)
Такое множество функций со схожими именами существует со времён V7 Unix, где документация по `execl()`, `execv()`, `execle()` и `execve()` размещена в справочном файле [exec(2)](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V7/usr/man/man2/exec.2). В V7, по состоянию на сегодняшний день, базовым системным вызовом является `execve()`, хотя ему назначено другое имя. Даже в V6 `execl()` и `execv()` описаны в единственном справочном файле [exec(2)](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/man/man2/exec.2).
(Соответствующий системный вызов V6 был назван `exec` и принимал лишь программу, которую нужно выполнить, и `argv`. Когда в V7 появилось такое понятие, как «окружение», там сохранился системный вызов `exec` из V6, который, в качестве дополнительного аргумента, принимал `envp`.)
P.S. В некоторых дистрибутивах Unix есть базовые системные вызовы, которые, по сути, являются разновидностями одного и того же вызова. Такая ситуация сложилась из-за того, что API системных вызовов развивался и совершенствовался достаточно длительное время. Например, подобное могло произойти при добавлении в систему 64-битных вариантов вызовов, которые раньше были 32-битными. Правда, обычно в сознании людей присутствуют лишь самые свежие версии системных вызовов; они не представлены некими семействами разновидностей какого-то вызова и в этом смысле не похожи на семейство `exec()`.
Встречались ли вы с какими-то странностями, касающимися именования сущностей в Unix?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=zametki_o_unix:_nebolshaya_strannost_semejstva_vyzovov_exec*()) | https://habr.com/ru/post/553070/ | null | ru | null |
# NiFi по красоте: HTTPS/LDAP/NiFi Registry/NiFi Cli + CI/CD
### Вступление
Давайте, я сразу объясню свою баянистость. Да, в интернетах полно мануалов. Да, полно пошаговых прохождений. Да, можете сказать, что все жевано пережевано. Но конкретно в моем случае, как это всегда и бывает, оказалась горстка "но":
Есть мануалы о том, как настроить связку NiFi и NiFi Registry со включенной аутентификацией и авторизацией. Но... используются самоподписанные серты.
Есть отдельные мануалы, как прикрутить коммерческий серт для NiFi; соответственно для NiFi Registry "кагбэ так же". Но взаимная аутентификация и авторизация будет происходить с использованеим Two way SSL... а у нас же LDAP... и обеспечить потом связность сладкой парочки с использованием только внешнего каталога у вас на голой интуиции не получится.
Есть мануалы по связке с LDAP и для NiFi, и для NiFi Registry. Нооо... как и в предыдущем "но", возникают вопросы, как обойтись потом только LDAP'ом, потому что у нас же еще NiFi Cli, а он в LDAP не умеет.
Иными словами, во всех мануалах есть маааленький нюанс: они покрывают только простейшие сценарии. Документации по комплексным связкам просто нет. Более того, в ходе настройки связки я столкнулся со сложностями, которые в буржуйнете встречаются всего несколько раз и все они либо без ответов, либо ответы не релевантны.
#### Что у нас есть и что мы хотим получить
У нас есть:
* Коммерческий wildcard SSL/TLS сертификат;
* Сервер каталогов, который умеет в LDAP (в моем случае Apache DS);
* Сервер NiFi, на котором ведется разработка;
* Сервер NiFi в продуктовом окружении;
* Сервер NiFi Registry.
Мы хотим:
* Аутентификацию, авторизацию и HTTPS. Тем более, NiFi не позволяет включить встроенные механизмы аутентификации без HTTPS;
* Централизованное управление пользователями на сервере каталогов;
* Версионирование flow и process-group в схожей с гитом манере;
* Автоматизацию доставки и развертывания релизов с дева на прод.
#### Наш план:
1. Настройка Apache DS;
2. Создание Java Keystore и Java Truststore, включение HTTPS;
3. Настройка аутентификации через LDAP в NiFi;
4. Настройка аутентификации через LDAP в NiFi Registry;
5. Переопределение значений идентификации;
6. Настройка связки NiFi и NiFi Registry;
7. Трансфер данных из одного NiFi в другой с помощью NiFi Cli.
#### Соглашение об именовании
> В нашем примере wildcard сертификат выдан на домен: **\*.love.you**;
>
> FQDN сервера с Apache DS: **auth.love.you**;
>
> Учетная запись для подключения к Apache DS: **uid=admin,ou=system**; пароль по умолчанию для первого входа: **secret**;
>
> Создадим в Apache DS раздел love.you: **dc=love,dc=you**;
>
> Создадим в Apache DS пользователя **nifiAdmin** с администраторскими привилегиями и пользователя **nifiUser** без администраторских привилегий в NiFi и NiFi Registry;
>
> Создадим в Apache DS группу **nifiAdmins** для администраторов и **nifiUsers** для пользователей в NiFi и NiFi Registry;
>
> FQDN NiFi, где ведется разработка: **nifi-deve.love.you**;
>
> FQDN NiFi Registry: **nifi-re.love.you**;
>
> FQDN целевого (продуктового) NiFi: **nifi.love.you**;
>
> Путь, по которому установлен NiFi: **$NIFI\_HOME**;
>
> Путь, по которому установлен NiFi Registry: **$NIFI\_REGISTRY\_HOME**;
>
> Путь, по которому установлен NiFi Toolkit: **$NIFI\_TOOLKIT\_HOME**;
>
> Путь, по которому сохранены сгенерированные контейнеры: **/love/conf/cert**;
>
> Пароль для экспорта из PKCS12, для Java Keystore и Java Truststore:
> `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO`
>
>
### Apache DS
На самом деле, конечно же, на Apache DS свет клином не сошелся. Вы можете использовать любую службу или любой сервер каталогов по вашему вкусу. У нас для внутрикорпоративных целей используется Azure AD, а для "третьих лиц", которые и будут пользоваться NiFi, корпоративную AD'шку использовать не хотелось. Apache DS был выбран просто потому что он, ну, тоже Apache.
Процесс установки прост. Я люблю ставить из архивов, поэтому скачал архив, распаковал в любимое место, создал файл сервиса, запустил сервис. Подробности - [на официальном сайте](https://directory.apache.org/).
По умолчанию после запуска сервис начинает слушать 10389 порт. Для подключения к сервису потребуется Apache Directory Studio. [Скачиваете](https://directory.apache.org/studio/downloads.html), устанавливаете, запускаете.
В левой нижней секции окна программы правый клик мыши и создаете соединение **New connection**:
Укаызваете имя и параметры подключения:
На следующем шаге мастера указываете данные учетной записи администратора: **uid=admin,ou=system** и пароль **secret**. Проверяем подключение нажатием на кнопку **Check Authentication**:
По завершении мастера соединие устанавливается автоматически.
Теперь необходимо отредактировать схему. Цель редактирования - добавить атрибут **member** в objectclass **inetOrgPerson**. Выберите в LDAP Browser'е вхождение **ou=schema** правым кликом мыши и выберите **Reload Entry**:
Разверните загруженный список и повторите действия над вхождением **cn=inetorgperson** и далее над **ou=objectClasses**. Нас интересует вхождение **m-oid=2.16.840.1.113730.3.2.2**. Правый клик мыши и выберите **Open With** -> **LDIF Entry Editor**:
Добавьте строку **m-may: member** и сохраните изменения **Ctrl+S**:
Далее правый клик на соединении в левой нижней части окна и выберите **Open Configuration**:
Выбираем **Advanced Partition configuration...**
Нажимаем **Add**, заполняем поля **ID** и **Suffix**. По окончании сохраняем изменения нажатием **Ctrl+S**:
Теперь важный момент: **изменения в схеме и созданный раздел станут доступны только после перезапуска службы**. Так что идем в консоль сервера и перезапускаем службу. Теперь разрываем соединение и подключаемся снова. Раздел появился:
Далее заносим группы и пользователей. Самый простой способ - с помощью импорта LDIF файла. Скопируйте содержимое из-под спойлера в файл **import.ldif** и сохраните его.
import.ldif
```
dn: ou=people,dc=love,dc=you
objectclass: organizationalUnit
objectClass: extensibleObject
objectclass: top
ou: people
dn: ou=groups,dc=love,dc=you
objectclass: organizationalUnit
objectClass: extensibleObject
objectclass: top
ou: groups
dn: cn=nifiUsers,ou=groups,dc=love,dc=you
objectClass: groupOfUniqueNames
objectClass: top
cn: nifiUsers
uniqueMember: cn=nifiUser,ou=people,dc=love,dc=you
dn: cn=nifiAdmins,ou=groups,dc=love,dc=you
objectClass: groupOfUniqueNames
objectClass: top
cn: nifiAdmins
uniqueMember: cn=nifiAdmin,ou=people,dc=love,dc=you
dn: cn=nifiUser,ou=people,dc=love,dc=you
objectclass: inetOrgPerson
objectclass: organizationalPerson
objectclass: person
objectclass: top
cn: nifiUser
description: A nifiUser user
sn: nifiUser
uid: nifiUser
mail: nifiUser@love.you
userpassword: password
member: cn=nifiUsers,ou=groups,dc=love,dc=you
dn: cn=nifiAdmin,ou=people,dc=love,dc=you
objectclass: inetOrgPerson
objectclass: organizationalPerson
objectclass: person
objectclass: top
cn: nifiAdmin
description: A nifiAdmin user
sn: nifiAdmin
uid: nifiAdmin
mail: nifiAdmin@love.you
userpassword: password
member: cn=nifiAdmins,ou=groups,dc=love,dc=you
dn: cn=*.love.you,ou=people,dc=love,dc=you
objectClass: person
objectClass: top
cn: *.love.you
sn: *.love.you
```
Правый клик по созданному разделу и выбрать **LDIF Import**:
Выберите сохраненный ранее файл и завершите импорт:
Итог импорта:
Об cn=\*.love.youВы наверняка обратили внимание, что в **ou=people** после импорта появилось вхождение **cn=\*.love.you**, которое **objectClass: person**:
Забегая вперед, поясню: это учетная запись для узлов, попадающих под маску сертификата **\*.love.you**. Этой учетке в дальнейшем мы будем давать специальные права для взаимодейтвия с NiFi Registry.
### Java Keystore и Java Truststore
Согласно [документации](https://nifi.apache.org/docs/nifi-docs/html/walkthroughs.html#securing-nifi-with-provided-certificates), есть два способа передать сертификат и приватный ключ: это с помощью контейнера PKCS12 и с помощью проприетарных контейнеров JKS. Причем, авторы NiFi рекомендуют именно второй.
Потребуется:
* Файл сертификата со всей цепочкой в PEM-формате: **fullchain.crt**;
* Файл соответствующего сертификату приватного ключа в PEM-формате: **private.key**;
* Файл сертификата certificate authority (CA) в PEM-формате: **cacert.pem**;
Как узнать, присутствует ли в сертификате цепочка. Если нет, то как ее сформировать.Откройте файл на просмотр. Если в нем только один блок:
```
-----BEGIN CERTIFICATE-----
...
...
...
-----END CERTIFICATE-----
```
Значит это просто сертификат.
Если блоков два или более, значит вся цепочка.
Для того, чтобы сформировать цепочку, создайте файл, который содержит в себе сначала блок символов (вместе со строками начала и конца) из файла с сертификатом. А после этого блока вставьте блок или блоки из CA сертификата.
Напрямую конвертировать сертификат и ключ в Java Keystore невозможно. Необходимо произвести промежуточную упаковку в контейнер PKCS12:
```
openssl pkcs12 -export -out nifi.p12 -inkey private.key -in fullchain.crt -name nifi-key
```
Перед созданием контейнера PKCS12 у вас спросят пароль для последующего экспорта. Сгенерируйте надежный пароль и введите его.
Формируем Java Keystore из PKCS12 контейнера:
```
keytool -importkeystore -srckeystore nifi.p12 -srcstoretype pkcs12 -srcalias nifi-key -destkeystore keystore.jks -deststoretype jks -destalias nifi-key
```
Введите пароль для экспорта, который указали на предыдущем шаге. Далее сгенерируйте надежный пароль для самого Java Keystore, введите его.
Формируем Java Truststore:
```
keytool -importcert -alias nifi-cert -file cacert.pem -keystore truststore.jks
```
У вас спросят пароль для Java Truststore. Сгенерируйте надежный пароль и введите его. Не возбраняется использовать одинаковый пароль для Keystore и для Truststore. Это снизит вероятность путаницы при дальнейшей настройке. Но тут уж как вы сами договоритесь со своим внутренним параноиком.
Полученные JKS контейнеры скопируйте на серверы с NiFi, где ведется разработка, на продуктовый NiFi и на сервер с NiFi Registry, разместив их по пути **/love/conf/cert/**;
Для завершения настройки NiFi на сервере, где ведется разработка, отредактируйте файл **$NIFI\_HOME/config/nifi.properties**, приведя значения параметров к виду под спойлером.
nifi.properties
```
# Site to Site properties
nifi.remote.input.host=nifi-deve.love.you
nifi.remote.input.secure=true
nifi.remote.input.socket.port=10443
# web properties #
nifi.web.http.host=
nifi.web.http.port=
nifi.web.https.host=nifi-deve.love.you
nifi.web.https.port=9443
# security properties #
nifi.security.keystore=/love/conf/cert/keystore.jks
nifi.security.keystoreType=jks
nifi.security.keystorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.security.truststore=/love/conf/cert/truststore.jks
nifi.security.truststoreType=jks
nifi.security.truststorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.security.allow.anonymous.authentication=false
nifi.security.user.login.identity.provider=ldap-provider
```
> Обратите внимание: необходимо **удалить значения** с параметров **nifi.web.http.host** и **nifi.web.http.port**. Если этого не сделать, получите ошибку при запуске и сообщение о том, что NiFi не может быть запущен одновременно на двух портах.
> Так же обратите внимание на строку **21** - тут определяется, что будет служить источником учетных записей.
>
> Не забудьте заменить пароль `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO` на действительный, сгенерированный вами.
>
>
Для завершения настройки NiFi на продуктовом сервере, отредактируйте файл **$NIFI\_HOME/config/nifi.properties**, приведя значения параметров к виду под спойлером.
nifi.properties
```
# Site to Site properties
nifi.remote.input.host=nifi.love.you
nifi.remote.input.secure=true
nifi.remote.input.socket.port=10443
# web properties #
nifi.web.http.host=
nifi.web.http.port=
nifi.web.https.host=nifi.love.you
nifi.web.https.port=9443
# security properties #
nifi.security.keystore=/love/conf/cert/keystore.jks
nifi.security.keystoreType=jks
nifi.security.keystorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.security.truststore=/love/conf/cert/truststore.jks
nifi.security.truststoreType=jks
nifi.security.truststorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.security.allow.anonymous.authentication=false
nifi.security.user.login.identity.provider=ldap-provider
# Identity Mapping Properties #
nifi.security.identity.mapping.pattern.dn=^CN=(.*?)$
nifi.security.identity.mapping.value.dn=$1
nifi.security.identity.mapping.transform.dn=NONE
```
> Обратите внимание: появились **настройки переопределения значений идентификации**. Смысл этой настройки я объясню ниже.
> Так же обратите внимание на строку **21** - тут определяется, что будет служить источником учетных записей.
>
> Не забудьте заменить пароль `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO` на действительный, сгенерированный вами.
>
>
Для завершения настройки NiFi Registry, отредактируйте файл **$NIFI\_REGISTRY\_HOME/config/nifi-registry.properties**, приведя значения параметров к виду под спойлером.
nifi-registry.properties
```
# web properties #
nifi.registry.web.http.host=
nifi.registry.web.http.port=
nifi.registry.web.https.host=nifi-re.love.you
nifi.registry.web.https.port=8443
# security properties #
nifi.registry.security.keystore=/abc/conf/cert/keystore.jks
nifi.registry.security.keystoreType=jks
nifi.registry.security.keystorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.registry.security.truststore=/abc/conf/cert/truststore.jks
nifi.registry.security.truststoreType=jks
nifi.registry.security.truststorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
nifi.registry.security.needClientAuth=false
nifi.registry.security.identity.provider=ldap-identity-provider
# Identity Mapping Properties #
nifi.registry.security.identity.mapping.pattern.dn=^CN=(.*?)$
nifi.registry.security.identity.mapping.value.dn=$1
nifi.registry.security.identity.mapping.transform.dn=NONE
```
> И вновь хочу обратить внимание: **настройки переопределения значений идентификации**. Смысл этой настройки я объясню ниже.
> Так же обратите внимание на строку **16** - тут определяется, что будет служить источником учетных записей.
>
> Не забудьте заменить пароль `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO` на действительный, сгенерированный вами.
>
>
UPD: Ошибка java.io.IOException: Failed to bind to nifi.love.you/:9443 Если машина, на которую вы ставите NiFi или NiFi Registry имеет IP из диапазона частных адресов, а публичный адрес ей назначается снаружи, то, естественно, ОС "не в курсе" своего публичного IP-адреса, который резолвится из FQDN, соответственно, Java тоже, и прибиндиться к IP, отсутствующему в системе, не получается. Отсюда и ошибка. Выход - прописать в`/etc/hosts` соответствие FQDN локальному айпи-адресу. Например:
### Аутентификации через LDAP в NiFi
Для настройки аутентификации через LDAP потребуется отредактировать два файла: **$NIFI\_HOME/conf/login-identity-providers.xml** и **$NIFI\_HOME/conf/authorizers.xml**
В файле **login-identity-providers.xml** определяется выбор способов входа и их ключевые параметры. Здесь настривается LDAP-подключение и удаляется все остальное. Приведите файл к виду под спойлером.
login-identity-providers.xml
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
ldap-provider
org.apache.nifi.ldap.LdapProvider
SIMPLE
uid=admin,ou=system
secret
FOLLOW
10 secs
10 secs
ldap://auth.love.you:10389
ou=people,dc=love,dc=you
(uid={0})
USE\_USERNAME
12 hours
```
> Настройки особого интереса не представляют, кроме строк **27** и **29**. В **27** строке мы устанавливаем фильтр, который будет использоваться для выборки из результатов, возвращаемым нашим LDAP-сервером. **{0}** - это заглушка, вместо которой будет подставлено значение поля **User** формы логина NiFi; **uid** - атрибут, который назначен учетной записи пользователя и который имеет значение, совпадающее с именем этой учетной записи. Например, **nifiUser**.
>
> Так же обратите внимание, что **значение фильтра взято в круглые скобки**. Таков синтаксис ApacheDS.
>
> **29** строка - способ идентификации пользователей: **либо по имени (USE\_USERNAME), либо по DN (USE\_DN)**. Эстетичней выглядит, конечно же, по имени. DN можно использовать для дебага.
>
>
В файле **authorizers.xml** определяются значения параметров, влияющих на способ представления пользователей и групп в NiFi и определяется "нулевой" администратор. Приведите файл к виду под спойлером.
authorizers.xml
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
ldap-user-group-provider
org.apache.nifi.ldap.tenants.LdapUserGroupProvider
SIMPLE
uid=admin,ou=system
secret
FOLLOW
10 secs
10 secs
ldap://auth.love.you:10389
1 mins
false
ou=people,dc=love,dc=you
person
ONE\_LEVEL
cn
member
ou=groups,dc=love,dc=you
groupOfUniqueNames
ONE\_LEVEL
cn
file-access-policy-provider
org.apache.nifi.authorization.FileAccessPolicyProvider
ldap-user-group-provider
./conf/authorizations.xml
nifiAdmin
managed-authorizer
org.apache.nifi.authorization.StandardManagedAuthorizer
file-access-policy-provider
```
> Интерес представляют следующие строки:
> **31** - определяется значение objectClass в ApacheDS, по которому будут отфильтровываться учетные записи из содержимого каталога;
> **35** - определяется имя атрибута, по значению которого будет определяться принадлежность пользователя к той или иной группе;
> **39** - определяется objectClass, по значению которого будут отфильтровываться группы из содержимого каталога;
> **50** - определятся имя блока, который служит источником учетных записей и групп (тег identifier: **ldap-user-group-provider** блока );
> **52** - имя учетной записи, которая будет иметь администраторские права при первом входе в систему - "нулевой" администратор.
>
>
Теперь можно запускать NiFi и входить с учетной записью **nifiAdmin** и паролем, заданным в ldif-файле.
### Аутентификации через LDAP в NiFi Registry
Настройки NiFi Registry повторяют настройки NiFi. Приведите файл **$NIFI\_REGISTRY\_HOME/conf/identity-providers.xml** к виду под спойлером.
identity-providers.xml
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
ldap-identity-provider
org.apache.nifi.registry.security.ldap.LdapIdentityProvider
SIMPLE
uid=admin,ou=system
secret
FOLLOW
10 secs
10 secs
ldap://auth.love.you:10389
ou=people,dc=love,dc=you
(uid={0})
USE\_USERNAME
12 hours
```
Приведите файл **$NIFI\_REGISTRY\_HOME/conf/authorizers.xml** к виду под спойлером.
authorizers.xml
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
ldap-user-group-provider
org.apache.nifi.registry.security.ldap.tenants.LdapUserGroupProvider
SIMPLE
uid=admin,ou=system
secret
FOLLOW
10 secs
10 secs
ldap://auth.love.you:10389
1 mins
false
ou=people,dc=love,dc=you
person
ONE\_LEVEL
cn
member
ou=groups,dc=love,dc=you
groupOfUniqueNames
ONE\_LEVEL
cn
file-access-policy-provider
org.apache.nifi.registry.security.authorization.file.FileAccessPolicyProvider
ldap-user-group-provider
./conf/authorizations.xml
nifiAdmin
managed-authorizer
org.apache.nifi.registry.security.authorization.StandardManagedAuthorizer
file-access-policy-provider
```
Теперь можно запускать NiFi Registry и входить с учетной записью **nifiAdmin** и паролем, заданным в ldif-файле.
### Переопределение значений идентификации
Теперь обещанные пара слов о параметрах в блоке **Identity Mapping Properties** файлов **nifi.properties** и **nifi-registry.properties**.
Собственно, вокруг этого блока и крутится успешная настройка связки NiFi и NiFi Registry.
Как следует из документации по настройке такой связки, необходимо создать пользователя с правами "**Proxy user requests**". На мой взгляд, такая формулировка вводит в заблуждение, поскольку происходит смешение понятий. Пользователь в том смысле, что это "учетная запись живого человека" смешивается с "учетной записью узла", которой, собственно и нужно давать права на проксирование запросов. На мой взгляд, корректнее было бы говорить не о пользователях, а о сущностях. Но авторы посчитали, что это усложнение концепций на ровном месте. И я в целом с ними согласен. И считаю нужным внести больше ясности в объяснение настройки.
Почему так важно сделать акцент на этом смешении? Причина заключается в том, что при обращении NiFi к NiFi Registry подключение происходит **не с учетными данными пользователя**, под которым вы вошли в систему. NiFi Registry при обращении к нему NiFi видит **сущность, которую NiFi подтянул из Java Keystore** и которой, собственно, и представился пред очами NiFi Registry. А, поскольку мы используем wildcard сертификат, то и представился он как **CN=\*.love.you**.
> **Важная ремарка!**
> На самом деле, тут следует сделать акцент на важной особенности поведения NiFi в процессах аутентификации. Возможности сравнить у меня не было, но подозреваю, что атрибут **CN** в сертификате может разниться от издателя к издателю. Причем разниться оформительски. Например, вместо **CN** может оказаться **cn**. А NiFi таких вольностей неприемлет.
>
>
И с этого момента начинается интересное. ApacheDS атрибут **cn** пишет прописными буквами. А в сертификате он написан заглавными. Это раз. Второе: при аутентификации используется только значение атрибута. И если зайти в NiFi и посмотреть на список пользователей, то мы увидим три вхождения: **nifiUser**, **nifiAdmin** и **\*.love.you**. Без всяких **cn=...**.
И, собственно, для нормализации сущностей, участвующих в аутентификации, и используется механизм переопределения значений.
Исходя из вышесказанного, становится понятно, что в параметре **....mapping.pattern.dn** определяется регулярное выражение с capture group, а в параметре **....mapping.value.dn** определяется регулярное выражение подменного значения. Иными словами значение **CN=\*.love.you** подменяется значением **\*.love.you**, которое совпадает с учетной записью в ApacheDS.
### Настройка связки NiFi и NiFi Registry
Я не стану вдаваться в пошаговые инструкции по захвату прав в NiFi нулевым администратором. Предполагаю, что вы умеете это делать, раз уже вводили NiFi в эксплуатацию. А если нет, то права вам нужно создать и назначить себе в двух местах.
Пиктограмма с ключиком на панели **Operate**:
И пункт **Policies** в меню, окрывающемся по нажатии на пиктограмму гамбургера в правом верхнем углу экрана:
Выполнив захват прав для учетной записи нулевого администратора, добавьте пользователя **\*.love.you** в **proxy user requests**:
Далее перейдите в раздел **Controller Settings**:
Перейдите на вкладку **REGISTRY CLIENTS**:
 И, нажав на иконку **+** в правой части экрана, заполните поля, необходимые для подключения:
Перейдите в NiFi Registry, войдите под учетной записью нулевого администратора и откройте настройки, нажав на пиктограмму гаечного ключа в правом верхнем углу:
На вкладке **USERS** нажмите на пиктограмму карандаша:
И дайте права на проксирование запросов:
На соседней вкладке создайте Bucket и назовите его Test
С этого момента можно включить версионирование в NiFi. Создадим process group и назовем ее Test. Щелкнем правой кнопкой мыши на заголовке созданной process group и выберем **Version -> Start version control**:
Заполните поля диалогового окна:
По нажатии SAVE в заголовке process group появится зеленая галочка:
Версионирование для этой process group включено.
### Трансфер данных из одного NiFi в другой с помощью NiFi Cli
Теперь, когда вы ведете версионирование process group и ваши flow сохраняются в Registry, можно наладить импорт данных в целевой (продуктовый) NiFi.
Скачайте NiFi Toolkit со [страницы загрузок NiFi](https://nifi.apache.org/download.html) и распакуйте его в удобное вам место на любой удобной вам машине.
Создайте два файла: **$NIFI\_TOOLKIT\_HOME/config/reg.properties** и **$NIFI\_TOOLKIT\_HOME/config/nifi-prod.properties**:
Настройки для подключения к NiFi Registry:
reg.properties
```
baseUrl=https://nifi-re.love.you:8443
keystore=/love/conf/cert/keystore.jks
keystoreType=jks
keystorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
keyPasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
truststore=/love/conf/cert/truststore.jks
truststoreType=jks
truststorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
proxiedEntity=nifiAdmin
```
> Не забудьте заменить пароль `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO` на действительный, сгенерированный вами.
>
>
Настройки для подключения к целевому (продуктовому) NiFi:
nifi-prod.properties
```
baseUrl=https://nifi.love.you:9443
keystore=/love/conf/cert/keystore.jks
keystoreType=jks
keystorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
keyPasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
truststore=/love/conf/cert/truststore.jks
truststoreType=jks
truststorePasswd=sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO
proxiedEntity=nifiAdmin
```
> Не забудьте заменить пароль `sF9ZCZvX#9rKHQY-Jv1PSx%IXpeGZ4@nwrO` на действительный, сгенерированный вами.
>
>
Последовательность действий:
1. Запрашиваем список бакетов у NiFi Registry и определяем ID бакета, из которого будем забирать flow.
2. Запрашиваем список flow из бакета с ID из предыдущего шага и определяем ID того flow, который будем перекидывать в целевой (продуктовый) NiFi.
3. Запрашиваем список версий интересующего flow;
4. Закидываем flow требуемой версии в целевой (продуктовый) NiFi.
Переходим в **$NIFI\_TOOLKIT\_HOME/bin** и поехали:
Запрашиваем список бакетов:
```
./cli.sh registry list-buckets -p ../conf/reg.properties
```
Получаем вывод:
```
# Name Id Description
- ---- ------------------------------------ -----------
1 Test 84744b22-0e2e-4342-b6ab-6658ff0e54ec (empty)
```
Запрашиваем список flow из бакета 84744b22-0e2e-4342-b6ab-6658ff0e54ec:
```
./cli.sh registry list-flows -b 84744b22-0e2e-4342-b6ab-6658ff0e54ec -p ../conf/reg.properties
```
Получаем вывод:
```
# Name Id Description
- ------------------ ------------------------------------ ------------------
1 PG versioning test bc9a3ff4-2d9c-44b0-bd8e-d86b51d3bac6 PG versioning test
```
Запрашиваем список версий интересующего flow:
```
./cli.sh registry list-flow-versions -f bc9a3ff4-2d9c-44b0-bd8e-d86b51d3bac6 -p ../conf/reg.properties
```
Получаем вывод:
```
Ver Date Author Message
--- -------------------------- --------- ------------------
1 Thu, Apr 22 2021 09:28 UTC nifiAdmin PG versioning test
```
Закидываем flow в целевой (продуктовый) NiFi:
```
./cli.sh nifi pg-import -b 84744b22-0e2e-4342-b6ab-6658ff0e54ec -f bc9a3ff4-2d9c-44b0-bd8e-d86b51d3bac6 -fv 1 -p ../conf/nifi-prod.properties
```
Получаем вывод:
```
f90df705-0178-1000-04fe-45ba27e76f99
```
Вывод - это ID process group в целевом (продуктовом) NiFi:
### Вместо заключения
Лукавить не стану, записал этот HowTo в первую очередь для себя по горячим следам. Чтобы раскурить всю последовательность и логику шагов по настройке, пришлось потратить уйму времени, перечитать километры форумов (особенно, когда у меня NiFi не видел список бакетов в Registry), включить режим логирования "TRACE" в NiFi и в NiFi Registry и просканировать еще десятки километров логов. Вот очень не хотелось собирать эту головоломку еще раз, поскольку пройдет месяц и уже и не вспомнишь, что и как делал.
Что касается именно CI/CD, то я не стал рисовать всю цепочку. У каждого свои паттерны и сценарии, да и сам пайплайн был бы оффтопиком. А приведенный пример NiFi Cli, считаю, неплохая отправная точка для реализации собственной схемы доставки.
Спасибо всем, кто дочитал и, надеюсь, текст оказался полезным. | https://habr.com/ru/post/553756/ | null | ru | null |
# Анонс Rust 1.0
Сегодня мы с гордостью представляем [релиз Rust версии 1.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-100-may-2015), нового языка программирования для создания более надёжных и эффективных систем. **Раст объединяет в себе низкоуровневый контроль над производительностью с удобством и гарантиями безопасности языков высокого уровня.** Лучше того, он при этом не требует сборщика мусора или среду выполнения, так что библиотеками на Расте [можно безболезненно заменять библиотеки на C](http://habrahabr.ru/post/257687/) ([англ.](http://blog.rust-lang.org/2015/04/24/Rust-Once-Run-Everywhere.html)). Если вы хотите поэкспериментировать с Растом, лучше всего начать с [раздела «Getting Started» книги Rust Book](http://doc.rust-lang.org/1.0.0-beta.5/book/getting-started.html) (если вы предпочитаете читать с электронных книг, Паскаль Хертлиф (Pascal Hertleif) поддерживает [неофициальные версии этой книги в электронном виде](http://killercup.github.io/trpl-ebook/)).
Что отличает Раст от других языков, так это его система типов, основанная на улучшенном и кодифицированном своде лучших практик, отработанных поколениями программистов на C и C++. Так что Расту есть что предложить как опытным системных программистам, так и новичкам: опытные разработчики оценят сэкономленное на отладке время, а новичкам придётся по вкусу возможность писать низкоуровневый код, не беспокоясь о мелких ошибках, которые приводят к необъяснимым падениям их программ.
#### Что значит для Раста релиз 1.0?
Текущая версия Раста — результат множества итераций и экспериментов. Такой процесс разработки прекрасно нам послужил: Раст сейчас намного проще и мощнее, чем мы изначально представляли. Но из-за всех этих экспериментов поддерживать проекты, написанные на Расте, было очень сложно, так как язык и стандартная библиотека постоянно менялись.
**Релиз версии 1.0 означает, что этому беспорядку пришёл конец.** Этот релиз — официальное [начало нашему пути к поддержанию стабильности](http://habrahabr.ru/post/243315/) ([англ.](http://blog.rust-lang.org/2014/10/30/Stability.html)). Начиная с этого момента изменения, ломающие совместимость, будут за пределами стабильной версии (за исключением [некоторых вещей](https://github.com/rust-lang/rfcs/pull/1105), вроде багов в компиляторе).
Учитывая сказанное, релиз 1.0 не означает, что язык Раст «завершён». У нас в запасе [множество улучшений](http://internals.rust-lang.org/t/priorities-after-1-0/1901). На самом деле, ночные сборки уже содержат [улучшения](https://github.com/rust-lang/rust/pull/24965) [в скорости](https://github.com/rust-lang/rust/pull/24615) [компиляции](https://github.com/rust-lang/rust/pull/25323) (а их будет ещё больше) и включают новые API и фичи языка, такие, как [`std::fs`](https://github.com/rust-lang/rfcs/pull/1044) и [ассоциированные константы](https://github.com/rust-lang/rust/pull/23606/).
Чтобы быть уверенными, что улучшения в компиляторе и языке входят в экосистему как можно более полно и быстро, мы решили использовать [train-based модель релизов](http://blog.rust-lang.org/2014/12/12/1.0-Timeline.html). Это означает, что мы будем выпускать регулярные релизы каждые шесть недель, как это делают команды Firefox и Chrome. **Чтобы начать этот процесс, мы также выпускаем бета-релиз Раста 1.1 — одновременно со стабильным релизом 1.0.**
#### Cargo и crates.io
Создание настоящего проекта — это не только написание кода, это ещё и управление зависимостями. [Cargo](http://blog.rust-lang.org/2014/11/20/Cargo.html) — пакетный менеджер и система сборки Раста — создан, чтобы облегчить эту задачу. С использованием Cargo скачивание и установка новых библиотек проста настолько же, насколько просто добавить новую строчку в файл манифеста.
Конечно, чтобы использовать зависимость, её нужно сначала найти. Здесь появляется [crates.io](https://crates.io/) — центральный репозиторий пакетов Раста. С его помощью очень просто и искать чужие пакеты, и публиковать свои.
С момента [анонсирования cargo и crates.io](http://blog.rust-lang.org/2014/11/20/Cargo.html) — месяцев шесть назад — число пакетов стабильно растёт. Однако сейчас мы в самом начале пути, так что есть ещё много замечательных пакетов, которые нужно написать. Если вам интересно создавать новые библиотеки, которые потрясут мир Раста — сейчас самое время!
#### Открытые и исходники, и управление
Раст был open-source проектом с самого начала. Последние несколько лет мы постоянно искали способы сделать наше руководство более открытым и управляемым сообществом. С тех пор, как мы ввели [процесс RFC](https://github.com/rust-lang/rfcs/blob/master/README.md), чуть больше года назад, все основные решения по поводу Раста записываются и обсуждаются открыто. Недавно мы приняли [новую модель управления](https://github.com/rust-lang/rfcs/pull/1068), которая состоит в разделении на подкоманды, каждая из которых будет отвечать за RFC в своей определённой области. Если вы хотите помочь определить будущее Раста, мы будем рады любому вашему участию: загружайте библиотеки на [crates.io](https://crates.io), комментируйте RFC, или [пишите сам код Раста](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md).
Мы бы хотели выразить особую благодарность следующим людям, каждый из которых привнёс свой вклад с момента нашего предыдущего релиза ([полный список контрибуторов здесь](https://github.com/rust-lang/rust/blob/master/AUTHORS.txt)):
* Aaron Gallagher <\_@habnab.it>
* Aaron Turon
* Abhishek Chanda
* Adolfo Ochagavía
* Alex Burka
* Alex Crichton
* Alex Quach
* Alexander Polakov
* Andrea Canciani
* Andreas Martens
* Andreas Tolfsen
* Andrei Oprea
* Andrew Paseltiner
* Andrew Seidl
* Andrew Straw
* Andrzej Janik
* Aram Visser
* Ariel Ben-Yehuda
* Augusto Hack
* Avdi Grimm
* Barosl Lee
* Ben Ashford
* Ben Gesoff
* Björn Steinbrink
* Brad King
* Brendan Graetz
* Brett Cannon
* Brian Anderson
* Brian Campbell
* Carlos Galarza
* Carol (Nichols || Goulding)
* Carol Nichols
* Chris Morgan
* Chris Wong
* Christopher Chambers
* Clark Gaebel
* Cole Reynolds
* Colin Walters
* Conrad Kleinespel
* Corey Farwell
* Dan Callahan
* Dave Huseby
* David Reid
* Diggory Hardy
* Dominic van Berkel
* Dominick Allen
* Don Petersen
* Dzmitry Malyshau
* Earl St Sauver
* Eduard Burtescu
* Erick Tryzelaar
* Felix S. Klock II
* Florian Hahn
* Florian Hartwig
* Franziska Hinkelmann
* FuGangqiang
* Garming Sam
* Geoffrey Thomas
* Geoffry Song
* Gleb Kozyrev
* Graydon Hoare
* Guillaume Gomez
* Hajime Morrita
* Hech
* Heejong Ahn
* Hika Hibariya
* Huon Wilson
* Igor Strebezhev
* Isaac Ge
* J Bailey
* Jake Goulding
* James Miller
* James Perry
* Jan Andersson
* Jan Bujak
* Jan-Erik Rediger
* Jannis Redmann
* Jason Yeo
* Johann
* Johann Hofmann
* Johannes Oertel
* John Gallagher
* John Van Enk
* Jonathan S
* Jordan Humphreys
* Joseph Crail
* Josh Triplett
* Kang Seonghoon
* Keegan McAllister
* Kelvin Ly
* Kevin Ballard
* Kevin Butler
* Kevin Mehall
* Krzysztof Drewniak
* Lee Aronson
* Lee Jeffery
* Liam Monahan
* Liigo Zhuang
* Luke Gallagher
* Luqman Aden
* Manish Goregaokar
* Manuel Hoffmann
* Marin Atanasov Nikolov
* Mark Mossberg
* Marvin Löbel
* Mathieu Rochette
* Mathijs van de Nes
* Matt Brubeck
* Michael Alexander
* Michael Macias
* Michael Park
* Michael Rosenberg <42micro@gmail.com>
* Michael Sproul
* Michael Woerister
* Michael Wu
* Michał Czardybon
* Mickaël Salaün
* Mike Boutin
* Mike Sampson
* Ms2ger
* Nelo Onyiah
* Nicholas
* Nicholas Mazzuca
* Nick Cameron
* Nick Hamann
* Nick Platt
* Niko Matsakis
* Oak
* Oliver Schneider
* P1start
* Pascal Hertleif
* Paul Banks
* Paul Faria
* Paul Quint
* Pete Hunt
* Peter Marheine
* Phil Dawes
* Philip Munksgaard
* Piotr Czarnecki
* Piotr Szotkowski
* Poga Po
* Przemysław Wesołek
* Ralph Giles
* Raphael Speyer
* Remi Rampin
* Ricardo Martins
* Richo Healey
* Rob Young
* Robin Kruppe
* Robin Stocker
* Rory O’Kane
* Ruud van Asseldonk
* Ryan Prichard
* Scott Olson
* Sean Bowe
* Sean McArthur
* Sean Patrick Santos
* Seo Sanghyeon
* Shmuale Mark
* Simon Kern
* Simon Sapin
* Simonas Kazlauskas
* Sindre Johansen
* Skyler
* Steve Klabnik
* Steven Allen
* Swaroop C H
* Sébastien Marie
* Tamir Duberstein
* Tero Hänninen
* Theo Belaire
* Theo Belaire
* Thiago Carvalho
* Thomas Jespersen
* Tibor Benke
* Tim Cuthbertson
* Tincan
* Ting-Yu Lin
* Tobias Bucher
* Toni Cárdenas
* Tshepang Lekhonkhobe
* Ulrik Sverdrup
* Vadim Chugunov
* Vadim Petrochenkov
* Valerii Hiora
* Wangshan Lu
* Wei-Ming Yang
* Will
* Will Hipschman
* Wojciech Ogrodowczyk
* Xue Fuqiao
* Xuefeng Wu
* York Xiang
* Young Wu
* bcoopers
* critiqjo
* diwic
* fenduru
* gareins
* github-monoculture
* inrustwetrust
* jooert
* kgv
* klutzy
* kwantam
* leunggamciu
* mdinger
* nwin
* pez
* robertfoss
* rundrop1
* sinkuu
* tynopex
* Łukasz Niemier
* らいどっと | https://habr.com/ru/post/258069/ | null | ru | null |
# Please come back to me in Casablanca
Несколько недель назад Microsoft презентовал свою новую разработку — проект Casablanca. Для того, чтобы понять что это, нужно вернуться еще чуть дальше в прошлое, к прошедшей конференции [Going Native 2012](http://www.google.com.ua/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CE4QFjAA&url=http%3A%2F%2Fchannel9.msdn.com%2FEvents%2FGoingNative%2FGoingNative-2012&ei=i4HGT4DeEYOa-wbRyqGmBQ&usg=AFQjCNHor1wTqiM_0l4Hk6DyPCWew8NmDg), где помимо обсуждения нового стандарта С++11 было сказано еще немало умных мыслей. Одна из них была в лекции Херба Саттера. Он заметил, что самой большой проблемой современного С++ является не всякие там сборщики мусора или синтаксис лямбда-выражений, а бедность стандартной библиотеки. Когда начинающий программист на Java или C# спрашивает у своего старшего коллеги, как ему послать\принять HTTP-запрос, распарсить XML\JSON, заархивировать\разархивировать ZIP-файл и т.д. — он получает конкретный, однозначный и работающий всегда ответ: «используй вот этот класс из стандартной библиотеки». Когда начинающий программист на С++ задаёт тот же вопрос — он слышит «ну, стандартных средств для этого нет, нужно или самому писать или вот есть какие-то библиотеки, но тут надо выбирать, тестировать, читать лицензии...». В результате мы имеем дикий зоопарк библиотек с разным уровнем производительности, часто паршивенькой кроссплатформенностью, кучу самописных велосипедов, трудности в переходе между проектами, потому что «раньше я использовал boost, а тут в проекте всё на Qt» и т.д. Херб Саттер высказал мысль, что основное, на чём следует сосредоточиться — это расширение стандартной библиотеки.
Так вот, Microsoft Casablanca — это первый набросок того, как это расширение могло бы выглядеть, что в него могло бы входить и как оно всё вместе могло бы работать. Никто пока не говорит о стандартизации Casablanca как расширения стандартной библиотеки С++, но уже сейчас его можно скачать в виде отдельной библиотеки (что-то вроде альфа-версии) и попробовать поизучать. Кроме того, Microsoft пропагандирует Casablanca как средство создания производительных сервисов для платформы Azure.
Итак, что же входит в Casablanca? Давайте я сразу покажу «Hello world» на Casablanca — это будет веб-сервер, возвращающий текст «Hello World!» на любой запрос к нему:
```
#include "stdafx.h"
#include
#include "astreambuf.h"
using namespace http::listener;
int main(int argc, char\* argv[])
{
http\_listener::create("http://localhost:4711/trivial", [](http\_request message)
{
message.reply(http::status\_codes::OK, "Hello World!");
})
/\* Prevent Listen() from returning until user hits 'Enter' \*/
.listen([]() { fgetc(stdin); }).wait();
return 0;
}
```
Красиво, правда?
А теперь чуть более полно о библиотеке. В неё входят следующие вещи:
#### PPL tasks
Это библиотека для работы с асинхронными операциями, которая, вообще-то входит в следующую (еще не вышедшую) версию Visual Studio, но разработчики Casablanca решили выделить её отдельно и дать возможность использовать и в Visual Studio 2010. Работает это дело примерно так:
```
http::http_client client("http://localhost:80");
pplx::task resp = client.request(methods::GET, "/foo.html");
```
Здесь мы создали http-клиент для обращения к localhost:80 и задачу «а дай-ка мне методом GET страницу foo.html». Задача начинает выполнятся асинхронно, начиная с момента создания. В любой момент времени мы можем сросить задачу, выполнилась ли она уже:
```
bool done = resp.is_done();
```
и попросить результат выполнения:
```
http_response response = resp.get();
```
Второй вариант — сразу передать задача лямбда-функцию, которая будет выполнена по её завершению:
```
resp.then(
[=](http_response response)
{
...
});
```
Больше о PPL tasks [тут](http://msdn.microsoft.com/en-us/library/dd492427%28v=vs.110%29.aspx)
#### HTTP клиенты и сервера
Два примера выше объясняют вкратце и то, и другое. Добавить к этому можно разве что наличие специальных классов для адресов, заголовков и прочих удобностей. В общем, работа с HTTP становится не сложнее C# или Java, и уж во всяком случае, намного приятнее, чем при использовании входящей нынче в состав Windows библиотека WinInet.
#### Доступ к Azure Storage Services
Я уже говорил, что одна из основных целей — облегчить создание приложений для Azure. Вот как выглядит процесс сохранения данных в Azure Storage Services
```
storage_credentials creds = local_storage::get_credentials();
cloud_blob_client local(local_storage::get_blob_uri(), local_storage::get_credentials());
cloud_blob_client real("http://johndoe.blob.core.windows.net", creds);
cloud_blob_container container = client.create_container(L"sampledata").get();
auto blob = container.create_block_blob(L"sample1");
blob.put(L"A first sample blob", L"text/plain");
```
Весьма лаконично, мне кажется.
#### JSON
##### Разбор
```
std::istream stream = ...;
json::value value1(stream);
double var = value1["var"].as_double()
```
##### Создание
```
json::value::element_vector e;
e.push_back(json::value(false));
e.push_back(json::value::string("hehe"));
json::value arr = json::value::array(e);
std::ostream stream = ...;
stream << arr;
```
#### Actors
Идея взята из Erlang. Посылка и обработка сообщений, как дополнительный слой изоляции от внешнего мира. Позволяет проще смотреть на некоторые вещи, избегать багов в многопоточном программировании и вообще есть хорошим паттерном. В примере ниже создаётся Actor, который умеет принимать сообщение и писать его в стандартный вывод.
```
class Hello : public actors::actor
{
public:
Hello() {}
actors::actor *factory() { new Hello(); }
protected:
void initialize(actors::ActorInitEvent e) { }
virtual void execute() {
std::string name;
accept(name).then([=](std::string &name) {
std::cout << "Hello, " << name << "!" << std::endl;
Done();
});
}
};
...
PID h = actor::spawn();
h.send("Niklas");
```
Библиотека еще в разработке и пока очень сырая. Лично мне трудно судить, насколько она приживется. На первый взгляд всё весьма культурно и логично. Архитектура проектировалась с мыслью о кросплатформенности, API открыт, есть стремление открыть код и добавить много полезных вещей. С другой стороны от «просто хорошей библиотеки» до «расширения стандартной библиотеки С++» пропасть шириной до горизонта. В любом случае, ради интереса на Касабланку можно посмотреть.
#### Материалы по теме
* [Casablanca на MSDN](http://msdn.microsoft.com/en-us/devlabs/hh974325)
* [FAQ](http://msdn.microsoft.com/en-us/devlabs/hh975439)
* [Документация](http://msdn.microsoft.com/en-us/devlabs/hh977175.aspx)
* [Примеры](http://go.microsoft.com/fwlink/?LinkId=249447) | https://habr.com/ru/post/144925/ | null | ru | null |
# Что такое AXON
[AXON](http://intellimath.bitbucket.org/axon) — это нотация для сериализованного представления объектов, документов и данных в текстовой форме. Она объединяет в себе *простоту* [JSON](http://www.json.org), *расширяемость* [XML](http://www.w3.org/xml) и *удобочитаемость* [YAML](http://www.yaml.org).
Есть проект [pyaxon](http://pypi.python.org/pypi/pyaxon) на [python](http://python.org), с которым можно "поиграться". Впрочем, он создавался таким образом, чтобы не сильно уступать по скорости с модулем [json](http://docs.python.org/3.5/library/json.html). Поэтому он может сгодиться и для реальных дел.
#### Зачем AXON?
`AXON` появился как попытка справиться с недостатками или неудобствами `JSON` и `XML`, но сохранить при этом их достоинства и возможности, дополнительно добавив удобочитаемость, присущую `YAML`.
#### AXON содержит "улучшенный" вариант JSON
**1.** `JSON` имеет два неудобства:
* имена атрибутов/ключей, которые являются идентификаторами приходится заключать в кавычки;
* легко забыть запятую в случае вставки новой пары *ключ: значение*.
`AXON` устраняет эти неудобства следующим образом:
* *можно не заключать* в кавычки имена, которые являются *идентификаторами*;
* совершенно *опускаются* разделительные *запятые*, используются только пробельные символы для разделения элементов.
В результате получается более компактное представление и удобство восприятия при форматировании.
Для сравнения:
**`JSON`**
```
{ "name": "Alex",
"birth": "1979-12-25",
"email": "mail@example.com"}
[ "Alex"
"1979-12-25"
"mail@example.com"]
```
**`AXON`**
```
{ name: "Alex"
birth: ^1979-12-25
email: "mail@example.com"}
[ "Alex"
^1979-12-25
"mail@example.com"]
```
**2.** В `JSON` не гарантируется, что после загрузки
```
{ "name": "Alex",
"birth": "1979-12-25",
"email": "mail@example.com"}
```
порядок ключей/атрибутов сохранится.
В `AXON` констатируется, что
```
{ name: "Alex"
birth: ^1979-12-25
email: "mail@example.com"}
```
преобразуется в `mapping` *без сохранения* порядка ключей.
В то же время констатируется, что
```
[ name: "Alex"
birth: ^1979-12-25
email: "mail@example.com"]
```
преобразуется в `mapping` *с сохранением* порядка ключей.
**3.** `AXON` поддерживает синтаксиc для представления даты и времени в `ISO`-подобном формате:
* даты
```
^2010-12-31
```
* времени
```
^12:30
^12:30:15
^12:30+03:00
^12:30:15-04:30
```
* даты и времени
```
^2010-12-31T12:30
^2010-12-31T12:30:05.0125
^2010-12-31T12:30+04:00
^2010-12-31T12:30:05.0123-04:00
```
а также для представления десятичных чисел:
```
1D 123456789D
3.14D 1.23e-6D
```
**4.** `AXON` также позволяет определять *метки* неатомарных значений и использовать их в качестве внутренних *ссылок*. Это позволяет при необходимости не создавать копии многократно используемых неатомарных значений при сериализации/десериализации.
Например:
```
[ { prev: &a (2012-12-30 10:00)
next: &c (2012-01-01 12:00) }
{ prev: &b (2012-12-31 13:00)
next: *a }
{ prev: *c
next: *b } ]
```
Метка имеет префикс `&` (`&a &b &c`), а ссылка имеет префикс `*` (`*a *b *c`).
#### Модель данных AXON содержит вариант модели Infoset XML в более компактной нотации
Рассмотрим иллюстративный пример `XML` представления структурированных данных:
```
John Smith
25
21 2nd Street
New York
NY
212-555-1234
```
`AXON` реализует идею более простого синтаксиса для представления `XML` структурированных данных:
```
person {
name {"John Smith"}
age {25}
address {
type: "home"
street {"21 2nd Street"}
city {"New York"}
state {"NY"}
}
phone {type:"home" "212-555-1234"}
}
```
Представление в формате `AXON` можно построить из формата `XML` за 5 шагов:
1. Заменить на `tag {`
2. Заменить на `}`
3. Заменить `attr=value` на `attr: value`
4. Текст внутри элементов заключить в двойные кавычки (`"`)
5. Удалить символ запятой (`,`) или заменить его на один пробел
Результат такого преобразования структурно идентичен первоначальному `XML` документу. По-существу это синтаксически более компактная форма представления `XML` документа.
Для сравнения также приведем представление в `AXON` с форматированием сложных элементов без {} с использованием принципа одинакового отступа для подэлементов структуры:
```
person
name {"John Smith"}
age {25}
address
type: "home"
street {"21 2nd Street"}
city {"New York"}
state {"NY"}
phone
type: "home"
"212-555-1234"
```
Это представление получается из предыдущего удалением всех символов { и }, а также ненужных пустых строк.
#### AXON расширяет возможности XML и JSON
В `XML` атрибуты могут иметь только простые значения, в `AXON` значением атрибута может любое значение (как и в `JSON`). Кроме того простые значения имеют тип (*текст* в формате `unicode`, *число*, *десятичное число*, *дата* и *время*, *массив байтов* в кодировке *base64*). `AXON` можно рассматривать как расширение `JSON` в том смысле, что объекты могут именованными, так же как и элементы `XML` являются именованными.
Например:
```
person
name: "John Smith"
age: 25
burn: 1975-10-21
locations: [
address
type: "home"
street: "21 2nd Street"
city: "New York"
state: "NY"
]
contacts: [
phone
type: "home"
"212-555-1234"
email
type: "personal"
"mail@example.com"
]
```
В `JSON` есть одно неудобство, связанное с представлением нерегулярных структур, в которых существенен порядок частей. В таких структурах доступ к элементам осуществляется в результате последовательного поиска по имени, а не в результате "прямого" доступа по имени.
В качестве примера рассмотрим структурированный документ в формате `XML`:
```
paragraph
item text
paragraph
item text
paragraph
```
Непосредственно, без преобразования структуры этот документ не транслируется в `JSON` из-за важности порядка и повторяемости элементов. Один вариант трансляции, который эмулирует последовательность именованных элементов имеет вид:
```
{
"tag": "section",
"@": {"title": "Title"},
"*": [
{ "tag": "par",
"@": {"style":"normal", "text":"paragraph"}},
{ "tag":"enumerate",
"@": {"style": "enumerate"},
"*": [
{ "tag":"item",
"@": {"text":"item text"}}
]
},
{ "tag": "par", "@": {"style":"normal", "text":"paragraph"}},
{ "tag":"itemize",
"*": [
{ "tag":"item", "@": {"text":"item text"}}
]
},
{ "tag": "par", "@": {"style":"normal", "text":"paragraph"}}
]
}
```
В `AXON` такие структуры транслируются "один в один":
```
section
title: "Title"
par
style: "normal"
"paragraph"
enumerate
style: "enum"
item { "item text" }
par
style: "normal"
"paragraph"
itemize
style: "itemize"
item { "Item text" }
par
style: "normal"
"paragraph"
```
### AXON поддерживает форматирование в стиле YAML
Привлекательной стороной `YAML` является формат представления в стиле `wiki`. `AXON` также поддерживает подобный стиль форматирования.
Например, для сравнения:
* форматирование без {} (`YAML`-стиль)
```
person
name: "Alex"
age: 25
```
* форматирование с {} и отступами (`C/JSON`-стиль)
```
person {
name: "Alex"
age: 25}
```
* компактный формат
```
person{name:"Alex" age:25}
```
### AXON может представлять серию объектов
Одно из ограничений `JSON` и `XML` связано с тем, что они представляют единственный корневой объект. Напротив, `AXON` представляет серию объектов или серию пар `ключ`:`объект`, которые можно загружать по одному. Например:
* серия объектов
```
{ name: "Alex"
age: 32 }
{ name: "Michael"
age: 28 }
{ name: "Nick"
age: 19 }
```
* серия объектов с ключами
```
alex: {
message: "Hello"
datetime: ^2015-07-12T12:32:35
}
michael: {
message: "How are you"
datetime: ^2015-07-12T12:32:35
}
``` | https://habr.com/ru/post/304516/ | null | ru | null |
# Цифровая фильтрация на ПЛИС – Часть 2
Всем привет!
Это вторая публикация на тему «Цифровая фильтрация на ПЛИС». Вторая часть будет посвящена практической реализации КИХ фильтров на FPGA. В процессе подготовки материала я понял, что она раздуется до небывалых размеров, но делить ее на несколько частей не хочется. Поэтому все тонкости теории и синтеза FIR фильтров будут в одной статье, разбитой на взаимосвязанные разделы. Начну обзор с теоретической части, в частности — расскажу об особенностях и методах расчета коэффициентов фильтров. Подробно рассмотрю создание КИХ фильтров в различных средах — MATLAB, CoreGENERATOR, Vivado HLS. Всех заинтересовавшихся прошу под кат.
#### Часть 2. КИХ фильтр
#### **Теория**
Рассмотрим простой пример реализации FIR фильтров. Как известно, существует два больших класса фильтров — БИХ, с **бесконечной импульсной характеристикой** и КИХ, с **конечной импульсной характеристикой**. Остановимся на втором типе: КИХ фильтрах (англ. FIR — «finite impulse response»). КИХ фильтр — это линейный цифровой фильтр, основной особенностью которого является ограниченность во времени его импульсной характеристики, то есть с определенного момента времени она становится равной нулю. Как правило, большинство КИХ фильтров выполнено без обратной связи, поэтому практически все КИХ фильтры — нерекурсивные.
Вот так выглядит реализация КИХ фильтра в общем виде, в частности — на ПЛИС.
Все КИХ-фильтры описываются следующими уравнениями:
где **y(n)** — выходной сигнал (функция текущего и прошедших значений на входе), **x(n)** — входное воздействие, **h(k)** — коэффициенты импульсной характеристики, **N** — длина фильтра (количество коэффициентов фильтра), **H(z)** — передаточная характеристика фильтра.
*В чем секрет КИХ фильтров?*
Самая важная особенность КИХ фильтров заключается в возможности получения точной линейной фазовой характеристики. У читателя возникает закономерный вопрос — «а зачем это надо?». Остановимся на этом моменте подробнее. Сигнал подвергается различным преобразованиям при прохождении через фильтр. В частности, изменяются амплитуда и фаза сигнала в зависимости от частотной характеристики фильтра (амплитудной, АЧХ и фазовой, ФЧХ). Для многочастотных сигналов недопустимо, чтобы при прохождении блоков обработки, фаза сигнала искажалась. Причем, если АЧХ в полосе пропускания сделать практически постоянной не составляет труда, то с ФЧХ возникают проблемы. Для оценки искажений фазы удобно ввести понятия фазовой и групповой задержек.
Фазовая задержка — это величина задержки для каждой из частотных компонент сигнала. Определяется как угол сдвига фазы, деленный на частоту. Групповая задержка — это средняя временная задержка всего многочастотного сигнала. Определяется как производная фазы по частоте. Математически фазовая и групповая задержки записываются следующим образом:
Из формулы для групповой задержки становится очевидно условие линейности ФЧХ фильтра. Если ФЧХ — линейна, то групповая задержка после взятия производной равна константе, то есть постоянна для всех частотных компонент. Логично, что фильтр с нелинейной ФЧХ будет вносить искажения в фазу сигнала.
Таким образом, линейность фазовой характеристики — одна из важнейших особенностей КИХ-фильтров. Остановимся на изучении этого класса фильтров.
#### **КИХ фильтры с линейной ФЧХ**
Для обеспечения линейности ФЧХ необходимо выполнение **условия симметрии** импульсной характеристики (или коэффициентов) фильтра. Проще говоря, КИХ фильтр с линейной ФЧХ — симметричен. Существует 4 типа фильтров, отличающихся четностью порядка фильтра N и типом симметрии (положительная или отрицательная). Например, для фильтров с отрицательной симметрией можно получить сдвиг фазы на 90o. Такие фильтры используются для проектирования дифференциаторов и преобразования Гильберта. Огибающая импульсной характеристики КИХ фильтра строится по закону **~sin(x)/x** независимо от типа фильтра (ФНЧ, ФВЧ, ПФ, РФ, дифференциатор). Для решения практических задач зачастую не приходится задумываться о том, какого типа фильтр выбран. Доказательство условия симметрии коэффициентов приводить не буду, но любопытный читатель может найти его сам в различной литературе, ссылки на которую я привожу в конце статьи.
#### **Проектирование КИХ фильтров**
Под «расчетом FIR фильтра» в большинстве случаев понимают поиск его коэффициентов по значениям частотной характеристики. Не могу припомнить случаев, когда решалась бы обратная задача за исключением академического интереса.
При создании нового цифрового КИХ фильтра любой инженер проходит через определенные стадии разработки\*:
* **Спецификация фильтра**. Задается тип фильтра (ФНЧ, ФВЧ, полосовой, режекторный), количество коэффициентов N, требуемая частотная характеристика, с допусками на нелинейность в полосе затухания и полосе пропускания и т. д.
* **Вычисление коэффициентов**. Любыми доступными способами и средствами вычисляются коэффициенты фильтра, удовлетворяющие спецификации из предыдущего пункта.
* **Анализ следствий конечной разрядности**. На этом этапе оценивается влияние эффектов квантования на коэффициенты фильтра, промежуточные и выходные данные.
* **Реализация**. На этой стадии происходит разработка фильтра на доступном языке программирования или реализация фильтра путем создания готовых IP-ядер.
\* — этапы разработки могут быть несколько иными, но суть всегда остается та же.
**Спецификация фильтра**
На этой стадии инженер производит поиск компромиссных решений для реализации требуемого фильтра с нужными параметрами. Их немного, но часто приходится жертвовать одним параметром для достижения требуемых значений по другим величинам.
* **Apass** — неравномерность в полосе пропускания,
* **Astop** — уровень затухания в полосе подавления,
* **Fpass** — граничная частота полосы пропускания,
* **Fstop** — граничная частота полосы затухания,
* **N** — порядок фильтра (количество коэффициентов фильтра).
На практике, параметры Apass и Astop задают в децибелах (дБ), а расстояние между Fpass и Fstop выражает ширину полосы перехода фильтра. Логично, что значение Apass должно быть как можно меньше, Apass как можно больше, а отношение Fpass/Fstop в идеале стремится к единице (идеально прямоугольная АЧХ). Количество коэффициентов не зря вносится в спецификацию фильтра. Как будет показано далее, от порядка фильтра N и разрядности коэффициентов зависят параметры частотной характеристики фильтра, а также объем занимаемых ресурсов ПЛИС.
**Вычисление коэффициентов фильтра**
На эту тему можно написать несколько книг и научных статей, но в рамках данной статьи рассматривать подробно все методы не будем. Существует множество методов расчета коэффициентов фильтра — метод взвешивания оконными функциями, метод частотной выборки, различные оптимальные (по Чебышеву) методы с применением алгоритма Ремеза и т.д. Все методы уникальны по своим особенностям и дают те или иные результаты. Для метода оконного взвешивания негативным проявлением становится **эффект Гиббса**, вносящий неравномерность и выбросы в частотную характеристику фильтра между рассчитанными точками функции. Бороться с ним можно бесконечно, но на практике вводят допуски по неравномерностям в полосе пропускания и полосе подавления.
Основным методом расчета коэффициентов для многих фильтров является модифицированный алгоритм Ремеза — «**[Parks-McClellan algorithm](https://en.wikipedia.org/wiki/Parks—McClellan_filter_design_algorithm)**». По своей сути это косвенный итерационный метод для нахождения оптимальных значений с Чебышевской характеристикой фильтра. Особенность метода заключается в минимизации ошибки в полосе затухания и пропускания путем Чебышевской аппроксимации импульсной характеристики. Вполне логично, что чем больше количество коэффициентов, тем меньше неравномерность АЧХ и тем она прямоугольнее.
От выбора метода зависит конечный результат, но все они сводятся к одним и тем же целям — минимизации выбросов в полосе пропускания и увеличении «прямоугольности» АЧХ.
**Анализ следствий конечной разрядности**
*Разрядность коэффициентов* — главный фактор, от которого зависит вид частотной характеристики. В современных ПЛИС разрядность коэффициентов может быть выбрана любой, но разумные цифры лежат в пределах от 16 до 27 битов. Для высоких порядков фильтра часто требуется обеспечить большой динамический диапазон разрядной сетки, но если этого не удается сделать, рано или поздно начинают проявляться ошибки квантования. Из-за ограниченной разрядности коэффициентов модифицируется частотная характеристика, а в некоторых случаях она искажается настолько сильно, что приходится жертвовать параметрами из частотной спецификации для достижения приемлемого результата. Так или иначе, разрядность представления коэффициентов прямо влияет на максимально возможное затухание Astop. Поэтому при использовании слишком ограниченной разрядной сетки коэффициентов, порой невозможно достичь желаемого подавления даже при огромных порядках фильтра!
Разрядность промежуточных данных и арифметическое переполнение — факторы, от которых также зависит вид частотной характеристики и результат на выходе фильтра. Во многих ПЛИС проблема устраняется использованием аккумуляторов большой разрядности в блоках DSP. Например, в ПЛИС Xilinx 6 и 7 серии в ячейках DSP48E1 используются 48-битные аккумуляторы и перемножители. На следующем рисунке представлен стандартный блок DSP48E1, на котором реализуются КИХ фильтры.
Встроенные DSP блоки современных ПЛИС выполнены таким образом, чтобы максимально удобно проводить задачи ЦОС. В первую очередь — для реализации FIR фильтров.
**Реализация**
Для реализации простейших фильтров требуется совсем немного логических операций. Основной узел, с помощью которого реализуется FIR фильтр — DSP блок ПЛИС. В этом блоке происходят все математические операции — перемножение входных отсчетов с коэффициентами фильтров, задержка входного сигнала, суммирование данных. Современные узлы DSP содержат предварительный сумматор, поэтому даже операции суммирования для фильтров с симметричной ИХ можно делать внутри этого узла. Помимо DSP блока, фильтру нужна память для хранения коэффициентов (распределенная или блочная). Больше фильтр ничего не использует. На рисунке приведена реализация КИХ фильтра с использованием перемножителей, аккумуляторов, линий задержки и памяти для хранения коэффициентов.
#### **Расчет фильтра в MATLAB**
Существует множество приложений, в которых можно проводить расчет фильтра и поиск его коэффициентов. Например, LABView, Scope FIR, FDATool из MATLAB или бесплатного аналога Octave. Пожалуй, самым удобным средством расчета КИХ фильтра является MATLAB. Для запуска средства создания и анализа фильтров необходимо в командном окне среды набрать ключевое слово **fdatool**. Появится примерно вот такое окно (в зависимости от версии MATLAB оно может иметь чуть иной вид):
Основные параметры задаются в окне **Filter Specifications**. В зависимости от настроек фильтра в области главного окна могут появляться те или иные параметры.
* **Filter Order** — определяет порядок фильтра (минимальный или заданный пользователем)\*\*.
* **Frequency Specifications** — определяет частотные параметры характеристики фильтра.
* **Magnitude Specifications** — определяет амплитудные параметры характеристики фильтра.
* **Density Factor** — для типа Equiripple задает сетку точек, по которым происходит аппроксимация АЧХ фильтра.
\*\* — в FDATool порядок фильтра N на единицу больше заданного (если задать N = 7, то утилита рассчитывает 8 коэффициентов)!!!
**Response type** — тип передаточной характеристики фильтра. В этом поле выбирается любой фильтр, какой только существует в природе, например:
* **Lowpass** — фильтр нижних частот,
* **Raised cosine** — фильтр «приподнятого косинуса»,
* **Highpass** — фильтр верхних частот,
* **Bandpass** — полосовой фильтр,
* **Bandstop** — режекторный (заграждающий) фильтр,
* **Differentiator** — дифференциатор,
* **Nyquist** — фильтр Найквиста,
* **Multiband** — многополосный фильтр,
* **Hilbert transformer** — преобразователь Гильберта,
* **Arbitrary magnitude** — фильтры с произвольной АЧХ.
и т.д.
Причем, в зависимости от типа фильтра, средство анализа укажет на ограничения по типу фильтра и предложит ввести корректное значение N.
**Design Method** — выбирается метод проектирования фильтра и его тип (БИХ или КИХ). Для БИХ фильтров доступны варианты:
* **Butterworth** — фильтры с характеристикой Баттерворта,
* **Chebyshev Type I, II** — фильтры Чебышева,
* **Elliptic** — эллиптический фильтр,
* **Maximally flat** — фильтр с максимально плоской характеристикой в полосе пропускания,
и т. д.
Для КИХ фильтров доступны варианты\*\*\*:
* **Equiripple** — фильтр с равномерно пульсирующей АЧХ,
* **Least-squares** — фильтр по методу наименьших квадратов,
* **Window** — фильтр с оконным взвешиванием различными функциями\*\*\*\*,
* **Complex Equiripple** — комплексный фильтр с равномерно пульсирующей АЧХ,
* **Maximally flat** — фильтр с максимально плоской характеристикой в полосе пропускания,
и т.д.
\*\*\* — наибольший практический интерес представляют фильтры типа **Equiripple** и **Window**.
\*\*\*\* — при выборе этой опции появляется панель доступа к оконным функциям и их параметрам.
Для метода Equiripple производится самый простейший расчет КИХ фильтра по модифицированному алгоритму Ремеза. Пользователь задает параметры из спецификации на фильтр и сразу видит результат. В случае неудовлетворительных результатов можно в любой момент изменить один или несколько параметров фильтра и получить другую частотную характеристику. Расчет проводится до тех пор, пока не получены требуемые характеристики. Если не удалось добиться значений по заданию, то рано или поздно придется жертвовать той или иной величиной из спецификации, либо существенно увеличивать порядок фильтра N.
Для метода Window доступно несколько вариантов оконных функций: **Bartlett, Blackman, Blackman-Harris, Chebyshev, Flat Top, Gaussian, Hamming, Hann, Kaiser, Rectangular** и т. д., вплоть до пользовательских оконных функций (User-defined). Все эти функции обладают своими особенностями и могут давать различные параметры частотной характеристики КИХ фильтра. Часть оконных функций рассчитывается без параметров, а часть фильтров задается через определенные параметры, влияющие на АЧХ фильтра.
Из всех представленных оконных функций, на мой взгляд, самой удобной является окно **Кайзера**. Для построения АЧХ требуется задать всего один параметр Beta, который влияет на уровень подавления в полосе затухания и на прямоугольность частотной характеристики.
Слева снизу относительно главной рабочей области средство FDATool содержит дополнительные вкладки, в которых можно указать тип фильтра (дециматор или интерполятор), имя модели для вставки в Simulink, тип и разрядность коэффициентов и входных данных и многое другое. В практических целях самые основные вкладки это **Design Filter** — в ней происходит расчет фильтра, и **Quantinization Parameters** — в этой вкладке задается тип и разрядность данных.
На верхней панели находятся кнопки, с помощью которых можно посмотреть АЧХ и ФЧХ фильтра, групповую и фазовую задержку, импульсную и переходную характеристики, карту нулей и полюсов фильтра, рассчитанные коэффициенты и т.д.
**Скриншоты рабочей области FDATool**График АЧХ и ФЧХ фильтра:
График импульсной характеристики фильтра:
График диаграммы нулей и полюсов:
Помимо всего этого, FDATool позволяет импортировать и экспортировать модели фильтров и рассчитанные коэффициенты. Например, можно рассчитать фильтр и отправить его модель в Simulink в виде модели на стандартных примитивах. Можно рассчитать коэффициенты и сохранить их в отдельном файле, например, как файл с расширением \*.h (header).
**Файл заголовка \*.h с коэффициентами фильтра**
```
/*
* Discrete-Time FIR Filter (real)
* -------------------------------
* Filter Structure : Direct-Form FIR
* Filter Length : 128
* Stable : Yes
* Linear Phase : Yes (Type 2)
* Arithmetic : fixed
* Numerator : s16,15 -> [-1 1)
* Round Mode : convergent
*/
/* General type conversion for MATLAB generated C-code */
#include "tmwtypes.h"
const int BL = 128;
const int16_T B[128] = {
-18, 0, 19, 39, 58, 75, 88, 97, 100,
96, 85, 68, 44, 16, -16, -50, -83, -113,
-139, -157, -166, -164, -152, -128, -94, -51, 0,
55, 111, 164, 211, 248, 272, 280, 269, 240,
192, 126, 45, -47, -146, -245, -339, -421, -483,
-521, -528, -501, -434, -329, -183, 0, 217, 462,
728, 1006, 1288, 1564, 1823, 2056, 2254, 2409, 2517,
2571, 2571, 2517, 2409, 2254, 2056, 1823, 1564, 1288,
1006, 728, 462, 217, 0, -183, -329, -434, -501,
-528, -521, -483, -421, -339, -245, -146, -47, 45,
126, 192, 240, 269, 280, 272, 248, 211, 164,
111, 55, 0, -51, -94, -128, -152, -164, -166,
-157, -139, -113, -83, -50, -16, 16, 44, 68,
85, 96, 100, 97, 88, 75, 58, 39, 19,
0, -18
};
```
Кроме того, можно создать файл коэффициентов \*.COE в специальном формате для Xilinx. Для этого нужно выбрать тип коэффициентов с фиксированной точкой и задать их разрядность. Затем нажать *Targets -> Xilinx Coefficient (.COE) File*, в результате чего в главном окне MATLAB отобразится содержимое файла — глобальные настройки и коэффициенты в HEX-формате.
**Пример \*.coe файла**
```
; XILINX CORE Generator(tm)Distributed Arithmetic FIR filter coefficient (.COE) File
; Generated by MATLAB(R) 8.3 and the DSP System Toolbox 8.6.
;
; Generated on: 06-Dec-2015 15:35:35
;
Radix = 16;
Coefficient_Width = 18;
CoefData = 3ffeb,
00018,
00049,
00067,
0005f,
00029,
3ffd2,
3ff79,
3ff46,
3ff59,
...
```
Видно, что при подаче на вход единичного импульса, на выходе образуется не что иное, как импульсная характеристика фильтра (график из Simulink).
#### **Xilinx FIR Compiler**
Как и в случае с CIC фильтром, приведу подробное описание средства создания FIR фильтров от Xilinx. Отмечу, что описание содержит не просто перевод из даташита, а замечания и рекомендации из личного опыта и опыта моих коллег.
**FIR Compiler — Вкладка 1:**
**Component name** — имя компонента (используются латинские буквы a-z, цифры 0-9 и символ "\_").
Рекомендую использовать осмысленные имена, в которых зашифрованы главные параметры фильтра. Например, *xfir128t\_d1\_b18\_4c\_w6\_a7* — фильтр, сделанный для Xilinx, N = 128 (taps), децимация не используется, разрядность коэффициентов 18, четыре канала, применена оконная функция Кайзера с параметром beta = 6, кристалл ПЛИС — Artix-7.
**Filter Coefficients:**
* **Select source** — выбор источника коэффициентов (**Vector** — вектор, заданный вручную или **COE File** — файл с набором коэффициентов). Предпочтительно использовать перегружаемые **\*.COE** файлы.
* **Coefficient Vector** — вектор коэффициентов, задаваемый вручную.
* **Coefficient File** — вектор коэффициентов, считываемый из файла.
* **Number of Coefficient Sets** — количество реально используемых DSP блоков для обработки коэффициентов. Количество коэффициентов должно делиться нацело на указанное значение. Полезная опция при работе на высокой частоте относительно частоты дискретизации, позволяет существенно экономить ресурсы ПЛИС.
* **Number of Coefficient (per set)** — количество коэффициентов, обрабатываемых единовременно DSP блоками. Значение в поле автоматически устанавливается при считывании количества коэффициентов и предыдущего параметра.
**Filter Specification:**
* **Filter type** — тип фильтра: простой / интерполирующий / децимирующий / полифазный.
* **Rate Change Type** — изменение скорости обработки. Может быть целочисленным или дробным.
* **Interpolation / Decimation Rate Value** — коэффициент интерполяции / децимации.
* **Zero Pack Factor** — для интерполирующих фильтров параметр определяет количество нулей, вставляемых между коэффициентами.
* **Number of channels** — количество независимых каналов фильтрации: 1-64.
**Hardware Oversampling Specification:** эти параметры влияют на выходную частоту дискретизации, количество тактов, требуемых для обработки данных. От этих параметров также зависит уровень параллелизма внутри ядра и количество занимаемых ресурсов.
* **Select format** — выбор частотных соотношений фильтра: Frequency Specification / Sample period.
* **Frequency Specification** — Частотная спецификация: пользователь задает частоту дискретизации и частоту обработки данных.
* **Sample period** — Тактовая спецификация: пользователь задает отношение частоты обработки к тактовой частоте данных.
* **Input Sampling Frequency** — входная частота дискретизации: \*.
* **Clock frequency** — частота обработки фильтра: \*\*\*\*\*.
* **Input Sampling period** — отношение частоты обработки к частоте входного тактового сигнала: \*\*\*\*\*.
\*\*\*\*\* — диапазон зависит от общих настроек и коэффициента дискретизации R.
**FIR Compiler — Вкладка 2:**
**Filter Architecture** — задает реализуемую архитектуру фильтра.
* **Systolic Multiply Accumulate** — систолический фильтр с накоплением,
* **Transpose Multiply Accumulate** — перестраиваемый фильтр с накоплением,
* **Distributed Arithmetic** — фильтр на распределенной логике ПЛИС.
**Coefficient Options** — параметры для коэффициентов
* **Use Reloadable Coeffcients** — использовать перегружаемые коэффициенты. Полезная опция для реализации в одном фильтре перегружаемых частотных характеристик.
* **Coefficient Structure** — структура коэффициентов, 5 типов: несимметричные, симметричные, отрицательно симметричные, полуполосные и с преобразованием Гильберта. По умолчанию FIR compiler пытается сам определить тип коэффициентов (inferred).
* **Coefficient Type** — тип коэффициентов: знаковый или беззнаковый.
* **Quantization** — задает метод округления: целочисленные коэффициенты, округление к ближайшему целому или максимальный динамический диапазон (масштабирует коэффициенты относительно максимального).
* **Coefficient Width** — разрядность коэффициентов. Значение в этом поле влияет на частотную характеристику фильтра, что можно наблюдать в соответствующем окне (Freq. Response).
* **Best Precision Fraction Length** — автоматически устанавливает наилучшее соотношение для целой и дробной частей разрядной сетки.
* **Coefficient Fractional Bits** — определяет позицию для разделения целой части от дробной в разрядной сетке представления коэффициентов.
**Datapath Options** — опции входных данных
* **Number of Paths** — определяет количество параллельных каналов для обработки. Количество DSP ядер пропорционально значению в этом поле. Для этой опции на вход фильтра поступает несколько независимых потоков данных, в то время как для параметра Number of Channels данные поступают на один вход и обрабатываются последовательно.
* **Input Data Type** — тип данных на входе фильтра (знаковый или беззнаковый).
* **Input Data Width** — разрядность входных данных.
* **Input Data Fractional Bits** — определяет количество бит, приходящихся на дробную часть представления входных данных. Значение в этом поле не влияет на реализацию фильтра! (число с фиксированной точкой можно представить как угодно: с дробной частью или вовсе без нее, но результат один и тот же).
* **Output Rounding Mode** — режим округления выходных данных: полная точность, отбрасывание младших значащих битов, округление до целого вниз/вверх, округление до четного/нечетного. Во многих задачах не требуется менять этот параметр и можно оставить Full Precision — полную точность.
* **Output Width** — разрядность выходных данных фильтра.
* **Output Fractional Bits** — количество бит, определяющих дробную часть выходных данных. Поле информативное и не влияет на реализацию фильтра.
* **Allow Rounding Approximation** — для режимов Symmetric Rounding Mode опция разрешает аппроксимацию при округлении без дополнительных затрат ресурсов (автоматическое определение знакового бита в слове).
* **Registered Output** — активная опция добавляет на выход фильтра дополнительный регистр для увеличения производительности (максимальной частоты обработки) фильтра.
**FIR Compiler — Вкладка 3:**
**Optimization Goal** — определяет цель оптимизации при создании фильтра (Area — по площади, Speed — по скорости). В большинстве случаев удается одновременно достичь максимальной скорости и минимальной затраты ресурсов, но в специфических случаях при указании Speed фильтр оптимальным образом расставляет внутренние регистры в критических путях между логическими функциями.
* **SCLR** — синхронный сброс фильтра (логическая единица на входе производит сброс).
* **Use Deterministic SCLR Behavior** — определяет поведение внутренних данных фильтра типа Multiply-Accumulate в процессе сброса. При активной опции сигнал сброса очищает внутренние регистры, память данных и хранения коэффициентов.
* **ND** — «New data», входной сигнал, определяющий поступление данных на вход фильтра. Вместе с сигналом RFD позволяют организовать пакетную обработку данных. Как правило, сигналы ND и RFD подключают к управляющим сигналам FIFO.
* **CE** — «Clock Enable», сигнал разрешения тактирования фильтра. При низком уровне на входе этого сигнала приостанавливается любая обработка внутри фильтра, независимо от того, поступают новые данные или нет.
* **DATA\_VALID** — сигнал валидности выходных данных. Опция полезна только в многоканальном режиме (Number of Channels > 1).
**Memory Options** — глобальные настройки выбора типа памяти для хранения входных данных, коэффициентов фильтра, промежуточных и выходных данных. Выбирая блочную память вместо распределенной, в некоторых случаях можно в сотни раз сэкономить логические ресурсы ПЛИС!
Для Data / Coefficient / Input / Output Buffer Type возможны режимы *Auto / Block / Distributed*.
**Preference for Other Storage** — определяет тип памяти для промежуточных данных. Также доступны режимы Auto / Block / Distributed.
**DSP Slice Column Options** — определяет настройки распределения DSP блоков между колонками ПЛИС. Для некоторых архитектур фильтров, например, с симметричными коэффициентами недоступен режим Multi-Colomn Support, поэтому необходимо следить за возможной реализацией фильтра.
* **Device Column Lengths** — определяет длину колонок DSP блоков. Полезное информативное поле, в котором можно заранее определить верхнюю границу порядка фильтра и максимальное количество реализуемых фильтров.
* **Column Configuration** — определяет конфигурацию и положение DSP блоков в колонках. С этим параметром нужно работать осторожно, поскольку при разрыве фильтра между несколькими колонками может возникнуть большая задержка, следовательно — упадет максимальная тактовая частота.
* **Inter-column Pipe Length** — определяет количество дополнительных регистров между колонками DSP блоков для устранения негативного эффекта задержки распространения.
**FIR Compiler — Вкладка 4:**
**Summary** — эта вкладка в виде списка отражает конечные настройки фильтра (количество каналов, порядок фильтра, параметры частот, разрядность входных, выходных и промежуточных данных, разрядность коэффициентов, задержка в фильтре, количество используемых DSP блоков, наличие сигналов контроля и т.д.).
В левой части окна FIR Compiler есть три полезные дополнительные вкладки:
* **IP-symbol** — схематичный вид IP-блока с активными портами ввода/вывода.
* **Freq. response** — частотная характеристика FIR-фильтра.
* **Implementation Details** — оценка занимаемых ресурсов DSP и RAMB, суммарная задержка, количество коэффициентов и порядок их загрузки.
#### **Абстрактный пример**
**Условие**
Проведем расчет широкополосного фильтра первичной обработки, обладающего следующими параметрами:
* Частота дискретизации Fs: 250 МГц,
* Частота среза фильтра Fpass: 55 МГц,
* Коэффициент прямоугольности: > 0.88 (Fpass/Fstop),
* Подавление в полосе пропускания (Apass): < 0.5 дБ,
* Подавление в полосе затухания (Astop): > 50 дБ.
Реализовать шесть независимых каналов фильтрации на микросхеме Artix-7 XC7A100T-FGG484. Коэффициенты ИХ – перегружаемые, симметричные и независимые для каждого канала фильтра.
**Решение**
**Шаг 1: Оценка ресурсов ПЛИС**
Необходимо понять, сколько доступно ресурсов кристалла для реализации подобного фильтра. В DS180 можно найти, что микросхема имеет 240 DSP48E1 блоков, выстроенных в три колонки (это важно!). Из ТЗ известно, что ИХ – симметрична, а это значит, что для фильтра порядка N потребуется N/2 блоков DSP48E1. Следовательно, на выбранной микросхеме возможна реализация 2 фильтров с длиной характеристики N = 240, либо 6 фильтров с длиной N = 80. В практических целях при обработке сигналов длину ИХ выбирают кратному степени двойки. Например, N = 64, 128 или 256. Либо, N = (128 + 64), (32 + 16 + 8). В нашем случае необходимо реализовать 6 фильтров на 240 DSP блоках. С учетом симметрии для каждого фильтра возможно использовать длину N < 81 коэффициентов. Предположим, что для достижения параметров фильтра хватит N = 80 = 64 + 16 коэффициентов.
**Шаг 2: Поиск коэффициентов фильтра**
Запустим FDATool и внесем в нужные поля параметры фильтра из спецификации (помним, что порядок N задается на 1 меньше, чем истинный порядок фильтра). Режим 1 – *Equiripple*. Для частоты среза Fpass = 55 МГц и коэффициента прямоугольности > 0.85 найдем частоту заграждения Fstop < 62.5 МГц. На следующем рисунке представлен расчет фильтра по требуемым параметрам:
Как видно, фильтр удовлетворяет всем перечисленным требованиям.
*Режим 2 – Window*. Неожиданно перед самой сдачей проекта вашему заумному заказчику вбрела в дурную голову мысль. «Хочу 70 дБ подавление при прочих равных условиях!». Элементная база выбрана, плата разведена и смонтирована, ПЛИС установлена, проект отлаживался несколько месяцев и нет возможности поставить что-то переделывать. Что делать? Проектировать свой собственный КИХ фильтр за неделю до сдачи проекта? Искать другие методы подавления АЧХ? Переделывать плату и устанавливать ПЛИС пожирнее? Нереально! Главное – не паниковать. Метод Equiripple уже не спасает. Переходим к оконному режиму Window. При выборе моего любимого окна Кайзера можно добиться лучших характеристик фильтра. Например, обеспечить необходимое подавление в полосе затухания Astop = 80 дБ (параметр Beta = 8). Но для оконного метода следует учитывать, что в полосе затухания из-за недостаточной разрядности коэффициентов могут проявляться эффекты квантования.
Далее известным способом выгружаем рассчитанные коэффициенты в \*.COE файл для дальнейшей работы.
**Шаг 3: Реализация**
Количество каналов и коэффициентов было подобрано таким образом, чтобы на 100% занять ресурсы DSP48E1 в ПЛИС. Количество занимаемых ресурсов для 6 каналов на рисунке ниже:
Не стоит пугаться, что проект не заработает на 250 МГц. Еще как заработает. PlanAhead любит перестраховываться и указывает значения ниже реальных. Результаты разводки шести каналов FIR фильтров.
**Красивые рисунки разводки проекта**Схематический вид части IP-ядра FIR фильтра:
Разводки платы в FPGA Editor (Zoom нижней части):
Разводка платы в FPGA Editor:
#### **Практические советы**
Конечно, переход к Window спасает не всегда, и на практике есть несколько иных методов, которые так или иначе упростят жизнь разработчику.
1. Заранее определить возможную децимацию сигнала (по отношению частоты дискретизации и граничной частоте в спектре сигнала). Использовать дешевые CIC-фильтры для целей децимации. После децимации возможно сократить количество используемых DSP блоков кристалла.
2. Определить отношение частоты дискретизации и частоты обработки в кристалле ПЛИС. Если частота обработки в несколько раз превышает частоту дискретизации, можно во столько же раз сэкономить количество ресурсов на реализацию FIR фильтра.
3. Реализовать фильтр на распределенной логике ПЛИС, если это возможно и не критично с точки зрения частот обработки. Этот метод очень сложен в реализации и не будет стабильно работать для больших порядков фильтра N.
4. Для реализации фильтров с симметричной ИХ предварительно оценить размер колонок DSP блоков и количество этих колонок в ПЛИС. Для реализации длинных фильтров с симметричной ИХ требуется каскадное соединение DSP блоков и при размещении фильтра внутри ПЛИС в одной колонке может не хватить ячеек DSP. С другой стороны, при реализации независимых каналов фильтров, может попросту не хватить колонок, если в каждой колонке умещается только один фильтр. Придется либо уменьшать длину характеристики, либо делать два небольших фильтра с меньшим числом коэффициентов.\*\*\*\*\*\*
5. Для современных кристаллов ПЛИС (Altera и Xilinx) при реализации фильтра с симметричной ИХ использовать предварительный сумматор в узле DSP, а не на распределенной логике. Внутренний pre-adder значительно экономит не только логические ячейки, но и трассировочные ресурсы кристалла! \*\*\*\*\*\*\*
\*\*\*\*\*\* — Для Xilinx фильтр гарантированно не разведется, если фильтр с симметричной ИХ не влезает в одну колонку (в PlanAhead колонки DSP блоков выделены зеленым цветом). На Altera – не проверял. Буду рад, если кто-то поделится своими опытами.
\*\*\*\*\*\*\* — для микросхем ПЛИС фирмы Xilinx 7 серии и старше этот метод спасает только в том случае, если разрядность коэффициентов не превышает 18. Для убер-современных по состоянию на 2015-2016 г. микросхем Xilinx Ultra-Scale возможно реализовать предварительный сумматор с разрядностью коэффициентов 24.
#### **Vivado HLS**
Современные методы создания узлов задач цифровой обработки сигналов на ПЛИС сводятся к двум принципам:
* уменьшение времени проектирования (понятие "*time-to-market*"),
* уменьшение порога вхождения (популяризация ПЛИС среди С++ разработчиков).
Оба принципа возникли не случайно и происходят в первую очередь от постоянного увеличения логической емкости FPGA. Xilinx заявляет, что старые методы программирования (на языках VHDL и Verilog) уже не справляются с современными задачами, и есть большая вероятность, что в будущем программирование на ПЛИС будет вестись исключительно на языках высокого уровня типа С и С++. Xilinx несколько лет назад анонсировал новое средство проектирования под названием Vivado HLS и предлагает все большие проекты частично или полностью переводить на новый уровень. Разработка на Vivado HLS сводится к тому, что можно уйти от понятия "*тактовая частота*" и разрабатывать сложные алгоритмы без привязки к ПЛИС, а всю оптимизацию под ПЛИС уже делать на последней стадии проекта. Посмотрим, что можно сделать с помощью новой среды и разработаем простейший КИХ-фильтр в Vivado HLS.
В качестве примера я взял одну из лабораторных работ от Xilinx, в которой в первом приближении показана вся мощь современных средств. Основная разработка с помощью Vivado HLS базируется на взаимосвязанных задачах: написание кода и его оптимизация по скорости (Speed) и занимаемой площади (Area) с помощью директив.
Xilinx предлагает следующее поведение при проектировании:
* – C Validation/Simulation (*Project -> Run C Simulation*): написание алгоритма, отладка проекта, выявление ошибок в коде, сравнение данных с эталоном и т.д.
* – C Synthesis (*Solution -> Run C Synthesis*): синтез проекта из C-кода в RTL форму и анализ полученных данных: оценка производительности (latency, trip count, speed etc.), оценка ресурсов, полученный интерфейс ввода/вывода.\*
* – RTL Verification (*Solution -> Run C/RTL Cosimulation*): повторное использование C-модели теста main() для анализа RTL-модели (self-checking).
* – IP Creation (*Solution -> Export RTL*): создание IP-ядра для дальнейшего использования в основном проекте (Xilinx ISE, Vivado и т.д)
\* — Мощь Vivado HLS в создании уникальных решений (**solutions**), различающихся способами оптимизации. Правильный подход заключается в создании множества решений и выборе оптимального, нежели в отладке одного единственного!
*Как сделать различные решения?* Использовать **директивы** — инструмент для оптимизации проектов в Vivado HLS. Директивы можно добавлять в исходный код (*Source file*) или в отдельный файл директив (*Directive file*).
* **Source file** – подходит для задания директив, которые НЕ БУДУТ меняться на протяжении создания проекта. Например, директивы для интерфейса портов I/O не меняются. В проекте эти директивы обозначаются префиксом: **#HLS**.
* **Directive file** – подходит для задания условий и ограничений, которые влияют на оптимизацию по скорости и размещению. Как правило, в проекте можно сравнить в различных solutions несколько ограничений и выбрать оптимальное. В проекте эти директивы обозначаются префиксом: **%HLS**.
Приведу пример исходников для простейшего КИХ фильтра. Обратите внимание на директивы в исходном коде.
**FIR Filter C++ for Vivado HLS**
```
#include "fir.h"
void fir (
data_t *y,
coef_t c[N],
data_t x
) {
**#pragma HLS** INTERFACE ap_ovld port=y
**#pragma HLS** INTERFACE ap_vld port=x
**#pragma HLS** RESOURCE variable=c core=RAM_1P_BRAM
static data_t shift_reg[N];
acc_t acc;
data_t data;
int i;
acc=0;
Shift_Accum_Loop: for (i=N-1;i>=0;i--) {
if (i==0) {
shift_reg[0]=x;
data = x;
} else {
shift_reg[i]=shift_reg[i-1];
data = shift_reg[i];
}
acc+=data*c[i];;
}
*y=acc;
}
```
Директивы в отдельном файле выглядят следующим образом:
```
set_directive_unroll "fir/Shift_Accum_Loop"
set_directive_array_partition -type complete -dim 1 "fir" shift_reg
```
**Замечание:** В процессе оптимизации разработчику часто приходится сравнивать различные результаты по производительности и ресурсам. Поэтому зачастую большая часть директив записывается в отдельный файл. Если разработчик уверен, что конкретная оптимизация нужна для всех решений, то её можно занести в исходные тексты!
Для проекта FIR создадим три разных решения:
* без использования директив (синтезатор использует минимум ресурсов — последовательная обработка данных),
* с использованием директив для портов (синтезатор оптимизирует интерфейс ввода/вывода),
* с использованием директивы UNROLL (для разворачивания цикла FOR и параллельной обработки каждой итерации цикла).
В результате синтеза в Vivado можно провести полный анализ по занимаемым ресурсам и максимальной производительности, увидеть интерфейс портов ввода/вывода для создаваемого ядра. Кроме того, можно увидеть, как исполняются те или иные функции, сколько ресурсов они занимают и сколько тактов выполняются.
Сравнение трех решений:
**Результаты синтеза проекта в Vivado HLS**Директивы:
Вкладка Performance:
Вкладка Resources:
* Чтение порта x и запись порта y происходит за один такт. Чтение порта c за два такта, потому что он описан как интерфейс памяти RAM;
* Используется два умножителя;
* Сдвиговый регистр shift\_reg используется для операции чтения и записи;
* Остальные ресурсы не используются совместно, потому что существуют в единственном виде (в выражениях в коде).
Ресурсы кристалла:
Процесс создания нового проекта и все шаги проектирования описывать не буду, поскольку статья и так уже разрослась до небывалых размеров. Но если вам интересна тема использования Vivado HLS в своих проектах – я с удовольствием поделюсь своим опытом. Также можно воспользоваться помощью хабраюзера [urock](https://habrahabr.ru/users/urock/). В этом деле он мастер!
#### **Заключение**
На этом хотелось бы подвести итог. В статье рассмотрены базовые принципы создания КИХ фильтров на ПЛИС. Общие выводы по статье:
* КИХ фильтры — линейные нерекурсивные фильтры, достаточно просты в реализации на современных FPGA и процессорах.
* Порядок фильтра = длина импульсной характеристики = количество коэффициентов = количество линий задержки.
* Могут иметь точную линейную фазовую характеристику, постоянные групповую и фазовую задержки.
* Для линейной фазовой характеристики требуются симметричные коэффициенты фильтра.
* Не забывайте про эффект Гиббса при расчете коэффициентов фильтра.
* При расчете коэффициентов пользуйтесь современными средствами и не изобретайте велосипед
* Если длина фильтра N превышает разумные пределы (например, больше 512), используйте алгоритм быстрой свертки через двойное БПФ.
* Разработка фильтра разбивается на несколько взаимосвязанных стадий.
* Используйте метод оконных функций для реализации частотных характеристик с хорошими параметрами.
* Учитывайте особенности выбранного кристалла ПЛИС для минимизации занимаемых ресурсов.
* Длина фильтра влияет на прямоугольность, а разрядность коэффициентов на подавление в полосе затухания.
* Существует множество методов разработки КИХ фильтров на ПЛИС. Выбирайте тот, который покажется проще.
**Полезные видео**Altera FIR Design:
Xilinx HLS FIR Design 1:
Xilinx HLS FIR Design 2:
**Литература**
1. [Статья на хабре](http://habrahabr.ru/post/128140/)
2. [Статья на DSPLIB](http://www.dsplib.ru/content/filters/fir/fir.html)
3. [Altera FIR Compiler](https://www.altera.co.jp/ja_JP/pdfs/literature/ug/fircompiler_ug.pdf)
4. [Xilinx FIR Compiler](http://www.xilinx.com/support/documentation/ip_documentation/fir_compiler_ds534.pdf)
5. [Xilinx DSP48E1 (7 Series)](http://www.xilinx.com/support/documentation/user_guides/ug479_7Series_DSP48E1.pdf)
6. [Xilinx DSP48E2 (Ultra-Scale)](http://www.xilinx.com/support/documentation/user_guides/ug579-ultrascale-dsp.pdf)
7. [Wikipedia FIR](https://ru.wikipedia.org/wiki/Фильтр_с_конечной_импульсной_характеристикой)
8. [Parks-McClellan algorithm](https://en.wikipedia.org/wiki/Parks–McClellan_filter_design_algorithm)
9. [MATLAB Tutorial 1](http://www.mathworks.com/help/signal/ug/opening-fdatool.html)
10. [MATLAB Tutorial 2](http://www.mathworks.com/help/signal/examples/introduction-to-the-filter-design-and-analysis-tool-fdatool.html)
11. [OpenCores FIR 1](http://opencores.org/project,cascaded_fir_filter)
12. [OpenCores FIR 2](http://opencores.org/project,lowpowerfir)
13. [OpenCores FIR 3](http://opencores.org/project,fir_wishbone)
*Продолжение следует...* | https://habr.com/ru/post/274847/ | null | ru | null |
# Домашка по арифметике
*Лёшенька, Лёшенька, сделай одолжение!
Выучи, Алёшенька, таблицу умножения !*
**Агния Барто**
Сначала задачка для первоклассника. Дано некоторое положительное число. Нужно умножить на него другое число, заранее неизвестное. Вопрос, как посоветуют это сделать благородные доны ??? Бывалый разраб наверняка скажет, мол мужик, ставь умножитель и не парь мне мОзги. И возможно будет в корне неправ! Ибо кроме монстров от Alterra и Xilinx существует ещё и такое замечательное семейство как [iCE-40 от Lattice](http://www.latticesemi.com/en/Products/FPGAandCPLD/iCE40). Ультрамикропотребляющее. Очень дешевое. Да вот беда, больно мелкие они, и увы, умножителей там нет. Я столкнулся с этим года 4 назад, когда портировал [некий ADPCM-кодек](https://hh.ru/resume/c00bf120ff0086f2090039ed1f736563726574) с ассемблера adsp-2185 на такой кристалл.
Нет, без умножителя общего назначения(для двух переменных) там разумеется не обошлось. Пришлось сделать его ручками и он занял половину кристалла. Беда в том, что молотил он у меня в каждом такте, т.е. вообще без свободных окон. А кроме умножений переменных в алгоритме были фиксированные коэффициенты, на которые тоже надо было умножать. И использовать для этого умножитель не было никакой возможности, просто не оставалось свободного окна. А поскольку борьба в проекте шла за каждую ячейку, разумеется меня очень интересовало, как бы извернуться, и используя свойства этих коэффициентов сделать оптимальную схему умножения на них(не умножитель общего назначения, а устройство умножения на заданное число !). Ну и как полная сбыча мечт — чтобы схемы умножения на разные коэффициенты максимально использовали какие-то общие ресурсы кристалла.
Итак, от задачки для первоклассника мы плавно перешли к задаче для инженера и математика. Как для заданного конкретного числа построить оптимальную схему умножения на него?
Вспомним немного, как мы вообще умножаем число **А** на **В**.
1. Для начала положим результат равным нулю.
2. Пробежимся по разрядам **A**.
3. Если в разряде 0, ничего не делаем.
4. Если в разряде 1, сдвигаем **B** на соответствующее число разрядов и прибавляем к результату.
Итого, чем меньше в разрядах **А** единиц, тем проще на него умножать. Умножить на 2, 4 или 8 совсем легко. Нужен только сдвиг. Немного труднее умножить на 3, 5 или 10. Потребуются одно сложение. Ещё труднее умножить на 11. Чем больше единиц, тем труднее.
Ну а как насчёт умножения на 255? Целых 8 единиц, кошмарная задача, правда? А вот и фигушки! Сделаем хитрый финт ушами. Умножим наше **В** на 256 (т.е. сдвинем на 8 разрядов) и вычтем его же из результата. Получается несмотря на грозный вид, умножить на 255 столь же легко, как и на 10. Столь же легко умножать и на 254, и на 240, и на 224 (если хотите, проверьте !).
Итого, вычитание помогает умножению. Запомним эту ценную мысль. А пока назовём **трудностью** числа минимальное число операций сложения (или вычитания), необходимых для умножения на него. Сдвиги не учитываем. Ибо в контексте задачи(у нас схемотехника, а не программирование !) они получаются даром. Сформулируем пока одно очевидное, но полезное утверждение:
**Трудность числа меньше или равна количеству единиц в его двоичной записи.**
В самом деле, если мы без фокусов с вычитанием честно умножим, как в учили в школе, число сложений будет равно числу единиц в двоичной записи **A**. А если начнём хитрить и к тому же нам повезёт, то сократим число операций.
Интересное следствие из этого утверждения:
**Трудность любого n-разрядного числа всегда строго меньше n**.
Ведь наибольшее число единиц в **n**-разрядном числе равно **n**, у числа подобного 255. С другой стороны понятно, что фокус, как с умножением на 255, мы можем повторить для чисел любой разрядности. Это открывает перспективы и для оптимизации умножителей общего назначения.
Придадим нашим рассуждениям более регулярный вид. Для начала пусть у нас уже есть какая-то схема умножения на **А**. Возьмём в качестве **В** единицу. Тогда все слагаемые сдвинутся, сложатся и вычтутся таким образом, что в результате получится то же самое **А**. Итого, наша схема умножения на **A** есть ни что иное, как представление числа **A** в виде суммы степеней двойки, в котором слагаемые могут быть и со знаком **+** и со знаком **-**. А можно сгруппировать вместе положительные и отрицательные слагаемые, и сказать что схема описывается разностью неких чисел **A+** и **A-**, равной **A**. Это плохо… Члены разности могут быть как угодно велики. Подумаем, есть ли какие-то соображения, позволяющие их ограничить?
Заметим прежде всего, что каждая степень двойки может входить в схему только один раз. В самом деле, если она входит дважды с одним знаком, это можно заменить степенью двойки на единицу бОльшей. Если она входит дважды с разными знаками, они взаимно вычитаются. Итого, схема очень напоминает обычное двоичное представление **A**. С той лишь разницей, что его «биты»(в дальнейшем будем называть их **триты**), могут принимать не два, а три значения: 1, 0 и -1.
Итого. Если **A** есть **n**-разрядное двоичное число, схема умножения на него описывается суммой:
где **** — триты, принимающие значения 1, 0 и -1, а **m** некое пока неизвестное число.
В дальнейшем будем называть такое выражение **троичной схемой** или просто **схемой** или **схемой умножения** для числа **A**.
Попытаемся найти **m**. Как видно из примера с умножением на 255, **m** никак не меньше **n**. Посмотрим, может ли оно быть равно **n+1**.
Пускай **A** как и прежде, положительное **n**-разрядное число. Тогда схема умножения задаётся как:
Вспомним, что 
Поэтому старший трит никак не может быть равен -1. Ведь даже если все остальные будут 1, сумма всё равно будет равна -1. А по условию **A** положительно. Пусть теперь старший трит равен 1. Но в этом случае следующий трит должен быть равен -1. Иначе сумма получится слишком большой. В самом деле, если следующий трит равен 0, сумма получится не меньше чем 
В то время как **n**-разрядное **A** не больше . Но если старший трит равен 1, а следующий -1, то сумма двух старших членов равна . А значит старший трит равен 0.
Таким образом доказано важное утверждение: **m=n**.
Иными словами для представления любой схемы умножения на **n**-разрядное **A** достаточно **n+1** степеней двойки — от 0 до **n**(на одну больше, чем для двоичного представления), что сразу избавляет нас от бесконечности.
Теперь можно попытаться вычислить **трудности**(см выше) каких-то конкретных чисел. Самое простое это поступить так, как мы поступаем выписывая по порядку двоичные числа. Только во-первых у нас тут не биты а триты (три возможных значения), во-вторых некоторые комбинации тритов дают отрицательные числа и их надо отбрасывать, в третьих некоторые комбинации могут давать совпадающие числа. Это означает что для такого числа существует несколько схем.
Писать будем на питоне. Не потому что я такой его фанат, а потому что с ним крайне удобно работать в блокнотах jupyter. Для начала напишем класс TriScheme, работающий с введёнными выше троичными схемами, функцию allSchemes, вычисляющую с его помощью все схемы для чисел заданной разрядности простым перебором, и функцию printSchemes, распечатывающую результат:
**TriScheme**
```
class TriScheme():
def __init__(self, buf:list): # создает из массива
self.buf=[]
for i in range(0, len(buf)):
s=0
if (type(buf[i]) == int) or (type(buf[i]) == float):
if buf[i] > 0: s=1
elif buf[i] < 0: s=-1
self.buf.append(s)
def zero(self): # обнуляет
self.buf=[0]*len(self.buf)
def __repr__(self): # представление в виде строки
s=""
for i in range(1, len(self.buf)+1):
if self.buf[-i]==1: s=s+"+"
elif self.buf[-i]==0: s=s+"0"
elif self.buf[-i]==-1: s=s+"-"
return s
def inc(self): # инкремент (переход к следующей)
for i in range(0, len(self.buf)):
if (self.buf[i]+1) < 2:
self.buf[i]+=1
break
for j in range(0, i+1):
self.buf[i]=-1
def __int__(self): # выдаёт значение
m=1
s=0
for i in range(0, len(self.buf)):
s+=self.buf[i]*m
m=m*2
return s
def isMax(self): # проверяет что схема максимальна
s=0
for i in range(0, len(self.buf)):
s+=self.buf[i]
return (s == len(self.buf))
def isMaxDig(self): # проверяет, что схема максимальная, соответствующая n-разрядному числу
s=[0]*len(self.buf)
s[0]=-1
s[-1]=1
return (self.buf == s)
def ones(self): # выдает число ненулевых элементов (трудность схемы)
s=0
for i in range(0, len(self.buf)):
if self.buf[i] != 0:
s+=1
return s
def minPos(self): # выдаёт номер минимальной ненулевой позиции
for i in range(0, len(self.buf)):
if self.buf[i] != 0:
return i
def allSchemes(dig): # считает все схемы для всех чисел разрядности dig
sch=[]
for i in range(0, 2**dig): sch.append([])
ts=TriScheme([0]*(dig+1))
while True:
sch[int(ts)].append(TriScheme(ts.buf))
if ts.isMaxDig():
break
ts.inc()
return sch
def printSchemes(sch): # печатает список схем в формате число трудность количество_схем список_схем
for i in range(0, len(sch)):
s=sch[i]
a=[]
for j in range(0, len(s)):
a.append(s[j].ones())
m=min(a)
print(i, m, len(s), s)
# Вычисляем схемы для всех 4-разрядных чисел
sch4=allSchemes(4)
printSchemes(sch4)
```
Вычислим схемы для всех 4-разрядных чисел:
0 0 1 [00000]
1 1 5 [0000+, 000+-, 00+--, 0+---, +----]
2 1 4 [000+0, 00+-0, 0+--0, +---0]
3 2 7 [000++, 00+-+, 00+0-, 0+--+, 0+-0-, +---+, +--0-]
4 1 3 [00+00, 0+-00, +--00]
5 2 8 [00+0+, 00++-, 0+-0+, 0+-+-, 0+0--, +--0+, +--+-, +-0--]
6 2 5 [00++0, 0+-+0, 0+0-0, +--+0, +-0-0]
7 2 7 [00+++, 0+-++, 0+0-+, 0+00-, +--++, +-0-+, +-00-]
8 1 2 [0+000, +-000]
9 2 7 [0+00+, 0+0+-, 0++--, +-00+, +-0+-, +-+--, +0---]
10 2 5 [0+0+0, 0++-0, +-0+0, +-+-0, +0--0]
11 3 8 [0+0++, 0++-+, 0++0-, +-0++, +-+-+, +-+0-, +0--+, +0-0-]
12 2 3 [0++00, +-+00, +0-00]
13 3 7 [0++0+, 0+++-, +-+0+, +-++-, +0-0+, +0-+-, +00--]
14 2 4 [0+++0, +-++0, +0-+0, +00-0]
15 2 5 [0++++, +-+++, +0-++, +00-+, +000-]
Здесь в начале строки число, за ним его трудность (минимальное количество ненулевых элементов в схеме), затем число схем, и наконец список схем.
В схеме **+** обозначает 1, **0** — 0, и **-** — -1. Старший трит слева (как при обычном написании чисел).
Из таблицы видно во-первых, что только числа 13 и 11 имеют трудность 3 (максимальную для 4-разрядных чисел, как доказано выше). И во-вторых, что число различных схем для каждого числа довольно велико. Это говорит во-первых о том, что умножение чаще всего операция сильно более простая чем нас учили в школе. И во-вторых о том, что для реализации устройств умножения на несколько констант с использованием общих ресурсов кристалла, выбор схем достаточно велик. Ещё интереснее выглядят данные по более длинным числам. Так для 14-разрядных чисел максимальная трудность получается равной 8. А максимальное число схем — 937.
Всё бы хорошо, но приведённый выше алгоритм слишком затратен. Его сложность растёт как  в зависимости от разрядности чисел **n**. Для 8 разрядов считается мгновенно. Для 14 — минуты. Для 16 — часы. Если нужно считать схемы ДЛЯ ВСЕХ **n**-разрядных чисел, увы, больше ничего сделать нельзя, кроме как переписать его на С и взять компьютер помощнее. Впрочем алгоритм прекрасно распараллеливается и наверняка может быть запущен на GPU или на кластере.
Для проектирования конкретных железок как правило требуются списки схем для конкретных чисел. Причём желательно ВСЕ, а не только оптимальные. Ибо какую выбрать, может зависеть от обстоятельств(например устройство умножения на несколько констант). И вот тут можно предложить алгоритм гораздо более гуманный. Ещё раз вспомним замечательное равенство: .
В контексте задачи это означает следующее. Пусть известны несколько старших тритов схемы. Все младшие триты, начиная с позиции **k** неизвестны и предварительно считаются равными нулю. Тогда изменяя каким угодно образом неизвестные триты, мы изменим значение схемы не более чем на плюс/минус . Причем с продвижением к младшим тритам величина этой неопределённости уменьшается. Это позволяет искать схемы методом последовательных приближений, трит за тритом.
Пусть дано положительное число **A**. Надо найти все схемы для него среди **n**-разрядных чисел. Абсолютную величину разности между **A** и значением некоторой схемы, назовём **погрешностью** схемы. Возьмем для начала **n+1**-разрядную схему, описывающую **n**-разрядные числа, все триты которой неизвестны, и изначально положены равными нулю. И начнём определять триты, один за другим, начиная со старшего. В **k**-й позиции схема может породить три новых схемы — со значениями **k**-го трита 1, 0 и -1. Оставим в списке схем для продолжения только те из них, погрешность которых не превышает . С получившимся списком схем перейдём к шагу в позиции **k-1**. Таким образом, в результирующем списке (в позиции 0) будут ВСЕ возможные схемы, значение которых равно **A**. Давайте напишем такую функцию calcSchemes.
**calcSchemes**
```
def calcSchemes(a, n=-1):
m=1
nn=1
while m < a:
nn+=1
m=m*2
if n < nn:
n=nn
sch=[TriScheme([0]*n)]
for i in range(0, n):
tmp=[]
pos=n-i-1
for j in range(0, len(sch)):
for k in range(-1, 2):
ts=sch[j]
ts.buf[pos]=k
d=abs(a - int(ts))
if d <= (2**pos - 1):
tmp.append(TriScheme(ts.buf))
sch=tmp
return sch
```
Ну и наконец обещанная сбыча мечт.
В том проекте было два коэффициента, на которые требовалось умножать: 16351 и 16318. Используя calcSchemes, найдём схемы для этих коэффициентов:
**Схемы**Для 16351
0++++++++0+++++
0+++++++++-++++
0+++++++++0-+++
0+++++++++00-++
0+++++++++000-+
0+++++++++0000-
+-+++++++0+++++
+-++++++++-++++
+-++++++++0-+++
+-++++++++00-++
+-++++++++000-+
+-++++++++0000-
+0-++++++0+++++
+0-+++++++-++++
+0-+++++++0-+++
+0-+++++++00-++
+0-+++++++000-+
+0-+++++++0000-
+00-+++++0+++++
+00-++++++-++++
+00-++++++0-+++
+00-++++++00-++
+00-++++++000-+
+00-++++++0000-
+000-++++0+++++
+000-+++++-++++
+000-+++++0-+++
+000-+++++00-++
+000-+++++000-+
+000-+++++0000-
+0000-+++0+++++
+0000-++++-++++
+0000-++++0-+++
+0000-++++00-++
+0000-++++000-+
+0000-++++0000-
+00000-++0+++++
+00000-+++-++++
+00000-+++0-+++
+00000-+++00-++
+00000-+++000-+
+00000-+++0000-
+000000-+0+++++
+000000-++-++++
+000000-++0-+++
+000000-++00-++
+000000-++000-+
+000000-++0000-
+0000000-0+++++
+0000000-+-++++
+0000000-+0-+++
+0000000-+00-++
+0000000-+000-+
+0000000-+0000-
+00000000--++++
+00000000-0-+++
+00000000-00-++
+00000000-000-+
+00000000-0000-
Для 16318
0+++++++0+++++0
0++++++++-++++0
0++++++++0-+++0
0++++++++00-++0
0++++++++000-+0
0++++++++0000-0
+-++++++0+++++0
+-+++++++-++++0
+-+++++++0-+++0
+-+++++++00-++0
+-+++++++000-+0
+-+++++++0000-0
+0-+++++0+++++0
+0-++++++-++++0
+0-++++++0-+++0
+0-++++++00-++0
+0-++++++000-+0
+0-++++++0000-0
+00-++++0+++++0
+00-+++++-++++0
+00-+++++0-+++0
+00-+++++00-++0
+00-+++++000-+0
+00-+++++0000-0
+000-+++0+++++0
+000-++++-++++0
+000-++++0-+++0
+000-++++00-++0
+000-++++000-+0
+000-++++0000-0
+0000-++0+++++0
+0000-+++-++++0
+0000-+++0-+++0
+0000-+++00-++0
+0000-+++000-+0
+0000-+++0000-0
+00000-+0+++++0
+00000-++-++++0
+00000-++0-+++0
+00000-++00-++0
+00000-++000-+0
+00000-++0000-0
+000000-0+++++0
+000000-+-++++0
+000000-+0-+++0
+000000-+00-++0
+000000-+000-+0
+000000-+0000-0
+0000000--++++0
+0000000-0-+++0
+0000000-00-++0
+0000000-000-+0
+0000000-0000-0
Нам повезло! Оба коэффициента имеют трудность 3. Выбираем для обоих оптимальные схемы:
Для 16318 **+0000000-0000-0** и для 16351 — **+00000000-0000-**. Нам ещё раз повезло! Обратите внимание на хвосты схем. Они для 16318 и 16351 отличаются только сдвигом влево на одну позицию. А значит устройство умножения на 16318 и 16351, включает только один добавочный мультиплексор, переключающий сдвинутый и не сдвинутый операнд на входе сумматора.
Давайте посмотрим результат. Напишем на верилоге три варианта устройства умножения на 16318 и 16351:
1. «Школьный» вариант (только сложения и сдвиги)
2. Оптимальная схема
3. Оптимальная схема, использующая общие ресурсы
Для всех трёх вариантов выполним синтез, и посмотрим сколько на каждый из них будет затрачено ресурсов кристалла.
**Verilog**
```
/*-----------------------Школьный вариант----------------------*/
module mul_163xx(
input[15:0] di,
input s,
output[31:0] dq
);
reg[31:0] dd;
always @*
if(s) dd= (di<<13)+(di<<12)+(di<<11)+(di<<10)+(di<<9)+(di<<8)+(di<<7)+(di<<4)+(di<<3)+(di<<2)+(di<<1) + (di<<6)+di;
else dd=(di<<13)+(di<<12)+(di<<11)+(di<<10)+(di<<9)+(di<<8)+(di<<7)+(di<<4)+(di<<3)+(di<<2)+(di<<1) + (di<<5);
assign dq=dd;
endmodule
/*---------------------------Оптимальная схема -------------------------*/
module mul_163xx(
input[15:0] di,
input s,
output[31:0] dq
);
reg[31:0] dd;
always @*
if(s) dd= (di<<14) - (di<<5) - di;
else dd=(di<<14) - (di<<6) - (di<<1);
assign dq=dd;
endmodule
/*--------------Оптимальная схема с общими ресурсами--------------*/
module mul_163xx(
input[15:0] di,
input s,
output[31:0] dq
);
wire[31:0] tail = (di<<5) + di;
reg[31:0] dd;
always @*
if(s) dd= (di<<14) - tail;
else dd=(di<<14) - (tail<<1);
assign dq=dd;
endmodule
/*-------------------------------Тестбенч------------------------------*/
module mult_tb();
reg clk = 0;
always #100 clk = ~clk;
reg[15:0] di;
wire[31:0] dq;
reg s;
mul_163xx mul (
.di (di),
.dq (dq),
.s (s)
);
initial
begin
clk=0;
s=0;
$display("s=0");
di=1;
@(posedge clk);
$display("%d", dq);
di=10;
@(posedge clk);
$display("%d", dq);
di=100;
@(posedge clk);
$display("%d", dq);
di=1000;
@(posedge clk);
$display("%d", dq);
s=1;
$display("s=1");
di=1;
@(posedge clk);
$display("%d", dq);
di=10;
@(posedge clk);
$display("%d", dq);
di=100;
@(posedge clk);
$display("%d", dq);
di=1000;
@(posedge clk);
$display("%d", dq);
$finish;
end
endmodule
/*------------------------------PCF-файл------------------------------*/
set_io dq[0] A1
set_io dq[1] A2
set_io dq[2] P16
set_io dq[3] M13
set_io dq[4] A5
set_io dq[5] A6
set_io dq[6] A7
set_io dq[7] L13
set_io dq[8] A9
set_io dq[9] A10
set_io dq[10] A11
set_io dq[11] M14
set_io dq[12] P15
set_io dq[13] N16
set_io dq[14] A15
set_io dq[15] A16
set_io dq[16] B1
set_io dq[17] B2
set_io dq[18] B3
set_io dq[19] B4
set_io dq[20] B5
set_io dq[21] B6
set_io dq[22] B7
set_io dq[23] B8
set_io dq[24] B9
set_io dq[25] B10
set_io dq[26] B11
set_io dq[27] B12
set_io dq[28] B13
set_io dq[29] B14
set_io dq[30] B15
set_io dq[31] B16
set_io di[0] C1
set_io di[1] C2
set_io di[2] C3
set_io di[3] C4
set_io di[4] C5
set_io di[5] C6
set_io di[6] C7
set_io di[7] C8
set_io di[8] C9
set_io di[9] C10
set_io di[10] C11
set_io di[11] C12
set_io di[12] C13
set_io di[13] C14
set_io di[14] D4
set_io di[15] C16
set_io s D1
```
Все три варианта работают правильно, умножая при 0 на входе s на 16318, а при 1 — на 16351. При этом yosys даёт для школьного варианта 488 ячеек, для оптимального — 206, и для варианта с общими ресурсами 202. Наверно он сам тоже что-то оптимизирует, хотя разница в 4 ячейки всё-таки есть. Как видим, разница со школьным вариантом очень приличная.
Ну и наконец. Возможно кому-то покажется излишним городить такой огород, только для того, чтобы элементарно сообразить, что 16318=16384-64-2, а 16351=16384-32-1. Однако во-первых числа могут быть и посложнее. Во-вторых, если устройство должно умножать несколько чисел, далеко не очевидно, что следует брать оптимальные схемы. Мне в том проекте просто повезло. В общем случае программа поиска схем может сильно помочь. Надеюсь статья кому-то оказалось полезной. И тот кто её прочитал, надеюсь не будет паниковать, если надо умножать, а умножителя нет. | https://habr.com/ru/post/485786/ | null | ru | null |
# Visual Studio Mobile Center: Деплоим мобильный софт с помощью devops-конвейера Microsoft
В [прошлой статье](https://habrahabr.ru/company/microsoft/blog/325184/) мы рассмотрели автоматизацию сборки мобильных приложений с помощью Bitrise, разобрались со сборкой Android- (и iOS-) приложения, подключили Xamarin Test Cloud, провели автоматическое UI-тестирование и внедрили HockeyApp для получения обратной связи. Сегодня мы продолжим погружение в мир инструментов Mobile DevOps, которые не просто ускоряют, но еще и заметно упрощают разработку мобильных приложений. На этот раз мы рассмотрим интегрированное решение Visual Studio Mobile Center.
*Примечание: мы продолжаем серию [публикаций полных версий статей из журнала Хакер](https://xakep.ru/2017/03/29/mobile-devops-vsmc/). Орфография и пунктуация автора сохранены.*
Начнем мы немного издалека и посмотрим на Mobile DevOps в историческом разрезе. Сами по себе смартфоны и планшеты вошли в нашу жизнь заметно быстрее, чем их шумные предки-пылесборники, и для многих людей на нашей планете уже давно стали основным способом подключения к цифровой реальности. Капитан Очевидность утверждает, что Mobile плотно войдет не только в жизнь обычных юзеров, но и в бизнес-процессы современных компаний по всему миру. Поэтому разработчику крутых приложений обязательно стоит присмотреться к практикам DevOps, чтобы не отстать от поезда.
Обзор Mobile Center
===================
Корпорация Microsoft в недалеком прошлом упустила рынок мобильных экосистем, поэтому теперь всеми силами (и долларами) старается наверстать упущенное, предлагая разработчикам целую кучу различных SDK, сервисов и инструментов. Покупка **Xamarin** и **HockeyApp** позволила корпорации предложить рынку интегрированные инструменты для профессиональной разработки мобильных приложений вне зависимости от целевой платформы. Сам конвейер [Visual Studio Mobile Center](https://mobile.azure.com/) (далее VSMC) основан на уже знакомых нам сервисе аналитики и дистрибуции [HockeyApp](https://hockeyapp.net/) и облачной ферме устройств [Xamarin Test Cloud](https://testcloud.xamarin.com/).
Если рассматривать рынок инструментов разработки, то все идет к тому, что миром Mobile будут править **Android + Java** (или что там обещают вместо Java в будущем? Kotlin?), **iOS + Swift**, **Xamarin** и **React Native**. Все четыре стека уже поддерживаются из коробки в новом VSMC. А в будущем обещают добавить еще и Windows.
Mobile Center пока находится в стадии раннего Preview, поэтому возможности еще достаточно ограниченны и сам сервис не рекомендуется к использованию в production-окружении. Однако в VSMC уже доступны все основные элементы конвейера Mobile DevOps: **сборка, тестирование, дистрибуция и аналитика** (различные события и краши).
Приятное дополнение к VSMC — модули Tables и Identity, которые могут быть полезны, если ты планируешь использовать Azure в своих мобильных приложениях. Tables — это облачный MBaaS (mobile backend as a service), который позволит развернуть базу данных в облаке и в несколько строк кода получить к ней доступ из приложения. В [Azure](https://azure.microsoft.com/) развернутся SQL Database и REST-сервер (на базе Azure App Services), настроенные для совместной работы и готовые к масштабированию и безотказному доступу. В реальных и больших проектах эта штука часто может быть излишней, однако для твоего стартапа или быстрого прототипа подойдет идеально. С помощью Identity можно будет легко авторизовать пользователей через Facebook, Google или Twitter. Авторизованные таким образом юзеры смогут получать доступ к данным из Tables, помеченным как требующие авторизации. И Tables, и Identity предоставляют базовую функциональность, которой может быть достаточно для небольших или простых проектов. Пара строк кода — и все работает.
Но сам по себе Mobile Center — это в первую очередь конвейер DevOps, поэтому перейдем к рассмотрению ключевой функциональности.
Билдим
======
Итак, у нас есть исходные коды проекта Navigation Drawer из набора стандартных примеров Android на Java. Заливаем их на [GitHub](https://github.com/) (поддержка других сервисов будет добавлена в VSMC позже), создаем бесплатную учетку на [mobile.azure.com](https://mobile.azure.com/) и добавляем новое приложение.
Переходим в раздел Build, подключаем репозиторий GitHub и выбираем основной branch. После сборки мы можем скачать полученные APK и подробные логи. Все как у людей и без излишеств.
Из дополнительных опций сборки можно отметить возможность запуска Unit-тестов и автоматического уведомления бета-тестировщиков о готовности установочного пакета.
В будущем также обещают добавить поддержку репозиториев [Bitbucket](https://bitbucket.org/) и [Visual Studio Team Services](https://www.visualstudio.com/). Для автоматических UI-тестов, правда, пока придется заливать сборку руками из консоли, о чем мы и поговорим далее.
#### Альтернатива VSMC на данном этапе
Если тебя интересует **отдельная система для сборки проектов**, то настоятельно рекомендуем познакомиться с [Bitrise.io](https://www.bitrise.io/), о котором мы [рассказывали](https://xakep.ru/2017/02/17/devops-authomatization/).
Гоняем тесты
============
Как мы уже знаем, в VSMC интегрирован сервис Xamarin Test Cloud. Для нашего примера мы будем использовать написанный раньше скрипт на [Calabash](https://calaba.sh/).
Для начала нам необходимо установить Node.js и Ruby плюс ряд дополнительных gems. Выдумывать ничего не придется, просто следуй инструкциям в Mobile Center. Перед тем как отправить приложение на тестирование, его нужно собрать командой `calabash-android build [путь до apk].apk` в консоли. Результатом работы этой команды должна быть папка test\_servers, содержащая корректно подписанный APK-файл. После сборки потребуется выполнить команду mobile-center test run. Через несколько минут мы увидим результаты тестирования и получим email-уведомление о завершении тестов.
Кстати, свои фермы для автоматизированного UI-тестирования приложений также представили Amazon и Google.
Отличий от оригинального Xamarin Test Cloud здесь немного: есть пошаговые скриншоты и мониторинг потребления ресурсов. Устройств много, но в VSMC Preview пока есть ограничение на количество одновременных запусков (одно устройство за один раз) и выделенного времени (до одного часа в день).
#### Альтернативы VSMC на данном этапе
Если ты ищешь **отдельную облачную ферму устройств** для автоматизированного UI-тестирования, то могу посоветовать посмотреть в сторону [AWS Device Farm](https://aws.amazon.com/device-farm/), [Xamarin Test Cloud](https://testcloud.xamarin.com/), [Google Firebase Test Lab](https://firebase.google.com/docs/test-lab/).
Анализируем и распространяем
============================
В качестве подсистемы для сборки крашей и событий внутри VSMC используется сервис HockeyApp. Для интеграции SDK достаточно добавить новые зависимости к проекту и зарегистрировать обработчик крашей.
Сами краши можно смотреть в stack trace, а события — в статистике.
#### Альтернативы VSMC на данном этапе
Для более детального анализа поведения пользователей все-таки лучше использовать «[Яндекс.Метрику](https://metrika.yandex.ru/)», [Google Analytics](https://analytics.google.com/) или [Flurry](https://dev.flurry.com/), так как маркетологи предпочитают для своей работы эти сервисы.
Выводы
======
Итак, сегодня мы познакомились с универсальным и интегрированным конвейером Visual Studio Mobile Center. Если сравнивать с тем же Bitrise.io, интегрированные решения, с одной стороны, могут сильно упростить жизнь разработчикам мобильных приложений и ускорить внедрение инструментов DevOps в повседневную практику, но с другой — они не настолько гибки и функциональны, как DIY-конвейеры. В ближайшее время стоит ожидать появления большего числа интегрированных систем от других игроков. Если же программистский зуд или задачи проекта требуют своего конвейера, то выбор инструментария уже сейчас достаточно широк, включая различные open source проекты, поэтому выбирать надо исходя из требований и планов развития продукта.
Успешной тебе автоматизации! Будут вопросы — пиши в комментариях!
### Об авторе
Вячеслав Черников — руководитель отдела разработки компании [Binwell](http://www.binwell.com/). В прошлом — один из Nokia Champion и Qt Certified Specialist, в настоящее время — специалист по платформам Xamarin и Azure. В сферу mobile пришел в 2005 году, с 2008 года занимается разработкой мобильных приложений: начинал с Symbian, Maemo, Meego, Windows Mobile, потом перешел на iOS, Android и Windows Phone.
Статьи Вячеслава вы также можете прочитать в [блоге на Medium](https://medium.com/binwell/public/home).
**Другие статьи автора:**
* [Авторизация OAuth для Xamarin-приложений](https://habrahabr.ru/company/microsoft/blog/332970)
* [DevOps на службе человека](https://habrahabr.ru/company/microsoft/blog/325184/)
* [Автоматизируем неавтоматизируемое, или про Xamarin в реальных проектах](https://habrahabr.ru/company/microsoft/blog/327900/)
* [Удобный REST для Xamarin-приложений](https://habrahabr.ru/company/microsoft/blog/310704/)
* [Быстрое создание MVP (minimum viable product) на базе Microsoft Azure и Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/281897/)
* [Готовим Xamarin.Forms: настройка окружения и первые шаги](https://habrahabr.ru/company/microsoft/blog/303630/)
* [Повышаем эффективность работы в Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/304678/)
* [Работаем с состояниями экранов в Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/307890/)
* [Подключаем Facebook SDK для Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/321454/)
* [Подключаем ВКонтакте SDK для Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/323296/)
*Напоминаем, что это полная версия [статьи из журнала Хакер](https://xakep.ru/2017/03/29/mobile-devops-vsmc/).* | https://habr.com/ru/post/329908/ | null | ru | null |
# Обзор ECMAScript 6, следующей версии JavaScript
Для начала, ликбез и несколько фактов:
* ECMAScript — это официальный стандарт языка JavaScript (Слово JavaScript не могло быть использовано, потому что слово Java являлось торговой маркой компании Sun) Т.е. JavaScript — это имплементация стандарта ECMAScript.
* TC39 — комитет, развивающий стандарт ECMAScript и принимающий решения по включению фич в него.
* ECMAScript стандартов много. Самый популярный из них — ECMA-262.
* ECMAScript 5 — последняя редакция стандарта ECMA-262 (утвержден в 2009 году).
* Предыдущие версии стандарта ECMA-262 были (совсем старые не упоминаю):
+ ECMAScript 3 — поддерживается большинством браузеров (утвержден в 1999 году).
+ ECMAScript 4 — не принят в виду слишком радикальных изменений в стандарте. Позднее в июле 2008 году в урезанном варианте (но все же намного богаче, чем ECMAScript 3) вылился в новый проект ECMAScript Harmony.
* ECMAScript 6 (кодовое имя ECMAScript.next) должен утвердиться **до конца 2013 года**.
Итак, что же нас ждет в новой версии JavaScript?
#### Блочная область видимости (block scope)
В текущей версии JavaScript присутствует функциональная область видимости. Это означает, что все переменные, объявленные c помощью ключевого слова `var`, будут видны в любом месте функции (даже если они объявлены внутри блока):
```
function f(a) {
if (a < 0) {
var i = 3;
}
console.log(i); // 3
}
f(-1)
```
В новой версии появится ключевое слово `let`, которое позволит объявлять переменные с блочной областью видимости:
```
function f(a) {
if (a < 0) {
let i = 3;
}
console.log(i); // ReferenceError: i is not defined
}
f(-1)
```
#### Значения параметров по умолчанию
В функциях добавилась возможность объявлять у параметров значения по умолчанию:
```
function setLevel(newLevel = 0) {
...
}
setLevel(); // newLevel = 0
setLevel(5); // newLevel = 5
setLevel(undefined); // newLevel = 0
```
#### Именованные параметры функций
В функциях также появилась возможность указывать именованные параметры:
```
function foo({ from, to = 10 }) {
...
}
foo({ from: 1, to: 5 });
foo({ to: 5, from: 1 });
foo({ from: 1 });
```
Именованные параметры можно комбинировать с обычным (позиционными параметрами):
```
function foo(positional, { named1, named2 }) {
...
}
foo(123, { named1: 'abc', named2: 'def' })
foo(123, { named2: 'def', named1: 'abc' })
```
#### Destructuring assignment
ECMAScript 6 позволит деструктуризировать при присваивании:
```
let { first: f, last: l } = { first: 'Jane', last: 'Doe' };
console.log(f); // 'Jane'
console.log(l); // 'Doe'
```
Кстати, в примере из предыдущего пункта (Именованные параметры) вы видели пример деструктуризации параметров функции.
Деструктуризация по умолчанию является refutable (не имею понятия, как это переводить). Т.е. если в объекте-источнике присваивания соответствующего поля нету, то выбрасывается ошибка:
```
let { first: f, last: l } = { first: 'Jane' }; // ошибка
```
Если же вы не хотите, чтобы ошибка генерировалась, то переменную можно объявить как irrefutable с помощью суффикса ?:
```
let { first: f, last?: l } = { first: 'Jane' }; // ok
console.log(l); // undefined
```
Либо можно дать переменной значение по умолчанию:
```
let { first: f, last: l = 'Unknown' } = { first: 'Jane' }; // ok
console.log(l); // 'Unknown'
```
Значение по умолчанию также срабатывает, если соответствующее поле в объекте-источнике является `undefined`:
```
let { a: x = 1 } = { a: undefined }
console.log(x); // 1
```
Наконец, если вы хотите, чтобы все переменные были irrefutable, то можно поставить суффикс ? в конце всего шаблона присваивания:
```
let { foo: f }? = anything; // всегда ok
```
В последнем примере переменная `f` будет инициализирована значением `undefined`, если `anything` будет равно `undefined`, `null` или не иметь поля `foo`.
С помощью деструктуризации можно одной строчкой кода поменять значение двух переменных (без всяких `tmp`):
```
{ foo: foo, bar: bar } = { foo: bar, bar: foo};
```
Или ище короче:
```
[ foo, bar ] = [ bar, foo ];
```
#### Классы
В ECMAScript 6 появятся классы:
```
// Supertype
class Person {
constructor(name) {
this.name = name;
}
describe() {
return "Person called " + this.name;
}
}
// Subtype
class Employee extends Person {
constructor(name, title) {
super.constructor(name);
this.title = title;
}
describe() {
return super.describe() + " (" + this.title + ")";
}
}
```
Теперь можно использовать эти классы:
```
let jane = new Employee("Jane", "CTO");
jane instanceof Person; // true
jane instanceof Employee; // true
jane.describe(); // 'Person called Jane (CTO)'
```
Всего того же можно было добиться с помощью прототипов:
```
// Supertype
function Person(name) {
this.name = name;
}
Person.prototype.describe = function () {
return "Person called " + this.name;
};
// Subtype
function Employee(name, title) {
Person.call(this, name);
this.title = title;
}
Employee.prototype = Object.create(Person.prototype);
Employee.prototype.constructor = Employee;
Employee.prototype.describe = function () {
return Person.prototype.describe.call(this) + " (" + this.title + ")";
};
```
Как видите, классы в ECMAScript 6 — это просто синтаксический сахар над конструкторами и функциями.
Классы могут иметь статические методы:
```
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}
static zero() {
return new Point(0, 0);
}
}
```
Приватных полей и методов не будет (по крайней мере, в ECMAScript 6). Однако некоторое сокрытие данных все же появится. Через модули.
#### Модули
В JavaScript наконец-то появятся модули:
```
module Math {
export function sum(x, y) {
return x + y;
}
export var pi = 3.141593;
// Не видна снаружи
function internal() {
...
}
}
```
Импортирование модуля:
```
import Math.{sum, pi};
alert("2π = " + sum(pi, pi));
```
Можно использовать `*`, чтобы импортировать всё:
```
import Math.*;
alert("2π = " + sum(pi, pi));
```
Модули можно вкладывать друг в друга:
```
module Widgets {
module Button { ... }
module Alert { ... }
module TextArea { ... }
...
}
import Widgets.Alert.{messageBox, confirmDialog};
...
```
Модули можно подгружать из веба или через файловую систему:
```
module JSON = require('http://json.org/modules/json2.js'); // web
import JSON.*;
module File = require('io/File'); // file system
import require("bar.js").y; // file system
```
Все глобальные переменные в модули являются глобальными только в этом модуле.
Возможны циклические зависимости между модулями.
#### Цикл `for-of`
Как вы знаете, цикл `for-in` в JavaScript итерирует по всем полям объекта (включая наследованных). Т.е. итерироваться по значениям массива можно, но опасно:
```
let arr = [ "blue", "green" ];
arr.notAnIndex = 123;
Array.prototype.protoProp = 456;
for(var x in arr) {
console.log(x); // Напечатает blue, green, notAnIndex, protoProp
}
```
В ECMAScript 6 появится цикл `for-of`, который решит данную проблему:
```
for(var x of arr) {
console.log(x); // Напечатает только blue, green
}
```
Также, возможно, в язык добавится оператор `yield`, с помощью которого можно легко и красиво писать кастомные итераторы.
#### Arrow-функции
В ECMAScript 6 появятся arrow functions:
```
let squares = [ 1, 2, 3 ].map(x => x * x);
```
Код выше эквивалентен этому:
```
let squares = [ 1, 2, 3 ].map(function (x) { return x * x });
```
Arrow-функции немножко отличаются от обычных функций. В первую очередь тем, что в arrow-функциях `this` привязан к вышестоящему контексту. Т.е.
```
let jane = {
name: "Jane",
sayHello: function (friends) {
friends.forEach(friend => { console.log(this.name + " says hello to " + friend) });
}
}
jane.sayHello([ 'Mark', 'John' ]);
```
выведет
```
Jane says hello to Mark
Jane says hello to John
```
как и ожидалось. А
```
let jane = {
name: "Jane",
sayHello: function (friends) {
friends.forEach(function(friend) { console.log(this.name + " says hello to " + friend) });
}
}
```
выведет:
```
says hello to Mark
says hello to John
```
Проблема в том, что `this` из анонимной функции `function(friend) { ... })` перекрывает `this` из окружающего контекста. Для того, чтобы этого избежать, можно использовать старый прием с `var self = this` или использовать функцию `bind`:
```
var jane = {
name: "Jane",
sayHello: function (friends) {
friends.forEach(function (friend) {
console.log(this.name + " says hello to " + friend)
}.bind(this));
}
}
```
Т.е. по сути своей arrow functions — опять же синтаксический сахар над существующими анонимными функциями:
```
(x, y) => x + y + this.z
```
есть ничто иное как:
```
function (x, y) { return x + y + this.z }.bind(this)
```
Другие отличия arrow-функций от обычных функций:
* Нельзя использовать arrow-функции как конструкторы (`new (() => {})` кинет ошибку)
* Arrow-функции не могут обратиться к переменной `arguments` (да и незачем)
В остальном arrow-функции не отличаются от обычных функций. Они поддерживают значения по умолчанию, переменное количество параметров, операторы `typeof` и `instanceof`:
```
typeof () => {}; // 'function'
() => {} instanceof Function; // true
```
#### Заключение
Я описал далеко не всё, что появится в новом стандарте ECMAScript 6. И очень возможно, что что-то из того, о чем я написал выше, может измениться или вообще не появиться в стандарте. Тем не менее, все, что я описал, — это не слухи. Это вещи, реально обсуждаемые комитетом TC39. И к концу этого (2013) года стандарт должен быть утвержден.
#### Ссылки
Большая часть информации взята из [блога](http://www.2ality.com/) доктора [Axel'а Rauschmayer'a](http://rauschma.de), послушать которого и повидать вживую мне посчастливилось на конференции CodeFest в Новосибирске.
PS. Спасибо 2GIS за организацию конференции! | https://habr.com/ru/post/175371/ | null | ru | null |
# «Kubernetes как часть data platform»
Привет, Хабр! Меня зовут Денис, в компании oneFactor я занимаю позицию архитектора, и одна из моих обязанностей — это развитие технического стека компании. В этой статье я расскажу про нашу data platform’у (далее просто DP или платформа) и про мотивацию внедрения в неё Kubernetes. Также подсвечу трудности, с которыми мы столкнулись в рамках пилота. И расскажу про набор активностей, которые не вошли в пилот, но будут выполнены во время миграции. Дополнительно представлю короткий обзор текущей интеграции между Spark и Kubernetes. Стоит отметить, что вопросы, связанные с хранилищем, здесь обсуждаться не будут.
### Краткое описание платформы
Основными элементами текущего стека нашей DP являются HDFS и YARN. В YARN мы запускаем исключительно Spark приложения, кластер настроен для выполнения Spark-приложений различных версий (от 2.0.2 до 3.2.1). Дни, когда на платформе выполняется более 50000 приложений, считаются нормой. Эти приложения имеют разную природу, часть из них запускаются регулярно, и каждый запуск потребляет примерно одинаковое количество ресурсов. Часть приложений запускается по запросу пользователей или внешних (по отношению к DP) систем. Для некоторых из них стабильность выполнения гораздо важнее скорости, но часто наоборот. Кроме того, часть ресурсов кластера необходимо аллоцировать для RnD активностей, в которые входят запросы от коллег из аналитического департамента и активности от дата-инженеров. Для того, чтобы все эти разношерстные приложения могли быть выполнены в прогнозируемый период времени, используя ограниченный набор ресурсов, в YARN мы использовали большое количество предоставляемых возможностей по настройке очередей, таких как:
**Weights** ****— для приоритизации выделения ресурсов.
**Max Running Apps** — для управления нагрузкой на upstream сервисы. Например, когда с помощью Spark загружаем данные во внешнее хранилище и нам необходимо ограничить нагрузку, которую мы на него создаем. Или для случаев, когда с владельцем продукта согласовано максимальное количество одновременно запущенных приложений.
**Иерархичность** — чтобы объединить потребляемые ресурсы между несколькими похожими классами задач, но к которым предъявляются немного разные требования.
**Preemption** — чтобы дать возможность приложениям со строгим SLA получать обещанные ресурсы за счет принудительной остановки YARN контейнеров в менее важных очередях.
**Max Resources (Virtual Core и Memory)** — чтобы не позволить одному классу приложений захватить все ресурсы кластера.
Платформа установлена на собственных серверах в ЦОДе одного из российских cloud provider'ов.
### Почему Kubernetes?
Наш текущий Hadoop кластер построен на версии Hadoop 2. Основная задача, которую мы сейчас решаем, это проработка будущего стека. После его выбора мы сможем сформировать roadmap для миграции. Рассматриваются следующие варианты:
1. Переезд на коммерческие решения (такие как Cloudera Data Platform). Данный вариант отпадает, т.к. стоимость владения становится очень высокой, а отсутствие бесшовной миграции с нашей версией Hadoop не позволяет нам выполнить миграцию в короткие сроки.
2. Миграция на Hadoop от другого вендора. Те же самые «за» и «против», как в предыдущем пункте.
3. Миграция на Apache Hadoop 3. На ряду с Kubernetes рассматривается как один из возможных вариантов.
4. Kubernetes. Герой нашего повествования, так же, как и Apache Hadoop 3, входит в наш short-лист кандидатов.
Итак, главная причина, которая драйвит нас к переходу на Kubernetes — это обновление нашего технологического стека, элементы которого уже находятся в End Of Life (EOL). В дополнение к этому мы планируем получить следующие преимущества:
* Более простая схема масштабирования.
* Решение проблемы эластичности, когда возникает резкий и высокий спрос на ресурсы с помощью динамического использования ресурсов cloud provider'а по модели `pay as you go.`
* Переносимость платформы. Kubernetes набирает популярность, услугу Managed Kubernetes кластера предоставляют все крупные облачные поставщики.
* В случае Managed Kubernetes сокращаются трудозатраты на поддержку инфраструктуры.
### Spark on Kubernetes
Поддержка Kubernetes в Spark заявлена начиная с версии 2.3, а с версии Spark 3.0 поддержка Kubernetes перешла в фазу production ready. Для более удобного запуска Spark-приложений разработан Spark Operator. Пример из официального репозитория ниже:
```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
name: spark-pi
namespace: default
spec:
type: Scala
mode: cluster
image: "gcr.io/spark-operator/spark:v3.1.1"
imagePullPolicy: Always
mainClass: org.apache.spark.examples.SparkPi
mainApplicationFile: "local:///opt/spark/examples/jars/spark-examples_2.12-3.1.1.jar"
sparkVersion: "3.1.1"
restartPolicy:
type: Never
volumes:
- name: "test-volume"
hostPath:
path: "/tmp"
type: Directory
driver:
cores: 1
coreLimit: "1200m"
memory: "512m"
labels:
version: 3.1.1
serviceAccount: spark
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
executor:
cores: 1
instances: 1
memory: "512m"
labels:
version: 3.1.1
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
```
Кроме привычного для Kubernetes оформления в Yaml формате, Spark Operator предоставляет некоторый набор «сахарных» конструкций, которые облегчают работу со Spark. Например, объявление `spec.hadoopConfigMap` и `spec.sparkConfigMap` упрощают монтирование соответствующих конфигурационных файлов в нужные места, освобождая нас от необходимости объявления volume’ов в Yaml файле в явном виде.
### Kubernetes и batch
Пожалуй, это один из самых интересных разделов в статье, и он сам по себе заслуживает отдельной статьи, но постараюсь быть кратким. Выше, в части «Краткое описание платформы», есть функционал очередей, которым мы пользуемся на платформе, для того, чтобы в условиях ограниченных ресурсов удовлетворить потребность разных типов приложений. Планировщик Kubernetes сам по себе данного функционала не предоставляет, но API Kubernetes позволят разработать собственный планировщик и использовать его.
Мы рассматривали две open-source реализации планировщика для Kubernetes, заточенного для выполнения batch-приложений:
* [Apache YuniKorn](https://yunikorn.apache.org/) — основной контрибьютор Cloudera, судя по найденным презентациям в Интернете, он активно используется в Apple.
* [Volcano](https://volcano.sh/en/) — основной контрибьютор Huawei.
В экспериментальную часть своих исследований, в силу ограниченного количества времени, мы выбрали Volcano. Основная причина — поддержка Volcano в Spark 3.3.
Вот так выглядит кусочек нашего Yaml, в котором мы указывали на использование Volcano:
```
spec:
type: Scala
mode: cluster
image: custom-build-spark3.3.0-on-k8s:0.0.28
mainClass: com.onefactor.spark33.App
mainApplicationFile: "hdfs://nameservice1/spark/spark3-mvp/app.jar"
sparkVersion: 3.3.0
restartPolicy:
type: Never
hadoopConfigMap: hadoop-conf
sparkConfigMap: spark-conf-k8s
batchScheduler: volcano
sparkConf:
spark.kubernetes.driver.pod.featureSteps: org.apache.spark.deploy.k8s.features.VolcanoFeatureStep
spark.kubernetes.scheduler.name: volcano
```
В этом отрывке ключевыми являются `batchScheduler` и пара параметров в секции `sparkConf`. Также есть возможность задать `spark.kubernetes.scheduler.volcano.podGroupTemplateFile`
Основные моменты, которые здесь хочется подсветить:
* В настоящий момент community Spark готовит новый релиз `Spark 3.3.0` (т.к. официального релиза пока нет, то в своих экспериментах мы использовали собственную сборку).
* Spark 3.3.0 будет иметь поддержку Volcano (может быть, к релизу успеют добавить и поддержку YuniKorn).
* В Kubernetes community осознают важность batch-приложений, и на только что прошедшей конференции KubeCon этой теме был посвящен выделенный [стрим](https://www.youtube.com/playlist?list=PLj6h78yzYM2MwbofRSIO-5NvesUSPzjjN).
### Интеграция с HDFS
Т.к. наш текущий стек основан на Hadoop, то для чтения и записи данных во время экспериментов приходилось взаимодействовать с HDFS. В нашем Hadoop кластере включена аутентификация через Kerberos.
Для того, чтобы выполнить аутентификацию, использовался side-car контейнер. Связка HDFS, Kerberos, K8s через Spark Operator выглядит следующим образом:
```
spec:
hadoopConfigMap: hadoop-conf
volumes:
- name: krb5-conf
configMap:
defaultMode: 420
name: krb5-client
- name: keytab
secret:
defaultMode: 420
secretName: client-keytab
- name: ccache
emptyDir:
medium: Memory
imagePullSecrets:
- our-registry
driver:
initContainers:
- name: kinit-sidecar
image: kinit-sidecar:0.1.0
volumeMounts:
- mountPath: /dev/shm
name: ccache
- mountPath: /etc/krb5.conf
name: krb5-conf
subPath: krb5.conf
- mountPath: /krb5/krb5.keytab
name: keytab
subPath: client.keytab
```
Более подробно о реализации krb аутентификации с помощью side-car контейнера можно посмотреть на форуме [openshift](https://cloud.redhat.com/blog/kerberos-sidecar-container).
### Наши результаты
В качестве экспериментов мы выбрали Spark приложение, которое у нас работает в Yarn’е. И без внесения изменений в его кодовую базу выполняли запуск в Kubernetes.
Особенности приложения:
* количество входных записей ~1 500 000 000;
* приложение использует операцию кэширования;
* имеется shuffle;
* количество выходных записей чуть больше, чем входных;
* YARN: для выполнения приложения за 10 минут необходимо 40 серверов с 64GB памяти и 10vCores;
* Kubernetes: для выполнения приложения за 10 минут необходимо 24 сервера с 64GB памяти и 10vCores (на 40% быстрее). Прежде всего, это связано с тем, что для хранения spill и shuffle промежуточных данных использовались PVC на SSD дисках (в то время как в Yarn использовались обычные диски). После завершения Spark-приложения SSD-диски автоматически удаляются.
### Планы
Во время наших тестов Kubernetes показал себя ожидаемо, и мы получили подтверждение, что он может быть внедрен в нашу платформу. Следующий этап — нагрузочное тестирование и проверка того, что работа очередей соответствует нашим требованиям. Также для нас пока что остается нерешенным вопрос о использовании внешнего shuffle сервиса (несмотря на его отсутствие в наших экспериментах, мы использовали динамическое аллоцирование executors, в этом нам помогли конфигурационные параметры `spark.dynamicAllocation.shuffleTracking.enabled` и `spark.dynamicAllocation.shuffleTracking.timeout`).
На этом всё. Спасибо, что прочитали статью до конца. Делитесь вашим опытом и рекомендациями в комментариях. | https://habr.com/ru/post/671334/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.